//----------------------------------------------------------------------------- static int gtpv1u_eNB_init(void) { int ret; NwGtpv1uRcT rc = NW_GTPV1U_FAILURE; NwGtpv1uUlpEntityT ulp; NwGtpv1uUdpEntityT udp; NwGtpv1uLogMgrEntityT log; NwGtpv1uTimerMgrEntityT tmr; Enb_properties_t *enb_properties_p = NULL; enb_properties_p = enb_config_get()->properties[0]; memset(>pv1u_data_g, 0, sizeof(gtpv1u_data_g)); LOG_I(GTPU, "Initializing GTPU stack %p\n",>pv1u_data_g); //gtpv1u_data_g.gtpv1u_stack; /* Initialize UE hashtable */ gtpv1u_data_g.ue_mapping = hashtable_create (32, NULL, NULL); AssertFatal(gtpv1u_data_g.ue_mapping != NULL, " ERROR Initializing TASK_GTPV1_U task interface: in hashtable_create returned %p\n", gtpv1u_data_g.ue_mapping); gtpv1u_data_g.teid_mapping = hashtable_create (256, NULL, NULL); AssertFatal(gtpv1u_data_g.teid_mapping != NULL, " ERROR Initializing TASK_GTPV1_U task interface: in hashtable_create\n"); gtpv1u_data_g.enb_ip_address_for_S1u_S12_S4_up = enb_properties_p->enb_ipv4_address_for_S1U; gtpv1u_data_g.ip_addr = NULL; gtpv1u_data_g.enb_port_for_S1u_S12_S4_up = enb_properties_p->enb_port_for_S1U; //gtpv1u_data_g.udp_data; gtpv1u_data_g.seq_num = 0; gtpv1u_data_g.restart_counter = 0; /* Initializing GTPv1-U stack */ if ((rc = nwGtpv1uInitialize(>pv1u_data_g.gtpv1u_stack, GTPU_STACK_ENB)) != NW_GTPV1U_OK) { LOG_E(GTPU, "Failed to setup nwGtpv1u stack %x\n", rc); return -1; } if ((rc = nwGtpv1uSetLogLevel(gtpv1u_data_g.gtpv1u_stack, NW_LOG_LEVEL_DEBG)) != NW_GTPV1U_OK) { LOG_E(GTPU, "Failed to setup loglevel for stack %x\n", rc); return -1; } /* Set the ULP API callback. Called once message have been processed by the * nw-gtpv1u stack. */ ulp.ulpReqCallback = gtpv1u_eNB_process_stack_req; if ((rc = nwGtpv1uSetUlpEntity(gtpv1u_data_g.gtpv1u_stack, &ulp)) != NW_GTPV1U_OK) { LOG_E(GTPU, "nwGtpv1uSetUlpEntity: %x", rc); return -1; } /* nw-gtpv1u stack requires an udp callback to send data over UDP. * We provide a wrapper to UDP task. */ udp.udpDataReqCallback = gtpv1u_eNB_send_udp_msg; if ((rc = nwGtpv1uSetUdpEntity(gtpv1u_data_g.gtpv1u_stack, &udp)) != NW_GTPV1U_OK) { LOG_E(GTPU, "nwGtpv1uSetUdpEntity: %x", rc); return -1; } log.logReqCallback = gtpv1u_eNB_log_request; if ((rc = nwGtpv1uSetLogMgrEntity(gtpv1u_data_g.gtpv1u_stack, &log)) != NW_GTPV1U_OK) { LOG_E(GTPU, "nwGtpv1uSetLogMgrEntity: %x", rc); return -1; } /* Timer interface is more complicated as both wrappers doesn't send a message * to the timer task but call the timer API functions start/stop timer. */ tmr.tmrMgrHandle = 0; tmr.tmrStartCallback = gtpv1u_start_timer_wrapper; tmr.tmrStopCallback = gtpv1u_stop_timer_wrapper; if ((rc = nwGtpv1uSetTimerMgrEntity(gtpv1u_data_g.gtpv1u_stack, &tmr)) != NW_GTPV1U_OK) { LOG_E(GTPU, "nwGtpv1uSetTimerMgrEntity: %x", rc); return -1; } #if defined(GTP_DUMP_SOCKET) && GTP_DUMP_SOCKET > 0 if ((ret = gtpv1u_eNB_create_dump_socket()) < 0) { return -1; } #endif ret = gtpv1u_eNB_send_init_udp(gtpv1u_data_g.enb_port_for_S1u_S12_S4_up); if (ret < 0) { return ret; } LOG_D(GTPU, "Initializing GTPV1U interface for eNB: DONE\n"); return 0; }
int main(int argc, char* argv[]) { NwGtpv1uRcT rc; char* logLevelStr; NwU32T logLevel; NwU32T num_of_connections; NwGtpv1uStackHandleT hGtpv1uStack = 0; NwMiniUlpEntityT ulpObj; NwMiniUdpEntityT udpObj; NwMiniLogMgrT logObj; NwGtpv1uUlpEntityT ulp; NwGtpv1uUdpEntityT udp; NwGtpv1uTimerMgrEntityT tmrMgr; NwGtpv1uLogMgrEntityT logMgr; if(argc != 4) { printf("Usage: %s <num-of-connections> <local-ip> <peer-ip>\n", argv[0]); exit(0); } logLevelStr = getenv ("NW_LOG_LEVEL"); if(logLevelStr == NULL) { logLevel = NW_LOG_LEVEL_INFO; } else { if(strncmp(logLevelStr, "EMER",4) == 0) logLevel = NW_LOG_LEVEL_EMER; else if(strncmp(logLevelStr, "ALER",4) == 0) logLevel = NW_LOG_LEVEL_ALER; else if(strncmp(logLevelStr, "CRIT",4) == 0) logLevel = NW_LOG_LEVEL_CRIT; else if(strncmp(logLevelStr, "ERRO",4) == 0) logLevel = NW_LOG_LEVEL_ERRO ; else if(strncmp(logLevelStr, "WARN",4) == 0) logLevel = NW_LOG_LEVEL_WARN; else if(strncmp(logLevelStr, "NOTI",4) == 0) logLevel = NW_LOG_LEVEL_NOTI; else if(strncmp(logLevelStr, "INFO",4) == 0) logLevel = NW_LOG_LEVEL_INFO; else if(strncmp(logLevelStr, "DEBG",4) == 0) logLevel = NW_LOG_LEVEL_DEBG; } /*--------------------------------------------------------------------------- * Initialize event library *--------------------------------------------------------------------------*/ NW_EVT_INIT(); /*--------------------------------------------------------------------------- * Initialize Log Manager *--------------------------------------------------------------------------*/ nwMiniLogMgrInit(&logObj, logLevel); /*--------------------------------------------------------------------------- * Create GTPv1u Stack Instance *--------------------------------------------------------------------------*/ rc = nwGtpv1uInitialize(&hGtpv1uStack); if(rc != NW_GTPV1U_OK) { NW_LOG(NW_LOG_LEVEL_ERRO, "Failed to create gtpv1u stack instance. Error '%u' occured", rc); exit(1); } NW_LOG(NW_LOG_LEVEL_INFO, "Gtpv1u Stack Handle '%X' Creation Successful!", hGtpv1uStack); /*--------------------------------------------------------------------------- * Set up Ulp Entity *--------------------------------------------------------------------------*/ rc = nwMiniUlpInit(&ulpObj, hGtpv1uStack); NW_ASSERT( rc == NW_GTPV1U_OK ); ulp.hUlp = (NwGtpv1uUlpHandleT) &ulpObj; ulp.ulpReqCallback = nwMiniUlpProcessStackReqCallback; rc = nwGtpv1uSetUlpEntity(hGtpv1uStack, &ulp); NW_ASSERT( rc == NW_GTPV1U_OK ); /*--------------------------------------------------------------------------- * Set up Udp Entity *--------------------------------------------------------------------------*/ rc = nwMiniUdpInit(&udpObj, hGtpv1uStack, (argv[2])); NW_ASSERT( rc == NW_GTPV1U_OK ); udp.hUdp = (NwGtpv1uUdpHandleT) &udpObj; udp.udpDataReqCallback = nwMiniUdpDataReq; rc = nwGtpv1uSetUdpEntity(hGtpv1uStack, &udp); NW_ASSERT( rc == NW_GTPV1U_OK ); /*--------------------------------------------------------------------------- * Set up Log Entity *--------------------------------------------------------------------------*/ tmrMgr.tmrMgrHandle = 0; tmrMgr.tmrStartCallback = nwTimerStart; tmrMgr.tmrStopCallback = nwTimerStop; rc = nwGtpv1uSetTimerMgrEntity(hGtpv1uStack, &tmrMgr); NW_ASSERT( rc == NW_GTPV1U_OK ); /*--------------------------------------------------------------------------- * Set up Log Entity *--------------------------------------------------------------------------*/ logMgr.logMgrHandle = (NwGtpv1uLogMgrHandleT) &logObj; logMgr.logReqCallback = nwMiniLogMgrLogRequest; rc = nwGtpv1uSetLogMgrEntity(hGtpv1uStack, &logMgr); NW_ASSERT( rc == NW_GTPV1U_OK ); /*--------------------------------------------------------------------------- * Set GTPv1u log level *--------------------------------------------------------------------------*/ rc = nwGtpv1uSetLogLevel(hGtpv1uStack, logLevel); /*--------------------------------------------------------------------------- * Send Create Session Request to GTPv1u Stack Instance *--------------------------------------------------------------------------*/ num_of_connections = atoi(argv[1]); while ( num_of_connections-- ) { //rc = nwMiniUlpCreateConn(&ulpObj, argv[2], 1234 + num_of_connections, argv[3]); rc = nwMiniUlpSendEchoRequestToPeer(&ulpObj, inet_addr(argv[3])); NW_ASSERT( rc == NW_GTPV1U_OK ); } /*--------------------------------------------------------------------------- * Event loop *--------------------------------------------------------------------------*/ NW_EVT_LOOP(); NW_LOG(NW_LOG_LEVEL_ERRO, "Exit from eventloop, no events to process!"); /*--------------------------------------------------------------------------- * Send Destroy Session Request to GTPv1u Stack Instance *--------------------------------------------------------------------------*/ rc = nwMiniUlpDestroyConn(&ulpObj); NW_ASSERT( rc == NW_GTPV1U_OK ); /*--------------------------------------------------------------------------- * Destroy GTPv1u Stack Instance *--------------------------------------------------------------------------*/ rc = nwGtpv1uFinalize(hGtpv1uStack); if(rc != NW_GTPV1U_OK) { NW_LOG(NW_LOG_LEVEL_ERRO, "Failed to finalize gtpv1u stack instance. Error '%u' occured", rc); } else { NW_LOG(NW_LOG_LEVEL_INFO, "Gtpv1u Stack Handle '%X' Finalize Successful!", hGtpv1uStack); } return rc; }
NwSdpRcT nwSdpCreateGtpuServiceHaveBase( NW_IN NwSdpHandleT hSdp, NW_IN NwU32T hGtpuTlInterface, NW_IN NwSdpRcT (*pGtpuTlDataReqCb)( NwGtpv1uUdpHandleT hUdp, NwU8T* dataBuf, NwU32T dataSize, NwU32T peerIpAddr, NwU32T peerPort), NW_IN NwSdpServiceHandleT* phSdpService, NW_IN NwGtpv1uStackHandleT hGtpv1uStackBase) { NwSdpRcT rc; NwSdpT* thiz; NwGtpv1uUlpEntityT gtpuUlp; NwGtpv1uUdpEntityT gtpuUdp; NwGtpv1uLogMgrEntityT gtpuLogMgr; NwGtpv1uTimerMgrEntityT gtpuTmrMgr; NwGtpv1uMemMgrEntityT gtpuMemMgr; thiz = (NwSdpT*) hSdp; /* * Create GTPU Stack Instance */ rc = nwGtpv1uInitialize(&thiz->hGtpv1uStack); if(rc != NW_SDP_OK) { NW_LOG(thiz, NW_LOG_LEVEL_ERRO, "Failed to create GTPU stack instance. Error '%u' occured", rc); exit(1); } NW_LOG(thiz, NW_LOG_LEVEL_INFO, "GTPU Stack Handle '%X' Creation Successful!", thiz->hGtpv1uStack); /*--------------------------------------------------------------------------- * Set up Mem Manager *--------------------------------------------------------------------------*/ gtpuMemMgr.hMemMgr = thiz->memMgr.hMemMgr; gtpuMemMgr.memAlloc = thiz->memMgr.memAlloc; gtpuMemMgr.memFree = thiz->memMgr.memFree; rc = nwGtpv1uSetMemMgrEntity(thiz->hGtpv1uStack, >puMemMgr); NW_ASSERT( rc == NW_SDP_OK ); /*--------------------------------------------------------------------------- * Set up Tmr Manager *--------------------------------------------------------------------------*/ gtpuTmrMgr.tmrMgrHandle = thiz->tmrMgr.tmrMgrHandle; gtpuTmrMgr.tmrStartCallback = thiz->tmrMgr.tmrStartCallback; gtpuTmrMgr.tmrStopCallback = thiz->tmrMgr.tmrStopCallback; rc = nwGtpv1uSetTimerMgrEntity(thiz->hGtpv1uStack, >puTmrMgr); NW_ASSERT( rc == NW_SDP_OK ); /*--------------------------------------------------------------------------- * Set up Log Entity *--------------------------------------------------------------------------*/ gtpuLogMgr.logMgrHandle = (NwGtpv1uLogMgrHandleT) thiz->logMgr.logMgrHandle; gtpuLogMgr.logReqCallback = thiz->logMgr.logReqCallback; rc = nwGtpv1uSetLogMgrEntity(thiz->hGtpv1uStack, >puLogMgr); NW_ASSERT( rc == NW_SDP_OK ); /*--------------------------------------------------------------------------- * Set GTPv1u log level *--------------------------------------------------------------------------*/ rc = nwGtpv1uSetLogLevel(thiz->hGtpv1uStack, thiz->logLevel); /*--------------------------------------------------------------------------- * Set ULP Entity *--------------------------------------------------------------------------*/ gtpuUlp.hUlp = (NwGtpv1uUlpHandleT) thiz; gtpuUlp.ulpReqCallback = nwSdpProcessGtpv1uStackReqCallback; rc = nwGtpv1uSetUlpEntity(thiz->hGtpv1uStack, >puUlp); NW_ASSERT( rc == NW_SDP_OK ); /*--------------------------------------------------------------------------- * Set UDP Entity *--------------------------------------------------------------------------*/ gtpuUdp.hUdp = (NwGtpv1uUdpHandleT) hGtpuTlInterface; gtpuUdp.udpDataReqCallback = pGtpuTlDataReqCb; rc = nwGtpv1uSetUdpEntity(thiz->hGtpv1uStack, >puUdp); NW_ASSERT( rc == NW_SDP_OK ); rc = nwGtpv1uSetStackEntity(thiz->hGtpv1uStack, hGtpv1uStackBase); NW_ASSERT( rc == NW_SDP_OK ); *phSdpService = (NwSdpServiceHandleT) (thiz->hGtpv1uStack); return rc; }