e2ap/libe2ap_wrapper/E2AP_if.c

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