Bouncer/e2ap/wrapper.c

   1 #include <errno.h>
   2 #include "wrapper.h"
   3
   4 size_t encode_E2AP_PDU(E2AP_PDU_t* pdu, void* buffer, size_t buf_size)
   5 {
   6     asn_enc_rval_t encode_result;
   7     encode_result = aper_encode_to_buffer(&asn_DEF_E2AP_PDU, NULL, pdu, buffer, buf_size);
   8     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
   9     if(encode_result.encoded == -1) {
  10         fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
  11         return -1;
  12     } else {
  13         return encode_result.encoded;
  14     }
  15 }
  16
  17 E2AP_PDU_t* decode_E2AP_PDU(const void* buffer, size_t buf_size)
  18 {
  19     asn_dec_rval_t decode_result;
  20     E2AP_PDU_t *pdu = 0;
  21     decode_result = aper_decode_complete(NULL, &asn_DEF_E2AP_PDU, (void **)&pdu, buffer, buf_size);
  22     //xer_fprint(stderr, &asn_DEF_E2AP_PDU,pdu);
  23     if(decode_result.code == RC_OK) {
  24         xer_fprint(stderr, &asn_DEF_E2AP_PDU,pdu);
  25         return pdu;
  26     } else {
  27         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  28         return 0;
  29     }
  30 }
  31
  32 /* RICsubscriptionRequest */
  33 long e2ap_get_ric_subscription_request_sequence_number(void *buffer, size_t buf_size)
  34 {
  35     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  36     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  37     {
  38         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
  39         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscription
  40             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
  41         {
  42             RICsubscriptionRequest_t *ric_subscription_request = &(initiatingMessage->value.choice.RICsubscriptionRequest);
  43             for (int i = 0; i < ric_subscription_request->protocolIEs.list.count; ++i )
  44             {
  45                 if ( ric_subscription_request->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  46                 {
  47                     long sequenceNumber = ric_subscription_request->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
  48                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  49                     return sequenceNumber;
  50                 }
  51             }
  52         }
  53     }
  54
  55     if(pdu != NULL)
  56         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  57     return -1;
  58 }
  59
  60 ssize_t  e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
  61 {
  62     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  63     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  64     {
  65         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
  66         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscription
  67             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
  68         {
  69             RICsubscriptionRequest_t *ricSubscriptionRequest = &initiatingMessage->value.choice.RICsubscriptionRequest;
  70             for (int i = 0; i < ricSubscriptionRequest->protocolIEs.list.count; ++i )
  71             {
  72                 if ( ricSubscriptionRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  73                 {
  74                     ricSubscriptionRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
  75                     return encode_E2AP_PDU(pdu, buffer, buf_size);
  76                 }
  77             }
  78         }
  79     }
  80
  81     if(pdu != NULL)
  82         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  83     return -1;
  84 }
  85
  86 ssize_t e2ap_encode_ric_subscription_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber, long ranFunctionID, void *eventTriggerDefinition, size_t eventTriggerDefinitionSize, int actionCount, long *actionIds, long* actionTypes, RICactionDefinition *actionDefinitions, RICSubsequentAction *subsequentActionTypes)
  87 {
  88     E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
  89     if(!init) {
  90         fprintf(stderr, "alloc E2AP_PDU failed\n");
  91         return -1;
  92     }
  93
  94     InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
  95     if(!initiatingMsg) {
  96         fprintf(stderr, "alloc InitiatingMessage failed\n");
  97         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
  98         return -1;
  99     }
 100
 101     init->choice.initiatingMessage = initiatingMsg;
 102     init->present = E2AP_PDU_PR_initiatingMessage;
 103
 104     initiatingMsg->procedureCode = ProcedureCode_id_RICsubscription;
 105     initiatingMsg->criticality = Criticality_reject;
 106     initiatingMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
 107
 108     RICsubscriptionRequest_t *subscription_request = &initiatingMsg->value.choice.RICsubscriptionRequest;
 109
 110     // request contains 5 IEs
 111
 112     // RICrequestID
 113     RICsubscriptionRequest_IEs_t *ies_reqID = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 114     if(!ies_reqID) {
 115         fprintf(stderr, "alloc RICrequestID failed\n");
 116         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 117         return -1;
 118     }
 119
 120     ies_reqID->criticality = Criticality_reject;
 121     ies_reqID->id = ProtocolIE_ID_id_RICrequestID;
 122     ies_reqID->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 123     RICrequestID_t *ricrequest_ie = &ies_reqID->value.choice.RICrequestID;
 124     ricrequest_ie->ricRequestorID = ricRequestorID;
 125     ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
 126     ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_reqID);
 127
 128     // RICfunctionID
 129     RICsubscriptionRequest_IEs_t *ies_ranfunc = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 130     if(!ies_ranfunc) {
 131         fprintf(stderr, "alloc RICfunctionID failed\n");
 132         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 133         return -1;
 134     }
 135
 136     ies_ranfunc->criticality = Criticality_reject;
 137     ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 138     ies_ranfunc->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 139     RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 140     *ranfunction_ie = ranFunctionID;
 141     ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_ranfunc);
 142
 143     // RICsubscription
 144     RICsubscriptionRequest_IEs_t *ies_subscription = (RICsubscriptionRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 145     if(!ies_subscription) {
 146         fprintf(stderr, "alloc RICsubscription failed\n");
 147         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 148         return -1;
 149     }
 150
 151     ies_subscription->criticality = Criticality_reject;
 152     ies_subscription->id = ProtocolIE_ID_id_RICsubscriptionDetails;
 153     ies_subscription->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 154     RICsubscriptionDetails_t *ricsubscription_ie = &ies_subscription->value.choice.RICsubscriptionDetails;
 155
 156     // RICeventTriggerDefinition
 157     RICeventTriggerDefinition_t *eventTrigger = &ricsubscription_ie->ricEventTriggerDefinition;
 158     eventTrigger->buf = (uint8_t *)calloc(1, eventTriggerDefinitionSize);
 159     if(!eventTrigger->buf) {
 160         fprintf(stderr, "alloc eventTrigger failed\n");
 161         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 162         return -1;
 163     }
 164
 165     memcpy(eventTrigger->buf, eventTriggerDefinition, eventTriggerDefinitionSize);
 166     eventTrigger->size = eventTriggerDefinitionSize;
 167
 168     // RICactions-ToBeSetup-List
 169     RICactions_ToBeSetup_List_t *ricActions = &ricsubscription_ie->ricAction_ToBeSetup_List;
 170     int index = 0;
 171     while (index < actionCount) {
 172         RICaction_ToBeSetup_ItemIEs_t *ies_action = (RICaction_ToBeSetup_ItemIEs_t *)calloc(1, sizeof(RICaction_ToBeSetup_ItemIEs_t));
 173         if(!ies_action) {
 174             fprintf(stderr, "alloc RICaction failed\n");
 175             ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 176             return -1;
 177         }
 178
 179         ies_action->criticality = Criticality_reject;
 180         ies_action->id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
 181         ies_action->value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 182         RICaction_ToBeSetup_Item_t *ricaction_ie = &ies_action->value.choice.RICaction_ToBeSetup_Item;
 183         ricaction_ie->ricActionID = actionIds[index];
 184         ricaction_ie->ricActionType = actionTypes[index];
 185
 186         int actionDefinitionSize = actionDefinitions[index].size;
 187         if(actionDefinitionSize != 0) {
 188             RICactionDefinition_t *actionDefinition = ricaction_ie->ricActionDefinition;
 189
 190             actionDefinition->buf = (uint8_t *)calloc(1, actionDefinitionSize);
 191             if(!actionDefinition->buf) {
 192                 fprintf(stderr, "alloc actionDefinition[%d] failed\n", index);
 193                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 194                 return -1;
 195             }
 196
 197             memcpy(actionDefinition->buf, actionDefinitions[index].actionDefinition, actionDefinitionSize);
 198             actionDefinition->size = actionDefinitionSize;
 199         }
 200
 201         if(subsequentActionTypes[index].isValid != 0) {
 202             RICsubsequentAction_t *subsequentAction = ricaction_ie->ricSubsequentAction;
 203             subsequentAction->ricSubsequentActionType = subsequentActionTypes[index].subsequentActionType;
 204             subsequentAction->ricTimeToWait = subsequentActionTypes[index].timeToWait;
 205         }
 206
 207         ASN_SEQUENCE_ADD(&ricActions->list, ies_action);
 208         index++;
 209     }
 210     ASN_SEQUENCE_ADD(&subscription_request->protocolIEs.list, ies_subscription);
 211
 212     return encode_E2AP_PDU(init, buffer, buf_size);
 213 }
 214
 215 /* RICsubscriptionResponse */
 216 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
 217 {
 218     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 219     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 220     {
 221         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 222         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
 223             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
 224         {
 225             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
 226             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
 227             {
 228                 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 229                 {
 230                     long sequenceNumber = ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 231                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 232                     return sequenceNumber;
 233                 }
 234             }
 235         }
 236     }
 237
 238     if(pdu != NULL)
 239         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 240     return -1;
 241 }
 242
 243 ssize_t  e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 244 {
 245     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 246     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 247     {
 248         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 249         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
 250             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
 251         {
 252             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
 253             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
 254             {
 255                 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 256                 {
 257                     ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
 258                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 259                 }
 260             }
 261         }
 262     }
 263
 264     if(pdu != NULL)
 265         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 266     return -1;
 267 }
 268
 269 RICsubscriptionResponseMsg* e2ap_decode_ric_subscription_response_message(void *buffer, size_t buf_size)
 270 {
 271     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 272     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 273     {
 274         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 275         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
 276             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
 277         {
 278             RICsubscriptionResponse_t *subscriptionResponse = &(successfulOutcome->value.choice.RICsubscriptionResponse);
 279             RICsubscriptionResponseMsg *msg = (RICsubscriptionResponseMsg *)calloc(1, sizeof(RICsubscriptionResponseMsg));
 280             for (int i = 0; i < subscriptionResponse->protocolIEs.list.count; ++i )
 281             {
 282                 if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
 283                     msg->requestorID = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 284                     msg->requestSequenceNumber = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 285                 }
 286                 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 287                     msg->ranfunctionID = subscriptionResponse->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 288                 }
 289                 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_Admitted) {
 290                     RICaction_Admitted_List_t *ricActionAdmittedList = &(subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICaction_Admitted_List);
 291                     int index = 0;
 292                     while (index < ricActionAdmittedList->list.count) {
 293                         RICaction_Admitted_ItemIEs_t *ricActionAdmittedItem = (RICaction_Admitted_ItemIEs_t *)ricActionAdmittedList->list.array[index];
 294                         if (ricActionAdmittedItem->id == ProtocolIE_ID_id_RICaction_Admitted_Item) {
 295                             msg->ricActionAdmittedList.ricActionID[index] = ricActionAdmittedItem->value.choice.RICaction_Admitted_Item.ricActionID;
 296                         }
 297                         index++;
 298                     }
 299                     msg->ricActionAdmittedList.count = index;
 300                 }
 301                 else if (subscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactions_NotAdmitted) {
 302                     RICaction_NotAdmitted_List_t *ricActionNotAdmittedList = &(subscriptionResponse->protocolIEs.list.array[i]->value.choice.RICaction_NotAdmitted_List);
 303                     int index = 0;
 304                     while (index < ricActionNotAdmittedList->list.count) {
 305                         RICaction_NotAdmitted_ItemIEs_t *ricActionNotAdmittedItem = (RICaction_NotAdmitted_ItemIEs_t *)ricActionNotAdmittedList->list.array[index];
 306                         if (ricActionNotAdmittedItem->id == ProtocolIE_ID_id_RICaction_NotAdmitted_Item) {
 307                             msg->ricActionNotAdmittedList.ricActionID[index] = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.ricActionID;
 308                             int RICcauseType = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.present;
 309                             switch(RICcauseType) {
 310                                 case Cause_PR_ricRequest:
 311                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_ricRequest;
 312                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricRequest;
 313                                     break;
 314                                 case Cause_PR_ricService:
 315                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_ricService;
 316                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.ricService;
 317                                     break;
 318                                 case Cause_PR_transport:
 319                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_transport;
 320                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.transport;
 321                                     break;
 322                                 case Cause_PR_protocol:
 323                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_protocol;
 324                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.protocol;
 325                                     break;
 326                                 case Cause_PR_misc:
 327                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseType = Cause_PR_misc;
 328                                     msg->ricActionNotAdmittedList.ricCause[index].ricCauseID = ricActionNotAdmittedItem->value.choice.RICaction_NotAdmitted_Item.cause.choice.misc;
 329                                     break;
 330                             }
 331                         }
 332                         index++;
 333                     }
 334                     msg->ricActionNotAdmittedList.count = index;
 335                 }
 336             }
 337             return msg;
 338         }
 339     }
 340     return NULL;
 341 }
 342
 343 /* RICsubscriptionFailure */
 344 long e2ap_get_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size)
 345 {
 346     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 347     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome )
 348     {
 349         UnsuccessfulOutcome_t* unsuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
 350         if ( unsuccessfulOutcome->procedureCode == ProcedureCode_id_RICsubscription
 351             && unsuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
 352         {
 353             RICsubscriptionFailure_t *ricSubscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
 354             for (int i = 0; i < ricSubscriptionFailure->protocolIEs.list.count; ++i )
 355             {
 356                 if ( ricSubscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 357                 {
 358                     long sequenceNumber = ricSubscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 359                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 360                     return sequenceNumber;
 361                 }
 362             }
 363         }
 364     }
 365
 366     if(pdu != NULL)
 367         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 368     return -1;
 369 }
 370
 371 /* RICsubscriptionDeleteRequest */
 372 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
 373 {
 374     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 375     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
 376     {
 377         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 378         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscriptionDelete
 379             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 380         {
 381             RICsubscriptionDeleteRequest_t *subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 382             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
 383             {
 384                 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 385                 {
 386                     long sequenceNumber = subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 387                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 388                     return sequenceNumber;
 389                 }
 390             }
 391         }
 392     }
 393
 394     if(pdu != NULL)
 395         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 396     return -1;
 397 }
 398
 399 ssize_t  e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 400 {
 401     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 402     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
 403     {
 404         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 405         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICsubscriptionDelete
 406             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 407         {
 408             RICsubscriptionDeleteRequest_t* subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 409             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
 410             {
 411                 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 412                 {
 413                     subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
 414                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 415                 }
 416             }
 417         }
 418     }
 419
 420     if(pdu != NULL)
 421         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 422     return -1;
 423 }
 424
 425 ssize_t e2ap_encode_ric_subscription_delete_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber, long ranFunctionID)
 426 {
 427     E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
 428     if(!init) {
 429         fprintf(stderr, "alloc E2AP_PDU failed\n");
 430         return -1;
 431     }
 432
 433     InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
 434     if(!initiatingMsg) {
 435         fprintf(stderr, "alloc InitiatingMessage failed\n");
 436         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 437         return -1;
 438     }
 439
 440     init->choice.initiatingMessage = initiatingMsg;
 441     init->present = E2AP_PDU_PR_initiatingMessage;
 442
 443     initiatingMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 444     initiatingMsg->criticality = Criticality_reject;
 445     initiatingMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionDeleteRequest;
 446
 447     RICsubscriptionDeleteRequest_t *subscription_delete_request = &initiatingMsg->value.choice.RICsubscriptionDeleteRequest;
 448
 449     // request contains 2 IEs
 450
 451     // RICrequestID
 452     RICsubscriptionDeleteRequest_IEs_t *ies_reqID = (RICsubscriptionDeleteRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 453     if(!ies_reqID) {
 454         fprintf(stderr, "alloc RICrequestID failed\n");
 455         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 456         return -1;
 457     }
 458
 459     ies_reqID->criticality = Criticality_reject;
 460     ies_reqID->id = ProtocolIE_ID_id_RICrequestID;
 461     ies_reqID->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RICrequestID;
 462     RICrequestID_t *ricrequest_ie = &ies_reqID->value.choice.RICrequestID;
 463     ricrequest_ie->ricRequestorID = ricRequestorID;
 464     ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
 465     ASN_SEQUENCE_ADD(&subscription_delete_request->protocolIEs.list, ies_reqID);
 466
 467     // RICfunctionID
 468     RICsubscriptionDeleteRequest_IEs_t *ies_ranfunc = (RICsubscriptionDeleteRequest_IEs_t *)calloc(1, sizeof(RICsubscriptionDeleteRequest_IEs_t));
 469     if(!ies_ranfunc) {
 470         fprintf(stderr, "alloc RICfunctionID failed\n");
 471         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 472         return -1;
 473     }
 474
 475     ies_ranfunc->criticality = Criticality_reject;
 476     ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 477     ies_ranfunc->value.present = RICsubscriptionDeleteRequest_IEs__value_PR_RANfunctionID;
 478     RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 479     *ranfunction_ie = ranFunctionID;
 480     ASN_SEQUENCE_ADD(&subscription_delete_request->protocolIEs.list, ies_ranfunc);
 481
 482     return encode_E2AP_PDU(init, buffer, buf_size);
 483 }
 484
 485 /* RICsubscriptionDeleteResponse */
 486 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
 487 {
 488     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 489     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 490     {
 491         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 492         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
 493             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 494         {
 495             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 496             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
 497             {
 498                 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 499                 {
 500                     long sequenceNumber = subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 501                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 502                     return sequenceNumber;
 503                 }
 504             }
 505         }
 506     }
 507
 508     if(pdu != NULL)
 509         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 510     return -1;
 511 }
 512
 513 ssize_t  e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 514 {
 515     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 516     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 517     {
 518         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 519         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
 520             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 521         {
 522             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 523             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
 524             {
 525                 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 526                 {
 527                     subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID = sequence_number;
 528                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 529                 }
 530             }
 531         }
 532     }
 533
 534     if(pdu != NULL)
 535         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 536     return -1;
 537 }
 538
 539 /* RICsubscriptionDeleteFailure */
 540 long e2ap_get_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size)
 541 {
 542     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 543     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome )
 544     {
 545         UnsuccessfulOutcome_t* unsuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
 546         if ( unsuccessfulOutcome->procedureCode == ProcedureCode_id_RICsubscriptionDelete
 547             && unsuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
 548         {
 549             RICsubscriptionDeleteFailure_t *ricSubscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
 550             for (int i = 0; i < ricSubscriptionDeleteFailure->protocolIEs.list.count; ++i )
 551             {
 552                 if ( ricSubscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 553                 {
 554                     long sequenceNumber = ricSubscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 555                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 556                     return sequenceNumber;
 557                 }
 558             }
 559         }
 560     }
 561
 562     if(pdu != NULL)
 563         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 564     return -1;
 565 }
 566
 567 /* RICindication */
 568
 569 RICindicationMsg* e2ap_decode_ric_indication_message(void *buffer, size_t buf_size)
 570 {
 571     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 572     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
 573     {
 574         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 575         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICindication
 576             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICindication)
 577         {
 578             RICindication_t *indication = &(initiatingMessage->value.choice.RICindication);
 579             RICindicationMsg *msg = (RICindicationMsg *)calloc(1, sizeof(RICindicationMsg));
 580             for (int i = 0; i < indication->protocolIEs.list.count; ++i )
 581             {
 582                 if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
 583                     msg->requestorID = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 584                     msg->requestSequenceNumber = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 585                 }
 586                 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 587                     msg->ranfunctionID = indication->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 588                 }
 589                 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactionID) {
 590                     msg->actionID = indication->protocolIEs.list.array[i]->value.choice.RICactionID;
 591                 }
 592                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationSN) {
 593                     msg->indicationSN = indication->protocolIEs.list.array[i]->value.choice.RICindicationSN;
 594                 }
 595                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationType) {
 596                     msg->indicationType = indication->protocolIEs.list.array[i]->value.choice.RICindicationType;
 597                 }
 598                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationHeader) {
 599                     size_t headerSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.size;
 600                     msg->indicationHeader = calloc(1, headerSize);
 601                     if (!msg->indicationHeader) {
 602                         fprintf(stderr, "alloc RICindicationHeader failed\n");
 603                         e2ap_free_decoded_ric_indication_message(msg);
 604                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 605                         return NULL;
 606                     }
 607
 608                     memcpy(msg->indicationHeader, indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.buf, headerSize);
 609                     msg->indicationHeaderSize = headerSize;
 610                 }
 611                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationMessage) {
 612                     size_t messsageSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.size;
 613                     msg->indicationMessage = calloc(1, messsageSize);
 614                     if (!msg->indicationMessage) {
 615                         fprintf(stderr, "alloc RICindicationMessage failed\n");
 616                         e2ap_free_decoded_ric_indication_message(msg);
 617                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 618                         return NULL;
 619                     }
 620
 621                     memcpy(msg->indicationMessage, indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.buf, messsageSize);
 622                     msg->indicationMessageSize = messsageSize;
 623                 }
 624                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 625                     size_t callProcessIDSize = indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 626                     msg->callProcessID = calloc(1, callProcessIDSize);
 627                     if (!msg->callProcessID) {
 628                         fprintf(stderr, "alloc RICcallProcessID failed\n");
 629                         e2ap_free_decoded_ric_indication_message(msg);
 630                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 631                         return NULL;
 632                     }
 633
 634                     memcpy(msg->callProcessID, indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
 635                     msg->callProcessIDSize = callProcessIDSize;
 636                 }
 637             }
 638             return msg;
 639         }
 640     }
 641
 642     if(pdu != NULL)
 643         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 644     return NULL;
 645 }
 646
 647
 648 RICindicationMsg* e2ap_decode_ric_indication_m()
 649 {
 650
 651
 652                 FILE *fp3 = fopen("sandy3.txt", "r");
 653                 if (fp3==NULL)
 654                 {
 655                  printf("\nFAILED TO OPEN FILE SANDY3.TXT");
 656                  return NULL;
 657                 }
 658                 fseek(fp3, 0L, SEEK_END);
 659                 long numbytes = ftell(fp3);
 660                 fseek(fp3, 0L, SEEK_SET);
 661                 char* text = (char*)calloc(numbytes, sizeof(char));
 662                 fread(text, sizeof(char), numbytes, fp3);
 663                 fclose(fp3);
 664                 printf(text);
 665                 E2AP_PDU_t *pdu=0;
 666                 asn_dec_rval_t lol =xer_decode(0,&asn_DEF_E2AP_PDU, (void **)&pdu,text,numbytes);
 667                 printf("\nxer decode result =%d",lol.code);
 668                 FILE *fp4 = fopen("sandy4.txt", "w");
 669                 int r2=asn_fprint(fp4,&asn_DEF_E2AP_PDU,pdu);
 670                 fclose(fp4);
 671                 if (r2==-1)
 672                          fprintf(stderr, "failed asn_fprint r2\n");
 673                 else
 674                          fprintf(stderr, "successfull asn_fprint r2\n");
 675
 676
 677     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
 678     {
 679         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 680         if ( initiatingMessage->procedureCode == ProcedureCode_id_RICindication
 681             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICindication)
 682         {
 683             RICindication_t *indication = &(initiatingMessage->value.choice.RICindication);
 684             RICindicationMsg *msg = (RICindicationMsg *)calloc(1, sizeof(RICindicationMsg));
 685             for (int i = 0; i < indication->protocolIEs.list.count; ++i )
 686             {
 687                 if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID) {
 688                     msg->requestorID = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 689                     msg->requestSequenceNumber = indication->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 690                 }
 691                 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 692                     msg->ranfunctionID = indication->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 693                 }
 694                 else if (indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICactionID) {
 695                     msg->actionID = indication->protocolIEs.list.array[i]->value.choice.RICactionID;
 696                 }
 697                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationSN) {
 698                     msg->indicationSN = indication->protocolIEs.list.array[i]->value.choice.RICindicationSN;
 699                 }
 700                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationType) {
 701                     msg->indicationType = indication->protocolIEs.list.array[i]->value.choice.RICindicationType;
 702                 }
 703                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationHeader) {
 704                     size_t headerSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.size;
 705                     msg->indicationHeader = calloc(1, headerSize);
 706                     if (!msg->indicationHeader) {
 707                         fprintf(stderr, "alloc RICindicationHeader failed\n");
 708                         e2ap_free_decoded_ric_indication_message(msg);
 709                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 710                         return NULL;
 711                     }
 712
 713                     memcpy(msg->indicationHeader, indication->protocolIEs.list.array[i]->value.choice.RICindicationHeader.buf, headerSize);
 714                     msg->indicationHeaderSize = headerSize;
 715                 }
 716                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICindicationMessage) {
 717                     size_t messsageSize = indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.size;
 718                     msg->indicationMessage = calloc(1, messsageSize);
 719                     if (!msg->indicationMessage) {
 720                         fprintf(stderr, "alloc RICindicationMessage failed\n");
 721                         e2ap_free_decoded_ric_indication_message(msg);
 722                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 723                         return NULL;
 724                     }
 725
 726                     memcpy(msg->indicationMessage, indication->protocolIEs.list.array[i]->value.choice.RICindicationMessage.buf, messsageSize);
 727                     msg->indicationMessageSize = messsageSize;
 728                 }
 729                 else if(indication->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 730                     size_t callProcessIDSize = indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 731                     msg->callProcessID = calloc(1, callProcessIDSize);
 732                     if (!msg->callProcessID) {
 733                         fprintf(stderr, "alloc RICcallProcessID failed\n");
 734                         e2ap_free_decoded_ric_indication_message(msg);
 735                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 736                         return NULL;
 737                     }
 738
 739                     memcpy(msg->callProcessID, indication->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
 740                     msg->callProcessIDSize = callProcessIDSize;
 741                 }
 742             }
 743 /*
 744                 RICindicationHeader_t *hdr;
 745                 hdr=calloc(1, sizeof(RICindicationHeader_t));
 746                 memcpy( hdr->buf,msg->indicationHeader,msg->indicationHeaderSize);
 747                 hdr->size=msg->indicationHeaderSize;
 748              xer_fprint(stdout, &asn_DEF_RICindicationHeader,hdr);
 749              RICindicationMessage_t *indm;
 750              indm=calloc(1, sizeof(RICindicationMessage_t));
 751              memcpy(indm->buf, msg->indicationMessage,msg->indicationMessageSize);
 752              indm->size=msg->indicationMessageSize;
 753           xer_fprint(stdout, &asn_DEF_RICindicationMessage, indm);
 754 */
 755 //        fprintf(stderr, "\nreturning msg\n");
 756
 757             return msg;
 758         }
 759     }
 760  //fprintf(stderr, "\nreturning null");
 761     if(pdu != NULL)
 762         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 763     return NULL;
 764 }
 765
 766 void e2ap_free_decoded_ric_indication_message(RICindicationMsg* msg) {
 767     if(msg == NULL) {
 768         return;
 769     }
 770
 771     if(msg->indicationHeader != NULL) {
 772         free(msg->indicationHeader);
 773         msg->indicationHeader = NULL;
 774     }
 775     if(msg->indicationMessage != NULL) {
 776         free(msg->indicationMessage);
 777         msg->indicationMessage = NULL;
 778     }
 779     if(msg->callProcessID != NULL) {
 780         free(msg->callProcessID);
 781         msg->callProcessID = NULL;
 782     }
 783     free(msg);
 784     msg = NULL;
 785 }
 786
 787 ssize_t e2ap_encode_ric_control_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber,
 788                   long ranFunctionID, void *ricControlHdr, size_t ricControlHdrSize, void *ricControlMsg, size_t ricControlMsgSize)
 789 {
 790
 791     E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
 792     if(!init) {
 793         fprintf(stderr, "alloc E2AP_PDU failed\n");
 794         return -1;
 795     }
 796
 797
 798     InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
 799     if(!initiatingMsg) {
 800         fprintf(stderr, "alloc InitiatingMessage failed\n");
 801         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 802         return -1;
 803     }
 804
 805         init->choice.initiatingMessage = initiatingMsg;
 806     init->present = E2AP_PDU_PR_initiatingMessage;
 807
 808     initiatingMsg->procedureCode = ProcedureCode_id_RICcontrol;
 809     initiatingMsg->criticality = Criticality_reject;
 810     initiatingMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
 811
 812     RICcontrolRequest_t *control_request = &initiatingMsg->value.choice.RICcontrolRequest;
 813
 814
 815     //RICrequestID
 816     RICcontrolRequest_IEs_t *controlReqID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
 817     if(!controlReqID) {
 818         fprintf(stderr, "alloc RICrequestID failed\n");
 819         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 820         return -1;
 821     }
 822
 823     controlReqID->criticality = Criticality_reject;
 824     controlReqID->id = ProtocolIE_ID_id_RICrequestID;
 825
 826     controlReqID->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
 827     RICrequestID_t *ricrequest_ie = &controlReqID->value.choice.RICrequestID;
 828     ricrequest_ie->ricRequestorID = ricRequestorID;
 829     ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
 830     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqID);
 831
 832     //RICfunctionID
 833     RICcontrolRequest_IEs_t *controlReqFunID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
 834     if(!controlReqFunID) {
 835         fprintf(stderr, "alloc RICrequestID failed\n");
 836         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 837         return -1;
 838     }
 839
 840     controlReqFunID->criticality = Criticality_reject;
 841     controlReqFunID->id = ProtocolIE_ID_id_RANfunctionID;
 842     controlReqFunID->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
 843     RANfunctionID_t *ranfunction_ie = &controlReqFunID->value.choice.RANfunctionID;
 844     *ranfunction_ie = ranFunctionID;
 845     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqFunID);
 846
 847     // RICControlHdr
 848     RICcontrolRequest_IEs_t *controlReqHdr = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
 849     if(!controlReqHdr) {
 850         fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
 851         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 852         return -1;
 853     }
 854     controlReqHdr->criticality = Criticality_reject;
 855     controlReqHdr->id = ProtocolIE_ID_id_RICcontrolHeader;
 856     controlReqHdr->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
 857     RICcontrolHeader_t *controlHdr = &controlReqHdr->value.choice.RICcontrolHeader;
 858     controlHdr->buf = (uint8_t *)calloc(1, ricControlHdrSize);
 859     if(!controlHdr->buf) {
 860         fprintf(stderr, "alloc RICcontrolHeader_t buf failed\n");
 861         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 862         return -1;
 863     }
 864
 865     memcpy(controlHdr->buf, ricControlHdr, ricControlHdrSize);
 866     controlHdr->size = ricControlHdrSize;
 867     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqHdr);
 868
 869     //Ric Control Message
 870     RICcontrolRequest_IEs_t *controlReqMsg = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
 871     if(!controlReqMsg) {
 872         fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
 873         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 874         return -1;
 875     }
 876     controlReqMsg->criticality = Criticality_reject;
 877     controlReqMsg->id = ProtocolIE_ID_id_RICcontrolMessage;
 878     controlReqMsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
 879     RICcontrolMessage_t *controlMsg = &controlReqMsg->value.choice.RICcontrolMessage;
 880     controlMsg->buf = (uint8_t *)calloc(1, ricControlMsgSize);
 881     if(!controlMsg->buf) {
 882         fprintf(stderr, "alloc RICcontrolMessage_t buf failed\n");
 883         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 884         return -1;
 885     }
 886
 887     memcpy(controlMsg->buf, ricControlMsg, ricControlMsgSize);
 888     controlMsg->size = ricControlMsgSize;
 889     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqMsg);
 890
 891     fprintf(stderr, "showing xer of asn_DEF_E2AP_PDU data\n");
 892     xer_fprint(stderr, &asn_DEF_E2AP_PDU, init);
 893     fprintf(stderr, "\n");
 894     fprintf(stderr, "After xer of asn_DEF_E2AP_PDU data\n");
 895
 896     return encode_E2AP_PDU(init, buffer, buf_size);
 897 }
 898
 899 RICControlAcknowledge* e2ap_decode_ric_control_acknowledge_message(void *buffer, size_t buf_size)
 900 {
 901     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 902     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 903     {
 904         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 905         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
 906             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICcontrolAcknowledge)
 907         {
 908                 RICcontrolAcknowledge_t *controlAck = &(successfulOutcome->value.choice.RICcontrolAcknowledge);
 909                 RICControlAcknowledge *msg = (RICControlAcknowledge *)calloc(1, sizeof(RICControlAcknowledge));
 910                 int i = 0;
 911                  for (i; i < controlAck->protocolIEs.list.count; ++i )
 912             {
 913                 if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 914                 {
 915                     msg->requestorID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 916                     msg->instanceID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 917                 }
 918                 else if (controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 919                     msg->ranfunctionID = controlAck->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 920                 }
 921                 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 922                     size_t callProcessIDSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 923                     msg->callProcessID = calloc(1, callProcessIDSize);
 924                     if (!msg->callProcessID) {
 925                         fprintf(stderr, "alloc RICcallProcessID failed\n");
 926                         e2ap_free_decoded_ric_control_ack(msg);
 927                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 928                         return NULL;
 929                     }
 930
 931                     memcpy(msg->callProcessID, controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
 932                     msg->callProcessIDSize = callProcessIDSize;
 933                 }
 934                 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
 935                     size_t ricControlOutComeSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
 936                     msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
 937                     if (!msg->ricControlOutCome) {
 938                         fprintf(stderr, "alloc ricControlOutCome failed\n");
 939                         e2ap_free_decoded_ric_control_ack(msg);
 940                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 941                         return NULL;
 942                     }
 943
 944                     memcpy(msg->ricControlOutCome, controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
 945                     msg->ricControlOutComeSize = ricControlOutComeSize;
 946                 }
 947         }
 948                  if(pdu != NULL)
 949                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 950                 return msg;
 951         }
 952         }
 953
 954     if(pdu != NULL)
 955         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 956     return NULL;
 957 }
 958
 959 void e2ap_free_decoded_ric_control_ack(RICControlAcknowledge* msg) {
 960     if(msg == NULL) {
 961         return;
 962     }
 963     if(msg->callProcessID != NULL) {
 964         free(msg->callProcessID);
 965         msg->callProcessID = NULL;
 966     }
 967     if(msg->ricControlOutCome != NULL) {
 968         free(msg->ricControlOutCome);
 969         msg->ricControlOutCome = NULL;
 970     }
 971         free(msg);
 972     msg = NULL;
 973 }
 974
 975 RICControlFailure* e2ap_decode_ric_control_failure_message(void *buffer, size_t buf_size)
 976 {
 977     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 978     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 979     {
 980         UnsuccessfulOutcome_t* unSuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
 981         if ( unSuccessfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
 982             && unSuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICcontrolFailure)
 983         {
 984                 RICcontrolFailure_t *controlFailure = &(unSuccessfulOutcome->value.choice.RICcontrolFailure);
 985                 RICControlFailure *msg = (RICControlFailure *)calloc(1, sizeof(RICControlFailure));
 986                 int i = 0;
 987                  for (i; i < controlFailure->protocolIEs.list.count; ++i )
 988             {
 989                 if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 990                 {
 991                     msg->requestorID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 992                     msg->instanceID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 993                 }
 994                 else if (controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 995                     msg->ranfunctionID = controlFailure->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 996                 }
 997                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 998                     size_t callProcessIDSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 999                     msg->callProcessID = calloc(1, callProcessIDSize);
1000                     if (!msg->callProcessID) {
1001                         fprintf(stderr, "alloc RICcallProcessID failed\n");
1002                         e2ap_free_decoded_ric_control_failure(msg);
1003                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1004                          return NULL;
1005                     }
1006
1007                 memcpy(msg->callProcessID, controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
1008                     msg->callProcessIDSize = callProcessIDSize;
1009                 }
1010                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
1011                         msg->causeType = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.present;
1012                         if (msg->causeType == Cause_PR_ricRequest) {
1013                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricRequest;
1014                         } else if (msg->causeType == Cause_PR_ricService) {
1015                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricService;
1016                         } else if (msg->causeType == Cause_PR_transport) {
1017                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.transport;
1018                         } else if (msg->causeType == Cause_PR_protocol) {
1019                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.protocol;
1020                         } else if (msg->causeType == Cause_PR_misc) {
1021                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.misc;
1022                         }else {
1023                                 msg->causeType == Cause_PR_NOTHING;
1024                         }
1025                 }
1026                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
1027                     size_t ricControlOutComeSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
1028                     msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
1029                     if (!msg->ricControlOutCome) {
1030                         fprintf(stderr, "alloc ricControlOutCome failed\n");
1031                         e2ap_free_decoded_ric_control_failure(msg);
1032                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1033                         return NULL;
1034                     }
1035
1036                     memcpy(msg->ricControlOutCome, controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
1037                     msg->ricControlOutComeSize = ricControlOutComeSize;
1038
1039                 }
1040         }
1041                  if(pdu != NULL)
1042                      ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1043
1044                 return msg;
1045         }
1046         }
1047
1048         if(pdu != NULL)
1049                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
1050
1051         return NULL;
1052 }
1053
1054 void e2ap_free_decoded_ric_control_failure(RICControlFailure* msg) {
1055     if(msg == NULL) {
1056         return;
1057     }
1058     if(msg->callProcessID != NULL) {
1059         free(msg->callProcessID);
1060         msg->callProcessID = NULL;
1061     }
1062     if(msg->ricControlOutCome != NULL) {
1063         free(msg->ricControlOutCome);
1064         msg->ricControlOutCome = NULL;
1065     }
1066         free(msg);
1067     msg = NULL;
1068 }
1069