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 = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 406         if (pRICsubscriptionFailure_IEs) {
 407             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_RICrequestID;
 408             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
 409             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
 410             pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionFailure->ricRequestID.ricRequestorID;
 411             pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionFailure->ricRequestID.ricInstanceID;
 412             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
 413         }
 414         else
 415             return e2err_RICSubscriptionFailureAllocRICrequestIDFail;
 416
 417         // RANfunctionID
 418         pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 419         if (pRICsubscriptionFailure_IEs) {
 420             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 421             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
 422             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
 423             pRICsubscriptionFailure_IEs->value.choice.RANfunctionID = pRICSubscriptionFailure->ranFunctionID;
 424             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
 425         }
 426         else
 427             return e2err_RICSubscriptionFailureAllocRANfunctionIDFail;
 428
 429         // Cause
 430         pRICsubscriptionFailure_IEs = calloc(1, sizeof(RICsubscriptionFailure_IEs_t));
 431         if (pRICsubscriptionFailure_IEs) {
 432             pRICsubscriptionFailure_IEs->id = ProtocolIE_ID_id_Cause;
 433             pRICsubscriptionFailure_IEs->criticality = Criticality_reject;
 434             pRICsubscriptionFailure_IEs->value.present = RICsubscriptionFailure_IEs__value_PR_Cause;
 435             if (pRICSubscriptionFailure->cause.content == Cause_PR_ricRequest) {
 436                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_ricRequest;
 437                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricRequest =
 438                   pRICSubscriptionFailure->cause.causeVal;
 439             }
 440             else if (pRICSubscriptionFailure->cause.content == Cause_PR_ricService) {
 441                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_ricService;
 442                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricService =
 443                   pRICSubscriptionFailure->cause.causeVal;
 444             }
 445             else if (pRICSubscriptionFailure->cause.content == Cause_PR_e2Node) {
 446                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_e2Node;
 447                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.e2Node =
 448                   pRICSubscriptionFailure->cause.causeVal;
 449             }
 450             else if (pRICSubscriptionFailure->cause.content == Cause_PR_transport) {
 451                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_transport;
 452                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.transport =
 453                   pRICSubscriptionFailure->cause.causeVal;
 454             }
 455             else if (pRICSubscriptionFailure->cause.content == Cause_PR_protocol) {
 456                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_protocol;
 457                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.protocol =
 458                   pRICSubscriptionFailure->cause.causeVal;
 459             }
 460             else if (pRICSubscriptionFailure->cause.content == Cause_PR_misc) {
 461                 pRICsubscriptionFailure_IEs->value.choice.Cause.present = Cause_PR_misc;
 462                 pRICsubscriptionFailure_IEs->value.choice.Cause.choice.misc =
 463                   pRICSubscriptionFailure->cause.causeVal;
 464             }
 465             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure.protocolIEs.list, pRICsubscriptionFailure_IEs);
 466         }
 467         else
 468             return e2err_RICSubscriptionFailureAllocCauseFail;
 469
 470         // CriticalityDiagnostics, OPTIONAL. Not used in RIC
 471
 472         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 473             return e2err_OK;
 474         else
 475             return e2err_RICSubscriptionFailureEncodeFail;
 476     }
 477     else
 478         return e2err_RICSubscriptionFailureAllocE2AP_PDUFail;
 479 }
 480
 481 //////////////////////////////////////////////////////////////////////
 482 uint64_t packRICSubscriptionDeleteRequest(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
 483
 484     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 485     if(pE2AP_PDU)
 486         {
 487         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
 488         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 489         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
 490         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest;
 491
 492         // RICrequestID
 493         RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 494         if (pRICsubscriptionDeleteRequest_IEs) {
 495             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RICrequestID;
 496             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
 497             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
 498             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID;
 499             pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID;
 500             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
 501         }
 502         else
 503             return e2err_RICSubscriptionDeleteRequestAllocRICrequestIDFail;
 504
 505         // RANfunctionID
 506         pRICsubscriptionDeleteRequest_IEs = calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 507         if (pRICsubscriptionDeleteRequest_IEs) {
 508             pRICsubscriptionDeleteRequest_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 509             pRICsubscriptionDeleteRequest_IEs->criticality = Criticality_reject;
 510             pRICsubscriptionDeleteRequest_IEs->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
 511             pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteRequest->ranFunctionID;
 512             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest.protocolIEs.list, pRICsubscriptionDeleteRequest_IEs);
 513         }
 514         else
 515             return e2err_RICSubscriptionDeleteRequestAllocRANfunctionIDFail;
 516
 517         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 518             return e2err_OK;
 519         else
 520             return e2err_RICSubscriptionDeleteRequestEncodeFail;
 521     }
 522     else
 523         return e2err_RICSubscriptionDeleteRequestAllocE2AP_PDUFail;
 524 }
 525
 526 //////////////////////////////////////////////////////////////////////
 527 uint64_t packRICSubscriptionDeleteResponse(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
 528
 529     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 530     if(pE2AP_PDU)
 531         {
 532         pE2AP_PDU->present = E2AP_PDU_PR_successfulOutcome;
 533         pE2AP_PDU->choice.successfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 534         pE2AP_PDU->choice.successfulOutcome.criticality = Criticality_ignore;
 535         pE2AP_PDU->choice.successfulOutcome.value.present = SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse;
 536
 537         // RICrequestID
 538         RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
 539         if (pRICsubscriptionDeleteResponse_IEs) {
 540             pRICsubscriptionDeleteResponse_IEs->id = ProtocolIE_ID_id_RICrequestID;
 541             pRICsubscriptionDeleteResponse_IEs->criticality = Criticality_reject;
 542             pRICsubscriptionDeleteResponse_IEs->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
 543             pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID;
 544             pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID;
 545             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs);
 546         }
 547         else
 548             return e2err_RICSubscriptionDeleteResponseAllocRICrequestIDFail;
 549
 550         // RANfunctionID
 551         pRICsubscriptionDeleteResponse_IEs = calloc(1, sizeof(RICsubscriptionDeleteResponse_IEs_t));
 552         if (pRICsubscriptionDeleteResponse_IEs) {
 553             pRICsubscriptionDeleteResponse_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 554             pRICsubscriptionDeleteResponse_IEs->criticality = Criticality_reject;
 555             pRICsubscriptionDeleteResponse_IEs->value.present = RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
 556             pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteResponse->ranFunctionID;
 557             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse.protocolIEs.list, pRICsubscriptionDeleteResponse_IEs);
 558         }
 559         else
 560             return e2err_RICSubscriptionDeleteResponseAllocRANfunctionIDFail;
 561
 562         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 563             return e2err_OK;
 564         else
 565             return e2err_RICSubscriptionDeleteResponseEncodeFail;
 566     }
 567     else
 568         return e2err_RICSubscriptionDeleteResponseAllocE2AP_PDUFail;
 569 }
 570
 571 uint64_t packRICSubscriptionDeleteFailure(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
 572
 573     E2AP_PDU_t* pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
 574     if(pE2AP_PDU)
 575         {
 576         pE2AP_PDU->present = E2AP_PDU_PR_unsuccessfulOutcome;
 577         pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 578         pE2AP_PDU->choice.unsuccessfulOutcome.criticality = Criticality_ignore;
 579         pE2AP_PDU->choice.unsuccessfulOutcome.value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
 580
 581         // RICrequestID
 582         RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 583         if (pRICsubscriptionDeleteFailure_IEs) {
 584             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_RICrequestID;
 585             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
 586             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
 587             pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID = pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID;
 588             pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID = pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID;
 589             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
 590         }
 591         else
 592             return e2err_RICSubscriptionDeleteFailureAllocRICrequestIDFail;
 593
 594         // RANfunctionID
 595         pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 596         if (pRICsubscriptionDeleteFailure_IEs) {
 597             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_RANfunctionID;
 598             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
 599             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
 600             pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID = pRICSubscriptionDeleteFailure->ranFunctionID;
 601             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
 602         }
 603         else
 604             return e2err_RICSubscriptionDeleteFailureAllocRANfunctionIDFail;
 605
 606         // Cause
 607         pRICsubscriptionDeleteFailure_IEs = calloc(1, sizeof(RICsubscriptionDeleteFailure_IEs_t));
 608         if (pRICsubscriptionDeleteFailure_IEs) {
 609             pRICsubscriptionDeleteFailure_IEs->id = ProtocolIE_ID_id_Cause;
 610             pRICsubscriptionDeleteFailure_IEs->criticality = Criticality_reject;
 611             pRICsubscriptionDeleteFailure_IEs->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_Cause;
 612             if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricRequest) {
 613                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricRequest;
 614                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest =
 615                   pRICSubscriptionDeleteFailure->cause.causeVal;
 616             }
 617             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_ricService) {
 618                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_ricService;
 619                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService =
 620                   pRICSubscriptionDeleteFailure->cause.causeVal;
 621             }
 622             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_e2Node) {
 623                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_e2Node;
 624                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.e2Node =
 625                   pRICSubscriptionDeleteFailure->cause.causeVal;
 626             }
 627             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_transport) {
 628                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_transport;
 629                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport =
 630                   pRICSubscriptionDeleteFailure->cause.causeVal;
 631             }
 632             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_protocol) {
 633                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_protocol;
 634                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol =
 635                   pRICSubscriptionDeleteFailure->cause.causeVal;
 636             }
 637             else if (pRICSubscriptionDeleteFailure->cause.content == Cause_PR_misc) {
 638                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present = Cause_PR_misc;
 639                 pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc =
 640                   pRICSubscriptionDeleteFailure->cause.causeVal;
 641             }
 642             ASN_SEQUENCE_ADD(&pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure.protocolIEs.list, pRICsubscriptionDeleteFailure_IEs);
 643         }
 644         else
 645             return e2err_RICSubscriptionDeleteFailureAllocRICcauseFail;
 646
 647         // CriticalityDiagnostics, OPTIONAL
 648
 649         if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
 650             return e2err_OK;
 651         else
 652             return e2err_RICSubscriptionDeleteFailureEncodeFail;
 653     }
 654     else
 655         return e2err_RICSubscriptionDeleteFailureAllocE2AP_PDUFail;
 656 }
 657
 658 //////////////////////////////////////////////////////////////////////
 659 e2ap_pdu_ptr_t* unpackE2AP_pdu(const size_t dataBufferSize, const byte* dataBuffer, char* pLogBuffer, E2MessageInfo_t* pMessageInfo) {
 660
 661     E2AP_PDU_t* pE2AP_PDU = 0;
 662     asn_dec_rval_t rval;
 663     rval = asn_decode(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **)&pE2AP_PDU, dataBuffer, dataBufferSize);
 664     switch (rval.code) {
 665     case RC_OK:
 666         if (debugPrints) {
 667             sprintf(pLogBuffer,"Successfully decoded E2AP-PDU");
 668             asn_fprint(stdout, &asn_DEF_E2AP_PDU, pE2AP_PDU);
 669         }
 670
 671         if (pE2AP_PDU->present == E2AP_PDU_PR_initiatingMessage) {
 672             if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscription) {
 673                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionRequest) {
 674                     pMessageInfo->messageType = cE2InitiatingMessage;
 675                     pMessageInfo->messageId = cRICSubscriptionRequest;
 676                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 677                 }
 678                 else {
 679                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
 680                     return 0;
 681                 }
 682             }
 683             else if (pE2AP_PDU->choice.initiatingMessage.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 684                 if (pE2AP_PDU->choice.initiatingMessage.value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest) {
 685                     pMessageInfo->messageType = cE2InitiatingMessage;
 686                     pMessageInfo->messageId = cRICSubscriptionDeleteRequest;
 687                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 688                 }
 689                 else {
 690                     sprintf(pLogBuffer,"Error. Not supported initiatingMessage MessageId = %u",pE2AP_PDU->choice.initiatingMessage.value.present);
 691                     return 0;
 692                 }
 693             }else if (pE2AP_PDU->choice.initiatingMessage.procedureCode ==
 694                                ProcedureCode_id_RICsubscriptionDeleteRequired) {
 695                         if (pE2AP_PDU->choice.initiatingMessage.value.present ==
 696                             InitiatingMessage__value_PR_RICsubscriptionDeleteRequired) {
 697                             pMessageInfo->messageType = cE2InitiatingMessage;
 698                             pMessageInfo->messageId = cRICSubscriptionDeleteRequired;
 699                             return (e2ap_pdu_ptr_t *) pE2AP_PDU;
 700                         } else {
 701                             sprintf(pLogBuffer, "Error. Not supported initiatingMessage MessageId = %u",
 702                                     pE2AP_PDU->choice.initiatingMessage.value.present);
 703                             return 0;
 704                         }
 705             }
 706             else {
 707                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.initiatingMessage.procedureCode);
 708                 return 0;
 709             }
 710         }
 711         else if (pE2AP_PDU->present == E2AP_PDU_PR_successfulOutcome) {
 712             if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
 713                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse) {
 714                     pMessageInfo->messageType = cE2SuccessfulOutcome;
 715                     pMessageInfo->messageId = cRICSubscriptionResponse;
 716                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 717                 }
 718                 else {
 719                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
 720                     return 0;
 721                 }
 722             }
 723             else if (pE2AP_PDU->choice.successfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 724                 if (pE2AP_PDU->choice.successfulOutcome.value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse) {
 725                     pMessageInfo->messageType = cE2SuccessfulOutcome;
 726                     pMessageInfo->messageId = cRICsubscriptionDeleteResponse;
 727                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 728                 }
 729                 else {
 730                     sprintf(pLogBuffer,"Error. Not supported successfulOutcome MessageId = %u",pE2AP_PDU->choice.successfulOutcome.value.present);
 731                     return 0;
 732                 }
 733             }
 734             else {
 735                 sprintf(pLogBuffer,"Error. Procedure not supported. ProcedureCode = %li",pE2AP_PDU->choice.successfulOutcome.procedureCode);
 736                 return 0;
 737             }
 738         }
 739         else if (pE2AP_PDU->present == E2AP_PDU_PR_unsuccessfulOutcome) {
 740             if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscription) {
 741                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionFailure) {
 742                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
 743                     pMessageInfo->messageId = cRICSubscriptionFailure;
 744                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 745                 }
 746                 else {
 747                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
 748                     return 0;
 749                 }
 750             }
 751             else if (pE2AP_PDU->choice.unsuccessfulOutcome.procedureCode == ProcedureCode_id_RICsubscriptionDelete) {
 752                 if (pE2AP_PDU->choice.unsuccessfulOutcome.value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure) {
 753                     pMessageInfo->messageType = cE2UnsuccessfulOutcome;
 754                     pMessageInfo->messageId = cRICsubscriptionDeleteFailure;
 755                     return (e2ap_pdu_ptr_t*)pE2AP_PDU;
 756                 }
 757                 else {
 758                     sprintf(pLogBuffer,"Error. Not supported unsuccessfulOutcome MessageId = %u",pE2AP_PDU->choice.unsuccessfulOutcome.value.present);
 759                     return 0;
 760                 }
 761             }
 762         }
 763         else
 764             sprintf(pLogBuffer,"Decode failed. Invalid message type %u",pE2AP_PDU->present);
 765         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 766         return 0;
 767     case RC_WMORE:
 768         sprintf(pLogBuffer,"Decode failed. More data needed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
 769         return 0;
 770     case RC_FAIL:
 771         sprintf(pLogBuffer,"Decode failed. Buffer size %zu, %s, consumed %zu",dataBufferSize, asn_DEF_E2AP_PDU.name, rval.consumed);
 772         return 0;
 773     default:
 774         return 0;
 775     }
 776 }
 777
 778 //////////////////////////////////////////////////////////////////////
 779 uint64_t getRICSubscriptionRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionRequest_t* pRICSubscriptionRequest) {
 780
 781     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
 782
 783     RICsubscriptionRequest_t *asnRicSubscriptionRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionRequest;
 784     RICsubscriptionRequest_IEs_t* pRICsubscriptionRequest_IEs;
 785
 786     // RICrequestID
 787     if (asnRicSubscriptionRequest->protocolIEs.list.count > 0 &&
 788         asnRicSubscriptionRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
 789         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[0];
 790         pRICSubscriptionRequest->ricRequestID.ricRequestorID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricRequestorID;
 791         pRICSubscriptionRequest->ricRequestID.ricInstanceID = pRICsubscriptionRequest_IEs->value.choice.RICrequestID.ricInstanceID;
 792     }
 793     else {
 794         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 795         return e2err_RICsubscriptionRequestRICrequestIDMissing;
 796     }
 797
 798     // RANfunctionID
 799     if (asnRicSubscriptionRequest->protocolIEs.list.count > 1 &&
 800         asnRicSubscriptionRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
 801         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[1];
 802         pRICSubscriptionRequest->ranFunctionID = pRICsubscriptionRequest_IEs->value.choice.RANfunctionID;
 803     }
 804     else {
 805         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 806         return e2err_RICsubscriptionRequestRANfunctionIDMissing;
 807     }
 808
 809     // RICsubscriptionDetails
 810     if (asnRicSubscriptionRequest->protocolIEs.list.count > 2 &&
 811         asnRicSubscriptionRequest->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_RICsubscriptionDetails) {
 812         pRICsubscriptionRequest_IEs = asnRicSubscriptionRequest->protocolIEs.list.array[2];
 813
 814         // Unpack EventTriggerDefinition
 815         RICeventTriggerDefinition_t* pRICeventTriggerDefinition =
 816           (RICeventTriggerDefinition_t*)&pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition;
 817         pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength = pRICeventTriggerDefinition->size;
 818         memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricEventTriggerDefinition.octetString.data, pRICeventTriggerDefinition->buf, pRICeventTriggerDefinition->size);
 819
 820         // RICactions-ToBeSetup-List
 821         RICaction_ToBeSetup_ItemIEs_t* pRICaction_ToBeSetup_ItemIEs;
 822         uint64_t index = 0;
 823         while (index < pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.count)
 824         {
 825             pRICaction_ToBeSetup_ItemIEs = (RICaction_ToBeSetup_ItemIEs_t*)pRICsubscriptionRequest_IEs->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list.array[index];
 826
 827             // RICActionID
 828             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID =
 829               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionID;
 830
 831             // RICActionType
 832             pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType =
 833               pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionType;
 834
 835             // RICactionDefinition, OPTIONAL
 836             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition)
 837             {
 838                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.contentLength =
 839                 pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size;
 840                 memcpy(pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.octetString.data,
 841                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->buf,
 842                        pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition->size);
 843
 844                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = true;
 845             }
 846             else
 847                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent = false;
 848
 849             // RICsubsequentAction, OPTIONAL
 850             RICsubsequentAction_t* pRICsubsequentAction;
 851             if (pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction)
 852             {
 853                 pRICsubsequentAction = pRICaction_ToBeSetup_ItemIEs->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction;
 854                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = true;
 855                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =
 856                   pRICsubsequentAction->ricSubsequentActionType;
 857                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =
 858                   pRICsubsequentAction->ricTimeToWait;
 859             }
 860             else
 861                 pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent = false;
 862             index++;
 863         }
 864         pRICSubscriptionRequest->ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = index;
 865     }
 866     else {
 867         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 868         return e2err_RICsubscriptionRequestICsubscriptionMissing;
 869     }
 870
 871     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 872     return e2err_OK;
 873 }
 874
 875
 876 //////////////////////////////////////////////////////////////////////
 877
 878 uint64_t getRICSubscriptionResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionResponse_t* pRICSubscriptionResponse) {
 879
 880     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
 881
 882     RICsubscriptionResponse_t *asnRicSubscriptionResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionResponse;
 883     RICsubscriptionResponse_IEs_t* pRICsubscriptionResponse_IEs;
 884
 885     bool foundRICrequestID = false;
 886     bool foundRANfunctionID = false;
 887     bool foundRICactions_Admitted = false;
 888     bool foundRICaction_NotAdmitted = false;
 889
 890     for (int i = 0; i < asnRicSubscriptionResponse->protocolIEs.list.count; i++) {
 891         if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
 892             if (checkIEOrder && i != 0) {
 893                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 894                 return e2err_RICsubscriptionResponseRICrequestIDWrongOrder;
 895             }
 896             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 897             pRICSubscriptionResponse->ricRequestID.ricRequestorID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricRequestorID;
 898             pRICSubscriptionResponse->ricRequestID.ricInstanceID = pRICsubscriptionResponse_IEs->value.choice.RICrequestID.ricInstanceID;
 899             foundRICrequestID = true;
 900         }
 901         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 902             if (checkIEOrder && i != 1) {
 903                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 904                 return e2err_RICsubscriptionResponseRANfunctionIDWrongOrder;
 905             }
 906             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 907             pRICSubscriptionResponse->ranFunctionID = pRICsubscriptionResponse_IEs->value.choice.RANfunctionID;
 908             foundRANfunctionID = true;
 909         }
 910         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_Admitted) {
 911             if (checkIEOrder && i != 2) {
 912                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 913                 return e2err_RICsubscriptionResponseRICaction_Admitted_ListWrongOrder;
 914             }
 915             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 916             pRICSubscriptionResponse->ricActionAdmittedList.contentLength = 0;
 917             uint64_t index = 0;
 918             while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.count)) {
 919                 RICaction_Admitted_ItemIEs_t* pRICaction_Admitted_ItemIEs =
 920                   (RICaction_Admitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_Admitted_List.list.array[index];
 921
 922                 // RICActionID
 923                 pRICSubscriptionResponse->ricActionAdmittedList.ricActionID[index] =
 924                   pRICaction_Admitted_ItemIEs->value.choice.RICaction_Admitted_Item.ricActionID;
 925                 index++;
 926             }
 927             pRICSubscriptionResponse->ricActionAdmittedList.contentLength = index;
 928             foundRICactions_Admitted = true;
 929         }
 930         else if (asnRicSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
 931             if (checkIEOrder && i != 3) {
 932                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 933                 return e2err_RICsubscriptionResponseRICaction_NotAdmitted_ListWrongOrder;
 934             }
 935             pRICsubscriptionResponse_IEs = asnRicSubscriptionResponse->protocolIEs.list.array[i];
 936             if (pRICsubscriptionResponse_IEs->value.present == RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List) {
 937                 pRICSubscriptionResponse->ricActionNotAdmittedListPresent = true;
 938                 pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
 939                 uint64_t index = 0;
 940                 while ((index < maxofRICactionID) && (index < pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.count)) {
 941                     RICaction_NotAdmitted_ItemIEs_t* pRICaction_NotAdmitted_ItemIEs =
 942                     (RICaction_NotAdmitted_ItemIEs_t*)pRICsubscriptionResponse_IEs->value.choice.RICaction_NotAdmitted_List.list.array[index];
 943
 944                     // RICActionID
 945                     pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID =
 946                     pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.ricActionID;
 947
 948                     //  Cause
 949                     if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricRequest) {
 950                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricRequest;
 951                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 952                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
 953                     }
 954                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_ricService) {
 955                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_ricService;
 956                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 957                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
 958                     }
 959                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_e2Node) {
 960                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_e2Node;
 961                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 962                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.e2Node;
 963                     }
 964                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_transport) {
 965                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_transport;
 966                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 967                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
 968                     }
 969                     else if (pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_protocol) {
 970                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_protocol;
 971                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 972                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
 973                     }
 974                     else if(pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.present == Cause_PR_misc) {
 975                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content = Cause_PR_misc;
 976                         pRICSubscriptionResponse->ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal =
 977                         pRICaction_NotAdmitted_ItemIEs->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
 978                     }
 979                     index++;
 980                 }
 981                 pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = index;
 982                 foundRICaction_NotAdmitted = true;
 983             }
 984         }
 985     }
 986
 987     if (!foundRICrequestID) {
 988         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 989         return e2err_RICsubscriptionResponseRICrequestIDMissing;
 990     }
 991     if (!foundRANfunctionID) {
 992         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 993         return e2err_RICsubscriptionResponseRANfunctionIDMissing;
 994     }
 995     if (!foundRICactions_Admitted) {
 996         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
 997         return e2err_RICsubscriptionResponseRICaction_Admitted_ListMissing;
 998     }
 999
