udp_tester.c

由smsc公司改进的lwip2.1.1基于嵌入式系统的TCP/ip协议栈

/* Copyright 2008 SMSC, All rights reserved
FILE: udp_tester.c
*/

#include "core/sps.h"

#if !UDP_ENABLED
#error UDP is not enabled
#endif

#include "applications/udp_tester.h" 

#define USE_INCREMENTING_DATA 	(0)
#define UDP_TESTER_TX_BURST_COUNT	(4)


void UdpTester_ReceiveFunction(
	void * param, struct UDP_CONTROL_BLOCK * udpControlBlock,
	struct PACKET_BUFFER * packet,
	PIP_ADDRESS sourceAddress,
	u16_t sourcePort)
{
	struct PACKET_BUFFER * buffer;
	struct PACKET_BUFFER * txPacket;
	u8_t *dataPointer;
	static u32_t udpMsgCount;
	static u32_t udpBytesReceived;
	struct stat {
		u32_t bytesReceived;
		double secRecvTime;
	} stat;
	static smsc_clock_t start_time;
	
	SMSC_ASSERT(packet!=NULL);
	buffer=packet; 
	udpMsgCount++;
	udpBytesReceived+=PacketBuffer_GetTotalLength(buffer);
	if((udpMsgCount%1000)==0) {
		SMSC_TRACE(1,("UdpTester_ReceiveFunction: udpMsgCount=%"U32_F" udpBytesReceived=%"U32_F, udpMsgCount,udpBytesReceived));
	}
#if !USE_INCREMENTING_DATA		
	while (buffer!=NULL) {
		u8_t * data=PacketBuffer_GetStartPoint(buffer);				
		if(strncmp((char *)data,(char *)"SSSSSS",6)==0) {
			udpMsgCount=0;
			SMSC_NOTICE(1,("***Received START MARKER***"));
			start_time=smsc_time_now();
			goto DROP_PACKET;			
		}
		if(strncmp((char *)data,(char *)"EEEEEE",6)==0) {
			u32_t recvTime=smsc_tick_to_sec(smsc_time_minus(smsc_time_now(),start_time));
			SMSC_NOTICE(1,("***Received END MARKER*** "));
			txPacket=Udp_AllocatePacket(sourceAddress,sizeof(stat));
			dataPointer=PacketBuffer_GetStartPoint(txPacket);
			stat.bytesReceived=udpBytesReceived;
			stat.secRecvTime=(double)recvTime;
			SMSC_NOTICE(1,("Bytes Received=%"U32_F,udpBytesReceived)); 
			memcpy(dataPointer, (char *) &stat, sizeof(stat));
			Udp_SendTo(udpControlBlock,txPacket,sourceAddress,sourcePort);
			goto DROP_PACKET;			
		}
		buffer=PacketBuffer_GetNextPointer(buffer);
	} 
#else	/* Verify the data */		
	while(buffer!=NULL) {
		u8_t firstByte=1;
		u8_t testData;
		u8_t startDataCount=0;
		u8_t endDataCount=0;
		u32_t index=0;
		u8_t * data=PacketBuffer_GetStartPoint(buffer);
		u32_t length=buffer->mThisLength;
		while(index<length) {
			if(firstByte) {
				testData=data[index];
				firstByte=0;
			} else if(testData!=data[index]) {
				if(data[index]=='S') {
					if(++startDataCount==4) {
						SMSC_NOTICE(1,("***Received START MARKER*** buf=%c", data[index]));	
						start_time=smsc_time_now();
					}
					udpMsgCount=0;
					testData++;
					index++;
					continue;
				}
				if(data[index]=='E') {
					if (++endDataCount==4) {
						u32_t recvTime=smsc_tick_to_sec(smsc_time_minus(smsc_time_now(),start_time));
						SMSC_NOTICE(1,("***Received END MARKER*** buf=%c"U32_F, data[index]));
						txPacket=Udp_AllocatePacket(sourceAddress,sizeof(stat));
						dataPointer=PacketBuffer_GetStartPoint(txPacket);
						stat.bytesReceived=udpBytesReceived;
						stat.secRecvTime=(double)recvTime;
						SMSC_NOTICE(1,("Bytes Received=%"U32_F,udpBytesReceived)); 
						memcpy(dataPointer, (char *) &stat, sizeof(stat));
						Udp_SendTo(udpControlBlock,txPacket,sourceAddress,sourcePort);
						goto DROP_PACKET;
					}
					testData++;
					index++;
					continue;
				}
				SMSC_NOTICE(1,("UdpTester_ReceiveFunction: Detected non incrementing data, msgcount=%"U32_F" buf=%c", udpMsgCount,data[index]));
				goto DROP_PACKET;
			}
			testData++;
			index++;
		}
		buffer=PacketBuffer_GetNextPointer(buffer);
	}   
	SMSC_TRACE(1,("UdpTester_ReceiveFunction: Verified incrementing data, msgcount=%"U32_F, udpMsgCount));
#endif
DROP_PACKET:
	PacketBuffer_DecreaseReference(packet);
}
void UdpTester_InitializeReceiver(
	PUDP_RX_TESTER udpTester,
	PIP_ADDRESS localAddress,u16_t localPort)
{    
	struct UDP_CONTROL_BLOCK * udpControlBlock;
	SMSC_ASSERT(udpTester!=NULL);
	memset(udpTester,0,sizeof(UDP_RX_TESTER));
	ASSIGN_SIGNATURE(udpTester,UDP_RX_TESTER_SIGNATURE);
	SMSC_ASSERT(localAddress!=NULL);
	        
	udpControlBlock=Udp_CreateControlBlock();
	if(udpControlBlock==NULL) {
		SMSC_NOTICE(1,("UdpTester_InitializeReceiver: Failed to create UDP_CONTROL_BLOCK"));
		return;
	}
	if(Udp_Bind(udpControlBlock,localAddress,localPort)!=ERR_OK) {
		SMSC_NOTICE(1,("UdpTester_InitializeReceiver: Failed to Bind UDP ControlBlock"));
		Udp_FreeControlBlock(udpControlBlock);
		return;
	}                                         
	Udp_SetReceiverCallBack(udpControlBlock,UdpTester_ReceiveFunction,udpTester);
	udpTester->mUdpControlBlock=udpControlBlock;
	SMSC_NOTICE(1,("UdpTester_InitializeReceiver: initialized, Ready to receive data"));
}

