static inline int s1ap_eNB_encode_successfull_outcome(s1ap_message *s1ap_message_p, uint8_t **buffer, uint32_t *len) { int ret = -1; MessageDef *message_p; char *message_string = NULL; size_t message_string_size; MessagesIds message_id; DevAssert(s1ap_message_p != NULL); message_string = calloc(10000, sizeof(char)); s1ap_string_total_size = 0; message_string_size = strlen(message_string); switch(s1ap_message_p->procedureCode) { case S1ap_ProcedureCode_id_InitialContextSetup: ret = s1ap_eNB_encode_initial_context_setup_response( &s1ap_message_p->msg.s1ap_InitialContextSetupResponseIEs, buffer, len); s1ap_xer_print_s1ap_initialcontextsetupresponse(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG; message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_initial_context_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_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 S1ap_ProcedureCode_id_UEContextRelease: ret = s1ap_eNB_encode_ue_context_release_complete( &s1ap_message_p->msg.s1ap_UEContextReleaseCompleteIEs, buffer, len); s1ap_xer_print_s1ap_uecontextreleasecomplete(s1ap_xer__print2sp, message_string, s1ap_message_p); message_id = S1AP_UE_CONTEXT_RELEASE_COMPLETE_LOG; message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_ue_context_release_complete_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_ue_context_release_complete_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); break; default: S1AP_DEBUG("Unknown procedure ID (%d) for successfull outcome message\n", (int)s1ap_message_p->procedureCode); return ret; break; } return ret; }
int nas_itti_plain_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link) { MessageDef *message_p; int data_length = length < NAS_DATA_LENGHT_MAX ? length : NAS_DATA_LENGHT_MAX; int message_type = -1; MessagesIds messageId_raw = -1; MessagesIds messageId_plain = -1; /* Define message ids */ if (msg->header.protocol_discriminator == EPS_MOBILITY_MANAGEMENT_MESSAGE) { message_type = 0; messageId_raw = down_link ? NAS_DL_EMM_RAW_MSG : NAS_UL_EMM_RAW_MSG; messageId_plain = down_link ? NAS_DL_EMM_PLAIN_MSG : NAS_UL_EMM_PLAIN_MSG; } else { if (msg->header.protocol_discriminator == EPS_SESSION_MANAGEMENT_MESSAGE) { message_type = 1; messageId_raw = down_link ? NAS_DL_ESM_RAW_MSG : NAS_UL_ESM_RAW_MSG; messageId_plain = down_link ? NAS_DL_ESM_PLAIN_MSG : NAS_UL_ESM_PLAIN_MSG; } } if (message_type >= 0) { /* Create and send the RAW message */ message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_raw); NAS_DL_EMM_RAW_MSG(message_p).lenght = length; memset ((void *) &(NAS_DL_EMM_RAW_MSG(message_p).data), 0, NAS_DATA_LENGHT_MAX); memcpy ((void *) &(NAS_DL_EMM_RAW_MSG(message_p).data), buffer, data_length); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); /* Create and send the plain message */ if (message_type == 0) { message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_plain); NAS_DL_EMM_PLAIN_MSG(message_p).present = _nas_find_message_index(msg->plain.emm.header.message_type, emm_message_ids, sizeof(emm_message_ids) / sizeof(emm_message_ids[0])); memcpy ((void *) &(NAS_DL_EMM_PLAIN_MSG(message_p).choice), &msg->plain.emm, sizeof (EMM_msg)); } else { message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_plain); NAS_DL_ESM_PLAIN_MSG(message_p).present = _nas_find_message_index(msg->plain.esm.header.message_type, esm_message_ids, sizeof(esm_message_ids) / sizeof(esm_message_ids[0])); memcpy ((void *) &(NAS_DL_ESM_PLAIN_MSG(message_p).choice), &msg->plain.esm, sizeof (ESM_msg)); } return itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); } return EXIT_FAILURE; }
int nas_itti_protected_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link) { MessageDef *message_p = NULL; if (msg->header.protocol_discriminator == EPS_MOBILITY_MANAGEMENT_MESSAGE) { message_p = itti_alloc_new_message(TASK_ORIGIN, down_link ? NAS_DL_EMM_PROTECTED_MSG : NAS_UL_EMM_PROTECTED_MSG); memcpy ((void *) &(NAS_DL_EMM_PROTECTED_MSG(message_p).header), &msg->header, sizeof (nas_message_security_header_t)); NAS_DL_EMM_PROTECTED_MSG(message_p).present = _nas_find_message_index(msg->security_protected.plain.emm.header.message_type, emm_message_ids, sizeof(emm_message_ids) / sizeof(emm_message_ids[0])); memcpy ((void *) &(NAS_DL_EMM_PROTECTED_MSG(message_p).choice), &msg->security_protected.plain.emm, sizeof (EMM_msg)); } else { if (msg->header.protocol_discriminator == EPS_SESSION_MANAGEMENT_MESSAGE) { message_p = itti_alloc_new_message(TASK_ORIGIN, down_link ? NAS_DL_ESM_PROTECTED_MSG : NAS_UL_ESM_PROTECTED_MSG); memcpy ((void *) &(NAS_DL_ESM_PROTECTED_MSG(message_p).header), &msg->header, sizeof (nas_message_security_header_t)); NAS_DL_ESM_PROTECTED_MSG(message_p).present = _nas_find_message_index(msg->security_protected.plain.esm.header.message_type, esm_message_ids, sizeof(esm_message_ids) / sizeof(esm_message_ids[0])); memcpy ((void *) &(NAS_DL_ESM_PROTECTED_MSG(message_p).choice), &msg->security_protected.plain.esm, sizeof (ESM_msg)); } } if (message_p != NULL) { return itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); } return EXIT_FAILURE; }
//----------------------------------------------------------------------------- static int gtpv1u_eNB_send_init_udp(uint16_t port_number) { // Create and alloc new message MessageDef *message_p; struct in_addr addr; message_p = itti_alloc_new_message(TASK_GTPV1_U, UDP_INIT); if (message_p == NULL) { return -1; } UDP_INIT(message_p).port = port_number; //LG UDP_INIT(message_p).address = "0.0.0.0"; //ANY address addr.s_addr = gtpv1u_data_g.enb_ip_address_for_S1u_S12_S4_up; UDP_INIT(message_p).address = inet_ntoa(addr); LOG_D(GTPU, "Tx UDP_INIT IP addr %s\n", UDP_INIT(message_p).address); MSC_LOG_EVENT( MSC_GTPU_ENB, "0 UDP bind %s:%u", UDP_INIT(message_p).address, UDP_INIT(message_p).port); return itti_send_msg_to_task(TASK_UDP, INSTANCE_DEFAULT, message_p); }
static int gtpv1u_create_s1u_tunnel(Gtpv1uCreateTunnelReq *create_tunnel_reqP) { /* Create a new nw-gtpv1-u stack req using API */ NwGtpv1uUlpApiT stack_req; NwGtpv1uRcT rc; /* Local tunnel end-point identifier */ uint32_t s1u_teid = 0; gtpv1u_teid2enb_info_t *gtpv1u_teid2enb_info = NULL; MessageDef *message_p = NULL; hashtable_rc_t hash_rc; GTPU_DEBUG("Rx GTPV1U_CREATE_TUNNEL_REQ Context %d\n", create_tunnel_reqP->context_teid); memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT)); stack_req.apiType = NW_GTPV1U_ULP_API_CREATE_TUNNEL_ENDPOINT; do { s1u_teid = gtpv1u_new_teid(); GTPU_DEBUG("gtpv1u_create_s1u_tunnel() %u\n", s1u_teid); stack_req.apiInfo.createTunnelEndPointInfo.teid = s1u_teid; stack_req.apiInfo.createTunnelEndPointInfo.hUlpSession = 0; stack_req.apiInfo.createTunnelEndPointInfo.hStackSession = 0; rc = nwGtpv1uProcessUlpReq(gtpv1u_sgw_data.gtpv1u_stack, &stack_req); GTPU_DEBUG(".\n"); } while (rc != NW_GTPV1U_OK); gtpv1u_teid2enb_info = malloc (sizeof(gtpv1u_teid2enb_info_t)); memset(gtpv1u_teid2enb_info, 0, sizeof(gtpv1u_teid2enb_info_t)); gtpv1u_teid2enb_info->state = BEARER_IN_CONFIG; //#warning !!! hack because missing modify session request, so force enb address // gtpv1u_teid2enb_info->enb_ip_addr.pdn_type = IPv4; // gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[0] = 192; // gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[1] = 168; // gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[2] = 1; // gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[3] = 2; message_p = itti_alloc_new_message(TASK_GTPV1_U, GTPV1U_CREATE_TUNNEL_RESP); message_p->ittiMsg.gtpv1uCreateTunnelResp.S1u_teid = s1u_teid; message_p->ittiMsg.gtpv1uCreateTunnelResp.context_teid = create_tunnel_reqP->context_teid; message_p->ittiMsg.gtpv1uCreateTunnelResp.eps_bearer_id = create_tunnel_reqP->eps_bearer_id; hash_rc = hashtable_is_key_exists(gtpv1u_sgw_data.S1U_mapping, s1u_teid); if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS) { hash_rc = hashtable_insert(gtpv1u_sgw_data.S1U_mapping, s1u_teid, gtpv1u_teid2enb_info); message_p->ittiMsg.gtpv1uCreateTunnelResp.status = 0; } else { message_p->ittiMsg.gtpv1uCreateTunnelResp.status = 0xFF; } GTPU_DEBUG("Tx GTPV1U_CREATE_TUNNEL_RESP Context %u teid %u eps bearer id %u status %d\n", message_p->ittiMsg.gtpv1uCreateTunnelResp.context_teid, message_p->ittiMsg.gtpv1uCreateTunnelResp.S1u_teid, message_p->ittiMsg.gtpv1uCreateTunnelResp.eps_bearer_id, message_p->ittiMsg.gtpv1uCreateTunnelResp.status); return itti_send_msg_to_task(TASK_SPGW_APP, INSTANCE_DEFAULT, message_p); }
static int gtpv1u_update_s1u_tunnel(Gtpv1uUpdateTunnelReq *reqP) { hashtable_rc_t hash_rc; gtpv1u_teid2enb_info_t *gtpv1u_teid2enb_info; MessageDef *message_p; GTPU_DEBUG("Rx GTPV1U_UPDATE_TUNNEL_REQ Context %u, S-GW S1U teid %u, eNB S1U teid %u\n", reqP->context_teid, reqP->sgw_S1u_teid, reqP->enb_S1u_teid); message_p = itti_alloc_new_message(TASK_GTPV1_U, GTPV1U_UPDATE_TUNNEL_RESP); hash_rc = hashtable_get(gtpv1u_sgw_data.S1U_mapping, reqP->sgw_S1u_teid, (void**)>pv1u_teid2enb_info); if (hash_rc == HASH_TABLE_OK) { gtpv1u_teid2enb_info->teid_enb = reqP->enb_S1u_teid; gtpv1u_teid2enb_info->enb_ip_addr = reqP->enb_ip_address_for_S1u; gtpv1u_teid2enb_info->state = BEARER_UP; gtpv1u_teid2enb_info->port = GTPV1U_UDP_PORT; message_p->ittiMsg.gtpv1uUpdateTunnelResp.status = 0; ///< Status (Failed = 0xFF or Success = 0x0) } else { GTPU_ERROR("Mapping not found\n"); message_p->ittiMsg.gtpv1uUpdateTunnelResp.status = 0xFF; ///< Status (Failed = 0xFF or Success = 0x0) } message_p->ittiMsg.gtpv1uUpdateTunnelResp.context_teid = reqP->context_teid; message_p->ittiMsg.gtpv1uUpdateTunnelResp.sgw_S1u_teid = reqP->sgw_S1u_teid; message_p->ittiMsg.gtpv1uUpdateTunnelResp.enb_S1u_teid = reqP->enb_S1u_teid; message_p->ittiMsg.gtpv1uUpdateTunnelResp.eps_bearer_id = reqP->eps_bearer_id; return itti_send_msg_to_task(TASK_SPGW_APP, INSTANCE_DEFAULT, message_p); }
//----------------------------------------------------------------------------- NwGtpv1uRcT gtpv1u_eNB_send_udp_msg( NwGtpv1uUdpHandleT udpHandle, uint8_t *buffer, uint32_t buffer_len, uint32_t buffer_offset, uint32_t peerIpAddr, uint16_t peerPort) { // Create and alloc new message MessageDef *message_p = NULL; udp_data_req_t *udp_data_req_p = NULL; message_p = itti_alloc_new_message(TASK_GTPV1_U, UDP_DATA_REQ); if (message_p) { #if defined(LOG_GTPU) && LOG_GTPU > 0 LOG_D(GTPU, "Sending UDP_DATA_REQ length %u offset %u", buffer_len, buffer_offset); #endif udp_data_req_p = &message_p->ittiMsg.udp_data_req; udp_data_req_p->peer_address = peerIpAddr; udp_data_req_p->peer_port = peerPort; udp_data_req_p->buffer = buffer; udp_data_req_p->buffer_length = buffer_len; udp_data_req_p->buffer_offset = buffer_offset; return itti_send_msg_to_task(TASK_UDP, INSTANCE_DEFAULT, message_p); } else { return NW_GTPV1U_FAILURE; } }
static NwRcT s11_sgw_send_udp_msg( NwGtpv2cUdpHandleT udpHandle, uint8_t *buffer, uint32_t buffer_len, uint32_t peerIpAddr, uint32_t peerPort) { // Create and alloc new message MessageDef *message_p; udp_data_req_t *udp_data_req_p; int ret = 0; message_p = itti_alloc_new_message(TASK_S11, UDP_DATA_REQ); udp_data_req_p = &message_p->ittiMsg.udp_data_req; udp_data_req_p->peer_address = peerIpAddr; udp_data_req_p->peer_port = peerPort; udp_data_req_p->buffer = buffer; udp_data_req_p->buffer_length = buffer_len; ret = itti_send_msg_to_task(TASK_UDP, INSTANCE_DEFAULT, message_p); return ret == 0 ? NW_OK : NW_FAILURE; }
//------------------------------------------------------------------------------ static uint32_t eNB_app_register(const uint32_t enb_id_start, const uint32_t enb_id_end, const Enb_properties_array_t *enb_properties) //------------------------------------------------------------------------------ { uint32_t enb_id; uint32_t mme_id; MessageDef *msg_p; uint32_t register_enb_pending = 0; char *str = NULL; struct in_addr addr; // 1 eNB should be max. // 1 eNB should be max. for (enb_id = enb_id_start; (enb_id < enb_id_end) ; enb_id++) { { s1ap_register_enb_req_t *s1ap_register_eNB; /* note: there is an implicit relationship between the data structure and the message name */ msg_p = itti_alloc_new_message (TASK_ENB_APP, S1AP_REGISTER_ENB_REQ); s1ap_register_eNB = &S1AP_REGISTER_ENB_REQ(msg_p); /* Some default/random parameters */ s1ap_register_eNB->eNB_id = enb_properties->properties[enb_id]->eNB_id; s1ap_register_eNB->cell_type = enb_properties->properties[enb_id]->cell_type; s1ap_register_eNB->eNB_name = enb_properties->properties[enb_id]->eNB_name; s1ap_register_eNB->tac = enb_properties->properties[enb_id]->tac; s1ap_register_eNB->mcc = enb_properties->properties[enb_id]->mcc; s1ap_register_eNB->mnc = enb_properties->properties[enb_id]->mnc; s1ap_register_eNB->mnc_digit_length = enb_properties->properties[enb_id]->mnc_digit_length; s1ap_register_eNB->default_drx = enb_properties->properties[enb_id]->pcch_defaultPagingCycle[0]; s1ap_register_eNB->nb_mme = enb_properties->properties[enb_id]->nb_mme; AssertFatal (s1ap_register_eNB->nb_mme <= S1AP_MAX_NB_MME_IP_ADDRESS, "Too many MME for eNB %d (%d/%d)!", enb_id, s1ap_register_eNB->nb_mme, S1AP_MAX_NB_MME_IP_ADDRESS); for (mme_id = 0; mme_id < s1ap_register_eNB->nb_mme; mme_id++) { s1ap_register_eNB->mme_ip_address[mme_id].ipv4 = enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv4; s1ap_register_eNB->mme_ip_address[mme_id].ipv6 = enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv6; strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv4_address, enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv4_address, sizeof(s1ap_register_eNB->mme_ip_address[0].ipv4_address)); strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv6_address, enb_properties->properties[enb_id]->mme_ip_address[mme_id].ipv6_address, sizeof(s1ap_register_eNB->mme_ip_address[0].ipv6_address)); } s1ap_register_eNB->enb_ip_address.ipv6 = 0; s1ap_register_eNB->enb_ip_address.ipv4 = 1; addr.s_addr = enb_properties->properties[enb_id]->enb_ipv4_address_for_S1_MME; str = inet_ntoa(addr); strcpy(s1ap_register_eNB->enb_ip_address.ipv4_address, str); itti_send_msg_to_task (TASK_S1AP, ENB_MODULE_ID_TO_INSTANCE(enb_id), msg_p); register_enb_pending++; } } return register_enb_pending; }
void s1ap_handle_s1_setup_message(s1ap_eNB_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 == S1AP_ENB_STATE_CONNECTED) { mme_desc_p->state = S1AP_ENB_STATE_DISCONNECTED; if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb > 0) { /* Decrease associated MME number */ mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb --; } /* If there are no more associated MME, inform eNB app */ if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb == 0) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S1AP, S1AP_DEREGISTERED_ENB_IND); S1AP_DEREGISTERED_ENB_IND(message_p).nb_mme = 0; itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p); } } } else { /* Check that at least one setup message is pending */ DevCheck(mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb > 0, mme_desc_p->s1ap_eNB_instance->instance, mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb, 0); if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb > 0) { /* Decrease pending messages number */ mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb --; } /* If there are no more pending messages, inform eNB app */ if (mme_desc_p->s1ap_eNB_instance->s1ap_mme_pending_nb == 0) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S1AP, S1AP_REGISTER_ENB_CNF); S1AP_REGISTER_ENB_CNF(message_p).nb_mme = mme_desc_p->s1ap_eNB_instance->s1ap_mme_associated_nb; itti_send_msg_to_task(TASK_ENB_APP, mme_desc_p->s1ap_eNB_instance->instance, message_p); } } }
int nas_itti_ul_data_req(const uint32_t ue_id, void *const data, const uint32_t length) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_UPLINK_DATA_REQ); NAS_UPLINK_DATA_REQ(message_p).UEid = ue_id; NAS_UPLINK_DATA_REQ(message_p).nasMsg.data = data; NAS_UPLINK_DATA_REQ(message_p).nasMsg.length = length; return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + 0 /* TODO to be virtualized */, message_p); }
int sctp_itti_send_com_down_ind ( uint32_t assoc_id) { MessageDef *message_p; sctp_close_association_t *sctp_close_association_p; message_p = itti_alloc_new_message (TASK_SCTP, SCTP_CLOSE_ASSOCIATION); sctp_close_association_p = &message_p->ittiMsg.sctp_close_association; sctp_close_association_p->assoc_id = assoc_id; return itti_send_msg_to_task (TASK_S1AP, INSTANCE_DEFAULT, message_p); }
int s1ap_mme_itti_send_sctp_request(uint8_t *buffer, uint32_t length, uint32_t assoc_id, uint16_t stream) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S1AP, SCTP_DATA_REQ); SCTP_DATA_REQ(message_p).buffer = buffer; SCTP_DATA_REQ(message_p).bufLen = length; SCTP_DATA_REQ(message_p).assocId = assoc_id; SCTP_DATA_REQ(message_p).stream = stream; return itti_send_msg_to_task(TASK_SCTP, INSTANCE_DEFAULT, message_p); }
//-------------------------------------------------------------------------------------------// void rrc_lite_data_ind(module_id_t enb_mod_idP, module_id_t ue_mod_idP, frame_t frameP, eNB_flag_t enb_flagP,rb_id_t Srb_id, sdu_size_t sdu_sizeP,uint8_t *buffer_pP){ //-------------------------------------------------------------------------------------------// rb_id_t DCCH_index = Srb_id; #if defined(ENABLE_ITTI) instance_t instance; #endif if (enb_flagP == ENB_FLAG_NO) { #if defined(ENABLE_ITTI) instance = ue_mod_idP + NB_eNB_INST; #endif LOG_N(RRC, "[UE %d] Frame %d: received a DCCH %d message on SRB %d with Size %d from eNB %d\n", ue_mod_idP, frameP, DCCH_index,Srb_id-1,sdu_sizeP, enb_mod_idP); } else { #if defined(ENABLE_ITTI) instance = enb_mod_idP; #endif LOG_N(RRC, "[eNB %d] Frame %d: received a DCCH %d message on SRB %d with Size %d from UE %d\n", enb_mod_idP, frameP, DCCH_index,Srb_id-1,sdu_sizeP, ue_mod_idP); } #if defined(ENABLE_ITTI) { MessageDef *message_p; // Uses a new buffer to avoid issue with PDCP buffer content that could be changed by PDCP (asynchronous message handling). uint8_t *message_buffer; message_buffer = itti_malloc (enb_flagP ? TASK_PDCP_ENB : TASK_PDCP_UE, enb_flagP ? TASK_RRC_ENB : TASK_RRC_UE, sdu_sizeP); memcpy (message_buffer, buffer_pP, sdu_sizeP); message_p = itti_alloc_new_message (enb_flagP ? TASK_PDCP_ENB : TASK_PDCP_UE, RRC_DCCH_DATA_IND); RRC_DCCH_DATA_IND (message_p).frame = frameP; RRC_DCCH_DATA_IND (message_p).dcch_index = DCCH_index; RRC_DCCH_DATA_IND (message_p).sdu_size = sdu_sizeP; RRC_DCCH_DATA_IND (message_p).sdu_p = message_buffer; RRC_DCCH_DATA_IND (message_p).ue_index = ue_mod_idP; RRC_DCCH_DATA_IND (message_p).eNB_index = enb_mod_idP; itti_send_msg_to_task (enb_flagP ? TASK_RRC_ENB : TASK_RRC_UE, instance, message_p); } #else if (enb_flagP == ENB_FLAG_YES) { rrc_eNB_decode_dcch(enb_mod_idP,frameP,DCCH_index,ue_mod_idP,buffer_pP,sdu_sizeP); } else { rrc_ue_decode_dcch(ue_mod_idP,frameP,DCCH_index,buffer_pP,enb_mod_idP); } #endif }
int timer_handle_signal(siginfo_t *info) { struct timer_elm_s *timer_p; MessageDef *message_p; timer_has_expired_t *timer_expired_p; task_id_t task_id; int32_t instance; /* Get back pointer to timer list element */ timer_p = (struct timer_elm_s *)info->si_ptr; // LG: To many traces for msc timer: // TMR_DEBUG("Timer with id 0x%lx has expired\n", (long)timer_p->timer); task_id = timer_p->task_id; instance = timer_p->instance; message_p = itti_alloc_new_message(TASK_TIMER, TIMER_HAS_EXPIRED); timer_expired_p = &message_p->ittiMsg.timer_has_expired; timer_expired_p->timer_id = (long)timer_p->timer; timer_expired_p->arg = timer_p->timer_arg; /* Timer is a one shot timer, remove it */ if (timer_p->type == TIMER_ONE_SHOT) { // if (timer_delete(timer_p->timer) < 0) { // TMR_DEBUG("Failed to delete timer 0x%lx\n", (long)timer_p->timer); // } // TMR_DEBUG("Removed timer 0x%lx\n", (long)timer_p->timer); // pthread_mutex_lock(&timer_desc.timer_list_mutex); // STAILQ_REMOVE(&timer_desc.timer_queue, timer_p, timer_elm_s, entries); // pthread_mutex_unlock(&timer_desc.timer_list_mutex); // free(timer_p); // timer_p = NULL; if (timer_remove((long)timer_p->timer) != 0) { TMR_DEBUG("Failed to delete timer 0x%lx\n", (long)timer_p->timer); } } /* Notify task of timer expiry */ if (itti_send_msg_to_task(task_id, instance, message_p) < 0) { TMR_DEBUG("Failed to send msg TIMER_HAS_EXPIRED to task %u\n", task_id); free(message_p); return -1; } return 0; }
int sctp_itti_send_new_association ( uint32_t assoc_id, uint16_t instreams, uint16_t outstreams) { MessageDef *message_p; sctp_new_peer_t *sctp_new_peer_p; message_p = itti_alloc_new_message (TASK_SCTP, SCTP_NEW_ASSOCIATION); sctp_new_peer_p = &message_p->ittiMsg.sctp_new_peer; sctp_new_peer_p->assoc_id = assoc_id; sctp_new_peer_p->instreams = instreams; sctp_new_peer_p->outstreams = outstreams; return itti_send_msg_to_task (TASK_S1AP, INSTANCE_DEFAULT, message_p); }
//-------------------------------------------------------------------------------------------// int mac_ue_ccch_success_ind(module_id_t Mod_idP, uint8_t eNB_index) { //-------------------------------------------------------------------------------------------// #if defined(ENABLE_ITTI) { MessageDef *message_p; message_p = itti_alloc_new_message (TASK_MAC_UE, RRC_MAC_CCCH_DATA_CNF); RRC_MAC_CCCH_DATA_CNF (message_p).enb_index = eNB_index; itti_send_msg_to_task (TASK_RRC_UE, Mod_idP + NB_eNB_INST, message_p); } #else // reset the tx buffer to indicate RRC that ccch was successfully transmitted (for example if contention resolution succeeds) UE_rrc_inst[Mod_idP].Srb0[eNB_index].Tx_buffer.payload_size=0; #endif return 0; }
void s1ap_eNB_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer, uint32_t buffer_length, uint16_t stream) { MessageDef *message_p; sctp_data_req_t *sctp_data_req; message_p = itti_alloc_new_message(TASK_S1AP, SCTP_DATA_REQ); sctp_data_req = &message_p->ittiMsg.sctp_data_req; sctp_data_req->assoc_id = assoc_id; sctp_data_req->buffer = buffer; sctp_data_req->buffer_length = buffer_length; sctp_data_req->stream = stream; itti_send_msg_to_task(TASK_SCTP, instance, message_p); }
static int s1ap_eNB_decode_successful_outcome(s1ap_message *message, S1ap_SuccessfulOutcome_t *successfullOutcome_p) { 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); s1ap_string_total_size = 0; message->procedureCode = successfullOutcome_p->procedureCode; message->criticality = successfullOutcome_p->criticality; switch(successfullOutcome_p->procedureCode) { case S1ap_ProcedureCode_id_S1Setup: ret = s1ap_decode_s1ap_s1setupresponseies( &message->msg.s1ap_S1SetupResponseIEs, &successfullOutcome_p->value); s1ap_xer_print_s1ap_s1setupresponse(s1ap_xer__print2sp, message_string, message); message_id = S1AP_S1_SETUP_LOG; break; default: S1AP_ERROR("Unknown procedure ID (%d) for successfull outcome message\n", (int)successfullOutcome_p->procedureCode); return -1; } message_string_size = strlen(message_string); message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, message_string_size + sizeof (IttiMsgText)); message_p->ittiMsg.s1ap_s1_setup_log.size = message_string_size; memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, message_string, message_string_size); itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p); free(message_string); return ret; }
int nas_itti_rab_establish_rsp(const as_stmsi_t s_tmsi, const as_rab_id_t rabID, const nas_error_code_t errCode) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_RAB_ESTABLI_RSP); NAS_RAB_ESTABLI_RSP(message_p).s_tmsi = s_tmsi; NAS_RAB_ESTABLI_RSP(message_p).rabID = rabID; NAS_RAB_ESTABLI_RSP(message_p).errCode = errCode; MSC_LOG_TX_MESSAGE( MSC_NAS_UE, MSC_RRC_UE, NULL,0, "0 NAS_RAB_ESTABLI_RSP MME code %u m-TMSI %u rb id %u status %u", s_tmsi.MMEcode, s_tmsi.m_tmsi,rabID, errCode ); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + 0 /* TODO to be virtualized */, message_p); }
static int s11_send_init_udp(char *address, uint16_t port_number) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S11, UDP_INIT); if (message_p == NULL) { return -1; } message_p->ittiMsg.udp_init.port = port_number; //LG message_p->ittiMsg.udpInit.address = "0.0.0.0"; //ANY address message_p->ittiMsg.udp_init.address = address; S11_DEBUG("Tx UDP_INIT IP addr %s\n", message_p->ittiMsg.udp_init.address); return itti_send_msg_to_task(TASK_UDP, INSTANCE_DEFAULT, message_p); }
//-------------------------------------------------------------------------------------------// void rrc_lite_in_sync_ind(module_id_t Mod_idP, frame_t frameP, uint16_t eNB_index) { //-------------------------------------------------------------------------------------------// #if defined(ENABLE_ITTI) { MessageDef *message_p; message_p = itti_alloc_new_message (TASK_MAC_UE, RRC_MAC_IN_SYNC_IND); RRC_MAC_IN_SYNC_IND (message_p).frame = frameP; RRC_MAC_IN_SYNC_IND (message_p).enb_index = eNB_index; itti_send_msg_to_task (TASK_RRC_UE, Mod_idP + NB_eNB_INST, message_p); } #else UE_rrc_inst[Mod_idP].Info[eNB_index].N310_cnt=0; if (UE_rrc_inst[Mod_idP].Info[eNB_index].T310_active==1) UE_rrc_inst[Mod_idP].Info[eNB_index].N311_cnt++; #endif }
int nas_itti_cell_info_req(const plmn_t plmnID, const Byte_t rat) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_CELL_SELECTION_REQ); NAS_CELL_SELECTION_REQ(message_p).plmnID = plmnID; NAS_CELL_SELECTION_REQ(message_p).rat = rat; MSC_LOG_TX_MESSAGE( MSC_NAS_UE, MSC_RRC_UE, NULL,0, "0 NAS_CELL_SELECTION_REQ PLMN %X%X%X.%X%X%X", plmnID.MCCdigit1, plmnID.MCCdigit2, plmnID.MCCdigit3, plmnID.MNCdigit1, plmnID.MNCdigit2, plmnID.MNCdigit3); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + 0 /* TODO to be virtualized */, message_p); }
int nas_itti_dl_data_req(const uint32_t ue_id, void *const data, const uint32_t length) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_NAS_MME, NAS_DOWNLINK_DATA_REQ); NAS_DL_DATA_REQ(message_p).UEid = ue_id; NAS_DL_DATA_REQ(message_p).nasMsg.data = data; NAS_DL_DATA_REQ(message_p).nasMsg.length = length; MSC_LOG_TX_MESSAGE( MSC_NAS_MME, MSC_S1AP_MME, NULL,0, "0 NAS_DOWNLINK_DATA_REQ ue id "NAS_UE_ID_FMT" len %u", ue_id, length); return itti_send_msg_to_task(TASK_S1AP, INSTANCE_DEFAULT, message_p); }
void s1ap_eNB_itti_send_nas_downlink_ind(instance_t instance, uint16_t ue_initial_id, uint32_t eNB_ue_s1ap_id, uint8_t *nas_pdu, uint32_t nas_pdu_length) { MessageDef *message_p; s1ap_downlink_nas_t *s1ap_downlink_nas; message_p = itti_alloc_new_message(TASK_S1AP, S1AP_DOWNLINK_NAS); s1ap_downlink_nas = &message_p->ittiMsg.s1ap_downlink_nas; s1ap_downlink_nas->ue_initial_id = ue_initial_id; s1ap_downlink_nas->eNB_ue_s1ap_id = eNB_ue_s1ap_id; s1ap_downlink_nas->nas_pdu.buffer = nas_pdu; s1ap_downlink_nas->nas_pdu.length = nas_pdu_length; itti_send_msg_to_task(TASK_RRC_ENB, instance, message_p); }
static int gtpv1u_delete_s1u_tunnel(Teid_t context_teidP, Teid_t S1U_teidP) { /* Local tunnel end-point identifier */ MessageDef *message_p; GTPU_DEBUG("Rx GTPV1U_DELETE_TUNNEL Context %u S1U teid %u\n", context_teidP, S1U_teidP); message_p = itti_alloc_new_message(TASK_GTPV1_U, GTPV1U_DELETE_TUNNEL_RESP); message_p->ittiMsg.gtpv1uDeleteTunnelResp.S1u_teid = S1U_teidP; message_p->ittiMsg.gtpv1uDeleteTunnelResp.context_teid = context_teidP; if (hashtable_remove(gtpv1u_sgw_data.S1U_mapping, S1U_teidP) == HASH_TABLE_OK ) { message_p->ittiMsg.gtpv1uDeleteTunnelResp.status = 0; } else { message_p->ittiMsg.gtpv1uDeleteTunnelResp.status = -1; } GTPU_DEBUG("Tx SGW_S1U_ENDPOINT_CREATED Context %u teid %u status %d\n", context_teidP, S1U_teidP, message_p->ittiMsg.gtpv1uDeleteTunnelResp.status); return itti_send_msg_to_task(TASK_SPGW_APP, INSTANCE_DEFAULT, message_p); }
int s1ap_mme_itti_nas_downlink_cnf(const uint32_t ue_id, nas_error_code_t error_code) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S1AP, NAS_DOWNLINK_DATA_CNF); NAS_DL_DATA_CNF(message_p).UEid = ue_id; NAS_DL_DATA_CNF(message_p).errCode = error_code; MSC_LOG_TX_MESSAGE( MSC_S1AP_MME, MSC_NAS_MME, NULL,0, "0 NAS_DOWNLINK_DATA_CNF ue_id "S1AP_UE_ID_FMT" errCode %u", NAS_DL_DATA_CNF(message_p).UEid, NAS_DL_DATA_CNF(message_p).errCode); return itti_send_msg_to_task(TASK_NAS_MME, INSTANCE_DEFAULT, message_p); }
int sctp_itti_send_new_message_ind ( int n, uint8_t * buffer, uint32_t assoc_id, uint16_t stream, uint16_t instreams, uint16_t outstreams) { MessageDef *message_p; message_p = itti_alloc_new_message (TASK_SCTP, SCTP_DATA_IND); SCTP_DATA_IND (message_p).buffer = malloc (sizeof (uint8_t) * n); memcpy ((void *)SCTP_DATA_IND (message_p).buffer, (void *)buffer, n); SCTP_DATA_IND (message_p).stream = stream; SCTP_DATA_IND (message_p).buf_length = n; SCTP_DATA_IND (message_p).assoc_id = assoc_id; SCTP_DATA_IND (message_p).instreams = instreams; SCTP_DATA_IND (message_p).outstreams = outstreams; return itti_send_msg_to_task (TASK_S1AP, INSTANCE_DEFAULT, message_p); }
int s1ap_mme_itti_nas_uplink_ind(const uint32_t ue_id, uint8_t * const buffer, const uint32_t length) { MessageDef *message_p; message_p = itti_alloc_new_message(TASK_S1AP, NAS_UPLINK_DATA_IND); NAS_UL_DATA_IND(message_p).UEid = ue_id; NAS_UL_DATA_IND(message_p).nasMsg.data = buffer; NAS_UL_DATA_IND(message_p).nasMsg.length = length; MSC_LOG_TX_MESSAGE( MSC_S1AP_MME, MSC_NAS_MME, NULL,0, "0 NAS_UPLINK_DATA_IND ue_id "S1AP_UE_ID_FMT" len %u", NAS_UL_DATA_IND(message_p).UEid, NAS_UL_DATA_IND(message_p).nasMsg.length); return itti_send_msg_to_task(TASK_NAS_MME, INSTANCE_DEFAULT, message_p); }
//-------------------------------------------------------------------------------------------// void rrc_lite_out_of_sync_ind(module_id_t Mod_idP, frame_t frameP, uint16_t eNB_index){ //-------------------------------------------------------------------------------------------// LOG_I(RRC,"[UE %d] Frame %d: OUT OF SYNC FROM eNB %d (T310 %d, N310 %d, N311 %d)\n ", Mod_idP,frameP,eNB_index, UE_rrc_inst[Mod_idP].Info[eNB_index].T310_cnt, UE_rrc_inst[Mod_idP].Info[eNB_index].N310_cnt, UE_rrc_inst[Mod_idP].Info[eNB_index].N311_cnt); #if defined(ENABLE_ITTI) { MessageDef *message_p; message_p = itti_alloc_new_message (TASK_MAC_UE, RRC_MAC_OUT_OF_SYNC_IND); RRC_MAC_OUT_OF_SYNC_IND (message_p).frame = frameP; RRC_MAC_OUT_OF_SYNC_IND (message_p).enb_index = eNB_index; itti_send_msg_to_task (TASK_RRC_UE, Mod_idP + NB_eNB_INST, message_p); } #else UE_rrc_inst[Mod_idP].Info[eNB_index].N310_cnt++; #endif }