alarm server.cpp

实时监控

#include "stdafx.h"
#include "net_cmd.h"
#include "net_cmdtcp.h"
#include "alarm server.h"

extern FILE *fppppp;

DWORD WINAPI ListenServerThread(LPVOID pnet)
{
	net_alarmserver * p  = (net_alarmserver *)(pnet);
	if(!p || p->server_socket == INVALID_SOCKET)
		return 0;

	FD_SET a;
	int result;
	timeval tv = {0, 200000};

	while(1)
	{
		if(p->m_lisen_exit)
			return 0;

		listen(p->server_socket, 5);
		
		FD_ZERO(&a);
		FD_SET(p->server_socket, &a);
		result = select(0, &a, NULL, NULL, &tv);
		if(!result)
			continue;

		if(result>0)
		{
			accept_connect * pc = new  accept_connect;
			pc->accept_socket = accept(p->server_socket, &(pc->m_acceptsockaddr), 0);
			if(pc->accept_socket != INVALID_SOCKET)
			{
				u_long  arg = 1;
				ioctlsocket(pc->accept_socket, FIONBIO, &arg);
				p->connect_vect.push_back(pc);
			}
		}
	}
}


net_alarmserver::net_alarmserver()
{
	m_lisen_exit = FALSE;
	connect_vect.reserve(64);

	FD_ZERO(&InternalReadfds);
	ListenThreadHandle = NULL;
	server_socket = NULL;
}

void net_alarmserver::destroy()
{
	m_lisen_exit = TRUE;
	if(ListenThreadHandle)
	{
		WaitForSingleObject(ListenThreadHandle, INFINITE) ;
		CloseHandle(ListenThreadHandle);
		ListenThreadHandle = NULL;
	}

	if(server_socket)
	{
		thrd_close(1000);
		closesocket(server_socket);
		server_socket = NULL;
	}

	for(cit pit = connect_vect.begin(); pit != connect_vect.end(); pit++)
	{
		accept_connect * p = *pit;
		delete p;
	}
}

bool net_alarmserver::create(USHORT bindport)
{	
	server_socket = socket(AF_INET, SOCK_STREAM, 0);
	if( INVALID_SOCKET == server_socket )
		return false;

	int optval = 1;
	int err = setsockopt(server_socket, IPPROTO_TCP, TCP_NODELAY, (char*)&optval, sizeof(optval));
	if( err == SOCKET_ERROR ) 
		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(bindport);

	int result = bind(server_socket, (LPSOCKADDR)&m_sockserveraddr, sizeof(m_sockserveraddr));
    if (result == SOCKET_ERROR)
		return false;
	
	DWORD ThreadID;
	ListenThreadHandle = CreateThread(NULL, 0, ListenServerThread, this, 0,  &ThreadID);
    if(!ListenThreadHandle)
		return false;

	SetThreadPriority(ListenThreadHandle, THREAD_PRIORITY_NORMAL) ;
	thrd_start(THREAD_PRIORITY_NORMAL) ;

	return true;
}

void net_alarmserver::got_something()
{
	for(cit pit = connect_vect.begin(); pit != connect_vect.end(); pit++)
	{
		accept_connect * p = *pit;
		WSASetLastError(0);
		int len = recv(p->accept_socket, (char*)getdatabuf, 512, 0);
		if(len>0)
		{
			on_net_tcp_recv(getdatabuf, len);
		}
		else
		{
			if(!len || WSAECONNRESET == WSAGetLastError())
			{
				FD_CLR(p->accept_socket, &InternalReadfds);
				closesocket(p->accept_socket);

				delete p;
				connect_vect.erase(pit);
				pit--;
			}
		}
	}
}

void net_alarmserver::entry()
{
	int result = 0;
	timeval tv = {0, 200000};

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

		if( !server_socket )
			break;

		if(!connect_vect.size())
		{
			Sleep(200);
			continue;
		}

		FD_ZERO(&InternalReadfds);
		for(cit pit = connect_vect.begin(); pit != connect_vect.end(); pit++)
		{
			accept_connect * p = *pit;
			FD_SET(p->accept_socket, &InternalReadfds);
		}

		result = select(0, &InternalReadfds, NULL, NULL, &tv);
		if( result > 0 )
			got_something();
	}
}

int find_flag_postion(byte* buf, int length)
{
	int pos = 0;
	while(pos < length)
	{
		if(buf[pos++] == ':')
			break;
	}
	return pos;
}


bool net_alarmserver::on_net_tcp_recv(byte* buf, int length)
{
	int index;
	int pos = 0;
	if(length <8)
		return false;

	while(pos < length)
	{
		if(buf[pos++] != 'R' || buf[pos++] != 'M' || buf[pos++] != 'S' || buf[pos++] != '&' || buf[pos++] != ':')
			continue;

		//second ":"
		index = find_flag_postion(buf+pos, length - pos);
		if(!index)
			break;
		pos += index; 

		//third ":"
		index = find_flag_postion(buf+pos, length - pos);
		if(!index)
			break;
		pos += index; 
	
		if(buf[pos++] !='M' || buf[pos++] != 'B' || buf[pos++] != 'C')
			continue;

		//fourth ":"
		index = find_flag_postion(buf+pos, length - pos);
		if(!index)
			break;
		pos += index; 

		ULONG cmd;
		USHORT data_len;
		
		if(pos >= length)
			break;
		memcpy(&cmd, buf+pos, 4);
		if(cmd != 2801)
			continue;
		pos += 4;
		
		if(pos >= length)
			break;
		memcpy(&data_len, buf+pos, 2);
		pos += 2;

		int id_len = data_len - 4 -2 ;
		if(id_len <= 0)   
			continue;

		ULONG stationid;
		if(pos >= length)
			break;
		memcpy(&stationid, buf+pos, 4);
		pos += 4;

		char alarmsgid[20];
		if(pos >= length)
			break;
		memcpy(alarmsgid, buf+pos, id_len);
		pos += id_len;
		ULONG sgid = atoi(alarmsgid); 

		send_alarm_id(stationid, sgid);
	}

	return true;
}

void net_alarmserver::send_alarm_id(DWORD pstid, DWORD psgid)
{
	HWND m_hwnd = NULL; 
	net_cmd *p =	net_cmd::m_netcmdp;
	net_cmdtcp *pp =	net_cmdtcp::m_netcmdp;
	
	if(p)
		m_hwnd = p->get_cmdhwnd();
	else if(pp)
		m_hwnd = pp->get_cmdhwnd();
	
	if(IsWindow(m_hwnd))
		SEND_NOTIFY(m_hwnd, NTM_ALARM_SERVER, (WPARAM)pstid, (LPARAM)psgid);
}