e2ap/libe2ap_wrapper/E2AP_if.c

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