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 RICControlAcknowledge* e2ap_decode_ric_control_acknowledge_message(void *buffer, size_t buf_size)
 143 {
 144     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 145     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_successfulOutcome)
 146     {
 147         SuccessfulOutcome_t* successfulOutcome = pdu->choice.successfulOutcome;
 148         if ( successfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
 149             && successfulOutcome->value.present == SuccessfulOutcome__value_PR_RICcontrolAcknowledge)
 150         {
 151                 RICcontrolAcknowledge_t *controlAck = &(successfulOutcome->value.choice.RICcontrolAcknowledge);
 152                 RICControlAcknowledge *msg = (RICControlAcknowledge *)calloc(1, sizeof(RICControlAcknowledge));
 153                 int i = 0;
 154                  for (i; i < controlAck->protocolIEs.list.count; ++i )
 155             {
 156                 if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 157                 {
 158                     msg->requestorID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 159                     msg->instanceID = controlAck->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 160                 }
 161                 else if (controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 162                     msg->ranfunctionID = controlAck->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 163                 }
 164                 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 165                     size_t callProcessIDSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 166                     msg->callProcessID = calloc(1, callProcessIDSize);
 167                     if (!msg->callProcessID) {
 168                         fprintf(stderr, "alloc RICcallProcessID failed\n");
 169                         e2ap_free_decoded_ric_control_ack(msg);
 170                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 171                         return NULL;
 172                     }
 173
 174                     memcpy(msg->callProcessID, controlAck->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
 175                     msg->callProcessIDSize = callProcessIDSize;
 176                 }
 177                 else if(controlAck->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
 178                     size_t ricControlOutComeSize = controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
 179                     msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
 180                     if (!msg->ricControlOutCome) {
 181                         fprintf(stderr, "alloc ricControlOutCome failed\n");
 182                         e2ap_free_decoded_ric_control_ack(msg);
 183                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 184                         return NULL;
 185                     }
 186
 187                     memcpy(msg->ricControlOutCome, controlAck->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
 188                     msg->ricControlOutComeSize = ricControlOutComeSize;
 189                 }
 190         }
 191                 return msg;
 192         }
 193         }
 194
 195     if(pdu != NULL)
 196         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 197     return NULL;
 198 }
 199
 200 void e2ap_free_decoded_ric_control_ack(RICControlAcknowledge* msg) {
 201     if(msg == NULL) {
 202         return;
 203     }
 204     if(msg->callProcessID != NULL) {
 205         free(msg->callProcessID);
 206         msg->callProcessID = NULL;
 207     }
 208     if(msg->ricControlOutCome != NULL) {
 209         free(msg->ricControlOutCome);
 210         msg->ricControlOutCome = NULL;
 211     }
 212         free(msg);
 213     msg = NULL;
 214 }
 215
 216 RICControlFailure* e2ap_decode_ric_control_failure_message(void *buffer, size_t buf_size)
 217 {
 218     E2AP_PDU_t *pdu = decode_E2AP_PDU(buffer, buf_size);
 219     if ( pdu != NULL && pdu->present == E2AP_PDU_PR_unsuccessfulOutcome)
 220     {
 221         UnsuccessfulOutcome_t* unSuccessfulOutcome = pdu->choice.unsuccessfulOutcome;
 222         if ( unSuccessfulOutcome->procedureCode == ProcedureCode_id_RICcontrol
 223             && unSuccessfulOutcome->value.present == UnsuccessfulOutcome__value_PR_RICcontrolFailure)
 224         {
 225                 RICcontrolFailure_t *controlFailure = &(unSuccessfulOutcome->value.choice.RICcontrolFailure);
 226                 RICControlFailure *msg = (RICControlFailure *)calloc(1, sizeof(RICControlFailure));
 227                 int i = 0;
 228                  for (i; i < controlFailure->protocolIEs.list.count; ++i )
 229             {
 230                 if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICrequestID)
 231                 {
 232                     msg->requestorID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricRequestorID;
 233                     msg->instanceID = controlFailure->protocolIEs.list.array[i]->value.choice.RICrequestID.ricInstanceID;
 234                 }
 235                 else if (controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RANfunctionID) {
 236                     msg->ranfunctionID = controlFailure->protocolIEs.list.array[i]->value.choice.RANfunctionID;
 237                 }
 238                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcallProcessID) {
 239                     size_t callProcessIDSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.size;
 240                     msg->callProcessID = calloc(1, callProcessIDSize);
 241                     if (!msg->callProcessID) {
 242                         fprintf(stderr, "alloc RICcallProcessID failed\n");
 243                         e2ap_free_decoded_ric_control_failure(msg);
 244                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 245                          return NULL;
 246                     }
 247
 248                 memcpy(msg->callProcessID, controlFailure->protocolIEs.list.array[i]->value.choice.RICcallProcessID.buf, callProcessIDSize);
 249                     msg->callProcessIDSize = callProcessIDSize;
 250                 }
 251                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
 252                         msg->causeType = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.present;
 253                         if (msg->causeType == Cause_PR_ricRequest) {
 254                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricRequest;
 255                         } else if (msg->causeType == Cause_PR_ricService) {
 256                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.ricService;
 257                         } else if (msg->causeType == Cause_PR_transport) {
 258                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.transport;
 259                         } else if (msg->causeType == Cause_PR_protocol) {
 260                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.protocol;
 261                         } else if (msg->causeType == Cause_PR_misc) {
 262                                 msg->causeValue = controlFailure->protocolIEs.list.array[i]->value.choice.Cause.choice.misc;
 263                         }else {
 264                                 msg->causeType == Cause_PR_NOTHING;
 265                         }
 266                 }
 267                 else if(controlFailure->protocolIEs.list.array[i]->id == ProtocolIE_ID_id_RICcontrolOutcome) {
 268                     size_t ricControlOutComeSize = controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.size;
 269                     msg->ricControlOutCome = calloc(1, ricControlOutComeSize);
 270                     if (!msg->ricControlOutCome) {
 271                         fprintf(stderr, "alloc ricControlOutCome failed\n");
 272                         e2ap_free_decoded_ric_control_failure(msg);
 273                         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 274                         return NULL;
 275                     }
 276
 277                     memcpy(msg->ricControlOutCome, controlFailure->protocolIEs.list.array[i]->value.choice.RICcontrolOutcome.buf, ricControlOutComeSize);
 278                     msg->ricControlOutComeSize = ricControlOutComeSize;
 279
 280                 }
 281         }
 282         return msg;
 283         }
 284         }
 285
 286         if(pdu != NULL)
 287                 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu);
 288
 289         return NULL;
 290 }
 291
 292 void e2ap_free_decoded_ric_control_failure(RICControlFailure* msg) {
 293     if(msg == NULL) {
 294         return;
 295     }
 296     if(msg->callProcessID != NULL) {
 297         free(msg->callProcessID);
 298         msg->callProcessID = NULL;
 299     }
 300     if(msg->ricControlOutCome != NULL) {
 301         free(msg->ricControlOutCome);
 302         msg->ricControlOutCome = NULL;
 303     }
 304         free(msg);
 305     msg = NULL;
 306 }