wisenet.cpp

network library that can be use all network application!

#include <stdio.h>
#include "wisenet.h"

extern "C" {
	DWORD WINAPI WiseNetSendingProc(LPVOID Param);
	DWORD WINAPI WiseNetRecvingProc(LPVOID Param);
};

CWiseNet::CWiseNet(int a_QFlag, int a_IpFlag)
{
	m_SleepTime = 1;
	m_RSocket = -1;
	m_SSocket = -1;
	m_SPort = 0;
	m_RPort = 0;
	m_RecvFunc = NULL;
	m_RecvFlag = 0;
	m_WaitFlag = WN_NOWAIT;

	m_QueueFlag = a_QFlag;
	m_IpFlag = a_IpFlag;

	m_HEvent = 0;
	m_SQEvent = 0;
	m_RQEvent = 0;

	if(m_QueueFlag == WN_QUEUE_USE) {

		m_SQStart = 0;
		m_SQEnd = 0;
		m_RQStart = 0;
		m_RQEnd = 0;
		m_SRQFlag = 0;

		memset(&m_SQData, 0x00, sizeof(m_SQData));
		memset(&m_RQData, 0x00, sizeof(m_RQData));
	}
	InitializeCriticalSection(&m_SockSection);
}

CWiseNet::~CWiseNet()
{
	m_SRQFlag = 0;
	Close();
	DeleteCriticalSection(&m_SockSection);
}

int	CWiseNet::Open(char *ap_Port, int a_Flag)
{
	if(ap_Port == NULL) {
		return(Open(-1, a_Flag));
	} else {
		return(Open((int)atoi(ap_Port), a_Flag));
	}
}

