net_lib.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 783 行 · 第 1/2 页

           // net_lib.cpp: implementation of the net_lib class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "net_lib.h"
#include "net.h"
#include "tcp.h"
#include "udp.h"

#include "log.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

LOG*	g_ptr_net_lib_log	= NULL;


void Sys_Log(const char* strLevel, const char *format,...)
{
	va_list args;
	va_start(args, format);
	char buf[256];
	VSNPRINTF(buf,255,format,args);
	if(g_ptr_net_lib_log)
		g_ptr_net_lib_log->ADD_Log(strLevel, buf);
	else
		printf("%s\r\n",buf);
	/* write to file */
	va_end(args);

}

unsigned long Sys_GetTime()
{
#ifdef WIN32
	return GetTickCount();
#else 
	/* linux */
	timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec*1000+tv.tv_usec/1000);
#endif
}

unsigned long Sys_GetSec()
{
	return time(NULL);	
}

void Sys_Sleep(int ms)
{
#ifdef WIN32
	Sleep(ms);
#else 
	/* linux */
	usleep(ms*1000);
#endif
}

void Sys_CreateConsole(int width, int height)
{
#ifdef WIN32
	HANDLE hStdOut;
    AllocConsole();
    SetConsoleTitle("Debug Window");
    hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 
    COORD co = {width , height};
    SetConsoleScreenBufferSize(hStdOut, co); 
    freopen("CONOUT$","w+t",stdout);
    freopen("CONIN$","r+t",stdin);
#endif
}



bool Net_Startup(int VersionHigh,int VersionLow)
{
#ifdef WIN32
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
 
	wVersionRequested = MAKEWORD(VersionHigh,VersionLow);
    err=WSAStartup(wVersionRequested, &wsaData);
	
	/* startup failed */
	if (err!=0)									
	{
		Sys_Log("net_lib_log", "WSAStartup Error");
		WSACleanup();
		return false;
	}

	/* version error */
	if (LOBYTE(wsaData.wVersion)!= VersionLow ||
        HIBYTE(wsaData.wVersion)!= VersionHigh ) 
	{
		Sys_Log("net_lib_log", "WSAStartup Version Error");
		WSACleanup();
		return false;
	}
	//Sys_Log("WSAStartup OK");
#endif
	return true;
}

bool Net_Cleanup()
{
#ifdef WIN32	
	WSACleanup();
#endif
	return true;
}

bool NET_CanRead(SOCKET socket)
{
	fd_set readfds;
	timeval timeout;

	timeout.tv_sec=0;
	timeout.tv_usec=0;
	FD_ZERO(&readfds);
	FD_SET(socket,&readfds);
	int ret = select(FD_SETSIZE,&readfds,NULL,NULL,&timeout);
	if(ret > 0 && FD_ISSET(socket,&readfds))
		return true;
	else 
		return false;
}

bool NET_CanWrite(SOCKET socket)
{
	fd_set writefds;
	timeval timeout;

	timeout.tv_sec=0;
	timeout.tv_usec=0;
	FD_ZERO(&writefds);
	FD_SET(socket,&writefds);
	int ret = select(FD_SETSIZE,NULL,&writefds,NULL,&timeout);
	if(ret > 0 && FD_ISSET(socket,&writefds))
		return true;
	else 
		return false;
}

bool NET_HasExcept(SOCKET socket)
{
	fd_set exceptfds;
	timeval timeout;

	timeout.tv_sec=0;
	timeout.tv_usec=0;
	FD_ZERO(&exceptfds);
	FD_SET(socket,&exceptfds);
	int ret = select(FD_SETSIZE,NULL,NULL,&exceptfds,&timeout);
	if(ret > 0 && FD_ISSET(socket,&exceptfds))
		return true;
	else 
		return false;
}

bool NET_WaitForRead(SOCKET socket, long time_out_sec)
{
	fd_set readfds;
	timeval timeout;

	timeout.tv_sec=time_out_sec;
	timeout.tv_usec=0;
	FD_ZERO(&readfds);
	FD_SET(socket,&readfds);
	int ret = select(FD_SETSIZE,&readfds,NULL,NULL,&timeout);
	if(ret > 0 && FD_ISSET(socket,&readfds))
		return true;
	else 
		return false;
}
bool NET_WaitForWrite(SOCKET socket, long time_out_sec)
{
	fd_set writefds;
	timeval timeout;

	timeout.tv_sec=time_out_sec;
	timeout.tv_usec=0;
	FD_ZERO(&writefds);
	FD_SET(socket,&writefds);
	int ret = select(FD_SETSIZE,NULL,&writefds,NULL,&timeout);
	if(ret > 0 && FD_ISSET(socket,&writefds))
		return true;
	else 
		return false;
}

NET_Packet*	NET_CreatePacket(int size)
{
	return new NET_Packet(size);
}

bool NET_SetSendBufferSize(SOCKET socket, int len)
{
	int ret;
	ret = setsockopt(socket,SOL_SOCKET,SO_SNDBUF,(char *)&len,sizeof(len));
	if (ret == SOCKET_ERROR) return false;
	return true;
}

bool NET_SetRecvBufferSize(SOCKET socket, int len)
{
	int ret;
	ret = setsockopt(socket,SOL_SOCKET,SO_RCVBUF,(char *)&len,sizeof(len));
	if (ret == SOCKET_ERROR) return false;
	return true;
}

