RIC-E2-TERMINATION/TEST/e2sm.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 > 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);
    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 = 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 = 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 = 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;
}