| /* |
| * Copyright 2019 AT&T Intellectual Property |
| * Copyright 2019 Nokia |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // |
| // Created by adi ENZEL on 12/10/19. |
| // |
| |
| #ifndef E2_E2BUILDER_H |
| #define E2_E2BUILDER_H |
| |
| #include <cstring> |
| #include <cstdio> |
| #include <cerrno> |
| #include <cstdlib> |
| #include <sys/types.h> |
| #include <error.h> |
| #include <algorithm> |
| #include <3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h> |
| #include <3rdparty/oranE2SM/RIC-InsertStyle-List.h> |
| #include <3rdparty/oranE2SM/RANparameterDef-Item.h> |
| |
| |
| //#include <mdclog/mdclog.h> |
| |
| |
| #include "oranE2/E2AP-PDU.h" |
| #include "oranE2/InitiatingMessage.h" |
| #include "oranE2/SuccessfulOutcome.h" |
| #include "oranE2/UnsuccessfulOutcome.h" |
| |
| #include "oranE2/ProtocolIE-Field.h" |
| #include "oranE2/ENB-ID.h" |
| #include "oranE2/GlobalENB-ID.h" |
| #include "oranE2/GlobalE2node-gNB-ID.h" |
| #include "oranE2/constr_TYPE.h" |
| #include "oranE2/asn_constant.h" |
| |
| using namespace std; |
| |
| #define printEntry(type, function); fprintf(stdout, "start Test %s , %s", type, function); |
| |
| |
| static void checkAndPrint(asn_TYPE_descriptor_t *typeDescriptor, void *data, char *dataType, const char *function) { |
| char errbuf[128]; /* Buffer for error message */ |
| size_t errlen = sizeof(errbuf); /* Size of the buffer */ |
| if (asn_check_constraints(typeDescriptor, data, errbuf, &errlen) != 0) { |
| fprintf(stderr, "%s Constraint validation failed: %s", dataType, errbuf); |
| } |
| fprintf(stdout, "%s successes function %s", dataType, function); |
| } |
| |
| void createPLMN_IDByMCCandMNC(PLMN_Identity_t *plmnId, int mcc, int mnc) { |
| |
| //printEntry("PLMN_Identity_t", __func__) |
| |
| ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, plmnId); |
| plmnId->size = 3; |
| plmnId->buf = (uint8_t *) calloc(1, 3); |
| volatile auto mcc1 = (unsigned int) (mcc / 100); |
| volatile auto mcc2 = (unsigned int) (mcc / 10 % 10); |
| volatile auto mcc3 = (unsigned int) (mcc % 10); |
| plmnId->buf[0] = mcc2 << 4 | mcc1; |
| |
| volatile auto mnc1 = (unsigned int)0; |
| volatile auto mnc2 = (unsigned int)0; |
| volatile auto mnc3 = (unsigned int)0; |
| |
| if (mnc >= 100) { |
| mnc1 = (unsigned int) (mnc / 100); |
| mnc2 = (unsigned int) (mnc / 10 % 10); |
| mnc3 = (unsigned int) (mnc % 10); |
| } else { |
| mnc1 = (unsigned int) (mnc / 10); |
| mnc2 = (unsigned int) (mnc % 10); |
| mnc3 = 15; |
| } |
| plmnId->buf[1] = mcc3 << 4 | mnc3 ; |
| plmnId->buf[2] = mnc2 << 4 | mnc1 ; |
| |
| //checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, (char *) "PLMN_Identity_t", __func__); |
| |
| } |
| |
| |
| PLMN_Identity_t *createPLMN_ID(const unsigned char *data) { |
| printEntry("PLMN_Identity_t", __func__) |
| auto *plmnId = (PLMN_Identity_t *) calloc(1, sizeof(PLMN_Identity_t)); |
| ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, plmnId); |
| plmnId->size = 3; |
| plmnId->buf = (uint8_t *) calloc(1, 3); |
| memcpy(plmnId->buf, data, 3); |
| |
| checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, (char *) "PLMN_Identity_t", __func__); |
| |
| return plmnId; |
| } |
| |
| BIT_STRING_t *createBIT_STRING(int size, int unusedBits, uint8_t *data) { |
| printEntry("BIT_STRING_t", __func__) |
| auto *bitString = (BIT_STRING_t *) calloc(1, sizeof(BIT_STRING_t)); |
| ASN_STRUCT_RESET(asn_DEF_BIT_STRING, bitString); |
| bitString->size = size; |
| bitString->bits_unused = unusedBits; |
| bitString->buf = (uint8_t *) calloc(1, size); |
| // set bits to zero |
| data[bitString->size - 1] = ((unsigned) (data[bitString->size - 1] >> |
| (unsigned) bitString->bits_unused) |
| << (unsigned) bitString->bits_unused); |
| memcpy(bitString->buf, data, size); |
| |
| checkAndPrint(&asn_DEF_BIT_STRING, bitString, (char *) "BIT_STRING_t", __func__); |
| |
| return bitString; |
| } |
| |
| |
| OCTET_STRING_t *createOCTET_STRING(const unsigned char *data, int size) { |
| printEntry("OCTET_STRING_t", __func__) |
| auto *octs = (PLMN_Identity_t *) calloc(1, sizeof(PLMN_Identity_t)); |
| ASN_STRUCT_RESET(asn_DEF_OCTET_STRING, octs); |
| octs->size = size; |
| octs->buf = (uint8_t *) calloc(1, size); |
| memcpy(octs->buf, data, size); |
| |
| checkAndPrint(&asn_DEF_OCTET_STRING, octs, (char *) "OCTET_STRING_t", __func__); |
| return octs; |
| } |
| |
| |
| ENB_ID_t *createENB_ID(ENB_ID_PR enbType, unsigned char *data) { |
| printEntry("ENB_ID_t", __func__) |
| auto *enb = (ENB_ID_t *) calloc(1, sizeof(ENB_ID_t)); |
| ASN_STRUCT_RESET(asn_DEF_ENB_ID, enb); |
| |
| enb->present = enbType; |
| |
| switch (enbType) { |
| case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes |
| enb->choice.macro_eNB_ID.size = 3; |
| enb->choice.macro_eNB_ID.bits_unused = 4; |
| |
| enb->present = ENB_ID_PR_macro_eNB_ID; |
| |
| enb->choice.macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.macro_eNB_ID.size); |
| data[enb->choice.macro_eNB_ID.size - 1] = ((unsigned) (data[enb->choice.macro_eNB_ID.size - 1] >> |
| (unsigned) enb->choice.macro_eNB_ID.bits_unused) |
| << (unsigned) enb->choice.macro_eNB_ID.bits_unused); |
| memcpy(enb->choice.macro_eNB_ID.buf, data, enb->choice.macro_eNB_ID.size); |
| |
| break; |
| } |
| case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes |
| enb->choice.home_eNB_ID.size = 4; |
| enb->choice.home_eNB_ID.bits_unused = 4; |
| enb->present = ENB_ID_PR_home_eNB_ID; |
| |
| enb->choice.home_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.home_eNB_ID.size); |
| data[enb->choice.home_eNB_ID.size - 1] = ((unsigned) (data[enb->choice.home_eNB_ID.size - 1] >> |
| (unsigned) enb->choice.home_eNB_ID.bits_unused) |
| << (unsigned) enb->choice.home_eNB_ID.bits_unused); |
| memcpy(enb->choice.home_eNB_ID.buf, data, enb->choice.home_eNB_ID.size); |
| break; |
| } |
| case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes |
| enb->choice.short_Macro_eNB_ID.size = 3; |
| enb->choice.short_Macro_eNB_ID.bits_unused = 6; |
| enb->present = ENB_ID_PR_short_Macro_eNB_ID; |
| |
| enb->choice.short_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.short_Macro_eNB_ID.size); |
| data[enb->choice.short_Macro_eNB_ID.size - 1] = ( |
| (unsigned) (data[enb->choice.short_Macro_eNB_ID.size - 1] >> |
| (unsigned) enb->choice.short_Macro_eNB_ID.bits_unused) |
| << (unsigned) enb->choice.short_Macro_eNB_ID.bits_unused); |
| memcpy(enb->choice.short_Macro_eNB_ID.buf, data, enb->choice.short_Macro_eNB_ID.size); |
| break; |
| } |
| case ENB_ID_PR_long_Macro_eNB_ID: { // 21 |
| enb->choice.long_Macro_eNB_ID.size = 3; |
| enb->choice.long_Macro_eNB_ID.bits_unused = 3; |
| enb->present = ENB_ID_PR_long_Macro_eNB_ID; |
| |
| enb->choice.long_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb->choice.long_Macro_eNB_ID.size); |
| data[enb->choice.long_Macro_eNB_ID.size - 1] = |
| ((unsigned) (data[enb->choice.long_Macro_eNB_ID.size - 1] >> (unsigned) enb->choice.long_Macro_eNB_ID.bits_unused) |
| << (unsigned) enb->choice.long_Macro_eNB_ID.bits_unused); |
| memcpy(enb->choice.long_Macro_eNB_ID.buf, data, enb->choice.long_Macro_eNB_ID.size); |
| break; |
| } |
| default: |
| free(enb); |
| return nullptr; |
| } |
| |
| checkAndPrint(&asn_DEF_ENB_ID, enb, (char *) "ENB_ID_t", __func__); |
| return enb; |
| } |
| |
| GlobalENB_ID_t *createGlobalENB_ID(PLMN_Identity_t *plmnIdentity, ENB_ID_t *enbId) { |
| printEntry("GlobalENB_ID_t", __func__) |
| auto *genbId = (GlobalENB_ID_t *) calloc(1, sizeof(GlobalENB_ID_t)); |
| ASN_STRUCT_RESET(asn_DEF_GlobalENB_ID, genbId); |
| memcpy(&genbId->pLMN_Identity, plmnIdentity, sizeof(PLMN_Identity_t)); |
| memcpy(&genbId->eNB_ID, enbId, sizeof(ENB_ID_t)); |
| |
| checkAndPrint(&asn_DEF_GlobalENB_ID, genbId, (char *) "GlobalENB_ID_t", __func__); |
| return genbId; |
| } |
| |
| |
| //static void buildInitiatingMessagePDU(E2AP_PDU_t &pdu, InitiatingMessage_t *initMsg) { |
| // pdu.present = E2AP_PDU_PR_initiatingMessage; |
| // pdu.choice.initiatingMessage = initMsg; |
| //} |
| |
| template<typename T> |
| static void buildInitMsg(InitiatingMessage_t &initMsg, |
| InitiatingMessage__value_PR present, |
| ProcedureCode_t procedureCode, |
| Criticality_t criticality, |
| T *value) { |
| initMsg.value.present = present; |
| initMsg.procedureCode = procedureCode; |
| initMsg.criticality = criticality; |
| |
| switch (present) { |
| case InitiatingMessage__value_PR_RICsubscriptionRequest: { |
| memcpy(&initMsg.value.choice.RICsubscriptionRequest, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_RICsubscriptionDeleteRequest: { |
| memcpy(&initMsg.value.choice.RICsubscriptionDeleteRequest, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_RICserviceUpdate: { |
| memcpy(&initMsg.value.choice.RICserviceUpdate, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_RICcontrolRequest: { |
| memcpy(&initMsg.value.choice.RICcontrolRequest, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_RICindication: { |
| memcpy(&initMsg.value.choice.RICindication, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_RICserviceQuery: { |
| memcpy(&initMsg.value.choice.RICserviceQuery, value, sizeof(*value)); |
| break; |
| } |
| case InitiatingMessage__value_PR_NOTHING: |
| default : { |
| break; |
| } |
| } |
| } |
| |
| //static void buildSuccsesfulMessagePDU(E2AP_PDU_t &pdu, SuccessfulOutcome_t *succMsg) { |
| // pdu.present = E2AP_PDU_PR_successfulOutcome; |
| // pdu.choice.successfulOutcome = succMsg; |
| //} |
| |
| template<typename T> |
| static void buildSuccMsg(SuccessfulOutcome_t &succMsg, |
| SuccessfulOutcome__value_PR present, |
| ProcedureCode_t procedureCode, |
| Criticality_t criticality, |
| T *value) { |
| succMsg.value.present = present; |
| succMsg.procedureCode = procedureCode; |
| succMsg.criticality = criticality; |
| |
| switch (present) { |
| case SuccessfulOutcome__value_PR_RICsubscriptionResponse: { |
| memcpy(&succMsg.value.choice.RICsubscriptionResponse, value, sizeof(*value)); |
| break; |
| } |
| case SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse: { |
| memcpy(&succMsg.value.choice.RICsubscriptionDeleteResponse, value, sizeof(*value)); |
| break; |
| } |
| case SuccessfulOutcome__value_PR_RICserviceUpdateAcknowledge: { |
| memcpy(&succMsg.value.choice.RICserviceUpdateAcknowledge, value, sizeof(*value)); |
| break; |
| } |
| case SuccessfulOutcome__value_PR_RICcontrolAcknowledge: { |
| memcpy(&succMsg.value.choice.RICcontrolAcknowledge, value, sizeof(*value)); |
| break; |
| } |
| case SuccessfulOutcome__value_PR_ResetResponse: { |
| memcpy(&succMsg.value.choice.ResetResponse, value, sizeof(*value)); |
| break; |
| } |
| case SuccessfulOutcome__value_PR_NOTHING: |
| default: |
| break; |
| } |
| } |
| |
| |
| //static void buildUnSucssesfullMessagePDU(E2AP_PDU_t &pdu, UnsuccessfulOutcome_t *unSuccMsg) { |
| // pdu.present = E2AP_PDU_PR_unsuccessfulOutcome; |
| // pdu.choice.unsuccessfulOutcome = unSuccMsg; |
| //} |
| |
| template<typename T> |
| static void buildUnSuccMsg(UnsuccessfulOutcome_t &unSuccMsg, |
| UnsuccessfulOutcome__value_PR present, |
| ProcedureCode_t procedureCode, |
| Criticality_t criticality, |
| T *value) { |
| unSuccMsg.value.present = present; |
| unSuccMsg.procedureCode = procedureCode; |
| unSuccMsg.criticality = criticality; |
| |
| switch (present) { |
| case UnsuccessfulOutcome__value_PR_RICsubscriptionFailure: { |
| memcpy(&unSuccMsg.value.choice.RICsubscriptionFailure, value, sizeof(*value)); |
| break; |
| } |
| case UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure: { |
| memcpy(&unSuccMsg.value.choice.RICsubscriptionDeleteFailure, value, sizeof(*value)); |
| break; |
| } |
| case UnsuccessfulOutcome__value_PR_RICserviceUpdateFailure: { |
| memcpy(&unSuccMsg.value.choice.RICserviceUpdateFailure, value, sizeof(*value)); |
| break; |
| } |
| case UnsuccessfulOutcome__value_PR_RICcontrolFailure: { |
| memcpy(&unSuccMsg.value.choice.RICcontrolFailure, value, sizeof(*value)); |
| break; |
| |
| } |
| case UnsuccessfulOutcome__value_PR_NOTHING: |
| default: |
| break; |
| } |
| } |
| |
| |
| //static void createPLMN_ID(PLMN_Identity_t &plmnId, const unsigned char *data) { |
| // //printEntry("PLMN_Identity_t", __func__) |
| // //PLMN_Identity_t *plmnId = calloc(1, sizeof(PLMN_Identity_t)); |
| // ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, &plmnId); |
| // plmnId.size = 3;// uint64_t st = 0; |
| //// uint32_t aux1 = 0; |
| //// st = rdtscp(aux1); |
| // |
| // plmnId.buf = (uint8_t *) calloc(1, 3); |
| // memcpy(plmnId.buf, data, 3); |
| // |
| // checkAndPrint(&asn_DEF_PLMN_Identity, &plmnId, (char *) "PLMN_Identity_t", __func__); |
| // |
| //} |
| |
| static void createENB_ID(ENB_ID_t &enb, ENB_ID_PR enbType, unsigned char *data) { |
| //printEntry("ENB_ID_t", __func__) |
| ASN_STRUCT_RESET(asn_DEF_ENB_ID, &enb); |
| enb.present = enbType; |
| switch (enbType) { |
| case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes |
| enb.choice.macro_eNB_ID.size = 3; |
| enb.choice.macro_eNB_ID.bits_unused = 4; |
| |
| enb.present = ENB_ID_PR_macro_eNB_ID; |
| |
| enb.choice.macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.macro_eNB_ID.size); |
| data[enb.choice.macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.macro_eNB_ID.size - 1] |
| >> (unsigned) enb.choice.macro_eNB_ID.bits_unused) |
| << (unsigned) enb.choice.macro_eNB_ID.bits_unused); |
| memcpy(enb.choice.macro_eNB_ID.buf, data, enb.choice.macro_eNB_ID.size); |
| |
| break; |
| } |
| case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes |
| enb.choice.home_eNB_ID.size = 4; |
| enb.choice.home_eNB_ID.bits_unused = 4; |
| enb.present = ENB_ID_PR_home_eNB_ID; |
| |
| enb.choice.home_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.home_eNB_ID.size); |
| data[enb.choice.home_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.home_eNB_ID.size - 1] |
| >> (unsigned) enb.choice.home_eNB_ID.bits_unused) |
| << (unsigned) enb.choice.home_eNB_ID.bits_unused); |
| memcpy(enb.choice.home_eNB_ID.buf, data, enb.choice.home_eNB_ID.size); |
| break; |
| } |
| case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes |
| enb.choice.short_Macro_eNB_ID.size = 3; |
| enb.choice.short_Macro_eNB_ID.bits_unused = 6; |
| enb.present = ENB_ID_PR_short_Macro_eNB_ID; |
| |
| enb.choice.short_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.short_Macro_eNB_ID.size); |
| data[enb.choice.short_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.short_Macro_eNB_ID.size - 1] |
| >> (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused) |
| << (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused); |
| memcpy(enb.choice.short_Macro_eNB_ID.buf, data, enb.choice.short_Macro_eNB_ID.size); |
| break; |
| } |
| case ENB_ID_PR_long_Macro_eNB_ID: { // 21 |
| enb.choice.long_Macro_eNB_ID.size = 3; |
| enb.choice.long_Macro_eNB_ID.bits_unused = 3; |
| enb.present = ENB_ID_PR_long_Macro_eNB_ID; |
| |
| enb.choice.long_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.long_Macro_eNB_ID.size); |
| data[enb.choice.long_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.long_Macro_eNB_ID.size - 1] |
| >> (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused) |
| << (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused); |
| memcpy(enb.choice.long_Macro_eNB_ID.buf, data, enb.choice.long_Macro_eNB_ID.size); |
| break; |
| } |
| default: |
| break; |
| } |
| |
| checkAndPrint(&asn_DEF_ENB_ID, &enb, (char *) "ENB_ID_t", __func__); |
| } |
| |
| |
| static void buildGlobalENB_ID(GlobalENB_ID_t *gnbId, |
| const unsigned char *gnbData, |
| ENB_ID_PR enbType, |
| unsigned char *enbData) { |
| auto *plmnID = createPLMN_ID(gnbData); |
| memcpy(&gnbId->pLMN_Identity, plmnID, sizeof(PLMN_Identity_t)); |
| createENB_ID(gnbId->eNB_ID, enbType, enbData); |
| checkAndPrint(&asn_DEF_GlobalENB_ID, gnbId, (char *) "GlobalENB_ID_t", __func__); |
| } |
| |
| |
| void buildSetupRequest(E2AP_PDU_t *pdu, int mcc, int mnc) { |
| ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); |
| |
| pdu->choice.initiatingMessage = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t)); |
| auto *initiatingMessage = pdu->choice.initiatingMessage; |
| ASN_STRUCT_RESET(asn_DEF_InitiatingMessage, initiatingMessage); |
| initiatingMessage->procedureCode = ProcedureCode_id_E2setup; |
| initiatingMessage->criticality = Criticality_reject; |
| initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; |
| |
| auto *e2SetupRequestIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2SetupRequestIEs); |
| |
| e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB = (GlobalE2node_gNB_ID_t *)calloc(1, sizeof(GlobalE2node_gNB_ID_t)); |
| auto *globalE2NodeGNbId = e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB; |
| ASN_STRUCT_RESET(asn_DEF_GlobalE2node_gNB_ID, globalE2NodeGNbId); |
| |
| createPLMN_IDByMCCandMNC(&globalE2NodeGNbId->global_gNB_ID.plmn_id, mcc, mnc); |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = 4; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = |
| (uint8_t *) calloc(1, globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); //22..32 bits |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.bits_unused = 0; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[0] = 0xB5; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[1] = 0xC6; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[2] = 0x77; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[3] = 0x88; |
| |
| e2SetupRequestIEs->criticality = Criticality_reject; |
| e2SetupRequestIEs->id = ProtocolIE_ID_id_GlobalE2node_ID; |
| e2SetupRequestIEs->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; |
| e2SetupRequestIEs->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; |
| |
| |
| auto *e2SetupRequest = &initiatingMessage->value.choice.E2setupRequest; |
| |
| ASN_STRUCT_RESET(asn_DEF_E2setupRequest, e2SetupRequest); |
| ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, e2SetupRequestIEs); |
| |
| pdu->present = E2AP_PDU_PR_initiatingMessage; |
| } |
| |
| void buildSetupRequestWithFunc(E2AP_PDU_t *pdu, int mcc, int mnc) { |
| ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); |
| |
| pdu->choice.initiatingMessage = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t)); |
| auto *initiatingMessage = pdu->choice.initiatingMessage; |
| ASN_STRUCT_RESET(asn_DEF_InitiatingMessage, initiatingMessage); |
| initiatingMessage->procedureCode = ProcedureCode_id_E2setup; |
| initiatingMessage->criticality = Criticality_reject; |
| initiatingMessage->value.present = InitiatingMessage__value_PR_E2setupRequest; |
| |
| auto *e2SetupRequestIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2SetupRequestIEs); |
| |
| e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB = (GlobalE2node_gNB_ID_t *)calloc(1, sizeof(GlobalE2node_gNB_ID_t)); |
| auto *globalE2NodeGNbId = e2SetupRequestIEs->value.choice.GlobalE2node_ID.choice.gNB; |
| ASN_STRUCT_RESET(asn_DEF_GlobalE2node_gNB_ID, globalE2NodeGNbId); |
| |
| createPLMN_IDByMCCandMNC(&globalE2NodeGNbId->global_gNB_ID.plmn_id, mcc, mnc); |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.present = GNB_ID_Choice_PR_gnb_ID; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size = 4; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf = |
| (uint8_t *) calloc(1, globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.size); //22..32 bits |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.bits_unused = 0; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[0] = 0xB5; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[1] = 0xC6; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[2] = 0x77; |
| globalE2NodeGNbId->global_gNB_ID.gnb_id.choice.gnb_ID.buf[3] = 0x88; |
| |
| e2SetupRequestIEs->criticality = Criticality_reject; |
| e2SetupRequestIEs->id = ProtocolIE_ID_id_GlobalE2node_ID; |
| e2SetupRequestIEs->value.present = E2setupRequestIEs__value_PR_GlobalE2node_ID; |
| e2SetupRequestIEs->value.choice.GlobalE2node_ID.present = GlobalE2node_ID_PR_gNB; |
| |
| |
| auto *e2SetupRequest = &initiatingMessage->value.choice.E2setupRequest; |
| |
| ASN_STRUCT_RESET(asn_DEF_E2setupRequest, e2SetupRequest); |
| ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, e2SetupRequestIEs); |
| |
| auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs); |
| ranFlistIEs->criticality = Criticality_reject; |
| ranFlistIEs->id = ProtocolIE_ID_id_RANfunctionsAdded; |
| ranFlistIEs->value.present = E2setupRequestIEs__value_PR_RANfunctions_List; |
| |
| auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_RANfunction_ItemIEs, itemIes); |
| |
| |
| E2SM_gNB_NRT_RANfunction_Definition_t ranFunDef; |
| uint8_t funcDes[] = "asdfghjklpoiuytrewq\0"; |
| ranFunDef.ranFunction_Name.ranFunction_Description.buf = (uint8_t *)calloc(1, strlen((char *)funcDes)); |
| ranFunDef.ranFunction_Name.ranFunction_Description.size = strlen((char *)funcDes); |
| memcpy(ranFunDef.ranFunction_Name.ranFunction_Description.buf, funcDes, strlen((char *)funcDes)); |
| |
| uint8_t funcOID[] = "ABCDEFGHIJ1234567890\0"; |
| ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.buf = (uint8_t *)calloc(1, strlen((char *)funcOID)); |
| ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.size = strlen((char *)funcOID); |
| memcpy(ranFunDef.ranFunction_Name.ranFunction_E2SM_OID.buf, funcOID, strlen((char *)funcOID)); |
| |
| uint8_t shortName[] = "Nothing to declare\0"; |
| ranFunDef.ranFunction_Name.ranFunction_ShortName.buf = (uint8_t *)calloc(1, strlen((char *)shortName)); |
| ranFunDef.ranFunction_Name.ranFunction_ShortName.size = strlen((char *)shortName); |
| memcpy(ranFunDef.ranFunction_Name.ranFunction_ShortName.buf, shortName, strlen((char *)shortName)); |
| |
| |
| RIC_InsertStyle_List_t insertStyleList; |
| insertStyleList.ric_CallProcessIDFormat_Type = 28l; |
| insertStyleList.ric_IndicationHeaderFormat_Type = 29; |
| insertStyleList.ric_IndicationMessageFormat_Type = 30; |
| insertStyleList.ric_InsertActionFormat_Type = 31l; |
| |
| uint8_t styleName[] = "What a style\0"; |
| |
| insertStyleList.ric_InsertStyle_Name.buf = (uint8_t *)calloc(1, strlen((char *)styleName)); |
| insertStyleList.ric_InsertStyle_Name.size = strlen((char *)styleName); |
| memcpy(insertStyleList.ric_InsertStyle_Name.buf, styleName, strlen((char *)styleName)); |
| |
| |
| insertStyleList.ric_InsertStyle_Type = 23; |
| |
| RANparameterDef_Item_t raNparameterDefItem; |
| raNparameterDefItem.ranParameter_ID = 8; |
| raNparameterDefItem.ranParameter_Type = 12; |
| |
| uint8_t ItemName[] = "What a style\0"; |
| raNparameterDefItem.ranParameter_Name.buf = (uint8_t *)calloc(1, strlen((char *)ItemName)); |
| raNparameterDefItem.ranParameter_Name.size = strlen((char *)ItemName); |
| memcpy(raNparameterDefItem.ranParameter_Name.buf, ItemName, strlen((char *)ItemName)); |
| |
| ASN_SEQUENCE_ADD(&insertStyleList.ric_InsertRanParameterDef_List.list, &raNparameterDefItem); |
| |
| ASN_SEQUENCE_ADD(&ranFunDef.ric_InsertStyle_List->list, &insertStyleList); |
| //ranFunDef.ric_InsertStyle_List. |
| |
| uint8_t buffer[8192]; |
| size_t buffer_size = 8192; |
| auto *ranDef = &itemIes->value.choice.RANfunction_Item.ranFunctionDefinition; |
| |
| auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_NRT_RANfunction_Definition, &ranFunDef, buffer, buffer_size); |
| if (er.encoded == -1) { |
| cerr << "encoding of " << asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name << " failed, " << strerror(errno) << endl; |
| exit(-1); |
| } else if (er.encoded > (ssize_t) buffer_size) { |
| cerr << "Buffer of size " << buffer_size << " is to small for " << asn_DEF_E2SM_gNB_NRT_RANfunction_Definition.name << endl; |
| exit(-1); |
| } else { |
| ranDef->buf = (uint8_t *)calloc(1, er.encoded); |
| ranDef->size = er.encoded; |
| memcpy(ranDef->buf, buffer, ranDef->size); |
| } |
| |
| |
| |
| itemIes->id = ProtocolIE_ID_id_RANfunction_Item; |
| itemIes->criticality = Criticality_reject; |
| itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item; |
| itemIes->value.choice.RANfunction_Item.ranFunctionID = 1; |
| // auto *ranDef = &itemIes->value.choice.RANfunction_Item.ranFunctionDefinition; |
| // ranDef->size = 3; |
| // ranDef->buf = (uint8_t *)calloc(1, ranDef->size); |
| // memcpy(ranDef->buf, buf, ranDef->size); |
| |
| ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes); |
| |
| auto *itemIes1 = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_RANfunction_ItemIEs, itemIes1); |
| itemIes1->id = ProtocolIE_ID_id_RANfunction_Item; |
| itemIes1->criticality = Criticality_reject; |
| itemIes1->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item; |
| itemIes1->value.choice.RANfunction_Item.ranFunctionID = 7; |
| ranDef = &itemIes1->value.choice.RANfunction_Item.ranFunctionDefinition; |
| |
| ranDef->buf = (uint8_t *)calloc(1, er.encoded); |
| ranDef->size = er.encoded; |
| memcpy(ranDef->buf, buffer, ranDef->size); |
| |
| ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes1); |
| |
| |
| ASN_SEQUENCE_ADD(&e2SetupRequest->protocolIEs.list, ranFlistIEs); |
| |
| pdu->present = E2AP_PDU_PR_initiatingMessage; |
| } |
| |
| |
| |
| |
| |
| void buildSetupSuccsessfulResponse(E2AP_PDU_t *pdu, int mcc, int mnc, uint8_t *data) { |
| ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); |
| |
| pdu->choice.successfulOutcome = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t)); |
| SuccessfulOutcome_t *successfulOutcome = pdu->choice.successfulOutcome; |
| ASN_STRUCT_RESET(asn_DEF_E2setupResponse, &successfulOutcome->value.choice.E2setupResponse); |
| successfulOutcome->procedureCode = ProcedureCode_id_E2setup; |
| successfulOutcome->criticality = Criticality_reject; |
| successfulOutcome->value.present = SuccessfulOutcome__value_PR_E2setupResponse; |
| |
| |
| auto *globalRicidIE = (E2setupResponseIEs_t *)calloc(1, sizeof(E2setupResponseIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupResponseIEs, globalRicidIE); |
| |
| globalRicidIE->criticality = Criticality_reject; |
| globalRicidIE->id = ProtocolIE_ID_id_GlobalRIC_ID; |
| globalRicidIE->value.present = E2setupResponseIEs__value_PR_GlobalRIC_ID; |
| createPLMN_IDByMCCandMNC(&globalRicidIE->value.choice.GlobalRIC_ID.pLMN_Identity, mcc, mnc); |
| |
| globalRicidIE->value.choice.GlobalRIC_ID.ric_ID = {nullptr, 3, 4}; |
| globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf = (uint8_t *)calloc(1, globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.size); |
| memcpy(globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf, data, globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.size); |
| globalRicidIE->value.choice.GlobalRIC_ID.ric_ID.buf[2] &= (unsigned)0xF0; |
| |
| |
| ASN_STRUCT_RESET(asn_DEF_E2setupResponse, &successfulOutcome->value.choice.E2setupResponse); |
| ASN_SEQUENCE_ADD(&successfulOutcome->value.choice.E2setupResponse.protocolIEs.list, globalRicidIE); |
| |
| auto *ranFunctionAdd = (E2setupResponseIEs_t *)calloc(1, sizeof(E2setupResponseIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupResponseIEs, ranFunctionAdd); |
| ranFunctionAdd->criticality = Criticality_reject; |
| ranFunctionAdd->id = ProtocolIE_ID_id_RANfunctionsAccepted; |
| ranFunctionAdd->value.present = E2setupResponseIEs__value_PR_RANfunctionsID_List; |
| |
| auto *ranFuncIdItemIEs = (RANfunctionID_ItemIEs_t *)calloc(1, sizeof(RANfunctionID_ItemIEs_t)); |
| |
| ranFuncIdItemIEs->criticality = Criticality_ignore; |
| ranFuncIdItemIEs->id = ProtocolIE_ID_id_RANfunctionID_Item; |
| ranFuncIdItemIEs->value.present = RANfunctionID_ItemIEs__value_PR_RANfunctionID_Item; |
| ranFuncIdItemIEs->value.choice.RANfunctionID_Item.ranFunctionID = 10; |
| ranFuncIdItemIEs->value.choice.RANfunctionID_Item.ranFunctionRevision = 1; |
| |
| ASN_SEQUENCE_ADD(&ranFunctionAdd->value.choice.RANfunctionsID_List.list, ranFuncIdItemIEs); |
| ASN_SEQUENCE_ADD(&successfulOutcome->value.choice.E2setupResponse.protocolIEs.list, ranFunctionAdd); |
| |
| |
| |
| |
| |
| pdu->present = E2AP_PDU_PR_successfulOutcome; |
| } |
| |
| |
| void buildSetupUnSuccsessfulResponse(E2AP_PDU_t *pdu) { |
| ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); |
| |
| pdu->choice.unsuccessfulOutcome = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t)); |
| UnsuccessfulOutcome_t *uns = pdu->choice.unsuccessfulOutcome; |
| uns->procedureCode = ProcedureCode_id_E2setup; |
| uns->criticality = Criticality_reject; |
| uns->value.present = UnsuccessfulOutcome__value_PR_E2setupFailure; |
| |
| auto *e2SetupFIE = (E2setupFailureIEs_t *)calloc(1, sizeof(E2setupFailureIEs_t)); |
| ASN_STRUCT_RESET(asn_DEF_E2setupFailureIEs, e2SetupFIE); |
| |
| e2SetupFIE->criticality = Criticality_reject; |
| e2SetupFIE->id = ProtocolIE_ID_id_GlobalRIC_ID; |
| e2SetupFIE->value.present = E2setupFailureIEs__value_PR_Cause; |
| e2SetupFIE->value.choice.Cause.present = Cause_PR_transport; |
| e2SetupFIE->value.choice.Cause.choice.transport = CauseTransport_transport_resource_unavailable; |
| |
| |
| ASN_STRUCT_RESET(asn_DEF_E2setupFailure, &uns->value.choice.E2setupFailure); |
| ASN_SEQUENCE_ADD(&uns->value.choice.E2setupFailure.protocolIEs.list, e2SetupFIE); |
| |
| pdu->present = E2AP_PDU_PR_unsuccessfulOutcome; |
| } |
| |
| #endif //E2_E2BUILDER_H |