host.c

实现网络流量的生成,为cs结构,可以控制流量大小

//                                     //
//*********** host.c ***************   //
//                                     // 

#include <stdio.h>
#include <windows.h>
#include "packet.h"

#define PKTLEN  100			//信息数据包的大小

static BOOL ControlSocketInit();
static BOOL SocketSend( SOCKET mySocket, unsigned char *buf, int len, struct sockaddr *recipient );
static int  SocketRcv( SOCKET mySocket, unsigned char *buf, int bufSize, struct sockaddr *sender );

DWORD WINAPI ThreadFunc( LPVOID lpParam ) ;
					
static SOCKET  mySocket, ControlSocket, RemoteSocket; 
static struct  PKT pkt;
static struct  REINFO  reinfo;
//static struct  SENDERINFO  senderinfo;
//static struct  RECVERINFO  recverinfo;


SOCKADDR_IN  ControlAddr, LocalAddr, RemoteAddr;
struct sockaddr  recipient, sender;
static int Port; 



char    SenderIP;
float   lostpercent;  
double  deltime;
int     pktLen;



BOOL WINAPI DllMain ( HINSTANCE hInstance, DWORD fdwReason, PVOID pvReserved )
{ 
	return TRUE; 
}
    

                  
static HWND g_hwnd1,g_hwnd2;
static unsigned int notifyMsg = WM_USER+100;           
/* 创建线程,专门用来进行监听反馈到控制台的信息 */
DWORD WINAPI ThreadFunc( LPVOID lpParam ) 
{
	int  pktSize;
	char sendnumberinfo[10];
	char recvnumberinfo[10];
	char deltime[10];
	int  delaytime6;
	char numberinfo[30];

	//memset( &reinfo, 0, sizeof(struct REINFO) );
	pktSize = sizeof( struct sockaddr );
	
	while( 1 )
	{
		recvfrom( ControlSocket,
	     		  ( char * )&reinfo,
			  sizeof( struct REINFO ),
			  0,
			  ( SOCKADDR * )&ControlAddr,
			  &pktSize     
			);
		
		switch ( reinfo.pktType )
		{  
			case PKT_SEND_STARTED:
			     reinfo.pktType = 0;
			     //MessageBox( NULL, "hello", "sendder begin to send!", 0 );
			     PostMessage( g_hwnd2, notifyMsg, (int)(inet_ntoa(ControlAddr.sin_addr)), 0 );
			     Sleep(300);
			break;
		
			case PKT_SEND_REINFO:
		             reinfo.pktType = 0;
		             //MessageBox( NULL, "hello", "receive from sender success!!", 0 );	
		             delaytime6 = (int)(reinfo.senderinfo.delaytime*1000000);
		             itoa( delaytime6, deltime, 10 );
	 	
		             PostMessage( g_hwnd1, notifyMsg, (int)(inet_ntoa(ControlAddr.sin_addr)), 
			                  (int)(deltime) ); 
			break;

			case PKT_RECV_REINFO:
		             reinfo.pktType = 0;
		             //MessageBox( NULL, "hello", "receive from recver success!!", 0 );			    
		
		             itoa( reinfo.recverinfo.sendnumber, sendnumberinfo, 10 );
			     itoa( reinfo.recverinfo.recvnumber, recvnumberinfo, 10 );
			     strcpy( numberinfo, sendnumberinfo );
			     strcat( numberinfo, "*" );
			     strcat( numberinfo, recvnumberinfo );
			     
			     PostMessage( g_hwnd1, notifyMsg, (int)(numberinfo), 0 );
			break;

			case PKT_SEND_STOPPED:
			     reinfo.pktType = 0;
			     //MessageBox( NULL, "hello", "sender have stopped!", 0);

			     PostMessage( g_hwnd2, notifyMsg, (int)("sender stopped!"), 0 );
			break;

			case PKT_RECV_STOPPED:
			     reinfo.pktType = 0;
			     //MessageBox( NULL, "hello", "recver have stopped!", 0);

			     PostMessage( g_hwnd2, notifyMsg, (int)("recver stopped!"), 0 );
			break;

			default:
			break;
		}/* switch */	   
	}/* while */		
	return 0; 
} 



/* 初始化控制端Socket,创建本地套接字,解析接收方IP地址 */
BOOL ControlSocketInit()
{
	WSADATA   LwsaData;
   
	/* startup Winsock2 DLL*/
	WSAStartup(MAKEWORD( 2, 2 ), &LwsaData );
   
	/* creat socket */
	ControlSocket = socket( AF_INET, SOCK_DGRAM, 0 );
	if ( ControlSocket == INVALID_SOCKET )
	return( FALSE );
   
	memset( &ControlAddr, 0, sizeof(ControlAddr) );
	ControlAddr.sin_family = AF_INET;
	ControlAddr.sin_port = htons( (short)Port );
	ControlAddr.sin_addr.s_addr = htonl( INADDR_ANY );
	//if ( bind( ControlSocket, (SOCKADDR *)&ControlAddr, sizeof(ControlAddr)) == SOCKET_ERROR )
	//return FALSE ;

	return TRUE;
}/* ControlSocketInit() */



/* 初始化发送端Socket */
BOOL LocalSocketInit( char *SenderIP )
{
	memset( &LocalAddr, 0, sizeof(LocalAddr) );
	LocalAddr.sin_family = AF_INET;
	LocalAddr.sin_port = htons( 7749 );
	LocalAddr.sin_addr.s_addr = inet_addr( SenderIP );
	return TRUE;
}/* LocalSocketInit() */



