Rigel/ec718
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ec718/ec_fullsdk/PLAT/middleware/thirdparty/iperf/iperf_api.c

2452 lines
76 KiB
C
Raw Normal View History

init
2025-04-10 17:31:33 +08:00
#include <stdio.h>
#include <string.h>
#include "cmsis_os2.h"
#include <stdlib.h>
#include "sys/socket.h"
#include "posix/errno.h"
#include "lwip/inet.h"
#include "iperf_api.h"
#include "iperf_config.h"
#include "debug_trace.h"
#include DEBUG_LOG_HEADER_FILE
#include "psdial.h"
#if (defined CHIP_EC618) || (defined CHIP_EC718) || (defined CHIP_EC716)
#include "slpman.h"
#elif defined CHIP_EC617
#include "slpman_ec617.h"
#endif
/***************************************************************************************
* Macros
****************************************************************************************/
static NET_ZI_DEF BOOL bIperfCltIsGoingOn = 0;
static NET_ZI_DEF BOOL bIperfSrvIsGoingOn = 0;
static NET_ZI_DEF osThreadId_t iperfCLtTask = NULL;
static NET_ZI_DEF osThreadId_t iperfSrvTask = NULL;
static NET_ZI_DEF BOOL bIperfCltTerminRunning = 0;
static NET_ZI_DEF BOOL bIperfSrvTerminRunning = 0;
static NET_ZI_DEF NmIperfReq pIperfClientReq;
static NET_ZI_DEF NmIperfReq pIperfServerReq;
/***************************************************************************************
* structure
****************************************************************************************/
typedef struct IperfCount_Tag
{
UINT32 Bytes;
UINT32 KBytes;
UINT32 MBytes;
UINT32 GBytes;
UINT32 times;
} IperfCount;
typedef struct IperfUdpDatagram_Tag
{
INT32 pkgId;
UINT32 sec;
UINT32 uSec;
} IperfUdpDatagram;
typedef struct IperfClientHeader_Tag
{
INT32 flags;
INT32 numChannels;
INT32 portClient;
INT32 buffLen;
INT32 band;
INT32 amounts;
} IperfClientHeader;
/****************************************************************************************
* Function Declarations
****************************************************************************************/
IperfCount IperfCalculateResult( INT32 pktSize, IperfCount pktCount, INT32 needToConvert );
IperfCount IperfCalculateAddHeader( INT32 domain, INT32 protocol, IperfCount pktCount );
IperfCount IperfResetCount( IperfCount pktCount );
IperfCount IperfCopyCount( IperfCount pktCount, IperfCount tmpCount );
IperfCount IperfDiffCount( IperfCount pktCount, IperfCount tmpCount );
/******************************************************
* Variables Definitions
******************************************************/
/******************************************************
* utility API
******************************************************/
void IperfGetCurrentTime(UINT32 *s, UINT32 *ms) {
UINT32 currentMs = 0;
if(!s && !ms) {
return;
}
currentMs = osKernelGetTickCount()/portTICK_PERIOD_MS;
if(s) {
*s = currentMs/1000;
}
if(ms) {
*ms = currentMs;
}
}
void IperfmSleep( UINT32 ms ) {
osDelay(ms/portTICK_PERIOD_MS);
}
INT32 IperfSetupUdpServerSocket(INT32 *fd, INT32 serverPort, UINT32 rcvTimeout, ip_addr_t *serverAddr, BOOL bNat)
{
struct sockaddr_in servaddr;
struct sockaddr_in6 servaddr6;
if(!fd)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_1, P_WARNING, 0, "IperfSetupClientSocket input fd point is invalid");
return NM_IPERF_PARAM_ERROR;
}
#if LWIP_SO_SNDRCVTIMEO_NONSTANDARD
UINT32 timeout = rcvTimeout;
#else
struct timeval timeout;
timeout.tv_sec = rcvTimeout;
timeout.tv_usec = 0;
#endif
if(serverAddr && (IP_IS_V4(serverAddr) && !ip_addr_isany(serverAddr)))
{
// Create a new UDP connection handle
if( (*fd = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_2, P_WARNING, 0, "create udp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and any IP address
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
if(bNat == FALSE)
{
inet_addr_from_ip4addr(&servaddr.sin_addr, ip_2_ip4(serverAddr));
}
servaddr.sin_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr, sizeof(servaddr) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_3, P_WARNING, 0, "udp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
else if(serverAddr && (IP_IS_V6(serverAddr) && !ip_addr_isany(serverAddr)))
{
// Create a new UDP connection handle
if( (*fd = socket( AF_INET6, SOCK_DGRAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_4, P_WARNING, 0, "create udp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and IP
memset( &servaddr6, 0, sizeof(servaddr6) );
servaddr6.sin6_family = AF_INET6;
if(bNat == FALSE)
{
inet6_addr_from_ip6addr(&servaddr6.sin6_addr, ip_2_ip6(serverAddr));
}
servaddr6.sin6_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr6, sizeof(servaddr6) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_5, P_WARNING, 0, "udp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
else
{
// Create a new UDP connection handle
if( (*fd = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_6, P_WARNING, 0, "create udp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and any IP address
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr, sizeof(servaddr) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_7, P_WARNING, 0, "udp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
socklen_t len = sizeof(timeout);
if( setsockopt( *fd, SOL_SOCKET, SO_RCVTIMEO, (CHAR *) &timeout, len ) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_8, P_WARNING, 0, "Setsockopt failed - cancel receive timeout");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
return 0;
}
INT32 IperfSetupTcpServerSocket(INT32 *fd, INT32 serverPort, UINT32 rcvTimeout, ip_addr_t *serverAddr)
{
struct sockaddr_in servaddr;
struct sockaddr_in6 servaddr6;
if(!fd)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_1, P_WARNING, 0, "IperfSetupTcpServerSocket input fd point is invalid");
return NM_IPERF_PARAM_ERROR;
}
#if LWIP_SO_SNDRCVTIMEO_NONSTANDARD
UINT32 timeout = rcvTimeout;
#else
struct timeval timeout;
timeout.tv_sec = rcvTimeout;
timeout.tv_usec = 0;
#endif
if(serverAddr && (IP_IS_V4(serverAddr) && !ip_addr_isany(serverAddr)))
{
// Create a new TCP connection handle
if( (*fd = socket( AF_INET, SOCK_STREAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_3, P_WARNING, 0, "create tcp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and any IP address
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
inet_addr_from_ip4addr(&servaddr.sin_addr, ip_2_ip4(serverAddr));
servaddr.sin_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr, sizeof(servaddr) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_4, P_WARNING, 0, "tcp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
else if(serverAddr && (IP_IS_V6(serverAddr) && !ip_addr_isany(serverAddr)))
{
// Create a new TCP connection handle
if( (*fd = socket( AF_INET6, SOCK_STREAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_5, P_WARNING, 0, "create tcp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and IP
memset( &servaddr6, 0, sizeof(servaddr6) );
servaddr6.sin6_family = AF_INET6;
inet6_addr_from_ip6addr(&servaddr6.sin6_addr, ip_2_ip6(serverAddr));
servaddr6.sin6_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr6, sizeof(servaddr6) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_6, P_WARNING, 0, "tcp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
else
{
// Create a new TCP connection handle
if( (*fd = socket( AF_INET, SOCK_STREAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_7, P_WARNING, 0, "create tcp server socket fail");
return NM_IPERF_SOCKET_ERROR;
}
// Bind to port and any IP address
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons( serverPort );
if( (bind( *fd, (struct sockaddr *) &servaddr, sizeof(servaddr) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupUdpServerSocket_7, P_WARNING, 0, "udp server socket bind fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
socklen_t len = sizeof(timeout);
if( setsockopt( *fd, SOL_SOCKET, SO_RCVTIMEO, (CHAR *) &timeout, len ) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_8, P_WARNING, 0, "Setsockopt failed - cancel receive timeout");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
// Put the connection into LISTEN state
if( (listen( *fd, IPERF_SERVER_MAX_LISTEN_NUM )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupTcpServerSocket_9, P_WARNING, 0, "iperf tcp server socket listen fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
return 0;
}
INT32 IperfSetupClientSocket(INT32 *fd, INT32 protocol, INT32 destPort, ip_addr_t *destAddr)
{
if(!fd)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_1, P_WARNING, 0, "IperfSetupClientSocket input fd point is invalid");
return NM_IPERF_PARAM_ERROR;
}
if(destAddr && (IP_IS_V4(destAddr) && !ip_addr_isany(destAddr)))
{
struct sockaddr_in servaddr;
// Create a new socket
if(protocol == IPERF_STREAM_PROTOCOL_TCP)
{
if( (*fd = socket( AF_INET, SOCK_STREAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_2, P_WARNING, 0, "iperf tcp client create ipv4 tcp socket fail");
return NM_IPERF_SOCKET_ERROR;
}
}
else if(protocol == IPERF_STREAM_PROTOCOL_UDP)
{
if( (*fd = socket( AF_INET, SOCK_DGRAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_3, P_WARNING, 0, "iperf tcp client create ipv4 udp socket fail");
return NM_IPERF_SOCKET_ERROR;
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_4, P_WARNING, 0, "IperfSetupClientSocket paramter invalid");
return NM_IPERF_PARAM_ERROR;
}
// Bind to port and IP
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
inet_addr_from_ip4addr(&servaddr.sin_addr, ip_2_ip4(destAddr));
servaddr.sin_port = htons( destPort );
if( (connect( *fd, (struct sockaddr *) &servaddr, sizeof(servaddr) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_5, P_WARNING, 0, "iperf tcp client socket connect fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}//ipv6 addr case
else if(destAddr && (IP_IS_V6(destAddr) && !ip_addr_isany(destAddr)))
{
struct sockaddr_in6 servaddr6;
// Create a new socket
if(protocol == IPERF_STREAM_PROTOCOL_TCP)
{
if( (*fd = socket( AF_INET6, SOCK_STREAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_6, P_WARNING, 0, "iperf tcp client create ipv6 tcp socket fail");
return NM_IPERF_SOCKET_ERROR;
}
}
else if(protocol == IPERF_STREAM_PROTOCOL_UDP)
{
if( (*fd = socket( AF_INET6, SOCK_DGRAM, 0 )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_7, P_WARNING, 0, "iperf tcp client create ipv6 udp socket fail");
return NM_IPERF_SOCKET_ERROR;
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_8, P_WARNING, 0, "IperfSetupClientSocket paramter invalid");
return NM_IPERF_PARAM_ERROR;
}
// Bind to port and IP
memset( &servaddr6, 0, sizeof(servaddr6) );
servaddr6.sin6_family = AF_INET6;
inet6_addr_from_ip6addr(&servaddr6.sin6_addr, ip_2_ip6(destAddr));
servaddr6.sin6_port = htons( destPort );
if( (connect( *fd, (struct sockaddr *) &servaddr6, sizeof(servaddr6) )) < 0 )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_9, P_WARNING, 0, "iperf tcp client socket connect fail");
close(*fd);
return NM_IPERF_SOCKET_ERROR;
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfSetupClientSocket_10, P_WARNING, 0, "IperfSetupClientSocket paramter invalid");
return NM_IPERF_PARAM_ERROR;
}
return 0;
}
INT32 IperfNatServerSendUdpPkg(INT32 sockfd, INT32 destPort, ip_addr_t *destAddr)
{
struct sockaddr_in cliaddr; //16 bytes
INT32 cliLen;
IperfUdpDatagram *udpHdr;
IperfClientHeader *clientHdr;
CHAR pBuf[IPERF_UDP_NAT_SERVER_SEND_PKT_LEN];
INT32 ret = -1;
OsaCheck(destAddr != NULL && sockfd >= 0, sockfd, destPort, destAddr);
if(!IP_IS_V4(destAddr) || ip_addr_isany(destAddr))
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfNatServerSendUdpPkg_1, P_WARNING, 0,
"IperfNatServerSendUdpPkg dst addr invalid");
return ret;
}
memset(pBuf, 0x00, IPERF_UDP_NAT_SERVER_SEND_PKT_LEN);
cliLen = sizeof(cliaddr);
memset(&cliaddr, 0, sizeof(cliaddr) );
cliaddr.sin_family = AF_INET;
if (destPort == 0 )
{
destPort = IPERF_DEFAULT_PORT;
}
cliaddr.sin_port = htons(destPort);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfNatServerSendUdpPkg_2, P_INFO, 1,
"Iperf, send one UDP pkg to dest port: %d", destPort);
inet_addr_from_ip4addr(&cliaddr.sin_addr, ip_2_ip4(destAddr));
// Init UDP data header
udpHdr = (IperfUdpDatagram *)&pBuf[0]; //12 bytes
udpHdr->pkgId = 0; //htonl(udpHdrId);
udpHdr->sec = htonl(200);
udpHdr->uSec = htonl(0);
clientHdr = (IperfClientHeader *) &pBuf[12]; //24bytes
clientHdr->flags = 0;
clientHdr->numChannels = htonl(1);
clientHdr->portClient = htonl(destPort);
clientHdr->buffLen = 0;
clientHdr->band = htonl(22000);
clientHdr->amounts = htonl( ~(long )(1000 * 100));
ret = sendto(sockfd, pBuf, IPERF_UDP_NAT_SERVER_SEND_PKT_LEN, 0, (struct sockaddr *)&cliaddr, cliLen);
return ret;
}
/******************************************************
* Function Definitions
******************************************************/
/* members are in network byte order */
void IperfUdpRunNatServer( void* arg )
{
NmIperfReq * serverParam = (NmIperfReq *)arg;
INT32 sockfd;
struct sockaddr_in cliaddr;
INT32 cliLen;
IperfCount pktCount = {0, 0, 0, 0, 0};
IperfCount tmpCount = {0, 0, 0, 0, 0};
INT32 nBytes = 0;
UINT32 intervalTag;
INT32 serverPort = 0;
UINT16 rcvTime;
UINT32 totalRptNum = 1;
UINT32 tmpRptNum = 0;
UINT32 rcvTimeout;
INT32 ret;
slpManRet_t pmuRet = RET_UNKNOW_FALSE;
UINT8 iperfPmuHdr = 0;
UINT32 t1,t1_ms,t2,t2_ms, currTime, offsetTime1;
IperfUdpDatagram *udpHdr;
IperfClientHeader *clientHdr;
IperfClientHeader clientHdrTrans;
INT32 isTestStarted = 0;
INT32 udpHdrId = 0;
struct NmAtiIperfResultIndTag nmIperfResult;
memset(&nmIperfResult, 0, sizeof(struct NmAtiIperfResultIndTag));
//init setting
if(serverParam->rptIntervalPresent && serverParam->rptIntervalS > 0)
{
intervalTag = serverParam->rptIntervalS;
}
else
{
intervalTag = IPERF_DEFAULT_REPORT_INTERVAL;
}
if(serverParam->durationPresent && serverParam->durationS > 0)
{
rcvTime = serverParam->durationS;
}
else
{
rcvTime = IPERF_MAX_SEND_RCV_TIME;
}
if(serverParam->port > 0)
{
serverPort = serverParam->port;
}
else
{
serverPort = IPERF_DEFAULT_PORT;
}
if (intervalTag < IPERF_SERVER_RECEIVE_TIMEOUT)
{
rcvTimeout = intervalTag;
}
else
{
rcvTimeout = IPERF_SERVER_RECEIVE_TIMEOUT;
}
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_1, P_SIG, 0, "iperf udp nat server task start runing");
//alloc rcv buffer
CHAR *buffer = (CHAR*) mallocEc( IPERF_TEST_BUFFER_SIZE );
if(!buffer)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_2, P_WARNING, 0, "malloc buffer fail");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_MALLOC_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
osThreadExit();
}
memset(buffer, 0 ,IPERF_TEST_BUFFER_SIZE);
//setup udp nat server socket
ret = IperfSetupUdpServerSocket(&sockfd, serverPort, rcvTimeout, &serverParam->destAddr, TRUE);
if (ret != 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_3, P_WARNING, 0, "setup udp nat server socket fail");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = ret;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
cliLen = sizeof(cliaddr);
/*
* start iperf, iperf task don't allow to enter HIB/Sleep2 state before iperf terminated
*/
pmuRet = slpManApplyPlatVoteHandle("iperfserver", &iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManPlatVoteDisableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
//fisrt send one UL pkg for NAT server
if(IperfNatServerSendUdpPkg(sockfd, serverPort, &serverParam->destAddr) < 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_11, P_WARNING, 0, "send one packet to client for NAT case fail");
}
IperfGetCurrentTime( &offsetTime1, 0 );
// Wait and check the request
do {
// Handles request
do {
//check cfun status first
if(!psDailBeCfun1State())
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_4, P_WARNING, 0, "Not CFUN1, iperf will terminal");
break;
}
nBytes = recvfrom(sockfd, buffer, IPERF_TEST_BUFFER_SIZE, 0, (struct sockaddr *) &cliaddr, (socklen_t *) &cliLen );
udpHdr = (IperfUdpDatagram *) buffer;
udpHdrId = (INT32) ntohl( udpHdr->pkgId );
pktCount = IperfCalculateResult( nBytes, pktCount, 0 );
if(nBytes > 0)
{
if(IP_IS_V4(&serverParam->destAddr))
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP4, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
else
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP6, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
}
//record the time when rcv the first packet
if( pktCount.times == 1 )
{
IperfGetCurrentTime( &t1, &t1_ms);
}
IperfGetCurrentTime( &currTime, 0 );
// Report every interval time
if( intervalTag > 0 )
{
if( currTime - offsetTime1 > 0 )
{
tmpRptNum = (((int)(currTime - offsetTime1)) / intervalTag);
if(tmpRptNum > 0)
{
if( tmpRptNum == totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/intervalTag);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_report_1, P_SIG, 2, "iperf UDP nat server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
else if(tmpRptNum > totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/(intervalTag *(tmpRptNum - totalRptNum + 1)));
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_report_2, P_SIG, 2, "iperf UDP nat server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
}
}
}
//rcv the fisrt valid udp packet
if( (isTestStarted == 0) && (udpHdrId > 0) && (nBytes > 0) )
{
isTestStarted = 1;
}//rcv the end udp packet
else if ( (udpHdrId < 0) && (isTestStarted == 1) )
{ // the last package
INT32 oldFlag = 0;
// print out result
//TODO: need to send the correct report to client-side, flag = 0 means the report is ignored.
//if( udpHdrId < 0 )
//{
oldFlag = clientHdrTrans.flags;
clientHdrTrans.flags = (INT32) 0;
// send the server report to client-side
sendto( sockfd, buffer, nBytes, 0, (struct sockaddr *) &cliaddr, cliLen );
clientHdrTrans.flags = oldFlag;
//}
clientHdr = (IperfClientHeader *) &buffer[12];
clientHdrTrans.flags = (INT32) (ntohl( clientHdr->flags ));
// Tradeoff mode
if( IPERF_HEADER_VERSION1 & clientHdrTrans.flags )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_6, P_WARNING, 0, "Tradeoff mode, client-side not support");
}
break;
}
//send one packet for NAT case,if rcv packet timeout
if(nBytes <= 0 && sock_get_errno(sockfd) == ETIME)
{
if(IperfNatServerSendUdpPkg(sockfd, serverPort, &serverParam->destAddr) < 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_7, P_WARNING, 0, "send one packet to client for NAT case fail");
}
else
{//if send fail,check whether need stop iperf server
if(bIperfSrvTerminRunning || currTime - offsetTime1 > rcvTime)
{
break;
}
else
{
continue;
}
}
}
//check whether rcv stop command
if(bIperfSrvTerminRunning)
{
break;
}
//check whether the total rcv timer timeout
if((currTime - offsetTime1 > rcvTime) && (currTime > offsetTime1))
{
break;
}
//check whether socket error and is not timeout
if( nBytes <= 0 && sock_get_errno(sockfd) != ETIME)
{
if(sock_get_errno(sockfd) != EHOSTUNREACH)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_8, P_WARNING, 0, "iperf UDP nat server socket rcv error");
break;
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_12, P_INFO, 0, "iperf UDP nat server ,maybe detach, try again");
}
}
}while(TRUE);
}while(FALSE);
// the end report
IperfGetCurrentTime( &t2, &t2_ms );
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_END_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes;
if(pktCount.times > 0)
{
if(t2 > t1)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8)/(t2 - t1));
}
else
{
if(t2_ms > t1_ms)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8 * 1000)/(t2_ms - t1_ms));
}
else
{
nmIperfResult.bandwidth = 0;
}
}
}
else
{
nmIperfResult.bandwidth = 0;
}
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_9, P_SIG, 2, "iperf UDP nat server report,TOTAL receive %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
close( sockfd );
freeEc( buffer );
bIperfSrvTerminRunning = 0;
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
/* before iperf task exit, should allow to enter HIB/Sleep2, and release hander */
pmuRet = slpManPlatVoteEnableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManGivebackPlatVoteHandle(iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunNatServer_10, P_SIG, 0, "iperf UDP nat server terminal");
osThreadExit();
}
void IperfUdpRunServer( void* arg )
{
NmIperfReq * serverParam = (NmIperfReq *)arg;
INT32 sockfd;
struct sockaddr_in cliaddr;
INT32 cliLen;
IperfCount pktCount = {0, 0, 0, 0, 0};
IperfCount tmpCount = {0, 0, 0, 0, 0};
INT32 nBytes = 0;
INT32 serverPort = 0;
UINT16 rcvTime;
UINT32 totalRptNum = 1;
UINT32 tmpRptNum = 0;
UINT32 intervalTag;
UINT32 rcvTimeout;
INT32 ret;
slpManRet_t pmuRet = RET_UNKNOW_FALSE;
UINT8 iperfPmuHdr = 0;
UINT32 t1,t1_ms,t2,t2_ms, currTime, offsetTime1;
IperfUdpDatagram *udpHdr;
IperfClientHeader *clientHdr;
IperfClientHeader clientHdrTrans;
int isTestStarted = 0;
INT32 udpHdrId = 0;
struct NmAtiIperfResultIndTag nmIperfResult;
memset(&nmIperfResult, 0, sizeof(struct NmAtiIperfResultIndTag));
//init setting
if(serverParam->rptIntervalPresent && serverParam->rptIntervalS > 0)
{
intervalTag = serverParam->rptIntervalS;
}
else
{
intervalTag = IPERF_DEFAULT_REPORT_INTERVAL;
}
if(serverParam->durationPresent && serverParam->durationS > 0)
{
rcvTime = serverParam->durationS;
}
else
{
rcvTime = IPERF_MAX_SEND_RCV_TIME;
}
if(serverParam->port > 0)
{
serverPort = serverParam->port;
}
else
{
serverPort = IPERF_DEFAULT_PORT;
}
if(intervalTag < IPERF_SERVER_RECEIVE_TIMEOUT)
{
rcvTimeout = intervalTag;
}
else
{
rcvTimeout = IPERF_SERVER_RECEIVE_TIMEOUT;
}
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_1, P_SIG, 0, "iperf udp server task start runing");
//init rcv buffer
CHAR *buffer = (CHAR*) mallocEc( IPERF_TEST_BUFFER_SIZE );
if(!buffer)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_2, P_WARNING, 0, "malloc buffer fail");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_MALLOC_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
osThreadExit();
}
memset(buffer, 0 ,IPERF_TEST_BUFFER_SIZE);
//setup udp server socket
ret = IperfSetupUdpServerSocket(&sockfd, serverPort, rcvTimeout, &serverParam->destAddr, FALSE);
if(ret != 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_3, P_WARNING, 0, "setup udp server socket fail");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = ret;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
cliLen = sizeof(cliaddr);
/*
* start iperf, iperf task don't allow to enter HIB/Sleep2 state before iperf terminated
*/
pmuRet = slpManApplyPlatVoteHandle("iperfserver", &iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManPlatVoteDisableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
IperfGetCurrentTime( &offsetTime1, 0 );
// Wait and check the request
do {
// Handles request
do {
//check cfun status first
if(!psDailBeCfun1State())
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_4, P_WARNING, 0, "Not CFUN1, iperf will terminal");
break;
}
nBytes = recvfrom( sockfd, buffer, IPERF_TEST_BUFFER_SIZE, 0, (struct sockaddr *) &cliaddr,
(socklen_t *) &cliLen );
udpHdr = (IperfUdpDatagram *) buffer;
udpHdrId = (INT32) ntohl( udpHdr->pkgId );
pktCount = IperfCalculateResult( nBytes, pktCount, 0 );
if(nBytes > 0)
{
if(IP_IS_V4(&serverParam->destAddr))
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP4, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
else
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP6, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
}
//record the time when rcv the first packet
if( pktCount.times == 1 )
{
IperfGetCurrentTime( &t1, &t1_ms );
}
IperfGetCurrentTime( &currTime, 0 );
// Report by second
if( intervalTag > 0 )
{
if( currTime - offsetTime1 > 0 )
{
tmpRptNum = (((int)(currTime - offsetTime1)) / intervalTag);
if(tmpRptNum > 0)
{
if( tmpRptNum == totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/intervalTag);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_report_1, P_SIG, 2, "iperf udp server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
else if(tmpRptNum > totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/(intervalTag *(tmpRptNum - totalRptNum + 1)));
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_report_2, P_SIG, 2, "iperf udp server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
}
}
}
//rcv the fisrt valid udp packet
if( (isTestStarted == 0) && (udpHdrId > 0) && (nBytes > 0) )
{
isTestStarted = 1;
}//rcf the last packet
else if ( (udpHdrId < 0) && (isTestStarted == 1) )
{ // the last package
INT32 oldFlag = 0;
// print out result
//TODO: need to send the correct report to client-side, flag = 0 means the report is ignored.
//if( udpHdrId < 0 )
//{
oldFlag = clientHdrTrans.flags;
clientHdrTrans.flags = (INT32) 0;
// send the server report to client-side
sendto( sockfd, buffer, nBytes, 0, (struct sockaddr *) &cliaddr, cliLen );
clientHdrTrans.flags = oldFlag;
//}
clientHdr = (IperfClientHeader *) &buffer[12];
clientHdrTrans.flags = (INT32) (ntohl( clientHdr->flags ));
// Tradeoff mode
if( IPERF_HEADER_VERSION1 & clientHdrTrans.flags )
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_6, P_WARNING, 0, "Tradeoff mode, client-side not support");
}
break;
}
//check whether rcv stop command
if(bIperfSrvTerminRunning)
{
break;
}
//check whether the total rcv timer timeout
if((currTime - offsetTime1 > rcvTime) && (currTime > offsetTime1))
{
break;
}
//check socket error and is not timeout
if( nBytes <= 0 && sock_get_errno(sockfd) != ETIME)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_7, P_WARNING, 0, "iperf UDP server socket rcv error");
break;
}
}while(TRUE);
} while (FALSE);
//the end report
IperfGetCurrentTime( &t2, &t2_ms );
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_END_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes;
if(pktCount.times > 0)
{
if(t2 > t1)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8)/(t2 - t1));
}
else
{
if(t2_ms > t1_ms)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8 * 1000)/(t2_ms - t1_ms));
}
else
{
nmIperfResult.bandwidth = 0;
}
}
}
else
{
nmIperfResult.bandwidth = 0;
}
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_8, P_SIG, 2, "iperf UDP server report,TOTAL receive %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
close( sockfd );
freeEc( buffer );
bIperfSrvTerminRunning = 0;
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
/* before iperf task exit, should allow to enter HIB/Sleep2, and release hander */
pmuRet = slpManPlatVoteEnableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManGivebackPlatVoteHandle(iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunServer_9, P_SIG, 0, "iperf UDP server terminal");
osThreadExit();
}
void IperfTcpRunServer( void *arg)
{
NmIperfReq * serverParam = (NmIperfReq *)arg;
INT32 listenfd, connfd;
struct sockaddr_in cliaddr;
socklen_t clilen;
INT32 serverPort;
IperfCount pktCount = {0, 0, 0, 0, 0};
IperfCount tmpCount = {0, 0, 0, 0, 0};
INT32 nBytes = 0;
UINT16 rcvTime;
UINT32 totalRptNum = 1;
UINT32 tmpRptNum = 0;
UINT32 intervalTag;
UINT32 rcvTimeout;
INT32 ret;
slpManRet_t pmuRet = RET_UNKNOW_FALSE;
UINT8 iperfPmuHdr = 0;
UINT32 t1,t1_ms,t2,t2_ms,currTime;
struct NmAtiIperfResultIndTag nmIperfResult;
memset(&nmIperfResult, 0, sizeof(struct NmAtiIperfResultIndTag));
//init setting
if(serverParam->rptIntervalPresent && serverParam->rptIntervalS > 0)
{
intervalTag = serverParam->rptIntervalS;
}
else
{
intervalTag = IPERF_DEFAULT_REPORT_INTERVAL;
}
if(serverParam->durationPresent && serverParam->durationS > 0)
{
rcvTime = serverParam->durationS;
}
else
{
rcvTime = IPERF_MAX_SEND_RCV_TIME;
}
if(serverParam->port > 0)
{
serverPort = serverParam->port;
}
else
{
serverPort = IPERF_DEFAULT_PORT;
}
if(intervalTag < IPERF_SERVER_RECEIVE_TIMEOUT)
{
rcvTimeout = intervalTag;
}
else
{
rcvTimeout = IPERF_SERVER_RECEIVE_TIMEOUT;
}
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_1, P_SIG, 0, "iperf tcp server task start runing");
//init rcv buffer
CHAR *buffer = (CHAR*) mallocEc( IPERF_TEST_BUFFER_SIZE );
if(!buffer)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_2, P_WARNING, 0, "IPERF tcp server malloc buffer fail!");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_MALLOC_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
osThreadExit();
}
// Create a new TCP connection handle
ret = IperfSetupTcpServerSocket(&listenfd, serverPort, rcvTimeout, &serverParam->destAddr);
if(ret != 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_3, P_WARNING, 0, "IPERF tcp server setup socket fail!");
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = ret;
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
/*
* start iperf, iperf task don't allow to enter HIB/Sleep2 state before iperf terminated
*/
pmuRet = slpManApplyPlatVoteHandle("iperfserver", &iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManPlatVoteDisableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
do {
do {
// ait for an incoming connection
if ( (connfd = accept( listenfd, (struct sockaddr *) &cliaddr, &clilen )) != -1 )
{
IperfGetCurrentTime( &t1, &t1_ms);
//Connection
do {
//check pdn status first
if(!psDailBeCfun1State())
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_4, P_WARNING, 0, "Not Cfun1, iperf will terminal");
break;
}
nBytes = recv( connfd, buffer, IPERF_TEST_BUFFER_SIZE, 0 );
pktCount = IperfCalculateResult( nBytes, pktCount, 0 );
if(nBytes > 0)
{
if(IP_IS_V4(&serverParam->destAddr))
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP4, IPERF_STREAM_PROTOCOL_TCP, pktCount);
}
else
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP6, IPERF_STREAM_PROTOCOL_TCP, pktCount);
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_5, P_WARNING, 0, "iperf tcp rcv fail");
}
IperfGetCurrentTime( &currTime, 0 );
if ( intervalTag > 0 )
{
if( currTime - t1 > 0 )
{
tmpRptNum = (((int)(currTime - t1)) / intervalTag);
if(tmpRptNum > 0)
{
if( tmpRptNum == totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/intervalTag);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_report_1, P_SIG, 2, "iperf tcp server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
else if(tmpRptNum > totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/(intervalTag *(tmpRptNum - totalRptNum + 1)));
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_report_2, P_SIG, 2, "iperf tcp server report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
}
}
}
// check whether rcv stop command
if(bIperfSrvTerminRunning)
{
break;
}
//check whether the total rcv timer timeout
if((currTime - t1 > rcvTime) && (currTime > t1))
{
break;
}
//check socket error and is not timeout
if( nBytes <= 0 && sock_get_errno(connfd) != ERR_TIMEOUT)
{
break;
}
}while(TRUE);
//if the connfd socket error, try accept again
close( connfd );
}
// check whether rcv stop command
if(bIperfSrvTerminRunning)
{
break;
}
//check whether the total rcv timer timeout
if((currTime - t1 > rcvTime) && (currTime > t1))
{
break;
}
}while(TRUE);
} while (FALSE); //Loop just once
//the end report
IperfGetCurrentTime( &t2, &t2_ms);
nmIperfResult.mode = NM_IPERF_MODE_SERVER;
nmIperfResult.result = NM_IPERF_END_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes;
if(pktCount.times > 0)
{
if(t2 > t1)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8)/(t2 - t1));
}
else
{
if(t2_ms > t1_ms)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8 * 1000)/(t2_ms - t1_ms));
}
else
{
nmIperfResult.bandwidth = 0;
}
}
}
else
{
nmIperfResult.bandwidth = 0;
}
AppMgrSendIperfResultInd(&nmIperfResult, serverParam->reqHandle);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_7, P_SIG, 2, "iperf tcp server report,TOTAL receive %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
close( listenfd );
freeEc( buffer );
bIperfSrvTerminRunning = 0;
iperfSrvTask = NULL;
bIperfSrvIsGoingOn = 0;
/* before iperf task exit, should allow to enter HIB/Sleep2, and release hander */
pmuRet = slpManPlatVoteEnableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManGivebackPlatVoteHandle(iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunServer_8, P_SIG, 0, "iperf tcp server terminal");
osThreadExit();
}
void IperfTcpRunClient( void* arg )
{
NmIperfReq *clientParam = (NmIperfReq *)arg;
INT32 sockfd;
IperfCount pktCount = {0, 0, 0, 0, 0};
IperfCount tmpCount = {0, 0, 0, 0, 0};
INT32 nBytes = 0;
INT32 winSize, sendTime, serverPort;
UINT32 t1,t1_ms,t2,t2_ms, currTime, bw, pktDelay = 0;
INT32 totalSend = 0x7FFFFFFF;
UINT32 totalRptNum = 1;
UINT32 tmpRptNum = 0;
INT32 ret;
INT32 sockErr;
BOOL bAlwaysSend = FALSE;
slpManRet_t pmuRet = RET_UNKNOW_FALSE;
UINT8 iperfPmuHdr = 0;
UINT32 intervalTag;
//Statistics init
struct NmAtiIperfResultIndTag nmIperfResult;
memset(&nmIperfResult, 0, sizeof(struct NmAtiIperfResultIndTag));
//init setting
if(clientParam->rptIntervalPresent && clientParam->rptIntervalS > 0)
{
intervalTag = clientParam->rptIntervalS; /* the tag of parameter "-i" */
}
else
{
intervalTag = IPERF_DEFAULT_REPORT_INTERVAL;
}
if(clientParam->payloadSizePresent && clientParam->payloadSize >= 36)
{
winSize = ((clientParam->payloadSize > IPERF_DEFAULT_PAYLOAD_SIZE) ? IPERF_DEFAULT_PAYLOAD_SIZE : clientParam->payloadSize);
}
else
{
winSize = IPERF_DEFAULT_PAYLOAD_SIZE;
}
if(clientParam->pkgNumPresent && clientParam->pkgNum > 0)
{
totalSend = clientParam->pkgNum * winSize; /* the total number of transmit */
}
else
{
// totalSend = IPERF_TOTAL_SEND_MAX;
bAlwaysSend = TRUE;
}
if(clientParam->durationPresent && clientParam->durationS > 0)
{
sendTime = clientParam->durationS;
}
else
{
sendTime = IPERF_MAX_SEND_RCV_TIME;
}
if(clientParam->port > 0)
{
serverPort = clientParam->port;
}
else
{
serverPort = IPERF_DEFAULT_PORT;
}
if (clientParam->tptPresent && clientParam->tpt > 0)
{
/* the input is bps, but bw is Bps (bytes per second)*/
if ((clientParam->tpt) & 0x07)
{
bw = ((clientParam->tpt) >> 3) + 1;
}
else
{
bw = (clientParam->tpt) >> 3;
}
}
else
{
bw = IPERF_DEFAULT_TPT; //8bps
}
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_1, P_SIG, 0, "iperf tcp client task start runing");
//init send buffer
CHAR *buffer = (CHAR*) mallocEc( winSize );
if(!buffer)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_2, P_WARNING, 0, "iperf tcp client malloc buffer fail");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_MALLOC_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
osThreadExit();
}
//calc the send packet delay depend on bw setting
if ( bw > 0 )
{
pktDelay = (1000 * winSize) / bw;
}
//setup socket connection
if(clientParam->destAddrPresent)
{
ret = IperfSetupClientSocket(&sockfd, IPERF_STREAM_PROTOCOL_TCP, serverPort, &clientParam->destAddr);
if(ret != 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_3, P_WARNING, 0, "iperf tcp client socket setup fail");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = ret;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_4, P_WARNING, 0, "iperf tcp client dest addr is not present");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_PARAM_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
/*
* start iperf, iperf task don't allow to enter HIB/Sleep2 state before iperf terminated
*/
pmuRet = slpManApplyPlatVoteHandle("iperfclient", &iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManPlatVoteDisableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
IperfGetCurrentTime( &t1, &t1_ms);
do {
//check pdn status first
if(!psDailBeCfun1State())
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_5, P_WARNING, 0, "Not CFUN1 state, iperf will terminal");
break;
}
nBytes = send( sockfd, buffer, winSize, 0 );
pktCount = IperfCalculateResult( nBytes, pktCount, 0 );
if(nBytes > 0)
{
if(IP_IS_V4(&clientParam->destAddr))
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP4, IPERF_STREAM_PROTOCOL_TCP, pktCount);
}
else
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP6, IPERF_STREAM_PROTOCOL_TCP, pktCount);
}
}
else
{
sockErr = sock_get_errno(sockfd);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_6, P_ERROR, 1, "iperf tcp client send packet fail,error code %d", sockErr);
if(socket_error_is_fatal(sockErr))
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_7, P_ERROR, 1, "iperf tcp client send packet fail,the error %d is fata error ,exist", sockErr);
break;
}
}
IperfmSleep( pktDelay );
IperfGetCurrentTime( &currTime, 0 );
if ( intervalTag > 0 )
{
if( currTime - t1 > 0 )
{
tmpRptNum = (((int)(currTime - t1)) / intervalTag);
if(tmpRptNum > 0)
{
if( tmpRptNum == totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/intervalTag);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_report_1, P_SIG, 2, "iperf tcp client report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
else if(tmpRptNum > totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/(intervalTag *(tmpRptNum - totalRptNum + 1)));
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_report_2, P_SIG, 2, "iperf tcp client report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
}
}
}
//check whether packet has send complete
if(bAlwaysSend == FALSE)
{
if(nBytes > 0)
{
totalSend -= nBytes;
}
if(totalSend <= 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_9, P_SIG, 0, "iperf tcp client send total packet finish");
break;
}
}
//check whether rcv stop command
if(bIperfCltTerminRunning)
{
break;
}
//check whether the total send timer timeout
if((currTime - t1 > sendTime) && (currTime > t1))
{
break;
}
} while(TRUE);
//the end report
IperfGetCurrentTime( &t2, &t2_ms);
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_END_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes;
if(pktCount.times > 0) {
if(t2 > t1)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8)/(t2-t1));
}
else
{
if(t2_ms > t1_ms)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8 * 1000)/(t2_ms-t1_ms));
}
else
{
nmIperfResult.bandwidth = 0;
}
}
}
else
{
nmIperfResult.bandwidth = 0;
}
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_10, P_SIG, 2, "iperf tcp client report,TOTAL send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
close( sockfd );
freeEc(buffer);
bIperfCltTerminRunning = 0;
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
/* before iperf task exit, should allow to enter HIB/Sleep2, and release hander */
pmuRet = slpManPlatVoteEnableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManGivebackPlatVoteHandle(iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfTcpRunClient_11, P_SIG, 0, "iperf tcp client terminal");
osThreadExit();
}
void IperfUdpRunClient( void* arg )
{
NmIperfReq *clientParam = (NmIperfReq *)arg;
INT32 sockfd;
INT32 ret;
IperfCount pktCount = {0, 0, 0, 0, 0};
IperfCount tmpCount = {0, 0, 0, 0, 0};
INT32 nBytes = 0;
INT32 tradeoffTag = FALSE;
UINT32 dataSize, sendTime, serverPort;
UINT32 pktDelay = 0;
UINT32 pktDelayOffset = 0;
UINT32 totalRptNum = 1;
UINT32 tmpRptNum = 0;
UINT32 bw; //bandwidth, in Bps (Bytes per second)
UINT32 t1, t2, currTime, t1_ms,t2_ms,lastTick, currentTick, lastSleep, currentSleep = 0;
INT32 totalSend = 0x7FFFFFFF;
INT32 sockErr = 0, lastErr = 0;
BOOL bAlwaysSend = FALSE;
IperfUdpDatagram *udpHdr;
IperfClientHeader *clientHdr;
INT32 udpHdrId = 0;
slpManRet_t pmuRet = RET_UNKNOW_FALSE;
UINT8 iperfPmuHdr = 0;
UINT32 intervalTag;
struct NmAtiIperfResultIndTag nmIperfResult;
memset(&nmIperfResult, 0, sizeof(struct NmAtiIperfResultIndTag));
//init setting
if (clientParam->rptIntervalPresent && clientParam->rptIntervalS > 0)
{
intervalTag = clientParam->rptIntervalS;
}
else
{
intervalTag = IPERF_DEFAULT_REPORT_INTERVAL;
}
if (clientParam->payloadSizePresent && clientParam->payloadSize >= 36)
{
dataSize = ((clientParam->payloadSize > IPERF_DEFAULT_PAYLOAD_SIZE) ? IPERF_DEFAULT_PAYLOAD_SIZE : clientParam->payloadSize);
}
else
{
dataSize = IPERF_DEFAULT_PAYLOAD_SIZE;
}
if (clientParam->pkgNumPresent && clientParam->pkgNum > 0)
{
totalSend = clientParam->pkgNum * dataSize;
}
else
{
// totalSend = IPERF_TOTAL_SEND_MAX;
bAlwaysSend = TRUE;
}
if (clientParam->durationPresent && clientParam->durationS > 0)
{
sendTime = clientParam->durationS;
}
else
{
sendTime = IPERF_MAX_SEND_RCV_TIME;
}
if (clientParam->port > 0)
{
serverPort = clientParam->port;
}
else
{
serverPort = IPERF_DEFAULT_PORT;
}
if (clientParam->tptPresent && clientParam->tpt > 0)
{
/* the input is bps, but bw is Bps (bytes per second)*/
if ((clientParam->tpt) & 0x07)
{
bw = ((clientParam->tpt) >> 3) + 1;
}
else
{
bw = (clientParam->tpt) >> 3;
}
}
else
{
bw = IPERF_DEFAULT_TPT; //1KBps
}
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_1, P_SIG, 0, "iperf udp client task start runing");
//init send buffer
CHAR *buffer = (CHAR*) mallocEc(dataSize);
if(!buffer)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_2, P_WARNING, 0, "iperf udp client malloc buffer fail");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_MALLOC_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
osThreadExit();
}
memset(buffer, 0, dataSize);
//calc the send packet delay depend on the bw setting
if (bw > 0)
{
pktDelay = (1000 * dataSize)/bw;
// pkt_dalay add 1ms regularly to reduce the offset
pktDelayOffset = (((1000 * dataSize) % bw) * 10 / bw);
if( pktDelayOffset )
{
pktDelayOffset = 10 / pktDelayOffset;
}
}
//setup socket connection
if (clientParam->destAddrPresent)
{
ret = IperfSetupClientSocket(&sockfd, IPERF_STREAM_PROTOCOL_UDP, serverPort, &clientParam->destAddr);
if(ret != 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_3, P_WARNING, 0, "iperf udp client socket setup fail");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = ret;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
//enable udp socket high water without delay retry for iperf udp client service
UINT32 hwwdr = 1;
ioctl(sockfd, FIOHWODR, &hwwdr);
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_4, P_WARNING, 0, "iperf udp client dest addr is not present");
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_PARAM_ERROR;
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
freeEc(buffer);
osThreadExit();
}
// Init UDP data header
udpHdr = (IperfUdpDatagram *) &buffer[0];
clientHdr = (IperfClientHeader *) &buffer[12];
if( tradeoffTag == TRUE )
{
clientHdr->flags = htonl( IPERF_HEADER_VERSION1 );
}
else
{
clientHdr->flags = 0;
}
clientHdr->numChannels = htonl( 1 );
clientHdr->portClient = htonl( serverPort );
clientHdr->buffLen = 0;
clientHdr->band = htonl(bw);
clientHdr->amounts = htonl((long )(sendTime * 100));
clientHdr->amounts &= htonl(0x7FFFFFFF);
/*
* start iperf, iperf task don't allow to enter HIB/Sleep2 state before iperf terminated
*/
pmuRet = slpManApplyPlatVoteHandle("iperfclient", &iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManPlatVoteDisableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
IperfGetCurrentTime( &t1, &t1_ms );
lastTick = t1_ms;
lastSleep = 0;
do {
//check pdn status first
if(!psDailBeCfun1State())
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_5, P_WARNING, 0, "Not cfun1 state, iperf will terminal");
break;
}
udpHdr->pkgId = htonl( udpHdrId );
udpHdr->sec = htonl( (lastTick + lastSleep) / 1000 );
udpHdr->uSec = htonl( lastTick + lastSleep );
udpHdrId++;
nBytes = send(sockfd, buffer, dataSize, 0);
pktCount = IperfCalculateResult( nBytes, pktCount, 0 );
if (nBytes > 0)
{
lastErr = 0;
if(IP_IS_V4(&clientParam->destAddr))
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP4, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
else
{
pktCount = IperfCalculateAddHeader(IPERF_STREAM_DOMAIN_IP6, IPERF_STREAM_PROTOCOL_UDP, pktCount);
}
}
else
{
sockErr = sock_get_errno(sockfd);
/* reduce some warning print */
if (lastErr != sockErr)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_6, P_ERROR, 1,
"iperf udp client send packet fail, error code: %d", sockErr);
lastErr = sockErr;
}
if (socket_error_is_fatal(sockErr))
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_7, P_ERROR, 1, "iperf udp client send packet fail,the error %d is fata error ,exist", sockErr);
break;
}
}
IperfGetCurrentTime(&currTime, &currentTick);
if (pktDelayOffset > 0)
{
if ((udpHdrId % pktDelayOffset) == 0)
{
currentSleep = pktDelay - (currentTick - lastTick - lastSleep) + 1;
}
}
else
{
currentSleep = pktDelay - (currentTick - lastTick - lastSleep);
}
if ((INT32)currentSleep > 0)
{
IperfmSleep( currentSleep );
}
else
{
currentSleep = 0;
}
lastTick = currentTick;
lastSleep = currentSleep;
if (intervalTag > 0)
{
if( currTime - t1 > 0 )
{
tmpRptNum = (((int)(currTime - t1)) / intervalTag);
if(tmpRptNum > 0)
{
if( tmpRptNum == totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/intervalTag);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_report_1, P_SIG, 2, "iperf udp client report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
else if(tmpRptNum > totalRptNum)
{
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_ONE_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes - tmpCount.Bytes;
nmIperfResult.bandwidth = (((pktCount.Bytes - tmpCount.Bytes) * 8)/(intervalTag *(tmpRptNum - totalRptNum + 1)));
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_report_2, P_SIG, 2, "iperf udp client report,send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
tmpCount = IperfCopyCount( pktCount, tmpCount );
totalRptNum = tmpRptNum + 1;
}
}
}
}
//check whether packet has sent complete
if(bAlwaysSend == FALSE)
{
if(nBytes > 0)
{
totalSend -= nBytes;
}
if(totalSend <= 0)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_9, P_SIG, 0, "iperf udp client send total packet finish");
break;
}
}
//check whether rcv stop command
if(bIperfCltTerminRunning)
{
break;
}
//check whether the total send timer timeout
if((currTime - t1 > sendTime) && (currTime > t1))
{
break;
}
} while(TRUE);
//the total end report
IperfGetCurrentTime( &t2, &t2_ms );
nmIperfResult.mode = NM_IPERF_MODE_CLIENT;
nmIperfResult.result = NM_IPERF_END_REPORT_SUCCESS;
nmIperfResult.dataNum = pktCount.Bytes;
if(pktCount.times > 0)
{
if(t2 > t1)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8)/(t2-t1));
}
else
{
if(t2_ms > t1_ms)
{
nmIperfResult.bandwidth = ((pktCount.Bytes * 8 * 1000)/(t2_ms-t1_ms));
}
else
{
nmIperfResult.bandwidth = 0;
}
}
}
else
{
nmIperfResult.bandwidth = 0;
}
AppMgrSendIperfResultInd(&nmIperfResult, clientParam->reqHandle);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_10, P_SIG, 2, "iperf udp client report,TOTAL send %u bytes payload packet, bandwidth %u bps", nmIperfResult.dataNum, nmIperfResult.bandwidth);
// send the last datagram
udpHdrId = (-udpHdrId);
udpHdr->pkgId = htonl( udpHdrId );
IperfGetCurrentTime( &currTime, 0 );
udpHdr->sec = htonl( currTime );
udpHdr->uSec = htonl( currTime * 1000 );
nBytes = send( sockfd, buffer, dataSize, 0 );
//TODO: receive the report from server side and print out
close( sockfd );
freeEc( buffer );
bIperfCltTerminRunning = 0;
iperfCLtTask = NULL;
bIperfCltIsGoingOn = 0;
/* before iperf task exit, should allow to enter HIB/Sleep2, and release hander */
pmuRet = slpManPlatVoteEnableSleep(iperfPmuHdr, SLP_SLP2_STATE);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
pmuRet = slpManGivebackPlatVoteHandle(iperfPmuHdr);
OsaCheck(pmuRet == RET_TRUE, pmuRet, 0, 0);
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfUdpRunClient_11, P_SIG, 0, "iperf udp client terminal");
osThreadExit();
}
IperfCount IperfCalculateResult( INT32 pktSize, IperfCount pktCount, INT32 needToConvert )
{
if ( pktSize > 0 ) {
pktCount.Bytes += pktSize;
pktCount.times++;
}
if ( needToConvert == 1 ) {
if ( pktCount.Bytes >= 1024 ) {
pktCount.KBytes += (pktCount.Bytes / 1024);
pktCount.Bytes = pktCount.Bytes % 1024;
}
if ( pktCount.KBytes >= 1024 ) {
pktCount.MBytes += (pktCount.KBytes / 1024);
pktCount.KBytes = pktCount.KBytes % 1024;
}
if ( pktCount.MBytes >= 1024 ) {
pktCount.GBytes += (pktCount.MBytes / 1024);
pktCount.MBytes = pktCount.MBytes % 1024;
}
}
return pktCount;
}
IperfCount IperfCalculateAddHeader( INT32 domain, INT32 protocol, IperfCount pktCount )
{
if(domain == IPERF_STREAM_DOMAIN_IP4)
{
pktCount.Bytes += 20;
}else if(domain == IPERF_STREAM_DOMAIN_IP6) {
pktCount.Bytes += 40;
}
if(protocol == IPERF_STREAM_PROTOCOL_UDP)
{
pktCount.Bytes += 8;
}else if(protocol == IPERF_STREAM_PROTOCOL_TCP) {
pktCount.Bytes += 20;
}
return pktCount;
}
IperfCount IperfResetCount( IperfCount pktCount )
{
pktCount.Bytes = 0;
pktCount.KBytes = 0;
pktCount.MBytes = 0;
pktCount.GBytes = 0;
pktCount.times = 0;
return pktCount;
}
IperfCount IperfCopyCount( IperfCount pktCount, IperfCount tmpCount )
{
tmpCount.Bytes = pktCount.Bytes;
tmpCount.KBytes = pktCount.KBytes;
tmpCount.MBytes = pktCount.MBytes;
tmpCount.GBytes = pktCount.GBytes;
tmpCount.times = pktCount.times;
return tmpCount;
}
IperfCount IperfDiffCount( IperfCount pktCount, IperfCount tmpCount )
{
/* pktCount > tmpCount */
tmpCount.times = pktCount.times - tmpCount.times;
if ( pktCount.Bytes >= tmpCount.Bytes ) {
tmpCount.Bytes = pktCount.Bytes - tmpCount.Bytes;
} else {
tmpCount.Bytes = pktCount.Bytes + 1024 - tmpCount.Bytes;
if ( pktCount.KBytes > 0 ) {
pktCount.KBytes--;
} else if ( pktCount.MBytes > 0 ) {
pktCount.MBytes--;
pktCount.KBytes = 1023;
} else if ( pktCount.GBytes > 0 ) {
pktCount.GBytes--;
pktCount.MBytes = 1023;
pktCount.KBytes = 1023;
}
}
if ( pktCount.KBytes >= tmpCount.KBytes ) {
tmpCount.KBytes = pktCount.KBytes - tmpCount.KBytes;
} else {
tmpCount.KBytes = pktCount.KBytes + 1024 - tmpCount.KBytes;
if ( pktCount.MBytes > 0 ) {
pktCount.MBytes--;
} else if ( pktCount.GBytes > 0 ) {
pktCount.GBytes--;
pktCount.MBytes = 1023;
}
}
if ( pktCount.MBytes >= tmpCount.MBytes ) {
tmpCount.MBytes = pktCount.MBytes - tmpCount.MBytes;
} else {
tmpCount.MBytes = pktCount.MBytes + 1024 - tmpCount.MBytes;
if ( pktCount.GBytes > 0 ) {
pktCount.GBytes--;
}
}
return tmpCount;
}
BOOL IperfInit(NmIperfReq *pIperfReq)
{
osThreadId_t xReturn = NULL;
osThreadAttr_t attr;
CHAR pcNameClient[] = "iperf_c";
CHAR pcNameServer[] = "iperf_s";
OsaDebugBegin(pIperfReq != PNULL, pIperfReq, 0, 0);
return FALSE;
OsaDebugEnd();
//check iperf task running status
if (pIperfReq->reqAct == NM_IPERF_START_CLIENT)
{
if (bIperfCltIsGoingOn)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_1, P_WARNING, 0, "iperf client is going on,please run it wait a moment");
return FALSE;
}
else
{
bIperfCltIsGoingOn = TRUE;
}
}
else if(pIperfReq->reqAct == NM_IPERF_START_SERVER || pIperfReq->reqAct == NM_IPERF_START_UDP_NAT_SERVER)
{
if (bIperfSrvIsGoingOn)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_2, P_WARNING, 0, "iperf server is going on,please run it wait a moment");
return FALSE;
}
else
{
bIperfSrvIsGoingOn = TRUE;
}
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_3, P_WARNING, 0, "iperf mode is invalid");
return FALSE;
}
//set task attr
memset(&attr, 0, sizeof(osThreadAttr_t));
attr.name = ((pIperfReq->reqAct == NM_IPERF_START_CLIENT) ? pcNameClient : pcNameServer);
attr.stack_size = IPERF_THREAD_STACKSIZE;
attr.priority = (osPriority_t)IPERF_THREAD_PRIO;
#ifdef TYPE_EC718M
attr.reserved = osThreadDynamicStackAlloc;
#endif
//setup iperf task
if(pIperfReq->reqAct == NM_IPERF_START_CLIENT)
{
memcpy(&pIperfClientReq, pIperfReq, sizeof(NmIperfReq));
if (pIperfReq->protocol == NM_IPERF_PROTOCOL_UDP)
{ //udp
xReturn = osThreadNew(IperfUdpRunClient, (void*)&pIperfClientReq, &attr);
}
else if (pIperfReq->protocol == NM_IPERF_PROTOCOL_TCP)
{ //tcp
xReturn = osThreadNew(IperfTcpRunClient, (void*)&pIperfClientReq, &attr);
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_4, P_WARNING, 0, "iperf protocol is invalid");
bIperfCltIsGoingOn = FALSE;
return FALSE;
}
if (xReturn == NULL)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_5, P_WARNING, 0, "can not create iperf task");
bIperfCltIsGoingOn = FALSE;
return FALSE;
}
else
{
iperfCLtTask = xReturn;
}
}
else if(pIperfReq->reqAct == NM_IPERF_START_SERVER)
{
memcpy(&pIperfServerReq, pIperfReq, sizeof(NmIperfReq));
if (pIperfReq->protocol == NM_IPERF_PROTOCOL_UDP)
{ //udp
xReturn = osThreadNew(IperfUdpRunServer, (void*)&pIperfServerReq, &attr);
}
else if (pIperfReq->protocol == NM_IPERF_PROTOCOL_TCP)
{ //tcp
xReturn = osThreadNew(IperfTcpRunServer, (void*)&pIperfServerReq, &attr);
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_6, P_WARNING, 0, "iperf protocol is invalid");
bIperfSrvIsGoingOn = FALSE;
return FALSE;
}
if (xReturn == NULL)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_7, P_WARNING, 0, "can not create iperf task");
bIperfSrvIsGoingOn = FALSE;
return FALSE;
}
else
{
iperfSrvTask = xReturn;
}
}
else if(pIperfReq->reqAct == NM_IPERF_START_UDP_NAT_SERVER)
{
memcpy(&pIperfServerReq, pIperfReq, sizeof(NmIperfReq));
if (pIperfReq->protocol == IPERF_STREAM_PROTOCOL_UDP)
{ //udp
xReturn = osThreadNew(IperfUdpRunNatServer, (void*)&pIperfServerReq, &attr);
}
else
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_6, P_WARNING, 0, "iperf protocol is invalid");
bIperfSrvIsGoingOn = FALSE;
return FALSE;
}
if (xReturn == NULL)
{
ECOMM_TRACE(UNILOG_TCPIP_APP, IperfInit_7, P_WARNING, 0, "can not create iperf task");
bIperfSrvIsGoingOn = FALSE;
return FALSE;
}
else
{
iperfSrvTask = xReturn;
}
}
return TRUE;
}
void IperfTerminate(NmIperfReq *pIperfReq)
{
OsaDebugBegin(pIperfReq != PNULL, pIperfReq, 0, 0);
return;
OsaDebugEnd();
switch(pIperfReq->reqAct)
{
case NM_IPERF_STOP_ALL:
{
if(iperfCLtTask)
{
bIperfCltTerminRunning = 1;
}
if(iperfSrvTask)
{
bIperfSrvTerminRunning = 1;
}
break;
}
case NM_IPERF_STOP_CLIENT:
{
if(iperfCLtTask)
{
bIperfCltTerminRunning = 1;
}
break;
}
case NM_IPERF_STOP_SERVER:
{
if(iperfSrvTask)
{
bIperfSrvTerminRunning = 1;
}
break;
}
default:
break;
}
return;
}
Reference in New Issue Copy Permalink