e2ap/libe2ap_wrapper/wrapper.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 <errno.h>
  21 #include "wrapper.h"
  22
  23 size_t encode_E2AP_PDU(E2AP_PDU_t* pdu, void* buffer, size_t buf_size)
  24 {
  25     asn_enc_rval_t encode_result;
  26     encode_result = aper_encode_to_buffer(&asn_DEF_E2AP_PDU, NULL, pdu, buffer, buf_size);
  27     if (encode_result.encoded == -1) {
  28         return -1;
  29     }
  30     return encode_result.encoded;
  31 }
  32
  33 E2AP_PDU_t* decode_E2AP_PDU(const void* buffer, size_t buf_size)
  34 {
  35     asn_dec_rval_t decode_result;
  36     E2AP_PDU_t *pdu = 0;
  37     decode_result = aper_decode_complete(NULL, &asn_DEF_E2AP_PDU, (void **)&pdu, buffer, buf_size);
  38     if (decode_result.code == RC_OK) {
  39         return pdu;
  40     } else {
  41         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  42         return 0;
  43     }
  44 }
  45
  46 long e2ap_get_ric_subscription_request_sequence_number(void *buffer, size_t buf_size)
  47 {
  48     int errorCode = -1;
  49     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  50     if  (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  51     {
  52         RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
  53         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
  54             && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionRequest)
  55         {
  56             RICsubscriptionRequest_t *ric_subscription_request = &(initiatingMessage->value.choice.RICsubscriptionRequest);
  57             for (int i = 0; i < ric_subscription_request->protocolIEs.list.count; ++i)
  58             {
  59                 if (ric_subscription_request->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
  60                 {
  61                     long sequence_number = ric_subscription_request->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
  62                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  63                     return sequence_number;
  64                 }
  65                 else
  66                     errorCode = -3;
  67             }
  68         }
  69         else
  70             errorCode = -2;
  71     }
  72     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  73     return errorCode;
  74 }
  75
  76 ssize_t  e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
  77 {
  78     int errorCode = -1;
  79     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  80     if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  81     {
  82         RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
  83         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
  84             && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionRequest)
  85         {
  86             RICsubscriptionRequest_t *ricSubscriptionRequest = &initiatingMessage->value.choice.RICsubscriptionRequest;
  87             for (int i = 0; i < ricSubscriptionRequest->protocolIEs.list.count; ++i)
  88             {
  89                 if (ricSubscriptionRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
  90                 {
  91                     ricSubscriptionRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
  92                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
  93                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  94                     return encode_size;
  95                 }
  96                 else
  97                     errorCode = -3;
  98             }
  99         }
 100         else
 101             return -2;
 102     }
 103     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 104     return errorCode;
 105 }
 106
 107 /* RICsubscriptionResponse */
 108 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
 109 {
 110     int errorCode = -1;
 111      E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 112     if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 113     {
 114         RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
 115         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
 116             && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionResponse)
 117         {
 118             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
 119             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i)
 120             {
 121                 if (ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 122                 {
 123                     long sequence_number = ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 124                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 125                     return sequence_number;
 126                 }
 127                 else
 128                     errorCode = -3;
 129             }
 130         }
 131         else
 132             errorCode = -2;
 133     }
 134     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 135     return errorCode;
 136 }
 137
 138 ssize_t  e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 139 {
 140     int errorCode = -1;
 141     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 142     if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 143     {
 144         RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
 145         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
 146             && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionResponse)
 147         {
 148             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
 149             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i)
 150             {
 151                 if (ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 152                 {
 153                     ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 154                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
 155                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 156                     return encode_size;
 157                 }
 158                 else
 159                     errorCode = -3;
 160             }
 161         }
 162         else
 163             errorCode = -2;
 164     }
 165     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 166     return errorCode;
 167 }
 168
 169 /* RICsubscriptionDeleteRequest */
 170 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
 171 {
 172     int errorCode = -1;
 173     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 174     if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
 175     {
 176         RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
 177         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 178             && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 179         {
 180             RICsubscriptionDeleteRequest_t *subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 181             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i)
 182             {
 183                 if (subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 184                 {
 185                     long sequence_number = subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 186                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 187                     return sequence_number;
 188                 }
 189                 else
 190                     errorCode = -3;
 191             }
 192         }
 193         else
 194             errorCode = -2;
 195     }
 196     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 197     return errorCode;
 198 }
 199
 200 ssize_t  e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 201 {
 202     int errorCode = -1;
 203     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 204     if (pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
 205     {
 206         RICInitiatingMessage_t* initiatingMessage = &pdu->choice.initiatingMessage;
 207         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 208             && initiatingMessage->value.present == RICInitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 209         {
 210             RICsubscriptionDeleteRequest_t* subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 211             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i)
 212             {
 213                 if (subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 214                 {
 215                     subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 216                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
 217                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 218                     return encode_size;
 219                 }
 220                 else
 221                     errorCode = -3;
 222             }
 223         }
 224         else
 225             errorCode = -2;
 226     }
 227     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 228     return errorCode;
 229 }
 230
 231 /* RICsubscriptionDeleteResponse */
 232 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
 233 {
 234     int errorCode = -1;
 235     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 236     if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 237     {
 238         RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
 239         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 240             && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 241         {
 242             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 243             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i)
 244             {
 245                 if (subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 246                 {
 247                     long sequence_number = subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 248                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 249                     return sequence_number;
 250                 }
 251                 else
 252                     errorCode = -3;
 253             }
 254         }
 255         else
 256             errorCode = -2;
 257     }
 258     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 259     return errorCode;
 260 }
 261
 262 ssize_t  e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 263 {
 264     int errorCode = -1;
 265     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 266     if (pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 267     {
 268         RICSuccessfulOutcome_t* successfulOutcome = &pdu->choice.successfulOutcome;
 269         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 270             && successfulOutcome->value.present == RICSuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 271         {
 272             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 273             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i)
 274             {
 275                 if (subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 276                 {
 277                     subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 278                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
 279                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 280                     return encode_size;
 281                 }
 282                 else
 283                     errorCode = -3;
 284             }
 285         }
 286         else
 287             errorCode = -2;
 288     }
 289     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 290     return errorCode;
 291 }
 292
 293 // This function is not used currently. Can be deleted if not needed
 294 ssize_t  e2ap_set_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 295 {
 296     int errorCode = -1;
 297     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 298     if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 299     {
 300         RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
 301         if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
 302             && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
 303         {
 304             RICsubscriptionFailure_t* subscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;
 305             for (int i = 0; i < subscriptionFailure->protocolIEs.list.count; ++i)
 306             {
 307                 if (subscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 308                 {
 309                     subscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 310                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
 311                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 312                     return encode_size;
 313                 }
 314                 else
 315                     errorCode = -3;
 316             }
 317         }
 318         else
 319             errorCode = -2;
 320     }
 321     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 322     return errorCode;
 323 }
 324
 325 long e2ap_get_ric_subscription_failure_sequence_number(void *buffer, size_t buf_size)
 326 {
 327     int errorCode = -1;
 328     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 329     if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 330     {
 331         RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
 332         if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
 333             && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionFailure)
 334         {
 335             RICsubscriptionFailure_t* subscriptionFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionFailure;;
 336             for (int i = 0; i < subscriptionFailure->protocolIEs.list.count; ++i)
 337             {
 338                 if (subscriptionFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 339                 {
 340                     long sequence_number = subscriptionFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 341                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 342                     return sequence_number;
 343                 }
 344                 else
 345                     errorCode = -3;
 346             }
 347         }
 348         else
 349             errorCode = -2;
 350     }
 351     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 352     return errorCode;
 353 }
 354
 355 // This function is not used currently. Can be deleted if not needed
 356 ssize_t  e2ap_set_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 357 {
 358     int errorCode = -1;
 359     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 360     if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 361     {
 362         RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
 363         if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 364             && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
 365         {
 366             RICsubscriptionDeleteFailure_t* subscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;
 367             for (int i = 0; i < subscriptionDeleteFailure->protocolIEs.list.count; ++i)
 368             {
 369                 if (subscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 370                 {
 371                     subscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 372                     size_t encode_size = encode_E2AP_PDU(pdu, buffer, buf_size);
 373                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 374                     return encode_size;
 375                 }
 376                 else
 377                     errorCode = -3;
 378             }
 379         }
 380         else
 381             errorCode = -2;
 382     }
 383     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 384     return errorCode;
 385 }
 386
 387 long e2ap_get_ric_subscription_delete_failure_sequence_number(void *buffer, size_t buf_size)
 388 {
 389     int errorCode = -1;
 390     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 391     if (pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 392     {
 393         RICUnsuccessfulOutcome_t* unsuccessfulOutcome = &pdu->choice.unsuccessfulOutcome;
 394         if (unsuccessfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 395             && unsuccessfulOutcome->value.present == RICUnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure)
 396         {
 397             RICsubscriptionDeleteFailure_t* subscriptionDeleteFailure = &unsuccessfulOutcome->value.choice.RICsubscriptionDeleteFailure;;
 398             for (int i = 0; i < subscriptionDeleteFailure->protocolIEs.list.count; ++i)
 399             {
 400                 if (subscriptionDeleteFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 401                 {
 402                     long sequence_number = subscriptionDeleteFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 403                     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 404                     return sequence_number;
 405                 }
 406                 else
 407                     errorCode = -3;
 408             }
 409         }
 410         else
 411             errorCode = -2;
 412     }
 413     ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 414     return errorCode;
 415 }