From cdfca6c00a0cf7410a35e749df15f0e43bf10804 Mon Sep 17 00:00:00 2001 From: Bing-Kai Hong <Bing-Kai.Hong@eurecom.fr> Date: Wed, 5 Sep 2018 11:14:35 +0200 Subject: [PATCH] F1: 1.create the f1ap handlers procedure 2.hide asn1c warning when in compile --- cmake_targets/CMakeLists.txt | 34 +- common/utils/T/T_messages.txt | 15 + openair2/F1AP/CU_F1AP.c | 119 +-- openair2/F1AP/DU_F1AP.c | 80 +- openair2/F1AP/f1ap_common.h | 14 +- openair2/F1AP/f1ap_decoder.c | 247 +++--- openair2/F1AP/f1ap_decoder.h | 13 +- openair2/F1AP/f1ap_handlers.c | 1348 ++------------------------------- openair2/F1AP/f1ap_handlers.h | 2 - openair2/F1AP/sctp_cu.c | 6 +- 10 files changed, 318 insertions(+), 1560 deletions(-) diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index 92ec6de90f..43ce9315f6 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -323,7 +323,9 @@ set (RRC_FULL_DIR ${asn1_generated_dir}/RRC_${RRC_ASN1_VERSION}) message("calling asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -D ${RRC_FULL_DIR} ${RRC_GRAMMAR}") execute_process(COMMAND mkdir -p ${RRC_FULL_DIR} COMMAND env asn1c -pdu=all -fcompound-names -gen-PER -no-gen-OER -no-gen-example -D ${RRC_FULL_DIR} ${RRC_GRAMMAR} - RESULT_VARIABLE ret) + RESULT_VARIABLE ret + OUTPUT_QUIET + ERROR_QUIET) if (NOT ${ret} STREQUAL 0) message(FATAL_ERROR "${ret}: error") endif (NOT ${ret} STREQUAL 0) @@ -384,7 +386,10 @@ set(S1AP_C_DIR ${asn1_generated_dir}/S1AP_${S1AP_RELEASE}) message("calling ASN1C_PREFIX=S1AP_ asn1c -pdu=all -fcompound-names -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D ${S1AP_C_DIR} ${S1AP_ASN_DIR}/${S1AP_ASN_FILES}") execute_process(COMMAND mkdir -p ${S1AP_C_DIR} COMMAND env "ASN1C_PREFIX=S1AP_" asn1c -pdu=all -fcompound-names -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D ${S1AP_C_DIR} ${S1AP_ASN_DIR}/${S1AP_ASN_FILES} - RESULT_VARIABLE ret) + RESULT_VARIABLE ret + OUTPUT_QUIET + ERROR_QUIET) + if (NOT ${ret} STREQUAL 0) message(FATAL_ERROR "${ret}: error") endif (NOT ${ret} STREQUAL 0) @@ -451,7 +456,9 @@ set(X2AP_C_DIR ${asn1_generated_dir}/X2AP_${X2AP_RELEASE}) message("calling ASN1C_PREFIX=X2AP_ asn1c -pdu=all -fcompound-names -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D ${X2AP_C_DIR} ${X2AP_ASN_DIR}/${X2AP_ASN_FILES}") execute_process(COMMAND mkdir -p ${X2AP_C_DIR} COMMAND env "ASN1C_PREFIX=X2AP_" asn1c -pdu=all -fcompound-names -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D ${X2AP_C_DIR} ${X2AP_ASN_DIR}/${X2AP_ASN_FILES} - RESULT_VARIABLE ret) + RESULT_VARIABLE ret + OUTPUT_QUIET + ERROR_QUIET) if (NOT ${ret} STREQUAL 0) message(FATAL_ERROR "${ret}: error") endif (NOT ${ret} STREQUAL 0) @@ -498,10 +505,13 @@ set(F1AP_ASN_FILES ) set(F1AP_C_DIR ${asn1_generated_dir}/F1AP_${ASN1RELDIR}) -set(ENV{ASN1C_PREFIX} F1AP_) -execute_process(COMMAND ${asn1c_call} ${F1AP_C_DIR} ${F1AP_ASN_FILES} - RESULT_VARIABLE reti) -unset(ENV{ASN1C_PREFIX}) +message("calling ASN1C_PREFIX=F1AP_ asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_C_DIR} ${F1AP_ASN_FILES}") +execute_process(COMMAND mkdir -p ${F1AP_C_DIR} + COMMAND env "ASN1C_PREFIX=F1AP_" asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_C_DIR} ${F1AP_ASN_FILES} + RESULT_VARIABLE ret + OUTPUT_QUIET + ERROR_QUIET) + if (NOT ${ret} STREQUAL 0) message(FATAL_ERROR "${asn1c_call}: error") endif (NOT ${ret} STREQUAL 0) @@ -533,6 +543,8 @@ add_library(F1AP #${F1AP_DIR}/test.c ${F1AP_DIR}/DU_F1AP.c ${F1AP_DIR}/CU_F1AP.c + ${F1AP_DIR}/f1ap_decoder.c + ${F1AP_DIR}/f1ap_handlers.c ${F1AP_DIR}/sctp_du.c ${F1AP_DIR}/sctp_cu.c ) @@ -540,21 +552,25 @@ add_library(F1AP add_executable(test_f1ap_du ${F1AP_DIR}/test_f1ap_du.c ${F1AP_DIR}/DU_F1AP.c + ${F1AP_DIR}/f1ap_decoder.c + ${F1AP_DIR}/f1ap_handlers.c ${F1AP_DIR}/sctp_du.c ) target_link_libraries(test_f1ap_du - -Wl,--start-group F1AP_LIB sctp pthread -Wl,--end-group + -Wl,--start-group F1AP_LIB ${T_LIB} sctp pthread -Wl,--end-group ) add_executable(test_f1ap_cu ${F1AP_DIR}/test_f1ap_cu.c ${F1AP_DIR}/CU_F1AP.c + ${F1AP_DIR}/f1ap_decoder.c + ${F1AP_DIR}/f1ap_handlers.c ${F1AP_DIR}/sctp_cu.c ) target_link_libraries(test_f1ap_cu - -Wl,--start-group F1AP_LIB sctp pthread -Wl,--end-group + -Wl,--start-group F1AP_LIB ${T_LIB} sctp pthread -Wl,--end-group ) # Hardware dependant options diff --git a/common/utils/T/T_messages.txt b/common/utils/T/T_messages.txt index ccac7de253..904fcb7355 100644 --- a/common/utils/T/T_messages.txt +++ b/common/utils/T/T_messages.txt @@ -868,6 +868,21 @@ ID = LEGACY_F1U_ERROR GROUP = ALL:LEGACY_F1U:LEGACY_GROUP_ERROR:LEGACY FORMAT = string,log +ID = LEGACY_F1AP_DEBUG + DESC = F1AP DEBUG LEVEL + GROUP = ALL:LEGACY_F1AP:LEGACY_GROUP_DEBUG:LEGACY + FORMAT = string,log + +ID = LEGACY_F1AP_INFO + DESC = F1AP INFO LEVEL + GROUP = ALL:LEGACY_F1AP:LEGACY_GROUP_INFO:LEGACY + FORMAT = string,log + +ID = LEGACY_F1AP_ERROR + DESC = F1AP ERROR LEVEL + GROUP = ALL:LEGACY_F1AP:LEGACY_GROUP_ERROR:LEGACY + FORMAT = string,log + ################# #### UE LOGS #### ################# diff --git a/openair2/F1AP/CU_F1AP.c b/openair2/F1AP/CU_F1AP.c index 8130f9b8e3..077dd4c858 100644 --- a/openair2/F1AP/CU_F1AP.c +++ b/openair2/F1AP/CU_F1AP.c @@ -52,7 +52,7 @@ typedef struct f1ap_info { /* This is the optional name provided by the MME */ char *GNB_CU_Name; - net_ip_address_t mme_net_ip_address; // useful for joining assoc_id and ip address of packets + f1ap_net_ip_address_t mme_net_ip_address; // useful for joining assoc_id and ip address of packets /* Number of input/ouput streams */ @@ -87,25 +87,38 @@ uint8_t F1AP_get_next_transaction_identifier(module_id_t enb_mod_idP, module_id_ void F1AP_CU_task() { printf("Start F1AP CU task!\n"); - //sctp_cu_init(); + sctp_cu_init(); - // while (1) { + // MessageDef *received_msg = NULL; + // int result; + + // F1AP_DEBUG("Starting F1AP layer\n"); - // switch () { + // f1ap_eNB_prepare_internal_data(); - //case F1AP_ProcedureCode_id_F1Setup: - CU_send_F1_SETUP_RESPONSE(); - //case F1AP_ProcedureCode_id_InitialULRRCMessageTransfer: - // CU_handle_UL_INITIAL_RRC_MESSAGE_TRANSFER (); - //CU_send_DL_RRC_MESSAGE_TRANSFER(); // SRBID and RRCContainer get issue when decode. - //CU_send_UE_CONTEXT_SETUP_REQUEST(); - //CU_send_UE_CONTEXT_MODIFICATION_REQUEST(); - //CU_send_gNB_CU_CONFIGURATION_UPDATE((module_id_t)1, (module_id_t)2); // some problem found - // break; + // itti_mark_task_ready(TASK_F1AP); + + // while (1) { + // switch (ITTI_MSG_ID(received_msg)) { + // case F1AP_SETUP_RESP: + // CU_send_F1_SETUP_RESPONSE(); + // break; + // case F1AP_INITIAL_UL_RRC_MESSAGE: + // CU_handle_UL_INITIAL_RRC_MESSAGE_TRANSFER(); + // break; + // case F1AP_DL_RRC_MESSAGE: + // CU_send_DL_RRC_MESSAGE_TRANSFER(); // SRBID and RRCContainer get issue when decode. + // break; + // //CU_send_UE_CONTEXT_SETUP_REQUEST(); + // case F1AP_UE_CONTEXT_MODIFICATION_REQ: + // CU_send_UE_CONTEXT_MODIFICATION_REQUEST(); + // break; + // //CU_send_gNB_CU_CONFIGURATION_UPDATE((module_id_t)1, (module_id_t)2); // some problem found + // break; - // default: + // default: - // } // switch + // } // switch // } // while @@ -321,59 +334,59 @@ int f1ap_encode_pdu(F1AP_F1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *length) { } -int f1ap_decode_pdu(F1AP_F1AP_PDU_t *message, uint8_t *buffer, uint32_t length) { +// int f1ap_decode_pdu(F1AP_F1AP_PDU_t *message, uint8_t *buffer, uint32_t length) { - //LOG_I(F1AP,"Entering main loop of DU F1AP pdu receiver\n"); - F1AP_F1AP_PDU_t pdu; - F1AP_F1AP_PDU_t *pdu_p = &pdu; - asn_dec_rval_t dec_ret; +// //LOG_I(F1AP,"Entering main loop of DU F1AP pdu receiver\n"); +// F1AP_F1AP_PDU_t pdu; +// F1AP_F1AP_PDU_t *pdu_p = &pdu; +// asn_dec_rval_t dec_ret; - DevAssert(buffer != NULL); +// DevAssert(buffer != NULL); - printf("buffer = \n"); - int i_ret; - for (i_ret = 0; i_ret < length; i_ret++) { - printf("%x ", *(buffer+i_ret)); - } - printf("\n"); +// printf("buffer = \n"); +// int i_ret; +// for (i_ret = 0; i_ret < length; i_ret++) { +// printf("%x ", *(buffer+i_ret)); +// } +// printf("\n"); - memset((void *)pdu_p, 0, sizeof(F1AP_F1AP_PDU_t)); +// memset((void *)pdu_p, 0, sizeof(F1AP_F1AP_PDU_t)); - dec_ret = aper_decode(NULL, - &asn_DEF_F1AP_F1AP_PDU, - (void **)&pdu_p, - buffer, - length, - 0, - 0); +// dec_ret = aper_decode(NULL, +// &asn_DEF_F1AP_F1AP_PDU, +// (void **)&pdu_p, +// buffer, +// length, +// 0, +// 0); - xer_fprint(stdout, &asn_DEF_F1AP_F1AP_PDU, pdu_p); +// xer_fprint(stdout, &asn_DEF_F1AP_F1AP_PDU, pdu_p); - printf("\n"); +// printf("\n"); - printf("dec_ret.code = %d \n", dec_ret.code); +// printf("dec_ret.code = %d \n", dec_ret.code); - AssertFatal(dec_ret.code == RC_OK,"Failed to decode pdu\n"); +// AssertFatal(dec_ret.code == RC_OK,"Failed to decode pdu\n"); - // switch(pdu_p->present) { - // case F1AP_F1AP_PDU_PR_initiatingpdu: - // return F1AP_DU_decode_initiating_pdu(&pdu_p->choice.initiatingpdu); +// // switch(pdu_p->present) { +// // case F1AP_F1AP_PDU_PR_initiatingpdu: +// // return F1AP_DU_decode_initiating_pdu(&pdu_p->choice.initiatingpdu); - // case F1AP_F1AP_PDU_PR_successfulOutcome: - // return F1AP_DU_decode_successful_outcome(&pdu_p->choice.successfulOutcome); +// // case F1AP_F1AP_PDU_PR_successfulOutcome: +// // return F1AP_DU_decode_successful_outcome(&pdu_p->choice.successfulOutcome); - // case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: - // return F1AP_DU_decode_unsuccessful_outcome(&pdu_p->choice.unsuccessfulOutcome); +// // case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: +// // return F1AP_DU_decode_unsuccessful_outcome(&pdu_p->choice.unsuccessfulOutcome); - // default: - // /*AssertFatal(1==0,"Unknown presence (%d) or not implemented\n", (int)pdu_p->present);*/ - // break; - // } +// // default: +// // /*AssertFatal(1==0,"Unknown presence (%d) or not implemented\n", (int)pdu_p->present);*/ +// // break; +// // } - //AssertFatal(1==0,"Shouldn't get here\n"); - return -1; -} +// //AssertFatal(1==0,"Shouldn't get here\n"); +// return -1; +// } void CU_send_F1_SETUP_FAILURE(F1AP_F1SetupFailure_t *F1SetupFailure) { AssertFatal(1==0,"Not implemented yet\n"); diff --git a/openair2/F1AP/DU_F1AP.c b/openair2/F1AP/DU_F1AP.c index f80e72c566..b6915b7af2 100644 --- a/openair2/F1AP/DU_F1AP.c +++ b/openair2/F1AP/DU_F1AP.c @@ -53,7 +53,7 @@ typedef struct f1ap_info { /* This is the optional name provided by the MME */ char *GNB_DU_Name; - net_ip_address_t mme_net_ip_address; // useful for joining assoc_id and ip address of packets + f1ap_net_ip_address_t mme_net_ip_address; // useful for joining assoc_id and ip address of packets /* Number of input/ouput streams */ @@ -103,7 +103,7 @@ void F1AP_DU_task() { // switch () { // case F1AP_ProcedureCode_id_F1Setup: - //DU_send_F1_SETUP_REQUEST((module_id_t)1, (module_id_t)2); + DU_send_F1_SETUP_REQUEST((module_id_t)1, (module_id_t)2); // break; //DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(); //DU_send_UL_RRC_MESSAGE_TRANSFER(); // OK @@ -422,59 +422,59 @@ int f1ap_encode_pdu(F1AP_F1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *length) { } -int f1ap_decode_pdu(F1AP_F1AP_PDU_t *message, uint8_t *buffer, uint32_t length) { +// int f1ap_decode_pdu(F1AP_F1AP_PDU_t *message, uint8_t *buffer, uint32_t length) { - //LOG_I(F1AP,"Entering main loop of DU F1AP pdu receiver\n"); - F1AP_F1AP_PDU_t pdu; - F1AP_F1AP_PDU_t *pdu_p = &pdu; - asn_dec_rval_t dec_ret; +// //LOG_I(F1AP,"Entering main loop of DU F1AP pdu receiver\n"); +// F1AP_F1AP_PDU_t pdu; +// F1AP_F1AP_PDU_t *pdu_p = &pdu; +// asn_dec_rval_t dec_ret; - DevAssert(buffer != NULL); +// DevAssert(buffer != NULL); - printf("buffer = \n"); - int i_ret; - for (i_ret = 0; i_ret < length; i_ret++) { - printf("%x ", *(buffer+i_ret)); - } - printf("\n"); +// printf("buffer = \n"); +// int i_ret; +// for (i_ret = 0; i_ret < length; i_ret++) { +// printf("%x ", *(buffer+i_ret)); +// } +// printf("\n"); - memset((void *)pdu_p, 0, sizeof(F1AP_F1AP_PDU_t)); +// memset((void *)pdu_p, 0, sizeof(F1AP_F1AP_PDU_t)); - dec_ret = aper_decode(NULL, - &asn_DEF_F1AP_F1AP_PDU, - (void **)&pdu_p, - buffer, - length, - 0, - 0); +// dec_ret = aper_decode(NULL, +// &asn_DEF_F1AP_F1AP_PDU, +// (void **)&pdu_p, +// buffer, +// length, +// 0, +// 0); - xer_fprint(stdout, &asn_DEF_F1AP_F1AP_PDU, pdu_p); +// xer_fprint(stdout, &asn_DEF_F1AP_F1AP_PDU, pdu_p); - printf("\n"); +// printf("\n"); - printf("dec_ret.code = %d \n", dec_ret.code); +// printf("dec_ret.code = %d \n", dec_ret.code); - AssertFatal(dec_ret.code == RC_OK,"Failed to decode pdu\n"); +// AssertFatal(dec_ret.code == RC_OK,"Failed to decode pdu\n"); - // switch(pdu_p->present) { - // case F1AP_F1AP_PDU_PR_initiatingpdu: - // return F1AP_DU_decode_initiating_pdu(&pdu_p->choice.initiatingpdu); +// // switch(pdu_p->present) { +// // case F1AP_F1AP_PDU_PR_initiatingpdu: +// // return F1AP_DU_decode_initiating_pdu(&pdu_p->choice.initiatingpdu); - // case F1AP_F1AP_PDU_PR_successfulOutcome: - // return F1AP_DU_decode_successful_outcome(&pdu_p->choice.successfulOutcome); +// // case F1AP_F1AP_PDU_PR_successfulOutcome: +// // return F1AP_DU_decode_successful_outcome(&pdu_p->choice.successfulOutcome); - // case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: - // return F1AP_DU_decode_unsuccessful_outcome(&pdu_p->choice.unsuccessfulOutcome); +// // case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: +// // return F1AP_DU_decode_unsuccessful_outcome(&pdu_p->choice.unsuccessfulOutcome); - // default: - // /*AssertFatal(1==0,"Unknown presence (%d) or not implemented\n", (int)pdu_p->present);*/ - // break; - // } +// // default: +// // /*AssertFatal(1==0,"Unknown presence (%d) or not implemented\n", (int)pdu_p->present);*/ +// // break; +// // } - //AssertFatal(1==0,"Shouldn't get here\n"); - return -1; -} +// //AssertFatal(1==0,"Shouldn't get here\n"); +// return -1; +// } // ssize_t s1ap_generate_initiating_pdu( diff --git a/openair2/F1AP/f1ap_common.h b/openair2/F1AP/f1ap_common.h index 22dc981565..fb33333a41 100644 --- a/openair2/F1AP/f1ap_common.h +++ b/openair2/F1AP/f1ap_common.h @@ -375,7 +375,7 @@ extern int asn1_xer_print; #include "assertions.h" #if defined(ENB_MODE) -# include "log.h" +# include "common/utils/LOG/log.h" # include "f1ap_default_values.h" # define F1AP_ERROR(x, args...) LOG_E(F1AP, x, ##args) # define F1AP_WARN(x, args...) LOG_W(F1AP, x, ##args) @@ -394,30 +394,30 @@ extern int asn1_xer_print; //Forward declaration //struct f1ap_message_s; -typedef struct net_ip_address_s { +typedef struct f1ap_net_ip_address_s { unsigned ipv4:1; unsigned ipv6:1; char ipv4_address[16]; char ipv6_address[46]; -} net_ip_address_t; +} f1ap_net_ip_address_t; -typedef struct f1ap_message_s { +/*typedef struct f1ap_message_s { F1AP_ProtocolIE_ID_t id; F1AP_Criticality_t criticality; uint8_t direction; union { F1AP_F1SetupRequestIEs_t f1ap_F1SetupRequestIEs; } msg; -} f1ap_message; +} f1ap_message;*/ /** \brief Function callback prototype. **/ -/*typedef int (*f1ap_message_decoded_callback)( +typedef int (*f1ap_message_decoded_callback)( uint32_t assoc_id, uint32_t stream, struct f1ap_message_s *message_p -);*/ +); /** \brief Encode a successfull outcome message \param buffer pointer to buffer in which data will be encoded diff --git a/openair2/F1AP/f1ap_decoder.c b/openair2/F1AP/f1ap_decoder.c index 9d89cf5172..fa861915f4 100644 --- a/openair2/F1AP/f1ap_decoder.c +++ b/openair2/F1AP/f1ap_decoder.c @@ -37,199 +37,142 @@ #include "intertask_interface.h" #include "f1ap_common.h" -#include "f1ap_ies_defs.h" #include "f1ap_decoder.h" -static int f1ap_decode_initiating_message(f1ap_message *message, - F1ap_InitiatingMessage_t *initiating_p) +static int f1ap_eNB_decode_initiating_message(F1AP_F1AP_PDU_t *pdu) { - int ret = -1; MessageDef *message_p; - char *message_string = NULL; - size_t message_string_size; MessagesIds message_id; - - DevAssert(initiating_p != NULL); - - message_string = calloc(10000, sizeof(char)); - - f1ap_string_total_size = 0; - - message->procedureCode = initiating_p->procedureCode; - message->criticality = initiating_p->criticality; - - switch(initiating_p->procedureCode) { - - case F1ap_ProcedureCode_id_InitialContextSetup: - ret = f1ap_decode_f1ap_initialcontextsetuprequesties( - &message->msg.f1ap_InitialContextSetupRequestIEs, &initiating_p->value); - f1ap_xer_print_f1ap_initialcontextsetuprequest(f1ap_xer__print2sp, message_string, message); - message_id = F1AP_INITIAL_CONTEXT_SETUP_LOG; - message_string_size = strlen(message_string); - message_p = itti_alloc_new_message_sized(TASK_F1AP, - message_id, - message_string_size + sizeof (IttiMsgText)); - message_p->ittiMsg.f1ap_initial_context_setup_log.size = message_string_size; - memcpy(&message_p->ittiMsg.f1ap_initial_context_setup_log.text, message_string, message_string_size); - itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); - free(message_string); - break; - - case F1ap_ProcedureCode_id_UEContextRelease: - ret = f1ap_decode_f1ap_uecontextreleasecommandies( - &message->msg.f1ap_UEContextReleaseCommandIEs, &initiating_p->value); - f1ap_xer_print_f1ap_uecontextreleasecommand(f1ap_xer__print2sp, message_string, message); - message_id = F1AP_UE_CONTEXT_RELEASE_COMMAND_LOG; - message_string_size = strlen(message_string); - message_p = itti_alloc_new_message_sized(TASK_F1AP, - message_id, - message_string_size + sizeof (IttiMsgText)); - message_p->ittiMsg.f1ap_ue_context_release_command_log.size = message_string_size; - memcpy(&message_p->ittiMsg.f1ap_ue_context_release_command_log.text, message_string, message_string_size); - itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); - free(message_string); - break; - - case F1ap_ProcedureCode_id_ErrorIndication: - ret = f1ap_decode_f1ap_errorindicationies( - &message->msg.f1ap_ErrorIndicationIEs, &initiating_p->value); - f1ap_xer_print_f1ap_errorindication(f1ap_xer__print2sp, message_string, message); - message_id = F1AP_E_RAB_ERROR_INDICATION_LOG; - message_string_size = strlen(message_string); - message_p = itti_alloc_new_message_sized(TASK_F1AP, - message_id, - message_string_size + sizeof (IttiMsgText)); - message_p->ittiMsg.f1ap_e_rab_release_request_log.size = message_string_size; - memcpy(&message_p->ittiMsg.f1ap_error_indication_log.text, message_string, message_string_size); - itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); - free(message_string); - F1AP_INFO("ErrorIndication initiating message\n"); - break; - - default: - F1AP_ERROR("Unknown procedure ID (%d) for initiating message\n", - (int)initiating_p->procedureCode); - AssertFatal( 0 , "Unknown procedure ID (%d) for initiating message\n", - (int)initiating_p->procedureCode); - return -1; + asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; + DevAssert(pdu != NULL); + + switch(pdu->choice.initiatingMessage->procedureCode) { + + case F1AP_ProcedureCode_id_F1Setup: + res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_F1AP_F1AP_PDU, pdu); + printf("f1ap_eNB_decode_initiating_message!\n"); + break; + // case F1AP_ProcedureCode_id_InitialContextSetup: + // res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_F1AP_F1AP_PDU, pdu); + // message_id = F1AP_INITIAL_CONTEXT_SETUP_LOG; + // message_p = itti_alloc_new_message_sized(TASK_F1AP, message_id, + // res.result.encoded + sizeof (IttiMsgText)); + // message_p->ittiMsg.f1ap_initial_context_setup_log.size = res.result.encoded; + // memcpy(&message_p->ittiMsg.f1ap_initial_context_setup_log.text, res.buffer, res.result.encoded); + // itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); + // free(res.buffer); + // break; + + default: + // F1AP_ERROR("Unknown procedure ID (%d) for initiating message\n", + // (int)pdu->choice.initiatingMessage->procedureCode); + printf("Unknown procedure ID (%d) for initiating message\n", + (int)pdu->choice.initiatingMessage->procedureCode); + AssertFatal( 0, "Unknown procedure ID (%d) for initiating message\n", + (int)pdu->choice.initiatingMessage->procedureCode); + return -1; } - - return ret; + return 0; } -static int f1ap_decode_successful_outcome(f1ap_message *message, - F1ap_SuccessfulOutcome_t *successfullOutcome_p) +static int f1ap_eNB_decode_successful_outcome(F1AP_F1AP_PDU_t *pdu) { - int ret = -1; MessageDef *message_p; - char *message_string = NULL; - size_t message_string_size; MessagesIds message_id; - - DevAssert(successfullOutcome_p != NULL); - - message_string = malloc(sizeof(char) * 10000); - memset((void*)message_string,0,sizeof(char) * 10000); - - f1ap_string_total_size = 0; - - message->procedureCode = successfullOutcome_p->procedureCode; - message->criticality = successfullOutcome_p->criticality; - - switch(successfullOutcome_p->procedureCode) { - case F1ap_ProcedureCode_id_F1Setup: - ret = f1ap_decode_f1ap_f1setupresponseies( - &message->msg.f1ap_F1SetupResponseIEs, &successfullOutcome_p->value); - f1ap_xer_print_f1ap_f1setupresponse(f1ap_xer__print2sp, message_string, message); - message_id = F1AP_F1_SETUP_LOG; - break; - - default: - F1AP_ERROR("Unknown procedure ID (%d) for successfull outcome message\n", - (int)successfullOutcome_p->procedureCode); - return -1; + asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; + DevAssert(pdu != NULL); + + switch(pdu->choice.successfulOutcome->procedureCode) { + // case F1AP_ProcedureCode_id_F1Setup: + // res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_F1AP_F1AP_PDU, pdu); + // message_id = F1AP_F1_SETUP_LOG; + // message_p = itti_alloc_new_message_sized(TASK_F1AP, message_id, res.result.encoded + sizeof (IttiMsgText)); + // message_p->ittiMsg.f1ap_s1_setup_log.size = res.result.encoded; + // memcpy(&message_p->ittiMsg.f1ap_s1_setup_log.text, res.buffer, res.result.encoded); + // itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); + // free(res.buffer); + // break; + + default: + // F1AP_ERROR("Unknown procedure ID (%d) for successfull outcome message\n", + // (int)pdu->choice.successfulOutcome->procedureCode); + printf("Unknown procedure ID (%d) for successfull outcome message\n", + (int)pdu->choice.successfulOutcome->procedureCode); + return -1; } - message_string_size = strlen(message_string); - - message_p = itti_alloc_new_message_sized(TASK_F1AP, message_id, message_string_size + sizeof (IttiMsgText)); - message_p->ittiMsg.f1ap_f1_setup_log.size = message_string_size; - memcpy(&message_p->ittiMsg.f1ap_f1_setup_log.text, message_string, message_string_size); - - itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); - - free(message_string); - - return ret; + return 0; } -static int f1ap_decode_unsuccessful_outcome(f1ap_message *message, - F1ap_UnsuccessfulOutcome_t *unSuccessfullOutcome_p) +static int f1ap_eNB_decode_unsuccessful_outcome(F1AP_F1AP_PDU_t *pdu) { - int ret = -1; - DevAssert(unSuccessfullOutcome_p != NULL); - - message->procedureCode = unSuccessfullOutcome_p->procedureCode; - message->criticality = unSuccessfullOutcome_p->criticality; - - switch(unSuccessfullOutcome_p->procedureCode) { - case F1ap_ProcedureCode_id_F1Setup: - return f1ap_decode_f1ap_f1setupfailureies( - &message->msg.f1ap_F1SetupFailureIEs, &unSuccessfullOutcome_p->value); - - default: - F1AP_ERROR("Unknown procedure ID (%d) for unsuccessfull outcome message\n", - (int)unSuccessfullOutcome_p->procedureCode); - break; + MessageDef *message_p; + MessagesIds message_id; + asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; + DevAssert(pdu != NULL); + + switch(pdu->choice.unsuccessfulOutcome->procedureCode) { + // case F1AP_ProcedureCode_id_F1Setup: + // res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_F1AP_F1AP_PDU, pdu); + // message_id = F1AP_F1_SETUP_LOG; + // message_p = itti_alloc_new_message_sized(TASK_F1AP, message_id, res.result.encoded + sizeof (IttiMsgText)); + // message_p->ittiMsg.f1ap_f1_setup_log.size = res.result.encoded; + // memcpy(&message_p->ittiMsg.f1ap_f1_setup_log.text, res.buffer, res.result.encoded); + // itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); + // free(res.buffer); + // break; + + default: + // F1AP_ERROR("Unknown procedure ID (%d) for unsuccessfull outcome message\n", + // (int)pdu->choice.unsuccessfulOutcome->procedureCode); + printf("Unknown procedure ID (%d) for unsuccessfull outcome message\n", + (int)pdu->choice.unsuccessfulOutcome->procedureCode); + return -1; } - return ret; + return 0; } -int f1ap_decode_pdu(f1ap_message *message, const uint8_t * const buffer, +int f1ap_decode_pdu(F1AP_F1AP_PDU_t *pdu, const uint8_t *const buffer, const uint32_t length) { - F1AP_PDU_t pdu; - F1AP_PDU_t *pdu_p = &pdu; asn_dec_rval_t dec_ret; DevAssert(buffer != NULL); - memset((void *)pdu_p, 0, sizeof(F1AP_PDU_t)); - dec_ret = aper_decode(NULL, - &asn_DEF_F1AP_PDU, - (void **)&pdu_p, + &asn_DEF_F1AP_F1AP_PDU, + (void **)&pdu, buffer, length, 0, 0); + //xer_fprint(stdout, &asn_DEF_F1AP_F1AP_PDU, pdu_p); + if (dec_ret.code != RC_OK) { - F1AP_ERROR("Failed to decode pdu\n"); + //F1AP_ERROR("Failed to decode pdu\n"); + printf("Failed to decode pdu\n"); return -1; } - message->direction = pdu_p->present; + switch(pdu->present) { + case F1AP_F1AP_PDU_PR_initiatingMessage: + return f1ap_eNB_decode_initiating_message(pdu); - switch(pdu_p->present) { - case F1AP_F1AP_PDU_PR_initiatingMessage: - return f1ap_decode_initiating_message(message, - &pdu_p->choice.initiatingMessage); + case F1AP_F1AP_PDU_PR_successfulOutcome: + return f1ap_eNB_decode_successful_outcome(pdu); - case F1AP_F1AP_PDU_PR_successfulOutcome: - return f1ap_decode_successful_outcome(message, - &pdu_p->choice.successfulOutcome); + case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: + return f1ap_eNB_decode_unsuccessful_outcome(pdu); - case F1AP_F1AP_PDU_PR_unsuccessfulOutcome: - return f1ap_decode_unsuccessful_outcome(message, - &pdu_p->choice.unsuccessfulOutcome); - - default: - F1AP_DEBUG("Unknown presence (%d) or not implemented\n", (int)pdu_p->present); - break; + default: + //F1AP_DEBUG("Unknown presence (%d) or not implemented\n", (int)pdu->present); + printf("Unknown presence (%d) or not implemented\n", (int)pdu->present); + break; } + return -1; } diff --git a/openair2/F1AP/f1ap_decoder.h b/openair2/F1AP/f1ap_decoder.h index 81a8e3512b..c16e880c33 100644 --- a/openair2/F1AP/f1ap_decoder.h +++ b/openair2/F1AP/f1ap_decoder.h @@ -30,13 +30,10 @@ * \warning */ -#include <stdint.h> -#include "f1ap_ies_defs.h" +#ifndef F1AP_ENB_ENCODER_H_ +#define F1AP_ENB_ENCODER_H_ -#ifndef F1AP_DECODER_H_ -#define F1AP_DECODER_H_ +int f1ap_eNB_encode_pdu(F1AP_F1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *len) +__attribute__ ((warn_unused_result)); -int f1ap_decode_pdu(f1ap_message *message, const uint8_t * const buffer, - const uint32_t length) __attribute__ ((warn_unused_result)); - -#endif /* F1AP_DECODER_H_ */ +#endif /* F1AP_ENB_ENCODER_H_ */ diff --git a/openair2/F1AP/f1ap_handlers.c b/openair2/F1AP/f1ap_handlers.c index e779364803..dd2be53943 100644 --- a/openair2/F1AP/f1ap_handlers.c +++ b/openair2/F1AP/f1ap_handlers.c @@ -37,17 +37,10 @@ #include "asn1_conversions.h" #include "f1ap_common.h" -#include "f1ap_ies_defs.h" // #include "f1ap_eNB.h" -#include "f1ap_defs.h" #include "f1ap_handlers.h" #include "f1ap_decoder.h" -#include "f1ap_ue_context.h" -#include "f1ap_trace.h" -#include "f1ap_nas_procedures.h" -#include "f1ap_management_procedures.h" - #include "f1ap_default_values.h" #include "assertions.h" @@ -55,1327 +48,106 @@ #include "msc.h" static -int f1ap_handle_f1_setup_response(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p); -static -int f1ap_handle_f1_setup_failure(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p); - -static -int f1ap_handle_error_indication(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p); - -static -int f1ap_handle_initial_context_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p); - -static -int f1ap_handle_ue_context_release_command(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p); +int f1ap_handle_f1_setup_request(uint32_t assoc_id, + uint32_t stream, + F1AP_F1AP_PDU_t *pdu); -static -int f1ap_handle_e_rab_setup_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p); - -static -int f1ap_handle_paging(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p); - -static -int f1ap_handle_e_rab_modify_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p); - -static -int f1ap_handle_e_rab_release_command(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p); - -/* Handlers matrix. Only eNB related procedure present here */ +/* Handlers matrix. Only f1 related procedure present here */ f1ap_message_decoded_callback messages_callback[][3] = { - { 0, 0, 0 }, /* HandoverPreparation */ - { 0, 0, 0 }, /* HandoverResourceAllocation */ - { 0, 0, 0 }, /* HandoverNotification */ - { 0, 0, 0 }, /* PathSwitchRequest */ - { 0, 0, 0 }, /* HandoverCancel */ - { f1ap_handle_e_rab_setup_request, 0, 0 }, /* E_RABSetup */ - { f1ap_handle_e_rab_modify_request, 0, 0 }, /* E_RABModify */ - { f1ap_handle_e_rab_release_command, 0, 0 }, /* E_RABRelease */ - { 0, 0, 0 }, /* E_RABReleaseIndication */ - { f1ap_handle_initial_context_request, 0, 0 }, /* InitialContextSetup */ - { f1ap_handle_paging, 0, 0 }, /* Paging */ - { f1ap_handle_nas_downlink, 0, 0 }, /* downlinkNASTransport */ - { 0, 0, 0 }, /* initialUEMessage */ - { 0, 0, 0 }, /* uplinkNASTransport */ + + { 0, 0, 0 }, /* Reset */ - { f1ap_handle_error_indication, 0, 0 }, /* ErrorIndication */ - { 0, 0, 0 }, /* NASNonDeliveryIndication */ - { 0, f1ap_handle_f1_setup_response, f1ap_handle_f1_setup_failure }, /* F1Setup */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* F1Setup */ + { 0, 0, 0 }, /* ErrorIndication */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* gNBDUConfigurationUpdate */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* gNBCUConfigurationUpdate */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* UEContextSetup */ + { 0, 0, 0 }, /* UEContextRelease */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* UEContextModification */ + { 0, 0, 0 }, /* UEContextModificationRequired */ + { 0, 0, 0 }, /* UEMobilityCommand */ { 0, 0, 0 }, /* UEContextReleaseRequest */ - { 0, 0, 0 }, /* DownlinkF1cdma2000tunneling */ - { 0, 0, 0 }, /* UplinkF1cdma2000tunneling */ - { 0, 0, 0 }, /* UEContextModification */ - { 0, 0, 0 }, /* UECapabilityInfoIndication */ - { f1ap_handle_ue_context_release_command, 0, 0 }, /* UEContextRelease */ - { 0, 0, 0 }, /* eNBStatusTransfer */ - { 0, 0, 0 }, /* MMEStatusTransfer */ - { f1ap_handle_deactivate_trace, 0, 0 }, /* DeactivateTrace */ - { f1ap_handle_trace_start, 0, 0 }, /* TraceStart */ - { 0, 0, 0 }, /* TraceFailureIndication */ - { 0, 0, 0 }, /* ENBConfigurationUpdate */ - { 0, 0, 0 }, /* MMEConfigurationUpdate */ - { 0, 0, 0 }, /* LocationReportingControl */ - { 0, 0, 0 }, /* LocationReportingFailureIndication */ - { 0, 0, 0 }, /* LocationReport */ - { 0, 0, 0 }, /* OverloadStart */ - { 0, 0, 0 }, /* OverloadStop */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* InitialULRRCMessageTransfer */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* DLRRCMessageTransfer */ + { f1ap_handle_f1_setup_request, 0, 0 }, /* ULRRCMessageTransfer */ + { 0, 0, 0 }, /* privateMessage */ + { 0, 0, 0 }, /* UEInactivityNotification */ + { 0, 0, 0 }, /* GNBDUResourceCoordination */ + { 0, 0, 0 }, /* SystemInformationDeliveryCommand */ + { 0, 0, 0 }, /* Paging */ + { 0, 0, 0 }, /* Notify */ { 0, 0, 0 }, /* WriteReplaceWarning */ - { 0, 0, 0 }, /* eNBDirectInformationTransfer */ - { 0, 0, 0 }, /* MMEDirectInformationTransfer */ - { 0, 0, 0 }, /* PrivateMessage */ - { 0, 0, 0 }, /* eNBConfigurationTransfer */ - { 0, 0, 0 }, /* MMEConfigurationTransfer */ - { 0, 0, 0 }, /* CellTrafficTrace */ -#if (F1AP_VERSION >= MAKE_VERSION(9, 0, 0)) - { 0, 0, 0 }, /* Kill */ - { 0, 0, 0 }, /* DownlinkUEAssociatedLPPaTransport */ - { 0, 0, 0 }, /* UplinkUEAssociatedLPPaTransport */ - { 0, 0, 0 }, /* DownlinkNonUEAssociatedLPPaTransport */ - { 0, 0, 0 }, /* UplinkNonUEAssociatedLPPaTransport */ -#endif + { 0, 0, 0 }, /* PWSCancel */ + { 0, 0, 0 }, /* PWSRestartIndication */ + { 0, 0, 0 }, /* PWSFailureIndication */ }; -static const char *f1ap_direction2String[] = { +char *f1ap_direction2String(int f1ap_dir) { +static const char *f1ap_direction_String[] = { "", /* Nothing */ - "Originating message", /* originating message */ + "Initiating message", /* initiating message */ "Successfull outcome", /* successfull outcome */ "UnSuccessfull outcome", /* successfull outcome */ }; - -void f1ap_handle_f1_setup_message(f1ap_mme_data_t *mme_desc_p, int sctp_shutdown) -{ - if (sctp_shutdown) { - /* A previously connected MME has been shutdown */ - - /* TODO check if it was used by some eNB and send a message to inform these eNB if there is no more associated MME */ - if (mme_desc_p->state == F1AP_ENB_STATE_CONNECTED) { - mme_desc_p->state = F1AP_ENB_STATE_DISCONNECTED; - - if (mme_desc_p->f1ap_instance->f1ap_mme_associated_nb > 0) { - /* Decrease associated MME number */ - mme_desc_p->f1ap_instance->f1ap_mme_associated_nb --; - } - - /* If there are no more associated MME, inform eNB app */ - if (mme_desc_p->f1ap_instance->f1ap_mme_associated_nb == 0) { - MessageDef *message_p; - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_DEREGISTERED_ENB_IND); - F1AP_DEREGISTERED_ENB_IND(message_p).nb_mme = 0; - itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->f1ap_instance->instance, message_p); - } - } - } else { - /* Check that at least one setup message is pending */ - DevCheck(mme_desc_p->f1ap_instance->f1ap_mme_pending_nb > 0, mme_desc_p->f1ap_instance->instance, - mme_desc_p->f1ap_instance->f1ap_mme_pending_nb, 0); - - if (mme_desc_p->f1ap_instance->f1ap_mme_pending_nb > 0) { - /* Decrease pending messages number */ - mme_desc_p->f1ap_instance->f1ap_mme_pending_nb --; - } - - /* If there are no more pending messages, inform eNB app */ - if (mme_desc_p->f1ap_instance->f1ap_mme_pending_nb == 0) { - MessageDef *message_p; - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_REGISTER_ENB_CNF); - F1AP_REGISTER_ENB_CNF(message_p).nb_mme = mme_desc_p->f1ap_instance->f1ap_mme_associated_nb; - itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->f1ap_instance->instance, message_p); - } - } +return(f1ap_direction_String[f1ap_dir]); } int f1ap_handle_message(uint32_t assoc_id, int32_t stream, const uint8_t * const data, const uint32_t data_length) { - struct f1ap_message_s message; + F1AP_F1AP_PDU_t pdu; + int ret; DevAssert(data != NULL); - memset(&message, 0, sizeof(struct f1ap_message_s)); + memset(&pdu, 0, sizeof(pdu)); - if (f1ap_decode_pdu(&message, data, data_length) < 0) { - F1AP_ERROR("Failed to decode PDU\n"); + if (f1ap_decode_pdu(&pdu, data, data_length) < 0) { + //F1AP_ERROR("Failed to decode PDU\n"); + printf("Failed to decode PDU\n"); return -1; } /* Checking procedure Code and direction of message */ - if (message.procedureCode > sizeof(messages_callback) / (3 * sizeof( + if (pdu.choice.initiatingMessage->procedureCode > sizeof(messages_callback) / (3 * sizeof( f1ap_message_decoded_callback)) - || (message.direction > F1AP_PDU_PR_unsuccessfulOutcome)) { - F1AP_ERROR("[SCTP %d] Either procedureCode %ld or direction %d exceed expected\n", - assoc_id, message.procedureCode, message.direction); + || (pdu.present > F1AP_F1AP_PDU_PR_unsuccessfulOutcome)) { + //F1AP_ERROR("[SCTP %d] Either procedureCode %ld or direction %d exceed expected\n", + // assoc_id, pdu.choice.initiatingMessage->procedureCode, pdu.present); + printf("[SCTP %d] Either procedureCode %ld or direction %d exceed expected\n", + assoc_id, pdu.choice.initiatingMessage->procedureCode, pdu.present); + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1AP_F1AP_PDU, &pdu); return -1; } /* No handler present. * This can mean not implemented or no procedure for eNB (wrong direction). */ - if (messages_callback[message.procedureCode][message.direction-1] == NULL) { - F1AP_ERROR("[SCTP %d] No handler for procedureCode %ld in %s\n", - assoc_id, message.procedureCode, - f1ap_direction2String[message.direction]); + if (messages_callback[pdu.choice.initiatingMessage->procedureCode][pdu.present - 1] == NULL) { + // F1AP_ERROR("[SCTP %d] No handler for procedureCode %ld in %s\n", + // assoc_id, pdu.choice.initiatingMessage->procedureCode, + // f1ap_direction2String(pdu.present - 1)); + printf("[SCTP %d] No handler for procedureCode %ld in %s\n", + assoc_id, pdu.choice.initiatingMessage->procedureCode, + f1ap_direction2String(pdu.present - 1)); + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1AP_F1AP_PDU, &pdu); return -1; } /* Calling the right handler */ - return (*messages_callback[message.procedureCode][message.direction-1]) - (assoc_id, stream, &message); -} - -static -int f1ap_handle_f1_setup_failure(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p) -{ - F1ap_F1SetupFailureIEs_t *f1_setup_failure_p; - f1ap_mme_data_t *mme_desc_p; - - DevAssert(message_p != NULL); - - f1_setup_failure_p = &message_p->msg.f1ap_F1SetupFailureIEs; - - /* F1 Setup Failure == Non UE-related procedure -> stream 0 */ - if (stream != 0) { - F1AP_WARN("[SCTP %d] Received f1 setup failure on stream != 0 (%d)\n", - assoc_id, stream); - } - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received F1 setup response for non existing " - "MME context\n", assoc_id); - return -1; - } - - if ((f1_setup_failure_p->cause.present == F1ap_Cause_PR_misc) && - (f1_setup_failure_p->cause.choice.misc == F1ap_CauseMisc_unspecified)) { - F1AP_WARN("Received f1 setup failure for MME... MME is not ready\n"); - } else { - F1AP_ERROR("Received f1 setup failure for MME... please check your parameters\n"); - } - - mme_desc_p->state = F1AP_ENB_STATE_WAITING; - f1ap_handle_f1_setup_message(mme_desc_p, 0); - - return 0; -} - -static -int f1ap_handle_f1_setup_response(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p) -{ - F1ap_F1SetupResponseIEs_t *f1SetupResponse_p; - f1ap_mme_data_t *mme_desc_p; - int i; - - DevAssert(message_p != NULL); - - f1SetupResponse_p = &message_p->msg.f1ap_F1SetupResponseIEs; - - /* F1 Setup Response == Non UE-related procedure -> stream 0 */ - if (stream != 0) { - F1AP_ERROR("[SCTP %d] Received f1 setup response on stream != 0 (%d)\n", - assoc_id, stream); - return -1; - } - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received F1 setup response for non existing " - "MME context\n", assoc_id); - return -1; - } - - /* The list of served gummei can contain at most 8 elements. - * LTE related gummei is the first element in the list, i.e with an id of 0. - */ - F1AP_DEBUG("servedGUMMEIs.list.count %d\n",f1SetupResponse_p->servedGUMMEIs.list.count); - DevAssert(f1SetupResponse_p->servedGUMMEIs.list.count > 0); - DevAssert(f1SetupResponse_p->servedGUMMEIs.list.count <= 8); - - - for (i = 0; i < f1SetupResponse_p->servedGUMMEIs.list.count; i++) { - struct F1ap_ServedGUMMEIsItem *gummei_item_p; - struct served_gummei_s *new_gummei_p; - int j; - - gummei_item_p = (struct F1ap_ServedGUMMEIsItem *) - f1SetupResponse_p->servedGUMMEIs.list.array[i]; - new_gummei_p = calloc(1, sizeof(struct served_gummei_s)); - - STAILQ_INIT(&new_gummei_p->served_plmns); - STAILQ_INIT(&new_gummei_p->served_group_ids); - STAILQ_INIT(&new_gummei_p->mme_codes); - - F1AP_DEBUG("servedPLMNs.list.count %d\n",gummei_item_p->servedPLMNs.list.count); - for (j = 0; j < gummei_item_p->servedPLMNs.list.count; j++) { - F1ap_PLMNidentity_t *plmn_identity_p; - struct plmn_identity_s *new_plmn_identity_p; - - plmn_identity_p = gummei_item_p->servedPLMNs.list.array[j]; - new_plmn_identity_p = calloc(1, sizeof(struct plmn_identity_s)); - TBCD_TO_MCC_MNC(plmn_identity_p, new_plmn_identity_p->mcc, - new_plmn_identity_p->mnc, new_plmn_identity_p->mnc_digit_length); - STAILQ_INSERT_TAIL(&new_gummei_p->served_plmns, new_plmn_identity_p, next); - new_gummei_p->nb_served_plmns++; - } - - for (j = 0; j < gummei_item_p->servedGroupIDs.list.count; j++) { - F1ap_MME_Group_ID_t *mme_group_id_p; - struct served_group_id_s *new_group_id_p; - - mme_group_id_p = gummei_item_p->servedGroupIDs.list.array[j]; - new_group_id_p = calloc(1, sizeof(struct served_group_id_s)); - OCTET_STRING_TO_INT16(mme_group_id_p, new_group_id_p->mme_group_id); - STAILQ_INSERT_TAIL(&new_gummei_p->served_group_ids, new_group_id_p, next); - new_gummei_p->nb_group_id++; - } - - for (j = 0; j < gummei_item_p->servedMMECs.list.count; j++) { - F1ap_MME_Code_t *mme_code_p; - struct mme_code_s *new_mme_code_p; - - mme_code_p = gummei_item_p->servedMMECs.list.array[j]; - new_mme_code_p = calloc(1, sizeof(struct mme_code_s)); - - OCTET_STRING_TO_INT8(mme_code_p, new_mme_code_p->mme_code); - STAILQ_INSERT_TAIL(&new_gummei_p->mme_codes, new_mme_code_p, next); - new_gummei_p->nb_mme_code++; - } - - STAILQ_INSERT_TAIL(&mme_desc_p->served_gummei, new_gummei_p, next); - } - - /* Free contents of the list */ - ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1ap_ServedGUMMEIs, - (void *)&f1SetupResponse_p->servedGUMMEIs); - /* Set the capacity of this MME */ - mme_desc_p->relative_mme_capacity = f1SetupResponse_p->relativeMMECapacity; - - /* Optionaly set the mme name */ - if (f1SetupResponse_p->presenceMask & F1AP_F1SETUPRESPONSEIES_MMENAME_PRESENT) { - mme_desc_p->mme_name = calloc(f1SetupResponse_p->mmEname.size + 1, sizeof(char)); - memcpy(mme_desc_p->mme_name, f1SetupResponse_p->mmEname.buf, - f1SetupResponse_p->mmEname.size); - /* Convert the mme name to a printable string */ - mme_desc_p->mme_name[f1SetupResponse_p->mmEname.size] = '\0'; - } - - /* The association is now ready as eNB and MME know parameters of each other. - * Mark the association as UP to enable UE contexts creation. - */ - mme_desc_p->state = F1AP_ENB_STATE_CONNECTED; - mme_desc_p->f1ap_instance->f1ap_mme_associated_nb ++; - f1ap_handle_f1_setup_message(mme_desc_p, 0); - -#if 0 - /* We call back our self - * -> generate a dummy initial UE message - */ - { - f1ap_nas_first_req_t f1ap_nas_first_req; - - memset(&f1ap_nas_first_req, 0, sizeof(f1ap_nas_first_req_t)); - - f1ap_nas_first_req.rnti = 0xC03A; - f1ap_nas_first_req.establishment_cause = RRC_CAUSE_MO_DATA; - f1ap_nas_first_req.ue_identity.presenceMask = UE_IDENTITIES_gummei; - - f1ap_nas_first_req.ue_identity.gummei.mcc = 208; - f1ap_nas_first_req.ue_identity.gummei.mnc = 34; - f1ap_nas_first_req.ue_identity.gummei.mme_code = 0; - f1ap_nas_first_req.ue_identity.gummei.mme_group_id = 0; - - /* NAS Attach request with IMSI */ - static uint8_t nas_attach_req_imsi[] = { - 0x07, 0x41, - /* EPS Mobile identity = IMSI */ - 0x71, 0x08, 0x29, 0x80, 0x43, 0x21, 0x43, 0x65, 0x87, - 0xF9, - /* End of EPS Mobile Identity */ - 0x02, 0xE0, 0xE0, 0x00, 0x20, 0x02, 0x03, - 0xD0, 0x11, 0x27, 0x1A, 0x80, 0x80, 0x21, 0x10, 0x01, 0x00, 0x00, - 0x10, 0x81, 0x06, 0x00, 0x00, 0x00, 0x00, 0x83, 0x06, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x0A, 0x00, 0x52, 0x12, 0xF2, - 0x01, 0x27, 0x11, - }; - - /* NAS Attach request with GUTI */ - static uint8_t nas_attach_req_guti[] = { - 0x07, 0x41, - /* EPS Mobile identity = IMSI */ - 0x71, 0x0B, 0xF6, 0x12, 0xF2, 0x01, 0x80, 0x00, 0x01, 0xE0, 0x00, - 0xDA, 0x1F, - /* End of EPS Mobile Identity */ - 0x02, 0xE0, 0xE0, 0x00, 0x20, 0x02, 0x03, - 0xD0, 0x11, 0x27, 0x1A, 0x80, 0x80, 0x21, 0x10, 0x01, 0x00, 0x00, - 0x10, 0x81, 0x06, 0x00, 0x00, 0x00, 0x00, 0x83, 0x06, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x0A, 0x00, 0x52, 0x12, 0xF2, - 0x01, 0x27, 0x11, - }; - - f1ap_nas_first_req.nas_pdu.buffer = nas_attach_req_guti; - f1ap_nas_first_req.nas_pdu.length = sizeof(nas_attach_req_guti); - - f1ap_handle_nas_first_req(mme_desc_p->f1ap_instance->instance, - &f1ap_nas_first_req); - } -#endif - - return 0; -} - - -static -int f1ap_handle_error_indication(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *message_p) -{ - F1ap_ErrorIndicationIEs_t *f1_error_indication_p; - f1ap_mme_data_t *mme_desc_p; - - DevAssert(message_p != NULL); - - f1_error_indication_p = &message_p->msg.f1ap_ErrorIndicationIEs; - - /* F1 Setup Failure == Non UE-related procedure -> stream 0 */ - if (stream != 0) { - F1AP_WARN("[SCTP %d] Received f1 Error indication on stream != 0 (%d)\n", - assoc_id, stream); - } - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received F1 Error indication for non existing " - "MME context\n", assoc_id); - return -1; - } - if ( f1_error_indication_p->presenceMask & F1AP_ERRORINDICATIONIES_MME_UE_F1AP_ID_PRESENT) { - F1AP_WARN("Received F1 Error indication MME UE F1AP ID 0x%lx\n", f1_error_indication_p->mme_ue_f1ap_id); - } - if ( f1_error_indication_p->presenceMask & F1AP_ERRORINDICATIONIES_ENB_UE_F1AP_ID_PRESENT) { - F1AP_WARN("Received F1 Error indication eNB UE F1AP ID 0x%lx\n", f1_error_indication_p->eNB_UE_F1AP_ID); - } - - if ( f1_error_indication_p->presenceMask & F1AP_ERRORINDICATIONIES_CAUSE_PRESENT) { - switch(f1_error_indication_p->cause.present) { - case F1ap_Cause_PR_NOTHING: - F1AP_WARN("Received F1 Error indication cause NOTHING\n"); - break; - case F1ap_Cause_PR_radioNetwork: - switch (f1_error_indication_p->cause.choice.radioNetwork) { - case F1ap_CauseRadioNetwork_unspecified: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unspecified\n"); - break; - case F1ap_CauseRadioNetwork_tx2relocoverall_expiry: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_tx2relocoverall_expiry\n"); - break; - case F1ap_CauseRadioNetwork_successful_handover: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_successful_handover\n"); - break; - case F1ap_CauseRadioNetwork_release_due_to_eutran_generated_reason: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_release_due_to_eutran_generated_reason\n"); - break; - case F1ap_CauseRadioNetwork_handover_cancelled: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_handover_cancelled\n"); - break; - case F1ap_CauseRadioNetwork_partial_handover: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_partial_handover\n"); - break; - case F1ap_CauseRadioNetwork_ho_failure_in_target_EPC_eNB_or_target_system: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_ho_failure_in_target_EPC_eNB_or_target_system\n"); - break; - case F1ap_CauseRadioNetwork_ho_target_not_allowed: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_ho_target_not_allowed\n"); - break; - case F1ap_CauseRadioNetwork_tF1relocoverall_expiry: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_tF1relocoverall_expiry\n"); - break; - case F1ap_CauseRadioNetwork_tF1relocprep_expiry: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_tF1relocprep_expiry\n"); - break; - case F1ap_CauseRadioNetwork_cell_not_available: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_cell_not_available\n"); - break; - case F1ap_CauseRadioNetwork_unknown_targetID: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unknown_targetID\n"); - break; - case F1ap_CauseRadioNetwork_no_radio_resources_available_in_target_cell: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_no_radio_resources_available_in_target_cell\n"); - break; - case F1ap_CauseRadioNetwork_unknown_mme_ue_f1ap_id: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unknown_mme_ue_f1ap_id\n"); - break; - case F1ap_CauseRadioNetwork_unknown_enb_ue_f1ap_id: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unknown_enb_ue_f1ap_id\n"); - break; - case F1ap_CauseRadioNetwork_unknown_pair_ue_f1ap_id: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unknown_pair_ue_f1ap_id\n"); - break; - case F1ap_CauseRadioNetwork_handover_desirable_for_radio_reason: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_handover_desirable_for_radio_reason\n"); - break; - case F1ap_CauseRadioNetwork_time_critical_handover: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_time_critical_handover\n"); - break; - case F1ap_CauseRadioNetwork_resource_optimisation_handover: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_resource_optimisation_handover\n"); - break; - case F1ap_CauseRadioNetwork_reduce_load_in_serving_cell: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_reduce_load_in_serving_cell\n"); - break; - case F1ap_CauseRadioNetwork_user_inactivity: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_user_inactivity\n"); - break; - case F1ap_CauseRadioNetwork_radio_connection_with_ue_lost: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_radio_connection_with_ue_lost\n"); - break; - case F1ap_CauseRadioNetwork_load_balancing_tau_required: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_load_balancing_tau_required\n"); - break; - case F1ap_CauseRadioNetwork_cs_fallback_triggered: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_cs_fallback_triggered\n"); - break; - case F1ap_CauseRadioNetwork_ue_not_available_for_ps_service: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_ue_not_available_for_ps_service\n"); - break; - case F1ap_CauseRadioNetwork_radio_resources_not_available: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_radio_resources_not_available\n"); - break; - case F1ap_CauseRadioNetwork_failure_in_radio_interface_procedure: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_failure_in_radio_interface_procedure\n"); - break; - case F1ap_CauseRadioNetwork_invalf1ap_id_qos_combination: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_invalf1ap_id_qos_combination\n"); - break; - case F1ap_CauseRadioNetwork_interrat_redirection: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_interrat_redirection\n"); - break; - case F1ap_CauseRadioNetwork_interaction_with_other_procedure: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_interaction_with_other_procedure\n"); - break; - case F1ap_CauseRadioNetwork_unknown_E_RAB_ID: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_unknown_E_RAB_ID\n"); - break; - case F1ap_CauseRadioNetwork_multiple_E_RAB_ID_instances: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_multiple_E_RAB_ID_instances\n"); - break; - case F1ap_CauseRadioNetwork_encryption_and_or_integrity_protection_algorithms_not_supported: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_encryption_and_or_integrity_protection_algorithms_not_supported\n"); - break; - case F1ap_CauseRadioNetwork_f1_intra_system_handover_triggered: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_f1_intra_system_handover_triggered\n"); - break; - case F1ap_CauseRadioNetwork_f1_inter_system_handover_triggered: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_f1_inter_system_handover_triggered\n"); - break; - case F1ap_CauseRadioNetwork_x2_handover_triggered: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_x2_handover_triggered\n"); - break; - case F1ap_CauseRadioNetwork_redirection_towards_1xRTT: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_redirection_towards_1xRTT\n"); - break; - case F1ap_CauseRadioNetwork_not_supported_QCI_value: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_not_supported_QCI_value\n"); - break; - case F1ap_CauseRadioNetwork_invalf1ap_id_CSG_Id: - F1AP_WARN("Received F1 Error indication F1ap_CauseRadioNetwork_invalf1ap_id_CSG_Id\n"); - break; - default: - F1AP_WARN("Received F1 Error indication cause radio network case not handled\n"); - } - break; - - case F1ap_Cause_PR_transport: - switch (f1_error_indication_p->cause.choice.transport) { - case F1ap_CauseTransport_transport_resource_unavailable: - F1AP_WARN("Received F1 Error indication F1ap_CauseTransport_transport_resource_unavailable\n"); - break; - case F1ap_CauseTransport_unspecified: - F1AP_WARN("Received F1 Error indication F1ap_CauseTransport_unspecified\n"); - break; - default: - F1AP_WARN("Received F1 Error indication cause transport case not handled\n"); - } - break; - - case F1ap_Cause_PR_nas: - switch (f1_error_indication_p->cause.choice.nas) { - case F1ap_CauseNas_normal_release: - F1AP_WARN("Received F1 Error indication F1ap_CauseNas_normal_release\n"); - break; - case F1ap_CauseNas_authentication_failure: - F1AP_WARN("Received F1 Error indication F1ap_CauseNas_authentication_failure\n"); - break; - case F1ap_CauseNas_detach: - F1AP_WARN("Received F1 Error indication F1ap_CauseNas_detach\n"); - break; - case F1ap_CauseNas_unspecified: - F1AP_WARN("Received F1 Error indication F1ap_CauseNas_unspecified\n"); - break; - case F1ap_CauseNas_csg_subscription_expiry: - F1AP_WARN("Received F1 Error indication F1ap_CauseNas_csg_subscription_expiry\n"); - break; - default: - F1AP_WARN("Received F1 Error indication cause nas case not handled\n"); - } - break; - - case F1ap_Cause_PR_protocol: - switch (f1_error_indication_p->cause.choice.protocol) { - case F1ap_CauseProtocol_transfer_syntax_error: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_transfer_syntax_error\n"); - break; - case F1ap_CauseProtocol_abstract_syntax_error_reject: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_abstract_syntax_error_reject\n"); - break; - case F1ap_CauseProtocol_abstract_syntax_error_ignore_and_notify: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_abstract_syntax_error_ignore_and_notify\n"); - break; - case F1ap_CauseProtocol_message_not_compatible_with_receiver_state: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_message_not_compatible_with_receiver_state\n"); - break; - case F1ap_CauseProtocol_semantic_error: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_semantic_error\n"); - break; - case F1ap_CauseProtocol_abstract_syntax_error_falsely_constructed_message: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_abstract_syntax_error_falsely_constructed_message\n"); - break; - case F1ap_CauseProtocol_unspecified: - F1AP_WARN("Received F1 Error indication F1ap_CauseProtocol_unspecified\n"); - break; - default: - F1AP_WARN("Received F1 Error indication cause protocol case not handled\n"); - } - break; - - case F1ap_Cause_PR_misc: - switch (f1_error_indication_p->cause.choice.protocol) { - case F1ap_CauseMisc_control_processing_overload: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_control_processing_overload\n"); - break; - case F1ap_CauseMisc_not_enough_user_plane_processing_resources: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_not_enough_user_plane_processing_resources\n"); - break; - case F1ap_CauseMisc_hardware_failure: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_hardware_failure\n"); - break; - case F1ap_CauseMisc_om_intervention: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_om_intervention\n"); - break; - case F1ap_CauseMisc_unspecified: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_unspecified\n"); - break; - case F1ap_CauseMisc_unknown_PLMN: - F1AP_WARN("Received F1 Error indication F1ap_CauseMisc_unknown_PLMN\n"); - break; - default: - F1AP_WARN("Received F1 Error indication cause misc case not handled\n"); - } - break; - } - } - if ( f1_error_indication_p->presenceMask & F1AP_ERRORINDICATIONIES_CRITICALITYDIAGNOSTICS_PRESENT) { - // TODO continue - } - // TODO continue - - return 0; -} - - -static -int f1ap_handle_initial_context_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) -{ - int i; - - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_ue_context_t *ue_desc_p = NULL; - MessageDef *message_p = NULL; - - F1ap_InitialContextSetupRequestIEs_t *initialContextSetupRequest_p; - DevAssert(f1ap_message_p != NULL); - - initialContextSetupRequest_p = &f1ap_message_p->msg.f1ap_InitialContextSetupRequestIEs; - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing MME context\n", assoc_id); - return -1; - } - - if ((ue_desc_p = f1ap_get_ue_context(mme_desc_p->f1ap_instance, - initialContextSetupRequest_p->eNB_UE_F1AP_ID)) == NULL) { - F1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing UE context 0x%06lx\n", assoc_id, - initialContextSetupRequest_p->eNB_UE_F1AP_ID); - return -1; - } - - /* Initial context request = UE-related procedure -> stream != 0 */ - if (stream == 0) { - F1AP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n", - assoc_id, stream); - return -1; - } - - ue_desc_p->rx_stream = stream; - - ue_desc_p->mme_ue_f1ap_id = initialContextSetupRequest_p->mme_ue_f1ap_id; - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_INITIAL_CONTEXT_SETUP_REQ); - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_initial_id = ue_desc_p->ue_initial_id; - ue_desc_p->ue_initial_id = 0; - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).eNB_ue_f1ap_id = ue_desc_p->eNB_ue_f1ap_id; - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).nb_of_e_rabs = - initialContextSetupRequest_p->e_RABToBeSetupListCtxtSUReq.f1ap_E_RABToBeSetupItemCtxtSUReq.count; - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_ambr.br_ul = 64;// TO DO(bitrate_t)(initialContextSetupRequest_p->uEaggregateMaximumBitrate.uEaggregateMaximumBitRateUL); - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).ue_ambr.br_dl = 1024;//(bitrate_t)(initialContextSetupRequest_p->uEaggregateMaximumBitrate.uEaggregateMaximumBitRateDL); - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).security_capabilities.encryption_algorithms = - BIT_STRING_to_uint16(&initialContextSetupRequest_p->ueSecurityCapabilities.encryptionAlgorithms); - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).security_capabilities.integrity_algorithms = - BIT_STRING_to_uint16(&initialContextSetupRequest_p->ueSecurityCapabilities.integrityProtectionAlgorithms); - - /* Copy the security key */ - memcpy(&F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).security_key, - initialContextSetupRequest_p->securityKey.buf, initialContextSetupRequest_p->securityKey.size); - - for (i = 0; i < initialContextSetupRequest_p->e_RABToBeSetupListCtxtSUReq.f1ap_E_RABToBeSetupItemCtxtSUReq.count; i++) { - F1ap_E_RABToBeSetupItemCtxtSUReq_t *item_p; - - item_p = (F1ap_E_RABToBeSetupItemCtxtSUReq_t *)initialContextSetupRequest_p->e_RABToBeSetupListCtxtSUReq.f1ap_E_RABToBeSetupItemCtxtSUReq.array[i]; - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].e_rab_id = item_p->e_RAB_ID; - - if (item_p->nAS_PDU != NULL) { - /* Only copy NAS pdu if present */ - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.length = item_p->nAS_PDU->size; - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer = - malloc(sizeof(uint8_t) * item_p->nAS_PDU->size); - - memcpy(F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer, - item_p->nAS_PDU->buf, item_p->nAS_PDU->size); - F1AP_DEBUG("Received NAS message with the E_RAB setup procedure\n"); - } else { - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.length = 0; - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].nas_pdu.buffer = NULL; - } - - /* Set the transport layer address */ - memcpy(F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].sgw_addr.buffer, - item_p->transportLayerAddress.buf, item_p->transportLayerAddress.size); - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].sgw_addr.length = - item_p->transportLayerAddress.size * 8 - item_p->transportLayerAddress.bits_unused; - - /* GTP tunnel endpoint ID */ - OCTET_STRING_TO_INT32(&item_p->gTP_TEID, F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].gtp_teid); - - /* Set the QOS informations */ - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.qci = item_p->e_RABlevelQoSParameters.qCI; - - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.allocation_retention_priority.priority_level = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.priorityLevel; - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.allocation_retention_priority.pre_emp_capability = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionCapability; - F1AP_INITIAL_CONTEXT_SETUP_REQ(message_p).e_rab_param[i].qos.allocation_retention_priority.pre_emp_vulnerability = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionVulnerability; - } - - itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p); - - return 0; -} - - -static -int f1ap_handle_ue_context_release_command(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) -{ - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_ue_context_t *ue_desc_p = NULL; - MessageDef *message_p = NULL; - - F1ap_UEContextReleaseCommandIEs_t *ueContextReleaseCommand_p; - DevAssert(f1ap_message_p != NULL); - - ueContextReleaseCommand_p = &f1ap_message_p->msg.f1ap_UEContextReleaseCommandIEs; - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received UE context release command for non " - "existing MME context\n", assoc_id); - return -1; - } - - F1ap_MME_UE_F1AP_ID_t mme_ue_f1ap_id; - F1ap_ENB_UE_F1AP_ID_t enb_ue_f1ap_id; - - switch (ueContextReleaseCommand_p->uE_F1AP_IDs.present) { - case F1ap_UE_F1AP_IDs_PR_uE_F1AP_ID_pair: - enb_ue_f1ap_id = ueContextReleaseCommand_p->uE_F1AP_IDs.choice.uE_F1AP_ID_pair.eNB_UE_F1AP_ID; - mme_ue_f1ap_id = ueContextReleaseCommand_p->uE_F1AP_IDs.choice.uE_F1AP_ID_pair.mME_UE_F1AP_ID; - - MSC_LOG_RX_MESSAGE( - MSC_F1AP_ENB, - MSC_F1AP_MME, - NULL,0, - "0 UEContextRelease/%s eNB_ue_f1ap_id "F1AP_UE_ID_FMT" mme_ue_f1ap_id "F1AP_UE_ID_FMT" len %u", - f1ap_direction2String[f1ap_message_p->direction], - enb_ue_f1ap_id, - mme_ue_f1ap_id); - - if ((ue_desc_p = f1ap_get_ue_context(mme_desc_p->f1ap_instance, - enb_ue_f1ap_id)) == NULL) { - F1AP_ERROR("[SCTP %d] Received UE context release command for non " - "existing UE context 0x%06lx\n", - assoc_id, - enb_ue_f1ap_id); - /*MessageDef *msg_complete_p; - msg_complete_p = itti_alloc_new_message(TASK_RRC_ENB, F1AP_UE_CONTEXT_RELEASE_COMPLETE); - F1AP_UE_CONTEXT_RELEASE_COMPLETE(msg_complete_p).eNB_ue_f1ap_id = enb_ue_f1ap_id; - itti_send_msg_to_task(TASK_F1AP, ue_desc_p->eNB_instance->instance <=> 0, msg_complete_p); - */ - return -1; - } else { - MSC_LOG_TX_MESSAGE( - MSC_F1AP_ENB, - MSC_RRC_ENB, - NULL,0, - "0 F1AP_UE_CONTEXT_RELEASE_COMMAND/%d eNB_ue_f1ap_id "F1AP_UE_ID_FMT" ", - enb_ue_f1ap_id); - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_UE_CONTEXT_RELEASE_COMMAND); - F1AP_UE_CONTEXT_RELEASE_COMMAND(message_p).eNB_ue_f1ap_id = enb_ue_f1ap_id; - itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p); - return 0; - } - - break; - -//#warning "TODO mapping mme_ue_f1ap_id enb_ue_f1ap_id?" - - case F1ap_UE_F1AP_IDs_PR_mME_UE_F1AP_ID: - mme_ue_f1ap_id = ueContextReleaseCommand_p->uE_F1AP_IDs.choice.mME_UE_F1AP_ID; - F1AP_ERROR("TO DO mapping mme_ue_f1ap_id enb_ue_f1ap_id"); - (void)mme_ue_f1ap_id; /* TODO: remove - it's to remove gcc warning about unused var */ - - case F1ap_UE_F1AP_IDs_PR_NOTHING: - default: - F1AP_ERROR("F1AP_UE_CONTEXT_RELEASE_COMMAND not processed, missing info elements"); - return -1; - } -} - -static -int f1ap_handle_e_rab_setup_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) { - - int i; - - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_ue_context_t *ue_desc_p = NULL; - MessageDef *message_p = NULL; - - F1ap_E_RABSetupRequestIEs_t *f1ap_E_RABSetupRequest; - DevAssert(f1ap_message_p != NULL); - - f1ap_E_RABSetupRequest = &f1ap_message_p->msg.f1ap_E_RABSetupRequestIEs; - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing MME context\n", assoc_id); - return -1; - } - - - if ((ue_desc_p = f1ap_get_ue_context(mme_desc_p->f1ap_instance, - f1ap_E_RABSetupRequest->eNB_UE_F1AP_ID)) == NULL) { - F1AP_ERROR("[SCTP %d] Received initial context setup request for non " - "existing UE context 0x%06lx\n", assoc_id, - f1ap_E_RABSetupRequest->eNB_UE_F1AP_ID); - return -1; - } - - /* Initial context request = UE-related procedure -> stream != 0 */ - if (stream == 0) { - F1AP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n", - assoc_id, stream); - return -1; - } - - ue_desc_p->rx_stream = stream; - - if ( ue_desc_p->mme_ue_f1ap_id != f1ap_E_RABSetupRequest->mme_ue_f1ap_id){ - F1AP_WARN("UE context mme_ue_f1ap_id is different form that of the message (%d != %ld)", - ue_desc_p->mme_ue_f1ap_id, f1ap_E_RABSetupRequest->mme_ue_f1ap_id); - - } - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_E_RAB_SETUP_REQ); - - F1AP_E_RAB_SETUP_REQ(message_p).ue_initial_id = ue_desc_p->ue_initial_id; - - F1AP_E_RAB_SETUP_REQ(message_p).mme_ue_f1ap_id = f1ap_E_RABSetupRequest->mme_ue_f1ap_id; - F1AP_E_RAB_SETUP_REQ(message_p).eNB_ue_f1ap_id = f1ap_E_RABSetupRequest->eNB_UE_F1AP_ID; - - F1AP_E_RAB_SETUP_REQ(message_p).nb_e_rabs_tosetup = - f1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.f1ap_E_RABToBeSetupItemBearerSUReq.count; - - for (i = 0; i < f1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.f1ap_E_RABToBeSetupItemBearerSUReq.count; i++) { - F1ap_E_RABToBeSetupItemBearerSUReq_t *item_p; - - item_p = (F1ap_E_RABToBeSetupItemBearerSUReq_t *)f1ap_E_RABSetupRequest->e_RABToBeSetupListBearerSUReq.f1ap_E_RABToBeSetupItemBearerSUReq.array[i]; - - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].e_rab_id = item_p->e_RAB_ID; - - // check for the NAS PDU - if (item_p->nAS_PDU.size > 0 ) { - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length = item_p->nAS_PDU.size; - - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer = malloc(sizeof(uint8_t) * item_p->nAS_PDU.size); - - memcpy(F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer, - item_p->nAS_PDU.buf, item_p->nAS_PDU.size); - // F1AP_INFO("received a NAS PDU with size %d (%02x.%02x)\n",F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length, item_p->nAS_PDU.buf[0], item_p->nAS_PDU.buf[1]); - } else { - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.length = 0; - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].nas_pdu.buffer = NULL; - - F1AP_WARN("NAS PDU is not provided, generate a E_RAB_SETUP Failure (TBD) back to MME \n"); - // return -1; - } - - /* Set the transport layer address */ - memcpy(F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.buffer, - item_p->transportLayerAddress.buf, item_p->transportLayerAddress.size); - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.length = - item_p->transportLayerAddress.size * 8 - item_p->transportLayerAddress.bits_unused; - - /* F1AP_INFO("sgw addr %s len: %d (size %d, index %d)\n", - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.buffer, - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].sgw_addr.length, - item_p->transportLayerAddress.size, i); - */ - /* GTP tunnel endpoint ID */ - OCTET_STRING_TO_INT32(&item_p->gTP_TEID, F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].gtp_teid); - - /* Set the QOS informations */ - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.qci = item_p->e_RABlevelQoSParameters.qCI; - - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.priority_level = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.priorityLevel; - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.pre_emp_capability = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionCapability; - F1AP_E_RAB_SETUP_REQ(message_p).e_rab_setup_params[i].qos.allocation_retention_priority.pre_emp_vulnerability = - item_p->e_RABlevelQoSParameters.allocationRetentionPriority.pre_emptionVulnerability; - } - - itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p); - - return 0; + ret = (*messages_callback[pdu.choice.initiatingMessage->procedureCode][pdu.present - 1]) + (assoc_id, stream, &pdu); + ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1AP_F1AP_PDU, &pdu); + return ret; } static -int f1ap_handle_paging(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) +int f1ap_handle_f1_setup_request(uint32_t assoc_id, + uint32_t stream, + F1AP_F1AP_PDU_t *pdu) { - F1ap_PagingIEs_t *paging_p; - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_instance_t *f1ap_instance = NULL; - MessageDef *message_p = NULL; - - DevAssert(f1ap_message_p != NULL); - // received Paging Message from MME - F1AP_DEBUG("[SCTP %d] Received Paging Message From MME\n",assoc_id); - - paging_p = &f1ap_message_p->msg.f1ap_PagingIEs; + printf("OOOOOOOOOOOOOOOOOOOOOOOOOOO\n"); - /* Paging procedure -> stream != 0 */ - if (stream == 0) { - F1AP_ERROR("[SCTP %d] Received Paging procedure on stream (%d)\n", - assoc_id, stream); - return -1; - } - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received Paging for non " - "existing MME context\n", assoc_id); - return -1; - } - - f1ap_instance = mme_desc_p->f1ap_instance; - if (f1ap_instance == NULL) { - F1AP_ERROR("[SCTP %d] Received Paging for non existing MME context : f1ap_instance is NULL\n", - assoc_id); - return -1; - } - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_PAGING_IND); - - /* convert F1ap_PagingIEs_t to f1ap_paging_ind_t */ - /* convert UE Identity Index value */ - F1AP_PAGING_IND(message_p).ue_index_value = BIT_STRING_to_uint32(&paging_p->ueIdentityIndexValue); - F1AP_DEBUG("[SCTP %d] Received Paging ue_index_value (%d)\n", - assoc_id,(uint32_t)F1AP_PAGING_IND(message_p).ue_index_value); - - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.mme_code = 0; - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.m_tmsi = 0; - - /* convert UE Paging Identity */ - if (paging_p->uePagingID.present == F1ap_UEPagingID_PR_s_TMSI) { - F1AP_PAGING_IND(message_p).ue_paging_identity.presenceMask = UE_PAGING_IDENTITY_s_tmsi; - OCTET_STRING_TO_INT8(&paging_p->uePagingID.choice.s_TMSI.mMEC, F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.mme_code); - OCTET_STRING_TO_INT32(&paging_p->uePagingID.choice.s_TMSI.m_TMSI, F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.m_tmsi); - } else if (paging_p->uePagingID.present == F1ap_UEPagingID_PR_iMSI) { - F1AP_PAGING_IND(message_p).ue_paging_identity.presenceMask = UE_PAGING_IDENTITY_imsi; - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length = 0; - for (int i = 0; i < paging_p->uePagingID.choice.iMSI.size; i++) { - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2*i] = (uint8_t)(paging_p->uePagingID.choice.iMSI.buf[i] & 0x0F ); - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length++; - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2*i+1] = (uint8_t)((paging_p->uePagingID.choice.iMSI.buf[i]>>4) & 0x0F); - LOG_D(F1AP,"paging : i %d %d imsi %d %d \n",2*i,2*i+1,F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2*i], F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2*i+1]); - if (F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2*i+1] == 0x0F) { - if(i != paging_p->uePagingID.choice.iMSI.size - 1){ - /* invalid paging_p->uePagingID.choise.iMSI.buffer */ - F1AP_ERROR("[SCTP %d] Received Paging : uePagingID.choise.iMSI error(i %d 0x0F)\n", assoc_id,i); - return -1; - } - } else { - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length++; - } - } - if (F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length >= F1AP_IMSI_LENGTH) { - /* invalid paging_p->uePagingID.choise.iMSI.size */ - F1AP_ERROR("[SCTP %d] Received Paging : uePagingID.choise.iMSI.size(%d) is over IMSI length(%d)\n", assoc_id, F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length, F1AP_IMSI_LENGTH); - return -1; - } -} else { - /* invalid paging_p->uePagingID.present */ - F1AP_ERROR("[SCTP %d] Received Paging : uePagingID.present(%d) is unknown\n", assoc_id, paging_p->uePagingID.present); - return -1; - } - -#if 0 - /* convert Paging DRX(optional) */ - if (paging_p->presenceMask & F1AP_PAGINGIES_PAGINGDRX_PRESENT) { - switch(paging_p->pagingDRX) { - case F1ap_PagingDRX_v32: - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_32; - break; - case F1ap_PagingDRX_v64: - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_64; - break; - case F1ap_PagingDRX_v128: - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_128; - break; - case F1ap_PagingDRX_v256: - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_256; - break; - default: - // when UE Paging DRX is no value - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_256; - break; - } - } -#endif - F1AP_PAGING_IND(message_p).paging_drx = PAGING_DRX_256; - - /* convert cnDomain */ - if (paging_p->cnDomain == F1ap_CNDomain_ps) { - F1AP_PAGING_IND(message_p).cn_domain = CN_DOMAIN_PS; - } else if (paging_p->cnDomain == F1ap_CNDomain_cs) { - F1AP_PAGING_IND(message_p).cn_domain = CN_DOMAIN_CS; - } else { - /* invalid paging_p->cnDomain */ - F1AP_ERROR("[SCTP %d] Received Paging : cnDomain(%ld) is unknown\n", assoc_id, paging_p->cnDomain); - return -1; - } - - memset (&F1AP_PAGING_IND(message_p).plmn_identity[0], 0, sizeof(plmn_identity_t)*256); - memset (&F1AP_PAGING_IND(message_p).tac[0], 0, sizeof(int16_t)*256); - F1AP_PAGING_IND(message_p).tai_size = 0; - - for (int i = 0; i < paging_p->taiList.f1ap_TAIItem.count; i++) { - F1AP_INFO("[SCTP %d] Received Paging taiList: i %d, count %d\n", assoc_id, i, paging_p->taiList.f1ap_TAIItem.count); - F1ap_TAIItem_t f1ap_TAIItem; - memset (&f1ap_TAIItem, 0, sizeof(F1ap_TAIItem_t)); - - memcpy(&f1ap_TAIItem, paging_p->taiList.f1ap_TAIItem.array[i], sizeof(F1ap_TAIItem_t)); - - TBCD_TO_MCC_MNC(&f1ap_TAIItem.tAI.pLMNidentity, F1AP_PAGING_IND(message_p).plmn_identity[i].mcc, - F1AP_PAGING_IND(message_p).plmn_identity[i].mnc, - F1AP_PAGING_IND(message_p).plmn_identity[i].mnc_digit_length); - OCTET_STRING_TO_INT16(&f1ap_TAIItem.tAI.tAC, F1AP_PAGING_IND(message_p).tac[i]); - F1AP_PAGING_IND(message_p).tai_size++; - F1AP_DEBUG("[SCTP %d] Received Paging: MCC %d, MNC %d, TAC %d\n", assoc_id, F1AP_PAGING_IND(message_p).plmn_identity[i].mcc, F1AP_PAGING_IND(message_p).plmn_identity[i].mnc, F1AP_PAGING_IND(message_p).tac[i]); - } - -#if 0 - // CSG Id(optional) List is not used - if (paging_p->presenceMask & F1AP_PAGINGIES_CSG_IDLIST_PRESENT) { - // TODO - } - - /* convert pagingPriority (optional) if has value */ - if (paging_p->presenceMask & F1AP_PAGINGIES_PAGINGPRIORITY_PRESENT) { - switch(paging_p->pagingPriority) { - case F1ap_PagingPriority_priolevel1: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL1; - break; - case F1ap_PagingPriority_priolevel2: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL2; - break; - case F1ap_PagingPriority_priolevel3: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL3; - break; - case F1ap_PagingPriority_priolevel4: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL4; - break; - case F1ap_PagingPriority_priolevel5: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL5; - break; - case F1ap_PagingPriority_priolevel6: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL6; - break; - case F1ap_PagingPriority_priolevel7: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL7; - break; - case F1ap_PagingPriority_priolevel8: - F1AP_PAGING_IND(message_p).paging_priority = PAGING_PRIO_LEVEL8; - break; - default: - /* invalid paging_p->pagingPriority */ - F1AP_ERROR("[SCTP %d] Received paging : pagingPriority(%ld) is invalid\n", assoc_id, paging_p->pagingPriority); - return -1; - } - } -#endif - //paging parameter values - F1AP_DEBUG("[SCTP %d] Received Paging parameters: ue_index_value %d cn_domain %d paging_drx %d paging_priority %d\n",assoc_id, - F1AP_PAGING_IND(message_p).ue_index_value, F1AP_PAGING_IND(message_p).cn_domain, - F1AP_PAGING_IND(message_p).paging_drx, F1AP_PAGING_IND(message_p).paging_priority); - F1AP_DEBUG("[SCTP %d] Received Paging parameters(ue): presenceMask %d s_tmsi.m_tmsi %d s_tmsi.mme_code %d IMSI length %d (0-5) %d%d%d%d%d%d\n",assoc_id, - F1AP_PAGING_IND(message_p).ue_paging_identity.presenceMask, F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.m_tmsi, - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.s_tmsi.mme_code, F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.length, - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[0], F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[1], - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[2], F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[3], - F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[4], F1AP_PAGING_IND(message_p).ue_paging_identity.choice.imsi.buffer[5]); - - /* send message to RRC */ - itti_send_msg_to_task(TASK_RRC_ENB, f1ap_instance->instance, message_p); - return 0; } - -static -int f1ap_handle_e_rab_modify_request(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) { - - int i; - - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_ue_context_t *ue_desc_p = NULL; - MessageDef *message_p = NULL; - int nb_of_e_rabs_failed = 0; - - F1ap_E_RABModifyRequestIEs_t *f1ap_E_RABModifyRequest; - DevAssert(f1ap_message_p != NULL); - - f1ap_E_RABModifyRequest = &f1ap_message_p->msg.f1ap_E_RABModifyRequestIEs; - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received E-RAB modify request for non " - "existing MME context\n", assoc_id); - return -1; - } - - - if ((ue_desc_p = f1ap_get_ue_context(mme_desc_p->f1ap_instance, - f1ap_E_RABModifyRequest->eNB_UE_F1AP_ID)) == NULL) { - F1AP_ERROR("[SCTP %d] Received E-RAB modify request for non " - "existing UE context 0x%06lx\n", assoc_id, - f1ap_E_RABModifyRequest->eNB_UE_F1AP_ID); - return -1; - } - - /* E-RAB modify request = UE-related procedure -> stream != 0 */ - if (stream == 0) { - F1AP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n", - assoc_id, stream); - return -1; - } - - ue_desc_p->rx_stream = stream; - - if ( ue_desc_p->mme_ue_f1ap_id != f1ap_E_RABModifyRequest->mme_ue_f1ap_id){ - F1AP_WARN("UE context mme_ue_f1ap_id is different form that of the message (%d != %ld)", - ue_desc_p->mme_ue_f1ap_id, f1ap_E_RABModifyRequest->mme_ue_f1ap_id); - message_p = itti_alloc_new_message (TASK_RRC_ENB, F1AP_E_RAB_MODIFY_RESP); - - F1AP_E_RAB_MODIFY_RESP (message_p).eNB_ue_f1ap_id = f1ap_E_RABModifyRequest->eNB_UE_F1AP_ID; -// F1AP_E_RAB_MODIFY_RESP (msg_fail_p).e_rabs[F1AP_MAX_E_RAB]; - F1AP_E_RAB_MODIFY_RESP (message_p).nb_of_e_rabs = 0; - - for(nb_of_e_rabs_failed = 0; nb_of_e_rabs_failed < f1ap_E_RABModifyRequest->e_RABToBeModifiedListBearerModReq.f1ap_E_RABToBeModifiedItemBearerModReq.count; nb_of_e_rabs_failed++) { - F1AP_E_RAB_MODIFY_RESP (message_p).e_rabs_failed[nb_of_e_rabs_failed].e_rab_id = - ((F1ap_E_RABToBeModifiedItemBearerModReq_t *)f1ap_E_RABModifyRequest->e_RABToBeModifiedListBearerModReq.f1ap_E_RABToBeModifiedItemBearerModReq.array[nb_of_e_rabs_failed])->e_RAB_ID; - F1AP_E_RAB_MODIFY_RESP (message_p).e_rabs_failed[nb_of_e_rabs_failed].cause = F1AP_CAUSE_RADIO_NETWORK; - F1AP_E_RAB_MODIFY_RESP (message_p).e_rabs_failed[nb_of_e_rabs_failed].cause_value = 13;//F1ap_CauseRadioNetwork_unknown_mme_ue_f1ap_id; - } - F1AP_E_RAB_MODIFY_RESP (message_p).nb_of_e_rabs_failed = nb_of_e_rabs_failed; - - f1ap_e_rab_modify_resp(mme_desc_p->f1ap_instance->instance, - &F1AP_E_RAB_MODIFY_RESP(message_p)); - - message_p = NULL; - return -1; - } - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_E_RAB_MODIFY_REQ); - - F1AP_E_RAB_MODIFY_REQ(message_p).ue_initial_id = ue_desc_p->ue_initial_id; - - F1AP_E_RAB_MODIFY_REQ(message_p).mme_ue_f1ap_id = f1ap_E_RABModifyRequest->mme_ue_f1ap_id; - F1AP_E_RAB_MODIFY_REQ(message_p).eNB_ue_f1ap_id = f1ap_E_RABModifyRequest->eNB_UE_F1AP_ID; - - F1AP_E_RAB_MODIFY_REQ(message_p).nb_e_rabs_tomodify = - f1ap_E_RABModifyRequest->e_RABToBeModifiedListBearerModReq.f1ap_E_RABToBeModifiedItemBearerModReq.count; - - for (i = 0; i < f1ap_E_RABModifyRequest->e_RABToBeModifiedListBearerModReq.f1ap_E_RABToBeModifiedItemBearerModReq.count; i++) { - F1ap_E_RABToBeModifiedItemBearerModReq_t *item_p; - - item_p = (F1ap_E_RABToBeModifiedItemBearerModReq_t *)f1ap_E_RABModifyRequest->e_RABToBeModifiedListBearerModReq.f1ap_E_RABToBeModifiedItemBearerModReq.array[i]; - - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].e_rab_id = item_p->e_RAB_ID; - - // check for the NAS PDU - if (item_p->nAS_PDU.size > 0 ) { - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.length = item_p->nAS_PDU.size; - - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.buffer = malloc(sizeof(uint8_t) * item_p->nAS_PDU.size); - - memcpy(F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.buffer, - item_p->nAS_PDU.buf, item_p->nAS_PDU.size); - } else { - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.length = 0; - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].nas_pdu.buffer = NULL; - continue; - } - - /* Set the QOS informations */ - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.qci = item_p->e_RABLevelQoSParameters.qCI; - - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.allocation_retention_priority.priority_level = - item_p->e_RABLevelQoSParameters.allocationRetentionPriority.priorityLevel; - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.allocation_retention_priority.pre_emp_capability = - item_p->e_RABLevelQoSParameters.allocationRetentionPriority.pre_emptionCapability; - F1AP_E_RAB_MODIFY_REQ(message_p).e_rab_modify_params[i].qos.allocation_retention_priority.pre_emp_vulnerability = - item_p->e_RABLevelQoSParameters.allocationRetentionPriority.pre_emptionVulnerability; - - } - - itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p); - - return 0; -} -// handle e-rab release command and send it to rrc_end -static -int f1ap_handle_e_rab_release_command(uint32_t assoc_id, - uint32_t stream, - struct f1ap_message_s *f1ap_message_p) { - - int i; - - f1ap_mme_data_t *mme_desc_p = NULL; - f1ap_ue_context_t *ue_desc_p = NULL; - MessageDef *message_p = NULL; - - F1ap_E_RABReleaseCommandIEs_t *f1ap_E_RABReleaseCommand; - DevAssert(f1ap_message_p != NULL); - f1ap_E_RABReleaseCommand = &f1ap_message_p->msg.f1ap_E_RABReleaseCommandIEs; - - if ((mme_desc_p = f1ap_get_MME(NULL, assoc_id, 0)) == NULL) { - F1AP_ERROR("[SCTP %d] Received E-RAB release command for non existing MME context\n", assoc_id); - return -1; - } - if ((ue_desc_p = f1ap_get_ue_context(mme_desc_p->f1ap_instance, - f1ap_E_RABReleaseCommand->eNB_UE_F1AP_ID)) == NULL) { - F1AP_ERROR("[SCTP %d] Received E-RAB release command for non existing UE context 0x%06lx\n", assoc_id, - f1ap_E_RABReleaseCommand->eNB_UE_F1AP_ID); - return -1; - } - - /* Initial context request = UE-related procedure -> stream != 0 */ - if (stream == 0) { - F1AP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n", - assoc_id, stream); - return -1; - } - - ue_desc_p->rx_stream = stream; - - if ( ue_desc_p->mme_ue_f1ap_id != f1ap_E_RABReleaseCommand->mme_ue_f1ap_id){ - F1AP_WARN("UE context mme_ue_f1ap_id is different form that of the message (%d != %ld)", - ue_desc_p->mme_ue_f1ap_id, f1ap_E_RABReleaseCommand->mme_ue_f1ap_id); - } - - F1AP_DEBUG("[SCTP %d] Received E-RAB release command for eNB_UE_F1AP_ID %ld mme_ue_f1ap_id %ld\n", - assoc_id, f1ap_E_RABReleaseCommand->eNB_UE_F1AP_ID, f1ap_E_RABReleaseCommand->mme_ue_f1ap_id); - - message_p = itti_alloc_new_message(TASK_F1AP, F1AP_E_RAB_RELEASE_COMMAND); - - F1AP_E_RAB_RELEASE_COMMAND(message_p).eNB_ue_f1ap_id = f1ap_E_RABReleaseCommand->eNB_UE_F1AP_ID; - F1AP_E_RAB_RELEASE_COMMAND(message_p).mme_ue_f1ap_id = f1ap_E_RABReleaseCommand->mme_ue_f1ap_id; - if(f1ap_E_RABReleaseCommand->nas_pdu.size > 0 ){ - F1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.length = f1ap_E_RABReleaseCommand->nas_pdu.size; - - F1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.buffer = - malloc(sizeof(uint8_t) * f1ap_E_RABReleaseCommand->nas_pdu.size); - - memcpy(F1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.buffer, - f1ap_E_RABReleaseCommand->nas_pdu.buf, - f1ap_E_RABReleaseCommand->nas_pdu.size); - } else { - F1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.length = 0; - F1AP_E_RAB_RELEASE_COMMAND(message_p).nas_pdu.buffer = NULL; - } - - F1AP_E_RAB_RELEASE_COMMAND(message_p).nb_e_rabs_torelease = f1ap_E_RABReleaseCommand->e_RABToBeReleasedList.f1ap_E_RABItem.count; - for(i=0; i < f1ap_E_RABReleaseCommand->e_RABToBeReleasedList.f1ap_E_RABItem.count; i++){ - F1ap_E_RABItem_t *item_p; - item_p = (F1ap_E_RABItem_t*)f1ap_E_RABReleaseCommand->e_RABToBeReleasedList.f1ap_E_RABItem.array[i]; - F1AP_E_RAB_RELEASE_COMMAND(message_p).e_rab_release_params[i].e_rab_id = item_p->e_RAB_ID; - F1AP_DEBUG("[SCTP] Received E-RAB release command for e-rab id %ld\n", item_p->e_RAB_ID); - } - - itti_send_msg_to_task(TASK_RRC_ENB, ue_desc_p->eNB_instance->instance, message_p); - - return 0; -} diff --git a/openair2/F1AP/f1ap_handlers.h b/openair2/F1AP/f1ap_handlers.h index eaa2b15c31..c3a7b7b225 100644 --- a/openair2/F1AP/f1ap_handlers.h +++ b/openair2/F1AP/f1ap_handlers.h @@ -33,8 +33,6 @@ #ifndef F1AP_HANDLERS_H_ #define F1AP_HANDLERS_H_ -void f1ap_handle_f1_setup_message(f1ap_eNB_mme_data_t *mme_desc_p, int sctp_shutdown); - int f1ap_handle_message(uint32_t assoc_id, int32_t stream, const uint8_t * const data, const uint32_t data_length); diff --git a/openair2/F1AP/sctp_cu.c b/openair2/F1AP/sctp_cu.c index 546759e003..29f8e93c8c 100644 --- a/openair2/F1AP/sctp_cu.c +++ b/openair2/F1AP/sctp_cu.c @@ -40,6 +40,7 @@ #include <pthread.h> #include <unistd.h> // for close #include <stdlib.h> +#include "f1ap_handlers.h" #define MAX_BUFFER 1024 @@ -81,7 +82,10 @@ void *recv_func(void *cfd) { printf("\n"); - f1ap_decode_pdu(NULL , buffer_recv, sizeof(buffer_recv)); + f1ap_handle_message(1/*sctp_data_ind->assoc_id*/, 1/*sctp_data_ind->stream*/, + buffer_recv, sizeof(buffer_recv)); + + //f1ap_decode_pdu(NULL , buffer_recv, sizeof(buffer_recv)); } printf("ret = %d\n", ret); close( *(int*)cfd ); -- 2.26.2