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 "E2AP-PDU.h"
  24 #include "ProtocolIE-Field.h"
  25 #include "RICsubsequentAction.h"
  26
  27 #include "asn_constant.h"
  28 #include "E2AP_if.h"
  29
  30 static bool debugPrints = false;
  31
  32 // Value of checkIEOrder defines if strict order to be followed while
  33 // packing/unpacking of E2AP messages.
  34 // Value 1 defines strict order and value 0 defines lenient order
  35 static uint8_t checkIEOrder = 1;
  36
  37 const int64_t cMaxNrOfErrors = 256;
  38 const uint64_t cMaxSizeOfOctetString = 1024;
  39
  40 const size_t cMacroENBIDP_20Bits = 20;
  41 const size_t cHomeENBID_28Bits = 28;
  42 const size_t cShortMacroENBID_18Bits = 18;
  43 const size_t clongMacroENBIDP_21Bits = 21;
  44
  45 const int cCauseRICRequest = 1;
  46 const int cCauseRICService = 2;
  47 const int cCauseTransport = 3;
  48 const int cCauseProtocol = 4;
  49 const int cCauseMisc = 5;
  50
  51 //////////////////////////////////////////////////////////////////////
  52 // Message definitons
  53
  54 // Below constant values are same as in E2AP, E2SM and X2AP specs
  55 const uint64_t cE2InitiatingMessage = 1;
  56 const uint64_t cE2SuccessfulOutcome = 2;
  57 const uint64_t cE2UnsuccessfulOutcome = 3;
  58
  59 // E2AP messages
  60 // Initiating message
  61 const uint64_t cRICSubscriptionRequest = 1;
  62 const uint64_t cRICSubscriptionDeleteRequest = 2;
  63 const uint64_t cRICSubscriptionDeleteRequired = 3;
  64
  65 // Successful outcome
  66 const uint64_t cRICSubscriptionResponse = 1;
  67 const uint64_t cRICsubscriptionDeleteResponse = 2;
  68
  69 // Unsuccessful outcome
  70 const uint64_t cRICSubscriptionFailure = 1;
  71 const uint64_t cRICsubscriptionDeleteFailure = 2;
  72
  73 typedef union {
  74     uint32_t  nodeID;
  75     uint8_t   octets[4];
  76 } IdOctects_t;
  77
  78 //////////////////////////////////////////////////////////////////////
  79 void allowASN1DebugPrints(bool allowASN1DebugPrints) {
  80     debugPrints = allowASN1DebugPrints;
  81 }
  82
  83 //////////////////////////////////////////////////////////////////////
  84 void allowOutOfOrderIEMsg(uint8_t e2IEOrderCheckEnabled) {
  85     checkIEOrder = e2IEOrderCheckEnabled;
  86 }
  87
  88 //////////////////////////////////////////////////////////////////////
  89 const char* getE2ErrorString(uint64_t errorCode) {
  90
  91     return E2ErrorStrings[errorCode];
  92 }
  93
  94 /////////////////////////////////////////////////////////////////////
  95 bool E2encode(E2AP_PDU_t* pE2AP_PDU, size_t* dataBufferSize, byte* dataBuffer, char* pLogBuffer) {
  96
  97     if (debugPrints)
  98         asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
  99
 100     asn_enc_rval_t rval;
 101     rval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pE2AP_PDU, dataBuffer, *dataBufferSize);
 102     if (rval.encoded == -1) {
 103         sprintf(pLogBuffer,"Serialization of %s failed", asn_DEF_E2AP_PDU.name);
 104         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 105         return false;
 106     }
 107     else if (rval.encoded > *dataBufferSize) {
 108         sprintf(pLogBuffer,"Buffer of size %zu is too small for %s, need %zu",*dataBufferSize, asn_DEF_E2AP_PDU.name, rval.encoded);
 109         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 110         return false;
 111     }
 112     else {
 113         if (debugPrints)
 114             sprintf(pLogBuffer,"Successfully encoded %s. Buffer size %zu, encoded size %zu",asn_DEF_E2AP_PDU.name, *dataBufferSize, rval.encoded);
 115
 116         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 117         *dataBufferSize = rval.encoded;
 118         return true;
 119     }
 120 }
 121
 122 //////////////////////////////////////////////////////////////////////
 123 uint64_t packRICSubscriptionRequest(size_t* pdataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 124
 125     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 126     if(pE2AP_PDU)
 127         {
 128         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
 129         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscription;
 130         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 131         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
 132
 133         // RICrequestID
 134         RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 135         if (pRICsubscriptionRequest_IEs) {
 136             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
 137             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 138             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 139             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionRequest->ricRequestID.ricRequestorID;
 140             pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionRequest->ricRequestID.ricInstanceID;
 141             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 142         }
 143         else
 144             return e2err_RICSubscriptionRequestAllocRICrequestIDFail;
 145
 146         // RANfunctionID
 147         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 148         if (pRICsubscriptionRequest_IEs) {
 149             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 150             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 151             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 152             pRICsubscriptionRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionRequest->ranFunctionID;
 153             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 154         }
 155         else
 156             return e2err_RICSubscriptionRequestAllocRANfunctionIDFail;
 157
 158         // RICsubscriptionDetails
 159         pRICsubscriptionRequest_IEs = calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 160         if (pRICsubscriptionRequest_IEs) {
 161             pRICsubscriptionRequest_IEs->id = ProtocolIE_ID_id_RICsubscriptionDetails;
 162             pRICsubscriptionRequest_IEs->criticality = Criticality_reject;
 163             pRICsubscriptionRequest_IEs->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 164
 165             // RICeventTriggerDefinition
 166             pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf =
 167               calloc(1, pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 168             if (pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf) {
 169                 pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.size =
 170                   pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength;
 171                 memcpy(pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition.buf,
 172                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data,
 173                        pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength);
 174             }
 175             else
 176                 return e2err_RICSubscriptionRequestAllocRICeventTriggerDefinitionBufFail;
 177
 178             // RICactions-ToBeSetup-List
 179             uint64_t index = 0;
 180             while (index < pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength && index < maxofRICactionID) {
 181                 RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs = calloc(1, sizeof(RICaction_ToBeSetup_ItemIEs_t));
 182                 if (pRICaction_ToBeSetup_ItemIEs) {
 183                     pRICaction_ToBeSetup_ItemIEs->id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
 184                     pRICaction_ToBeSetup_ItemIEs->criticality = Criticality_ignore;
 185                     pRICaction_ToBeSetup_ItemIEs->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 186
 187                     // RICActionID
 188                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID =
 189                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID;
 190
 191                     // RICActionType
 192                     pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType =
 193                       pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType;
 194
 195                     // RICactionDefinition, OPTIONAL
 196                     if (pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent) {
 197                         pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition = calloc(1, sizeof (RICactionDefinition_t));
 198                         if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition) {
 199                             pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf =
 200                               calloc(1, pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength);
 201                             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf) {
 202                                 pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size =
 203                                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength;
 204                                 memcpy(pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf,
 205                                        pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data,
 206                                        pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength);
 207                             }
 208                             else
 209                                 return e2err_RICSubscriptionRequestAllocRICactionDefinitionBufFail;
 210                         }
 211                         else
 212                             return e2err_RICSubscriptionRequestAllocRICactionDefinitionFail;
 213                     }
 214
 215                     // RICsubsequentAction, OPTIONAL
 216                     if (pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent) {
 217                         RICsubsequentAction_t* pRICsubsequentAction = calloc(1, sizeof(RICsubsequentAction_t));
 218                         if (pRICsubsequentAction) {
 219                             pRICsubsequentAction->ricSubsequentActionType =
 220                             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType;
 221                             pRICsubsequentAction->ricTimeToWait =
 222                             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait;
 223                             pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = pRICsubsequentAction;
 224                         }
 225                         else
 226                             return e2err_RICSubscriptionRequestAllocRICsubsequentActionFail;
 227                     }
 228                 }
 229                 else
 230                     return e2err_RICSubscriptionRequestAllocRICaction_ToBeSetup_ItemIEsFail;
 231
 232                 ASN_SEQUENCE_ADD(&pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list, pRICaction_ToBeSetup_ItemIEs);
 233                 index++;
 234             }
 235             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest.protocolIEs.list, pRICsubscriptionRequest_IEs);
 236         }
 237         else
 238             return e2err_RICSubscriptionRequestAllocRICsubscriptionRequest_IEsFail;
 239         if (E2encode(pE2AP_PDU, pdataBufferSize, pDataBuffer, pLogBuffer))
 240             return e2err_OK;
 241         else
 242             return e2err_RICSubscriptionRequestEncodeFail;
 243     }
 244     return e2err_RICSubscriptionRequestAllocE2AP_PDUFail;
 245 }
 246
 247
 248 //////////////////////////////////////////////////////////////////////
 249 uint64_t packRICSubscriptionResponse(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
 250
 251     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 252     if(pE2AP_PDU)
 253         {
 254         pE2AP_PDU->present = E2AP_PDU_PR_successfulOutcome;
 255         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscription;
 256         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 257         pE2AP_PDU->choice.initiatingMessage.value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
 258
 259         // RICrequestID
 260         RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs_RicRequestID = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 261         if (pRICsubscriptionResponse_IEs_RicRequestID) {
 262             pRICsubscriptionResponse_IEs_RicRequestID->id = ProtocolIE_ID_id_RICrequestID;
 263             pRICsubscriptionResponse_IEs_RicRequestID->criticality = Criticality_reject;
 264             pRICsubscriptionResponse_IEs_RicRequestID->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
 265             pRICsubscriptionResponse_IEs_RicRequestID->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionResponse->ricRequestID.ricRequestorID;
 266             pRICsubscriptionResponse_IEs_RicRequestID->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionResponse->ricRequestID.ricInstanceID;
 267         }
 268         else
 269             return e2err_RICSubscriptionResponseAllocRICrequestIDFail;
 270
 271         // RANfunctionID
 272         RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs_RANFunctionID = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 273         if (pRICsubscriptionResponse_IEs_RANFunctionID) {
 274             pRICsubscriptionResponse_IEs_RANFunctionID->id = ProtocolIE_ID_id_RANfunctionID;
 275             pRICsubscriptionResponse_IEs_RANFunctionID->criticality = Criticality_reject;
 276             pRICsubscriptionResponse_IEs_RANFunctionID->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
 277             pRICsubscriptionResponse_IEs_RANFunctionID->value.choice.RANfunctionID = pRICSubscriptionResponse->ranFunctionID;
 278         }
 279         else
 280             return e2err_RICSubscriptionResponseAllocRANfunctionIDFail;
 281
 282         // Check if Out of order IE messages to be packed, add RANFunctionID IE before RICRequestID
 283         if (checkIEOrder) {
 284             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs_RicRequestID);
 285             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs_RANFunctionID);
 286         } else {
 287             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs_RANFunctionID);
 288             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs_RicRequestID);
 289         }
 290
 291         // RICaction-Admitted list
 292         RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 293         if (pRICsubscriptionResponse_IEs) {
 294             pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RICactions_Admitted;
 295             pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
 296             pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 297
 298             uint64_t index = 0;
 299             while (index < pRICSubscriptionResponse->ricActionAdmittedList.contentLength && index < maxofRICactionID) {
 300
 301                 RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs = calloc(1, sizeof (RICaction_Admitted_ItemIEs_t));
 302                 if (pRICaction_Admitted_ItemIEs)
 303                 {
 304                     pRICaction_Admitted_ItemIEs->id = ProtocolIE_ID_id_RICaction_Admitted_Item;
 305                     pRICaction_Admitted_ItemIEs->criticality = Criticality_reject;
 306                     pRICaction_Admitted_ItemIEs->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 307
 308                     // RICActionID
 309                     pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID = pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index];
 310                     ASN_SEQUENCE_ADD(&pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list, pRICaction_Admitted_ItemIEs);
 311                 }
 312                 else
 313                     return e2err_RICSubscriptionResponseAllocRICaction_Admitted_ItemIEsFail;
 314                 index++;
 315             }
 316         }
 317         else
 318             return e2err_RICSubscriptionResponseAllocRICActionAdmittedListFail;
 319
 320         ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
 321
 322         // RICaction-NotAdmitted list, OPTIONAL
 323         if (pRICSubscriptionResponse->ricActionNotAdmittedListPresent) {
 324             pRICsubscriptionResponse_IEs = calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 325             if (pRICsubscriptionResponse_IEs) {
 326                 pRICsubscriptionResponse_IEs->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
 327                 pRICsubscriptionResponse_IEs->criticality = Criticality_reject;
 328                 pRICsubscriptionResponse_IEs->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
 329
 330                 uint64_t index = 0;
 331                 while (index < pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength && index < maxofRICactionID) {
 332
 333                     RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs = calloc(1, sizeof (RICaction_NotAdmitted_ItemIEs_t));
 334                     if (pRICaction_NotAdmitted_ItemIEs)
 335                     {
 336                         pRICaction_NotAdmitted_ItemIEs->id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item;
 337                         pRICaction_NotAdmitted_ItemIEs->criticality = Criticality_reject;
 338                         pRICaction_NotAdmitted_ItemIEs->value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;
 339
 340                         // RICActionID
 341                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID =
 342                           pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID;
 343
 344                         // Cause
 345                         if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricRequest) {
 346                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricRequest;
 347                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest =
 348                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 349                         }
 350                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_ricService) {
 351                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_ricService;
 352                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService =
 353                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 354                         }
 355                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_e2Node) {
 356                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_e2Node;
 357                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.e2Node =
 358                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 359                         }
 360                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_transport) {
 361                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_transport;
 362                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport =
 363                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 364                         }
 365                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_protocol) {
 366                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_protocol;
 367                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol =
 368                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 369                         }
 370                         else if (pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content == Cause_PR_misc) {
 371                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present = Cause_PR_misc;
 372                             pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc =
 373                               pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal;
 374                         }
 375                         ASN_SEQUENCE_ADD(&pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list, pRICaction_NotAdmitted_ItemIEs);
 376                     }
 377                     else
 378                         return e2err_RICSubscriptionResponseAllocRICaction_NotAdmitted_ItemIEsFail;
 379                     index++;
 380                 }
 381             }
 382             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse.protocolIEs.list, pRICsubscriptionResponse_IEs);
 383         }
 384
 385         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 386             return e2err_OK;
 387         else
 388             return e2err_RICSubscriptionResponseEncodeFail;
 389     }
 390     return e2err_RICSubscriptionResponseAllocE2AP_PDUFail;
 391 }
 392
 393 //////////////////////////////////////////////////////////////////////
 394 uint64_t packRICSubscriptionFailure(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
 395
 396     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 397     if(pE2AP_PDU)
 398         {
 399         pE2AP_PDU->present = E2AP_PDU_PR_unsuccessfulOutcome;
 400         pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode = ProcedureCode_id_RICsubscription;
 401         pE2AP_PDU->choice.unsuccessfulOutcome.criticality = Criticality_ignore;
 402         pE2AP_PDU->choice.unsuccessfulOutcome.value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
 403
 404         // RICrequestID
 405         RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs_RICrequestID = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 406         if (pRICsubscriptionFailure_IEs_RICrequestID) {
 407             pRICsubscriptionFailure_IEs_RICrequestID->id = ProtocolIE_ID_id_RICrequestID;
 408             pRICsubscriptionFailure_IEs_RICrequestID->criticality = Criticality_reject;
 409             pRICsubscriptionFailure_IEs_RICrequestID->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
 410             pRICsubscriptionFailure_IEs_RICrequestID->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionFailure->ricRequestID.ricRequestorID;
 411             pRICsubscriptionFailure_IEs_RICrequestID->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionFailure->ricRequestID.ricInstanceID;
 412         }
 413         else
 414             return e2err_RICSubscriptionFailureAllocRICrequestIDFail;
 415
 416         // RANfunctionID
 417         RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs_RANfunctionID = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 418         if (pRICsubscriptionFailure_IEs_RANfunctionID) {
 419             pRICsubscriptionFailure_IEs_RANfunctionID->id = ProtocolIE_ID_id_RANfunctionID;
 420             pRICsubscriptionFailure_IEs_RANfunctionID->criticality = Criticality_reject;
 421             pRICsubscriptionFailure_IEs_RANfunctionID->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
 422             pRICsubscriptionFailure_IEs_RANfunctionID->value.choice.RANfunctionID = pRICSubscriptionFailure->ranFunctionID;
 423         }
 424         else
 425             return e2err_RICSubscriptionFailureAllocRANfunctionIDFail;
 426
 427         // Check if Out of order IE messages to be packed, add RANFunctionID IE before RICRequestID
 428         if (checkIEOrder) {
 429             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs_RICrequestID);
 430             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs_RANfunctionID);
 431         } else {
 432             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs_RANfunctionID);
 433             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs_RICrequestID);
 434         }
 435
 436         // Cause
 437         RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 438         if (pRICsubscriptionFailure_IEs) {
 439             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_Cause;
 440             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
 441             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_Cause;
 442             if (pRICSubscriptionFailure->cause.content == Cause_PR_ricRequest) {
 443                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_ricRequest;
 444                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricRequest =
 445                   pRICSubscriptionFailure->cause.causeVal;
 446             }
 447             else if (pRICSubscriptionFailure->cause.content == Cause_PR_ricService) {
 448                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_ricService;
 449                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricService =
 450                   pRICSubscriptionFailure->cause.causeVal;
 451             }
 452             else if (pRICSubscriptionFailure->cause.content == Cause_PR_e2Node) {
 453                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_e2Node;
 454                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.e2Node =
 455                   pRICSubscriptionFailure->cause.causeVal;
 456             }
 457             else if (pRICSubscriptionFailure->cause.content == Cause_PR_transport) {
 458                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_transport;
 459                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.transport =
 460                   pRICSubscriptionFailure->cause.causeVal;
 461             }
 462             else if (pRICSubscriptionFailure->cause.content == Cause_PR_protocol) {
 463                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_protocol;
 464                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.protocol =
 465                   pRICSubscriptionFailure->cause.causeVal;
 466             }
 467             else if (pRICSubscriptionFailure->cause.content == Cause_PR_misc) {
 468                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_misc;
 469                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.misc =
 470                   pRICSubscriptionFailure->cause.causeVal;
 471             }
 472             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
 473         }
 474         else
 475             return e2err_RICSubscriptionFailureAllocCauseFail;
 476
 477         // CriticalityDiagnostics, OPTIONAL. Not used in RIC
 478
 479         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 480             return e2err_OK;
 481         else
 482             return e2err_RICSubscriptionFailureEncodeFail;
 483     }
 484     else
 485         return e2err_RICSubscriptionFailureAllocE2AP_PDUFail;
 486 }
 487
 488 //////////////////////////////////////////////////////////////////////
 489 uint64_t packRICSubscriptionDeleteRequest(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
 490
 491     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 492     if(pE2AP_PDU)
 493         {
 494         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
 495         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 496         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 497         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest;
 498
 499         // RICrequestID
 500         RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 501         if (pRICsubscriptionDeleteRequest_IEs) {
 502             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
 503             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
 504             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
 505             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID;
 506             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID;
 507             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
 508         }
 509         else
 510             return e2err_RICSubscriptionDeleteRequestAllocRICrequestIDFail;
 511
 512         // RANfunctionID
 513         pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 514         if (pRICsubscriptionDeleteRequest_IEs) {
 515             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 516             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
 517             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
 518             pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteRequest->ranFunctionID;
 519             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
 520         }
 521         else
 522             return e2err_RICSubscriptionDeleteRequestAllocRANfunctionIDFail;
 523
 524         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 525             return e2err_OK;
 526         else
 527             return e2err_RICSubscriptionDeleteRequestEncodeFail;
 528     }
 529     else
 530         return e2err_RICSubscriptionDeleteRequestAllocE2AP_PDUFail;
 531 }
 532
 533 //////////////////////////////////////////////////////////////////////
 534 uint64_t packRICSubscriptionDeleteResponse(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
 535
 536     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 537     if(pE2AP_PDU)
 538         {
 539         pE2AP_PDU->present = E2AP_PDU_PR_successfulOutcome;
 540         pE2AP_PDU->choice.successfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 541         pE2AP_PDU->choice.successfulOutcome.criticality = Criticality_ignore;
 542         pE2AP_PDU->choice.successfulOutcome.value.present = SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse;
 543
 544         // RICrequestID
 545         RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs_RICrequestID = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
 546         if (pRICsubscriptionDeleteResponse_IEs_RICrequestID) {
 547             pRICsubscriptionDeleteResponse_IEs_RICrequestID->id = ProtocolIE_ID_id_RICrequestID;
 548             pRICsubscriptionDeleteResponse_IEs_RICrequestID->criticality = Criticality_reject;
 549             pRICsubscriptionDeleteResponse_IEs_RICrequestID->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
 550             pRICsubscriptionDeleteResponse_IEs_RICrequestID->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID;
 551             pRICsubscriptionDeleteResponse_IEs_RICrequestID->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID;
 552         }
 553         else
 554             return e2err_RICSubscriptionDeleteResponseAllocRICrequestIDFail;
 555
 556         // RANfunctionID
 557         RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs_RANfunctionID = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
 558         if (pRICsubscriptionDeleteResponse_IEs_RANfunctionID) {
 559             pRICsubscriptionDeleteResponse_IEs_RANfunctionID->id = ProtocolIE_ID_id_RANfunctionID;
 560             pRICsubscriptionDeleteResponse_IEs_RANfunctionID->criticality = Criticality_reject;
 561             pRICsubscriptionDeleteResponse_IEs_RANfunctionID->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
 562             pRICsubscriptionDeleteResponse_IEs_RANfunctionID->value.choice.RANfunctionID = pRICSubscriptionDeleteResponse->ranFunctionID;
 563         }
 564         else
 565             return e2err_RICSubscriptionDeleteResponseAllocRANfunctionIDFail;
 566
 567         // // Check if Out of order IE messages to be packed, add RANFunctionID IE before RICRequestID
 568         if (checkIEOrder) {
 569             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs_RICrequestID);
 570             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs_RANfunctionID);
 571         } else {
 572             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs_RANfunctionID);
 573             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs_RICrequestID);
 574         }
 575
 576         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 577             return e2err_OK;
 578         else
 579             return e2err_RICSubscriptionDeleteResponseEncodeFail;
 580     }
 581     else
 582         return e2err_RICSubscriptionDeleteResponseAllocE2AP_PDUFail;
 583 }
 584
 585 uint64_t packRICSubscriptionDeleteFailure(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
 586
 587     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 588     if(pE2AP_PDU)
 589         {
 590         pE2AP_PDU->present = E2AP_PDU_PR_unsuccessfulOutcome;
 591         pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 592         pE2AP_PDU->choice.unsuccessfulOutcome.criticality = Criticality_ignore;
 593         pE2AP_PDU->choice.unsuccessfulOutcome.value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
 594
 595         // RICrequestID
 596         RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs_RICrequestID = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 597         if (pRICsubscriptionDeleteFailure_IEs_RICrequestID) {
 598             pRICsubscriptionDeleteFailure_IEs_RICrequestID->id = ProtocolIE_ID_id_RICrequestID;
 599             pRICsubscriptionDeleteFailure_IEs_RICrequestID->criticality = Criticality_reject;
 600             pRICsubscriptionDeleteFailure_IEs_RICrequestID->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
 601             pRICsubscriptionDeleteFailure_IEs_RICrequestID->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID;
 602             pRICsubscriptionDeleteFailure_IEs_RICrequestID->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID;
 603         }
 604         else
 605             return e2err_RICSubscriptionDeleteFailureAllocRICrequestIDFail;
 606
 607         // RANfunctionID
 608         RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs_RANfunctionID = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 609         if (pRICsubscriptionDeleteFailure_IEs_RANfunctionID) {
 610             pRICsubscriptionDeleteFailure_IEs_RANfunctionID->id = ProtocolIE_ID_id_RANfunctionID;
 611             pRICsubscriptionDeleteFailure_IEs_RANfunctionID->criticality = Criticality_reject;
 612             pRICsubscriptionDeleteFailure_IEs_RANfunctionID->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
 613             pRICsubscriptionDeleteFailure_IEs_RANfunctionID->value.choice.RANfunctionID = pRICSubscriptionDeleteFailure->ranFunctionID;
 614         }
 615         else
 616             return e2err_RICSubscriptionDeleteFailureAllocRANfunctionIDFail;
 617
 618         // Check if Out of order IE messages to be packed, add RANFunctionID IE before RICRequestID
 619         if (checkIEOrder) {
 620             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs_RICrequestID);
 621             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs_RANfunctionID);
 622         } else {
 623             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs_RANfunctionID);
 624             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs_RICrequestID);
 625         }
 626
 627         // Cause
 628         RICsubscriptionFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 629         if (pRICsubscriptionDeleteFailure_IEs) {
 630             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_Cause;
 631             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
 632             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_Cause;
 633             if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricRequest) {
 634                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricRequest;
 635                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest =
 636                   pRICSubscriptionDeleteFailure->cause.causeVal;
 637             }
 638             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricService) {
 639                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricService;
 640                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService =
 641                   pRICSubscriptionDeleteFailure->cause.causeVal;
 642             }
 643             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_e2Node) {
 644                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_e2Node;
 645                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.e2Node =
 646                   pRICSubscriptionDeleteFailure->cause.causeVal;
 647             }
 648             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_transport) {
 649                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_transport;
 650                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport =
 651                   pRICSubscriptionDeleteFailure->cause.causeVal;
 652             }
 653             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_protocol) {
 654                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_protocol;
 655                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol =
 656                   pRICSubscriptionDeleteFailure->cause.causeVal;
 657             }
 658             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_misc) {
 659                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_misc;
 660                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc =
 661                   pRICSubscriptionDeleteFailure->cause.causeVal;
 662             }
 663             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
 664         }
 665         else
 666             return e2err_RICSubscriptionDeleteFailureAllocRICcauseFail;
 667
 668         // CriticalityDiagnostics, OPTIONAL
 669
 670         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 671             return e2err_OK;
 672         else
 673             return e2err_RICSubscriptionDeleteFailureEncodeFail;
 674     }
 675     else
 676         return e2err_RICSubscriptionDeleteFailureAllocE2AP_PDUFail;
 677 }
 678
 679 //////////////////////////////////////////////////////////////////////
 680 e2ap_pdu_ptr_t* unpackE2AP_pdu(const size_t dataBufferSize, const byte* dataBuffer, char* pLogBuffer, E2MessageInfo_t* pMessageInfo) {
 681
 682     E2AP_PDU_t* pE2AP_PDU = 0;
 683     asn_dec_rval_t rval;
 684     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **)&pE2AP_PDU, dataBuffer, dataBufferSize);
 685     switch (rval.code) {
 686     case RC_OK:
 687         if (debugPrints) {
 688             sprintf(pLogBuffer,"Successfully decoded E2AP-PDU");
 689             asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
 690         }
 691
 692         if (pE2AP_PDU->present == E2AP_PDU_PR_initiatingMessage) {
 693             if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscription) {
 694                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionRequest) {
 695                     pMessageInfo->messageType = cE2InitiatingMessage;
 696                     pMessageInfo->messageId = cRICSubscriptionRequest;
 697                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 698                 }
 699                 else {
 700                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
 701                     return 0;
 702                 }
 703             }
 704             else if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 705                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest) {
 706                     pMessageInfo->messageType = cE2InitiatingMessage;
 707                     pMessageInfo->messageId = cRICSubscriptionDeleteRequest;
 708                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 709                 }
 710                 else {
 711                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
 712                     return 0;
 713                 }
 714             }else if (pE2AP_PDU->choice.initiatingMessage.procedureCode ==
 715                                ProcedureCode_id_RICsubscriptionDeleteRequired) {
 716                         if (pE2AP_PDU->choice.initiatingMessage.value.present ==
 717                             InitiatingMessage__value_PR_RICsubscriptionDeleteRequired) {
 718                             pMessageInfo->messageType = cE2InitiatingMessage;
 719                             pMessageInfo->messageId = cRICSubscriptionDeleteRequired;
 720                             return (e2ap_pdu_ptr_t *) pE2AP_PDU;
 721                         } else {
 722                             sprintf(pLogBuffer, "Error. Not supported initiatingMessage MessageId = %u",
 723                                     pE2AP_PDU->choice.initiatingMessage.value.present);
 724                             return 0;
 725                         }
 726             }
 727             else {
 728                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.initiatingMessage.procedureCode);
 729                 return 0;
 730             }
 731         }
 732         else if (pE2AP_PDU->present == E2AP_PDU_PR_successfulOutcome) {
 733             if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
 734                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse) {
 735                     pMessageInfo->messageType = cE2SuccessfulOutcome;
 736                     pMessageInfo->messageId = cRICSubscriptionResponse;
 737                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 738                 }
 739                 else {
 740                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
 741                     return 0;
 742                 }
 743             }
 744             else if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 745                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse) {
 746                     pMessageInfo->messageType = cE2SuccessfulOutcome;
 747                     pMessageInfo->messageId = cRICsubscriptionDeleteResponse;
 748                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 749                 }
 750                 else {
 751                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
 752                     return 0;
 753                 }
 754             }
 755             else {
 756                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.successfulOutcome.procedureCode);
 757                 return 0;
 758             }
 759         }
 760         else if (pE2AP_PDU->present == E2AP_PDU_PR_unsuccessfulOutcome) {
 761             if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
 762                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionFailure) {
 763                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
 764                     pMessageInfo->messageId = cRICSubscriptionFailure;
 765                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 766                 }
 767                 else {
 768                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
 769                     return 0;
 770                 }
 771             }
 772             else if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 773                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure) {
 774                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
 775                     pMessageInfo->messageId = cRICsubscriptionDeleteFailure;
 776                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 777                 }
 778                 else {
 779                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
 780                     return 0;
 781                 }
 782             }
 783         }
 784         else
 785             sprintf(pLogBuffer,"Decode failed. Invalid message type %u",pE2AP_PDU->present);
 786         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 787         return 0;
 788     case RC_WMORE:
 789         sprintf(pLogBuffer,"Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
 790         return 0;
 791     case RC_FAIL:
 792         sprintf(pLogBuffer,"Decode failed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
 793         return 0;
 794     default:
 795         return 0;
 796     }
 797 }
 798
 799 //////////////////////////////////////////////////////////////////////
 800 uint64_t getRICSubscriptionRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 801
 802     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
 803
 804     RICsubscriptionRequest_t *asnRicSubscriptionRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest;
 805     RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs;
 806
 807     // RICrequestID
 808     if (asnRicSubscriptionRequest->protocolIEs.list.count > 0 &&
 809         asnRicSubscriptionRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
 810         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[0];
 811         pRICSubscriptionRequest->ricRequestID.ricRequestorID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID;
 812         pRICSubscriptionRequest->ricRequestID.ricInstanceID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID;
 813     }
 814     else {
 815         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 816         return e2err_RICsubscriptionRequestRICrequestIDMissing;
 817     }
 818
 819     // RANfunctionID
 820     if (asnRicSubscriptionRequest->protocolIEs.list.count > 1 &&
 821         asnRicSubscriptionRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
 822         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[1];
 823         pRICSubscriptionRequest->ranFunctionID = pRICsubscriptionRequest_IEs->value.choice.RANfunctionID;
 824     }
 825     else {
 826         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 827         return e2err_RICsubscriptionRequestRANfunctionIDMissing;
 828     }
 829
 830     // RICsubscriptionDetails
 831     if (asnRicSubscriptionRequest->protocolIEs.list.count > 2 &&
 832         asnRicSubscriptionRequest->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICsubscriptionDetails) {
 833         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[2];
 834
 835         // Unpack EventTriggerDefinition
 836         RICeventTriggerDefinition_t* pRICeventTriggerDefinition =
 837           (RICeventTriggerDefinition_t*)&pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition;
 838         pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength = pRICeventTriggerDefinition->size;
 839         memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data, pRICeventTriggerDefinition->buf, pRICeventTriggerDefinition->size);
 840
 841         // RICactions-ToBeSetup-List
 842         RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs;
 843         uint64_t index = 0;
 844         while (index < pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count)
 845         {
 846             pRICaction_ToBeSetup_ItemIEs = (RICaction_ToBeSetup_ItemIEs_t*)pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.array[index];
 847
 848             // RICActionID
 849             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID =
 850               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID;
 851
 852             // RICActionType
 853             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType =
 854               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType;
 855
 856             // RICactionDefinition, OPTIONAL
 857             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
 858             {
 859                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength =
 860                 pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size;
 861                 memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data,
 862                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf,
 863                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
 864
 865                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = true;
 866             }
 867             else
 868                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = false;
 869
 870             // RICsubsequentAction, OPTIONAL
 871             RICsubsequentAction_t* pRICsubsequentAction;
 872             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction)
 873             {
 874                 pRICsubsequentAction = pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction;
 875                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = true;
 876                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =
 877                   pRICsubsequentAction->ricSubsequentActionType;
 878                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =
 879                   pRICsubsequentAction->ricTimeToWait;
 880             }
 881             else
 882                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = false;
 883             index++;
 884         }
 885         pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = index;
 886     }
 887     else {
 888         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 889         return e2err_RICsubscriptionRequestICsubscriptionMissing;
 890     }
 891
 892     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 893     return e2err_OK;
 894 }
 895
 896
 897 //////////////////////////////////////////////////////////////////////
 898
 899 uint64_t getRICSubscriptionResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
 900
 901     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
 902
 903     RICsubscriptionResponse_t *asnRicSubscriptionResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse;
 904     RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs;
 905
 906     bool foundRICrequestID = false;
 907     bool foundRANfunctionID = false;
 908     bool foundRICactions_Admitted = false;
 909     bool foundRICaction_NotAdmitted = false;
 910
 911     for (int i = 0; i < asnRicSubscriptionResponse->protocolIEs.list.count; i++) {
 912         if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
 913             if (checkIEOrder && i != 0) {
 914                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 915                 return e2err_RICsubscriptionResponseRICrequestIDWrongOrder;
 916             }
 917             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 918             pRICSubscriptionResponse->ricRequestID.ricRequestorID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricRequestorID;
 919             pRICSubscriptionResponse->ricRequestID.ricInstanceID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricInstanceID;
 920             foundRICrequestID = true;
 921         }
 922         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 923             if (checkIEOrder && i != 1) {
 924                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 925                 return e2err_RICsubscriptionResponseRANfunctionIDWrongOrder;
 926             }
 927             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 928             pRICSubscriptionResponse->ranFunctionID = pRICsubscriptionResponse_IEs->value.choice.RANfunctionID;
 929             foundRANfunctionID = true;
 930         }
 931         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_Admitted) {
 932             if (checkIEOrder && i != 2) {
 933                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 934                 return e2err_RICsubscriptionResponseRICaction_Admitted_ListWrongOrder;
 935             }
 936             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 937             pRICSubscriptionResponse->ricActionAdmittedList.contentLength = 0;
 938             uint64_t index = 0;
 939             while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.count)) {
 940                 RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs =
 941                   (RICaction_Admitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.array[index];
 942
 943                 // RICActionID
 944                 pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index] =
 945                   pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID;
 946                 index++;
 947             }
 948             pRICSubscriptionResponse->ricActionAdmittedList.contentLength = index;
 949             foundRICactions_Admitted = true;
 950         }
 951         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
 952             if (checkIEOrder && i != 3) {
 953                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 954                 return e2err_RICsubscriptionResponseRICaction_NotAdmitted_ListWrongOrder;
 955             }
 956             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 957             if (pRICsubscriptionResponse_IEs->value.present == RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List) {
 958                 pRICSubscriptionResponse->ricActionNotAdmittedListPresent = true;
 959                 pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
 960                 uint64_t index = 0;
 961                 while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
 962                     RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
 963                     (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
 964
 965                     // RICActionID
 966                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
 967                     pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
 968
 969                     //  Cause
 970                     if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
 971                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
 972                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 973                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
 974                     }
 975                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
 976                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
 977                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 978                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
 979                     }
 980                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_e2Node) {
 981                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_e2Node;
 982                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 983                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.e2Node;
 984                     }
 985                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
 986                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
 987                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 988                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
 989                     }
 990                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
 991                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
 992                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 993                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
 994                     }
 995                     else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
 996                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
 997                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 998                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
 999                     }
