//-------------------------------------------------------------------------------------------// 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 }
//-------------------------------------------------------------------------------------------// uint8_t rrc_lite_data_req(module_id_t enb_mod_idP, module_id_t ue_mod_idP, frame_t frameP, eNB_flag_t enb_flagP, rb_id_t rb_idP, mui_t muiP, uint32_t confirmP, sdu_size_t sdu_size, uint8_t* buffer_pP, pdcp_transmission_mode_t mode) { //-------------------------------------------------------------------------------------------// #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_RRC_ENB : TASK_RRC_UE, enb_flagP ? TASK_PDCP_ENB : TASK_PDCP_UE, sdu_size); memcpy (message_buffer, buffer_pP, sdu_size); message_p = itti_alloc_new_message (enb_flagP ? TASK_RRC_ENB : TASK_RRC_UE, RRC_DCCH_DATA_REQ); RRC_DCCH_DATA_REQ (message_p).frame = frameP; RRC_DCCH_DATA_REQ (message_p).enb_flag = enb_flagP; RRC_DCCH_DATA_REQ (message_p).rb_id = rb_idP; RRC_DCCH_DATA_REQ (message_p).muip = muiP; RRC_DCCH_DATA_REQ (message_p).confirmp = confirmP; RRC_DCCH_DATA_REQ (message_p).sdu_size = sdu_size; RRC_DCCH_DATA_REQ (message_p).sdu_p = message_buffer; RRC_DCCH_DATA_REQ (message_p).mode = mode; RRC_DCCH_DATA_REQ (message_p).eNB_index = enb_mod_idP; RRC_DCCH_DATA_REQ (message_p).ue_index = ue_mod_idP; itti_send_msg_to_task (enb_flagP ? TASK_PDCP_ENB : TASK_PDCP_UE, enb_flagP ? enb_mod_idP : NB_eNB_INST + ue_mod_idP, message_p); return TRUE; // TODO should be changed to a CNF message later, currently RRC lite does not used the returned value anyway. } #else protocol_ctxt_t ctxt; ctxt.enb_module_id = enb_mod_idP; ctxt.ue_module_id = ue_mod_idP; ctxt.frame = frameP; ctxt.enb_flag = enb_flagP; return pdcp_data_req (&ctxt, SRB_FLAG_YES, rb_idP, muiP, confirmP, sdu_size, buffer_pP, mode); #endif }
static NwGtpv1uRcT nwGtpv1uHandleEchoReq(NW_IN NwGtpv1uStackT *thiz, NW_IN uint8_t *msgBuf, NW_IN uint32_t msgBufLen, NW_IN uint16_t peerPort, NW_IN uint32_t peerIp) { NwGtpv1uRcT rc = NW_GTPV1U_FAILURE; uint16_t seqNum = 0; NwGtpv1uMsgHandleT hMsg = 0; int bufLen = 0; seqNum = ntohs(*(uint16_t *) (msgBuf + (((*msgBuf) & 0x02) ? 8 : 4))); MSC_LOG_RX_MESSAGE( (thiz->stackType == GTPU_STACK_ENB) ? MSC_GTPU_ENB:MSC_GTPU_SGW, (thiz->stackType == GTPU_STACK_ENB) ? MSC_GTPU_SGW:MSC_GTPU_ENB, NULL, 0, MSC_AS_TIME_FMT" ECHO-REQ seq %u size %u", 0,0,seqNum, msgBufLen); /* Send Echo Response */ rc = nwGtpv1uMsgNew( (NwGtpv1uStackHandleT)thiz, NW_TRUE, /* SeqNum flag */ NW_FALSE, NW_FALSE, NW_GTP_ECHO_RSP, /* Msg Type */ 0x00000000U, /* TEID */ seqNum, /* Seq Number */ 0, 0, (&hMsg)); bufLen = sizeof(NwGtpv1uIeTv1T)+ ((NwGtpv1uMsgT*)hMsg)->msgLen; ((NwGtpv1uMsgT*)hMsg)->msgBuf = itti_malloc( TASK_GTPV1_U, TASK_UDP, bufLen); ((NwGtpv1uMsgT*)hMsg)->msgBufLen = bufLen; NW_ASSERT(NW_GTPV1U_OK == rc); /* * The Restart Counter value in the Recovery information element shall * not be used, i.e. it shall be set to zero by the sender and shall be * ignored by the receiver. */ rc = nwGtpv1uMsgAddIeTV1(hMsg, NW_GTPV1U_IE_RECOVERY, 0x00); #if defined(LOG_GTPU) && LOG_GTPU > 0 GTPU_INFO("Sending NW_GTP_ECHO_RSP message to %x:%x with seq %u\n", peerIp, peerPort, seqNum); #endif MSC_LOG_TX_MESSAGE( (thiz->stackType == GTPU_STACK_ENB) ? MSC_GTPU_ENB:MSC_GTPU_SGW, (thiz->stackType == GTPU_STACK_ENB) ? MSC_GTPU_SGW:MSC_GTPU_ENB, NULL, 0, MSC_AS_TIME_FMT" ECHO-RSP seq %u", 0,0,seqNum); rc = nwGtpv1uCreateAndSendMsg( thiz, peerIp, peerPort, (NwGtpv1uMsgT *) hMsg); rc = nwGtpv1uMsgDelete((NwGtpv1uStackHandleT)thiz, hMsg); NW_ASSERT(NW_GTPV1U_OK == rc); return rc; }