/******************************************************************************* OpenAirInterface Copyright(c) 1999 - 2014 Eurecom OpenAirInterface is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. OpenAirInterface is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenAirInterface.The full GNU General Public License is included in this distribution in the file called "COPYING". If not, see <http://www.gnu.org/licenses/>. Contact Information OpenAirInterface Admin: openair_admin@eurecom.fr OpenAirInterface Tech : openair_tech@eurecom.fr OpenAirInterface Dev : openair4g-devel@lists.eurecom.fr Address : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France. *******************************************************************************/ /*! \file x2ap_eNB_encoder.c * \brief x2ap pdu encode procedures for eNB * \author Navid Nikaein * \date 2015- 2016 * \version 0.1 */ #include <stdio.h> #include <string.h> #include <stdint.h> #include "conversions.h" #include "intertask_interface.h" #include "x2ap_common.h" #include "x2ap_ies_defs.h" #include "x2ap_eNB_encoder.h" static inline int x2ap_encode_initiating(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length); static inline int x2ap_encode_successful(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length); static inline int x2ap_encode_unsuccessful(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length); int x2ap_eNB_encode_pdu(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length) { switch(x2ap_message_p->direction) { case X2AP_PDU_PR_initiatingMessage: return x2ap_eNB_encode_initiating(x2ap_message_p, buf, length); case X2AP_PDU_PR_successfulOutcome: return x2ap_eNB_encode_successful(x2ap_message_p, buf, length); case X2AP_PDU_PR_unsuccessfulOutcome: return x2ap_eNB_encode_unsuccessful(x2ap_message_p, buf, length); default: X2AP_DEBUG("Unknown message outcome (%d) or not implemented", (int)x2ap_message_p->direction); break; } return -1; } static inline int x2ap_eNB_encode_initiating(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length){ int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(x2ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); x2ap_string_total_size = 0; switch(x2ap_message_p->procedureCode) { case ProcedureCode_id_reset: ret = x2ap_reset_request_encoder(&x2ap_message_p->msg.resetRequest_IEs, buf, length); #warning "do the same for the other messages" x2ap_xer_print_x2ap_resetrequest_(x2ap_xer__print2sp, message_string, x2ap_message_p); message_id = X2AP_RESET_REQUST_LOG; message_p = itti_alloc_new_message_sized(TASK_X2AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.x2ap_reset_request_log.size = message_string_size; memcpy(&message_p->ittiMsg.x2ap_reset_request_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case ProcedureCode_id_loadIndication: ret = x2ap_load_information_encoder(&x2ap_message_p->msg.loadInformation_IEs, buf, length); break; case ProcedureCode_id_resourceStatusReportingInitiation: ret = x2ap_resource_status_request_encoder(&x2ap_message_p->msg.resourceStatusRequest_IEs, buf, length); break; case ProcedureCode_id_resourceStatusReporting: ret = x2ap_resource_status_update_encoder(&x2ap_message_p->msg.resourceStatusUpdate_IEs, buf, length); break; case ProcedureCode_id_mobilitySettingsChange: ret = x2ap_mobility_change_request_encoder(&x2ap_message_p->msg.mobilityChangeRequest_IEs, buf, length); break; case ProcedureCode_id_x2Setup: ret = x2_setup_request_encoder(&x2ap_message_p->msg.x2SetupRequest_IEs, buf, length); break; case ProcedureCode_id_handoverPreparation: ret = x2ap_handover_request_encoder(&x2ap_message_p->msg.handoverRequest_IEs, buf, length); break; case ProcedureCode_id_errorIndication: ret = x2ap_error_indication_encoder(&x2ap_message_p->msg.errorIndication_IEs, buf, length); break; case ProcedureCode_id_handoverCancel: ret = x2ap_handover_cancel_encoder(&x2ap_message_p->msg.handoverCancel_IEs, buf, length); break; case ProcedureCode_id_handoverReport: ret = x2ap_handover_report_encoder(&x2ap_message_p->msg.handoverReport_IEs, buf, length); break; case ProcedureCode_id_eNBConfigurationUpdate: ret = x2ap_eNB_configuration_update_request_encoder(&x2ap_message_p->msg.enbConfigurationUpdate_IEs,buf, length); break; case ProcedureCode_id_uEContextRelease: ret = x2ap_ue_context_release_encoder(&x2ap_message_p->msg.ueContextRelease_IEs, buf, length ); break; case ProcedureCode_id_snStatusTransfer: ret = x2ap_sn_status_transfer_encoder(&x2ap_message_p->msg.snStatusTransfer_IEs, buf, length); break; case ProcedureCode_id_rLFIndication: ret = x2ap_rlf_indication_encoder(&x2ap_message_p->msg.rlfIndication_IEs, buf, length); break; case ProcedureCode_id_cellActivation: ret = x2ap_cell_activation_request_encoder(&x2ap_message_p->msg.cellActivationRequest_IEs, buf, length); break; default: X2AP_DEBUG("Unknown procedure (%d) or not implemented", (int)x2ap_message_p->procedureCode); break; } return ret; } static inline int x2ap_eNB_encode_successful(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length){ int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(x2ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); x2ap_string_total_size = 0; switch(x2ap_message_p->procedureCode) { case ProcedureCode_id_resourceStatusReportingInitiation: ret = x2ap_resource_status_response_encoder(&x2ap_message_p->msg.resourceStatusResponse_IEs, buf, length); #warning "do the same for the other messages" x2ap_xer_print_x2ap_resourcestatusresponse_(x2ap_xer__print2sp, message_string, x2ap_message_p); message_id = X2AP_RESOURCE_STATUS_RESPONSE_LOG; message_p = itti_alloc_new_message_sized(TASK_X2AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.x2ap_resource_status_response_log.size = message_string_size; memcpy(&message_p->ittiMsg.x2ap_resource_status_response_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case ProcedureCode_id_mobilitySettingsChange: ret = x2ap_mobility_change_acknowledge_encoder(&x2ap_message_p->msg.mobilityChangeAcknowledge_IEs, buf, length); break; case ProcedureCode_id_reset: ret = x2ap_reset_response_encoder(&x2ap_message_p->msg.resetResponse_IEs, buf, length); break; case ProcedureCode_id_x2Setup: ret = x2_setup_response_encoder(&x2ap_message_p->msg.x2SetupResponse_IEs, buf, length); break; case ProcedureCode_id_handoverPreparation: ret = x2ap_handover_request_acknowledge_encoder(&x2ap_message_p->msg.handoverRequestAcknowledge_IEs, buf, length); break; case ProcedureCode_id_eNBConfigurationUpdate: ret = x2ap_eNB_configuration_update_acknowledge_encoder(&x2ap_message_p->msg.enbConfigurationUpdateAcknowledge_IEs, buf, length); break; case ProcedureCode_id_cellActivation: ret = x2ap_cell_activation_response_encoder(&x2ap_message_p->msg.cellActivationResponse_IEs, buf, length); break; default: X2AP_DEBUG("Unknown procedure (%d) or not implemented", (int)x2ap_message_p->procedureCode); break; } return ret; } static inline int x2ap_eNB_encode_unsuccessful(x2ap_message *x2ap_message_p, uint8_t **buf, uint32_t *length){ int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(x2ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); x2ap_string_total_size = 0; switch(x2ap_message_p->procedureCode) { case ProcedureCode_id_resourceStatusReportingInitiation: ret = x2ap_resource_status_failure_encoder(&x2ap_message_p->msg.resourceStatusFailure_IEs, buf, length); #warning "do the same for the other messages" x2ap_xer_print_x2ap_resourcestatusfailure_(x2ap_xer__print2sp, message_string, x2ap_message_p); message_id = X2AP_RESOURCE_STATUS_FAILURE_LOG; message_p = itti_alloc_new_message_sized(TASK_X2AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.x2ap_resource_status_failure_log.size = message_string_size; memcpy(&message_p->ittiMsg.x2ap_resource_status_failure_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; case ProcedureCode_id_mobilitySettingsChange: ret = x2ap_mobility_change_failure_encoder(&x2ap_message_p->msg.mobilityChangeFailure_IEs, buf, length); break; case ProcedureCode_id_x2Setup: ret = x2_setup_failure_encoder(&x2ap_message_p->msg.x2SetupFailure_IEs, buf, length); break; case ProcedureCode_id_handoverPreparation: ret = x2ap_handover_preparation_failure_encoder(&x2ap_message_p->msg.handoverPreparationFailure_IEs, buf, length); break; case ProcedureCode_id_eNBConfigurationUpdate: ret = x2ap_eNB_configuration_update_failure_encoder(&x2ap_message_p->msg.enbConfigurationUpdateFailure_IEs, buf, length); break; case ProcedureCode_id_cellActivation: ret = x2ap_cell_activation_failure_encoder(&x2ap_message_p->msg.cellActivationFailure_IEs, buf, length); break; default: X2AP_DEBUG("Unknown procedure (%d) or not implemented", (int)x2ap_message_p->procedureCode); break; } return ret; } static inline int x2ap_reset_request_encoder(ResetRequest_IEs_t *resetRequest_IEs, uint8_t **buf, uint32_t *length){ int i; ResetRequest_t resetRequest; memset (&resetRequest,0, sizeof(ResetRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_resetrequest_ies(&resetRequest, resetRequest_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_reset if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_reset, Criticality_reject, &asn_DEF_ResetRequest, &resetRequest) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } int x2_setup_response_encoder(X2SetupResponse_IEs_t *x2SetupResponse_IEs, uint8_t **buf, uint32_t *length){ int i; X2SetupResponse_t x2SetupResponse; memset (&x2SetupResponse,0, sizeof(X2SetupResponse_t)); asn1_xer_print = 0; asn_debug = 0; // encoding X2 Setup response message if (x2ap_encode_x2setupresponse_ies(&x2SetupResponse, x2SetupResponse_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_x2Setup if (x2ap_generate_successfull_outcome (buf, length, ProcedureCode_id_x2Setup, Criticality_reject, &asn_DEF_X2SetupResponse, &x2SetupResponse) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } int x2_setup_failure_encoder(X2SetupFailure_IEs_t *x2SetupFailure_IEs, uint8_t **buf, uint32_t *length){ int i; X2SetupFailure_t x2SetupFailure; memset (&x2SetupFailure,0, sizeof(X2SetupFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding X2 Setup failure message if (x2ap_encode_x2setupfailure_ies(&x2SetupFailure, x2SetupFailure_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_x2Setup if (x2ap_generate_unsuccessfull_outcome (buf, length, ProcedureCode_id_x2Setup, Criticality_reject, &asn_DEF_X2SetupFailure, &x2SetupFailure) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } int x2_setup_request_encoder(X2SetupRequest_IEs_t *x2SetupRequest_IEs, uint8_t **buf, uint32_t *length){ int i; X2SetupRequest_t x2SetupRequest; memset (&x2SetupRequest,0, sizeof(X2SetupRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding X2 Setup request message if (x2ap_encode_x2setuprequest_ies(&x2SetupRequest, x2SetupRequest_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_x2Setup if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_x2Setup, Criticality_reject, &asn_DEF_X2SetupRequest, &x2SetupRequest) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_reset_response_encoder(ResetResponse_IEs_t *resetResponse_IEs, uint8_t **buf, uint32_t *length){ int i; ResetResponse_t resetResponse; memset (&resetResponse,0, sizeof(ResetResponse_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset Response message if (x2ap_encode_resetresponse_ies(&resetResponse, resetResponse_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_reset if (x2ap_generate_successfull_outcome(buf, length, ProcedureCode_id_reset, Criticality_reject, &asn_DEF_ResetResponse, &resetResponse) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_mobility_change_failure_encoder(MobilityChangeFailure_IEs_t *mobilityChangeFailure_IEs, uint8_t **buf, uint32_t *length){ int i; MobilityChangeFailure_t mobilityChangeFailure; memset (&mobilityChangeFailure,0, sizeof(MobilityChangeFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Mobility Change Failure message if (x2ap_encode_mobilitychangefailure_ies(&mobilityChangeFailure, mobilityChangeFailure_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_mobilitySettingsChange if (x2ap_generate_unsuccessfull_outcome (buf, length, ProcedureCode_id_mobilitySettingsChange, Criticality_reject, &asn_DEF_MobilityChangeFailure, &mobilityChangeFailure) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_mobility_change_acknowledge_encoder(MobilityChangeAcknowledge_IEs_t *mobilityChangeAcknowledge_IEs, uint8_t **buf, uint32_t *length){ int i; MobilityChangeAcknowledge_t mobilityChangeAcknowledge; memset (&mobilityChangeAcknowledge,0, sizeof(MobilityChangeAcknowledge_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Mobility Change Acknowledge message if (x2ap_encode_mobilitychangeacknowledge_ies(&mobilityChangeAcknowledge, mobilityChangeAcknowledge_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_mobilitySettingsChange if (x2ap_generate_successfull_outcome (buf, length, ProcedureCode_id_mobilitySettingsChange, Criticality_reject, &asn_DEF_MobilityChangeAcknowledge, &mobilityChangeAcknowledge) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_mobility_change_request_encoder(MobilityChangeRequest_IEs_t *mobilityChangeRequest_IEs, uint8_t **buf, uint32_t *length){ int i; MobilityChangeRequest_t mobilityChangeRequest; memset (&mobilityChangeRequest,0, sizeof(MobilityChangeRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Mobility Change Request message if (x2ap_encode_mobilitychangerequest_ies(&mobilityChangeRequest, mobilityChangeRequest_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_mobilitySettingsChange if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_mobilitySettingsChange, Criticality_reject, &asn_DEF_MobilityChangeRequest, &mobilityChangeRequest) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_resource_status_update_encoder(ResourceStatusUpdate_IEs_t *resourceStatusUpdate_IEs, uint8_t **buf, uint32_t *length){ int i; ResourceStatusUpdate_t resourceStatusUpdate; memset (&resourceStatusUpdate,0, sizeof(ResourceStatusUpdate_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Resource Status Update message if (x2ap_encode_resourcestatusupdate_ies(&resourceStatusUpdate, resourceStatusUpdate_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_resourceStatusReporting if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_resourceStatusReporting, Criticality_ignore, &asn_DEF_ResourceStatusUpdate, &resourceStatusUpdate) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_resource_status_failure_encoder(ResourceStatusFailure_IEs_t *resourceStatusFailure_IEs, uint8_t **buf, uint32_t *length){ int i; ResourceStatusFailure_t resourceStatusFailure; memset (&resourceStatusFailure,0, sizeof(ResourceStatusFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Resource Status Failure message if (x2ap_encode_resourcestatusfailure_ies(&resourceStatusFailure, resourceStatusFailure_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_resourceStatusReportingInitiation if (x2ap_generate_unsuccessfull_outcome (buf, length, ProcedureCode_id_resourceStatusReportingInitiation, Criticality_reject, &asn_DEF_ResourceStatusFailure, &resourceStatusFailure) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_resource_status_response_encoder(ResourceStatusResponse_IEs_t *resourceStatusResponse_IEs, uint8_t **buf, uint32_t *length){ int i; ResourceStatusResponse_t resourceStatusResponse; memset (&resourceStatusResponse,0, sizeof(ResourceStatusResponse_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Resource Status Response message if (x2ap_encode_resourcestatusresponse_ies(&resourceStatusResponse, resourceStatusResponse_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_resourceStatusReportingInitiation if (x2ap_generate_successfull_outcome (buf, length, ProcedureCode_id_resourceStatusReportingInitiation, Criticality_reject, &asn_DEF_ResourceStatusResponse, &resourceStatusResponse) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_resource_status_request_encoder(ResourceStatusRequest_IEs_t *resourceStatusRequest_IEs, uint8_t **buf, uint32_t *length){ int i; ResourceStatusRequest_t resourceStatusRequest; memset (&resourceStatusRequest,0, sizeof(ResourceStatusRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Resource Status Resquest message if (x2ap_encode_resourcestatusrequest_ies(&resourceStatusRequest, resourceStatusRequest_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_resourceStatusReportingInitiation if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_resourceStatusReportingInitiation, Criticality_reject, &asn_DEF_ResourceStatusRequest, &resourceStatusRequest) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_load_information_encoder(LoadInformation_IEs_t *loadInformation_IEs, uint8_t **buf, uint32_t *length){ int i; LoadInformation_t loadInformation; memset (&loadInformation,0, sizeof(LoadInformation_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_loadinformation_ies(&loadInformation, loadInformation_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_loadIndication, Criticality_ignore, &asn_DEF_LoadInformation, &loadInformation) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_handover_request_encoder(HandoverRequest_IEs_t *handoverRequest_IEs, uint8_t **buf, uint32_t *length){ int i; HandoverRequest_t x2HandoverRequest; memset (&x2HandoverRequest,0, sizeof(HandoverRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_handoverrequest_ies(&x2HandoverRequest, handoverRequest_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_handoverPreparation, Criticality_reject, &asn_DEF_HandoverRequest, &x2HandoverRequest) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_handover_request_acknowledge_encoder(HandoverRequestAcknowledge_IEs_t *handoverRequestAcknowledge_IEs, uint8_t **buf, uint32_t *length){ int i; HandoverRequestAcknowledge_t x2HandoverRequestAcknowledge; memset (&x2HandoverRequestAcknowledge,0, sizeof(HandoverRequestAcknowledge_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_handoverrequestacknowledge_ies(&x2HandoverRequestAcknowledge, handoverRequestAcknowledge_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } if (x2ap_generate_successfull_outcome(buf, length, ProcedureCode_id_handoverPreparation, Criticality_reject, &asn_DEF_HandoverRequestAcknowledge, &x2HandoverRequestAcknowledge) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_handover_preparation_failure_encoder(HandoverPreparationFailure_IEs_t *handoverPreparationFailure_IEs, uint8_t **buf, uint32_t *length){ int i; HandoverPreparationFailure_t x2HandoverPreparationFailure; memset (&x2HandoverPreparationFailure,0, sizeof(HandoverPreparationFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_handoverpreparationfailure_ies(&x2HandoverPreparationFailure, handoverPreparationFailure_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_unsuccessfull_outcome(buf, length, ProcedureCode_id_handoverPreparation, Criticality_reject, &asn_DEF_HandoverPreparationFailure, &x2HandoverPreparationFailure) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_error_indication_encoder(ErrorIndication_IEs_t *errorIndication_IEs, uint8_t **buf, uint32_t *length){ int i; ErrorIndication_t x2Error_indication; memset (&x2Error_indication,0, sizeof(ErrorIndication_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_errorindication_ies(&x2Error_indication, errorIndication_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message(buf, length, ProcedureCode_id_errorIndication, Criticality_ignore, &asn_DEF_ErrorIndication, &x2Error_indication) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_handover_cancel_encoder(HandoverCancel_IEs_t *handoverCancel_IEs, uint8_t **buf, uint32_t *length){ int i; HandoverCancel_t x2HandoverCancel; memset (&x2HandoverCancel,0, sizeof(HandoverCancel_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_handovercancel_ies(&x2HandoverCancel, handoverCancel_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message(buf, length, ProcedureCode_id_handoverCancel, Criticality_ignore, &asn_DEF_HandoverCancel, &x2HandoverCancel) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_handover_report_encoder( HandoverReport_IEs_t *handoverReport_IEs, uint8_t **buf, uint32_t *length){ int i; HandoverReport_t HandoverReport; memset (&HandoverReport,0, sizeof(HandoverReport_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_handoverreport_ies(&HandoverReport, handoverReport_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message(buf, length, ProcedureCode_id_handoverReport, Criticality_ignore, &asn_DEF_HandoverReport, &HandoverReport) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_eNB_configuration_update_request_encoder(ENBConfigurationUpdate_IEs_t *enbConfigurationUpdate_IEs, uint8_t **buf, uint32_t *length){ int i; ENBConfigurationUpdate_t x2ENBConfigurationUpdate; memset (&x2ENBConfigurationUpdate,0, sizeof(ENBConfigurationUpdate_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_enbconfigurationupdate_ies(&x2ENBConfigurationUpdate, enbConfigurationUpdate_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_initiating_message(buf, length, ProcedureCode_id_eNBConfigurationUpdate, Criticality_reject, &asn_DEF_ENBConfigurationUpdate, &x2ENBConfigurationUpdate) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_eNB_configuration_update_acknowledge_encoder(ENBConfigurationUpdateAcknowledge_IEs_t *enbConfigurationUpdateAcknowledge_IEs, uint8_t **buf, uint32_t *length){ int i; ENBConfigurationUpdateAcknowledge_t x2ENBConfigurationUpdateAcknowledge; memset (&x2ENBConfigurationUpdateAcknowledge,0, sizeof(ENBConfigurationUpdateAcknowledge_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_enbconfigurationupdateacknowledge_ies(&x2ENBConfigurationUpdateAcknowledge, enbConfigurationUpdateAcknowledge_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_loadIndication if (x2ap_generate_successfull_outcome(buf, length, ProcedureCode_id_eNBConfigurationUpdate, Criticality_reject, &asn_DEF_ENBConfigurationUpdateAcknowledge, &x2ENBConfigurationUpdateAcknowledge) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_eNB_configuration_update_failure_encoder( ENBConfigurationUpdateFailure_IEs_t *enbConfigurationUpdateFailure_IEs, uint8_t **buf, uint32_t *length){ int i; ENBConfigurationUpdateFailure_t x2ENBConfigurationUpdateFailure; memset (&x2ENBConfigurationUpdateFailure,0, sizeof(ENBConfigurationUpdateFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Reset request message if (x2ap_encode_enbconfigurationupdatefailure_ies(&x2ENBConfigurationUpdateFailure, enbConfigurationUpdateFailure_IEs) <0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_eNBConfigurationUpdate if (x2ap_generate_unsuccessfull_outcome(buf, length, ProcedureCode_id_eNBConfigurationUpdate, Criticality_reject, &asn_DEF_ENBConfigurationUpdateFailure, &x2ENBConfigurationUpdateFailure) <0) { printf ("Encode procedure failes\n"); return -1; } for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_cell_activation_failure_encoder(CellActivationFailure_IEs_t *cellActivationFailure_IEs, uint8_t **buf, uint32_t *length){ int i; CellActivationFailure_t cellActivationFailure; memset (&cellActivationFailure,0, sizeof(CellActivationFailure_t)); asn1_xer_print = 0; asn_debug = 0; // encoding cell activationfailure message if (x2ap_encode_cellactivationfailure_ies(&cellActivationFailure,cellActivationFailure_IEs)<0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_cellActivation if (x2ap_generate_unsuccessfull_outcome (buf, length, ProcedureCode_id_cellActivation , Criticality_reject, &asn_DEF_CellActivationFailure, &cellActivationFailure) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_cell_activation_response_encoder(CellActivationResponse_IEs_t *cellActivationResponse_IEs, uint8_t **buf, uint32_t *length) { int i; CellActivationResponse_t cellActivationResponse;; memset (&cellActivationResponse,0, sizeof(CellActivationResponse_t)); asn1_xer_print = 0; asn_debug = 0; // encoding Cell Activation Response message if (x2ap_encode_cellactivationresponse_ies(&cellActivationResponse,cellActivationResponse_IEs)<0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_cellActivation if (x2ap_generate_successfull_outcome (buf, length, ProcedureCode_id_cellActivation , Criticality_reject, &asn_DEF_CellActivationResponse, &cellActivationResponse) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_cell_activation_request_encoder(CellActivationRequest_IEs_t *cellActivationRequest_IEs, uint8_t **buf, uint32_t *length) { int i; CellActivationRequest_t cellActivationRequest; memset (&cellActivationRequest,0, sizeof(CellActivationRequest_t)); asn1_xer_print = 0; asn_debug = 0; // encoding cell Activation Request message if (x2ap_encode_cellactivationrequest_ies(&cellActivationRequest,cellActivationRequest_IEs)<0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_cellActivation if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_cellActivation , Criticality_reject, &asn_DEF_CellActivationRequest, &cellActivationRequest) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_rlf_indication_encoder(RLFIndication_IEs_t *rlfIndication_IEs, uint8_t **buf, uint32_t *length) { int i; RLFIndication_t rlfIndication; memset (&rlfIndication,0, sizeof(RLFIndication_t)); asn1_xer_print = 0; asn_debug = 0; // encoding RLF Indication message if (x2ap_encode_rlfindication_ies(&rlfIndication,rlfIndication_IEs)<0) { printf ("Encode procedure failes\n"); return -1; } // encoding ProcedureCode_id_rlfIndication if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_rLFIndication , Criticality_reject, &asn_DEF_RLFIndication, &rlfIndication) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_sn_status_transfer_encoder(SNStatusTransfer_IEs_t *snStatusTransfer_IEs, uint8_t **buf, uint32_t *length){ int i; SNStatusTransfer_t snStatusTransfer; memset (&snStatusTransfer,0, sizeof(SNStatusTransfer_t)); asn1_xer_print = 0; asn_debug = 0; // encoding sn status transfer message if (x2ap_encode_snstatustransfer_ies(&snStatusTransfer,snStatusTransfer_IEs)<0) { printf ("Encode procedure failes\n"); return -1; } if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_snStatusTransfer , Criticality_reject, &asn_DEF_SNStatusTransfer, &snStatusTransfer) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); } static inline int x2ap_ue_context_release_encoder(UEContextRelease_IEs_t *uecontext_rel, uint8_t **buf, uint32_t *length){ int i; UEContextRelease_t ueContextRelease; memset (&ueContextRelease,0, sizeof(UEContextRelease_t)); asn1_xer_print = 0; asn_debug = 0; // encoding ue context release message if (x2ap_encode_uecontextrelease_ies(&ueContextRelease, uecontext_rel) <0) { printf ("Encode procedure failes\n"); return -1; } //Procedure code for UE Context Release = "5" if (x2ap_generate_initiating_message (buf, length, ProcedureCode_id_uEContextRelease , Criticality_reject, &asn_DEF_UEContextRelease, &ueContextRelease) <0) { printf ("Initiating Message for Encode procedure failes\n"); return -1; } //Printing Buff values on terminal for (i=0;i< *length; i++) { printf ("0x%02x ", (*buf)[i]); } printf ("\n"); }