1000                     index++;
1001                 }
1002                 pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = index;
1003                 foundRICaction_NotAdmitted = true;
1004             }
1005         }
1006     }
1007
1008     if (!foundRICrequestID) {
1009         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1010         return e2err_RICsubscriptionResponseRICrequestIDMissing;
1011     }
1012     if (!foundRANfunctionID) {
1013         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1014         return e2err_RICsubscriptionResponseRANfunctionIDMissing;
1015     }
1016     if (!foundRICactions_Admitted) {
1017         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1018         return e2err_RICsubscriptionResponseRICaction_Admitted_ListMissing;
1019     }
1020
1021     if (!foundRICaction_NotAdmitted) {
1022         pRICSubscriptionResponse->ricActionNotAdmittedListPresent = false;
1023         pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
1024     }
1025     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1026     return e2err_OK;
1027 }
1028
1029 //////////////////////////////////////////////////////////////////////
1030 uint64_t getRICSubscriptionFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
1031
1032     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1033
1034     RICsubscriptionFailure_t *asnRicSubscriptionFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure;
1035     RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs;
1036
1037     bool foundRICrequestID = false;
1038     bool foundRANfunctionID = false;
1039     bool foundCause = false;
1040
1041     for (int i = 0; i < asnRicSubscriptionFailure->protocolIEs.list.count; i++) {
1042         if (asnRicSubscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
1043             if (checkIEOrder && i != 0) {
1044                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1045                 return e2err_RICsubscriptionFailureRICrequestIDWrongOrder;
1046             }
1047             pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[i];
1048             pRICSubscriptionFailure->ricRequestID.ricRequestorID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID;
1049             pRICSubscriptionFailure->ricRequestID.ricInstanceID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID;
1050             foundRICrequestID = true;
1051         }
1052         else if (asnRicSubscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
1053             if (checkIEOrder && i != 1) {
1054                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1055                 return e2err_RICsubscriptionFailureRANfunctionIDWrongOrder;
1056             }
1057             pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[i];
1058             pRICSubscriptionFailure->ranFunctionID = pRICsubscriptionFailure_IEs->value.choice.RANfunctionID;
1059             foundRANfunctionID = true;
1060         }
1061         else if (asnRicSubscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_Cause) {
1062             if (checkIEOrder && i != 2) {
1063                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1064                 return e2err_RICsubscriptionFailureCauseWrongOrder;
1065             }
1066             pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[i];
1067             if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
1068                 pRICSubscriptionFailure->cause.content = Cause_PR_ricRequest;
1069                 pRICSubscriptionFailure->cause.causeVal =
1070                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricRequest;
1071             }
1072             else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
1073                 pRICSubscriptionFailure->cause.content = Cause_PR_ricService;
1074                 pRICSubscriptionFailure->cause.causeVal =
1075                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricService;
1076             }
1077             else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_e2Node) {
1078                 pRICSubscriptionFailure->cause.content = Cause_PR_e2Node;
1079                 pRICSubscriptionFailure->cause.causeVal =
1080                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.e2Node;
1081             }
1082             else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
1083                 pRICSubscriptionFailure->cause.content = Cause_PR_transport;
1084                 pRICSubscriptionFailure->cause.causeVal =
1085                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.transport;
1086             }
1087             else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
1088                 pRICSubscriptionFailure->cause.content = Cause_PR_protocol;
1089                 pRICSubscriptionFailure->cause.causeVal =
1090                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.protocol;
1091             }
1092             else if(pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
1093                 pRICSubscriptionFailure->cause.content = Cause_PR_misc;
1094                 pRICSubscriptionFailure->cause.causeVal =
1095                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.misc;
1096             }
1097             foundCause = true;
1098         }
1099     }
1100
1101     if (!foundRICrequestID) {
1102         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1103                 return e2err_RICsubscriptionFailureRICrequestIDMissing;
1104     }
1105     if (!foundRANfunctionID) {
1106         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1107         return e2err_RICsubscriptionFailureRANfunctionIDMissing;
1108     }
1109     if (!foundCause) {
1110         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1111         return e2err_RICsubscriptionFailureCauseMissing;
1112     }
1113
1114     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1115     return e2err_OK;
1116 }
1117
1118 //////////////////////////////////////////////////////////////////////
1119 uint64_t getRICSubscriptionDeleteRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
1120
1121     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1122
1123     RICsubscriptionDeleteRequest_t *asnRicSubscriptionDeleteRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest;
1124     RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs;
1125
1126     // RICrequestID
1127     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 0 &&
1128         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1129         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0];
1130         pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID;
1131         pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID;
1132     }
1133     else {
1134         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1135         return e2err_RICsubscriptionDeleteRequestRICrequestIDMissing;
1136     }
1137
1138     // RANfunctionID
1139     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 1 &&
1140         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1141         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1];
1142         pRICSubscriptionDeleteRequest->ranFunctionID = pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID;
1143     }
1144     else {
1145         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1146         return e2err_RICsubscriptionDeleteRequestRANfunctionIDMissing;
1147     }
1148     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1149     return e2err_OK;
1150 }
1151
1152 //////////////////////////////////////////////////////////////////////
1153 uint64_t getRICSubscriptionDeleteResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
1154
1155     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1156
1157     RICsubscriptionDeleteResponse_t *asnRicSubscriptionDeleteResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse;
1158     RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs;
1159
1160     bool ricRequestIDFound = false;
1161     bool ranFunctionIDFound = false;
1162
1163     for (int i = 0; i < asnRicSubscriptionDeleteResponse->protocolIEs.list.count; i++) {
1164         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[i];
1165
1166         if (pRICsubscriptionDeleteResponse_IEs->id == ProtocolIE_ID_id_RICrequestID) {
1167             if (checkIEOrder && i != 0) {
1168                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1169                 return e2err_RICsubscriptionDeleteResponseRICrequestIDWrongOrder;
1170             }
1171             pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID;
1172             pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID;
1173             ricRequestIDFound = true;
1174         }
1175         else if (pRICsubscriptionDeleteResponse_IEs->id == ProtocolIE_ID_id_RANfunctionID) {
1176             if (checkIEOrder && i != 1) {
1177                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1178                 return e2err_RICsubscriptionDeleteResponseRANfunctionIDWrongOrder;
1179             }
1180             pRICSubscriptionDeleteResponse->ranFunctionID = pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID;
1181             ranFunctionIDFound = true;
1182         }
1183     }
1184
1185     if (!ricRequestIDFound) {
1186         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1187         return e2err_RICsubscriptionDeleteResponseRICrequestIDMissing;
1188     }
1189
1190     if (!ranFunctionIDFound) {
1191         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1192         return e2err_RICsubscriptionDeleteResponseRANfunctionIDMissing;
1193     }
1194
1195     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1196     return e2err_OK;
1197 }
1198
1199 //////////////////////////////////////////////////////////////////////
1200 uint64_t getRICSubscriptionDeleteFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
1201
1202     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1203
1204     RICsubscriptionDeleteFailure_t *asnRicSubscriptionDeleteFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure;
1205     RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs;
1206
1207     bool foundRICrequestID = false;
1208     bool foundRANfunctionID = false;
1209     bool foundCause = false;
1210
1211     for (int i = 0; i < asnRicSubscriptionDeleteFailure->protocolIEs.list.count; i++) {
1212         if (asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
1213             if (checkIEOrder && i != 0) {
1214                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1215                 return e2err_RICsubscriptionDeleteFailureRICrequestIDWrongOrder;
1216             }
1217             pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i];
1218             pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID;
1219             pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID;
1220             foundRICrequestID = true;
1221         } else if (asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
1222              if (checkIEOrder && i != 1) {
1223                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1224                 return e2err_RICsubscriptionDeleteFailureRANfunctionIDWrongOrder;
1225             }
1226             pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i];
1227             pRICSubscriptionDeleteFailure->ranFunctionID = pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID;
1228             foundRANfunctionID = true;
1229         } else if (asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_Cause) {
1230             if (checkIEOrder && i != 2) {
1231                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1232                 return e2err_RICsubscriptionDeleteFailureRICcauseWrongOrder;
1233             }
1234             pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[i];
1235             if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
1236                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricRequest;
1237                 pRICSubscriptionDeleteFailure->cause.causeVal =
1238                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest;
1239             }
1240             else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
1241                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricService;
1242                 pRICSubscriptionDeleteFailure->cause.causeVal =
1243                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService;
1244             }
1245             else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_e2Node) {
1246                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_e2Node;
1247                 pRICSubscriptionDeleteFailure->cause.causeVal =
1248                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.e2Node;
1249             }
1250             else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
1251                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_transport;
1252                 pRICSubscriptionDeleteFailure->cause.causeVal =
1253                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport;
1254             }
1255             else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
1256                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_protocol;
1257                 pRICSubscriptionDeleteFailure->cause.causeVal =
1258                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol;
1259             }
1260             else if(pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
1261                 pRICSubscriptionDeleteFailure->cause.content = Cause_PR_misc;
1262                 pRICSubscriptionDeleteFailure->cause.causeVal =
1263                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc;
1264             }
1265             foundCause = true;
1266         }
1267     }
1268
1269     if (!foundRICrequestID) {
1270         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1271                 return e2err_RICsubscriptionDeleteFailureRICrequestIDMissing;
1272     }
1273     if (!foundRANfunctionID) {
1274         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1275         return e2err_RICsubscriptionDeleteFailureRANfunctionIDMissing;
1276     }
1277     if (!foundCause) {
1278         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1279         return e2err_RICsubscriptionDeleteFailureRICcauseMissing;
1280     }
1281
1282     // CriticalityDiagnostics, OPTIONAL
1283
1284     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1285     return e2err_OK;
1286 }
1287
1288 //**************************************************************************************************************************
1289 uint64_t packRICSubscriptionDeleteRequired(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubsDeleteRequired_t* pRICSubscriptionDeleteRequired) {
1290
1291     E2AP_PDU_t *pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1292     if (pE2AP_PDU) {
1293         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
1294         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired;
1295         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
1296         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired;
1297
1298         {
1299             RICsubscriptionDeleteRequired_IEs_t *ricSubsDeleteRequiredIEs = calloc(1,
1300                                                                                    sizeof(RICsubscriptionDeleteRequired_IEs_t));
1301             ricSubsDeleteRequiredIEs->id = ProtocolIE_ID_id_RICsubscriptionToBeRemoved;
1302             ricSubsDeleteRequiredIEs->criticality = Criticality_ignore;
1303             ricSubsDeleteRequiredIEs->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
1304
1305             for (int idx = 0; idx < pRICSubscriptionDeleteRequired->noOfRanSubscriptions; idx++) {
1306                 RICsubscription_withCause_ItemIEs_t *ricSubsListWithCauseItem = calloc(1,
1307                                                                                        sizeof(RICsubscription_withCause_ItemIEs_t));
1308                 ricSubsListWithCauseItem->id = ProtocolIE_ID_id_RICsubscription_withCause_Item;
1309                 ricSubsListWithCauseItem->criticality = Criticality_ignore;
1310                 ricSubsListWithCauseItem->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
1311
1312                 // RIC RequestID
1313                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ricRequestID.ricRequestorID =
1314                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID;
1315                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ricRequestID.ricInstanceID =
1316                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID;
1317
1318                 // RANFunctionID
1319                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ranFunctionID =
1320                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ranFunctionID;
1321
1322                 // RICCause
1323                 if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1324                     Cause_PR_ricRequest) {
1325                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_ricRequest;
1326                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.ricRequest =
1327                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1328                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1329                            Cause_PR_ricService) {
1330                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_ricService;
1331                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.ricService =
1332                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1333                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1334                            Cause_PR_e2Node) {
1335                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_e2Node;
1336                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.e2Node =
1337                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1338                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1339                            Cause_PR_protocol) {
1340                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_protocol;
1341                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.protocol =
1342                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1343                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1344                            Cause_PR_transport) {
1345                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_transport;
1346                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.transport =
1347                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1348                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1349                            Cause_PR_misc) {
1350                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_misc;
1351                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.misc =
1352                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1353                 }
1354                 asn_sequence_add(&ricSubsDeleteRequiredIEs->value.choice.RICsubscription_List_withCause.list,
1355                                  ricSubsListWithCauseItem);
1356             }
1357             asn_sequence_add(
1358                     &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequired.protocolIEs.list,
1359                     ricSubsDeleteRequiredIEs);
1360
1361             if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1362                 return e2err_OK;
1363             else
1364                 return e2err_RICSubscriptionDeleteRequiredEncodeFail;
1365         }
1366     }
1367     else
1368         return e2err_RICSubscriptionDeleteRequiredAllocE2AP_PDUFail;
1369 }
1370
1371 //**************************************************************************************************************************
1372 uint64_t getRICSubscriptionDeleteRequiredData(e2ap_pdu_ptr_t *pE2AP_PDU_pointer,
1373                                                   RICSubsDeleteRequired_t *pRICSubscriptionDeleteRequired) {
1374
1375         E2AP_PDU_t *pE2AP_PDU = (E2AP_PDU_t *) pE2AP_PDU_pointer;
1376
1377         RICsubscriptionDeleteRequired_t *asnRicSubscriptionDeleteRequired = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequired;
1378
1379         if (asnRicSubscriptionDeleteRequired->protocolIEs.list.count > 0 &&
1380             asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->id ==
1381             ProtocolIE_ID_id_RICsubscriptionToBeRemoved) {
1382             if (asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->value.present ==
1383                 RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause) {
1384                 RICsubscription_List_withCause_t riCsubscriptionListWithCause = asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->value.choice.RICsubscription_List_withCause;
1385                 pRICSubscriptionDeleteRequired->noOfRanSubscriptions = riCsubscriptionListWithCause.list.count;
1386                 for (int idx = 0; idx < riCsubscriptionListWithCause.list.count; idx++) {
1387                     RICsubscription_withCause_ItemIEs_t *riCsubscriptionWithCauseItemIEs = (RICsubscription_withCause_ItemIEs_t*)riCsubscriptionListWithCause.list.array[idx];
1388                     if (riCsubscriptionWithCauseItemIEs->id == ProtocolIE_ID_id_RICsubscription_withCause_Item &&
1389                             riCsubscriptionWithCauseItemIEs->value.present ==
1390                         RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item) {
1391                         // RIC RequestID
1392                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ricRequestID.ricRequestorID;
1393                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ricRequestID.ricInstanceID;
1394
1395                         // RANFunctionID
1396                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ranFunctionID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ranFunctionID;
1397
1398                         // RICCause
1399                         if (riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1400                             Cause_PR_ricRequest) {
1401                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_ricRequest;
1402                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1403                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.ricRequest;
1404                         }
1405                             //TODO : RIC Cause
1406                         else if (riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1407                                  Cause_PR_ricService) {
1408                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_ricService;
1409                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1410                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.ricService;
1411                         } else if (
1412                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1413                                 Cause_PR_transport) {
1414                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_transport;
1415                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1416                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.transport;
1417                         } else if (
1418                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1419                                 Cause_PR_protocol) {
1420                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_protocol;
1421                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1422                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.protocol;
1423                         } else if (
1424                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1425                                 Cause_PR_misc) {
1426                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_misc;
1427                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1428                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.misc;
1429                         }
1430                     }
1431                 }
1432
1433             }
1434
1435         }
1436
1437
1438         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1439         return e2err_OK;
1440     }
1441