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     if(decode_result.code == RC_OK) {
  23         return pdu;
  24     } else {
  25         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
  26         return 0;
  27     }
  28 }
  29
  30 ssize_t e2ap_encode_ric_control_request_message(void *buffer, size_t buf_size, long ricRequestorID, long ricRequestSequenceNumber,
  31                   long ranFunctionID, void *ricControlHdr, size_t ricControlHdrSize, void *ricControlMsg, size_t ricControlMsgSize)
  32 {
  33
  34     E2AP_PDU_t *init = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
  35     if(!init) {
  36         fprintf(stderr, "alloc E2AP_PDU failed\n");
  37         return -1;
  38     }
  39
  40
  41     InitiatingMessage_t *initiatingMsg = (InitiatingMessage_t *)calloc(1, sizeof(InitiatingMessage_t));
  42     if(!initiatingMsg) {
  43         fprintf(stderr, "alloc InitiatingMessage failed\n");
  44         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
  45         return -1;
  46     }
  47
  48         init->choice.initiatingMessage = initiatingMsg;
  49     init->present = E2AP_PDU_PR_initiatingMessage;
  50
  51     initiatingMsg->procedureCode = ProcedureCode_id_RICcontrol;
  52     initiatingMsg->criticality = Criticality_reject;
  53     initiatingMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
  54
  55     RICcontrolRequest_t *control_request = &initiatingMsg->value.choice.RICcontrolRequest;
  56
  57
  58     //RICrequestID
  59     RICcontrolRequest_IEs_t *controlReqID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
  60     if(!controlReqID) {
  61         fprintf(stderr, "alloc RICrequestID failed\n");
  62         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
  63         return -1;
  64     }
  65
  66     controlReqID->criticality = Criticality_reject;
  67     controlReqID->id = ProtocolIE_ID_id_RICrequestID;
  68
  69     controlReqID->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
  70     RICrequestID_t *ricrequest_ie = &controlReqID->value.choice.RICrequestID;
  71     ricrequest_ie->ricRequestorID = ricRequestorID;
  72     ricrequest_ie->ricInstanceID = ricRequestSequenceNumber;
  73     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqID);
  74
  75     //RICfunctionID
  76     RICcontrolRequest_IEs_t *controlReqFunID = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
  77     if(!controlReqFunID) {
  78         fprintf(stderr, "alloc RICrequestID failed\n");
  79         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
  80         return -1;
  81     }
  82
  83     controlReqFunID->criticality = Criticality_reject;
  84     controlReqFunID->id = ProtocolIE_ID_id_RANfunctionID;
  85     controlReqFunID->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
  86     RANfunctionID_t *ranfunction_ie = &controlReqFunID->value.choice.RANfunctionID;
  87     *ranfunction_ie = ranFunctionID;
  88     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqFunID);
  89
  90     // RICControlHdr
  91     RICcontrolRequest_IEs_t *controlReqHdr = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
  92     if(!controlReqHdr) {
  93         fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
  94         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
  95         return -1;
  96     }
  97     controlReqHdr->criticality = Criticality_reject;
  98     controlReqHdr->id = ProtocolIE_ID_id_RICcontrolHeader;
  99     controlReqHdr->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
 100     RICcontrolHeader_t *controlHdr = &controlReqHdr->value.choice.RICcontrolHeader;
 101     controlHdr->buf = (uint8_t *)calloc(1, ricControlHdrSize);
 102     if(!controlHdr->buf) {
 103         fprintf(stderr, "alloc RICcontrolHeader_t buf failed\n");
 104         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 105         return -1;
 106     }
 107
 108     memcpy(controlHdr->buf, ricControlHdr, ricControlHdrSize);
 109     controlHdr->size = ricControlHdrSize;
 110     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqHdr);
 111
 112     //Ric Control Message
 113     RICcontrolRequest_IEs_t *controlReqMsg = (RICcontrolRequest_IEs_t *)calloc(1, sizeof(RICcontrolRequest_IEs_t));
 114     if(!controlReqMsg) {
 115         fprintf(stderr, "alloc RICcontrolRequest_IEs_t failed\n");
 116         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 117         return -1;
 118     }
 119     controlReqMsg->criticality = Criticality_reject;
 120     controlReqMsg->id = ProtocolIE_ID_id_RICcontrolMessage;
 121     controlReqMsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
 122     RICcontrolMessage_t *controlMsg = &controlReqMsg->value.choice.RICcontrolMessage;
 123     controlMsg->buf = (uint8_t *)calloc(1, ricControlMsgSize);
 124     if(!controlMsg->buf) {
 125         fprintf(stderr, "alloc RICcontrolMessage_t buf failed\n");
 126         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, init);
 127         return -1;
 128     }
 129
 130     memcpy(controlMsg->buf, ricControlMsg, ricControlMsgSize);
 131     controlMsg->size = ricControlMsgSize;
 132     ASN_SEQUENCE_ADD(&control_request->protocolIEs.list, controlReqMsg);
 133
 134     fprintf(stderr, "showing xer of asn_DEF_E2AP_PDU data\n");
 135     xer_fprint(stderr, &asn_DEF_E2AP_PDU, init);
 136     fprintf(stderr, "\n");
 137     fprintf(stderr, "After xer of asn_DEF_E2AP_PDU data\n");
 138
 139     return encode_E2AP_PDU(init, buffer, buf_size);
 140 }
 141
 142