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