tcpsendreceive.c

这是一个VxWorks下TCP的收发C源程序

#include "vxWorks.h"
#include "fioLib.h"
#include "stdio.h"
#include "unistd.h"
#include "string.h"
#include "usrLib.h"
#include "errnoLib.h"
#include "hostLib.h"
#include "sockLib.h"
#include "socket.h"
#include "inetLib.h"
#include "in.h"
#include "time.h"

#define  SERVER_NUM 7000
#define  CLIENT_NUM 6000
#define TCP_RECEIVE_DATA_ADDR 0x4000000

int                 TcpTranSize=0x1000000;
int                 tcppackSize=1024;
char                *tcpSendStartAdd=0x1000000;
int                 tcplp=1;
struct sockaddr_in	tcpserverAddr;	/* server's address */
struct sockaddr_in	tcpclientAddr;	/* client's address */
int                 tcpclientSock;	

int                 tcpsockAddrSize;  /* size of socket address structure */ 
char                *tcpTransBuffer;
unsigned int        PacketStartTime, PacketEndTime, TimePassed, StartTime, EndTime;
long                tcpsendtimes=0;
int                 tcpBusFreq=33;
char                *specNetIp="192.168.0.55";


char *tcpreceiveDataAdd=TCP_RECEIVE_DATA_ADDR;
int tcpreceiveSize=1024;
int tcpReceiveFlag=1;
int tcpDebug=0;

STATUS tcpClient (hostName)
	char *hostName; /* name of host running server, 0=boot host */
{

	/* Zero out the sock_addr structures.
	 * This MUST be done before the socket call.
	 */

	bzero ((char *) &tcpserverAddr, sizeof (tcpserverAddr));
	bzero ((char *) &tcpclientAddr, sizeof (tcpclientAddr));

	/* Open the socket.
	 * Use ARPA Internet address format and stream sockets.
	 * Format described in "socket.h".
	 */

	tcpclientSock = socket (AF_INET, SOCK_STREAM, 0);

	if (tcpclientSock == ERROR)
	return (ERROR);


/* bind not required - port number is dynamic  */
	tcpsockAddrSize = sizeof (struct sockaddr_in); 
	bzero ((char *) &tcpclientAddr, tcpsockAddrSize); 
	tcpclientAddr.sin_len = (u_char) tcpsockAddrSize; 
	tcpclientAddr.sin_family = AF_INET; 

	tcpclientAddr.sin_port = htons (CLIENT_NUM); 
	tcpclientAddr.sin_addr.s_addr = inet_addr(specNetIp);
	
	/*
	if (bind (tcpclientSock, (struct sockaddr *) &tcpclientAddr, tcpsockAddrSize) == ERROR) 
		{ 
		perror ("bind"); 
		close (tcpclientSock); 
		return (ERROR); 
		} 
    */ 

	tcpserverAddr.sin_family = AF_INET;
	tcpserverAddr.sin_port   = htons(SERVER_NUM);
	tcpserverAddr.sin_addr.s_addr = inet_addr (hostName);

   	printf ("Server's ip address is %x:\n", hostName);
 
	if (connect (tcpclientSock, (struct sockaddr *)&tcpserverAddr,
			sizeof (tcpserverAddr)) == ERROR)
	 {
	  printf ("Connect failed:\n");
	  close (tcpclientSock);
	  return (ERROR);
	 }

	printf ("Connected ok!\n");

	return (OK);
}


int tcpSend()
{
   unsigned long begin,end;  
   float ftime=0;

	printf ("Begin to send\n");
	do
	{
	/* read a character from standard input */
	 begin=tickGet();
	  for(tcpTransBuffer = (char *)tcpSendStartAdd; tcpTransBuffer < (char *)(tcpSendStartAdd +TcpTranSize ); tcpTransBuffer += tcppackSize)
		{
		 if(sendto(tcpclientSock,(caddr_t)tcpTransBuffer,tcppackSize,0,(struct sockaddr *)&tcpserverAddr,tcpsockAddrSize) == ERROR)
		   {
			 printf("Send Erro\n");
			 break;
		   }
		tcpsendtimes++;
		}
		
	 end=tickGet();
 
     ftime=(float)(end-begin)/sysClkRateGet();
     printf("begin tick is:%d,end tick is:%d\ntime=%3.1f sec\n",begin,end,ftime);
     printf("TCP send speed:%3.1f MB\n\n", (float)TcpTranSize/0x100000/ ftime );
 
         taskDelay(50);
		
	}while (tcplp);

   return OK;
}

int tcpClose()
{
   close (tcpclientSock);
   printf ("\n...goodbye\n");
   return (OK);
}


char		*cbuffer=0xa000000;


int tcpServer ()
	{
	int			sock, snew;	/* socket fd's */
	struct sockaddr_in	serverAddr;	/* server's address */
	struct sockaddr_in 	clientAddr;	/* client's address */
	int			client_len;	/* length of clientAddr */
        int        rcvsize,i;
	extern int		errno;		/* for UNIX error referencing */

	/* Zero out the sock_addr structures.
	 * This MUST be done before the socket calls.
	 */

	bzero (&serverAddr, sizeof (serverAddr));
	bzero (&clientAddr, sizeof (clientAddr));

	/* Open the socket.
	 * Use ARPA Internet address format and stream sockets.
	 * Format described in "socket.h".
	 */

	sock = socket (AF_INET, SOCK_STREAM, 0);

	if (sock == -1)
	exit (1);

	/* Set up our internet address, and bind it so the client can connect. */

	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(SERVER_NUM);

	printf ("\nBinding SERVER\n", serverAddr.sin_port);

	if (bind (sock, (struct sockaddr *)&serverAddr, sizeof (serverAddr))
							== -1)
	{
	printf ("bind failed, errno = %d\n", errno);
	close (sock);
	exit (1);
	}

	/* Listen, for the client to connect to us. */

	printf ("Listening to client\n");

	if (listen (sock, 2) == -1)
	{
	printf ("listen failed\n");
	close (sock);
	exit (1);
	}

	/* The client has connected.  Accept, and receive chars */

	printf ("Accepting CLIENT\n");

	client_len = sizeof (clientAddr);

	snew = accept (sock, (struct sockaddr *)&clientAddr, &client_len);

	if (snew == -1)
	{
	printf ("accept failed\n");
	close (sock);
	exit (1);
	}

	printf ("CLIENT: port = %d: family = %d: addr = %lx:\n",
		ntohs(clientAddr.sin_port), clientAddr.sin_family,
		ntohl(clientAddr.sin_addr.s_addr));

	/* repeatedly recieve characters from client and put on stdout */


	for(;;)
	{
	  if ( (rcvsize=recv (snew, cbuffer, 0x10000, 0) )== 0)
		{
		/* client has disappeared */
		break;
		}

	 if(tcpDebug==1)
           {
	    for (i=0;i<rcvsize;i++)
	     putchar (cbuffer[i]);
           }
	
	}

	/* close the socket from the UNIX side */

	close (sock);
	close (snew);

	printf ("\n...goodbye\n");
	}