e2ap/wrapper.c

   1 #include <errno.h>
   2 #include "wrapper.h"
   3
   4 ssize_t encode_RIC_subscription_request(RICsubscriptionRequest_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_RICsubscriptionRequest, NULL, pdu, buffer, buf_size);
   8     if(encode_result.encoded == -1) {
   9         return -1;
  10     }
  11     return encode_result.encoded;
  12 }
  13
  14 RICsubscriptionRequest_t* decode_RIC_subscription_request(const void *buffer, size_t buf_size)
  15 {
  16     asn_dec_rval_t decode_result;
  17     RICsubscriptionRequest_t *pdu = 0;
  18     decode_result = aper_decode_complete(NULL, &asn_DEF_RICsubscriptionRequest, (void **)&pdu, buffer, buf_size);
  19     if(decode_result.code == RC_OK) {
  20         return pdu;
  21     } else {
  22         ASN_STRUCT_FREE(asn_DEF_RICsubscriptionRequest, pdu);
  23         return 0;
  24     }
  25 }
  26
  27 long e2ap_get_ric_subscription_request_sequence_number(void *buffer, size_t buf_size)
  28 {
  29     RICsubscriptionRequest_t *pdu = decode_RIC_subscription_request(buffer, buf_size);
  30     if ( pdu != NULL )
  31     {
  32         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
  33         {
  34             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  35             {
  36                 return pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
  37             }
  38         }
  39     }
  40     return -1;
  41 }
  42
  43 ssize_t  e2ap_set_ric_subscription_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
  44 {
  45     RICsubscriptionRequest_t *pdu = decode_RIC_subscription_request(buffer, buf_size);
  46     if ( pdu != NULL )
  47     {
  48         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
  49         {
  50             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  51             {
  52                 pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
  53                 return encode_RIC_subscription_request(pdu, buffer, buf_size);
  54             }
  55         }
  56     }
  57     return -1;
  58 }
  59
  60 /* RICsubscriptionResponse */
  61 ssize_t encode_RIC_subscription_response(RICsubscriptionResponse_t* pdu, void* buffer, size_t buf_size)
  62 {
  63     asn_enc_rval_t encode_result;
  64     encode_result = aper_encode_to_buffer(&asn_DEF_RICsubscriptionResponse, NULL, pdu, buffer, buf_size);
  65     if(encode_result.encoded == -1) {
  66         return -1;
  67     }
  68     return encode_result.encoded;
  69 }
  70
  71 RICsubscriptionResponse_t* decode_RIC_subscription_response(const void *buffer, size_t buf_size)
  72 {
  73     asn_dec_rval_t decode_result;
  74     RICsubscriptionResponse_t *pdu = 0;
  75     decode_result = aper_decode_complete(NULL, &asn_DEF_RICsubscriptionResponse, (void **)&pdu, buffer, buf_size);
  76     if(decode_result.code == RC_OK) {
  77         fprintf(stdout, "decoded bytes: %ld\n", decode_result.consumed);
  78         return pdu;
  79     } else {
  80         ASN_STRUCT_FREE(asn_DEF_RICsubscriptionResponse, pdu);
  81         return 0;
  82     }
  83 }
  84
  85 long e2ap_get_ric_subscription_response_sequence_number(void *buffer, size_t buf_size)
  86 {
  87     RICsubscriptionResponse_t *pdu = decode_RIC_subscription_response(buffer, buf_size);
  88     if ( pdu != NULL )
  89     {
  90         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
  91         {
  92             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
  93             {
  94                 return pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
  95             }
  96         }
  97     }
  98     return -1;
  99 }
 100
 101 ssize_t  e2ap_set_ric_subscription_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 102 {
 103     RICsubscriptionResponse_t *pdu = decode_RIC_subscription_response(buffer, buf_size);
 104     if ( pdu != NULL )
 105     {
 106         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
 107         {
 108             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 109             {
 110                 pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 111                 return encode_RIC_subscription_response(pdu, buffer, buf_size);
 112             }
 113         }
 114     }
 115     return -1;
 116 }
 117
 118 /* RICsubscriptionDeleteRequest */
 119 ssize_t encode_RIC_subscription_delete_request(RICsubscriptionDeleteRequest_t* pdu, void* buffer, size_t buf_size)
 120 {
 121     asn_enc_rval_t encode_result;
 122     encode_result = aper_encode_to_buffer(&asn_DEF_RICsubscriptionDeleteRequest, NULL, pdu, buffer, buf_size);
 123     if(encode_result.encoded == -1) {
 124         return -1;
 125     }
 126     return encode_result.encoded;
 127 }
 128
 129 RICsubscriptionDeleteRequest_t* decode_RIC_subscription_delete_request(const void *buffer, size_t buf_size)
 130 {
 131     asn_dec_rval_t decode_result;
 132     RICsubscriptionDeleteRequest_t *pdu = 0;
 133     decode_result = aper_decode_complete(NULL, &asn_DEF_RICsubscriptionDeleteRequest, (void **)&pdu, buffer, buf_size);
 134     if(decode_result.code == RC_OK) {
 135         return pdu;
 136     } else {
 137         ASN_STRUCT_FREE(asn_DEF_RICsubscriptionDeleteRequest, pdu);
 138         return 0;
 139     }
 140 }
 141
 142 long e2ap_get_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size)
 143 {
 144     RICsubscriptionDeleteRequest_t *pdu = decode_RIC_subscription_delete_request(buffer, buf_size);
 145     if ( pdu != NULL )
 146     {
 147         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
 148         {
 149             /* TODO */
 150             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 151             {
 152                 return pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 153             }
 154         }
 155     }
 156     return -1;
 157 }
 158
 159 ssize_t  e2ap_set_ric_subscription_delete_request_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 160 {
 161     RICsubscriptionDeleteRequest_t *pdu = decode_RIC_subscription_delete_request(buffer, buf_size);
 162     if ( pdu != NULL )
 163     {
 164         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
 165         {
 166             /* TODO */
 167             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 168             {
 169                 pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 170                 return encode_RIC_subscription_delete_request(pdu, buffer, buf_size);
 171             }
 172         }
 173     }
 174     return -1;
 175 }
 176
 177 /* RICsubscriptionDeleteResponse */
 178 ssize_t encode_RIC_subscription_delete_response(RICsubscriptionDeleteResponse_t* pdu, void* buffer, size_t buf_size)
 179 {
 180     asn_enc_rval_t encode_result;
 181     encode_result = aper_encode_to_buffer(&asn_DEF_RICsubscriptionDeleteResponse, NULL, pdu, buffer, buf_size);
 182     if(encode_result.encoded == -1) {
 183         return -1;
 184     }
 185     return encode_result.encoded;
 186 }
 187
 188 RICsubscriptionDeleteResponse_t* decode_RIC_subscription_delete_response(const void *buffer, size_t buf_size)
 189 {
 190     asn_dec_rval_t decode_result;
 191     RICsubscriptionDeleteResponse_t *pdu = 0;
 192     decode_result = aper_decode_complete(NULL, &asn_DEF_RICsubscriptionDeleteResponse, (void **)&pdu, buffer, buf_size);
 193     if(decode_result.code == RC_OK) {
 194         fprintf(stdout, "decoded bytes: %ld\n", decode_result.consumed);
 195         return pdu;
 196     } else {
 197         ASN_STRUCT_FREE(asn_DEF_RICsubscriptionDeleteResponse, pdu);
 198         return 0;
 199     }
 200 }
 201
 202 long e2ap_get_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size)
 203 {
 204     RICsubscriptionDeleteResponse_t *pdu = decode_RIC_subscription_delete_response(buffer, buf_size);
 205     if ( pdu != NULL )
 206     {
 207         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
 208         {
 209             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 210             {
 211                 /* TODO */
 212                 return pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber;
 213             }
 214         }
 215     }
 216     return -1;
 217 }
 218
 219 ssize_t  e2ap_set_ric_subscription_delete_response_sequence_number(void *buffer, size_t buf_size, long sequence_number)
 220 {
 221     RICsubscriptionDeleteResponse_t *pdu = decode_RIC_subscription_delete_response(buffer, buf_size);
 222     if ( pdu != NULL )
 223     {
 224         for (int i = 0; i < pdu->protocolIEs.list.count; ++i )
 225         {
 226             if ( pdu->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID )
 227             {
 228                 /* todo */
 229                 pdu->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestSequenceNumber = sequence_number;
 230                 return encode_RIC_subscription_delete_response(pdu, buffer, buf_size);
 231             }
 232         }
 233     }
 234     return -1;
 235 }