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     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  30     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  31     {
  32         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
  33         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
  34             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
  35         {
  36             RICsubscriptionRequest_t *ric_subscription_request = &(initiatingMessage->value.choice.RICsubscriptionRequest);
  37             for (int i = 0; i < ric_subscription_request->protocolIEs.list.count; ++i )
  38             {
  39                 if ( ric_subscription_request->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  40                 {
  41                     return ric_subscription_request->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
  42                 }
  43             }
  44         }
  45     }
  46     return -1;
  47 }
  48
  49 ssize_t  e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
  50 {
  51     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  52     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage)
  53     {
  54         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
  55         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscription
  56             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionRequest)
  57         {
  58             RICsubscriptionRequest_t *ricSubscriptionRequest = &initiatingMessage->value.choice.RICsubscriptionRequest;
  59             for (int i = 0; i < ricSubscriptionRequest->protocolIEs.list.count; ++i )
  60             {
  61                 if ( ricSubscriptionRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  62                 {
  63                     ricSubscriptionRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
  64                     return encode_E2AP_PDU(pdu, buffer, buf_size);
  65                 }
  66             }
  67         }
  68     }
  69     return -1;
  70 }
  71
  72 /* RICsubscriptionResponse */
  73 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
  74 {
  75     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  76     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
  77     {
  78         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
  79         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
  80             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
  81         {
  82             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
  83             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
  84             {
  85                 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  86                 {
  87                     return ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
  88                 }
  89             }
  90         }
  91     }
  92     return -1;
  93 }
  94
  95 ssize_t  e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
  96 {
  97     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
  98     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
  99     {
 100         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 101         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscription
 102             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionResponse)
 103         {
 104             RICsubscriptionResponse_t *ricSubscriptionResponse = &successfulOutcome->value.choice.RICsubscriptionResponse;
 105             for (int i = 0; i < ricSubscriptionResponse->protocolIEs.list.count; ++i )
 106             {
 107                 if ( ricSubscriptionResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 108                 {
 109                     ricSubscriptionResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 110                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 111                 }
 112             }
 113         }
 114     }
 115     return -1;
 116 }
 117
 118 /* RICsubscriptionDeleteRequest */
 119 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
 120 {
 121     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 122     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
 123     {
 124         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 125         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 126             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 127         {
 128             RICsubscriptionDeleteRequest_t *subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 129             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
 130             {
 131                 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 132                 {
 133                     return subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 134                 }
 135             }
 136         }
 137     }
 138     return -1;
 139 }
 140
 141 ssize_t  e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 142 {
 143     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 144     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_initiatingMessage )
 145     {
 146         InitiatingMessage_t* initiatingMessage = pdu->choice.initiatingMessage;
 147         if ( initiatingMessage->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 148             && initiatingMessage->value.present == InitiatingMessage__value_PR_RICsubscriptionDeleteRequest )
 149         {
 150             RICsubscriptionDeleteRequest_t* subscriptionDeleteRequest = &initiatingMessage->value.choice.RICsubscriptionDeleteRequest;
 151             for (int i = 0; i < subscriptionDeleteRequest->protocolIEs.list.count; ++i )
 152             {
 153                 if ( subscriptionDeleteRequest->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 154                 {
 155                     subscriptionDeleteRequest->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 156                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 157                 }
 158             }
 159         }
 160     }
 161     return -1;
 162 }
 163
 164 /* RICsubscriptionDeleteResponse */
 165 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
 166 {
 167     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 168     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 169     {
 170         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 171         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 172             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 173         {
 174             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 175             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
 176             {
 177                 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 178                 {
 179                     return subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 180                 }
 181             }
 182         }
 183     }
 184     return -1;
 185 }
 186
 187 ssize_t  e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 188 {
 189     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 190     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome )
 191     {
 192         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 193         if ( successfulOutcome->procedureCode == ProcedureCode_id_ricSubscriptionDelete
 194             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse )
 195         {
 196             RICsubscriptionDeleteResponse_t* subscriptionDeleteResponse = &successfulOutcome->value.choice.RICsubscriptionDeleteResponse;
 197             for (int i = 0; i < subscriptionDeleteResponse->protocolIEs.list.count; ++i )
 198             {
 199                 if ( subscriptionDeleteResponse->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 200                 {
 201                     subscriptionDeleteResponse->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 202                     return encode_E2AP_PDU(pdu, buffer, buf_size);
 203                 }
 204             }
 205         }
 206     }
 207     return -1;
 208 }