unsigned long NET_GetLocalIP()
{
	char szHostName[128];
	HOSTENT *lpHost=NULL;
    struct sockaddr_in sock;

	gethostname(szHostName, sizeof(szHostName));
    lpHost = gethostbyname(szHostName);
	if (lpHost != NULL)
    {
		for(int i=0; lpHost->h_addr_list[i] != NULL ;i++)
        {
			memcpy(&(sock.sin_addr), lpHost->h_addr_list[i], lpHost->h_length);
			if (i == 0)
			{
				return sock.sin_addr.S_un.S_addr;
			}
			else
			if (i == 1)
			{
				return sock.sin_addr.S_un.S_addr;
				//SetDlgItemText(IDC_IPADDRESS2, inet_ntoa(sock.sin_addr));
			}
		}
	}
	return 0;
}
/* 
 * get local address 
 */
bool NET_GetLocalAddr(SOCKET socket, char *addr, short *port, unsigned long *ip)
{
	SOCKADDR_IN addrLocal;
	socklen_t len = sizeof(addrLocal);
	if(getsockname(socket,(SOCKADDR*)&addrLocal,&len)==SOCKET_ERROR)
		return false;
	
	char *tmp = inet_ntoa(addrLocal.sin_addr);
	if(!tmp) 
		return false;
	if(addr) 
		strcpy(addr,tmp);
	if(port)
		*port = ntohs(addrLocal.sin_port);
	if(ip) 
		*ip = addrLocal.sin_addr.s_addr;
	return true;
}

/* 
 * get remote address 
 */
bool NET_GetRemoteAddr(SOCKET socket, char *addr, short *port,unsigned long *ip)
{
	sockaddr_in addrRemote;
	int len = sizeof(addrRemote);
	if(getpeername(socket,(sockaddr *)&addrRemote,(socklen_t *)&len)==SOCKET_ERROR)
		return false;
	
	char *tmp = inet_ntoa(addrRemote.sin_addr);
	if(!tmp) 
		return false;
	if(addr)
		strcpy(addr,tmp);
	if(port)
		*port = ntohs(addrRemote.sin_port);
	if(ip)
		*ip = addrRemote.sin_addr.s_addr; 
	return true;
}

bool NET_SetReuseAddr(SOCKET socket, bool reuse)
{
#ifndef WIN32
	/* only useful in linux */
	int opt = 0;
	unsigned int len = sizeof(opt);

	if(reuse) opt = 1;
	if(setsockopt(socket,SOL_SOCKET,SO_REUSEADDR,
		(const void*)&opt,len)==SOCKET_ERROR)
	{
		return false;
	}
	else
	{
		return true;
	}
#endif
	return true;
}



/*
//DWORD thread_UDP_transfers( LPVOID lpParam )
THREAD_FUNC(thread_UDP_transfers)
{
	if(lpParam==NULL)
		return 0;
	UDP_Socket* ptr_socket	= (UDP_Socket*)lpParam;

//	ptr_socket->ThreadInit();

	NET_Packet*	ptr_recv_packet	= new NET_Packet;
	NET_Packet*	ptr_send_packet = NULL;
	time_t time_ref = Sys_GetTime();
	while(ptr_socket->m_wait_thread_end==false)
	{
		time_t tm	= Sys_GetTime();

		//send request packet
		if(ptr_send_packet==NULL)
		{
			ptr_send_packet = ptr_socket->PopSendPacket();
		}

		if(ptr_send_packet && ptr_socket->CanWrite())
		{
			ptr_send_packet->send(ptr_socket);
			delete(ptr_send_packet);
			ptr_send_packet = NULL;
		}

		//recv packet
		if(ptr_socket->CanRead() && ptr_recv_packet->recv(ptr_socket)>0)
		{
			if(ptr_socket->PushRecvPacket(ptr_recv_packet, tm))
				ptr_recv_packet	= new NET_Packet;
		}

		//连线检测
 		if(tm - time_ref>1000)
		{
			ptr_socket->CheckConnect(tm);
			time_ref	= tm;
		}



		Sys_Sleep(10);
	}

	//exit thread
	if(ptr_recv_packet)
		delete(ptr_recv_packet);
	if(ptr_send_packet)
		delete(ptr_send_packet);
	ptr_socket->m_wait_thread_end	= false;
	ptr_socket->ThreadEnd();
	return 0;
}
*/

THREAD_FUNC(thread_UDP_send)
{
	if(lpParam==NULL)
		return 0;
	THREAD_PARAM_DATA* pTPD	= (THREAD_PARAM_DATA*)lpParam;
	pTPD->Lock();
	pTPD->Lock_Runing();
	UDP_Socket*	ptr_socket	= (UDP_Socket*)pTPD->ptr_arg;
	pTPD->Unlock();
	if(ptr_socket==NULL)
	{
		pTPD->Unlock_Runing();
		THREAD_END(pTPD);
		return 0;
	}

	NET_Packet*	ptr_send_packet	= NULL;
	while(pTPD->command!=THREAD_POOL_CMD_SHUTDOWN)
	{
		//send request packet
		if(ptr_send_packet==NULL)
		{
			ptr_send_packet = ptr_socket->PopSendPacket();