j3d1/sdk-ameba-v4.0b_without_nda_gcc
1
0
Fork 0
mirror of https://github.com/cwyark/sdk-ameba-v4.0b_without_nda_gcc.git synced 2024-11-22 05:54:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
sdk-ameba-v4.0b_without_nda.../component/common/utilities/tcptest.c

1119 lines
37 KiB
C
Raw Permalink Normal View History

Initial commit
2017-10-15 06:36:37 +00:00
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include <lwip/sockets.h>
#include <lwip/raw.h>
#include <lwip/icmp.h>
#include <lwip/inet_chksum.h>
#include <platform/platform_stdlib.h>
#define BSD_STACK_SIZE 256
#define DEFAULT_PORT 5001
#define DEFAULT_TIME 10
#define SERVER_BUF_SIZE 1500
#define CLIENT_BUF_SIZE 1460
#define KB 1024
#define MB 1048576//1024*1024
#define DEFAULT_UDP_BANDWIDTH 131072 //128*1024Bytes = 1Mbits
#define DEFAULT_REPORT_INTERVAL 0xffffffff
#define DEFAULT_UDP_TOS_VALUE 96 // BE=96
struct iperf_data_t{
uint64_t total_size;
uint64_t bandwidth;
int server_fd;
int client_fd;
uint32_t buf_size;
uint32_t time;
uint32_t report_interval;
uint16_t port;
uint8_t server_ip[16];
uint8_t start;
uint8_t tos_value;
};
struct iperf_tcp_client_hdr{
uint32_t flags;
uint32_t numThreads;
uint32_t mPort;
uint32_t bufferlen;
uint32_t mWinband;
uint32_t mAmount;
};
struct iperf_udp_client_hdr{
uint32_t id;
uint32_t tv_sec;
uint32_t tv_usec;
uint32_t flags;
uint32_t numThreads;
uint32_t mPort;
uint32_t bufferlen;
uint32_t mWinband;
uint32_t mAmount;
};
struct iperf_data_t tcp_server_data,tcp_client_data,udp_server_data,udp_client_data;
xTaskHandle g_tcp_server_task = NULL;
xTaskHandle g_tcp_client_task = NULL;
xTaskHandle g_udp_client_task = NULL;
xTaskHandle g_udp_server_task = NULL;
unsigned char g_tcp_terminate = 0;
unsigned char g_udp_terminate = 0;
unsigned char g_tcp_bidirection = 0;
unsigned char g_udp_bidirection = 0;
char *tcp_client_buffer = NULL;
char *tcp_server_buffer = NULL;
char *udp_client_buffer = NULL;
char *udp_server_buffer = NULL;
static void udp_client_handler(void *param);
static void tcp_client_handler(void *param);
int tcp_client_func(struct iperf_data_t iperf_data)
{
struct sockaddr_in ser_addr;
int i=0;
uint32_t start_time, end_time, bandwidth_time, report_start_time;
uint64_t total_size=0, bandwidth_size=0, report_size=0;
struct iperf_tcp_client_hdr client_hdr;
// for internal tese
iperf_data.bandwidth = 0;
tcp_client_buffer = pvPortMalloc(iperf_data.buf_size);
if(!tcp_client_buffer){
printf("\n\r[ERROR] %s: Alloc buffer failed",__func__);
goto Exit2;
}
//filling the buffer
for (i = 0; i < iperf_data.buf_size; i++)
tcp_client_buffer[i] = (char)(i % 10);
//create socket
if( (iperf_data.client_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
printf("\n\r[ERROR] %s: Create TCP socket failed",__func__);
goto Exit2;
}
//initialize value in dest
memset(&ser_addr, 0, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(iperf_data.port);
ser_addr.sin_addr.s_addr = inet_addr(iperf_data.server_ip);
printf("\n\r%s: Server IP=%s, port=%d", __func__,iperf_data.server_ip, iperf_data.port);
printf("\n\r%s: Create socket fd = %d", __func__,iperf_data.client_fd);
//Connecting to server
if( connect(iperf_data.client_fd, (struct sockaddr*)&ser_addr, sizeof(ser_addr)) < 0){
printf("\n\r[ERROR] %s: Connect to server failed",__func__);
goto Exit1;
}
printf("\n\r%s: Connect to server successfully",__func__);
// For "iperf -d" command, send first packet with iperf client header
if(g_tcp_bidirection){
client_hdr.flags = 0x01000080;
client_hdr.numThreads = 0x01000000;
client_hdr.mPort = htonl(iperf_data.port);
client_hdr.bufferlen = 0;
client_hdr.mWinband = 0;
client_hdr.mAmount = htonl (~(iperf_data.time*100) + 1);
if( send(iperf_data.client_fd, (char*) &client_hdr, sizeof(client_hdr),0) <= 0){
printf("\n\r[ERROR] %s: TCP client send data error",__func__);
goto Exit1;
}
}
if(iperf_data.total_size == 0){
start_time = xTaskGetTickCount();
end_time = start_time;
bandwidth_time = start_time;
report_start_time = start_time;
while ( ((end_time - start_time) <= (configTICK_RATE_HZ * iperf_data.time)) && (!g_tcp_terminate) ) {
if( send(iperf_data.client_fd, tcp_client_buffer, iperf_data.buf_size,0) <= 0){
printf("\n\r[ERROR] %s: TCP client send data error",__func__);
goto Exit1;
}
total_size+=iperf_data.buf_size;
bandwidth_size+=iperf_data.buf_size;
report_size+=iperf_data.buf_size;
end_time = xTaskGetTickCount();
if( (iperf_data.bandwidth != 0) && (bandwidth_size >= iperf_data.bandwidth) && ((end_time - bandwidth_time) < (configTICK_RATE_HZ*1)) ){
vTaskDelay(configTICK_RATE_HZ * 1 - (end_time - bandwidth_time));
end_time = xTaskGetTickCount();
bandwidth_time = end_time;
bandwidth_size = 0;
}
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval))){
printf("\n\r%s: Send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
bandwidth_time = end_time;
report_size = 0;
bandwidth_size = 0;
}
}
}
else{
start_time = xTaskGetTickCount();
end_time = start_time;
bandwidth_time = start_time;
report_start_time = start_time;
while ( (total_size < iperf_data.total_size) && (!g_tcp_terminate) ) {
if( send(iperf_data.client_fd, tcp_client_buffer, iperf_data.buf_size,0) <= 0){
printf("\n\r[ERROR] %s: TCP client send data error",__func__);
goto Exit1;
}
total_size+=iperf_data.buf_size;
bandwidth_size+=iperf_data.buf_size;
report_size+=iperf_data.buf_size;
end_time = xTaskGetTickCount();
if( (iperf_data.bandwidth != 0) && (bandwidth_size >= iperf_data.bandwidth) && ((end_time - bandwidth_time) < (configTICK_RATE_HZ*1)) ){
vTaskDelay(configTICK_RATE_HZ * 1 - (end_time - bandwidth_time));
end_time = xTaskGetTickCount();
bandwidth_time = end_time;
bandwidth_size = 0;
}
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval))) {
printf("\n\r%s: Send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
bandwidth_time = end_time;
report_size = 0;
bandwidth_size = 0;
}
}
}
printf("\n\r%s: [END] Totally send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(total_size/KB),(uint32_t)(end_time-start_time),((uint32_t)(total_size*8)/(end_time - start_time)));
Exit1:
closesocket(iperf_data.client_fd);
Exit2:
printf("\n\r%s: Close client socket",__func__);
if(tcp_client_buffer){
vPortFree(tcp_client_buffer);
tcp_client_buffer = NULL;
}
return 0;
}
int tcp_server_func(struct iperf_data_t iperf_data)
{
struct sockaddr_in ser_addr , client_addr;
int addrlen = sizeof(struct sockaddr_in);
int n = 1;
int recv_size=0;
uint64_t total_size=0,report_size=0;
uint32_t start_time, report_start_time, end_time;
struct iperf_tcp_client_hdr client_hdr;
tcp_server_buffer = pvPortMalloc(iperf_data.buf_size);
if(!tcp_server_buffer){
printf("\n\r[ERROR] %s: Alloc buffer failed",__func__);
goto Exit3;
}
//create socket
if((iperf_data.server_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
printf("\n\r[ERROR] %s: Create socket failed",__func__);
goto Exit3;
}
printf("\n\r%s: Create socket fd = %d", __func__,iperf_data.server_fd);
setsockopt( iperf_data.server_fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &n, sizeof( n ) );
//initialize structure dest
memset(&ser_addr, 0, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(iperf_data.port);
ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
// binding the TCP socket to the TCP server address
if( bind(iperf_data.server_fd, (struct sockaddr*)&ser_addr, sizeof(ser_addr)) < 0){
printf("\n\r[ERROR] %s: Bind socket failed",__func__);
goto Exit2;
}
printf("\n\r%s: Bind socket successfully",__func__);
//Make it listen to socket with max 20 connections
if( listen(iperf_data.server_fd, 20) != 0){
printf("\n\r[ERROR] %s: Listen socket failed",__func__);
goto Exit2;
}
printf("\n\r%s: Listen port %d",__func__,iperf_data.port);
Restart:
if( (iperf_data.client_fd = accept(iperf_data.server_fd, (struct sockaddr*)&client_addr, &addrlen)) < 0){
printf("\n\r[ERROR] %s: Accept TCP client socket error!",__func__);
goto Exit2;
}
printf("\n\r%s: Accept connection successfully",__func__);
recv_size = recv(iperf_data.client_fd, tcp_server_buffer, iperf_data.buf_size, 0);
if(!g_tcp_bidirection){//Server
//parser the amount of tcp iperf setting
memcpy(&client_hdr, tcp_server_buffer, sizeof(client_hdr));
if(client_hdr.mAmount != 0){
client_hdr.mAmount = ntohl(client_hdr.mAmount);
if(client_hdr.mAmount > 0x7fffffff){
client_hdr.mAmount = (~(client_hdr.mAmount) + 1) / 100;
tcp_client_data.time = client_hdr.mAmount;
}else
tcp_client_data.total_size = client_hdr.mAmount;
}
if(ntohl(client_hdr.flags) == 0x80000001){//bi-direction, create client to send packets back
if((NULL == g_tcp_client_task)){
if(xTaskCreate(tcp_client_handler, "tcp_client_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1 + PRIORITIE_OFFSET, &g_tcp_client_task) != pdPASS)
printf("\n\rTCP ERROR: Create TCP client task failed.");
else{
strncpy(tcp_client_data.server_ip, inet_ntoa(client_addr.sin_addr), (strlen(inet_ntoa(client_addr.sin_addr))) );
tcp_client_data.port = ntohl(client_hdr.mPort);
tcp_client_data.buf_size = CLIENT_BUF_SIZE;
tcp_client_data.report_interval = DEFAULT_REPORT_INTERVAL;
}
}
}
}
start_time = xTaskGetTickCount();
report_start_time = start_time;
while (!g_tcp_terminate) {
recv_size = recv(iperf_data.client_fd, tcp_server_buffer, iperf_data.buf_size, 0); //MSG_DONTWAIT MSG_WAITALL
if( recv_size < 0){
printf("\n\r[ERROR] %s: Receive data failed",__func__);
goto Exit1;
}
else if(recv_size == 0){
//printf("\n\r%s: [END] Totally receive %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t) (total_size/KB),(uint32_t) (end_time-start_time),((uint32_t) (total_size*8)/(end_time - start_time)));
//total_size=0;
//close(iperf_data.client_fd);
//goto Restart;
break;
}
end_time = xTaskGetTickCount();
total_size+=recv_size;
report_size+=recv_size;
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval)) && ((end_time - report_start_time) <= (configTICK_RATE_HZ * (iperf_data.report_interval + 1)))) {
printf("\n\r%s: Receive %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t) (report_size/KB),(uint32_t) (end_time-report_start_time),((uint32_t) (report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
report_size = 0;
}
}
printf("\n\r%s: [END] Totally receive %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t) (total_size/KB),(uint32_t) (end_time-start_time),((uint32_t) (total_size*8)/(end_time - start_time)));
Exit1:
// close the connected socket after receiving from connected TCP client
close(iperf_data.client_fd);
Exit2:
// close the listening socket
close(iperf_data.server_fd);
Exit3:
if(tcp_server_buffer){
vPortFree(tcp_server_buffer);
tcp_server_buffer = NULL;
}
return 0;
}
int udp_client_func(struct iperf_data_t iperf_data)
{
struct sockaddr_in ser_addr;
int i=0;
int addrlen = sizeof(struct sockaddr_in);
uint32_t start_time, end_time, bandwidth_time,report_start_time;
uint64_t total_size=0, bandwidth_size=0, report_size=0;
struct iperf_udp_client_hdr client_hdr;
udp_client_buffer = pvPortMalloc(iperf_data.buf_size);
if(!udp_client_buffer){
printf("\n\r[ERROR] %s: Alloc buffer failed",__func__);
goto Exit2;
}
//filling the buffer
for (i = 0; i < iperf_data.buf_size; i++)
udp_client_buffer[i] = (char)(i % 10);
//create socket
if( (iperf_data.client_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
printf("\n\r[ERROR] %s: Create UDP socket failed",__func__);
goto Exit2;
}
//initialize value in dest
memset(&ser_addr, 0, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(iperf_data.port);
ser_addr.sin_addr.s_addr = inet_addr(iperf_data.server_ip);
printf("\n\r%s: Server IP=%s, port=%d", __func__,iperf_data.server_ip, iperf_data.port);
printf("\n\r%s: Create socket fd = %d", __func__,iperf_data.client_fd);
lwip_setsockopt(iperf_data.client_fd,IPPROTO_IP,IP_TOS,&iperf_data.tos_value,sizeof(iperf_data.tos_value));
if(g_udp_bidirection){
client_hdr.id = 0;
client_hdr.tv_sec = 0;
client_hdr.tv_usec = 0;
client_hdr.flags = htonl(0x80000001);
client_hdr.numThreads = htonl(0x00000001);
client_hdr.mPort = htonl(iperf_data.port);
client_hdr.bufferlen = 0;
client_hdr.mWinband = htonl(iperf_data.bandwidth);
client_hdr.mAmount = htonl(~(iperf_data.time*100) + 1);
memcpy(udp_client_buffer, &client_hdr, sizeof(client_hdr));
}
if(iperf_data.total_size == 0){
start_time = xTaskGetTickCount();
end_time = start_time;
bandwidth_time = start_time;
report_start_time = start_time;
while ( ((end_time - start_time) <= (configTICK_RATE_HZ * iperf_data.time)) && (!g_udp_terminate) ) {
if( sendto(iperf_data.client_fd, udp_client_buffer, iperf_data.buf_size,0,(struct sockaddr*)&ser_addr, addrlen) < 0){
//printf("\n\r[ERROR] %s: UDP client send data error",__func__);
}else{
total_size+=iperf_data.buf_size;
bandwidth_size+=iperf_data.buf_size;
report_size+=iperf_data.buf_size;
}
end_time = xTaskGetTickCount();
if( (bandwidth_size >= iperf_data.bandwidth) && ((end_time - bandwidth_time) < (configTICK_RATE_HZ*1)) ){
vTaskDelay(configTICK_RATE_HZ * 1 - (end_time - bandwidth_time));
end_time = xTaskGetTickCount();
bandwidth_time = end_time;
bandwidth_size = 0;
}
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval))){
printf("\n\r%s: Send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
bandwidth_time = end_time;
report_size = 0;
bandwidth_size = 0;
}
}
}
else{
start_time = xTaskGetTickCount();
end_time = start_time;
bandwidth_time = start_time;
report_start_time = start_time;
while ( (total_size < iperf_data.total_size) && (!g_udp_terminate) ) {
if( sendto(iperf_data.client_fd, udp_client_buffer, iperf_data.buf_size,0,(struct sockaddr*)&ser_addr, addrlen) < 0){
//printf("\n\r[ERROR] %s: UDP client send data error",__func__);
}else{
total_size+=iperf_data.buf_size;
bandwidth_size+=iperf_data.buf_size;
report_size+=iperf_data.buf_size;
}
end_time = xTaskGetTickCount();
if( (bandwidth_size >= iperf_data.bandwidth) && ((end_time - bandwidth_time) < (configTICK_RATE_HZ*1)) ){
vTaskDelay(configTICK_RATE_HZ * 1 - (end_time - bandwidth_time));
end_time = xTaskGetTickCount();
bandwidth_time = end_time;
bandwidth_size = 0;
}
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval))) {
printf("\n\r%s: Send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
bandwidth_time = end_time;
report_size = 0;
bandwidth_size = 0;
}
}
}
printf("\n\r%s: [END] Totally send %d KBytes in %d ms, %d Kbits/sec",__func__, (uint32_t)(total_size/KB),(uint32_t)(end_time-start_time),((uint32_t)(total_size*8)/(end_time - start_time)));
Exit1:
close(iperf_data.client_fd);
Exit2:
printf("\n\r%s: Close client socket",__func__);
if(udp_client_buffer){
vPortFree(udp_client_buffer);
udp_client_buffer = NULL;
}
return 0;
}
int udp_server_func(struct iperf_data_t iperf_data)
{
struct sockaddr_in ser_addr , client_addr;
int addrlen = sizeof(struct sockaddr_in);
int n = 1;
uint32_t start_time, report_start_time, end_time;
int recv_size=0;
uint64_t total_size=0,report_size=0;
struct iperf_udp_client_hdr client_hdr;
uint8_t time_boundary = 0, size_boundary = 0;
udp_server_buffer = pvPortMalloc(iperf_data.buf_size);
if(!udp_server_buffer){
printf("\n\r[ERROR] %s: Alloc buffer failed",__func__);
goto Exit2;
}
//create socket
if((iperf_data.server_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
printf("\n\r[ERROR] %s: Create socket failed",__func__);
goto Exit2;
}
printf("\n\r%s: Create socket fd = %d, port = %d", __func__,iperf_data.server_fd,iperf_data.port);
setsockopt( iperf_data.server_fd, SOL_SOCKET, SO_REUSEADDR, (const char *) &n, sizeof( n ) );
//initialize structure dest
memset(&ser_addr, 0, sizeof(ser_addr));
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(iperf_data.port);
ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
// binding the TCP socket to the TCP server address
if( bind(iperf_data.server_fd, (struct sockaddr*)&ser_addr, sizeof(ser_addr)) < 0){
printf("\n\r[ERROR] %s: Bind socket failed",__func__);
goto Exit1;
}
printf("\n\r%s: Bind socket successfully",__func__);
//wait for first packet to start
recv_size = recvfrom(iperf_data.server_fd,udp_server_buffer,iperf_data.buf_size,0,(struct sockaddr *) &client_addr,&addrlen);
total_size+=recv_size;
report_size+=recv_size;
start_time = xTaskGetTickCount();
report_start_time = start_time;
end_time = start_time;
if(!g_udp_bidirection){//Server
//parser the amount of udp iperf setting
memcpy(&client_hdr, udp_server_buffer, sizeof(client_hdr));
if(client_hdr.mAmount != 0){
client_hdr.mAmount = ntohl(client_hdr.mAmount);
if(client_hdr.mAmount > 0x7fffffff){
client_hdr.mAmount = (~(client_hdr.mAmount) + 1) / 100;
time_boundary = 1;
udp_client_data.time = client_hdr.mAmount;
}else{
size_boundary = 1;
udp_client_data.total_size = client_hdr.mAmount;
}
}
if(ntohl(client_hdr.flags) == 0x80000001){//bi-direction, create client to send packets back
if(NULL == g_udp_client_task){
if(xTaskCreate(udp_client_handler, "udp_client_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1 + PRIORITIE_OFFSET, &g_udp_client_task) != pdPASS)
printf("\r\nUDP ERROR: Create UDP client task failed.");
else{
strncpy(udp_client_data.server_ip, inet_ntoa(client_addr.sin_addr), (strlen(inet_ntoa(client_addr.sin_addr))) );
udp_client_data.port = ntohl(client_hdr.mPort);
udp_client_data.bandwidth = ntohl(client_hdr.mWinband);
udp_client_data.buf_size = CLIENT_BUF_SIZE;
udp_client_data.tos_value = DEFAULT_UDP_TOS_VALUE;
udp_client_data.report_interval = DEFAULT_REPORT_INTERVAL;
}
}
}
}else{//listener
if(iperf_data.total_size){
client_hdr.mAmount = iperf_data.total_size;
size_boundary = 1;
}
else if(iperf_data.time){
client_hdr.mAmount = iperf_data.time;
time_boundary = 1;
}
}
if(time_boundary){
while ( ((end_time - start_time) <= (configTICK_RATE_HZ * client_hdr.mAmount )) && (!g_udp_terminate) ) {
recv_size = recvfrom(iperf_data.server_fd,udp_server_buffer,iperf_data.buf_size,0,(struct sockaddr *) &client_addr,&addrlen);
if( recv_size < 0){
printf("\n\r[ERROR] %s: Receive data failed",__func__);
goto Exit1;
}
// ack data to client
// Not send ack to prevent send fail due to limited skb, but it will have warning at iperf client
//sendto(server_fd,udp_server_buffer,ret,0,(struct sockaddr*)&client_addr,sizeof(client_addr));
end_time = xTaskGetTickCount();
total_size+=recv_size;
report_size+=recv_size;
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval)) && ((end_time - report_start_time) <= (configTICK_RATE_HZ * (iperf_data.report_interval + 1)))) {
printf("\n\r%s: Receive %d KBytes in %d ms, %d Kbits/sec",__func__,(uint32_t) (report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
report_size = 0;
}
}
}else if(size_boundary){
while ( (total_size < client_hdr.mAmount) && (!g_udp_terminate) ) {
recv_size = recvfrom(iperf_data.server_fd,udp_server_buffer,iperf_data.buf_size,0,(struct sockaddr *) &client_addr,&addrlen);
if( recv_size < 0){
printf("\n\r[ERROR] %s: Receive data failed",__func__);
goto Exit1;
}
// ack data to client
// Not send ack to prevent send fail due to limited skb, but it will have warning at iperf client
//sendto(server_fd,udp_server_buffer,ret,0,(struct sockaddr*)&client_addr,sizeof(client_addr));
end_time = xTaskGetTickCount();
total_size+=recv_size;
report_size+=recv_size;
if( (iperf_data.report_interval != DEFAULT_REPORT_INTERVAL) && ((end_time - report_start_time) >= (configTICK_RATE_HZ * iperf_data.report_interval)) && ((end_time - report_start_time) <= (configTICK_RATE_HZ * (iperf_data.report_interval + 1)))) {
printf("\n\r%s: Receive %d KBytes in %d ms, %d Kbits/sec",__func__,(uint32_t) (report_size/KB),(uint32_t)(end_time-report_start_time),((uint32_t)(report_size*8)/(end_time - report_start_time)));
report_start_time = end_time;
report_size = 0;
}
}
}
printf("\n\r%s: [END] Totally receive %d KBytes in %d ms, %d Kbits/sec",__func__,(uint32_t) (total_size/KB),(uint32_t)(end_time-start_time),((uint32_t)(total_size*8)/(end_time - start_time)));
Exit1:
// close the listening socket
close(iperf_data.server_fd);
Exit2:
if(udp_server_buffer){
vPortFree(udp_server_buffer);
udp_server_buffer = NULL;
}
return 0;
}
static void tcp_client_handler(void *param)
{
vTaskDelay(100);
printf("\n\rTCP: Start TCP client!");
tcp_client_func(tcp_client_data);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
printf("\n\rMin available stack size of %s = %d * %d bytes\n\r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
printf("\n\rTCP: TCP client stopped!");
g_tcp_client_task = NULL;
vTaskDelete(NULL);
}
static void tcp_server_handler(void *param)
{
vTaskDelay(100);
printf("\n\rTCP: Start TCP server!");
tcp_server_func(tcp_server_data);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
printf("\n\rMin available stack size of %s = %d * %d bytes\n\r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
printf("\n\rTCP: TCP server stopped!");
g_tcp_server_task = NULL;
vTaskDelete(NULL);
}
static void udp_client_handler(void *param)
{
vTaskDelay(100);
printf("\n\rUDP: Start UDP client!");
udp_client_func(udp_client_data);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
printf("\n\rMin available stack size of %s = %d * %d bytes", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
printf("\n\rUDP: UDP client stopped!");
g_udp_client_task = NULL;
vTaskDelete(NULL);
}
static void udp_server_handler(void *param)
{
vTaskDelay(100);
printf("\n\rUDP: Start UDP server!");
udp_server_func(udp_server_data);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
printf("\n\rMin available stack size of %s = %d * %d bytes", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
printf("\n\rUDP: UDP server stopped!");
g_udp_server_task = NULL;
vTaskDelete(NULL);
}
uint64_t km_parser(char *buf, int len)
{
uint64_t ret=0;
int keyword_num=0;
char num_str[17] = "\0";
uint64_t num;
if(len>16)
return ret;
while((buf[keyword_num] != '\0')&&(keyword_num<len)){
if((buf[keyword_num] == 'k')||(buf[keyword_num] == 'K')){
strncpy(num_str,buf,keyword_num);
num = atol(num_str);
ret = num * KB;
break;
}
else if((buf[keyword_num] == 'm')||(buf[keyword_num] == 'M')){
strncpy(num_str,buf,keyword_num);
num = atol(num_str);
ret = num * MB;
break;
}
keyword_num++;
if(keyword_num == len){
strncpy(num_str,buf,keyword_num);
num = atol(num_str);
ret = num;
break;
}
}
return ret;
}
void cmd_tcp(int argc, char **argv)
{
int argv_count = 2;
uint8_t time_boundary = 0, size_boundary = 0;
if(argc < 2)
goto Exit;
g_tcp_terminate = 0;
while(argv_count<=argc){
//first operation
if(argv_count == 2){
if(strcmp(argv[argv_count-1], "-s") == 0){
if(g_tcp_server_task){
printf("\n\rTCP: TCP Server is already running.");
return;
}else{
memset(&tcp_server_data,0,sizeof(struct iperf_data_t));
tcp_server_data.start = 1;
argv_count++;
}
}
else if(strcmp(argv[argv_count-1], "stop") == 0){
if(argc == 2){
vTaskDelay(100);
g_tcp_terminate = 1;
tcp_server_data.start = 0;
tcp_client_data.start = 0;
if(g_tcp_server_task){
if(tcp_server_data.server_fd >=0){
close(tcp_server_data.server_fd);
}
if(tcp_server_data.client_fd >=0){
close(tcp_server_data.client_fd);
}
if(tcp_server_buffer){
vPortFree(tcp_server_buffer);
tcp_server_buffer = NULL;
}
printf("\n\rTCP server stopped!\n");
vTaskDelete(g_tcp_server_task);
g_tcp_server_task = NULL;
}
return;
}
else
goto Exit;
}
else if(strcmp(argv[argv_count-1], "-c") == 0){
if(g_tcp_client_task){
printf("\n\rTCP: TCP client is already running. Please enter \"ATWT=stop\" to stop it.");
return;
}else{
if(argc < (argv_count+1))
goto Exit;
memset(&tcp_client_data,0,sizeof(struct iperf_data_t));
tcp_client_data.start = 1;
strncpy(tcp_client_data.server_ip, argv[2], (strlen(argv[2])>16)?16:strlen(argv[2]));
argv_count+=2;
}
}
else
goto Exit;
}
else{
if(strcmp(argv[argv_count-1], "-d") == 0){
if(tcp_client_data.start)
g_tcp_bidirection = 1;
else
goto Exit;
argv_count+=1;
}
else if(strcmp(argv[argv_count-1], "-i") == 0){
if(argc < (argv_count+1))
goto Exit;
if(tcp_server_data.start)
tcp_server_data.report_interval = (uint32_t) atoi(argv[argv_count]);
else if(tcp_client_data.start)
tcp_client_data.report_interval = (uint32_t) atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-l") == 0){
if(argc < (argv_count+1))
goto Exit;
if(tcp_server_data.start)
tcp_server_data.buf_size = atoi(argv[argv_count]);
else if(tcp_client_data.start)
tcp_client_data.buf_size = atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-n") == 0){
if(argc < (argv_count+1))
goto Exit;
size_boundary = 1;
if(tcp_client_data.start)
tcp_client_data.total_size = km_parser(argv[argv_count],strlen(argv[argv_count]));
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-p") == 0){
if(argc < (argv_count+1))
goto Exit;
if(tcp_server_data.start)
tcp_server_data.port = (uint16_t) atoi(argv[argv_count]);
else if(tcp_client_data.start)
tcp_client_data.port = (uint16_t) atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-t") == 0){
if(argc < (argv_count+1))
goto Exit;
time_boundary = 1;
if(tcp_client_data.start)
tcp_client_data.time = atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else{
goto Exit;
}
}
}
if(g_tcp_bidirection == 1){
tcp_server_data.start = 1;
tcp_server_data.port = tcp_client_data.port;
}
if(tcp_server_data.start && (NULL == g_tcp_server_task)){
if(xTaskCreate(tcp_server_handler, "tcp_server_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1 + PRIORITIE_OFFSET, &g_tcp_server_task) != pdPASS)
printf("\n\rTCP ERROR: Create TCP server task failed.");
else{
if(tcp_server_data.port == 0)
tcp_server_data.port = DEFAULT_PORT;
if(tcp_server_data.buf_size == 0)
tcp_server_data.buf_size = SERVER_BUF_SIZE;
if(tcp_server_data.report_interval == 0)
tcp_server_data.report_interval = DEFAULT_REPORT_INTERVAL;
}
}
if(tcp_client_data.start && (NULL == g_tcp_client_task)){
if(xTaskCreate(tcp_client_handler, "tcp_client_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1 + PRIORITIE_OFFSET, &g_tcp_client_task) != pdPASS)
printf("\n\rTCP ERROR: Create TCP client task failed.");
else{
if(tcp_client_data.port == 0)
tcp_client_data.port = DEFAULT_PORT;
if(tcp_client_data.buf_size == 0)
tcp_client_data.buf_size = CLIENT_BUF_SIZE;
if(tcp_client_data.report_interval == 0)
tcp_client_data.report_interval = DEFAULT_REPORT_INTERVAL;
if((time_boundary == 0) && (size_boundary == 0))
tcp_client_data.time = DEFAULT_TIME;
}
}
return;
Exit:
printf("\n\r[ATWT] Command format ERROR!\n");
printf("\n\r[ATWT] Usage: ATWT=[-s|-c,host|stop],[options]\n");
printf("\n\r Client/Server:\n");
printf(" \r stop terminate client & server\n");
printf(" \r -i # seconds between periodic bandwidth reports\n");
printf(" \r -l # length of buffer to read or write (default 1460 Bytes)\n");
printf(" \r -p # server port to listen on/connect to (default 5001)\n");
printf("\n\r Server specific:\n");
printf(" \r -s run in server mode\n");
printf("\n\r Client specific:\n");
printf(" \r -c <host> run in client mode, connecting to <host>\n");
printf(" \r -d Do a bidirectional test simultaneously\n");
printf(" \r -t # time in seconds to transmit for (default 10 secs)\n");
printf(" \r -n #[KM] number of bytes to transmit (instead of -t)\n");
printf("\n\r Example:\n");
printf(" \r ATWT=-s,-p,5002\n");
printf(" \r ATWT=-c,192.168.1.2,-t,100,-p,5002\n");
return;
}
void cmd_udp(int argc, char **argv)
{
int argv_count = 2;
uint8_t tos_value = 0;
uint8_t time_boundary = 0, size_boundary = 0;
if(argc < 2)
goto Exit;
g_udp_terminate = 0;
while(argv_count<=argc){
//first operation
if(argv_count == 2){
if(strcmp(argv[argv_count-1], "-s") == 0){
if(g_udp_server_task){
printf("\n\rUDP: UDP Server is already running.");
return;
}else{
memset(&udp_server_data,0,sizeof(struct iperf_data_t));
udp_server_data.start = 1;
argv_count++;
}
}
else if(strcmp(argv[argv_count-1], "stop") == 0){
if(argc == 2){
vTaskDelay(100);
g_udp_terminate = 1;
udp_server_data.start = 0;
udp_client_data.start = 0;
if(g_udp_server_task){
if(udp_server_data.server_fd >=0){
close(udp_server_data.server_fd);
}
if(udp_server_buffer){
vPortFree(udp_server_buffer);
udp_server_buffer = NULL;
}
printf("\n\rUDP server stopped!\n");
vTaskDelete(g_udp_server_task);
g_udp_server_task = NULL;
}
return;
}
else
goto Exit;
}
else if(strcmp(argv[argv_count-1], "-c") == 0){
if(g_udp_client_task){
printf("\n\rUDP: UDP client is already running. Please enter \"ATWU=stop\" to stop it.");
return;
}else{
if(argc < (argv_count+1))
goto Exit;
memset(&udp_client_data,0,sizeof(struct iperf_data_t));
udp_client_data.start = 1;
strncpy(udp_client_data.server_ip, argv[2], (strlen(argv[2])>16)?16:strlen(argv[2]));
argv_count+=2;
}
}
else
goto Exit;
}
else{
if(strcmp(argv[argv_count-1], "-b") == 0){
if(argc < (argv_count+1))
goto Exit;
if(udp_client_data.start){
udp_client_data.bandwidth = km_parser(argv[argv_count],strlen(argv[argv_count]));
udp_client_data.bandwidth = udp_client_data.bandwidth/8;//bits to Bytes
}
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-d") == 0){
if(udp_client_data.start)
g_udp_bidirection = 1;
else
goto Exit;
argv_count+=1;
}
else if(strcmp(argv[argv_count-1], "-i") == 0){
if(argc < (argv_count+1))
goto Exit;
if(udp_server_data.start)
udp_server_data.report_interval = (uint32_t) atoi(argv[argv_count]);
else if(udp_client_data.start)
udp_client_data.report_interval = (uint32_t) atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-l") == 0){
if(argc < (argv_count+1))
goto Exit;
if(udp_server_data.start)
udp_server_data.buf_size = atoi(argv[argv_count]);
else if(udp_client_data.start)
udp_client_data.buf_size = atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-n") == 0){
if(argc < (argv_count+1))
goto Exit;
size_boundary = 1;
if(udp_server_data.start)
udp_server_data.total_size = km_parser(argv[argv_count],strlen(argv[argv_count]));
else if(udp_client_data.start)
udp_client_data.total_size = km_parser(argv[argv_count],strlen(argv[argv_count]));
else
goto Exit;
argv_count+=2;
}
else if(strcmp(argv[argv_count-1], "-p") == 0){
if(argc < (argv_count+1))
goto Exit;
if(udp_server_data.start)
udp_server_data.port = (uint16_t) atoi(argv[argv_count]);
else if(udp_client_data.start)
udp_client_data.port = (uint16_t) atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
#if CONFIG_WLAN
else if(strcmp(argv[argv_count-1], "-S") == 0){ //for wmm test
if(argc < (argv_count+1))
goto Exit;
if(udp_client_data.start){
if(atoi(argv[argv_count]) >= 0 && atoi(argv[argv_count]) <= 255){
tos_value = (uint8_t) atoi(argv[argv_count]);
wext_set_tos_value(WLAN0_NAME, &tos_value);
udp_client_data.tos_value = tos_value;
}
else
goto Exit;
}
else
goto Exit;
argv_count+=2;
}
#endif
else if(strcmp(argv[argv_count-1], "-t") == 0){
if(argc < (argv_count+1))
goto Exit;
time_boundary = 1;
if(udp_server_data.start)
udp_server_data.time = atoi(argv[argv_count]);
else if(udp_client_data.start)
udp_client_data.time = atoi(argv[argv_count]);
else
goto Exit;
argv_count+=2;
}
else{
goto Exit;
}
}
}
if(g_udp_bidirection == 1){
udp_server_data.start = 1;
udp_server_data.port = udp_client_data.port;
udp_server_data.time = udp_client_data.time;
udp_server_data.total_size = udp_client_data.total_size;
}
if(udp_server_data.start && (NULL == g_udp_server_task)){
if(xTaskCreate(udp_server_handler, "udp_server_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 2 + PRIORITIE_OFFSET, &g_udp_server_task) != pdPASS)
printf("\r\nUDP ERROR: Create UDP server task failed.");
else{
if(udp_server_data.port == 0)
udp_server_data.port = DEFAULT_PORT;
if(udp_server_data.buf_size == 0)
udp_server_data.buf_size = SERVER_BUF_SIZE;
if(udp_server_data.report_interval == 0)
udp_server_data.report_interval = DEFAULT_REPORT_INTERVAL;
if((time_boundary == 0) && (size_boundary == 0)){
udp_server_data.time = DEFAULT_TIME;
}
}
}
if(udp_client_data.start && (NULL == g_udp_client_task)){
if(xTaskCreate(udp_client_handler, "udp_client_handler", BSD_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1 + PRIORITIE_OFFSET, &g_udp_client_task) != pdPASS)
printf("\r\nUDP ERROR: Create UDP client task failed.");
else{
if(udp_client_data.port == 0)
udp_client_data.port = DEFAULT_PORT;
if(udp_client_data.bandwidth == 0)
udp_client_data.bandwidth = DEFAULT_UDP_BANDWIDTH;
if(udp_client_data.buf_size == 0)
udp_client_data.buf_size = CLIENT_BUF_SIZE;
if(udp_client_data.tos_value == 0)
udp_client_data.tos_value = DEFAULT_UDP_TOS_VALUE;
if(udp_client_data.report_interval == 0)
udp_client_data.report_interval = DEFAULT_REPORT_INTERVAL;
if((time_boundary == 0) && (size_boundary == 0)){
udp_client_data.time = DEFAULT_TIME;
}
}
}
return;
Exit:
printf("\n\r[ATWU] Command format ERROR!\n");
printf("\n\r[ATWU] Usage: ATWU=[-s|-c,host|stop][options]\n");
printf("\n\r Client/Server:\n");
printf(" \r stop terminate client & server\n");
printf(" \r -i # seconds between periodic bandwidth reports\n");
printf(" \r -l # length of buffer to read or write (default 1460 Bytes)\n");
printf(" \r -p # server port to listen on/connect to (default 5001)\n");
printf("\n\r Server specific:\n");
printf(" \r -s run in server mode\n");
printf("\n\r Client specific:\n");
printf(" \r -b #[KM] for UDP, bandwidth to send at in bits/sec (default 1 Mbit/sec)\n");
printf(" \r -c <host> run in client mode, connecting to <host>\n");
printf(" \r -d Do a bidirectional test simultaneously\n");
printf(" \r -t # time in seconds to transmit for (default 10 secs)\n");
printf(" \r -n #[KM] number of bytes to transmit (instead of -t)\n");
#if CONFIG_WLAN
printf(" \r -S # set the IP 'type of service'\n");
#endif
printf("\n\r Example:\n");
printf(" \r ATWU=-s,-p,5002\n");
printf(" \r ATWU=-c,192.168.1.2,-t,100,-p,5002\n");
return;
}
Reference in a new issue Copy permalink