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