void UdpTester_TransmitTask(void * param)
{
	PUDP_TX_TESTER udpTester=(PUDP_TX_TESTER)param;
	struct UDP_CONTROL_BLOCK * udpControlBlock;
	struct PACKET_BUFFER * packet; 
	int count=0;
	SMSC_ASSERT(udpTester!=NULL);
	CHECK_SIGNATURE(udpTester,UDP_TX_TESTER_SIGNATURE);

	udpControlBlock=udpTester->mUdpControlBlock;
	SMSC_ASSERT(udpControlBlock!=NULL);

	while(count<UDP_TESTER_TX_BURST_COUNT) {
		packet=Udp_AllocatePacket(&(udpTester->mRemoteAddress),udpTester->mPacketSize);
		if(packet==NULL) {
			SMSC_NOTICE(1,("UdpTester_TransmitTask: Failed to allocate packet buffer"));
			goto RESCHEDULE;
		} else {
			/*SMSC_TRACE(1,("UdpTester_TransmitTask: Transmitting UDP Packet"));*/
		}

		#if USE_INCREMENTING_DATA
		{/* Initialize packet with incrementing data */
			u8_t data=0;
			struct PACKET_BUFFER * buffer=packet;
			while(buffer!=NULL) {
				u16_t index;
				u8_t * dataPointer=PacketBuffer_GetStartPoint(buffer);
				for(index=0;index<buffer->mThisLength;index++,data++) {
					dataPointer[index]=data;
				}
				buffer=buffer->mNext;
			}
		}
		#endif

		Udp_SendTo(
			udpControlBlock,packet,
			&(udpTester->mRemoteAddress),udpTester->mRemotePort);
		count++;
	}
RESCHEDULE:
	TaskManager_ScheduleAsSoonAsPossible((udpTester->mTransmitTask));
	/*TaskManager_ScheduleByTimer((udpTester->mTransmitTask),100);*/
}

void UdpTester_InitializeTransmitter(
	PUDP_TX_TESTER udpTester,
	PIP_ADDRESS remoteAddress,u16_t remotePort,
	u32_t size)
{
	struct UDP_CONTROL_BLOCK * udpControlBlock;
	SMSC_ASSERT(udpTester!=NULL);
	memset(udpTester,0,sizeof(UDP_TX_TESTER));
	ASSIGN_SIGNATURE(udpTester,UDP_TX_TESTER_SIGNATURE);
	SMSC_ASSERT(remoteAddress!=NULL);
	        
	udpControlBlock=Udp_CreateControlBlock();
	if(udpControlBlock==NULL) {
		SMSC_NOTICE(1,("UdpTester_InitializeTransmitter: Failed to create UDP_CONTROL_BLOCK"));
		return;
	}
	
	IP_ADDRESS_COPY(&(udpTester->mRemoteAddress),remoteAddress);
	udpTester->mRemotePort=remotePort;
	udpTester->mPacketSize=size;
	udpTester->mUdpControlBlock=udpControlBlock;
	udpTester->mTransmitTask=Task_Allocate(
		TASK_PRIORITY_APPLICATION_LOW,/* Priority is low to ensure that the RX task is not choked */
		UdpTester_TransmitTask,udpTester);
	SMSC_ASSERT(udpTester->mTransmitTask!=NULL);
	TaskManager_ScheduleAsSoonAsPossible((udpTester->mTransmitTask));
}