net_clienttcp.cpp

实时监控

#include "stdafx.h"
#include "net_clienttcp.h"
#include "net.h"

extern FILE *fppppp;
extern int start_port;
extern int unused_port();
extern BOOL port_type[MAX_PORT];

net_clienttcp::net_clienttcp()
{
	bind_port = 0;
	connect_socket = NULL;
}


net_clienttcp::~net_clienttcp()
{
	destroy();
}

bool net_clienttcp::create(ULONG connectip, USHORT connectport, USHORT bindport,BOOL bUdpav)
{
	_ip = connectip;
	_port = connectport;
	if(bUdpav)
		connect_socket = socket(AF_INET, SOCK_DGRAM, 0);
	else
		connect_socket = socket(AF_INET, SOCK_STREAM, 0);
	if( INVALID_SOCKET == connect_socket )
		return false;

	if(!bUdpav)
	{
		int optval = 1;
		int err = setsockopt(connect_socket, IPPROTO_TCP, TCP_NODELAY, (char*)&optval, sizeof(optval));
		if( err == SOCKET_ERROR ) 
			return false;
	}
		
	int len = 32768*3;
	int err = setsockopt(connect_socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int));
	
	if(!bind_socket())
		return false;

	if(!connect_server(connectip, connectport))
		return false;

	thrd_start(THREAD_PRIORITY_NORMAL) ;
	
	return true;
}

bool net_clienttcp::bind_socket()
{
	bind_port = unused_port();
	if(bind_port==-1)
	{
		AfxMessageBox("端口绑定失败,请重启客户端");
		return FALSE;
	}
	SOCKADDR_IN m_sockserveraddr;
	m_sockserveraddr.sin_family = AF_INET;
    m_sockserveraddr.sin_addr.s_addr = INADDR_ANY;   
    m_sockserveraddr.sin_port = htons(bind_port);

	int result = bind(connect_socket,(LPSOCKADDR)&m_sockserveraddr,sizeof(m_sockserveraddr));
    if (result == SOCKET_ERROR)
	{
		if(WSAGetLastError() == WSAEADDRINUSE )
		{
			while(1)
			{
				if(bind_socket())
					break;
			}
		}
		else
			return false;
	}

	return true;
}

bool net_clienttcp::connect_server(ULONG ip, USHORT port)
{
	SOCKADDR_IN sockstruct;
	sockstruct.sin_port = htons(port);
	sockstruct.sin_family = AF_INET; 
	sockstruct.sin_addr.S_un.S_addr = ip; 

	unsigned long ul = 1;
	int result = ioctlsocket(connect_socket, FIONBIO, (unsigned long*)&ul);
	if(result == SOCKET_ERROR)
		return false;
	
	connect(connect_socket, (LPSOCKADDR)&sockstruct, sizeof(SOCKADDR_IN));

	FD_SET a;
	if(connect_socket == INVALID_SOCKET)
		return false;
	FD_ZERO(&a);
	FD_SET(connect_socket, &a);
	timeval tv = {3, 0};

	result = select(0, NULL, &a, NULL, &tv);
	if(result<1)
		return false;
	
	ul= 0 ;
	result = ioctlsocket(connect_socket, FIONBIO, (unsigned long*)&ul);
	if(result == SOCKET_ERROR)
		return false;

	return true;
}

void net_clienttcp::clossock()
{
	if(connect_socket)
	{
		thrd_terminate_close();
		closesocket(connect_socket);
		connect_socket = NULL;
//		release_port();
		on_disconnect(_ip, _port);
	}
}

void net_clienttcp::destroy()
{
	if(connect_socket)
	{
		thrd_close(1000);
		closesocket(connect_socket);
		connect_socket = NULL;
//		release_port();
	}
}

bool net_clienttcp::got_something()
{
	int err =0;
	if(!connect_socket)
		return TRUE;
	err = recv(connect_socket, (char*)getdatabuf, 8192, 0);
	if( err == SOCKET_ERROR || !err)
	{
		clossock();
		return false;
	}

	return on_net_tcp_recv(getdatabuf, err, _ip, _port);
}

void net_clienttcp::send_something(char * buf, int length)
{
	if(!connect_socket)
		return;

	int err = send(connect_socket, buf, length, 0);
	if( err == SOCKET_ERROR ) 
	{
		clossock();
		return;	
	}
}

void net_clienttcp::shutdownsocket()
{
//	shutdown(connect_socket, 1);
}

void net_clienttcp::entry()
{
	FD_SET a;
	int err = 0;
	timeval tv = {0,200000};

	while(1)
	{
		if( check_exit() )
			break;

		if( !connect_socket )
			Sleep(40);

		FD_ZERO(&a);
		FD_SET(connect_socket, &a);
		err = select(0, &a, NULL, NULL, &tv);
		if( err > 0 )
		{
			if(!got_something())
				return;
		}
	}
}

BOOL net_clienttcp::join(ULONG ip,USHORT port)
{
	int err = 0;
	net_addr local;
	memset(&local, 0, sizeof(net_addr));
	
	ip_mreq im;
	memset(&im, 0, sizeof(im));
	im.imr_interface.s_addr = INADDR_ANY;
	im.imr_multiaddr.s_addr = ip;
///////////////////////////////////////////////////////////

	int ttl = 8;
	BOOL loopback = FALSE;
	//////////////////////////////////////////////////////////
	err = setsockopt(connect_socket, 0, IP_MULTICAST_TTL, (char*)&ttl, sizeof(int));
	err = setsockopt(connect_socket, 0, IP_MULTICAST_LOOP, (char*)&loopback, sizeof(BOOL));
	
	//						IP_ADD_MEMBERSHIP, WS11:(5) WS22:(12)
	err = setsockopt(connect_socket, 0,	IP_ADD_MEMBERSHIP, (char*)&im, sizeof(im));
	
	err = WSAGetLastError();
	return TRUE;
}

BOOL net_clienttcp::create_udp_socket(ULONG ip,USHORT port)
{
//	thrd_close(1000);
	int err = 0;
	net_addr local;
	local.set_real_port(port);
	closesocket(connect_socket);
	connect_socket = NULL;
//	release_port();
	
	connect_socket = socket(AF_INET, SOCK_DGRAM, 0);
	if( INVALID_SOCKET == connect_socket)
		return FALSE;
	int len = 32768*3;
	err = setsockopt(connect_socket, SOL_SOCKET, SO_RCVBUF, (char*)&len, sizeof(int));
	
	err = bind(connect_socket, (sockaddr*)(&local), sizeof(local));
	
	if( SOCKET_ERROR == err )
	{
		return FALSE;
	}
	return TRUE;
//	thrd_start(THREAD_PRIORITY_NORMAL) ;
}

void net_clienttcp::release_port()
{
	if(!bind_port)
		return;
	if(bind_port>=start_port)
		port_type[bind_port-start_port] = FALSE;
	else 
		port_type[END_PORT+start_port-bind_port] = FALSE;
	bind_port = 0;
}