//-----------------------------------------------------------------------------
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;
}
