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