834 lines
32 KiB
C
834 lines
32 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* This source code is part of the near-RT RIC (RAN Intelligent Controller)
|
|
* platform project (RICP).
|
|
*/
|
|
|
|
//
|
|
// Created by adi ENZEL on 6/19/19.
|
|
//
|
|
|
|
#include "e2sm.h"
|
|
|
|
#define printEntry(type, function) \
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) { \
|
|
mdclog_write(MDCLOG_DEBUG, "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) {
|
|
mdclog_write(MDCLOG_ERR, "%s Constraint validation failed: %s", dataType, errbuf);
|
|
} else if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
mdclog_write(MDCLOG_DEBUG, "%s successes function %s", dataType, function);
|
|
}
|
|
}
|
|
|
|
static size_t encodebuff(int codingType,
|
|
asn_TYPE_descriptor_t *typeDescriptor,
|
|
void *objectData,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
asn_enc_rval_t er;
|
|
struct timespec start = {0,0};
|
|
struct timespec end = {0,0};
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
er = asn_encode_to_buffer(0, codingType, typeDescriptor, objectData, buffer, buffer_size);
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
if (er.encoded == -1) {
|
|
mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2SM_gNB_X2_eventTriggerDefinition.name, strerror(errno));
|
|
} else if (er.encoded > (ssize_t)buffer_size) {
|
|
mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s", (int) buffer_size,
|
|
typeDescriptor->name);
|
|
} else if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
if (codingType == ATS_BASIC_XER) {
|
|
mdclog_write(MDCLOG_DEBUG, "Buffer of size %d, data = %s", (int) er.encoded, buffer);
|
|
}
|
|
else {
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
char *printBuffer;
|
|
size_t size;
|
|
FILE *stream = open_memstream(&printBuffer, &size);
|
|
asn_fprint(stream, typeDescriptor, objectData);
|
|
mdclog_write(MDCLOG_DEBUG, "Encoding E2SM PDU past : %s", printBuffer);
|
|
}
|
|
|
|
|
|
mdclog_write(MDCLOG_DEBUG, "Buffer of size %d", (int) er.encoded);
|
|
}
|
|
}
|
|
mdclog_write(MDCLOG_INFO, "Encoding type %d, time is %ld seconds, %ld nanoseconds", codingType, end.tv_sec - start.tv_sec, end.tv_nsec - start.tv_nsec);
|
|
//mdclog_write(MDCLOG_INFO, "Encoding time is %3.9f seconds", ((double)end.tv_sec + 1.0e-9 * end.tv_nsec) - ((double)start.tv_sec + 1.0e-9 * start.tv_nsec));
|
|
return er.encoded;
|
|
}
|
|
|
|
PLMN_Identity_t *createPLMN_ID(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;
|
|
plmnId->buf = calloc(1, 3);
|
|
memcpy(plmnId->buf, data, 3);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, "PLMN_Identity_t", __func__);
|
|
}
|
|
|
|
return plmnId;
|
|
}
|
|
|
|
ENB_ID_t *createENB_ID(ENB_ID_PR enbType, unsigned char *data) {
|
|
printEntry("ENB_ID_t", __func__)
|
|
ENB_ID_t *enb = 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 = 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 = 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 = 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 = 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 NULL;
|
|
|
|
}
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ENB_ID, enb, "ENB_ID_t", __func__);
|
|
}
|
|
return enb;
|
|
}
|
|
|
|
GNB_ID_t *createGnb_id(const unsigned char *data, int numOfBits) {
|
|
printEntry("GNB_ID_t", __func__)
|
|
if (numOfBits < 22 || numOfBits > 32) {
|
|
mdclog_write(MDCLOG_ERR, "GNB_ID_t number of bits = %d, needs to be 22 .. 32", numOfBits);
|
|
return NULL;
|
|
}
|
|
GNB_ID_t *gnb = calloc(1, sizeof(GNB_ID_t));
|
|
ASN_STRUCT_RESET(asn_DEF_GNB_ID, gnb);
|
|
|
|
gnb->present = GNB_ID_PR_gNB_ID;
|
|
gnb->choice.gNB_ID.size = numOfBits % 8 == 0 ? (unsigned int)(numOfBits / 8) : (unsigned int)(numOfBits / 8 + 1);
|
|
gnb->choice.gNB_ID.bits_unused = (int)gnb->choice.gNB_ID.size * 8 - numOfBits;
|
|
gnb->choice.gNB_ID.buf = calloc(1, gnb->choice.gNB_ID.size);
|
|
memcpy(gnb->choice.gNB_ID.buf, data, gnb->choice.gNB_ID.size);
|
|
gnb->choice.gNB_ID.buf[gnb->choice.gNB_ID.size - 1] =
|
|
((unsigned)(gnb->choice.gNB_ID.buf[gnb->choice.gNB_ID.size - 1] >> (unsigned)gnb->choice.gNB_ID.bits_unused)
|
|
<< (unsigned)gnb->choice.gNB_ID.bits_unused);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_GNB_ID, gnb, "GNB_ID_t", __func__);
|
|
}
|
|
|
|
return gnb;
|
|
|
|
}
|
|
|
|
GlobalENB_ID_t *createGlobalENB_ID(PLMN_Identity_t *plmnIdentity, ENB_ID_t *enbId) {
|
|
printEntry("GlobalENB_ID_t", __func__)
|
|
GlobalENB_ID_t *genbId = 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));
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_GlobalENB_ID, genbId, "GlobalENB_ID_t", __func__);
|
|
}
|
|
return genbId;
|
|
}
|
|
|
|
GlobalGNB_ID_t *createGlobalGNB_ID(PLMN_Identity_t *plmnIdentity, GNB_ID_t *gnb) {
|
|
printEntry("GlobalGNB_ID_t", __func__)
|
|
GlobalGNB_ID_t *ggnbId = calloc(1, sizeof(GlobalGNB_ID_t));
|
|
ASN_STRUCT_RESET(asn_DEF_GlobalGNB_ID, ggnbId);
|
|
|
|
memcpy(&ggnbId->pLMN_Identity, plmnIdentity, sizeof(PLMN_Identity_t));
|
|
memcpy(&ggnbId->gNB_ID, gnb, sizeof(GNB_ID_t));
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_GlobalGNB_ID, ggnbId, "GlobalGNB_ID_t", __func__);
|
|
}
|
|
|
|
return ggnbId;
|
|
}
|
|
|
|
|
|
Interface_ID_t *createInterfaceIDForGnb(GlobalGNB_ID_t *gnb) {
|
|
printEntry("Interface_ID_t", __func__)
|
|
Interface_ID_t *interfaceId = calloc(1, sizeof(Interface_ID_t));
|
|
ASN_STRUCT_RESET(asn_DEF_Interface_ID, interfaceId);
|
|
|
|
interfaceId->present = Interface_ID_PR_global_gNB_ID;
|
|
//memcpy(&interfaceId->choice.global_gNB_ID, gnb, sizeof(GlobalGNB_ID_t));
|
|
interfaceId->choice.global_gNB_ID = gnb;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_Interface_ID, interfaceId, "Interface_ID_t", __func__);
|
|
}
|
|
|
|
return interfaceId;
|
|
}
|
|
|
|
Interface_ID_t *createInterfaceIDForEnb(GlobalENB_ID_t *enb) {
|
|
printEntry("Interface_ID_t", __func__)
|
|
Interface_ID_t *interfaceId = calloc(1, sizeof(Interface_ID_t));
|
|
ASN_STRUCT_RESET(asn_DEF_Interface_ID, interfaceId);
|
|
|
|
interfaceId->present = Interface_ID_PR_global_eNB_ID;
|
|
//memcpy(&interfaceId->choice.global_eNB_ID, enb, sizeof(GlobalENB_ID_t));
|
|
interfaceId->choice.global_eNB_ID = enb;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_Interface_ID, interfaceId, "Interface_ID_t", __func__);
|
|
}
|
|
|
|
return interfaceId;
|
|
}
|
|
|
|
|
|
|
|
InterfaceMessageType_t *createInterfaceMessageInitiating(long procedureCode) {
|
|
printEntry("InterfaceMessageType_t", __func__)
|
|
InterfaceMessageType_t *intMsgT = calloc(1, sizeof(InterfaceMessageType_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceMessageType, intMsgT);
|
|
|
|
intMsgT->procedureCode = procedureCode;
|
|
intMsgT->typeOfMessage = TypeOfMessage_initiating_message;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceMessageType, intMsgT, "InterfaceMessageType_t", __func__);
|
|
}
|
|
|
|
return intMsgT;
|
|
}
|
|
|
|
InterfaceMessageType_t *createInterfaceMessageSuccsesful(long procedureCode) {
|
|
printEntry("InterfaceMessageType_t", __func__)
|
|
InterfaceMessageType_t *intMsgT = calloc(1, sizeof(InterfaceMessageType_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceMessageType, intMsgT);
|
|
|
|
intMsgT->procedureCode = procedureCode;
|
|
intMsgT->typeOfMessage = TypeOfMessage_successful_outcome;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceMessageType, intMsgT, "InterfaceMessageType_t", __func__);
|
|
}
|
|
|
|
return intMsgT;
|
|
}
|
|
|
|
InterfaceMessageType_t *createInterfaceMessageUnsuccessful(long procedureCode) {
|
|
printEntry("InterfaceMessageType_t", __func__)
|
|
InterfaceMessageType_t *intMsgT = calloc(1, sizeof(InterfaceMessageType_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceMessageType, intMsgT);
|
|
|
|
intMsgT->procedureCode = procedureCode;
|
|
intMsgT->typeOfMessage = TypeOfMessage_unsuccessful_outcome;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceMessageType, intMsgT, "InterfaceMessageType_t", __func__);
|
|
}
|
|
|
|
return intMsgT;
|
|
}
|
|
|
|
InterfaceProtocolIE_Value_t *createInterfaceProtocolValueInt(long number) {
|
|
printEntry("InterfaceProtocolIE_Value_t", __func__)
|
|
InterfaceProtocolIE_Value_t *value = calloc(1, sizeof(InterfaceProtocolIE_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Value, value);
|
|
|
|
value->present = InterfaceProtocolIE_Value_PR_valueInt;
|
|
value->choice.valueInt = number;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Value, value, "InterfaceProtocolIE_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
InterfaceProtocolIE_Value_t *createInterfaceProtocolValueEnum(long number) {
|
|
printEntry("InterfaceProtocolIE_Value_t", __func__)
|
|
InterfaceProtocolIE_Value_t *value = calloc(1, sizeof(InterfaceProtocolIE_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Value, value);
|
|
|
|
value->present = InterfaceProtocolIE_Value_PR_valueEnum;
|
|
value->choice.valueEnum = number;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Value, value, "InterfaceProtocolIE_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
InterfaceProtocolIE_Value_t *createInterfaceProtocolValueBool(int val) {
|
|
printEntry("InterfaceProtocolIE_Value_t", __func__)
|
|
InterfaceProtocolIE_Value_t *value = calloc(1, sizeof(InterfaceProtocolIE_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Value, value);
|
|
|
|
value->present = InterfaceProtocolIE_Value_PR_valueBool;
|
|
value->choice.valueBool = val == 0 ? 0 : 1;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Value, value, "InterfaceProtocolIE_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
InterfaceProtocolIE_Value_t *createInterfaceProtocolValueBitString(unsigned char *buf, int numOfBits) {
|
|
printEntry("InterfaceProtocolIE_Value_t", __func__)
|
|
size_t size = numOfBits % 8 == 0 ? (unsigned int)(numOfBits / 8) : (unsigned int)(numOfBits / 8 + 1);
|
|
if (strlen((const char *)buf) < size) {
|
|
mdclog_write(MDCLOG_ERR, "size of buffer is small : %d needs to be %d in %s", (int)strlen((const char *)buf), (int)size, __func__);
|
|
}
|
|
InterfaceProtocolIE_Value_t *value = calloc(1, sizeof(InterfaceProtocolIE_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Value, value);
|
|
|
|
value->present = InterfaceProtocolIE_Value_PR_valueBitS;
|
|
value->choice.valueBitS.size = numOfBits % 8 == 0 ? (unsigned int)(numOfBits / 8) : (unsigned int)(numOfBits / 8 + 1);
|
|
value->choice.valueBitS.buf = calloc(1, value->choice.valueBitS.size);
|
|
int bits_unused = (int)value->choice.valueBitS.size * 8 - numOfBits;
|
|
value->choice.valueBitS.bits_unused = bits_unused;
|
|
|
|
memcpy(value->choice.valueBitS.buf, buf, value->choice.valueBitS.size);
|
|
value->choice.valueBitS.buf[size -1] = ((unsigned)(buf[size - 1]) >> (unsigned)bits_unused << (unsigned)bits_unused);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Value, value, "InterfaceProtocolIE_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
InterfaceProtocolIE_Value_t *createInterfaceProtocolValueOCTETS(uint8_t *buf) {
|
|
printEntry("InterfaceProtocolIE_Value_t", __func__)
|
|
size_t size = strlen((const char *)buf);
|
|
InterfaceProtocolIE_Value_t *value = calloc(1, sizeof(InterfaceProtocolIE_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Value, value);
|
|
|
|
value->present = InterfaceProtocolIE_Value_PR_valueOctS;
|
|
value->choice.valueOctS.size = size;
|
|
value->choice.valueOctS.buf = calloc(1, value->choice.valueOctS.size);
|
|
memcpy(value->choice.valueOctS.buf, buf, value->choice.valueOctS.size);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Value, value, "InterfaceProtocolIE_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
InterfaceProtocolIE_Item_t *createInterfaceProtocolIE_Item(long id, long test, InterfaceProtocolIE_Value_t *value) {
|
|
printEntry("InterfaceProtocolIE_Item_t", __func__)
|
|
if (test < InterfaceProtocolIE_Test_equal || test > InterfaceProtocolIE_Test_present) {
|
|
mdclog_write(MDCLOG_ERR, "InterfaceProtocolIE_Item_t test value is %ld, out of scope %d .. %d ",
|
|
test, InterfaceProtocolIE_Test_equal, InterfaceProtocolIE_Test_present);
|
|
return NULL;
|
|
}
|
|
InterfaceProtocolIE_Item_t *intProtIt = calloc(1, sizeof(InterfaceProtocolIE_Item_t));
|
|
ASN_STRUCT_RESET(asn_DEF_InterfaceProtocolIE_Item, intProtIt);
|
|
|
|
|
|
intProtIt->interfaceProtocolIE_ID = id;
|
|
|
|
intProtIt->interfaceProtocolIE_Test = test;
|
|
|
|
memcpy(&intProtIt->interfaceProtocolIE_Value, value, sizeof(InterfaceProtocolIE_Value_t));
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_InterfaceProtocolIE_Item, intProtIt, "InterfaceProtocolIE_Item_t", __func__);
|
|
}
|
|
|
|
return intProtIt;
|
|
|
|
}
|
|
|
|
|
|
|
|
ActionParameter_Value_t *createActionParameterValue_Int(long number) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valueInt;
|
|
value->choice.valueInt = number;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
ActionParameter_Value_t *createActionParameterValue_Enum(long number) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valueEnum;
|
|
value->choice.valueEnum = number;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
ActionParameter_Value_t *createActionParameterValue_Bool(int val) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valueBool;
|
|
value->choice.valueBool = val == 0 ? 0 : 1;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
ActionParameter_Value_t *createActionParameterValue_Bit_String(unsigned char *buf, int numOfBits) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
size_t size = numOfBits % 8 == 0 ? (unsigned int)(numOfBits / 8) : (unsigned int)(numOfBits / 8 + 1);
|
|
if (strlen((const char *)buf) < size) {
|
|
mdclog_write(MDCLOG_ERR, "size of buffer is small : %d needs to be %d in %s", (int)strlen((const char *)buf), (int)size, __func__);
|
|
}
|
|
int bits_unused = (int)size * 8 - numOfBits;
|
|
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valueBitS;
|
|
value->choice.valueBitS.size = size;
|
|
value->choice.valueBitS.buf = calloc(1, size);
|
|
value->choice.valueBitS.bits_unused = bits_unused;
|
|
|
|
memcpy(value->choice.valueBitS.buf, buf, size);
|
|
value->choice.valueBitS.buf[size -1] = ((unsigned)(buf[size - 1]) >> (unsigned)bits_unused << (unsigned)bits_unused);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
ActionParameter_Value_t *createActionParameterValue_OCTETS(uint8_t *buf) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
size_t size = strlen((const char *)buf);
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valueOctS;
|
|
value->choice.valueOctS.size = size;
|
|
value->choice.valueOctS.buf = calloc(1, value->choice.valueOctS.size);
|
|
memcpy(value->choice.valueOctS.buf, buf, value->choice.valueOctS.size);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param buf buffer that must be null terminated
|
|
* @return ActionParameter_Value_t *
|
|
*/
|
|
ActionParameter_Value_t *createActionParameterValue_PRINTS(char *buf) {
|
|
printEntry("ActionParameter_Value_t", __func__)
|
|
size_t size = strlen((const char *)buf);
|
|
ActionParameter_Value_t *value = calloc(1, sizeof(ActionParameter_Value_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Value, value);
|
|
|
|
value->present = ActionParameter_Value_PR_valuePrtS;
|
|
value->choice.valuePrtS.size = size;
|
|
value->choice.valuePrtS.buf = calloc(1, value->choice.valuePrtS.size);
|
|
memcpy(value->choice.valuePrtS.buf, buf, value->choice.valuePrtS.size);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Value, value, "ActionParameter_Value_t", __func__);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
ActionParameter_Item_t *creatActionParameter_Item(long id, ActionParameter_Value_t *val) {
|
|
printEntry("ActionParameter_Item_t", __func__)
|
|
if (id < 0 || id > 255) {
|
|
mdclog_write(MDCLOG_ERR, "ActionParameter_Item_t id = %ld, values are 0 .. 255", id);
|
|
return NULL;
|
|
}
|
|
ActionParameter_Item_t *actionParameterItem = calloc(1, sizeof(ActionParameter_Item_t));
|
|
ASN_STRUCT_RESET(asn_DEF_ActionParameter_Item, actionParameterItem);
|
|
|
|
actionParameterItem->actionParameter_ID = id;
|
|
memcpy(&actionParameterItem->actionParameter_Value, val, sizeof(ActionParameter_Value_t));
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_ActionParameter_Item, actionParameterItem, "ActionParameter_Item_t", __func__);
|
|
}
|
|
|
|
return actionParameterItem;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param interfaceId
|
|
* @param direction
|
|
* @param messageType
|
|
* @param interfaceProtocolItemList
|
|
* @param listSize
|
|
* @param buffer
|
|
* @param buffer_size
|
|
* @return
|
|
*/
|
|
size_t createEventTrigger(Interface_ID_t *interfaceId, long direction,
|
|
InterfaceMessageType_t *messageType,
|
|
InterfaceProtocolIE_Item_t interfaceProtocolItemList[],
|
|
int listSize,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_eventTriggerDefinition_t", __func__)
|
|
if (direction < InterfaceDirection_incoming || direction > InterfaceDirection_outgoing) {
|
|
mdclog_write(MDCLOG_ERR, "E2SM_gNB_X2_eventTriggerDefinition_t direction = %ld, values are %d .. %d",
|
|
direction, InterfaceDirection_incoming, InterfaceDirection_outgoing);
|
|
return -1;
|
|
}
|
|
|
|
E2SM_gNB_X2_eventTriggerDefinition_t *eventTrigger = calloc(1, sizeof(E2SM_gNB_X2_eventTriggerDefinition_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, eventTrigger);
|
|
|
|
memcpy(&eventTrigger->interface_ID , interfaceId, sizeof(Interface_ID_t));
|
|
|
|
eventTrigger->interfaceDirection = direction;
|
|
memcpy(&eventTrigger->interfaceMessageType, messageType, sizeof(InterfaceMessageType_t));
|
|
|
|
for (int i = 0; i < listSize; i++) {
|
|
ASN_SEQUENCE_ADD(eventTrigger->interfaceProtocolIE_List, &interfaceProtocolItemList[i]);
|
|
}
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, eventTrigger, "E2SM_gNB_X2_eventTriggerDefinition_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_eventTriggerDefinition,
|
|
eventTrigger,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_eventTriggerDefinition,
|
|
eventTrigger,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
size_t createActionDefinition(long styleId, ActionParameter_Item_t actionParamList[], int listSize,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_actionDefinition_t", __func__)
|
|
E2SM_gNB_X2_actionDefinition_t *actDef = calloc(1, sizeof(E2SM_gNB_X2_actionDefinition_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_actionDefinition, actDef);
|
|
|
|
actDef->style_ID = styleId;
|
|
for (int i = 0; i < listSize; i++) {
|
|
ASN_SEQUENCE_ADD(actDef->actionParameter_List, &actionParamList[i]);
|
|
}
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_actionDefinition, actDef, "E2SM_gNB_X2_actionDefinition_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_actionDefinition,
|
|
actDef,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_actionDefinition,
|
|
actDef,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
size_t createE2SM_gNB_X2_indicationHeader(long direction,
|
|
Interface_ID_t *interfaceId,
|
|
uint8_t *timestamp, //can put NULL if size == 0
|
|
int size,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_indicationHeader_t", __func__)
|
|
if (direction < InterfaceDirection_incoming || direction > InterfaceDirection_outgoing) {
|
|
mdclog_write(MDCLOG_ERR, "E2SM_gNB_X2_indicationHeader_t direction = %ld, values are %d .. %d",
|
|
direction, InterfaceDirection_incoming, InterfaceDirection_outgoing);
|
|
return -1;
|
|
}
|
|
|
|
E2SM_gNB_X2_indicationHeader_t *indiHead = calloc(1, sizeof(E2SM_gNB_X2_indicationHeader_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_indicationHeader, indiHead);
|
|
|
|
indiHead->interfaceDirection = direction;
|
|
memcpy(&indiHead->interface_ID, interfaceId, sizeof(Interface_ID_t));
|
|
if (size > 0) {
|
|
indiHead->timestamp->size = size;
|
|
indiHead->timestamp->buf = calloc(1, sizeof(uint8_t) * size);
|
|
memcpy(indiHead->timestamp->buf, timestamp, size);
|
|
}
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_indicationHeader, indiHead, "E2SM_gNB_X2_indicationHeader_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_indicationHeader,
|
|
indiHead,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_indicationHeader,
|
|
indiHead,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
size_t createE2SM_gNB_X2_indicationMessage(uint8_t *message, uint msgSize,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_indicationMessage_t", __func__)
|
|
if (msgSize <= 0) {
|
|
mdclog_write(MDCLOG_ERR, "E2SM_gNB_X2_indicationMessage_t failed messsage size = %d", msgSize);
|
|
return -1;
|
|
}
|
|
|
|
E2SM_gNB_X2_indicationMessage_t *indicationMessage = calloc(1, sizeof(E2SM_gNB_X2_indicationMessage_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_indicationMessage, indicationMessage);
|
|
|
|
indicationMessage->interfaceMessage.size = msgSize;
|
|
indicationMessage->interfaceMessage.buf = calloc(1, sizeof(uint8_t) * msgSize);
|
|
memcpy(indicationMessage->interfaceMessage.buf, message, msgSize);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_indicationMessage, indicationMessage, "E2SM_gNB_X2_indicationMessage_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_indicationMessage,
|
|
indicationMessage,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_indicationMessage,
|
|
indicationMessage,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
size_t createE2SM_gNB_X2_callProcessID(long callProcess_Id,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_callProcessID_t", __func__)
|
|
E2SM_gNB_X2_callProcessID_t *callProcessId = calloc(1, sizeof(E2SM_gNB_X2_callProcessID_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_callProcessID, callProcessId);
|
|
|
|
callProcessId->callProcess_ID = callProcess_Id;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_callProcessID, callProcessId, "E2SM_gNB_X2_indicationMessage_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_callProcessID,
|
|
callProcessId,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_callProcessID,
|
|
callProcessId,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
size_t createE2SM_gNB_X2_controlHeader(Interface_ID_t *interfaceId, long direction,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_controlHeader_t", __func__)
|
|
if (direction < InterfaceDirection_incoming || direction > InterfaceDirection_outgoing) {
|
|
mdclog_write(MDCLOG_ERR, "E2SM_gNB_X2_controlHeader_t direction = %ld, values are %d .. %d",
|
|
direction, InterfaceDirection_incoming, InterfaceDirection_outgoing);
|
|
return -1;
|
|
}
|
|
E2SM_gNB_X2_controlHeader_t *controlHeader = calloc(1, sizeof(E2SM_gNB_X2_controlHeader_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_controlHeader, controlHeader);
|
|
|
|
memcpy(&controlHeader->interface_ID, interfaceId, sizeof(Interface_ID_t));
|
|
controlHeader->interfaceDirection = direction;
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_controlHeader, controlHeader, "E2SM_gNB_X2_controlHeader_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_controlHeader,
|
|
controlHeader,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_controlHeader,
|
|
controlHeader,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
size_t createE2SM_gNB_X2_controlMessage(uint8_t *message, uint msgSize,
|
|
uint8_t *buffer,
|
|
size_t buffer_size) {
|
|
printEntry("E2SM_gNB_X2_controlMessage_t", __func__)
|
|
E2SM_gNB_X2_controlMessage_t *controlMsg = calloc(1, sizeof(E2SM_gNB_X2_controlMessage_t));
|
|
ASN_STRUCT_RESET(asn_DEF_E2SM_gNB_X2_controlMessage, controlMsg);
|
|
|
|
controlMsg->interfaceMessage.size = msgSize;
|
|
controlMsg->interfaceMessage.buf = calloc(1, sizeof(uint8_t) * msgSize);
|
|
memcpy(controlMsg->interfaceMessage.buf, message, msgSize);
|
|
|
|
if (mdclog_level_get() >= MDCLOG_DEBUG) {
|
|
checkAndPrint(&asn_DEF_E2SM_gNB_X2_controlMessage, controlMsg, "E2SM_gNB_X2_controlMessage_t", __func__);
|
|
}
|
|
|
|
size_t len = encodebuff(ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_controlMessage,
|
|
controlMsg,
|
|
buffer,
|
|
buffer_size);
|
|
|
|
|
|
if (mdclog_level_get() >= MDCLOG_INFO) {
|
|
uint8_t buf1[4096];
|
|
//asn_enc_rval_t er1;
|
|
encodebuff(ATS_BASIC_XER, &asn_DEF_E2SM_gNB_X2_controlMessage,
|
|
controlMsg,
|
|
buf1,
|
|
4096);
|
|
|
|
}
|
|
|
|
return len;
|
|
}
|