2452 lines
76 KiB
C
2452 lines
76 KiB
C
#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, ¤tTick);
|
|
|
|
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;
|
|
}
|
|
|
|
|