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