e2ap/libe2ap_wrapper/E2AP_if.c

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22
  23 #include "E2_asn_constant.h"
  24 #include "E2AP-PDU.h"
  25 #include "ProtocolIE-Field.h"
  26 #include "RICsubsequentAction.h"
  27 #include "E2_E2SM-gNB-X2-eventTriggerDefinition.h"
  28 #include "E2_E2SM-gNB-NRT-EventTriggerDefinition.h"
  29 #include "E2_E2SM-gNB-X2-ActionDefinitionChoice.h"
  30 #include "E2_E2SM-gNB-X2-actionDefinition.h"
  31 #include "E2_ActionParameter-Item.h"
  32 #include "E2_E2SM-gNB-X2-ActionDefinition-Format2.h"
  33 #include "E2_RANueGroup-Item.h"
  34 #include "E2_RANueGroupDef-Item.h"
  35 #include "E2_RANimperativePolicy.h"
  36 #include "E2_RANParameter-Item.h"
  37
  38 // E2SM-gNB-NRT
  39 #include "E2_E2SM-gNB-NRT-ActionDefinition.h"
  40 #include "E2_E2SM-gNB-NRT-ActionDefinition-Format1.h"
  41 #include "E2_RANparameter-Item.h"
  42
  43 #include "asn_constant.h"
  44 #include "E2_asn_constant.h"
  45 #include "E2AP_if.h"
  46
  47
  48 #ifdef DEBUG
  49     static const bool debug = true;
  50 #else
  51     static const bool debug = true; //false;
  52 #endif
  53
  54 const int64_t cMaxNrOfErrors = 256;
  55 const uint64_t cMaxSizeOfOctetString = 1024;
  56
  57 const size_t cMacroENBIDP_20Bits = 20;
  58 const size_t cHomeENBID_28Bits = 28;
  59 const size_t cShortMacroENBID_18Bits = 18;
  60 const size_t clongMacroENBIDP_21Bits = 21;
  61
  62 const int cCauseRICRequest = 1;
  63 const int cCauseRICService = 2;
  64 const int cCauseTransport = 3;
  65 const int cCauseProtocol = 4;
  66 const int cCauseMisc = 5;
  67
  68 //////////////////////////////////////////////////////////////////////
  69 // Message definitons
  70
  71 // Below constant values are same as in E2AP, E2SM and X2AP specs
  72 const uint64_t cE2InitiatingMessage = 1;
  73 const uint64_t cE2SuccessfulOutcome = 2;
  74 const uint64_t cE2UnsuccessfulOutcome = 3;
  75
  76 // E2AP messages
  77 // Initiating message
  78 const uint64_t cRICSubscriptionRequest = 1;
  79 const uint64_t cRICSubscriptionDeleteRequest = 2;
  80
  81 // Successful outcome
  82 const uint64_t cRICSubscriptionResponse = 1;
  83 const uint64_t cRICsubscriptionDeleteResponse = 2;
  84
  85 // Unsuccessful outcome
  86 const uint64_t cRICSubscriptionFailure = 1;
  87 const uint64_t cRICsubscriptionDeleteFailure = 2;
  88
  89 typedef union {
  90     uint32_t  nodeID;
  91     uint8_t   octets[4];
  92 } IdOctects_t;
  93
  94 //////////////////////////////////////////////////////////////////////
  95 const char* getE2ErrorString(uint64_t errorCode) {
  96
  97     return E2ErrorStrings[errorCode];
  98 }
  99
 100 /////////////////////////////////////////////////////////////////////
 101 bool E2encode(E2AP_PDU_t* pE2AP_PDU, size_t* dataBufferSize, byte* dataBuffer, char* pLogBuffer) {
 102
 103     // Debug print
 104     if (debug)
 105         asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
 106
 107     asn_enc_rval_t rval;
 108     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pE2AP_PDU, dataBuffer, *dataBufferSize);
 109     if (rval.encoded == -1) {
 110         sprintf(pLogBuffer,"Serialization of %s failed", asn_DEF_E2AP_PDU.name);
 111         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 112         return false;
 113     }
 114     else if (rval.encoded > *dataBufferSize) {
 115         sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",*dataBufferSize, asn_DEF_E2AP_PDU.name, rval.encoded);
 116         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 117         return false;
 118     }
 119     else {
 120         if (debug)
 121             sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2AP_PDU.name, *dataBufferSize, rval.encoded);
 122
 123         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 124         *dataBufferSize = rval.encoded;
 125         return true;
 126     }
 127 }
 128
 129 //////////////////////////////////////////////////////////////////////
 130 uint64_t packRICSubscriptionRequest(size_t* pdataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 131
 132     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 133     if(pE2AP_PDU)
 134         {
 135         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
 136         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscription;
 137         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 138         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
 139
 140         // RICrequestID
 141         RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 142         if (pRICsubscriptionRequest_IEs) {
 143             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
 144             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 145             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 146             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionRequest->ricRequestID.ricRequestorID;
 147             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionRequest->ricRequestID.ricInstanceID;
 148             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 149         }
 150         else
 151             return e2err_RICSubscriptionRequestAllocRICrequestIDFail;
 152
 153         // RANfunctionID
 154         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 155         if (pRICsubscriptionRequest_IEs) {
 156             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 157             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 158             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 159             pRICsubscriptionRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionRequest->ranFunctionID;
 160             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 161         }
 162         else
 163             return e2err_RICSubscriptionRequestAllocRANfunctionIDFail;
 164
 165         // RICsubscriptionDetails
 166         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 167         if (pRICsubscriptionRequest_IEs) {
 168             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICsubscriptionDetails;
 169             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 170             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 171
 172             // RICeventTriggerDefinition
 173             uint64_t returnCode;
 174             if ((returnCode = packRICEventTriggerDefinition(pLogBuffer, &pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition) != e2err_OK))
 175                 return returnCode;
 176
 177             pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf =
 178               calloc(1, pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 179             if (pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf) {
 180                 pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.size =
 181                   pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength;
 182                 memcpy(pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf,
 183                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data,
 184                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 185             }
 186             else
 187                 return e2err_RICSubscriptionRequestAllocRICeventTriggerDefinitionBufFail;
 188
 189             // RICactions-ToBeSetup-List
 190             uint64_t index = 0;
 191             while (index < pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength && index < maxofRICactionID) {
 192                 RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs = calloc(1, sizeof(RICaction_ToBeSetup_ItemIEs_t));
 193                 if (pRICaction_ToBeSetup_ItemIEs) {
 194                     pRICaction_ToBeSetup_ItemIEs->id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
 195                     pRICaction_ToBeSetup_ItemIEs->criticality = Criticality_reject;
 196                     pRICaction_ToBeSetup_ItemIEs->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 197
 198                     // RICActionID
 199                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID =
 200                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID;
 201
 202                     // RICActionType
 203                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType =
 204                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType;
 205
 206                     // RICactionDefinition, OPTIONAL
 207                     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             uint64_t index = 0;
2034             while (index < pE2_E2SM_gNB_NRT_ActionDefinition->choice.actionDefinition_Format1.ranParameter_List->list.count) {
2035                 E2_RANparameter_Item_t* pE2_RANparameter_Item = pE2_E2SM_gNB_NRT_ActionDefinition->choice.actionDefinition_Format1.ranParameter_List->list.array[index];
2036                 if (pE2_RANparameter_Item) {
2037                     pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterID = pE2_RANparameter_Item->ranParameter_ID;
2038
2039                     if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueInt) {
2040                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueIntPresent = true;
2041                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueInt =
2042                           pE2_RANparameter_Item->ranParameter_Value.choice.valueInt;
2043                     }
2044                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueEnum) {
2045                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnumPresent = true;
2046                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueEnum =
2047                           pE2_RANparameter_Item->ranParameter_Value.choice.valueEnum;
2048                     }
2049                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueBool) {
2050                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBoolPresent = true;
2051                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBool =
2052                           pE2_RANparameter_Item->ranParameter_Value.choice.valueBool;
2053                     }
2054                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueBitS) {
2055                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitSPresent = true;
2056                         addBitString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueBitS,
2057                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.size,
2058                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.buf,
2059                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueBitS.bits_unused);
2060                     }
2061                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valueOctS) {
2062                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctSPresent = true;
2063                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valueOctS,
2064                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueOctS.size,
2065                                      pE2_RANparameter_Item->ranParameter_Value.choice.valueOctS.buf);
2066                     }
2067                     else if (pE2_RANparameter_Item->ranParameter_Value.present == E2_RANparameter_Value_PR_valuePrtS) {
2068                         pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtSPresent = true;
2069                         addOctetString(pDynMemHead, &pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterList[index].ranParameterValue.valuePrtS,
2070                                      pE2_RANparameter_Item->ranParameter_Value.choice.valuePrtS.size,
2071                                      pE2_RANparameter_Item->ranParameter_Value.choice.valuePrtS.buf);
2072                     }
2073                     else {
2074                         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2075                         return e2err_RICSubscriptionRequestNRTRanParameterItemRanParameterValueEmptyFail;
2076                     }
2077                 }
2078                 else {
2079                     ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2080                     return e2err_RICSubscriptionRequestNRTAllocActionDefinitionFail;
2081                 }
2082                 index++;
2083             }
2084             pRICActionDefinitionChoice->actionDefinitionNRTFormat1->ranParameterCount = index;
2085         }
2086         ASN_STRUCT_FREE(asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition, pE2_E2SM_gNB_NRT_ActionDefinition);
2087         return e2err_OK;
2088     case RC_WMORE:
2089         if (debug)
2090             printf("Decode failed. More data needed. Buffer size %zu, %s, consumed %zu\n",pRICActionDefinitionChoice->octetString.contentLength,
2091                    asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, rval.consumed);
2092
2093         return e2err_RICNRTActionDefinitionChoiceWMOREFail;
2094     case RC_FAIL:
2095         if (debug)
2096             printf("Decode failed. Buffer size %zu, %s, consumed %zu\n",pRICActionDefinitionChoice->octetString.contentLength,
2097                    asn_DEF_E2_E2SM_gNB_NRT_ActionDefinition.name, rval.consumed);
2098
2099         return e2err_RICNRTActionDefinitionChoiceDecodeFAIL;
2100     default:
2101         return e2err_RICNRTActionDefinitionChoiceDecodeDefaultFail;
2102     }
2103 }
2104 //////////////////////////////////////////////////////////////////////
2105 uint64_t getRICSubscriptionResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
2106
2107     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2108
2109     RICsubscriptionResponse_t *asnRicSubscriptionResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse;
2110     RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs;
2111
2112     // RICrequestID
2113     if (asnRicSubscriptionResponse->protocolIEs.list.count > 0 &&
2114         asnRicSubscriptionResponse->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2115         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[0];
2116         pRICSubscriptionResponse->ricRequestID.ricRequestorID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricRequestorID;
2117         pRICSubscriptionResponse->ricRequestID.ricInstanceID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricInstanceID;
2118     }
2119     else {
2120         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2121         return e2err_RICsubscriptionResponseRICrequestIDMissing;
2122     }
2123
2124     // RANfunctionID
2125     if (asnRicSubscriptionResponse->protocolIEs.list.count > 1 &&
2126         asnRicSubscriptionResponse->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2127         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[1];
2128         pRICSubscriptionResponse->ranFunctionID = pRICsubscriptionResponse_IEs->value.choice.RANfunctionID;
2129     }
2130     else {
2131         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2132         return e2err_RICsubscriptionResponseRANfunctionIDMissing;
2133     }
2134
2135     // RICaction-Admitted-List
2136     if (asnRicSubscriptionResponse->protocolIEs.list.count > 2  &&
2137         asnRicSubscriptionResponse->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICactions_Admitted) {
2138         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[2];
2139         pRICSubscriptionResponse->ricActionAdmittedList.contentLength = 0;
2140         uint64_t index = 0;
2141         while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.count)) {
2142             RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs =
2143               (RICaction_Admitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.array[index];
2144
2145             // RICActionID
2146             pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index] =
2147               pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID;
2148             index++;
2149         }
2150         pRICSubscriptionResponse->ricActionAdmittedList.contentLength = index;
2151     }
2152     else {
2153         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2154         return e2err_RICsubscriptionResponseRICaction_Admitted_ListMissing;
2155     }
2156
2157     // RICaction-NotAdmitted-List, OPTIONAL
2158     if (asnRicSubscriptionResponse->protocolIEs.list.count > 3 &&
2159         asnRicSubscriptionResponse->protocolIEs.list.array[3]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
2160         pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[3];
2161         if (pRICsubscriptionResponse_IEs->value.present == RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List) {
2162             pRICSubscriptionResponse->ricActionNotAdmittedListPresent = true;
2163             pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
2164             uint64_t index = 0;
2165             while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
2166                 RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
2167                   (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
2168
2169                 // RICActionID
2170                 pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
2171                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
2172
2173                 //  RICcause
2174                 if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
2175                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
2176                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2177                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
2178                 }
2179                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
2180                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
2181                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2182                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
2183                 }
2184                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
2185                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
2186                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2187                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
2188                 }
2189                 else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
2190                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
2191                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2192                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
2193                 }
2194                 else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
2195                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
2196                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2197                       pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
2198                 }
2199                index++;
2200             }
2201             pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = index;
2202         }
2203     }
2204     else {
2205         pRICSubscriptionResponse->ricActionNotAdmittedListPresent = false;
2206         pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
2207     }
2208     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2209     return e2err_OK;
2210 }
2211
2212 //////////////////////////////////////////////////////////////////////
2213 uint64_t getRICSubscriptionFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
2214
2215     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2216
2217     RICsubscriptionFailure_t *asnRicSubscriptionFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure;
2218     RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs;
2219
2220     // RICrequestID
2221     if (asnRicSubscriptionFailure->protocolIEs.list.count > 0 &&
2222         asnRicSubscriptionFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2223         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[0];
2224         pRICSubscriptionFailure->ricRequestID.ricRequestorID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID;
2225         pRICSubscriptionFailure->ricRequestID.ricInstanceID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID;
2226     }
2227     else {
2228         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2229         return e2err_RICsubscriptionFailureRICrequestIDMissing;
2230     }
2231
2232     // RANfunctionID
2233     if (asnRicSubscriptionFailure->protocolIEs.list.count > 1 &&
2234         asnRicSubscriptionFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2235         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[1];
2236         pRICSubscriptionFailure->ranFunctionID = pRICsubscriptionFailure_IEs->value.choice.RANfunctionID;
2237     }
2238     else {
2239         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2240         return e2err_RICsubscriptionFailureRANfunctionIDMissing;
2241     }
2242
2243     // RICaction-NotAdmitted-List
2244     if (asnRicSubscriptionFailure->protocolIEs.list.count > 2 &&
2245         asnRicSubscriptionFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
2246         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[2];
2247         uint64_t index = 0;
2248         while ((index < maxofRICactionID) && (index < pRICsubscriptionFailure_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
2249             RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
2250               (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionFailure_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
2251
2252             // RICActionID
2253             pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
2254               pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
2255
2256             //  RICcause
2257             if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
2258                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
2259                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2260                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
2261             }
2262             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
2263                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
2264                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2265                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
2266             }
2267             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
2268                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
2269                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2270                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
2271             }
2272             else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
2273                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
2274                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2275                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
2276             }
2277             else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
2278                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
2279                 pRICSubscriptionFailure->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
2280                   pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
2281             }
2282             index++;
2283         }
2284         pRICSubscriptionFailure->ricActionNotAdmittedList.contentLength = index;
2285
2286         // CriticalityDiagnostics. OPTIONAL
2287
2288     }
2289     else {
2290         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2291         return e2err_RICsubscriptionFailureRICaction_NotAdmitted_ListMissing;
2292     }
2293     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2294     return e2err_OK;
2295 }
2296
2297 //////////////////////////////////////////////////////////////////////
2298 uint64_t getRICSubscriptionDeleteRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
2299
2300     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2301
2302     RICsubscriptionDeleteRequest_t *asnRicSubscriptionDeleteRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest;
2303     RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs;
2304
2305     // RICrequestID
2306     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 0 &&
2307         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2308         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0];
2309         pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID;
2310         pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID;
2311     }
2312     else {
2313         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2314         return e2err_RICsubscriptionDeleteRequestRICrequestIDMissing;
2315     }
2316
2317     // RANfunctionID
2318     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 1 &&
2319         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2320         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1];
2321         pRICSubscriptionDeleteRequest->ranFunctionID = pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID;
2322     }
2323     else {
2324         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2325         return e2err_RICsubscriptionDeleteRequestRANfunctionIDMissing;
2326     }
2327     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2328     return e2err_OK;
2329 }
2330
2331 //////////////////////////////////////////////////////////////////////
2332 uint64_t getRICSubscriptionDeleteResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
2333
2334     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2335
2336     RICsubscriptionDeleteResponse_t *asnRicSubscriptionDeleteResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse;
2337     RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs;
2338
2339     // RICrequestID
2340     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 0 &&
2341         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2342         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0];
2343         pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID;
2344         pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID;
2345     }
2346     else {
2347         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2348         return e2err_RICsubscriptionDeleteResponseRICrequestIDMissing;
2349     }
2350
2351     // RANfunctionID
2352     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 1 &&
2353         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2354         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1];
2355         pRICSubscriptionDeleteResponse->ranFunctionID = pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID;
2356     }
2357     else {
2358         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2359         return e2err_RICsubscriptionDeleteResponseRANfunctionIDMissing;
2360     }
2361     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2362     return e2err_OK;
2363 }
2364
2365 //////////////////////////////////////////////////////////////////////
2366 uint64_t getRICSubscriptionDeleteFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
2367
2368     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
2369
2370     RICsubscriptionDeleteFailure_t *asnRicSubscriptionDeleteFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure;
2371     RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs;
2372
2373     // RICrequestID
2374     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 0 &&
2375         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
2376         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0];
2377         pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID;
2378         pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID;
2379     }
2380     else {
2381         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2382         return e2err_RICsubscriptionDeleteFailureRICrequestIDMissing;
2383     }
2384
2385     // RANfunctionID
2386     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 1 &&
2387         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
2388         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1];
2389         pRICSubscriptionDeleteFailure->ranFunctionID = pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID;
2390     }
2391     else {
2392         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2393         return e2err_RICsubscriptionDeleteFailureRANfunctionIDMissing;
2394     }
2395
2396     // RICcause
2397     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 2 &&
2398         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_Cause) {
2399         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2];
2400         if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
2401             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricRequest;
2402             pRICSubscriptionDeleteFailure->cause.causeVal =
2403               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest;
2404         }
2405         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
2406             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricService;
2407             pRICSubscriptionDeleteFailure->cause.causeVal =
2408               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService;
2409         }
2410         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
2411             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_transport;
2412             pRICSubscriptionDeleteFailure->cause.causeVal =
2413               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport;
2414         }
2415         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
2416             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_protocol;
2417             pRICSubscriptionDeleteFailure->cause.causeVal =
2418               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol;
2419         }
2420         else if(pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
2421             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_misc;
2422             pRICSubscriptionDeleteFailure->cause.causeVal =
2423               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc;
2424         }
2425     }
2426     else {
2427         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2428         return e2err_RICsubscriptionDeleteFailureRICcauseMissing;
2429     }
2430     // CriticalityDiagnostics, OPTIONAL
2431
2432     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
2433     return e2err_OK;
2434 }
2435
2436 //////////////////////////////////////////////////////////////////////
2437 uint64_t allocActionDefinitionX2Format1(mem_track_hdr_t* pDynMemHead, E2SMgNBX2actionDefinition_t** pActionDefinition) {
2438     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBX2actionDefinition_t));
2439     if(*pActionDefinition)
2440         return e2err_OK;
2441     else
2442         return e2err_RICSubscriptionRequestAllocactionDefinitionX2Format1Fail;
2443 }
2444
2445 //////////////////////////////////////////////////////////////////////
2446 uint64_t allocActionDefinitionX2Format2(mem_track_hdr_t* pDynMemHead, E2SMgNBX2ActionDefinitionFormat2_t** pActionDefinition) {
2447     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBX2ActionDefinitionFormat2_t));
2448     if(*pActionDefinition)
2449         return e2err_OK;
2450     else
2451         return e2err_RICSubscriptionRequestAllocactionDefinitionX2Format2Fail;
2452 }
2453
2454 //////////////////////////////////////////////////////////////////////
2455 uint64_t allocActionDefinitionNRTFormat1(mem_track_hdr_t* pDynMemHead, E2SMgNBNRTActionDefinitionFormat1_t** pActionDefinition) {
2456     *pActionDefinition = mem_track_alloc(pDynMemHead, sizeof(E2SMgNBNRTActionDefinitionFormat1_t));
2457     if(*pActionDefinition)
2458         return e2err_OK;
2459     else
2460         return e2err_RICSubscriptionRequestAllocactionDefinitionNRTFormat1Fail;
2461 }
2462
2463 //////////////////////////////////////////////////////////////////////
2464 bool addOctetString(mem_track_hdr_t* pDynMemHead, DynOctetString_t* pOctetString, uint64_t bufferSize, void* pData)
2465 {
2466     pOctetString->data = mem_track_alloc(pDynMemHead, bufferSize);
2467     if (pOctetString->data) {
2468         pOctetString->length = bufferSize;
2469         memcpy(pOctetString->data,pData,bufferSize);
2470         return true;
2471     }
2472     else
2473         return false;
2474 }
2475
2476 //////////////////////////////////////////////////////////////////////
2477 bool addBitString(mem_track_hdr_t* pDynMemHead, DynBitString_t* pBitString, uint64_t bufferSize, void* pData, uint8_t unusedBits)
2478 {
2479     pBitString->data = mem_track_alloc(pDynMemHead, bufferSize);
2480     if (pBitString->data) {
2481         pBitString->byteLength = bufferSize;
2482         pBitString->unusedBits = unusedBits; // Unused trailing bits in the last octet (0..7)
2483         memcpy(pBitString->data,pData,bufferSize);
2484         return true;
2485     }
2486     else
2487         return false;
2488 }
2489
2490 //////////////////////////////////////////////////////////////////////
2491 void mem_track_init(mem_track_hdr_t *curr)
2492 {
2493     *curr=(mem_track_hdr_t)MEM_TRACK_HDR_INIT;
2494 }
2495
2496 //////////////////////////////////////////////////////////////////////
2497 void* mem_track_alloc(mem_track_hdr_t *curr, size_t sz)
2498 {
2499     mem_track_t *newentry = (mem_track_t *)malloc(sizeof(mem_track_t)+sz);
2500     newentry->next=0;
2501     newentry->sz=sz;
2502     memset(newentry->ptr,0,newentry->sz);
2503
2504     if (!curr->next) {
2505         curr->next = newentry;
2506     } else {
2507         mem_track_t *iter=curr->next;
2508         for(;iter->next;iter=iter->next);
2509         iter->next = newentry;
2510     }
2511     return newentry->ptr;
2512 }
2513
2514 //////////////////////////////////////////////////////////////////////
2515 void mem_track_free(mem_track_hdr_t *curr)
2516 {
2517     mem_track_t *itecurr,*itenext;
2518     for(itecurr=curr->next; itecurr; itecurr=itenext){
2519         itenext = itecurr->next;
2520         free(itecurr);
2521     }
2522     mem_track_init(curr);
2523 }