/* 初始化接收端Socket,创建套接字,解析接收端IP地址 */
static BOOL RemoteSocketInit( char* szRecipient, int Port )
{
	WSADATA   RwsaData;
	/* startup Winsock2 DLL*/
	WSAStartup( MAKEWORD(2, 2), &RwsaData );
   
	/* creat socket */
	RemoteSocket = socket( AF_INET, SOCK_DGRAM, 0 );
	if ( RemoteSocket == INVALID_SOCKET )
	return( FALSE );
   
	memset( &RemoteAddr, 0, sizeof(RemoteAddr) );
	RemoteAddr.sin_family = AF_INET;
	RemoteAddr.sin_port = htons( (short)Port );
	RemoteAddr.sin_addr.s_addr = inet_addr( szRecipient );

	return TRUE;
}/* RemoteSocketInit() */


/* 发送函数 */
static BOOL SocketSend( SOCKET mySocket, unsigned char *buf, int len, struct sockaddr *recipient )
{
	int result;                    
	result = sendto( mySocket,
		         buf,
        	         len,
			 0,
                         recipient,
			 sizeof(struct sockaddr)
		       );
	if ( result == SOCKET_ERROR )
	return FALSE;	    
	else 
	return TRUE;
} /* SocketSend() */



/* 接收函数 */
static int  SocketRcv( SOCKET mySocket, unsigned char *buf, int bufSize, struct sockaddr *sender )
{
	fd_set  fdSet;
	struct timeval  timeVal;
	int msgLen, temp, result;

	fdSet.fd_count = 1;
	fdSet.fd_array[0] = mySocket;
	timeVal.tv_sec = 3;
	timeVal.tv_usec = 500000;                                       
	result = select( 0, &fdSet, NULL, NULL, &timeVal );
	if ( result == 0 )
	return 0;
	if ( result == SOCKET_ERROR )
	return -1;
	temp = sizeof( struct sockaddr );
	msgLen = recvfrom( mySocket,
		           buf,
			   bufSize,
			   0,
			   sender,
			   &temp );
	if ( msgLen == SOCKET_ERROR || msgLen == 0 )
	    return -1;
	else
            return msgLen;
}/* SocketRcv() */



/* 初始化控制台 */
EXPORT BOOL CONTROLSOCKETINIT()
{ 
	DWORD dwThreadId, dwThrdParam = 1; 
	HANDLE hThread; 
	
	ControlSocketInit();
	
	hThread = CreateThread(			// create a separted thread	
		NULL,				// default security attributes 
		0,				// use default stack size  
		ThreadFunc,			// thread function 
		&dwThrdParam,			// argument to thread function 
		0,				// use default creation flags 
		&dwThreadId );			// returns the thread identifier                
 
	return TRUE;
}/* CONTROLSOCKETINIT */
 


int Num = 1;
/* 1.初始化发送端 2.初始化接收端 3.发送控制相关信息，请求发送端开始发送 */
EXPORT BOOL COMM_STARTTOSEND( char *SenderIP, char* szRecipient, int Port, int pktLen, int sleeptime )
{
	LocalSocketInit( SenderIP );
	RemoteSocketInit( szRecipient, Port );		
	pkt.type = PKT_SEND_START;		// 请求开始发送的信号
	pkt.num = Num;				// 对各个发送端进行编号
	strcpy( pkt.ip, szRecipient );		// 接收方的ip地址
	pkt.port = Port;                        // 接收方的端口号
	pkt.pktLen = pktLen;                    // 定义数据包的大小
	pkt.sleeptime = sleeptime;              // 发送数据包的时间间隔   
		
	SocketSend( ControlSocket, 
	 	    (char *)&pkt,
                    PKTLEN,
	            (SOCKADDR *)&LocalAddr );
	Num = Num + 1;
	return TRUE;
}/* COMM_STARTTOSEND */



/* 请求发送端返回当前网络时延 */				
EXPORT BOOL COMM_RESENDERINFO( char *SenderIP )
{
	LocalSocketInit( SenderIP );
	pkt.type = PKT_SEND_INFO;
	SocketSend( ControlSocket, 
		    (char *)&pkt,
		    PKTLEN,
       		    (SOCKADDR *)&LocalAddr );	
	return TRUE;	 
}/* COMM_RESENDERINFO() */



/* 请求接收端返回已发送的和已接收的数据包数 */
EXPORT BOOL COMM_RERECVERINFO()
{ 	
	pkt.type = PKT_RECV_INFO;     	 
	SocketSend( ControlSocket,
	            (char *)&pkt,
                    PKTLEN,
	            (SOCKADDR *)&RemoteAddr );    	
	return TRUE;
}/* COMM_RERECVERINFO */

 

/* 请求发送端停止发送 */
EXPORT BOOL COMM_STOPTOSEND( char *SenderIP )
{   
	LocalSocketInit( SenderIP );
	Num = 1;
	pkt.type = PKT_SEND_STOP;         
	SocketSend( ControlSocket, 
	            (char *)&pkt,
		    PKTLEN,
       	            (SOCKADDR *)&LocalAddr );	
	return TRUE;
}/* COMM_STOPTOSEND */



/* 请求接收端停止接收 */
EXPORT BOOL COMM_STOPTORECV()
{   
	pkt.type = PKT_RECV_STOP;         
	SocketSend( ControlSocket, 
	            (char *)&pkt,
		    PKTLEN,
                    (SOCKADDR *)&RemoteAddr );	
	return TRUE;
}/* COMM_STOPTORECV */


EXPORT void GiveWndHandle( HWND hwnd1, HWND hwnd2 )	//获取两个窗口句柄
{
	g_hwnd1 = hwnd1;		//对应窗口为发送数据包数，接收数据包数和网络时延信息
	g_hwnd2 = hwnd2;		//对应窗口为请求开始发送和停止发送、接收信息
}