e2ap/libe2ap_wrapper/E2AP_if.c

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22
  23 #include "E2_asn_constant.h"
  24 #include "E2AP-PDU.h"
  25 #include "ProtocolIE-Field.h"
  26 #include "RICsubsequentAction.h"
  27 #include "E2_E2SM-gNB-X2-eventTriggerDefinition.h"
  28 #include "E2_E2SM-gNB-NRT-EventTriggerDefinition.h"
  29 #include "E2_E2SM-gNB-X2-ActionDefinitionChoice.h"
  30 #include "E2_E2SM-gNB-X2-actionDefinition.h"
  31 #include "E2_ActionParameter-Item.h"
  32 #include "E2_E2SM-gNB-X2-ActionDefinition-Format2.h"
  33 #include "E2_RANueGroup-Item.h"
  34 #include "E2_RANueGroupDef-Item.h"
  35 #include "E2_RANimperativePolicy.h"
  36 #include "E2_RANParameter-Item.h"
  37
  38 // E2SM-gNB-NRT
  39 #include "E2_E2SM-gNB-NRT-ActionDefinition.h"
  40 #include "E2_E2SM-gNB-NRT-ActionDefinition-Format1.h"
  41 #include "E2_RANparameter-Item.h"
  42
  43 #include "asn_constant.h"
  44 #include "E2_asn_constant.h"
  45 #include "E2AP_if.h"
  46
  47
  48 #ifdef DEBUG
  49     static const bool debug = true;
  50 #else
  51     static const bool debug = true; //false;
  52 #endif
  53
  54 const int64_t cMaxNrOfErrors = 256;
  55 const uint64_t cMaxSizeOfOctetString = 1024;
  56
  57 const size_t cMacroENBIDP_20Bits = 20;
  58 const size_t cHomeENBID_28Bits = 28;
  59 const size_t cShortMacroENBID_18Bits = 18;
  60 const size_t clongMacroENBIDP_21Bits = 21;
  61
  62 const int cCauseRICRequest = 1;
  63 const int cCauseRICService = 2;
  64 const int cCauseTransport = 3;
  65 const int cCauseProtocol = 4;
  66 const int cCauseMisc = 5;
  67
  68 //////////////////////////////////////////////////////////////////////
  69 // Message definitons
  70
  71 // Below constant values are same as in E2AP, E2SM and X2AP specs
  72 const uint64_t cE2InitiatingMessage = 1;
  73 const uint64_t cE2SuccessfulOutcome = 2;
  74 const uint64_t cE2UnsuccessfulOutcome = 3;
  75
  76 // E2AP messages
  77 // Initiating message
  78 const uint64_t cRICSubscriptionRequest = 1;
  79 const uint64_t cRICSubscriptionDeleteRequest = 2;
  80
  81 // Successful outcome
  82 const uint64_t cRICSubscriptionResponse = 1;
  83 const uint64_t cRICsubscriptionDeleteResponse = 2;
  84
  85 // Unsuccessful outcome
  86 const uint64_t cRICSubscriptionFailure = 1;
  87 const uint64_t cRICsubscriptionDeleteFailure = 2;
  88
  89 typedef union {
  90     uint32_t  nodeID;
  91     uint8_t   octets[4];
  92 } IdOctects_t;
  93
  94 //////////////////////////////////////////////////////////////////////
  95 const char* getE2ErrorString(uint64_t errorCode) {
  96
  97     return E2ErrorStrings[errorCode];
  98 }
  99
 100 /////////////////////////////////////////////////////////////////////
 101 bool E2encode(E2AP_PDU_t* pE2AP_PDU, size_t* dataBufferSize, byte* dataBuffer, char* pLogBuffer) {
 102
 103     // Debug print
 104     if (debug)
 105         asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
 106
 107     asn_enc_rval_t rval;
 108     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pE2AP_PDU, dataBuffer, *dataBufferSize);
 109     if (rval.encoded == -1) {
 110         sprintf(pLogBuffer,"Serialization of %s failed.", asn_DEF_E2AP_PDU.name);
 111         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 112         return false;
 113     }
 114     else if (rval.encoded > *dataBufferSize) {
 115         sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",*dataBufferSize, asn_DEF_E2AP_PDU.name, rval.encoded);
 116         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 117         return false;
 118     }
 119     else {
 120         if (debug)
 121             sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2AP_PDU.name, *dataBufferSize, rval.encoded);
 122
 123         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 124         *dataBufferSize = rval.encoded;
 125         return true;
 126     }
 127 }
 128
 129 //////////////////////////////////////////////////////////////////////
 130 uint64_t packRICSubscriptionRequest(size_t* pdataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 131
 132     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 133     if(pE2AP_PDU)
 134         {
 135         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
 136         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscription;
 137         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 138         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
 139
 140         // RICrequestID
 141         RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 142         if (pRICsubscriptionRequest_IEs) {
 143             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
 144             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 145             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 146             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionRequest->ricRequestID.ricRequestorID;
 147             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionRequest->ricRequestID.ricInstanceID;
 148             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 149         }
 150         else
 151             return e2err_RICSubscriptionRequestAllocRICrequestIDFail;
 152
 153         // RANfunctionID
 154         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 155         if (pRICsubscriptionRequest_IEs) {
 156             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 157             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 158             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 159             pRICsubscriptionRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionRequest->ranFunctionID;
 160             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 161         }
 162         else
 163             return e2err_RICSubscriptionRequestAllocRANfunctionIDFail;
 164
 165         // RICsubscriptionDetails
 166         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 167         if (pRICsubscriptionRequest_IEs) {
 168             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICsubscriptionDetails;
 169             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 170             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 171
 172             // RICeventTriggerDefinition
 173             uint64_t returnCode;
 174             if ((returnCode = packRICEventTriggerDefinition(pLogBuffer, &pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition) != e2err_OK))
 175                 return returnCode;
 176
 177             pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf =
 178               calloc(1, pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 179             if (pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf) {
 180                 pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.size =
 181                   pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength;
 182                 memcpy(pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf,
 183                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data,
 184                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 185             }
 186             else
 187                 return e2err_RICSubscriptionRequestAllocRICeventTriggerDefinitionBufFail;
 188
 189             // RICactions-ToBeSetup-List
 190             uint64_t index = 0;
 191             while (index < pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength && index < maxofRICactionID) {
 192                 RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs = calloc(1, sizeof(RICaction_ToBeSetup_ItemIEs_t));
 193                 if (pRICaction_ToBeSetup_ItemIEs) {
 194                     pRICaction_ToBeSetup_ItemIEs->id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
 195                     pRICaction_ToBeSetup_ItemIEs->criticality = Criticality_reject;
 196                     pRICaction_ToBeSetup_ItemIEs->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 197
 198                     // RICActionID
 199                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID =
 200                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID;
 201
 202                     // RICActionType
 203                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType =
 204                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType;
 205
 206                     // RICactionDefinition, OPTIONAL
 207                     uint64_t returnCode;
 208                     if ((returnCode = packRICActionDefinition(pLogBuffer, &pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem->ricActionDefinitionChoice) != e2err_OK)) {
 209                         return returnCode;
 210                     }
 211
 212                     if (pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent) {
 213                         pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition = calloc(1, sizeof (RICactionDefinition_t));
 214                         if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) {
 215                             pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf =
 216                               calloc(1, pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength);
 217                             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf) {
 218                                 pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size =
 219                                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength;
 220                                 memcpy(pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf,
 221                                        pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data,
 222                                        pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength);
 223                             }
 224                             else
 225                                 return e2err_RICSubscriptionRequestAllocRICactionDefinitionBufFail;
 226                         }
 227                         else
 228                             return e2err_RICSubscriptionRequestAllocRICactionDefinitionFail;
 229                     }
 230
 231                     // RICsubsequentAction, OPTIONAL
 232                     if (pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent) {
 233                         RICsubsequentAction_t* pRICsubsequentAction = calloc(1, sizeof(RICsubsequentAction_t));
 234                         if (pRICsubsequentAction) {
 235                             pRICsubsequentAction->ricSubsequentActionType =
 236                             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType;
 237                             pRICsubsequentAction->ricTimeToWait =
 238                             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait;
 239                             pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = pRICsubsequentAction;
 240                         }
 241                         else
 242                             return e2err_RICSubscriptionRequestAllocRICsubsequentActionFail;
 243                     }
 244                 }
 245                 else
 246                     return e2err_RICSubscriptionRequestAllocRICaction_ToBeSetup_ItemIEsFail;
 247
 248                 ASN_SEQUENCE_ADD(&pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list, pRICaction_ToBeSetup_ItemIEs);
 249                 index++;
 250             }
 251             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 252         }
 253         else
 254             return e2err_RICSubscriptionRequestAllocRICsubscriptionRequest_IEsFail;
 255         if (E2encode(pE2AP_PDU, pdataBufferSize, pDataBuffer, pLogBuffer))
 256             return e2err_OK;
 257         else
 258             return e2err_RICSubscriptionRequestEncodeFail;
 259     }
 260     return e2err_RICSubscriptionRequestAllocE2AP_PDUFail;
 261 }
 262
 263 //////////////////////////////////////////////////////////////////////
 264 uint64_t packRICEventTriggerDefinition(char* pLogBuffer, RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
 265
 266     if (pRICEventTriggerDefinition->E2SMgNBX2EventTriggerDefinitionPresent)
 267         return packRICEventTriggerDefinitionX2Format(pLogBuffer, pRICEventTriggerDefinition);
 268     else if(pRICEventTriggerDefinition->E2SMgNBNRTEventTriggerDefinitionPresent)
 269         return packRICEventTriggerDefinitionNRTFormat(pLogBuffer, pRICEventTriggerDefinition);
 270     else
 271         return e2err_RICEventTriggerDefinitionAllocEventTriggerDefinitionEmptyFail;
 272 }
 273
 274 //////////////////////////////////////////////////////////////////////
 275 uint64_t packRICEventTriggerDefinitionX2Format(char* pLogBuffer, RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
 276
 277     E2_E2SM_gNB_X2_eventTriggerDefinition_t* pE2SM_gNB_X2_eventTriggerDefinition = calloc(1, sizeof(E2_E2SM_gNB_X2_eventTriggerDefinition_t));
 278     if(pE2SM_gNB_X2_eventTriggerDefinition == NULL)
 279         return e2err_RICEventTriggerDefinitionAllocE2SM_gNB_X2_eventTriggerDefinitionFail;
 280
 281     // RICeventTriggerDefinition
 282     // InterfaceID
 283     if ((pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent == true &&
 284          pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent == true) ||
 285         (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent == false &&
 286          pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent == false))
 287         return e2err_RICEventTriggerDefinitionIEValueFail_1;
 288
 289     // GlobalENB-ID or GlobalGNB-ID
 290     if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent)
 291     {
 292         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.present = E2_Interface_ID_PR_global_eNB_ID;
 293
 294         // GlobalENB-ID
 295         // PLMN-Identity
 296         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.size =
 297         pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength;
 298         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.buf = calloc(1,3);
 299         if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.buf) {
 300             memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.buf,
 301                    pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal,
 302                    pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength);
 303         }
 304         else
 305             return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_eNB_IDpLMN_IdentityBufFail;
 306
 307         // Add ENB-ID
 308         if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits == cMacroENBIDP_20Bits){
 309             // BIT STRING, SIZE 20
 310             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present = ENB_ID_PR_macro_eNB_ID;
 311             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.buf = calloc(1,3);
 312             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.buf) {
 313                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.size = 3; // bytes
 314                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.bits_unused = 4; // trailing unused bits
 315                 memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.buf,
 316                        (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID,3);
 317             }
 318             else
 319                 return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_eNB_IDeNB_IDmacro_eNB_IDBufFail;
 320         }
 321         else if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits == cHomeENBID_28Bits) {
 322             // BIT STRING, SIZE 28
 323             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present = ENB_ID_PR_home_eNB_ID;
 324             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.buf = calloc(1,4);
 325             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.buf) {
 326                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.size = 4; // bytes
 327                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.bits_unused = 4; // trailing unused bits
 328                 memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.buf,
 329                        (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID,4);
 330             }
 331             else
 332                 return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_eNB_IDeNB_IDhome_eNB_IDBufFail;
 333         }
 334         else if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits == cShortMacroENBID_18Bits) {
 335             // BIT STRING, SIZE 18
 336             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present = ENB_ID_PR_short_Macro_eNB_ID;
 337             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.buf = calloc(1,3);
 338             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.buf) {
 339                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.size = 3;
 340                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.bits_unused = 6; // trailing unused bits
 341                 memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.buf,
 342                        (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID,3);
 343             }
 344             else
 345                 return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_eNB_IDeNB_IDshort_Macro_eNB_IDBufFail;
 346         }
 347         else if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits == clongMacroENBIDP_21Bits) {
 348             // BIT STRING, SIZE 21
 349             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present = ENB_ID_PR_long_Macro_eNB_ID;
 350             pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.buf = calloc(1,3);
 351             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.buf) {
 352                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.size = 3; // bytes
 353                 pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.bits_unused = 3; // trailing unused bits
 354                 memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.buf,
 355                        (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID,3);
 356             }
 357             else
 358                 return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_eNB_IDeNB_IDlong_Macro_eNB_IDBufFail;
 359         }
 360         else
 361             return e2err_RICEventTriggerDefinitionIEValueFail_2;
 362     }
 363     else if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent) {
 364         // GlobalGNB-ID
 365         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.present = E2_Interface_ID_PR_global_gNB_ID;
 366
 367         // PLMN-Identity
 368         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.pLMN_Identity.size =
 369           pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength;
 370         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.pLMN_Identity.buf =
 371           calloc(1,pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength);
 372         if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.pLMN_Identity.buf) {
 373             memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.pLMN_Identity.buf,
 374                    (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal,
 375                     pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength);
 376         }
 377         else
 378             return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_gNB_IDpLMN_IdentityBufFail;
 379
 380         // GNB-ID, BIT STRING, SIZE 22..32
 381         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.size = 4;  //32bits
 382         pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.buf = calloc(1, 4);
 383         if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.buf) {
 384             memcpy(pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.buf,
 385                    (void*)&pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID,4); //32bits
 386         }
 387         else
 388             return e2err_RICIndicationAllocRICEventTriggerDefinitionglobal_gNB_IDgNB_IDBufFail;
 389     }
 390     else
 391         return e2err_RICEventTriggerDefinitionIEValueFail_3;
 392
 393     // InterfaceDirection
 394     pE2SM_gNB_X2_eventTriggerDefinition->interfaceDirection = pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceDirection;
 395
 396     // InterfaceMessageType
 397     // ProcedureCode
 398     pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.procedureCode = pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.procedureCode;
 399
 400     // TypeOfMessage
 401     if(pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage == cE2InitiatingMessage)
 402         pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage = E2_TypeOfMessage_initiating_message;
 403     else if(pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage == cE2SuccessfulOutcome)
 404         pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage = E2_TypeOfMessage_successful_outcome;
 405     else if(pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage == cE2UnsuccessfulOutcome)
 406         pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage = E2_TypeOfMessage_unsuccessful_outcome;
 407     else
 408         return e2err_RICEventTriggerDefinitionIEValueFail_4;
 409
 410     // InterfaceProtocolIE-List, OPTIONAL. Not used in RIC currently
 411     if (pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceProtocolIEListPresent == true) {}
 412
 413     // Debug print
 414     if (debug)
 415         asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
 416
 417     // Encode
 418     size_t bufferSize = sizeof(pRICEventTriggerDefinition->octetString.data);
 419     asn_enc_rval_t rval;
 420     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition,
 421                                 pRICEventTriggerDefinition->octetString.data, bufferSize);
 422
 423     if(rval.encoded == -1) {
 424         sprintf(pLogBuffer,"Serialization of %s failed.", asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition.name);
 425         return e2err_RICEventTriggerDefinitionPackFail_1;
 426     }
 427     else if(rval.encoded > bufferSize) {
 428        sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",bufferSize, asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition.name, rval.encoded);
 429         return e2err_RICEventTriggerDefinitionPackFail_2;
 430     }
 431     else
 432     if (debug)
 433            sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition.name, bufferSize, rval.encoded);
 434
 435     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
 436
 437     pRICEventTriggerDefinition->octetString.contentLength = rval.encoded;
 438     return e2err_OK;
 439 }
 440
 441 //////////////////////////////////////////////////////////////////////
 442 uint64_t packRICEventTriggerDefinitionNRTFormat(char* pLogBuffer, RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
 443
 444     E2_E2SM_gNB_NRT_EventTriggerDefinition_t* pE2_E2SM_gNB_NRT_EventTriggerDefinition = calloc(1, sizeof(E2_E2SM_gNB_NRT_EventTriggerDefinition_t));
 445     if(pE2_E2SM_gNB_NRT_EventTriggerDefinition == NULL)
 446         return e2err_RICEventTriggerDefinitionAllocE2SM_gNB_NRT_eventTriggerDefinitionFail;
 447
 448     pE2_E2SM_gNB_NRT_EventTriggerDefinition->present = E2_E2SM_gNB_NRT_EventTriggerDefinition_PR_eventDefinition_Format1;
 449     pE2_E2SM_gNB_NRT_EventTriggerDefinition->choice.eventDefinition_Format1.triggerNature =
 450       pRICEventTriggerDefinition->e2SMgNBNRTEventTriggerDefinition.eventDefinitionFormat1.triggerNature;
 451
 452     // Debug print
 453     if (debug)
 454         asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, pE2_E2SM_gNB_NRT_EventTriggerDefinition);
 455
 456     // Encode
 457     size_t bufferSize = sizeof(pRICEventTriggerDefinition->octetString.data);
 458     asn_enc_rval_t rval;
 459     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, pE2_E2SM_gNB_NRT_EventTriggerDefinition,
 460                                 pRICEventTriggerDefinition->octetString.data, bufferSize);
 461
 462     if(rval.encoded == -1) {
 463         sprintf(pLogBuffer,"Serialization of %s failed.", asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition.name);
 464         return e2err_RICENRTventTriggerDefinitionPackFail_1;
 465     }
 466     else if(rval.encoded > bufferSize) {
 467        sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",bufferSize, asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition.name, rval.encoded);
 468         return e2err_RICNRTEventTriggerDefinitionPackFail_2;
 469     }
 470     else
 471     if (debug)
 472            sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition.name, bufferSize, rval.encoded);
 473
 474     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, pE2_E2SM_gNB_NRT_EventTriggerDefinition);
 475
 476     pRICEventTriggerDefinition->octetString.contentLength = rval.encoded;
 477     return e2err_OK;
 478 }
 479
 480 //////////////////////////////////////////////////////////////////////
 481 uint64_t packRICActionDefinition(char* pLogBuffer, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
 482
 483     if (pRICActionDefinitionChoice->actionDefinitionX2Format1Present ||
 484         pRICActionDefinitionChoice->actionDefinitionX2Format2Present) {
 485         // E2SM-gNB-X2-actionDefinition
 486         return packActionDefinitionX2Format(pLogBuffer,pRICActionDefinitionChoice);
 487     }
 488     else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present) {
 489         // E2SM-gNB-NRT-actionDefinition
 490         return packActionDefinitionNRTFormat(pLogBuffer,pRICActionDefinitionChoice);
 491     }
 492     else
 493         return e2err_RICSubscriptionRequestRICActionDefinitionEmpty;
 494 }
 495
 496 //////////////////////////////////////////////////////////////////////
 497 uint64_t packActionDefinitionX2Format(char* pLogBuffer, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
 498
 499     int result;
 500
 501     // E2SM-gNB-X2-actionDefinition
 502     E2_E2SM_gNB_X2_ActionDefinitionChoice_t* pE2_E2SM_gNB_X2_ActionDefinitionChoice = calloc(1, sizeof(E2_E2SM_gNB_X2_ActionDefinitionChoice_t));
 503     if (pE2_E2SM_gNB_X2_ActionDefinitionChoice == NULL) {
 504         return e2err_RICSubscriptionRequestAllocE2_E2SM_gNB_X2_ActionDefinitionChoiceFail;
 505     }
 506
 507     if (pRICActionDefinitionChoice->actionDefinitionX2Format1Present) {
 508
 509         // E2SM-gNB-X2-actionDefinition
 510         pE2_E2SM_gNB_X2_ActionDefinitionChoice->present = E2_E2SM_gNB_X2_ActionDefinitionChoice_PR_actionDefinition_Format1;
 511         pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.style_ID = pRICActionDefinitionChoice->actionDefinitionX2Format1->styleID;
 512
 513         if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterCount > 0) {
 514             struct E2_E2SM_gNB_X2_actionDefinition__actionParameter_List* pE2_E2SM_gNB_X2_actionDefinition__actionParameter_List =
 515             calloc(1, sizeof (struct E2_E2SM_gNB_X2_actionDefinition__actionParameter_List));
 516             uint64_t index = 0;
 517             while (index < pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterCount && index < E2_maxofRANParameters) {
 518                 E2_ActionParameter_Item_t* pE2_ActionParameter_Item = calloc(1, sizeof(E2_ActionParameter_Item_t));
 519                 if (pE2_ActionParameter_Item) {
 520                     pE2_ActionParameter_Item->actionParameter_ID = pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->parameterID;
 521                     if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueIntPresent) {
 522                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valueInt;
 523                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueInt =
 524                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueInt;
 525                     }
 526                     else if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueEnumPresent) {
 527                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valueEnum;
 528                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueEnum =
 529                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueIntPresent;
 530                     }
 531                     else if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBoolPresent) {
 532                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valueBool;
 533                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBool =
 534                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBool;
 535                     }
 536                     else if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitSPresent) {
 537                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valueBitS;
 538                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.size =
 539                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS.byteLength;
 540                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.bits_unused =
 541                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS.unusedBits;
 542                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.buf =
 543                         calloc(pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS.byteLength, 1);
 544                         if (pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.buf) {
 545                             memcpy(pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.buf,
 546                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS.data,
 547                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS.byteLength);
 548                         }
 549                         else
 550                             return e2err_RICSubscriptionRequestAllocactionParameterValueValueBitSFail;
 551                     }
 552                     else if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctSPresent) {
 553                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valueOctS;
 554                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.size =
 555                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctS.length;
 556                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.buf =
 557                         calloc(pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctS.length, 1);
 558                         if (pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.buf) {
 559                             memcpy(pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.buf,
 560                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctS.data,
 561                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctS.length);
 562                         }
 563                         else
 564                             return e2err_RICSubscriptionRequestAllocactionParameterValueValueOctSFail;
 565                     }
 566                     else if (pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtSPresent) {
 567                         pE2_ActionParameter_Item->actionParameter_Value.present = E2_ActionParameter_Value_PR_valuePrtS;
 568                         pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.size =
 569                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtS.length;
 570                         pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.buf =
 571                         calloc(pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtS.length ,1);
 572                         if (pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.buf) {
 573                             memcpy(pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.buf,
 574                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtS.data,
 575                                 pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtS.length);
 576                         }
 577                         else
 578                             return e2err_RICSubscriptionRequestAllocactionParameterValueValuePrtsSFail;
 579                     }
 580                     else
 581                         return e2err_RICSubscriptionRequestActionParameterItemFail;
 582
 583                     if ((result = asn_set_add(pE2_E2SM_gNB_X2_actionDefinition__actionParameter_List, pE2_ActionParameter_Item)) != 0)
 584                         return e2err_RICSubscriptionRequestAsn_set_addE2_ActionParameter_ItemFail;
 585                 }
 586                 else
 587                     return e2err_RICSubscriptionRequestAllocActionDefinitionFail;
 588                 index++;
 589             }
 590             pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.actionParameter_List = pE2_E2SM_gNB_X2_actionDefinition__actionParameter_List;
 591         }
 592     }
 593     else if (pRICActionDefinitionChoice->actionDefinitionX2Format2Present) {
 594
 595         // E2SM-gNB-X2-ActionDefinition-Format2
 596         pE2_E2SM_gNB_X2_ActionDefinitionChoice->present = E2_E2SM_gNB_X2_ActionDefinitionChoice_PR_actionDefinition_Format2;
 597
 598         if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupCount > 0) {
 599             struct E2_E2SM_gNB_X2_ActionDefinition_Format2__ranUEgroup_List* pE2_E2SM_gNB_X2_ActionDefinition_Format2__ranUEgroup_List =
 600             calloc(1, sizeof(struct E2_E2SM_gNB_X2_ActionDefinition_Format2__ranUEgroup_List));
 601
 602             uint64_t index = 0;
 603             while (index < pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupCount && index < E2_maxofUEgroup) {
 604
 605                 E2_RANueGroup_Item_t* pE2_RANueGroup_Item = calloc(1, sizeof(E2_RANueGroup_Item_t));
 606                 if (pE2_RANueGroup_Item) {
 607
 608                     struct E2_RANueGroupDefinition__ranUEgroupDef_List* pE2_RANueGroupDefinition__ranUEgroupDef_List =
 609                     calloc(1, sizeof (struct E2_RANueGroupDefinition__ranUEgroupDef_List));
 610
 611                     pE2_RANueGroup_Item->ranUEgroupID = pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupID;
 612
 613                     uint64_t index2 = 0;
 614                     while (index2 < pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefCount && index2 < E2_maxofRANParameters) {
 615                         E2_RANueGroupDef_Item_t* pE2_RANueGroupDef_Item = calloc(1, sizeof(E2_RANueGroupDef_Item_t));
 616                         if(pE2_RANueGroupDef_Item) {
 617                             pE2_RANueGroupDef_Item->ranParameter_ID = pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterID;
 618                             pE2_RANueGroupDef_Item->ranParameter_Test = pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterTest;
 619                             if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueIntPresent) {
 620                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueInt;
 621                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueInt =
 622                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueInt;
 623                             }
 624                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueEnum) {
 625                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueEnum;
 626                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueEnum =
 627                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueEnum;
 628                             }
 629                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBoolPresent) {
 630                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBool;
 631                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBool =
 632                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBool;
 633                             }
 634                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitSPresent) {
 635                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBitS;
 636                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.size =
 637                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS.byteLength;
 638                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.bits_unused =
 639                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS.unusedBits;
 640                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.buf =
 641                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS.byteLength, 1);
 642                                 if (pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.buf) {
 643                                     memcpy(pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.buf,
 644                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS.data,
 645                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS.byteLength);
 646                                 }
 647                                 else
 648                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValueValueBitSFail;
 649                             }
 650                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctSPresent) {
 651                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueOctS;
 652                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.size =
 653                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctS.length;
 654                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.buf =
 655                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctS.length, 1);
 656                                 if (pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.buf) {
 657                                     memcpy(pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.buf,
 658                                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctS.data,
 659                                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctS.length);
 660                                 }
 661                                 else
 662                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValueValueOctSFail;
 663                             }
 664                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtSPresent) {
 665                                 pE2_RANueGroupDef_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valuePrtS;
 666                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.size =
 667                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtS.length;
 668                                 pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.buf =
 669                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtS.length, 1);
 670                                 if (pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.buf) {
 671                                     memcpy(pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.buf,
 672                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtS.data,
 673                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtS.length);
 674                                 }
 675                                 else
 676                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValueValuePrtsSFail;
 677                             }
 678                             else
 679                                 return e2err_RICSubscriptionRequestRanranUeGroupDefItemParameterValueEmptyFail;
 680
 681                             if ((result = asn_set_add(pE2_RANueGroupDefinition__ranUEgroupDef_List, pE2_RANueGroupDef_Item)) != 0)
 682                                 return e2err_RICSubscriptionRequestAsn_set_addRANueGroupDef_ItemFail;
 683                             pE2_RANueGroup_Item->ranUEgroupDefinition.ranUEgroupDef_List = pE2_RANueGroupDefinition__ranUEgroupDef_List;
 684                         }
 685                         else
 686                             return e2err_RICSubscriptionRequestAllocE2_RANueGroupDef_ItemFail;
 687                         index2++;
 688                     }
 689
 690                     struct E2_RANimperativePolicy__ranImperativePolicy_List* pE2_RANimperativePolicy__ranImperativePolicy_List =
 691                     calloc(1, sizeof (struct E2_RANimperativePolicy__ranImperativePolicy_List));
 692
 693                     uint64_t index3 = 0;
 694                     while (index3 < pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterCount && index3 < E2_maxofRANParameters) {
 695                         E2_RANParameter_Item_t* pE2_RANParameter_Item = calloc(1, sizeof(E2_RANParameter_Item_t));
 696                         if (pE2_RANParameter_Item) {
 697                             pE2_RANParameter_Item->ranParameter_ID = pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterID;
 698                             if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueIntPresent) {
 699                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueInt;
 700                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueInt =
 701                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueInt;
 702                             }
 703                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueEnum) {
 704                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueEnum;
 705                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueEnum =
 706                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueEnum;
 707                             }
 708                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBoolPresent) {
 709                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBool;
 710                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueBool =
 711                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBool;
 712                             }
 713                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitSPresent) {
 714                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBitS;
 715                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.size =
 716                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS.byteLength;
 717                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.bits_unused =
 718                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS.unusedBits;
 719                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf =
 720                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS.byteLength, 1);
 721                                 if (pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf) {
 722                                     memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf,
 723                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS.data,
 724                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS.byteLength);
 725                                 }
 726                                 else
 727                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValue2ValueBitSFail;
 728                             }
 729                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctSPresent) {
 730                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueOctS;
 731                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.size =
 732                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctS.length;
 733                                 pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf =
 734                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctS.length, 1);
 735                                 if (pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf) {
 736                                     memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf,
 737                                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctS.data,
 738                                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctS.length);
 739                                 }
 740                                 else
 741                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValue2ValueOctSFail;
 742                             }
 743                             else if (pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtSPresent) {
 744                                 pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valuePrtS;
 745                                 pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.size =
 746                                 pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtS.length;
 747                                 pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf =
 748                                 calloc(pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtS.length, 1);
 749                                 if (pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf) {
 750                                     memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf,
 751                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtS.data,
 752                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtS.length);
 753                                 }
 754                                 else
 755                                     return e2err_RICSubscriptionRequestAllocactionRanParameterValue2ValuePrtsSFail;
 756                             }
 757                             else
 758                                 return e2err_RICSubscriptionRequestRanParameterItemRanParameterValueEmptyFail;
 759
 760                             if ((result = asn_set_add(pE2_RANimperativePolicy__ranImperativePolicy_List, pE2_RANParameter_Item)) != 0)
 761                                 return e2err_RICSubscriptionRequestAsn_set_addE2_RANParameter_ItemFail;
 762                             pE2_RANueGroup_Item->ranPolicy.ranImperativePolicy_List = pE2_RANimperativePolicy__ranImperativePolicy_List;
 763                         }
 764                         else
 765                             return e2err_RICSubscriptionRequestAllocActionDefinitionFail;
 766                         index3++;
 767                     }
 768
 769                     const int result = asn_set_add(pE2_E2SM_gNB_X2_ActionDefinition_Format2__ranUEgroup_List, pE2_RANueGroup_Item);
 770                     if (result != 0)
 771                     printf("asn_set_add() failed\n");
 772                 }
 773                 else
 774                     return e2err_RICSubscriptionRequestAllocRANParameter_ItemFail;
 775                 index++;
 776             }
 777             pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format2.ranUEgroup_List = pE2_E2SM_gNB_X2_ActionDefinition_Format2__ranUEgroup_List;
 778         }
 779     }
 780     else {
 781         return e2err_RICSubscriptionRequestRICActionDefinitionEmptyE2_E2SM_gNB_X2_actionDefinition;
 782     }
 783
 784     // Debug print
 785     if (debug)
 786         asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
 787
 788     // Encode
 789     size_t bufferSize = sizeof(pRICActionDefinitionChoice->octetString.data);
 790     asn_enc_rval_t rval;
 791     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice,
 792                                 pRICActionDefinitionChoice->octetString.data, bufferSize);
 793     if(rval.encoded == -1) {
 794         sprintf(pLogBuffer,"Serialization of %s failed.", asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice.name);
 795         return e2err_RICActionDefinitionChoicePackFail_1;
 796     }
 797     else if(rval.encoded > bufferSize) {
 798        sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",bufferSize, asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice.name, rval.encoded);
 799         return e2err_RICActionDefinitionChoicePackFail_2;
 800     }
 801     else
 802     if (debug)
 803            sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice.name, bufferSize, rval.encoded);
 804
 805     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
 806
 807     pRICActionDefinitionChoice->octetString.contentLength = rval.encoded;
 808     return e2err_OK;
 809 }
 810
 811 //////////////////////////////////////////////////////////////////////
 812 uint64_t packActionDefinitionNRTFormat(char* pLogBuffer, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
 813
 814     // E2SM-gNB-NRT-actionDefinition
 815     E2_E2SM_gNB_NRT_ActionDefinition_t* pE2_E2SM_gNB_NRT_ActionDefinition = calloc(1, sizeof(E2_E2SM_gNB_NRT_ActionDefinition_t));
 816     if (pE2_E2SM_gNB_NRT_ActionDefinition == NULL)
 817         return e2err_RICSubscriptionRequestAllocE2_E2SM_gNB_NRT_ActionDefinitionFail;
 818
 819     if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present) {
 820
 821         // E2SM-gNB-NRT-ActionDefinition-Format1
 822         pE2_E2SM_gNB_NRT_ActionDefinition->present = E2_E2SM_gNB_NRT_ActionDefinition_PR_actionDefinition_Format1;
 823
 824         struct E2_E2SM_gNB_NRT_ActionDefinition_Format1__ranParameter_List* pE2_E2SM_gNB_NRT_ActionDefinition_Format1__ranParameter_List =
 825           calloc(1, sizeof(struct E2_E2SM_gNB_NRT_ActionDefinition_Format1__ranParameter_List));
 826
 827         uint64_t index = 0;
 828         while (index <  pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterCount && index < E2_maxofRANParameters) {
 829             E2_RANParameter_Item_t* pE2_RANParameter_Item = calloc(1, sizeof(E2_RANParameter_Item_t));
 830             if (pE2_RANParameter_Item) {
 831                 pE2_RANParameter_Item->ranParameter_ID = pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterID;
 832                 if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueIntPresent) {
 833                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueInt;
 834                     pE2_RANParameter_Item->ranParameter_Value.choice.valueInt =
 835                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueInt;
 836                 }
 837                 else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnum) {
 838                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueEnum;
 839                     pE2_RANParameter_Item->ranParameter_Value.choice.valueEnum =
 840                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnum;
 841                 }
 842                 else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBoolPresent) {
 843                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBool;
 844                     pE2_RANParameter_Item->ranParameter_Value.choice.valueBool =
 845                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBool;
 846                 }
 847                 else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitSPresent) {
 848                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueBitS;
 849                     pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.size =
 850                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS.byteLength;
 851                     pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.bits_unused =
 852                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS.unusedBits;
 853                     pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf =
 854                       calloc(pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS.byteLength, 1);
 855                     if (pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf) {
 856                         memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf,
 857                                pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS.data,
 858                                pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS.byteLength);
 859                       }
 860                       else
 861                         return e2err_RICSubscriptionRequestAllocactionNRTRanParameterValue2ValueBitSFail;
 862                 }
 863                 else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctSPresent) {
 864                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valueOctS;
 865                     pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.size =
 866                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS.length;
 867                       pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf =
 868                       calloc(pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS.length, 1);
 869                       if (pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf) {
 870                           memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf,
 871                                  pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS.data,
 872                                  pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS.length);
 873                       }
 874                       else
 875                         return e2err_RICSubscriptionRequestAllocactionNRTRanParameterValue2ValueOctSFail;
 876                 }
 877                 else if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtSPresent) {
 878                     pE2_RANParameter_Item->ranParameter_Value.present = E2_RANParameter_Value_PR_valuePrtS;
 879                     pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.size =
 880                       pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS.length;
 881                     pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf =
 882                       calloc(pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS.length, 1);
 883                     if (pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf) {
 884                         memcpy(pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf,
 885                                pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS.data,
 886                                pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS.length);
 887                       }
 888                       else
 889                         return e2err_RICSubscriptionRequestAllocactionNRTRanParameterValue2ValuePrtsSFail;
 890                 }
 891                 else
 892                     return e2err_RICSubscriptionRequestRanParameterItemNRTRanParameterValueEmptyFail;
 893
 894                 int result;
 895                 if ((result = asn_set_add(pE2_E2SM_gNB_NRT_ActionDefinition_Format1__ranParameter_List, pE2_RANParameter_Item)) != 0)
 896                     return e2err_RICSubscriptionRequestAsn_set_addE2_NRTRANParameter_ItemFail;
 897                 pE2_E2SM_gNB_NRT_ActionDefinition->choice.actionDefinition_Format1.ranParameter_List = pE2_E2SM_gNB_NRT_ActionDefinition_Format1__ranParameter_List;
 898             }
 899             else
 900                 return e2err_RICSubscriptionRequestAllocNRTRANParameter_ItemFail;
 901             index++;
 902         }
 903     }
 904     else
 905         return e2err_RICSubscriptionRequestRICActionDefinitionEmptyE2_E2SM_gNB_NRT_actionDefinition;
 906
 907     // Debug print
 908     if (debug)
 909         asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
 910
 911     // Encode
 912     size_t bufferSize = sizeof(pRICActionDefinitionChoice->octetString.data);
 913     asn_enc_rval_t rval;
 914     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition,
 915                                 pRICActionDefinitionChoice->octetString.data, bufferSize);
 916     if(rval.encoded == -1) {
 917         sprintf(pLogBuffer,"Serialization of %s failed.", asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name);
 918         return e2err_RICActionDefinitionChoicePackFail_1;
 919     }
 920     else if(rval.encoded > bufferSize) {
 921        sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",bufferSize, asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, rval.encoded);
 922         return e2err_RICActionDefinitionChoicePackFail_2;
 923     }
 924     else
 925     if (debug)
 926            sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, bufferSize, rval.encoded);
 927
 928     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
 929
 930     pRICActionDefinitionChoice->octetString.contentLength = rval.encoded;
 931     return e2err_OK;
 932 }
 933
 934 //////////////////////////////////////////////////////////////////////
 935 uint64_t packRICSubscriptionResponse(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
 936
 937     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 938     if(pE2AP_PDU)
 939         {
 940         pE2AP_PDU->present = E2AP_PDU_PR_successfulOutcome;
 941         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscription;
 942         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 943         pE2AP_PDU->choice.initiatingMessage.value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
 944
 945         // RICrequestID
 946         RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 947         if (pRICsubscriptionResponse_IEs) {
 948             pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RICrequestID;
 949             pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
 950             pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
 951             pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionResponse->ricRequestID.ricRequestorID;
 952             pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionResponse->ricRequestID.ricInstanceID;
 953             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
 954         }
 955         else
 956             return e2err_RICSubscriptionResponseAllocRICrequestIDFail;
 957
 958         // RANfunctionID
 959         pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 960         if (pRICsubscriptionResponse_IEs) {
 961             pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 962             pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
 963             pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
 964             pRICsubscriptionResponse_IEs->value.choice.RANfunctionID = pRICSubscriptionResponse->ranFunctionID;
 965             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
 966         }
 967         else
 968             return e2err_RICSubscriptionResponseAllocRANfunctionIDFail;
 969
 970         // RICaction-Admitted list
 971         pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 972         if (pRICsubscriptionResponse_IEs) {
 973             pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RICactions_Admitted;
 974             pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
 975             pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 976
 977             uint64_t index = 0;
 978             while (index < pRICSubscriptionResponse->ricActionAdmittedList.contentLength && index < maxofRICactionID) {
 979
 980                 RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs = calloc(1, sizeof (RICaction_Admitted_ItemIEs_t));
 981                 if (pRICaction_Admitted_ItemIEs)
 982                 {
 983                     pRICaction_Admitted_ItemIEs->id = ProtocolIE_ID_id_RICaction_Admitted_Item;
 984                     pRICaction_Admitted_ItemIEs->criticality = Criticality_reject;
 985                     pRICaction_Admitted_ItemIEs->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 986
 987                     // RICActionID
 988                     pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID = pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index];
 989                     ASN_SEQUENCE_ADD(&pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list, pRICaction_Admitted_ItemIEs);
 990                 }
 991                 else
 992                     return e2err_RICSubscriptionResponseAllocRICaction_Admitted_ItemIEsFail;
 993                 index++;
 994             }
 995         }
 996         else
 997             return e2err_RICSubscriptionResponseAllocRICActionAdmittedListFail;
 998
 999         ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
1000
1001         // RICaction-NotAdmitted list, OPTIONAL
1002         if (pRICSubscriptionResponse->ricActionNotAdmittedListPresent) {
1003             pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
1004             if (pRICsubscriptionResponse_IEs) {
1005                 pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
1006                 pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
1007                 pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
1008
1009                 uint64_t index = 0;
1010                 while (index < pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength && index < maxofRICactionID) {
1011
1012                     RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs = calloc(1, sizeof (RICaction_NotAdmitted_ItemIEs_t));
1013                     if (pRICaction_NotAdmitted_ItemIEs)
1014                     {
1015                         pRICaction_NotAdmitted_ItemIEs->id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item;
1016                         pRICaction_NotAdmitted_ItemIEs->criticality = Criticality_reject;
1017                         pRICaction_NotAdmitted_ItemIEs->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
1018
1019                         // RICActionID
1020                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID =
1021                           pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID;
1022
1023                         // RICCause
1024                         if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricRequest) {
1025                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricRequest;
1026                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest =
1027                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1028                         }
1029                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricService) {
1030                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricService;
1031                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService =
1032                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1033                         }
1034                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_transport) {
1035                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_transport;
1036                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport =
1037                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1038                         }
1039                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_protocol) {
1040                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_protocol;
1041                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol =
1042                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1043                         }
1044                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_misc) {
1045                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_misc;
1046                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc =
1047                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1048                         }
1049                         ASN_SEQUENCE_ADD(&pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list, pRICaction_NotAdmitted_ItemIEs);
1050                     }
1051                     else
1052                         return e2err_RICSubscriptionResponseAllocRICaction_NotAdmitted_ItemIEsFail;
1053                     index++;
1054                 }
1055             }
1056             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
1057         }
1058
1059         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1060             return e2err_OK;
1061         else
1062             return e2err_RICSubscriptionResponseEncodeFail;
1063     }
1064     return e2err_RICSubscriptionResponseAllocE2AP_PDUFail;
1065 }
1066
1067 //////////////////////////////////////////////////////////////////////
1068 uint64_t packRICSubscriptionFailure(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
1069
1070     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1071     if(pE2AP_PDU)
1072         {
1073         pE2AP_PDU->present = E2AP_PDU_PR_unsuccessfulOutcome;
1074         pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode = ProcedureCode_id_RICsubscription;
1075         pE2AP_PDU->choice.unsuccessfulOutcome.criticality = Criticality_ignore;
1076         pE2AP_PDU->choice.unsuccessfulOutcome.value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
1077
1078         // RICrequestID
1079         RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
1080         if (pRICsubscriptionFailure_IEs) {
1081             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_RICrequestID;
1082             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
1083             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
1084             pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionFailure->ricRequestID.ricRequestorID;
1085             pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionFailure->ricRequestID.ricInstanceID;
1086             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
1087         }
1088         else
1089             return e2err_RICSubscriptionFailureAllocRICrequestIDFail;
1090
1091         // RANfunctionID
1092         pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
1093         if (pRICsubscriptionFailure_IEs) {
1094             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_RANfunctionID;
1095             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
1096             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
1097             pRICsubscriptionFailure_IEs->value.choice.RANfunctionID = pRICSubscriptionFailure->ranFunctionID;
1098             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
1099         }
1100         else
1101             return e2err_RICSubscriptionFailureAllocRANfunctionIDFail;
1102
1103         // RICaction-NotAdmitted list
1104         pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
1105         if (pRICsubscriptionFailure_IEs) {
1106             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
1107             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
1108             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List;
1109
1110             uint64_t index = 0;
1111             while (index < pRICSubscriptionFailure->ricActionNotAdmittedList.contentLength && index < maxofRICactionID) {
1112
1113                 RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs = calloc(1, sizeof (RICaction_NotAdmitted_ItemIEs_t));
1114                 if (pRICaction_NotAdmitted_ItemIEs)
1115                 {
1116                     pRICaction_NotAdmitted_ItemIEs->id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item;
1117                     pRICaction_NotAdmitted_ItemIEs->criticality = Criticality_reject;
1118                     pRICaction_NotAdmitted_ItemIEs->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
1119
1120                     // RICActionID
1121                     pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID =
1122                       pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID;
1123
1124                     // RICCause
1125                     if (pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricRequest) {
1126                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricRequest;
1127                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest =
1128                           pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1129                     }
1130                     else if (pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricService) {
1131                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricService;
1132                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService =
1133                           pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1134                     }
1135                     else if (pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_transport) {
1136                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_transport;
1137                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport =
1138                           pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1139                     }
1140                     else if (pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_protocol) {
1141                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_protocol;
1142                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol =
1143                           pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1144                     }
1145                     else if (pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_misc) {
1146                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_misc;
1147                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc =
1148                           pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
1149                     }
1150                     ASN_SEQUENCE_ADD(&pRICsubscriptionFailure_IEs->value.choice.RICaction_NotAdmitted_List.list, pRICaction_NotAdmitted_ItemIEs);
1151                 }
1152                 else
1153                     return e2err_RICSubscriptionFailureAllocRICaction_NotAdmitted_ItemIEsFail;
1154                 index++;
1155             }
1156             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
1157         }
1158         else
1159             return e2err_RICSubscriptionFailureAllocRICActionAdmittedListFail;
1160
1161         // CriticalityDiagnostics, OPTIONAL. Not used in RIC
1162
1163         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1164             return e2err_OK;
1165         else
1166             return e2err_RICSubscriptionFailureEncodeFail;
1167     }
1168     else
1169         return e2err_RICSubscriptionFailureAllocE2AP_PDUFail;
1170 }
1171
1172 //////////////////////////////////////////////////////////////////////
1173 uint64_t packRICSubscriptionDeleteRequest(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
1174
1175     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1176     if(pE2AP_PDU)
1177         {
1178         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
1179         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
1180         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
1181         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest;
1182
1183         // RICrequestID
1184         RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
1185         if (pRICsubscriptionDeleteRequest_IEs) {
1186             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
1187             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
1188             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
1189             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID;
1190             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID;
1191             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
1192         }
1193         else
1194             return e2err_RICSubscriptionDeleteRequestAllocRICrequestIDFail;
1195
1196         // RANfunctionID
1197         pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
1198         if (pRICsubscriptionDeleteRequest_IEs) {
1199             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
1200             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
1201             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
1202             pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteRequest->ranFunctionID;
1203             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
1204         }
1205         else
1206             return e2err_RICSubscriptionDeleteRequestAllocRANfunctionIDFail;
1207
1208         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1209             return e2err_OK;
1210         else
1211             return e2err_RICSubscriptionDeleteRequestEncodeFail;
1212     }
1213     else
1214         return e2err_RICSubscriptionDeleteRequestAllocE2AP_PDUFail;
1215 }
1216
1217 //////////////////////////////////////////////////////////////////////
1218 uint64_t packRICSubscriptionDeleteResponse(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
1219
1220     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1221     if(pE2AP_PDU)
1222         {
1223         pE2AP_PDU->present = E2AP_PDU_PR_successfulOutcome;
1224         pE2AP_PDU->choice.successfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
1225         pE2AP_PDU->choice.successfulOutcome.criticality = Criticality_ignore;
1226         pE2AP_PDU->choice.successfulOutcome.value.present = SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse;
1227
1228         // RICrequestID
1229         RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
1230         if (pRICsubscriptionDeleteResponse_IEs) {
1231             pRICsubscriptionDeleteResponse_IEs->id = ProtocolIE_ID_id_RICrequestID;
1232             pRICsubscriptionDeleteResponse_IEs->criticality = Criticality_reject;
1233             pRICsubscriptionDeleteResponse_IEs->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
1234             pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID;
1235             pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID;
1236             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs);
1237         }
1238         else
1239             return e2err_RICSubscriptionDeleteResponseAllocRICrequestIDFail;
1240
1241         // RANfunctionID
1242         pRICsubscriptionDeleteResponse_IEs = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
1243         if (pRICsubscriptionDeleteResponse_IEs) {
1244             pRICsubscriptionDeleteResponse_IEs->id = ProtocolIE_ID_id_RANfunctionID;
1245             pRICsubscriptionDeleteResponse_IEs->criticality = Criticality_reject;
1246             pRICsubscriptionDeleteResponse_IEs->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
1247             pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteResponse->ranFunctionID;
1248             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs);
1249         }
1250         else
1251             return e2err_RICSubscriptionDeleteResponseAllocRANfunctionIDFail;
1252
1253         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1254             return e2err_OK;
1255         else
1256             return e2err_RICSubscriptionDeleteResponseEncodeFail;
1257     }
1258     else
1259         return e2err_RICSubscriptionDeleteResponseAllocE2AP_PDUFail;
1260 }
1261
1262 uint64_t packRICSubscriptionDeleteFailure(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
1263
1264     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1265     if(pE2AP_PDU)
1266         {
1267         pE2AP_PDU->present = E2AP_PDU_PR_unsuccessfulOutcome;
1268         pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
1269         pE2AP_PDU->choice.unsuccessfulOutcome.criticality = Criticality_ignore;
1270         pE2AP_PDU->choice.unsuccessfulOutcome.value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
1271
1272         // RICrequestID
1273         RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
1274         if (pRICsubscriptionDeleteFailure_IEs) {
1275             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_RICrequestID;
1276             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
1277             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
1278             pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID;
1279             pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID;
1280             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
1281         }
1282         else
1283             return e2err_RICSubscriptionDeleteFailureAllocRICrequestIDFail;
1284
1285         // RANfunctionID
1286         pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
1287         if (pRICsubscriptionDeleteFailure_IEs) {
1288             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_RANfunctionID;
1289             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
1290             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
1291             pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteFailure->ranFunctionID;
1292             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
1293         }
1294         else
1295             return e2err_RICSubscriptionDeleteFailureAllocRANfunctionIDFail;
1296
1297         // RICcause
1298         pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
1299         if (pRICsubscriptionDeleteFailure_IEs) {
1300             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_Cause;
1301             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
1302             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_Cause;
1303             if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricRequest) {
1304                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricRequest;
1305                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest =
1306                   pRICSubscriptionDeleteFailure->cause.causeVal;
1307             }
1308             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricService) {
1309                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricService;
1310                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService =
1311                   pRICSubscriptionDeleteFailure->cause.causeVal;
1312             }
1313             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_transport) {
1314                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_transport;
1315                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport =
1316                   pRICSubscriptionDeleteFailure->cause.causeVal;
1317             }
1318             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_protocol) {
1319                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_protocol;
1320                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol =
1321                   pRICSubscriptionDeleteFailure->cause.causeVal;
1322             }
1323             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_misc) {
1324                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_misc;
1325                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc =
1326                   pRICSubscriptionDeleteFailure->cause.causeVal;
1327             }
1328             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
1329         }
1330         else
1331             return e2err_RICSubscriptionDeleteFailureAllocRICcauseFail;
1332
1333         // CriticalityDiagnostics, OPTIONAL
1334
1335         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1336             return e2err_OK;
1337         else
1338             return e2err_RICSubscriptionDeleteFailureEncodeFail;
1339     }
1340     else
1341         return e2err_RICSubscriptionDeleteFailureAllocE2AP_PDUFail;
1342 }
1343
1344 //////////////////////////////////////////////////////////////////////
1345 e2ap_pdu_ptr_t* unpackE2AP_pdu(const size_t dataBufferSize, const byte* dataBuffer, char* pLogBuffer, E2MessageInfo_t* pMessageInfo) {
1346
1347     E2AP_PDU_t* pE2AP_PDU = 0;
1348     asn_dec_rval_t rval;
1349     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **)&pE2AP_PDU, dataBuffer, dataBufferSize);
1350     switch (rval.code) {
1351     case RC_OK:
1352         // Debug print
1353         if (debug) {
1354             sprintf(pLogBuffer,"Successfully decoded E2AP-PDU");
1355             asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
1356         }
1357
1358         if (pE2AP_PDU->present == E2AP_PDU_PR_initiatingMessage) {
1359             if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscription) {
1360                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionRequest) {
1361                     pMessageInfo->messageType = cE2InitiatingMessage;
1362                     pMessageInfo->messageId = cRICSubscriptionRequest;
1363                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1364                 }
1365                 else {
1366                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
1367                     return 0;
1368                 }
1369             }
1370             else if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
1371                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest) {
1372                     pMessageInfo->messageType = cE2InitiatingMessage;
1373                     pMessageInfo->messageId = cRICSubscriptionDeleteRequest;
1374                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1375                 }
1376                 else {
1377                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
1378                     return 0;
1379                 }
1380             }
1381             else {
1382                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.initiatingMessage.procedureCode);
1383                 return 0;
1384             }
1385         }
1386         else if (pE2AP_PDU->present == E2AP_PDU_PR_successfulOutcome) {
1387             if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
1388                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse) {
1389                     pMessageInfo->messageType = cE2SuccessfulOutcome;
1390                     pMessageInfo->messageId = cRICSubscriptionResponse;
1391                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1392                 }
1393                 else {
1394                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
1395                     return 0;
1396                 }
1397             }
1398             else if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
1399                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse) {
1400                     pMessageInfo->messageType = cE2SuccessfulOutcome;
1401                     pMessageInfo->messageId = cRICsubscriptionDeleteResponse;
1402                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1403                 }
1404                 else {
1405                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
1406                     return 0;
1407                 }
1408             }
1409             else {
1410                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.successfulOutcome.procedureCode);
1411                 return 0;
1412             }
1413         }
1414         else if (pE2AP_PDU->present == E2AP_PDU_PR_unsuccessfulOutcome) {
1415             if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
1416                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionFailure) {
1417                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
1418                     pMessageInfo->messageId = cRICSubscriptionFailure;
1419                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1420                 }
1421                 else {
1422                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
1423                     return 0;
1424                 }
1425             }
1426             else if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
1427                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure) {
1428                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
1429                     pMessageInfo->messageId = cRICsubscriptionDeleteFailure;
1430                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
1431                 }
1432                 else {
1433                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
1434                     return 0;
1435                 }
1436             }
1437         }
1438         else
1439             sprintf(pLogBuffer,"Decode failed. Invalid message type %u",pE2AP_PDU->present);
1440         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1441         return 0;
1442     case RC_WMORE:
1443         sprintf(pLogBuffer,"Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
1444         return 0;
1445     case RC_FAIL:
1446         sprintf(pLogBuffer,"Decode failed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
1447         return 0;
1448     default:
1449         return 0;
1450     }
1451 }
1452
1453 //////////////////////////////////////////////////////////////////////
1454 uint64_t getRICSubscriptionRequestData(mem_track_hdr_t * pDynMemHead, e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
1455
1456     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1457
1458     RICsubscriptionRequest_t *asnRicSubscriptionRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest;
1459     RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs;
1460
1461     // RICrequestID
1462     if (asnRicSubscriptionRequest->protocolIEs.list.count > 0 &&
1463         asnRicSubscriptionRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1464         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[0];
1465         pRICSubscriptionRequest->ricRequestID.ricRequestorID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID;
1466         pRICSubscriptionRequest->ricRequestID.ricInstanceID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID;
1467     }
1468     else {
1469         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1470         return e2err_RICsubscriptionRequestRICrequestIDMissing;
1471     }
1472
1473     // RANfunctionID
1474     if (asnRicSubscriptionRequest->protocolIEs.list.count > 1 &&
1475         asnRicSubscriptionRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1476         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[1];
1477         pRICSubscriptionRequest->ranFunctionID = pRICsubscriptionRequest_IEs->value.choice.RANfunctionID;
1478     }
1479     else {
1480         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1481         return e2err_RICsubscriptionRequestRANfunctionIDMissing;
1482     }
1483
1484     // RICsubscriptionDetails
1485     if (asnRicSubscriptionRequest->protocolIEs.list.count > 2 &&
1486         asnRicSubscriptionRequest->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICsubscriptionDetails) {
1487         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[2];
1488
1489         // Unpack EventTriggerDefinition
1490         RICeventTriggerDefinition_t* pRICeventTriggerDefinition =
1491           (RICeventTriggerDefinition_t*)&pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition;
1492         pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength = pRICeventTriggerDefinition->size;
1493         memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data, pRICeventTriggerDefinition->buf, pRICeventTriggerDefinition->size);
1494
1495         // Workaroud to spec problem. E2AP spec does not specify what speck (gNB-X2 or gNB-NRT) should be used when decoded EventTriggerDefinition and ActionDefinition
1496         // received received. Here we know that length of gNB-NRT EventTriggerDefinition octet string is always 1 at the moment.
1497         if (pRICeventTriggerDefinition->size == 1) {
1498             pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.E2SMgNBNRTEventTriggerDefinitionPresent = true;
1499             pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.E2SMgNBX2EventTriggerDefinitionPresent = false;
1500         }
1501         else {
1502             pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.E2SMgNBNRTEventTriggerDefinitionPresent = false;
1503             pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.E2SMgNBX2EventTriggerDefinitionPresent = true;
1504         }
1505
1506         uint64_t returnCode;
1507         if ((returnCode = getRICEventTriggerDefinitionData(&pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition)) != e2err_OK) {
1508             ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1509             return returnCode;
1510         }
1511
1512         // RICactions-ToBeSetup-List
1513         RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs;
1514         uint64_t index = 0;
1515         while (index < pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count)
1516         {
1517             pRICaction_ToBeSetup_ItemIEs = (RICaction_ToBeSetup_ItemIEs_t*)pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.array[index];
1518
1519             // RICActionID
1520             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID =
1521               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID;
1522
1523             // RICActionType
1524             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType =
1525               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType;
1526
1527             // RICactionDefinition, OPTIONAL
1528             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
1529             {
1530                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength =
1531                 pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size;
1532                 memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data,
1533                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf,
1534                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
1535
1536                 // Workaroud to spec problem. E2AP spec does not specify what speck (gNB-X2 or gNB-NRT) should be used when decoded EventTriggerDefinition and ActionDefinition
1537                 // received received. Here we know that length of gNB-NRT EventTriggerDefinition octet string is always 1 at the moment.
1538                 if (pRICeventTriggerDefinition->size == 1)
1539                     pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present = true;
1540                 else
1541                     pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present = false;
1542
1543                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = true;
1544                 if ((returnCode = getRICActionDefinitionData(pDynMemHead, &pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice)) != e2err_OK) {
1545                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1546                     return returnCode;
1547                 }
1548             }
1549             else
1550                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = false;
1551
1552             // RICsubsequentAction, OPTIONAL
1553             RICsubsequentAction_t* pRICsubsequentAction;
1554             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction)
1555             {
1556                 pRICsubsequentAction = pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction;
1557                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = true;
1558                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =
1559                   pRICsubsequentAction->ricSubsequentActionType;
1560                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =
1561                   pRICsubsequentAction->ricTimeToWait;
1562             }
1563             else
1564                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = false;
1565             index++;
1566         }
1567         pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = index;
1568     }
1569     else {
1570         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1571         return e2err_RICsubscriptionRequestICsubscriptionMissing;
1572     }
1573
1574     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1575     return e2err_OK;
1576 }
1577
1578 //////////////////////////////////////////////////////////////////////
1579 uint64_t getRICEventTriggerDefinitionData(RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
1580
1581     if (pRICEventTriggerDefinition->E2SMgNBX2EventTriggerDefinitionPresent)
1582         return getRICEventTriggerDefinitionDataX2Format(pRICEventTriggerDefinition);
1583     else if (pRICEventTriggerDefinition->E2SMgNBNRTEventTriggerDefinitionPresent)
1584         return getRICEventTriggerDefinitionDataNRTFormat(pRICEventTriggerDefinition);
1585     else
1586         return e2err_RICEventTriggerDefinitionEmptyDecodeDefaultFail;
1587 }
1588
1589 //////////////////////////////////////////////////////////////////////
1590 uint64_t getRICEventTriggerDefinitionDataX2Format(RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
1591
1592     E2_E2SM_gNB_X2_eventTriggerDefinition_t* pE2SM_gNB_X2_eventTriggerDefinition = 0;
1593     asn_dec_rval_t rval;
1594     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, (void **)&pE2SM_gNB_X2_eventTriggerDefinition,
1595                       pRICEventTriggerDefinition->octetString.data, pRICEventTriggerDefinition->octetString.contentLength);
1596     switch(rval.code) {
1597     case RC_OK:
1598         // Debug print
1599         if (debug) {
1600             printf("Successfully decoded E2SM_gNB_X2_eventTriggerDefinition");
1601             asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1602         }
1603
1604         // InterfaceID, GlobalENB-ID or GlobalGNB-ID
1605         if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.present == E2_Interface_ID_PR_global_eNB_ID) {
1606
1607             // GlobalENB-ID
1608             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent = true;
1609
1610             // PLMN-Identity
1611             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength =
1612               pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.size;
1613             memcpy(pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal,
1614               pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.buf,
1615               pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength);
1616
1617             //  ENB-ID
1618             IdOctects_t eNBOctects;
1619             memset(eNBOctects.octets, 0, sizeof(eNBOctects));
1620             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present == E2_ENB_ID_PR_macro_eNB_ID) {
1621                 // BIT STRING, SIZE 20
1622                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits = cMacroENBIDP_20Bits;
1623                 memcpy(eNBOctects.octets,pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.buf,
1624                   pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.macro_eNB_ID.size);
1625                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID = eNBOctects.nodeID;
1626             }
1627             else if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present == E2_ENB_ID_PR_home_eNB_ID) {
1628                 // BIT STRING, SIZE 28
1629                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits = cHomeENBID_28Bits;
1630                 memcpy(eNBOctects.octets,pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.buf,
1631                   pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.home_eNB_ID.size);
1632                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID = eNBOctects.nodeID;
1633             }
1634             else if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present == E2_ENB_ID_PR_short_Macro_eNB_ID) {
1635                 // BIT STRING, SIZE 18
1636                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits = cShortMacroENBID_18Bits;
1637                 memcpy(eNBOctects.octets,pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.buf,
1638                   pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.short_Macro_eNB_ID.size);
1639                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID = eNBOctects.nodeID;
1640             }
1641             else if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.present == E2_ENB_ID_PR_long_Macro_eNB_ID) {
1642                 // BIT STRING, SIZE 21
1643                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits =  clongMacroENBIDP_21Bits;
1644                 memcpy(eNBOctects.octets,pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.buf,
1645                   pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.eNB_ID.choice.long_Macro_eNB_ID.size);
1646                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID = eNBOctects.nodeID;
1647             }
1648             else {
1649                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent = false;
1650                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent = false;
1651                 ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1652                 return e2err_RICEventTriggerDefinitionIEValueFail_5;
1653             }
1654         }
1655         else if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.present == E2_Interface_ID_PR_global_gNB_ID) {
1656             // GlobalGNB-ID
1657             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent = true;
1658
1659             // PLMN-Identity
1660             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength =
1661               pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.size;
1662             memcpy(pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal,
1663               pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_eNB_ID.pLMN_Identity.buf,
1664               pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength);
1665
1666             // GNB-ID
1667             IdOctects_t gNBOctects;
1668             memset(gNBOctects.octets, 0, sizeof(gNBOctects));
1669             if (pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.present == E2_GNB_ID_PR_gNB_ID) {
1670                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.bits = pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.size;
1671                 memcpy(gNBOctects.octets, pE2SM_gNB_X2_eventTriggerDefinition->interface_ID.choice.global_gNB_ID.gNB_ID.choice.gNB_ID.buf,
1672                    pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.bits);
1673                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.nodeID = gNBOctects.nodeID;
1674             }
1675             else {
1676                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent = false;
1677                 pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent = false;
1678                 ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1679                 return e2err_RICEventTriggerDefinitionIEValueFail_6;
1680             }
1681         }
1682         else {
1683             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent = false;
1684             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent = false;
1685             ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1686             return e2err_RICEventTriggerDefinitionIEValueFail_7;
1687         }
1688
1689         // InterfaceDirection
1690         pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceDirection = pE2SM_gNB_X2_eventTriggerDefinition->interfaceDirection;
1691
1692         // InterfaceMessageType
1693         pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.procedureCode = pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.procedureCode;
1694
1695         if (pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage == E2_TypeOfMessage_initiating_message)
1696             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage = cE2InitiatingMessage;
1697         else if (pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage == E2_TypeOfMessage_successful_outcome)
1698             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage = cE2SuccessfulOutcome;
1699         else if (pE2SM_gNB_X2_eventTriggerDefinition->interfaceMessageType.typeOfMessage == E2_TypeOfMessage_unsuccessful_outcome)
1700             pRICEventTriggerDefinition->e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage = cE2UnsuccessfulOutcome;
1701         else {
1702             ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1703             return e2err_RICEventTriggerDefinitionIEValueFail_8;
1704         }
1705         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition, pE2SM_gNB_X2_eventTriggerDefinition);
1706         return e2err_OK;
1707     case RC_WMORE:
1708         if (debug)
1709             printf("Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",pRICEventTriggerDefinition->octetString.contentLength,
1710                    asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition.name, rval.consumed);
1711
1712         return e2err_RICEventTriggerDefinitionDecodeWMOREFail;
1713     case RC_FAIL:
1714         if (debug)
1715             printf("Decode failed. Buffer size %zu, %s, consumed %zu",pRICEventTriggerDefinition->octetString.contentLength,
1716                    asn_DEF_E2_E2SM_gNB_X2_eventTriggerDefinition.name, rval.consumed);
1717         return e2err_RICEventTriggerDefinitionDecodeFAIL;
1718     default:
1719         return e2err_RICEventTriggerDefinitionDecodeDefaultFail;
1720     }
1721 }
1722
1723 //////////////////////////////////////////////////////////////////////
1724 uint64_t getRICEventTriggerDefinitionDataNRTFormat(RICEventTriggerDefinition_t* pRICEventTriggerDefinition) {
1725
1726     E2_E2SM_gNB_NRT_EventTriggerDefinition_t* pE2_E2SM_gNB_NRT_EventTriggerDefinition = 0;
1727     asn_dec_rval_t rval;
1728     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, (void **)&pE2_E2SM_gNB_NRT_EventTriggerDefinition,
1729                       pRICEventTriggerDefinition->octetString.data, pRICEventTriggerDefinition->octetString.contentLength);
1730     switch(rval.code) {
1731     case RC_OK:
1732         // Debug print
1733         if (debug) {
1734             printf("Successfully decoded E2SM_gNB_X2_eventTriggerDefinition");
1735             asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, pE2_E2SM_gNB_NRT_EventTriggerDefinition);
1736         }
1737
1738         // NRT-TriggerNature
1739         if (pE2_E2SM_gNB_NRT_EventTriggerDefinition->present == E2_E2SM_gNB_NRT_EventTriggerDefinition_PR_eventDefinition_Format1) {
1740             pRICEventTriggerDefinition->E2SMgNBNRTEventTriggerDefinitionPresent = true;
1741             pRICEventTriggerDefinition->e2SMgNBNRTEventTriggerDefinition.eventDefinitionFormat1.triggerNature =
1742               pE2_E2SM_gNB_NRT_EventTriggerDefinition->choice.eventDefinition_Format1.triggerNature;
1743         }
1744         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition, pE2_E2SM_gNB_NRT_EventTriggerDefinition);
1745         return e2err_OK;
1746     case RC_WMORE:
1747         if (debug)
1748             printf("Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",pRICEventTriggerDefinition->octetString.contentLength,
1749                    asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition.name, rval.consumed);
1750
1751         return e2err_RICNRTEventTriggerDefinitionDecodeWMOREFail;
1752     case RC_FAIL:
1753         if (debug)
1754             printf("Decode failed. Buffer size %zu, %s, consumed %zu",pRICEventTriggerDefinition->octetString.contentLength,
1755                    asn_DEF_E2_E2SM_gNB_NRT_EventTriggerDefinition.name, rval.consumed);
1756         return e2err_RICNRTEventTriggerDefinitionDecodeFAIL;
1757     default:
1758         return e2err_RICNRTEventTriggerDefinitionDecodeDefaultFail;
1759     }
1760 }
1761
1762 //////////////////////////////////////////////////////////////////////
1763 uint64_t getRICActionDefinitionData(mem_track_hdr_t *pDynMemHead, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
1764
1765     if (pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present)
1766         return getRICActionDefinitionDataNRTFormat(pDynMemHead, pRICActionDefinitionChoice);
1767 //    if (pRICActionDefinitionChoice->actionDefinitionX2Format1Present || pRICActionDefinitionChoice->actionDefinitionX2Format2Present)
1768     else
1769         return getRICActionDefinitionDataX2Format(pDynMemHead, pRICActionDefinitionChoice);
1770 //    else
1771 //        return e2err_RICActionDefinitionChoiceEmptyFAIL;
1772 }
1773
1774 //////////////////////////////////////////////////////////////////////
1775 uint64_t getRICActionDefinitionDataX2Format(mem_track_hdr_t* pDynMemHead, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
1776
1777     E2_E2SM_gNB_X2_ActionDefinitionChoice_t* pE2_E2SM_gNB_X2_ActionDefinitionChoice = 0;
1778     asn_dec_rval_t rval;
1779     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, (void **)&pE2_E2SM_gNB_X2_ActionDefinitionChoice,
1780                       pRICActionDefinitionChoice->octetString.data, pRICActionDefinitionChoice->octetString.contentLength);
1781     switch(rval.code) {
1782     case RC_OK:
1783         // Debug print
1784         if (debug) {
1785             printf("Successfully decoded E2SM_gNB_X2_ActionDefinitionChoice\n");
1786             asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1787         }
1788         // ActionDefinitionChoice
1789         if (pE2_E2SM_gNB_X2_ActionDefinitionChoice->present == E2_E2SM_gNB_X2_ActionDefinitionChoice_PR_actionDefinition_Format1) {
1790
1791             // E2SM-gNB-X2-actionDefinition
1792             uint64_t status;
1793             if ((status = allocActionDefinitionX2Format1(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format1)) != e2err_OK)
1794                 return status;
1795             pRICActionDefinitionChoice->actionDefinitionX2Format1Present = true;
1796             pRICActionDefinitionChoice->actionDefinitionX2Format2Present = false;
1797             pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present = false;
1798             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterCount = 0;
1799             pRICActionDefinitionChoice->actionDefinitionX2Format1->styleID = pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.style_ID;
1800
1801             uint64_t index = 0;
1802             if (pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.actionParameter_List) {
1803                 while (index < pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.actionParameter_List->list.count) {
1804                     E2_ActionParameter_Item_t* pE2_ActionParameter_Item = pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format1.actionParameter_List->list.array[index];
1805                     if (pE2_ActionParameter_Item) {
1806                         pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->parameterID = pE2_ActionParameter_Item->actionParameter_ID;
1807                         if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valueInt) {
1808                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueIntPresent = true;
1809                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueInt =
1810                             pE2_ActionParameter_Item->actionParameter_Value.choice.valueInt;
1811                         }
1812                         else if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valueEnum) {
1813                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueEnumPresent = true;
1814                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueIntPresent =
1815                             pE2_ActionParameter_Item->actionParameter_Value.choice.valueEnum;
1816                         }
1817                         else if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valueBool) {
1818                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBoolPresent = true;
1819                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBool =
1820                             pE2_ActionParameter_Item->actionParameter_Value.choice.valueBool;
1821                         }
1822                         else if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valueBitS) {
1823                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitSPresent = true;
1824                             addBitString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueBitS,
1825                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.size,
1826                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.buf,
1827                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueBitS.bits_unused);
1828                         }
1829                         else if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valueOctS) {
1830                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctSPresent = true;
1831                             addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valueOctS,
1832                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.size,
1833                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valueOctS.buf);
1834                         }
1835                         else if (pE2_ActionParameter_Item->actionParameter_Value.present == E2_ActionParameter_Value_PR_valuePrtS) {
1836                             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtSPresent = true;
1837                             addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterItem->actionParameterValue.valuePrtS,
1838                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.size,
1839                                         pE2_ActionParameter_Item->actionParameter_Value.choice.valuePrtS.buf);
1840                         }
1841                         else {
1842                             ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1843                             return e2err_RICSubscriptionRequestActionParameterItemFail;
1844                         }
1845                     }
1846                     index++;
1847                 }
1848             }
1849             pRICActionDefinitionChoice->actionDefinitionX2Format1->actionParameterCount = index;
1850         }
1851         else if (pE2_E2SM_gNB_X2_ActionDefinitionChoice->present == E2_E2SM_gNB_X2_ActionDefinitionChoice_PR_actionDefinition_Format2) {
1852
1853             // E2SM-gNB-X2-ActionDefinition-Format2
1854             uint64_t status;
1855             if ((status = allocActionDefinitionX2Format2(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2)) != e2err_OK)
1856                 return status;
1857
1858             pRICActionDefinitionChoice->actionDefinitionX2Format2Present = true;
1859             pRICActionDefinitionChoice->actionDefinitionX2Format1Present = false;
1860             pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present = false;
1861             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupCount = 0;
1862             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem->ranUEgroupDefinition.ranUeGroupDefCount = 0;
1863             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem->ranPolicy.ranParameterCount = 0;
1864
1865             E2_E2SM_gNB_X2_ActionDefinition_Format2_t* pE2SM_gNB_X2_actionDefinition = &pE2_E2SM_gNB_X2_ActionDefinitionChoice->choice.actionDefinition_Format2;
1866             if(pE2SM_gNB_X2_actionDefinition) {
1867                 uint64_t index = 0;
1868                 if (pE2SM_gNB_X2_actionDefinition->ranUEgroup_List) {
1869                     while (index < pE2SM_gNB_X2_actionDefinition->ranUEgroup_List->list.count) {
1870                         E2_RANueGroup_Item_t* pE2_RANueGroup_Item = pE2SM_gNB_X2_actionDefinition->ranUEgroup_List->list.array[index];
1871                         if (pE2_RANueGroup_Item) {
1872                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupID = pE2_RANueGroup_Item->ranUEgroupID;
1873                             uint64_t index2 = 0;
1874                             while (index2 < pE2_RANueGroup_Item->ranUEgroupDefinition.ranUEgroupDef_List->list.count) {
1875                                 E2_RANueGroupDef_Item_t* pE2_RANueGroupDef_Item = pE2_RANueGroup_Item->ranUEgroupDefinition.ranUEgroupDef_List->list.array[index2];
1876                                 if(pE2_RANueGroupDef_Item) {
1877                                     pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterID = pE2_RANueGroupDef_Item->ranParameter_ID;
1878                                     pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterTest = pE2_RANueGroupDef_Item->ranParameter_Test;
1879                                     if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueInt) {
1880                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueIntPresent = true;
1881                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueInt =
1882                                           pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueInt;
1883                                     }
1884                                     else if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueEnum) {
1885                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueEnum = true;
1886                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueEnum =
1887                                           pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueEnum;
1888                                     }
1889                                     else if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueBool) {
1890                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBoolPresent = true;
1891                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBool =
1892                                           pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBool;
1893                                     }
1894                                     else if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueBitS) {
1895                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitSPresent = true;
1896                                         addBitString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueBitS,
1897                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.size,
1898                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.buf,
1899                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueBitS.bits_unused);
1900                                     }
1901                                     else if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueOctS) {
1902                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctSPresent = true;
1903                                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valueOctS,
1904                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.size,
1905                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valueOctS.buf);
1906                                     }
1907                                     else if (pE2_RANueGroupDef_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valuePrtS) {
1908                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtSPresent = true;
1909                                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefItem[index2].ranParameterValue.valuePrtS,
1910                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.size,
1911                                                      pE2_RANueGroupDef_Item->ranParameter_Value.choice.valuePrtS.buf);
1912                                     }
1913                                     else {
1914                                         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1915                                         return e2err_RICSubscriptionRequestRanranUeGroupDefItemParameterValueEmptyFail;
1916                                     }
1917                                 }
1918                                 else {
1919                                     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1920                                     return e2err_RICSubscriptionRequestAllocE2_RANueGroupDef_ItemFail;
1921                                 }
1922                                 index2++;
1923                             }
1924                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranUEgroupDefinition.ranUeGroupDefCount = index2;
1925
1926                             uint64_t index3 = 0;
1927                             while (index3 < pE2_RANueGroup_Item->ranPolicy.ranImperativePolicy_List->list.count) {
1928                                 E2_RANParameter_Item_t* pE2_RANParameter_Item = pE2_RANueGroup_Item->ranPolicy.ranImperativePolicy_List->list.array[index3];
1929                                 if (pE2_RANParameter_Item) {
1930                                     pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterID = pE2_RANParameter_Item->ranParameter_ID;
1931                                     if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueInt) {
1932                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueIntPresent = true;
1933                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueInt =
1934                                           pE2_RANParameter_Item->ranParameter_Value.choice.valueInt;
1935                                     }
1936                                     else if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueEnum) {
1937                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueEnum = true;
1938                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueEnum =
1939                                           pE2_RANParameter_Item->ranParameter_Value.choice.valueEnum;
1940                                     }
1941                                     else if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueBool) {
1942                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBoolPresent = true;
1943                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBool =
1944                                           pE2_RANParameter_Item->ranParameter_Value.choice.valueBool;
1945                                     }
1946                                     else if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueBitS) {
1947                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitSPresent = true;
1948                                         addBitString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueBitS,
1949                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.size,
1950                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.buf,
1951                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valueBitS.bits_unused);
1952                                     }
1953                                     else if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valueOctS) {
1954                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctSPresent = true;
1955                                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valueOctS,
1956                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.size,
1957                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valueOctS.buf);
1958                                     }
1959                                     else if (pE2_RANParameter_Item->ranParameter_Value.present == E2_RANParameter_Value_PR_valuePrtS) {
1960                                         pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtSPresent = true;
1961                                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterItem[index3].ranParameterValue.valuePrtS,
1962                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.size,
1963                                                      pE2_RANParameter_Item->ranParameter_Value.choice.valuePrtS.buf);
1964                                     }
1965                                     else {
1966                                         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1967                                         return e2err_RICSubscriptionRequestRanParameterItemRanParameterValueEmptyFail;
1968                                     }
1969                                 }
1970                                 else {
1971                                     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1972                                     return e2err_RICSubscriptionRequestAllocActionDefinitionFail;
1973                                 }
1974                                 index3++;
1975                             }
1976                             pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupItem[index].ranPolicy.ranParameterCount = index3;
1977                         }
1978                         else {
1979                             ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1980                             return e2err_RICSubscriptionRequestAllocRANParameter_ItemFail;
1981                         }
1982                         index++;
1983                     }
1984                }
1985                pRICActionDefinitionChoice->actionDefinitionX2Format2->ranUeGroupCount = index;
1986             }
1987         }
1988         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice, pE2_E2SM_gNB_X2_ActionDefinitionChoice);
1989         return e2err_OK;
1990     case RC_WMORE:
1991         if (debug)
1992             printf("Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",pRICActionDefinitionChoice->octetString.contentLength,
1993                    asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice.name, rval.consumed);
1994
1995         return e2err_RICActionDefinitionChoiceWMOREFail;
1996     case RC_FAIL:
1997         if (debug)
1998             printf("Decode failed. Buffer size %zu, %s, consumed %zu",pRICActionDefinitionChoice->octetString.contentLength,
1999                    asn_DEF_E2_E2SM_gNB_X2_ActionDefinitionChoice.name, rval.consumed);
2000
2001         return e2err_RICActionDefinitionChoiceDecodeFAIL;
2002     default:
2003         return e2err_RICActionDefinitionChoiceDecodeDefaultFail;
2004     }
2005 }
2006
2007 //////////////////////////////////////////////////////////////////////
2008 uint64_t getRICActionDefinitionDataNRTFormat(mem_track_hdr_t* pDynMemHead, RICActionDefinitionChoice_t* pRICActionDefinitionChoice) {
2009
2010     E2_E2SM_gNB_NRT_ActionDefinition_t* pE2_E2SM_gNB_NRT_ActionDefinition = 0;
2011     asn_dec_rval_t rval;
2012     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, (void **)&pE2_E2SM_gNB_NRT_ActionDefinition,
2013                       pRICActionDefinitionChoice->octetString.data, pRICActionDefinitionChoice->octetString.contentLength);
2014     switch(rval.code) {
2015     case RC_OK:
2016         // Debug print
2017         if (debug) {
2018             printf("Successfully decoded E2SM_gNB_NRT_ActionDefinition");
2019             asn_fprint(stdout, &asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2020         }
2021
2022         // ActionDefinitionChoice
2023         if (pE2_E2SM_gNB_NRT_ActionDefinition->present == E2_E2SM_gNB_NRT_ActionDefinition_PR_actionDefinition_Format1) {
2024
2025             // E2SM-gNB-NRT-actionDefinition
2026             uint64_t status;
2027             if ((status = allocActionDefinitionNRTFormat1(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1)) != e2err_OK)
2028                 return status;
2029
2030             pRICActionDefinitionChoice->actionDefinitionNRTFormat1Present = true;
2031             pRICActionDefinitionChoice->actionDefinitionX2Format1Present = false;
2032             pRICActionDefinitionChoice->actionDefinitionX2Format2Present = false;
2033             pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterCount = 0;
2034             uint64_t index = 0;
2035             while (index < pE2_E2SM_gNB_NRT_ActionDefinition->choice.actionDefinition_Format1.ranParameter_List->list.count) {
2036                 E2_RANparameter_Item_t* pE2_RANparameter_Item = pE2_E2SM_gNB_NRT_ActionDefinition->choice.actionDefinition_Format1.ranParameter_List->list.array[index];
2037                 if (pE2_RANparameter_Item) {
2038                     pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterID = pE2_RANparameter_Item->ranParameter_ID;
2039
2040                     if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueInt) {
2041                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueIntPresent = true;
2042                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueInt =
2043                           pE2_RANparameter_Item->ranParameter_Value.choice.valueInt;
2044                     }
2045                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueEnum) {
2046                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnumPresent = true;
2047                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnum =
2048                           pE2_RANparameter_Item->ranParameter_Value.choice.valueEnum;
2049                     }
2050                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueBool) {
2051                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBoolPresent = true;
2052                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBool =
2053                           pE2_RANparameter_Item->ranParameter_Value.choice.valueBool;
2054                     }
2055                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueBitS) {
2056                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitSPresent = true;
2057                         addBitString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS,
2058                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.size,
2059                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.buf,
2060                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.bits_unused);
2061                     }
2062                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueOctS) {
2063                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctSPresent = true;
2064                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS,
2065                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueOctS.size,
2066                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueOctS.buf);
2067                     }
2068                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valuePrtS) {
2069                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtSPresent = true;
2070                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS,
2071                                      pE2_RANparameter_Item->ranParameter_Value.choice.valuePrtS.size,
2072                                      pE2_RANparameter_Item->ranParameter_Value.choice.valuePrtS.buf);
2073                     }
2074                     else {
2075                         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2076                         return e2err_RICSubscriptionRequestNRTRanParameterItemRanParameterValueEmptyFail;
2077                     }
2078                 }
2079                 else {
2080                     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2081                     return e2err_RICSubscriptionRequestNRTAllocActionDefinitionFail;
2082                 }
2083                 index++;
2084             }
2085             pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterCount = index;
2086         }
2087         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2088         return e2err_OK;
2089     case RC_WMORE:
2090         if (debug)
2091             printf("Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",pRICActionDefinitionChoice->octetString.contentLength,
2092                    asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, rval.consumed);
2093
2094         return e2err_RICNRTActionDefinitionChoiceWMOREFail;
2095     case RC_FAIL:
2096         if (debug)
2097             printf("Decode failed. Buffer size %zu, %s, consumed %zu",pRICActionDefinitionChoice->octetString.contentLength,
2098                    asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, rval.consumed);
2099
2100         return e2err_RICNRTActionDefinitionChoiceDecodeFAIL;
2101     default:
2102         return e2err_RICNRTActionDefinitionChoiceDecodeDefaultFail;
2103     }
2104 }
2105 //////////////////////////////////////////////////////////////////////
2106 uint64_t getRICSubscriptionResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
2107
2108     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2109
2110     RICsubscriptionResponse_t *asnRicSubscriptionResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse;
2111     RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs;
2112
2113     // RICrequestID
2114     if (asnRicSubscriptionResponse->protocolIEs.list.count > 0 &&
2115         asnRicSubscriptionResponse->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2116         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[0];
2117         pRICSubscriptionResponse->ricRequestID.ricRequestorID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricRequestorID;
2118         pRICSubscriptionResponse->ricRequestID.ricInstanceID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricInstanceID;
2119     }
2120     else {
2121         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2122         return e2err_RICsubscriptionResponseRICrequestIDMissing;
2123     }
2124
2125     // RANfunctionID
2126     if (asnRicSubscriptionResponse->protocolIEs.list.count > 1 &&
2127         asnRicSubscriptionResponse->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2128         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[1];
2129         pRICSubscriptionResponse->ranFunctionID = pRICsubscriptionResponse_IEs->value.choice.RANfunctionID;
2130     }
2131     else {
2132         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2133         return e2err_RICsubscriptionResponseRANfunctionIDMissing;
2134     }
2135
2136     // RICaction-Admitted-List
2137     if (asnRicSubscriptionResponse->protocolIEs.list.count > 2  &&
2138         asnRicSubscriptionResponse->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICactions_Admitted) {
2139         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[2];
2140         pRICSubscriptionResponse->ricActionAdmittedList.contentLength = 0;
2141         uint64_t index = 0;
2142         while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.count)) {
2143             RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs =
2144               (RICaction_Admitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.array[index];
2145
2146             // RICActionID
2147             pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index] =
2148               pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID;
2149             index++;
2150         }
2151         pRICSubscriptionResponse->ricActionAdmittedList.contentLength = index;
2152     }
2153     else {
2154         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2155         return e2err_RICsubscriptionResponseRICaction_Admitted_ListMissing;
2156     }
2157
2158     // RICaction-NotAdmitted-List, OPTIONAL
2159     if (asnRicSubscriptionResponse->protocolIEs.list.count > 3 &&
2160         asnRicSubscriptionResponse->protocolIEs.list.array[3]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
2161         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[3];
2162         if (pRICsubscriptionResponse_IEs->value.present == RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List) {
2163             pRICSubscriptionResponse->ricActionNotAdmittedListPresent = true;
2164             pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
2165             uint64_t index = 0;
2166             while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
2167                 RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
2168                   (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
2169
2170                 // RICActionID
2171                 pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
2172                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
2173
2174                 //  RICcause
2175                 if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
2176                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
2177                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2178                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
2179                 }
2180                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
2181                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
2182                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2183                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
2184                 }
2185                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
2186                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
2187                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2188                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
2189                 }
2190                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
2191                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
2192                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2193                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
2194                 }
2195                 else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
2196                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
2197                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2198                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
2199                 }
2200                index++;
2201             }
2202             pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = index;
2203         }
2204     }
2205     else {
2206         pRICSubscriptionResponse->ricActionNotAdmittedListPresent = false;
2207         pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
2208     }
2209     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2210     return e2err_OK;
2211 }
2212
2213 //////////////////////////////////////////////////////////////////////
2214 uint64_t getRICSubscriptionFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
2215
2216     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2217
2218     RICsubscriptionFailure_t *asnRicSubscriptionFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure;
2219     RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs;
2220
2221     // RICrequestID
2222     if (asnRicSubscriptionFailure->protocolIEs.list.count > 0 &&
2223         asnRicSubscriptionFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2224         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[0];
2225         pRICSubscriptionFailure->ricRequestID.ricRequestorID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID;
2226         pRICSubscriptionFailure->ricRequestID.ricInstanceID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID;
2227     }
2228     else {
2229         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2230         return e2err_RICsubscriptionFailureRICrequestIDMissing;
2231     }
2232
2233     // RANfunctionID
2234     if (asnRicSubscriptionFailure->protocolIEs.list.count > 1 &&
2235         asnRicSubscriptionFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2236         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[1];
2237         pRICSubscriptionFailure->ranFunctionID = pRICsubscriptionFailure_IEs->value.choice.RANfunctionID;
2238     }
2239     else {
2240         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2241         return e2err_RICsubscriptionFailureRANfunctionIDMissing;
2242     }
2243
2244     // RICaction-NotAdmitted-List
2245     if (asnRicSubscriptionFailure->protocolIEs.list.count > 2 &&
2246         asnRicSubscriptionFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
2247         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[2];
2248         uint64_t index = 0;
2249         while ((index < maxofRICactionID) && (index < pRICsubscriptionFailure_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
2250             RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
2251               (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionFailure_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
2252
2253             // RICActionID
2254             pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
2255               pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
2256
2257             //  RICcause
2258             if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
2259                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
2260                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2261                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
2262             }
2263             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
2264                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
2265                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2266                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
2267             }
2268             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
2269                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
2270                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2271                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
2272             }
2273             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
2274                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
2275                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2276                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
2277             }
2278             else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
2279                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
2280                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2281                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
2282             }
2283             index++;
2284         }
2285         pRICSubscriptionFailure->ricActionNotAdmittedList.contentLength = index;
2286
2287         // CriticalityDiagnostics. OPTIONAL
2288
2289     }
2290     else {
2291         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2292         return e2err_RICsubscriptionFailureRICaction_NotAdmitted_ListMissing;
2293     }
2294     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2295     return e2err_OK;
2296 }
2297
2298 //////////////////////////////////////////////////////////////////////
2299 uint64_t getRICSubscriptionDeleteRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
2300
2301     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2302
2303     RICsubscriptionDeleteRequest_t *asnRicSubscriptionDeleteRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest;
2304     RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs;
2305
2306     // RICrequestID
2307     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 0 &&
2308         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2309         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0];
2310         pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID;
2311         pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID;
2312     }
2313     else {
2314         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2315         return e2err_RICsubscriptionDeleteRequestRICrequestIDMissing;
2316     }
2317
2318     // RANfunctionID
2319     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 1 &&
2320         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2321         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1];
2322         pRICSubscriptionDeleteRequest->ranFunctionID = pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID;
2323     }
2324     else {
2325         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2326         return e2err_RICsubscriptionDeleteRequestRANfunctionIDMissing;
2327     }
2328     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2329     return e2err_OK;
2330 }
2331
2332 //////////////////////////////////////////////////////////////////////
2333 uint64_t getRICSubscriptionDeleteResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
2334
2335     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2336
2337     RICsubscriptionDeleteResponse_t *asnRicSubscriptionDeleteResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse;
2338     RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs;
2339
2340     // RICrequestID
2341     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 0 &&
2342         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2343         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0];
2344         pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID;
2345         pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID;
2346     }
2347     else {
2348         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2349         return e2err_RICsubscriptionDeleteResponseRICrequestIDMissing;
2350     }
2351
2352     // RANfunctionID
2353     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 1 &&
2354         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2355         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1];
2356         pRICSubscriptionDeleteResponse->ranFunctionID = pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID;
2357     }
2358     else {
2359         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2360         return e2err_RICsubscriptionDeleteResponseRANfunctionIDMissing;
2361     }
2362     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2363     return e2err_OK;
2364 }
2365
2366 //////////////////////////////////////////////////////////////////////
2367 uint64_t getRICSubscriptionDeleteFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
2368
2369     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2370
2371     RICsubscriptionDeleteFailure_t *asnRicSubscriptionDeleteFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure;
2372     RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs;
2373
2374     // RICrequestID
2375     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 0 &&
2376         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2377         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0];
2378         pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID;
2379         pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID;
2380     }
2381     else {
2382         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2383         return e2err_RICsubscriptionDeleteFailureRICrequestIDMissing;
2384     }
2385
2386     // RANfunctionID
2387     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 1 &&
2388         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2389         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1];
2390         pRICSubscriptionDeleteFailure->ranFunctionID = pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID;
2391     }
2392     else {
2393         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2394         return e2err_RICsubscriptionDeleteFailureRANfunctionIDMissing;
2395     }
2396
2397     // RICcause
2398     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 2 &&
2399         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_Cause) {
2400         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2];
2401         if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
2402             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricRequest;
2403             pRICSubscriptionDeleteFailure->cause.causeVal =
2404               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest;
2405         }
2406         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
2407             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricService;
2408             pRICSubscriptionDeleteFailure->cause.causeVal =
2409               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService;
2410         }
2411         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
2412             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_transport;
2413             pRICSubscriptionDeleteFailure->cause.causeVal =
2414               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport;
2415         }
2416         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
2417             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_protocol;
2418             pRICSubscriptionDeleteFailure->cause.causeVal =
2419               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol;
2420         }
2421         else if(pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
2422             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_misc;
2423             pRICSubscriptionDeleteFailure->cause.causeVal =
2424               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc;
2425         }
2426     }
2427     else {
2428         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2429         return e2err_RICsubscriptionDeleteFailureRICcauseMissing;
2430     }
2431     // CriticalityDiagnostics, OPTIONAL
2432
2433     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2434     return e2err_OK;
2435 }
2436
2437 //////////////////////////////////////////////////////////////////////
2438 uint64_t allocActionDefinitionX2Format1(mem_track_hdr_t* pDynMemHead, E2SMgNBX2actionDefinition_t** pActionDefinition) {
2439     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBX2actionDefinition_t));
2440     if(*pActionDefinition)
2441         return e2err_OK;
2442     else
2443         return e2err_RICSubscriptionRequestAllocactionDefinitionX2Format1Fail;
2444 }
2445
2446 //////////////////////////////////////////////////////////////////////
2447 uint64_t allocActionDefinitionX2Format2(mem_track_hdr_t* pDynMemHead, E2SMgNBX2ActionDefinitionFormat2_t** pActionDefinition) {
2448     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBX2ActionDefinitionFormat2_t));
2449     if(*pActionDefinition)
2450         return e2err_OK;
2451     else
2452         return e2err_RICSubscriptionRequestAllocactionDefinitionX2Format2Fail;
2453 }
2454
2455 //////////////////////////////////////////////////////////////////////
2456 uint64_t allocActionDefinitionNRTFormat1(mem_track_hdr_t* pDynMemHead, E2SMgNBNRTActionDefinitionFormat1_t** pActionDefinition) {
2457     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBNRTActionDefinitionFormat1_t));
2458     if(*pActionDefinition)
2459         return e2err_OK;
2460     else
2461         return e2err_RICSubscriptionRequestAllocactionDefinitionNRTFormat1Fail;
2462 }
2463
2464 //////////////////////////////////////////////////////////////////////
2465 bool addOctetString(mem_track_hdr_t* pDynMemHead, DynOctetString_t* pOctetString, uint64_t bufferSize, void* pData)
2466 {
2467     pOctetString->data = mem_track_alloc(pDynMemHead, bufferSize);
2468     if (pOctetString->data) {
2469         pOctetString->length = bufferSize;
2470         memcpy(pOctetString->data,pData,bufferSize);
2471         return true;
2472     }
2473     else
2474         return false;
2475 }
2476
2477 //////////////////////////////////////////////////////////////////////
2478 bool addBitString(mem_track_hdr_t* pDynMemHead, DynBitString_t* pBitString, uint64_t bufferSize, void* pData, uint8_t unusedBits)
2479 {
2480     pBitString->data = mem_track_alloc(pDynMemHead, bufferSize);
2481     if (pBitString->data) {
2482         pBitString->byteLength = bufferSize;
2483         pBitString->unusedBits = unusedBits; // Unused trailing bits in the last octet (0..7)
2484         memcpy(pBitString->data,pData,bufferSize);
2485         return true;
2486     }
2487     else
2488         return false;
2489 }
2490
2491 //////////////////////////////////////////////////////////////////////
2492 void mem_track_init(mem_track_hdr_t *curr)
2493 {
2494     *curr=(mem_track_hdr_t)MEM_TRACK_HDR_INIT;
2495 }
2496
2497 //////////////////////////////////////////////////////////////////////
2498 void* mem_track_alloc(mem_track_hdr_t *curr, size_t sz)
2499 {
2500     mem_track_t *newentry = (mem_track_t *)malloc(sizeof(mem_track_t)+sz);
2501     newentry->next=0;
2502     newentry->sz=sz;
2503     memset(newentry->ptr,0,newentry->sz);
2504
2505     if (!curr->next) {
2506         curr->next = newentry;
2507     } else {
2508         mem_track_t *iter=curr->next;
2509         for(;iter->next;iter=iter->next);
2510         iter->next = newentry;
2511     }
2512     return newentry->ptr;
2513 }
2514
2515 //////////////////////////////////////////////////////////////////////
2516 void mem_track_free(mem_track_hdr_t *curr)
2517 {
2518     mem_track_t *itecurr,*itenext;
2519     for(itecurr=curr->next; itecurr; itecurr=itenext){
2520         itenext = itecurr->next;
2521         free(itecurr);
2522     }
2523     mem_track_init(curr);
2524 }