server.c

udp通信阿达洒洒萨法萨达洒洒洒洒嗒嗒嗒萨

#include "server.h"

void main()
{
	serverInit();
	server();
	closesocket( listenSkt );
}

void serverInit()
{
	struct sockaddr_in serverAddr;
	struct in_addr     *ip;
	struct hostent far *host;
	char               name[40];
	WSADATA wsaData;
	
	
	WSAStartup( WINSOCK_VERSION , &wsaData ) ;
	listenSkt = socket( AF_INET , SOCK_DGRAM , 0 ) ;
	if ( listenSkt == INVALID_SOCKET )
	{
		printf( "Create Error----%d\n" , WSAGetLastError() ) ;
		WSACleanup() ;
		exit(1) ;
	}
	
	gethostname( name , sizeof(name) ) ;
	host = gethostbyname( name ) ;
	ip = (struct in_addr*)*host->h_addr_list ;
	
	serverAddr.sin_addr   = *ip ;
	serverAddr.sin_family = AF_INET ;
	serverAddr.sin_port   = htons( LOCAL_PORT ) ;
	
	if ( bind( listenSkt , (struct sockaddr*)&serverAddr , sizeof(serverAddr) ) 
		== SOCKET_ERROR)
	{
		printf( "Bind Error----%d\n" , WSAGetLastError() ) ;
		WSACleanup() ;
		exit(1) ;
	}
	
	printf( "Server IP:%s\nServer Initiate Successfully\nBegin to communicate:\n" ,
		inet_ntoa( serverAddr.sin_addr ) ) ;
	printf( "*************************************************************\n" ) ;
	
}

void server()
{
	int recvSize     = 0;
	int totalSize    = 1;
	int checkFlag;
	short int seqNum = 0;
	unsigned char msg[MSG_MAX_SIZE];
	unsigned char packet[MSG_MAX_SIZE+PKT_SEQNUM_SIZE+PKT_CHECKSUM_SIZE+PKT_MSG_SIZE];
	int  msgLen;
	int  addrSize;
	
	char *fileContext;
	char *ptr;
	FILE *dstFile;
	int  size = 0;
	addrSize = sizeof(struct sockaddr_in);
	while ( recvSize < totalSize )
	{
		memset( &clientAddr,0,sizeof(clientAddr) );
		memset( packet , 0 , sizeof(packet) );
		memset( msg,0,sizeof(msg) );
		msgLen = recvfrom( listenSkt,packet,sizeof(packet),0,
			(struct sockaddr*)&clientAddr,&addrSize );
		if ( msgLen == SOCKET_ERROR )
		{
			printf( "Recv Error----%d\n",WSAGetLastError() );
			break;
		}
		
		/*recv corrupt packet*/
		if ( (checkFlag = checkError( packet )) != 0 || getSeqNum(packet) != seqNum )
		{
			printf( "Recv corrupted packet\n" );
		}
		else /*recv good packet*/
		{
			
			recvSize += disPacketMsg( msg,packet );
			size = disPacketMsg( msg,packet );
			if ( size == 0 )
			{
				totalSize = _8to32( msg );
				fileContext = (char*)malloc(sizeof(char)*(totalSize+1));
				ptr         = fileContext;
				memset( fileContext,0,sizeof(char)*(totalSize+1));
				printf( "Totalsize  %d\n",totalSize );
			}
			else
			{
				memcpy( ptr,msg,size*sizeof(char) );
				ptr = fileContext+recvSize;
				printf( "%dReceive from %s:\n%d  %s\n",checkError(packet),inet_ntoa( clientAddr.sin_addr ),
				getSeqNum(packet),msg ) ;
				printf( "%d*************************************************************\n",recvSize ) ;
			}
			
			/*send back*/
			memset( msg,0,sizeof(msg) );
			memset( packet,0,sizeof(packet) );
			strcpy( msg,"ACK" );
			printf( "%d  %s\n",seqNum,msg );
			packageMsg( packet,msg,3,seqNum );		
			sendto( listenSkt,packet,sizeof(packet),0,(struct sockaddr*)&clientAddr,
				sizeof(clientAddr) );
			printf( "************************************************Message SendOut\n" );
			seqNum = (seqNum+1)%2;
		}
	}
	dstFile = fopen( "dst.exe","wb" );
	fwrite( fileContext,1,sizeof(char)*(totalSize+1),dstFile );
	fclose( dstFile );
}

void _32to8(unsigned char* buffer,int size)
{
	int i=0;
	while ( i<4 )
	{
		buffer[i] = (size>>(32-(i+1)*8))&0x00ff;
		i++;
	}
}

int _8to32(unsigned char *buffer)
{
	return ((buffer[0]*0x1000000)&0xff000000)+((buffer[1]*0x10000)&0xff0000)
		+((buffer[2]*0x100)&0xff00)+buffer[3];
}

void packageMsg(unsigned char *dstMsg,unsigned char *msg,int msgSize,int seqNum )
{
	unsigned int sum   = 0;
	unsigned int hWord = 0;
	int          i     = 0;
	unsigned char temp[4];
	unsigned char seq[2];
	
	for ( i=0;i<MSG_MAX_SIZE;i++ )
	{
		dstMsg[PKT_CHECKSUM_SIZE+PKT_SEQNUM_SIZE+PKT_MSG_SIZE+i] = msg[i];
	}
	
	_16to8( seq,seqNum );
	dstMsg[2] = seq[0];
	dstMsg[3] = seq[1];

	_32to8( temp,msgSize );
	dstMsg[4] = temp[0];
	dstMsg[5] = temp[1];
	dstMsg[6] = temp[2];
	dstMsg[7] = temp[3];

	i = 0;
	while ( i < MSG_MAX_SIZE+PKT_CHECKSUM_SIZE+PKT_SEQNUM_SIZE+PKT_MSG_SIZE )
	{
		sum += dstMsg[i]*0x100+dstMsg[i+1];
		i = i + 2;
	}
	hWord = (sum>>16)&0x0000ffff;
	sum   = sum &0x0000ffff;
	sum   = sum + hWord;
	sum   = ~sum;
	
	_32to8( temp,sum );
	dstMsg[0] = temp[2];
	dstMsg[1] = temp[3];
}

int  disPacketMsg( unsigned char *dstMsg,unsigned char *srcMsg )
{
	int i;
	unsigned char temp[4];
	for ( i = 0;i < MSG_MAX_SIZE;i ++ )
	{
		dstMsg[i] = srcMsg[PKT_CHECKSUM_SIZE+PKT_SEQNUM_SIZE+PKT_MSG_SIZE+i];
	}
	temp[0] = srcMsg[4];
	temp[1] = srcMsg[5];
	temp[2] = srcMsg[6];
	temp[3] = srcMsg[7];
	return _8to32( temp );
}

int  checkError( unsigned char* msg )
{
	unsigned int sum  = 0;
	unsigned int hWord = 0;
	int          i     = 0;
	
	while ( i < PKT_CHECKSUM_SIZE+PKT_SEQNUM_SIZE+MSG_MAX_SIZE+PKT_MSG_SIZE )
	{
		sum += ((msg[i]*0x100)&0xff00) + msg[i+1];
		i = i + 2;
	}
	hWord = (sum>>16)&0x0000ffff;
	sum   = sum &0x0000ffff;
	sum   = sum + hWord;
	return (sum^0xffff);
}

int  getSeqNum( unsigned char *pkt )
{
	return ( ((pkt[2]*0x100)&0xff00)+pkt[3] );
}

void _16to8( unsigned char *buffer,int value )
{
	buffer[0] = ((value>>8)&0xff);
	buffer[1] = value&0xff;
}