1000     if (!foundRICaction_NotAdmitted) {
1001         pRICSubscriptionResponse->ricActionNotAdmittedListPresent = false;
1002         pRICSubscriptionResponse->ricActionNotAdmittedList.contentLength = 0;
1003     }
1004     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1005     return e2err_OK;
1006 }
1007
1008 //////////////////////////////////////////////////////////////////////
1009 uint64_t getRICSubscriptionFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionFailure_t* pRICSubscriptionFailure) {
1010
1011     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1012
1013     RICsubscriptionFailure_t *asnRicSubscriptionFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionFailure;
1014     RICsubscriptionFailure_IEs_t* pRICsubscriptionFailure_IEs;
1015
1016     // RICrequestID
1017     if (asnRicSubscriptionFailure->protocolIEs.list.count > 0 &&
1018         asnRicSubscriptionFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1019         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[0];
1020         pRICSubscriptionFailure->ricRequestID.ricRequestorID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricRequestorID;
1021         pRICSubscriptionFailure->ricRequestID.ricInstanceID = pRICsubscriptionFailure_IEs->value.choice.RICrequestID.ricInstanceID;
1022     }
1023     else {
1024         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1025         return e2err_RICsubscriptionFailureRICrequestIDMissing;
1026     }
1027
1028     // RANfunctionID
1029     if (asnRicSubscriptionFailure->protocolIEs.list.count > 1 &&
1030         asnRicSubscriptionFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1031         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[1];
1032         pRICSubscriptionFailure->ranFunctionID = pRICsubscriptionFailure_IEs->value.choice.RANfunctionID;
1033     }
1034     else {
1035         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1036         return e2err_RICsubscriptionFailureRANfunctionIDMissing;
1037     }
1038
1039     // Cause
1040     if (asnRicSubscriptionFailure->protocolIEs.list.count > 2 &&
1041         asnRicSubscriptionFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_Cause) {
1042         pRICsubscriptionFailure_IEs = asnRicSubscriptionFailure->protocolIEs.list.array[2];
1043         if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
1044             pRICSubscriptionFailure->cause.content = Cause_PR_ricRequest;
1045             pRICSubscriptionFailure->cause.causeVal =
1046               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricRequest;
1047         }
1048         else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
1049             pRICSubscriptionFailure->cause.content = Cause_PR_ricService;
1050             pRICSubscriptionFailure->cause.causeVal =
1051               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.ricService;
1052         }
1053         else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_e2Node) {
1054             pRICSubscriptionFailure->cause.content = Cause_PR_e2Node;
1055             pRICSubscriptionFailure->cause.causeVal =
1056               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.e2Node;
1057         }
1058         else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
1059             pRICSubscriptionFailure->cause.content = Cause_PR_transport;
1060             pRICSubscriptionFailure->cause.causeVal =
1061               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.transport;
1062         }
1063         else if (pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
1064             pRICSubscriptionFailure->cause.content = Cause_PR_protocol;
1065             pRICSubscriptionFailure->cause.causeVal =
1066               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.protocol;
1067         }
1068         else if(pRICsubscriptionFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
1069             pRICSubscriptionFailure->cause.content = Cause_PR_misc;
1070             pRICSubscriptionFailure->cause.causeVal =
1071               pRICsubscriptionFailure_IEs->value.choice.Cause.choice.misc;
1072         }
1073     }
1074     else {
1075         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1076         return e2err_RICsubscriptionFailureCauseMissing;
1077     }
1078
1079     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1080     return e2err_OK;
1081 }
1082
1083 //////////////////////////////////////////////////////////////////////
1084 uint64_t getRICSubscriptionDeleteRequestData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteRequest_t* pRICSubscriptionDeleteRequest) {
1085
1086     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1087
1088     RICsubscriptionDeleteRequest_t *asnRicSubscriptionDeleteRequest = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequest;
1089     RICsubscriptionDeleteRequest_IEs_t* pRICsubscriptionDeleteRequest_IEs;
1090
1091     // RICrequestID
1092     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 0 &&
1093         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1094         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[0];
1095         pRICSubscriptionDeleteRequest->ricRequestID.ricRequestorID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricRequestorID;
1096         pRICSubscriptionDeleteRequest->ricRequestID.ricInstanceID = pRICsubscriptionDeleteRequest_IEs->value.choice.RICrequestID.ricInstanceID;
1097     }
1098     else {
1099         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1100         return e2err_RICsubscriptionDeleteRequestRICrequestIDMissing;
1101     }
1102
1103     // RANfunctionID
1104     if (asnRicSubscriptionDeleteRequest->protocolIEs.list.count > 1 &&
1105         asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1106         pRICsubscriptionDeleteRequest_IEs = asnRicSubscriptionDeleteRequest->protocolIEs.list.array[1];
1107         pRICSubscriptionDeleteRequest->ranFunctionID = pRICsubscriptionDeleteRequest_IEs->value.choice.RANfunctionID;
1108     }
1109     else {
1110         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1111         return e2err_RICsubscriptionDeleteRequestRANfunctionIDMissing;
1112     }
1113     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1114     return e2err_OK;
1115 }
1116
1117 //////////////////////////////////////////////////////////////////////
1118 uint64_t getRICSubscriptionDeleteResponseData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteResponse_t* pRICSubscriptionDeleteResponse) {
1119
1120     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1121
1122     RICsubscriptionDeleteResponse_t *asnRicSubscriptionDeleteResponse = &pE2AP_PDU->choice.successfulOutcome.value.choice.RICsubscriptionDeleteResponse;
1123     RICsubscriptionDeleteResponse_IEs_t* pRICsubscriptionDeleteResponse_IEs;
1124
1125     // RICrequestID
1126     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 0 &&
1127         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1128         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[0];
1129         pRICSubscriptionDeleteResponse->ricRequestID.ricRequestorID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricRequestorID;
1130         pRICSubscriptionDeleteResponse->ricRequestID.ricInstanceID = pRICsubscriptionDeleteResponse_IEs->value.choice.RICrequestID.ricInstanceID;
1131     }
1132     else {
1133         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1134         return e2err_RICsubscriptionDeleteResponseRICrequestIDMissing;
1135     }
1136
1137     // RANfunctionID
1138     if (asnRicSubscriptionDeleteResponse->protocolIEs.list.count > 1 &&
1139         asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1140         pRICsubscriptionDeleteResponse_IEs = asnRicSubscriptionDeleteResponse->protocolIEs.list.array[1];
1141         pRICSubscriptionDeleteResponse->ranFunctionID = pRICsubscriptionDeleteResponse_IEs->value.choice.RANfunctionID;
1142     }
1143     else {
1144         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1145         return e2err_RICsubscriptionDeleteResponseRANfunctionIDMissing;
1146     }
1147     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1148     return e2err_OK;
1149 }
1150
1151 //////////////////////////////////////////////////////////////////////
1152 uint64_t getRICSubscriptionDeleteFailureData(e2ap_pdu_ptr_t* pE2AP_PDU_pointer, RICSubscriptionDeleteFailure_t* pRICSubscriptionDeleteFailure) {
1153
1154     E2AP_PDU_t* pE2AP_PDU = (E2AP_PDU_t*)pE2AP_PDU_pointer;
1155
1156     RICsubscriptionDeleteFailure_t *asnRicSubscriptionDeleteFailure = &pE2AP_PDU->choice.unsuccessfulOutcome.value.choice.RICsubscriptionDeleteFailure;
1157     RICsubscriptionDeleteFailure_IEs_t* pRICsubscriptionDeleteFailure_IEs;
1158
1159     // RICrequestID
1160     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 0 &&
1161         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0]->id == ProtocolIE_ID_id_RICrequestID) {
1162         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[0];
1163         pRICSubscriptionDeleteFailure->ricRequestID.ricRequestorID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricRequestorID;
1164         pRICSubscriptionDeleteFailure->ricRequestID.ricInstanceID = pRICsubscriptionDeleteFailure_IEs->value.choice.RICrequestID.ricInstanceID;
1165     }
1166     else {
1167         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1168         return e2err_RICsubscriptionDeleteFailureRICrequestIDMissing;
1169     }
1170
1171     // RANfunctionID
1172     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 1 &&
1173         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1]->id == ProtocolIE_ID_id_RANfunctionID) {
1174         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[1];
1175         pRICSubscriptionDeleteFailure->ranFunctionID = pRICsubscriptionDeleteFailure_IEs->value.choice.RANfunctionID;
1176     }
1177     else {
1178         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1179         return e2err_RICsubscriptionDeleteFailureRANfunctionIDMissing;
1180     }
1181
1182     // Cause
1183     if (asnRicSubscriptionDeleteFailure->protocolIEs.list.count > 2 &&
1184         asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2]->id == ProtocolIE_ID_id_Cause) {
1185         pRICsubscriptionDeleteFailure_IEs = asnRicSubscriptionDeleteFailure->protocolIEs.list.array[2];
1186         if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricRequest) {
1187             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricRequest;
1188             pRICSubscriptionDeleteFailure->cause.causeVal =
1189               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricRequest;
1190         }
1191         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_ricService) {
1192             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_ricService;
1193             pRICSubscriptionDeleteFailure->cause.causeVal =
1194               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.ricService;
1195         }
1196         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_e2Node) {
1197             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_e2Node;
1198             pRICSubscriptionDeleteFailure->cause.causeVal =
1199               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.e2Node;
1200         }
1201         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_transport) {
1202             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_transport;
1203             pRICSubscriptionDeleteFailure->cause.causeVal =
1204               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.transport;
1205         }
1206         else if (pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_protocol) {
1207             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_protocol;
1208             pRICSubscriptionDeleteFailure->cause.causeVal =
1209               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.protocol;
1210         }
1211         else if(pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.present == Cause_PR_misc) {
1212             pRICSubscriptionDeleteFailure->cause.content = Cause_PR_misc;
1213             pRICSubscriptionDeleteFailure->cause.causeVal =
1214               pRICsubscriptionDeleteFailure_IEs->value.choice.Cause.choice.misc;
1215         }
1216     }
1217     else {
1218         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1219         return e2err_RICsubscriptionDeleteFailureRICcauseMissing;
1220     }
1221     // CriticalityDiagnostics, OPTIONAL
1222
1223     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1224     return e2err_OK;
1225 }
1226
1227 //**************************************************************************************************************************
1228 uint64_t packRICSubscriptionDeleteRequired(size_t* pDataBufferSize, byte* pDataBuffer, char* pLogBuffer, RICSubsDeleteRequired_t* pRICSubscriptionDeleteRequired) {
1229
1230     E2AP_PDU_t *pE2AP_PDU = calloc(1, sizeof(E2AP_PDU_t));
1231     if (pE2AP_PDU) {
1232         pE2AP_PDU->present = E2AP_PDU_PR_initiatingMessage;
1233         pE2AP_PDU->choice.initiatingMessage.procedureCode = ProcedureCode_id_RICsubscriptionDeleteRequired;
1234         pE2AP_PDU->choice.initiatingMessage.criticality = Criticality_ignore;
1235         pE2AP_PDU->choice.initiatingMessage.value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequired;
1236
1237         {
1238             RICsubscriptionDeleteRequired_IEs_t *ricSubsDeleteRequiredIEs = calloc(1,
1239                                                                                    sizeof(RICsubscriptionDeleteRequired_IEs_t));
1240             ricSubsDeleteRequiredIEs->id = ProtocolIE_ID_id_RICsubscriptionToBeRemoved;
1241             ricSubsDeleteRequiredIEs->criticality = Criticality_ignore;
1242             ricSubsDeleteRequiredIEs->value.present = RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause;
1243
1244             for (int idx = 0; idx < pRICSubscriptionDeleteRequired->noOfRanSubscriptions; idx++) {
1245                 RICsubscription_withCause_ItemIEs_t *ricSubsListWithCauseItem = calloc(1,
1246                                                                                        sizeof(RICsubscription_withCause_ItemIEs_t));
1247                 ricSubsListWithCauseItem->id = ProtocolIE_ID_id_RICsubscription_withCause_Item;
1248                 ricSubsListWithCauseItem->criticality = Criticality_ignore;
1249                 ricSubsListWithCauseItem->value.present = RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item;
1250
1251                 // RIC RequestID
1252                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ricRequestID.ricRequestorID =
1253                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID;
1254                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ricRequestID.ricInstanceID =
1255                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID;
1256
1257                 // RANFunctionID
1258                 ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.ranFunctionID =
1259                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ranFunctionID;
1260
1261                 // RICCause
1262                 if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1263                     Cause_PR_ricRequest) {
1264                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_ricRequest;
1265                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.ricRequest =
1266                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1267                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1268                            Cause_PR_ricService) {
1269                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_ricService;
1270                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.ricService =
1271                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1272                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1273                            Cause_PR_e2Node) {
1274                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_e2Node;
1275                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.e2Node =
1276                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1277                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1278                            Cause_PR_protocol) {
1279                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_protocol;
1280                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.protocol =
1281                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1282                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1283                            Cause_PR_transport) {
1284                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_transport;
1285                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.transport =
1286                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1287                 } else if (pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content ==
1288                            Cause_PR_misc) {
1289                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.present = Cause_PR_misc;
1290                     ricSubsListWithCauseItem->value.choice.RICsubscription_withCause_Item.cause.choice.misc =
1291                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal;
1292                 }
1293                 asn_sequence_add(&ricSubsDeleteRequiredIEs->value.choice.RICsubscription_List_withCause.list,
1294                                  ricSubsListWithCauseItem);
1295             }
1296             asn_sequence_add(
1297                     &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequired.protocolIEs.list,
1298                     ricSubsDeleteRequiredIEs);
1299
1300             if (E2encode(pE2AP_PDU, pDataBufferSize, pDataBuffer, pLogBuffer))
1301                 return e2err_OK;
1302             else
1303                 return e2err_RICSubscriptionDeleteRequiredEncodeFail;
1304         }
1305     }
1306     else
1307         return e2err_RICSubscriptionDeleteRequiredAllocE2AP_PDUFail;
1308 }
1309
1310 //**************************************************************************************************************************
1311 uint64_t getRICSubscriptionDeleteRequiredData(e2ap_pdu_ptr_t *pE2AP_PDU_pointer,
1312                                                   RICSubsDeleteRequired_t *pRICSubscriptionDeleteRequired) {
1313
1314         E2AP_PDU_t *pE2AP_PDU = (E2AP_PDU_t *) pE2AP_PDU_pointer;
1315
1316         RICsubscriptionDeleteRequired_t *asnRicSubscriptionDeleteRequired = &pE2AP_PDU->choice.initiatingMessage.value.choice.RICsubscriptionDeleteRequired;
1317
1318         if (asnRicSubscriptionDeleteRequired->protocolIEs.list.count > 0 &&
1319             asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->id ==
1320             ProtocolIE_ID_id_RICsubscriptionToBeRemoved) {
1321             if (asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->value.present ==
1322                 RICsubscriptionDeleteRequired_IEs__value_PR_RICsubscription_List_withCause) {
1323                 RICsubscription_List_withCause_t riCsubscriptionListWithCause = asnRicSubscriptionDeleteRequired->protocolIEs.list.array[0]->value.choice.RICsubscription_List_withCause;
1324                 pRICSubscriptionDeleteRequired->noOfRanSubscriptions = riCsubscriptionListWithCause.list.count;
1325                 for (int idx = 0; idx < riCsubscriptionListWithCause.list.count; idx++) {
1326                     RICsubscription_withCause_ItemIEs_t *riCsubscriptionWithCauseItemIEs = (RICsubscription_withCause_ItemIEs_t*)riCsubscriptionListWithCause.list.array[idx];
1327                     if (riCsubscriptionWithCauseItemIEs->id == ProtocolIE_ID_id_RICsubscription_withCause_Item &&
1328                             riCsubscriptionWithCauseItemIEs->value.present ==
1329                         RICsubscription_withCause_ItemIEs__value_PR_RICsubscription_withCause_Item) {
1330                         // RIC RequestID
1331                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricRequestorID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ricRequestID.ricRequestorID;
1332                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ricRequestID.ricInstanceID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ricRequestID.ricInstanceID;
1333
1334                         // RANFunctionID
1335                         pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].ranFunctionID = riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.ranFunctionID;
1336
1337                         // RICCause
1338                         if (riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1339                             Cause_PR_ricRequest) {
1340                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_ricRequest;
1341                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1342                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.ricRequest;
1343                         }
1344                             //TODO : RIC Cause
1345                         else if (riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1346                                  Cause_PR_ricService) {
1347                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_ricService;
1348                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1349                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.ricService;
1350                         } else if (
1351                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1352                                 Cause_PR_transport) {
1353                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_transport;
1354                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1355                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.transport;
1356                         } else if (
1357                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1358                                 Cause_PR_protocol) {
1359                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_protocol;
1360                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1361                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.protocol;
1362                         } else if (
1363                                 riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.present ==
1364                                 Cause_PR_misc) {
1365                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.content = Cause_PR_misc;
1366                             pRICSubscriptionDeleteRequired->ranSubscriptionsDelRequired[idx].cause.causeVal =
1367                                     riCsubscriptionWithCauseItemIEs->value.choice.RICsubscription_withCause_Item.cause.choice.misc;
1368                         }
1369                     }
1370                 }
1371
1372             }
1373
1374         }
1375
1376
1377         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pE2AP_PDU);
1378         return e2err_OK;
1379     }
1380