int	CWiseNet::Open(int a_Port, int a_Flag)
{
	WSADATA w_SData;
	struct	sockaddr_in	w_Addr;

	if(m_RSocket >= 0) {
		return(1);
	}

	if (WSAStartup(0x0202,&w_SData) != 0 ) {
		return(WN_SOCKET_ERR);
	}

	if((m_RSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		return(WN_SOCKET_ERR);
	}
	if(a_Port >= 0) {
		m_RPort = a_Port;
	}

	if(a_Flag) {	// SEND SOCKET 喊档 荤侩
		if((m_SSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
			return(WN_SOCKET_ERR);
		}
	} else {
		m_SSocket = m_RSocket;
	}

	memset((char *)&w_Addr, 0x00, sizeof(w_Addr));

	if(a_Flag) {	// SEND SOCKET 喊档 荤侩
		w_Addr.sin_family = AF_INET;
		w_Addr.sin_addr.s_addr = htonl(0); 
		w_Addr.sin_port = htons(0);
		if(bind(m_SSocket, (struct sockaddr *)&w_Addr, sizeof(w_Addr)) < 0) {
			m_SSocket = -1;
			return(WN_BIND_ERR);
		}
	}

	w_Addr.sin_family = AF_INET;
	w_Addr.sin_addr.s_addr = htonl(INADDR_ANY); 
	w_Addr.sin_port = htons(m_RPort);

	if(bind(m_RSocket, (struct sockaddr *)&w_Addr, sizeof(w_Addr)) < 0) {
		m_RSocket = -1;
		return(WN_BIND_ERR);
	}  

	if(a_Flag) {	// SEND SOCKET 喊档 荤侩
		int w_SockLen = sizeof(struct sockaddr);

		if(getsockname(m_SSocket, (struct sockaddr *)&w_Addr, &w_SockLen) != 0) {
			return(WN_SOCKET_ERR);
		} 
		m_SPort = ntohs(w_Addr.sin_port);
	} else {
		m_SPort = m_RPort;
	}
	

	if(m_QueueFlag == WN_QUEUE_USE) {		// SEND/RECV Q START
		if(StartWisenetProcess() < 0) {
			Close();
			return(WN_THREADSTART_ERROR);
		}
	}

	return(1);
}

int CWiseNet::Send(char *ap_Ip, int a_Port, char *ap_Buff, int a_Len, int a_Flag)
{
	if(m_QueueFlag == WN_QUEUE_USE) {		// SEND/RECV Q START ==> INSERT Q
		if(m_SRQFlag == 1) {
			WN_PACKET	*wp_Packet;
	
			wp_Packet = &m_SQData[m_SQStart];

			wp_Packet->m_RPort = a_Port;
			strcpy(wp_Packet->m_Ip, ap_Ip);
			wp_Packet->m_Len = a_Len;
			memcpy(wp_Packet->mp_Data, ap_Buff, a_Len);

			m_SQStart = (m_SQStart + 1) % WN_SQNUM;
		}
		return(a_Len);
	} else {
		return(SendTo(ap_Ip, a_Port, ap_Buff, a_Len, a_Flag));
	}
}

int CWiseNet::SendTo(char *ap_Ip, int a_Port, char *ap_Buff, int a_Len, int a_Flag)
{
	int		w_Rtn;
	struct	sockaddr_in	w_Addr;

	if(m_SSocket < 0) {
		return(WN_SOCKETNOTOPEN_ERR);
	}

	memset((char *)&w_Addr, 0x00, sizeof(w_Addr));

	if(ap_Ip[0]) {
		w_Addr.sin_family = AF_INET;
		w_Addr.sin_addr.s_addr = inet_addr(ap_Ip); 
		w_Addr.sin_port = htons(a_Port);

		if(m_SSocket == m_RSocket) {
			EnterCriticalSection(&m_SockSection);
		}
		w_Rtn = sendto(m_SSocket, ap_Buff, a_Len, a_Flag, (const struct sockaddr *)&w_Addr, sizeof(w_Addr));
		if(m_SSocket == m_RSocket) {
			LeaveCriticalSection(&m_SockSection);
		}
	} else {
		EROOMIPLIST *wp_IpList;

		if(m_SSocket == m_RSocket) {
			EnterCriticalSection(&m_SockSection);
		}
		StartCSection();
		wp_IpList = Head();
		while(wp_IpList) {
			if(wp_IpList->m_Status & EI_ST_CONNECTED) {
				w_Addr.sin_family = AF_INET;
				w_Addr.sin_addr.s_addr = wp_IpList->m_Ip; 
				w_Addr.sin_port = wp_IpList->m_Port;

				w_Rtn = sendto(m_SSocket, ap_Buff, a_Len, a_Flag, (const struct sockaddr *)&w_Addr, sizeof(w_Addr));
			}
			wp_IpList = wp_IpList->mp_Next;
		}
		EndCSection();
		if(m_SSocket == m_RSocket) {
			LeaveCriticalSection(&m_SockSection);
		}
	}

	if(w_Rtn < 0) {
		return(WN_SEND_ERR);
	}
	return(w_Rtn);
}

int CWiseNet::Send(char *ap_Ip, char *ap_Buff, int a_Len, int a_Flag)
{
	return(Send( ap_Ip, m_RPort, ap_Buff, a_Len, a_Flag));
}

int	CWiseNet::Recv(char *ap_Ip, char *ap_Buff, int &a_Len, int a_WaitTime, int a_Flag)
{
	int	w_Port;

	return(Recv(ap_Ip, w_Port, ap_Buff, a_Len, a_WaitTime, a_Flag));
}

int	CWiseNet::Recv(char *ap_Ip, int &a_Port, char *ap_Buff, int &a_Len, int a_WaitTime, int a_Flag)
{
	if(m_QueueFlag == WN_QUEUE_USE) {		// SEND/RECV Q START ==> INSERT Q
		if(m_SRQFlag == 1) {
			WN_PACKET	*wp_Packet;
	
			if(m_RQEnd != m_RQStart) {
				wp_Packet = &m_RQData[m_RQEnd];
				strcpy(ap_Ip, wp_Packet->m_Ip);
				a_Port = wp_Packet->m_RPort;
				a_Len = wp_Packet->m_Len;
				memcpy(ap_Buff, (char *)wp_Packet->mp_Data, a_Len);
				m_RQEnd = (m_RQEnd + 1) % WN_RQNUM;

				return(a_Len);
			}
		}
		return(0);
	} else {
		return(RecvFrom(ap_Ip, a_Port, ap_Buff, a_Len, a_WaitTime, a_Flag));
	}
}

int	CWiseNet::RecvFrom(char *ap_Ip, int &a_Port, char *ap_Buff, int &a_Len, int a_WaitTime, int a_Flag)

{
	int		w_Nfd;
	fd_set	w_Rfds;
    struct	timeval w_TimeVal;
	struct	sockaddr_in	w_Addr;
	int		w_AddrLen = sizeof(struct sockaddr_in);
	int		w_Len = 0;

	a_Len = 0;

	if(m_RSocket < 0) {
		return(WN_SOCKETNOTOPEN_ERR);
	}
#define __USE_SELECT__
#ifdef __USE_SELECT__ // USE__SELECT
	if(a_WaitTime == WN_NOWAIT) {
		w_TimeVal.tv_sec = 0;
		w_TimeVal.tv_usec = 0 ;
	} else if (a_WaitTime > 0) {
		w_TimeVal.tv_sec = a_WaitTime / 1000;
		w_TimeVal.tv_usec = a_WaitTime % 1000;
	}

	if(m_SSocket == m_RSocket) {
		EnterCriticalSection(&m_SockSection);
	}
	FD_ZERO(&w_Rfds);
	FD_SET(m_RSocket, &w_Rfds);

	if(a_WaitTime == WN_WAITFOREVER) {	// 磷阑锭鳖瘤 扁促覆
		w_Nfd = select(m_RSocket+1, &w_Rfds, NULL, NULL, NULL);
	} else {
		w_Nfd = select(m_RSocket+1, &w_Rfds, NULL, NULL, &w_TimeVal);
	}
	if(w_Nfd >= 0) { 
		if(FD_ISSET(m_RSocket, &w_Rfds)) {
#else			// USE_ioctlsocket
		ioctlsocket(m_RSocket, FIONREAD, (unsigned long *)&w_Len);
		if(w_Len > 0) {
#endif
			w_Len = recvfrom(m_RSocket, ap_Buff, WN_MAX_RECVLEN, 0, (struct sockaddr *)&w_Addr, &w_AddrLen);
			if(w_Len > 0) {
				ap_Buff[w_Len] = 0;

				if(!m_IpFlag) {
					sprintf(ap_Ip, "%d.%d.%d.%d", 
						w_Addr.sin_addr.S_un.S_un_b.s_b1,
						w_Addr.sin_addr.S_un.S_un_b.s_b2,
						w_Addr.sin_addr.S_un.S_un_b.s_b3,
						w_Addr.sin_addr.S_un.S_un_b.s_b4);
				} else {
					ap_Ip[0] = 0;
				}
				a_Port = htons(w_Addr.sin_port);
				a_Len = w_Len;
			} else {
				w_Len = WN_RECV_ERR;
			}
		} else {
			w_Len = WN_RECV_ERR;
		}
#ifdef __USE_SELECT__ // USE__SELECT
	} else if(w_Nfd < 0) {
		return(WN_RECV_ERR);		// Recv 阂啊
	}
#endif
	if(m_SSocket == m_RSocket) {
		LeaveCriticalSection(&m_SockSection);
	}	
	return(w_Len);
}



void CWiseNet::Close()
{
	if(m_RSocket >= 0) {
//		shutdown(m_SSocket, 1);
		closesocket(m_RSocket);
		if(m_RPort != m_SPort) {
			closesocket(m_SSocket);
		}
		WSACleanup();
	}
	m_RSocket = -1;
	m_SSocket = -1;

	if(m_QueueFlag == WN_QUEUE_USE) {
		StopWisenetProcess();
	}
}

int CWiseNet::IsOpened()
{
	return((m_RSocket == -1) ? 0 : 1);
}

int CWiseNet::SetRecvFunc(int (*ap_RecvFunc)(char *ap_Ip, int a_Port, char *ap_Buff, int w_Len), int a_WaitTime)
{
	DWORD		IDThread;
	HANDLE		hThread;
	if(!m_RecvFunc && ap_RecvFunc) {
		m_RecvFlag = 1;
		m_RecvFunc = ap_RecvFunc;
		m_WaitFlag = a_WaitTime;
		m_HEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		hThread = ::CreateThread(NULL, 0, WiseNetRecvProc, this, 0, &IDThread);
		if(!hThread) {
			SetEvent(m_HEvent);
			CloseHandle(m_HEvent);
			m_HEvent = NULL;
			m_RecvFlag = 0;
			m_RecvFunc = NULL;
			return(-1);
		}
	} else if(m_RecvFunc && !ap_RecvFunc) {
		m_RecvFlag = 0;
		if(m_HEvent) {
			WaitForSingleObject(m_HEvent, WN_KILLWAITTIME);
			CloseHandle(m_HEvent);
			m_HEvent = NULL;
		}
	}

	return(1);
}


extern "C" DWORD WINAPI WiseNetRecvProc(LPVOID Param)
{
	int			w_Flag = 0;
	int			w_Port;
	char		w_Ip[256];
	char		w_Buff[WN_MAX_RECVLEN+WN_MAX_RECVLEN];
	int			w_Len;
	int			w_Rtn;
	CWiseNet	*wp_WiseNet = (CWiseNet *)Param;

	if(wp_WiseNet->GetQueueFlag() == WN_QUEUE_USE) {
		WN_PACKET	*wp_Packet;


		while(wp_WiseNet->m_RecvFlag) {
			if(wp_WiseNet->m_SRQFlag ) {
				if(wp_WiseNet->m_RQEnd != wp_WiseNet->m_RQStart) {
					wp_Packet = &wp_WiseNet->m_RQData[wp_WiseNet->m_RQEnd];

					if(wp_WiseNet->m_RecvFunc) {
						wp_WiseNet->m_RecvFunc(wp_Packet->m_Ip, wp_Packet->m_RPort, (char *)wp_Packet->mp_Data, wp_Packet->m_Len);
					}
					wp_WiseNet->m_RQEnd = (wp_WiseNet->m_RQEnd + 1) % WN_RQNUM;
				}
			}
			Sleep(1);
		}
	} else {
		while(wp_WiseNet->m_RecvFlag) {
			w_Rtn = wp_WiseNet->RecvFrom(w_Ip, w_Port, w_Buff, w_Len, wp_WiseNet->m_WaitFlag);
			if(w_Rtn < 0) {
//				printf("Getting Error\n");
//				printf("Open : 1, Send : 2, Close : 3, Wait Flag(Sending):4 QUIT: Q,q!!!!\n");
			} else if(w_Rtn > 0) {
				wp_WiseNet->m_RecvFunc(w_Ip, w_Port, w_Buff, w_Len);
//				printf("Dada : (%s), Ip : (%s)\n", w_Ip, w_Buff);
//				printf("Open : 1, Send : 2, Close : 3, Wait Flag(Sending):4 QUIT: Q,q!!!!\n");
//			} else {
//				printf("Data Nothing\n");
//				printf("Open : 1, Send : 2, Close : 3, Wait Flag(Sending):4 QUIT: Q,q!!!!\n");
			}
			Sleep(1);
		}
	}
	SetEvent(wp_WiseNet->m_HEvent);
	wp_WiseNet->m_RecvFlag = 0;
	wp_WiseNet->m_RecvFunc = NULL;
	return(1);
}


int	 CWiseNet::StartWisenetProcess()
{
	DWORD		IDThread1;
	HANDLE		hThread1;
	DWORD		IDThread2;
	HANDLE		hThread2;
	int			w_II;

	m_SQStart = 0;
	m_SQEnd = 0;
	m_RQStart = 0;
	m_RQEnd = 0;

	if(m_SRQFlag == 1) {
		return(1);
	}
	m_SRQFlag = 1;

	for(w_II=0;w_II<WN_SQNUM;w_II++) {
		m_SQData[w_II].mp_Data = new unsigned char[WN_MAX_SENDLEN+WN_MAX_SENDLEN];
	}

	for(w_II=0;w_II<WN_RQNUM;w_II++) {
		m_RQData[w_II].mp_Data = new unsigned char[WN_MAX_RECVLEN+WN_MAX_SENDLEN];
	}

	m_SQEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	hThread1 = ::CreateThread(NULL, 0, WiseNetSendingProc, this, 0, &IDThread1);
	if(!hThread1) {
		SetEvent(m_SQEvent);
		CloseHandle(m_SQEvent);
		m_SQEvent = NULL;
		m_SRQFlag = 0;
		return(-1);
	}

	m_RQEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	hThread2 = ::CreateThread(NULL, 0, WiseNetRecvingProc, this, 0, &IDThread2);
	if(!hThread2) {
		SetEvent(m_RQEvent);
		CloseHandle(m_RQEvent);
		m_RQEvent = NULL;
		m_SRQFlag = 0;
		return(-1);
	}
	return(1);
}

int  CWiseNet::StopWisenetProcess()
{
	int		w_II;

	if(m_SRQFlag == 0) {
		return(1);
	}
	m_SRQFlag = 0;

	for(w_II=0;w_II<WN_SQNUM;w_II++) {
		delete m_SQData[w_II].mp_Data;
		m_SQData[w_II].mp_Data = NULL;
	}
	for(w_II=0;w_II<WN_RQNUM;w_II++) {
		delete m_RQData[w_II].mp_Data;
		m_RQData[w_II].mp_Data = NULL;
	}
	if(m_SQEvent) {
		WaitForSingleObject(m_SQEvent, WN_KILLWAITTIME);
		CloseHandle(m_SQEvent);
		m_SQEvent = NULL;
	}
	if(m_RQEvent) {
		WaitForSingleObject(m_RQEvent, WN_KILLWAITTIME);
		CloseHandle(m_RQEvent);
		m_RQEvent = NULL;
	}
	return(1);
}

void CWiseNet::SetSleepTime(int a_Time)
{
	m_SleepTime = a_Time;
}

int CWiseNet::GetSleepTime()
{
	return(m_SleepTime);
}


extern "C" DWORD WINAPI WiseNetSendingProc(LPVOID Param)
{
	int			w_Rtn;
	WN_PACKET	*wp_Packet;
	CWiseNet	*wp_WiseNet = (CWiseNet *)Param;


	while(wp_WiseNet->m_SRQFlag) {
		if(wp_WiseNet->m_SQEnd != wp_WiseNet->m_SQStart) {
			wp_Packet = &wp_WiseNet->m_SQData[wp_WiseNet->m_SQEnd];

			w_Rtn = wp_WiseNet->SendTo(wp_Packet->m_Ip, wp_Packet->m_RPort, (char *)wp_Packet->mp_Data, wp_Packet->m_Len);

			wp_WiseNet->m_SQEnd = (wp_WiseNet->m_SQEnd + 1) % WN_SQNUM;
		}
		Sleep(1);
	}
	SetEvent(wp_WiseNet->m_SQEvent);
	wp_WiseNet->m_SRQFlag = 0;

	return(1);
}

extern "C" DWORD WINAPI WiseNetRecvingProc(LPVOID Param)
{
	char		w_Ip[256];
	int			w_Port;
	char		w_Buff[4096];
	int			w_Len;
	int			w_Rtn;
	WN_PACKET	*wp_Packet;
	CWiseNet	*wp_WiseNet = (CWiseNet *)Param;


	while(wp_WiseNet->m_SRQFlag) {
		if(wp_WiseNet->m_RecvFunc) {	// RECV MODULE捞 酒流 START 救凳 
			w_Rtn = wp_WiseNet->RecvFrom(w_Ip, w_Port, w_Buff, w_Len, wp_WiseNet->m_WaitFlag);
			if(w_Rtn > 0) {

				wp_Packet = &wp_WiseNet->m_RQData[wp_WiseNet->m_RQStart];
				wp_Packet->m_RPort = w_Port;
				strcpy(wp_Packet->m_Ip, w_Ip);
				wp_Packet->m_Len = w_Len;
				memcpy(wp_Packet->mp_Data, w_Buff, w_Len);

				wp_WiseNet->m_RQStart = (wp_WiseNet->m_RQStart + 1) % WN_RQNUM;
			}
			Sleep(1);
		} else {
			Sleep(100);
		}
	}
	SetEvent(wp_WiseNet->m_RQEvent);
	wp_WiseNet->m_SRQFlag = 0;

	return(1);
}