socket

最新推荐文章于 2021-08-01 04:02:16 发布
最新推荐文章于 2021-08-01 04:02:16 发布
阅读量394 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_39455451/article/details/77336510
本文介绍了一个基于Cocos2d-x的游戏网络通信模块实现细节，包括跨平台的Socket编程接口封装、多线程消息队列管理、数据加密解密流程等关键技术点。 
头文件
#ifndef _MTNotification_H_
#define _MTNotification_H_

#include <thread>
#include "SocketSinkHead.h"

#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)
#include <WinSock2.h>  
#include <WS2tcpip.h>
#pragma comment (lib,"WS2_32.Lib")  
#define LHS_EAGAIN          WSAEWOULDBLOCK    
#define LHS_EWOULDBLOCK     WSAEWOULDBLOCK  

#define LHS_ETIMEDOUT		WSAETIMEDOUT  
#define LHS_ENETDOWN		WSAENETDOWN  
#define LHS_WSAEINVAL		WSAEINVAL  

#else
#include <signal.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
#include<netinet/tcp.h>  
#include <netdb.h>  
#include <errno.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <sys/stat.h>  
#include <sys/types.h>  
#include <arpa/inet.h> 
typedef int					SOCKET;
#define INVALID_SOCKET		(SOCKET)(~0)  
#define SOCKET_ERROR		(-1)  
#define LHS_EAGAIN          EAGAIN              //此操作会令线程阻塞,但socket为不可阻塞的  
#define LHS_EWOULDBLOCK     EWOULDBLOCK         //资源暂时不可用  
#define LHS_ETIMEDOUT		ETIMEDOUT  
#define LHS_ENETDOWN		ENETDOWN  
#define LHS_WSAEINVAL		10022
#endif

USING_NS_CC;
//  TCP 网络连接
class CSocketEngine : public ITCPSocket
{
	friend class MTSocketQueue;
	// 辅助变量
private:
	WORD											m_wSocketID;					//  网络标识
	int												m_SocketIndex;					//	网络索引
	BYTE											m_cbSocketStatus;				//  网络状态
	//  计数变量
private:
	DWORD											m_dwSendTickCount;				//  发送时间
	DWORD											m_dwRecvTickCount;				//  接收时间
	//  接收变量
private:
	WORD											m_wRecvSize;					//  接收长度
	BYTE											m_cbRecvBuf[SOCKET_TCP_BUFFER * 10]; //  接收缓冲
	//  内核变量
private:
	SOCKET											m_hSocket;						//  连接句柄
	ITCPSocketSink*									m_pITCPSocketSink;				//  回调接口
	std::mutex										m_MutexRecv;
	
	// 函数定义
public:
	// 构造函数
	CSocketEngine();
	// 析构函数
	virtual ~CSocketEngine();
	// 标识接口
public:
	// 获取标识
	virtual WORD GetSocketID() { return m_wSocketID; }
	// 设置标识
	virtual void SetSocketID(WORD wSocketID) { m_wSocketID = wSocketID; }

	// 配置接口
public:
	// 设置接口
	virtual bool SetTCPSocketSink(ITCPSocketSink* pIUnknownEx);
	// 信息接口
public:
	// 获取状态
	virtual BYTE GetSocketStatus() { return m_cbSocketStatus; }
	// 操作接口
public:
	// 连接操作
	virtual BYTE Connect(std::string szServerIP, WORD wPort);
	// 发送函数
	virtual WORD SendData(WORD wMainCmdID, WORD wSubCmdID);
	// 发送函数
	virtual WORD SendData(WORD wMainCmdID, WORD wSubCmdID, VOID* pData, WORD wDataSize);
	// 关闭连接
	virtual VOID CloseSocket();

	// 辅助函数
protected:
	// 连接事件
	void OnSocketLink(int nErrorCode);
	// 发送数据
	WORD SendDataBuffer(void* pBuffer, WORD wSendSize);
	// 应答事件
	void OnSocketRead(void* pBuffer, WORD wSendSize);
	// 关闭连接
	void CloseSocket(BYTE cbShutReason);
	// 解密数据
	WORD CrevasseBuffer(BYTE cbDataBuffer[], WORD wDataSize);
	// 加密数据
	WORD EncryptBuffer(BYTE cbDataBuffer[], WORD wDataSize, WORD wBufferSize);
private:
    
    static void PerformConnectThread(std::string szServerIP, WORD wPort, int nSocketIndex);
	static void PerformRecvectThread(int nSocketIndex);
	
};

//////////////////////////////////////////////////////////////////////////
#endif // _MTNotification_H_



源文件
#include <iostream>
#include <map>
#include "cocos2d.h"
#include <mutex>
#include "SocketEngine.h"

USING_NS_CC;
//////////////////////////////////////////////////////////////////////////
// 多线程共享消息队列
//////////////////////////////////////////////////////////////////////////
void socket_close(int s)
{
#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)  
	shutdown(s, SD_BOTH);
	closesocket(s);
#else  
	shutdown(s, 2);
	close(s);
#endif 
}

int socket_send(int s, const char* data, int size)
{
	unsigned int flags = 0;
#if (CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID)  
	flags = MSG_NOSIGNAL;
#endif  
	return send(s, data, size, flags);
}

int socket_recv(int s, char* data, int size)
{
	unsigned int flags = 0;
#if (CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID)  
	flags = MSG_NOSIGNAL;
#endif  
	return recv(s, data, size, flags);
}

int socket_error()
{
#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)
	return WSAGetLastError();
#else
	return errno;
#endif
}

void socket_sleep(unsigned int delay)
{
#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)
	Sleep(delay);
#else
	usleep(delay * 1000);
#endif
}

long socket_TickCount()
{
	timeval now;
	gettimeofday(&now, 0);
	return (LONG)(now.tv_sec * 1000 + now.tv_usec / 1000);
}

//////////////////////////////////////////////////////////////////////////
static bool					__isSetSig = true;
static int					__SocketIndex = 0;
static const BYTE			__SocketCount = 100;
static CSocketEngine*		__SocketMap[__SocketCount];
static const BYTE			EVENT_TCP_SOCKET_LINK = 0;		//连接事件
static const BYTE			EVENT_TCP_SOCKET_READ = 1;		//读取事件
static const BYTE			EVENT_TCP_SOCKET_SHUT = 2;		//关闭事件
#define GetMTSocketQueue	MTSocketQueue::GetInstance()
//////////////////////////////////////////////////////////////////////////
class CInitSock
{
public:
	CInitSock()
	{
		ZeroMemory(__SocketMap, sizeof(__SocketMap));

#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)
		if (__isSetSig)
		{
			__isSetSig = false;
			WSADATA wsaData;
			//初始化Socket环境
			if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
			{
				//初始化DLL错误，显示错误提示，程序退出
				CCLOG("WSAStartup failed!\nInitialize socket failed.\n");
	}
}
#endif
#if (CC_TARGET_PLATFORM==CC_PLATFORM_IOS)
		if (__isSetSig)
		{
			__isSetSig = false;
			struct sigaction Sa;
			Sa.sa_handler = SIG_IGN;
			sigaction(SIGPIPE, &Sa, 0);
		}
#endif 
	}

	~CInitSock()
	{
#if (CC_TARGET_PLATFORM==CC_PLATFORM_WIN32)
		WSACleanup();
#endif
	}
};
CInitSock __InitSock;
//////////////////////////////////////////////////////////////////////////
// 循环消息处理
class MTSocketQueue : public Ref
{
	struct MTData
	{
		BYTE			onwer;		//数据拥有者
		int				cmd;		//命令:0关闭连接 1:错误码(dataSize) 2:消息
		BYTE*			data;
		int				dataSize;
	};

	std::list<MTData>	m_DataQueues;
	std::mutex			m_Mutex;

	static MTSocketQueue*	m_sInstance;
private:
	MTSocketQueue()
	{
		Director::getInstance()->getScheduler()->schedule(CC_SCHEDULE_SELECTOR(MTSocketQueue::post), this, 0.0f, false);
	}

	~MTSocketQueue()
	{
		std::lock_guard<std::mutex> lk(m_Mutex); //线程开始加锁，退出时自动解锁  
		while (!m_DataQueues.empty())
		{
			MTData& mtData = m_DataQueues.front();
			if (mtData.data)	delete[]mtData.data;
			m_DataQueues.pop_front();
		}
	}
public:
	static MTSocketQueue* GetInstance()
	{
		if (m_sInstance == 0)
			m_sInstance = new MTSocketQueue();
		return m_sInstance;
	}
public:
	void PostAsynEventData(BYTE cbIndex, WORD cmd, void* data, WORD dataSize)
	{
		std::lock_guard<std::mutex> lk(m_Mutex); //线程开始加锁，退出时自动解锁  
		if (cbIndex > __SocketCount && __SocketMap[cbIndex] == 0)	{ return; }
		MTData mtData;
		memset(&mtData, 0, sizeof(mtData));
		mtData.onwer = cbIndex;
		mtData.cmd = cmd;
		mtData.dataSize = dataSize;

		if (data != 0)
		{
			mtData.data = new BYTE[dataSize];
			if (mtData.data == 0){ return; }
			memcpy(mtData.data, data, dataSize);
		}
		m_DataQueues.push_back(mtData);
	}
	// 处理消息
	void post(float dt)
	{
		std::lock_guard<std::mutex> lk(m_Mutex); //线程开始加锁，退出时自动解锁  

		while (!m_DataQueues.empty())
		{
			const MTData& mtData = m_DataQueues.front();
			if (mtData.onwer < __SocketIndex)
			{
				CSocketEngine* owner = __SocketMap[mtData.onwer];
				if (owner)
				{
					if (mtData.cmd == EVENT_TCP_SOCKET_LINK)		owner->OnSocketLink(mtData.dataSize);
					else if (mtData.cmd == EVENT_TCP_SOCKET_READ)	owner->OnSocketRead(mtData.data, mtData.dataSize);
					else if (mtData.cmd == EVENT_TCP_SOCKET_SHUT)	owner->CloseSocket(mtData.dataSize);
				}
				if (mtData.data)		delete[]mtData.data;
			}

			m_DataQueues.pop_front();
		}
	}
};
//////////////////////////////////////////////////////////////////////////
MTSocketQueue* MTSocketQueue::m_sInstance = 0;
//////////////////////////////////////////////////////////////////////////
void CSocketEngine::PerformConnectThread(std::string szServerIP, WORD wPort, int nSocketIndex)
{
	if (nSocketIndex > __SocketCount) return;

	struct addrinfo * res = NULL;
    
    char szPort[10]={0};
    sprintf(szPort,"%d",wPort);

	int error = getaddrinfo(szServerIP.c_str(), szPort, NULL, &res);
    
	if (error != 0)
	{
		CCLOG("域名解析失败，[%s] line [%d] error in ServerIP[%s], Port[%d], getaddrinfo:%d, strErr=%s",
              __FUNCTION__, __LINE__, szServerIP.c_str(), wPort, error, gai_strerror(error));
        
        if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_EXCEPTION);        return;
		return;
	}
    if (__SocketMap[nSocketIndex])			__SocketMap[nSocketIndex]->m_hSocket = socket(res->ai_family,SOCK_STREAM,0);
    
    if (__SocketMap[nSocketIndex] && __SocketMap[nSocketIndex]->m_hSocket < 0)
    {
        CCLOG("TcpClientSocket::function [%s] line [%d]", __FUNCTION__, __LINE__);
        if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_EXCEPTION);        return;
    }
    
    if (__SocketMap[nSocketIndex] && connect(__SocketMap[nSocketIndex]->m_hSocket, res->ai_addr, res->ai_addrlen) < 0)
    {
        CCLOG("Socket::%s  connect err... line [%d]", __FUNCTION__, __LINE__);
        if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_EXCEPTION);         return;
    }


    freeaddrinfo(res);

	int nSendtimeout = 3000; //3s
	if (__SocketMap[nSocketIndex])	setsockopt(__SocketMap[nSocketIndex]->m_hSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&nSendtimeout, sizeof(nSendtimeout));
	int nRecvtimeout = 21000;	//21s
	if (__SocketMap[nSocketIndex])	setsockopt(__SocketMap[nSocketIndex]->m_hSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&nRecvtimeout, sizeof(nRecvtimeout));
    
    if (__SocketMap[nSocketIndex])__SocketMap[nSocketIndex]->m_wSocketID = (WORD)__SocketMap[nSocketIndex]->m_hSocket;
    
	std::thread tThread(&CSocketEngine::PerformRecvectThread, nSocketIndex);
	tThread.detach();
}
// 客户端线程接收连接
void CSocketEngine::PerformRecvectThread(int nSocketIndex)
{
	if (nSocketIndex > __SocketCount) return;

	if (__SocketMap[nSocketIndex])	std::lock_guard<std::mutex> lk(__SocketMap[nSocketIndex]->m_MutexRecv); //线程开始加锁，退出时自动解锁  

	if (__SocketMap[nSocketIndex]) __SocketMap[nSocketIndex]->m_cbSocketStatus = SOCKET_STATUS_CONNECT;

	if (__SocketMap[nSocketIndex] && GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_LINK, 0, SOCKET_STATUS_CONNECT);

	socket_sleep(10);

	while (__SocketMap[nSocketIndex] && __SocketMap[nSocketIndex]->GetSocketStatus() == SOCKET_STATUS_CONNECT)
	{
		char cbRecvBuf[SOCKET_TCP_BUFFER] = { 0 };	//接收缓冲

		if (!__SocketMap[nSocketIndex]) continue;
		int nDataSize = socket_recv(__SocketMap[nSocketIndex]->m_hSocket, cbRecvBuf, SOCKET_TCP_BUFFER);
		if (SOCKET_ERROR == nDataSize)
		{
			int errCode = socket_error();
			//CCLOG("recv failed %d !", errCode);
			//无法立即完成非阻塞Socket上的操作
			if (errCode == 10004) 	break;
			else if (errCode == LHS_EWOULDBLOCK)
			{
				socket_sleep(20);
				CCLOG("waiting back msg!\n");
				continue;
			}
			else if (errCode == LHS_EAGAIN)
			{
				continue;
			}
			if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_EXCEPTION);
			return;
		}
		if (nDataSize == 0)	break;
		if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_READ, cbRecvBuf, nDataSize);
	}


	if (__SocketMap[nSocketIndex] && __SocketMap[nSocketIndex]->m_hSocket != INVALID_SOCKET &&  GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(nSocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_NORMAL);
}

//////////////////////////////////////////////////////////////////////////

// 构造函数
CSocketEngine::CSocketEngine()
{
	// 辅助变量
	m_wSocketID = INVALID_WORD;
	m_SocketIndex = -1;
	m_cbSocketStatus = SOCKET_STATUS_IDLE;				//  网络状态
	m_dwSendTickCount = INVALID_DWORD;					//  发送时间
	m_dwRecvTickCount = INVALID_DWORD;					//  接收时间
	m_wRecvSize = 0;									//  接收长度
	ZeroMemory(m_cbRecvBuf, sizeof(m_cbRecvBuf));		//  接收缓冲
	m_hSocket = INVALID_SOCKET;							//  连接句柄
	m_pITCPSocketSink = nullptr;						//  回调接口
}

// 析构函数
CSocketEngine::~CSocketEngine()
{
	__SocketMap[m_SocketIndex] = 0;
	m_pITCPSocketSink = nullptr;							//  回调接口
	CloseSocket(SHUT_REASON_NORMAL);
}

// 设置接口
bool CSocketEngine::SetTCPSocketSink(ITCPSocketSink* pIUnknownEx)
{
	m_pITCPSocketSink = pIUnknownEx;
	return (m_pITCPSocketSink != NULL);
}

// 连接服务器
BYTE CSocketEngine::Connect(std::string szServerIP, WORD wPort)
{
	// 效验数据
	if (szServerIP.empty() || (wPort == 0)) return CONNECT_FAILURE;

	m_cbSocketStatus = SOCKET_STATUS_WAIT;

	if (m_SocketIndex == -1)
	{
		m_SocketIndex = __SocketIndex++;
		__SocketMap[m_SocketIndex] = this;
		if (__SocketIndex >= __SocketCount)__SocketIndex = 0;
	}
	std::thread tThread(&CSocketEngine::PerformConnectThread, szServerIP, wPort, m_SocketIndex);
	tThread.detach();
	return CONNECT_SUCCESS;
}

// 发送函数
WORD CSocketEngine::SendData(WORD wMainCmdID, WORD wSubCmdID)
{
	// 效验状态
	if (m_hSocket == INVALID_SOCKET) return false;
	if (m_cbSocketStatus != SOCKET_STATUS_CONNECT) return false;

	// 构造数据
	BYTE cbDataBuffer[SOCKET_TCP_BUFFER];
	TCP_Head* pHead = (TCP_Head*)cbDataBuffer;
	pHead->CommandInfo.wMainCmdID = wMainCmdID;
	pHead->CommandInfo.wSubCmdID = wSubCmdID;

	// 加密数据
	WORD wSendSize = EncryptBuffer(cbDataBuffer, sizeof(TCP_Head), sizeof(cbDataBuffer));

	// 发送数据
	return SendDataBuffer(cbDataBuffer, wSendSize) != 0;
}

// 发送函数
WORD CSocketEngine::SendData(WORD wMainCmdID, WORD wSubCmdID, void* pData, WORD wDataSize)
{
	// 效验状态
	if (m_hSocket == INVALID_SOCKET) return false;
	if (m_cbSocketStatus != SOCKET_STATUS_CONNECT) return false;

	// 效验大小
	ASSERT(wDataSize <= SOCKET_TCP_PACKET);
	if (wDataSize > SOCKET_TCP_PACKET) return false;

	BYTE cbDataBuffer[SOCKET_TCP_BUFFER];
	TCP_Head* pHead = (TCP_Head*)cbDataBuffer;
	pHead->CommandInfo.wMainCmdID = wMainCmdID;
	pHead->CommandInfo.wSubCmdID = wSubCmdID;
	if (wDataSize > 0)
	{
		ASSERT(pData != NULL);
		CopyMemory(pHead + 1, pData, wDataSize);
	}

	// 加密数据
	WORD wSendSize = EncryptBuffer(cbDataBuffer, sizeof(TCP_Head) + wDataSize, sizeof(cbDataBuffer));

	// 发送数据
	return SendDataBuffer(cbDataBuffer, wSendSize);
}

// 关闭连接
VOID CSocketEngine::CloseSocket()
{
	CloseSocket(SHUT_REASON_NORMAL);
}

// 连接事件
void CSocketEngine::OnSocketLink(int nErrorCode)
{
	if (m_pITCPSocketSink)	m_pITCPSocketSink->OnEventTCPSocketLink(m_wSocketID, nErrorCode);
}

// 发送数据
WORD CSocketEngine::SendDataBuffer(void* pBuffer, WORD wSendSize)
{
	// 效验参数
	ASSERT(wSendSize != 0);
	ASSERT(pBuffer != NULL);

	// 发送数据
	WORD wSended = 0;
	while (wSended < wSendSize)
	{
		while (true)
		{
			int retVal = socket_send(m_hSocket, (char*)pBuffer + wSended, wSendSize - wSended);
			if (SOCKET_ERROR == retVal)
			{
				if (socket_error() == LHS_EWOULDBLOCK)
				{
					//无法立即完成非阻塞Socket上的操作
					socket_sleep(5);
					continue;
				}
				else
				{
					CCLOG("send failed %d!\n", socket_error());
					if (GetMTSocketQueue)	GetMTSocketQueue->PostAsynEventData(m_SocketIndex, EVENT_TCP_SOCKET_SHUT, 0, SHUT_REASON_EXCEPTION);
					return 0;
				}
			}
			wSended += retVal;
			break;
		}
	}

	m_dwSendTickCount = socket_TickCount();
	return wSended;
}

// 网络消息
void CSocketEngine::OnSocketRead(void* pBuffer, WORD wSendSize)
{
	try
	{
		CopyMemory(&m_cbRecvBuf[m_wRecvSize], pBuffer, wSendSize);
		m_wRecvSize += wSendSize;

		DWORD dwLong = socket_TickCount() - m_dwRecvTickCount;
		//CCLOG("---------- %d ms", dwLong);
		m_dwRecvTickCount = socket_TickCount();

		// 变量定义
		WORD wPacketSize = 0;
		BYTE cbDataBuffer[SOCKET_TCP_BUFFER] = { 0 };
		TCP_Head* pHead = (TCP_Head*)m_cbRecvBuf;

		while (m_wRecvSize >= sizeof(TCP_Head) && m_cbSocketStatus == SOCKET_STATUS_CONNECT)
		{
			// 效验参数
			wPacketSize = pHead->TCPInfo.wPacketSize;
			ASSERT(pHead->TCPInfo.cbDataKind == DK_MAPPED);
			ASSERT(wPacketSize <= SOCKET_TCP_BUFFER);
			if (pHead->TCPInfo.cbDataKind != DK_MAPPED)
			{
				cocos2d::MessageBox("只支持加密映射", "");
				throw "只支持映射加密";
			}
			if (wPacketSize > SOCKET_TCP_BUFFER)
			{
				cocos2d::MessageBox("只支持加密映射", "");
				throw "数据包太大";
			}
			if (m_wRecvSize < wPacketSize) return;

			// 拷贝数据
			CopyMemory(cbDataBuffer, m_cbRecvBuf, wPacketSize);
			m_wRecvSize -= wPacketSize;
			MoveMemory(m_cbRecvBuf, m_cbRecvBuf + wPacketSize, m_wRecvSize);

			// 解密数据
			WORD wRealySize = CrevasseBuffer(cbDataBuffer, wPacketSize);
			ASSERT(wRealySize >= sizeof(TCP_Head));
			// 解释数据
			WORD wDataSize = wRealySize - sizeof(TCP_Head);
			void * pDataBuffer = cbDataBuffer + sizeof(TCP_Head);
			TCP_Command Command = ((TCP_Head*)cbDataBuffer)->CommandInfo;

			// 内核命令 --> 网络检测
			if (Command.wMainCmdID == MDM_KN_COMMAND && Command.wSubCmdID == SUB_KN_DETECT_SOCKET)
			{
				// 发送数据
				SendData(MDM_KN_COMMAND, SUB_KN_DETECT_SOCKET, pDataBuffer, wDataSize);
				continue;
			}

			// 处理数据
			bool bSuccess = m_pITCPSocketSink->OnEventTCPSocketRead(m_wSocketID, Command, pDataBuffer, wDataSize);
			if (bSuccess == false) throw "网络数据包处理失败";
		}
	}
	catch (...)
	{
		CloseSocket(SHUT_REASON_EXCEPTION);
	}
}

// 关闭连接
VOID CSocketEngine::CloseSocket(BYTE cbShutReason)
{
	// 关闭连接
	if (m_hSocket != INVALID_SOCKET)
	{
		socket_close(m_hSocket);
		m_hSocket = INVALID_SOCKET;
		m_cbSocketStatus = SOCKET_STATUS_IDLE;
		if (m_SocketIndex != -1 && __SocketMap[m_SocketIndex]) __SocketMap[m_SocketIndex] = 0;
		m_SocketIndex = -1;
		
	}
	if (m_pITCPSocketSink)
	{
		try { m_pITCPSocketSink->OnEventTCPSocketShut(m_wSocketID, cbShutReason); }
		catch (...) {}
	}
	// 恢复数据
	m_wRecvSize = 0;
	m_dwSendTickCount = 0;
	m_dwRecvTickCount = 0;
}

// 加密数据
WORD CSocketEngine::EncryptBuffer(BYTE pcbDataBuffer[], WORD wDataSize, WORD wBufferSize)
{
	// 效验参数
	CC_ASSERT(wDataSize >= sizeof(TCP_Head));
	CC_ASSERT(wBufferSize >= wDataSize);
	CC_ASSERT(wDataSize <= SOCKET_TCP_BUFFER);
	// 效验码与字节映射
	BYTE cbCheckCode = 0;
	for (WORD i = sizeof(TCP_Info); i < wDataSize; i++)
	{
		cbCheckCode += pcbDataBuffer[i];
		pcbDataBuffer[i] = g_SendByteMap[pcbDataBuffer[i]];
	}

	// 填写信息头
	TCP_Head* pHead = (TCP_Head*)pcbDataBuffer;
	pHead->TCPInfo.cbCheckCode = ~cbCheckCode + 1;
	pHead->TCPInfo.wPacketSize = wDataSize;
	pHead->TCPInfo.cbDataKind = DK_MAPPED;
	return wDataSize;
}

// 解密数据
WORD CSocketEngine::CrevasseBuffer(BYTE pcbDataBuffer[], WORD wDataSize)
{
	// 效验参数
	CC_ASSERT(wDataSize >= sizeof(TCP_Head));
	CC_ASSERT(((TCP_Head*)pcbDataBuffer)->TCPInfo.wPacketSize == wDataSize);

	// 效验码与字节映射
	TCP_Head* pHead = (TCP_Head*)pcbDataBuffer;
	BYTE cbCheckCode = pHead->TCPInfo.cbCheckCode;
	for (int i = sizeof(TCP_Info); i < wDataSize; i++)
	{
		pcbDataBuffer[i] = g_RecvByteMap[pcbDataBuffer[i]];
		cbCheckCode += pcbDataBuffer[i];
	}
	if (cbCheckCode != 0) { CC_ASSERT(false || "数据包效验码错误"); }
	return wDataSize;
}

//////////////////////////////////////////////////////////////////////////
//bool TcpClientSocket::subConnectServerIPV6(const char *pServerIP, unsigned short ServerPort)
//{
//	CCLog("TcpClientSocket::function [%s] line [%d]", __FUNCTION__, __LINE__);
//	struct sockaddr_in6     addrServer;
//	int tempSocket = -1;
//
//	memset(&addrServer, 0, sizeof(addrServer));
//	addrServer.sin6_family = AF_INET6;
//	addrServer.sin6_port = htons(ServerPort);
//	inet_pton(AF_INET6, pServerIP, &addrServer.sin6_addr);
//	if ((tempSocket = socket(AF_INET6, SOCK_STREAM, 0)) < 0)
//	{
//		state = NETWORK_STATE_FAILED;
//		CCLog("TcpClientSocket::%s  socket err... line [%d]", __FUNCTION__, __LINE__);
//		return false;
//	}
//
//	if (connect(tempSocket, (struct sockaddr*)&addrServer, sizeof(addrServer)) < 0)
//	{
//		CCLog("TcpClientSocket::%s  connect err... line [%d]", __FUNCTION__, __LINE__);
//
//		return false;
//	}
//	return true;
//}














                

        

    

    
  



    



                



	

		

			

				
					
安卓 cocos2dx 启动失败

				
			

			

				

					lvye1221的专栏
				

				

					01-05
					
					837
					
				

			

		

		

			
				
现象android 下在没网（无wifi，无移动网络）的情况下，启动app时，提示“很抱歉,‘XXXX’已停止运行”！通过 eclipse 的调试，打印出信息如下：01-03 21:40:32.095: D/VivoDaemon_SmartMultiWindowService(1769): onChange isFullScreen =1isAllowActiveSpilt = falseSmart

			
		

	



                

            
              



	

		

			

				
					
s60 2nd通过代码创建cmnet接入点的方法

				
			

			

				

					World of iOs
				

				

					02-09
					
					850
					
				

			

		

		

			
				
<br />北京理工大学  20981  陈罡<br />最近比较忙，没有时间更新blog了，忙里偷闲跑出来冒个泡泡贴点东西。<br />前段时间贴了关于s60 2nd平台创建cmwap接入点的方法，很多朋友问我如何创建<br />基于cmnet的接入点，其实基本上是完全一样的，所不同的是需要把proxy设置相关<br />的地方给去掉即可（我们都是中国移动的“好孩子”）。<br /><br />_LIT(KCmnetIapName, "CMNET For XXXXXX") ; <br />TUint32 

			
		

	



              


  
              

                


	

		

			

				
					
浅谈贝贝游戏数据加密解密方式

				
			

			

				

					
				

				

					10-20
					
					6428
					
				

			

		

		

			
				
贝贝游戏 网址www.game499.com 这个游戏和其他的网狐的客服端不同，界面不同其次主要的不同是他们数据加密方法不同，传统的数据加密方式如下，因为手上有网狐的源码所以直接上源码//加密数据
WORD CTCPSocket::EncryptBuffer(BYTE pcbDataBuffer[], WORD wDataSize, WORD wBufferSize)
{
	//效验参数
	ASS

			
		

	





	

		

			

				
					
SuperSocket服务器架设(二)：使用SuperSocket构建简单服务器

					
热门推荐

				
			

			

				

					宽仔
				

				

					12-01
					
					2万+
					
				

			

		

		

			
				
服务器效果截图：

 
客户端效果截图：

 
1.      创建控制台项目，导入SuperSocket.Common、SuperSocket.SocketBase、SuperSocket.SocketEngine并添加好引用


2.      在控制台项目中添加Config文件夹及SuperSocket提供的log4net配置文件


3.      添加using引

			
		

	



		

			
		



	

		

			

				
					
网狐棋牌游戏平台服务器架构设计分析

				
			

			

				

					weixin_30364147的博客
				

				

					08-18
					
					1483
					
				

			

		

		

			
				
网狐棋牌游戏平台服务器架构设计分析   基本设计概念和处理流程   调用模型  模仿COM组件接口模式，利用面向对象思想多态性polymorphism，调用方保存着被调用方的基础接口指针(interface or sink钩子)（Pure Virtual Function），调用方直接调用接口指针内声明的纯虚方法，而此纯虚函数的具体逻辑由该接口的派生类实现。  示意图:     基于事件驱动...

			
		

	





	

		

			

				
					
C#高性能大容量SOCKET并发完成端口例子（有C#客户端）完整实例源码

				
			

			

				

					06-08
				

			

		

		

			
				
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，用于测试SocketAsyncEventArgs的性能和压力，最大连接数支持65535个长连接，最高命令交互速度...

			
		

	





	

		

			

				
					
SocketTool4下载 socket安装包下载windows sockettool v4

				
			

			

				

					03-27
				

			

		

		

			
				
socket工具，socketTool v4版本

			
		

	





	

		

			

				
					
Socket测试工具 设置服务端，发送socket报文

				
			

			

				

					07-24
				

			

		

		

			
				
Socket测试工具 设置服务端，发送socket报文 Socket测试工具 设置服务端，发送socket报文 Socket测试工具 设置服务端，发送socket报文

			
		

	





	

		

			

				
					
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器

				
			

			

				

					10-28
				

			

		

		

			
				
Socket调试助手，该助手可用于调试socket通信，包含socket客户端，socket服务器，udp客户端，udp服务器

			
		

	





	

		

			

				
					
SocketTool，网络调试助手

					
最新发布

				
			

			

				

					07-09
				

			

		

		

			
				
SocketTool，网络调试助手

			
		

	





	

		

			

				
					
网狐6.6 服务器源代码 & 共享组件 & 数据库 （7）完毕

				
			

			

				

					09-28
				

			

		

		

			
				
网狐6.6 服务器源代码&共享组件&数据库，包括服务器端所有组件（内核除外，现在市面上还没有6.6内核），共享组件（公共服务，界面控件，界面资源），以及全部数据库文件和脚本文件，6.6较6.5有较大改动，是学习研究的上等程序代码。
结合本人上次发布的客户端组件，即为网狐66系统模块全部源代码！！！官方售价几万，网上有人卖几百到几千不等，本程序绝对6.6新版代码（带道具），识货的下。

总共140M,7个解压包：1～7。

#ifndef KERNEL_ENGINE_HEAD_HEAD_FILE
#define KERNEL_ENGINE_HEAD_HEAD_FILE

//////////////////////////////////////////////////////////////////////////
//包含文件

#include 
#include 
#include 
#include 
#include 

//平台文件
#include "..\..\模板库\Template.h"
#include "..\..\公共文件\Constant.h"
#include "..\..\公共文件\GlobalDef.h"
#include "..\..\共享组件\公共服务\ComService.h"

//////////////////////////////////////////////////////////////////////////
//ADO 定义

#import "MSADO15.DLL" rename_namespace("ADOCG") rename("EOF","EndOfFile")
using namespace ADOCG;

typedef _com_error						CComError;						//COM 错误
typedef _variant_t						CDBVarValue;					//数据库数值

//////////////////////////////////////////////////////////////////////////
//导出定义

//导出定义
#ifndef KERNEL_ENGINE_CLASS
	#ifdef  KERNEL_ENGINE_DLL
		#define KERNEL_ENGINE_CLASS _declspec(dllexport)
	#else
		#define KERNEL_ENGINE_CLASS _declspec(dllimport)
	#endif
#endif

//模块定义
#ifndef _DEBUG
	#define KERNEL_ENGINE_DLL_NAME	TEXT("KernelEngine.dll")			//组件 DLL 名字
#else
	#define KERNEL_ENGINE_DLL_NAME	TEXT("KernelEngineD.dll")			//组件 DLL 名字
#endif

//////////////////////////////////////////////////////////////////////////
//系统常量

//常量定义
#define TIME_CELL					200									//时间单元
#define TIMES_INFINITY				DWORD(-1)							//无限次数
#define MAX_ASYNCHRONISM_DATA		8192								//异步数据

//////////////////////////////////////////////////////////////////////////
//网络定义

//连接错误
#define CONNECT_SUCCESS				0									//连接成功
#define CONNECT_FAILURE				1									//连接失败
#define CONNECT_EXCEPTION			2									//参数异常

//关闭原因
#define SHUT_REASON_INSIDE			0									//内部原因
#define SHUT_REASON_NORMAL			1									//正常关闭
#define SHUT_REASON_REMOTE			2									//远程关闭
#define SHUT_REASON_TIME_OUT		3									//网络超时

			
		

	





	

		

			

				
					
读取服务器配置信息服务

				
			

			

				

					11-27
				

			

		

		

			
				
自已写的一个读取计算机的配置如CPU、内存、硬盘、显存的ID、空量、使用率、计算机名、当前用户、磁盘空间等信息的一个windows服务 包含源代码，同时包含写入日志，相当有用，配合前端网页可实时展示计算机配置信息。

			
		

	





	

		

			

				
					
Connect a list container to a tree/list control连接一个列表

				
			

			

				

					02-23
				

			

		

		

			
				
Connect a list container to a tree/list control连接一个列表容器到列表控制(4KB)

			
		

	





	

		

			

				
					
WH服务器框架分析系列二：网络核心组件CTCPSocketEngine

				
			

			

				

					qq51931373的专栏
				

				

					04-14
					
					594
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					
TCPSocketEnging分析 2011-6-9 00:29 阅读(13)

				
			

			

				

					weixin_30391339的博客
				

				

					06-19
					
					212
					
				

			

		

		

			
				
赞
转载
分享
评论
复制地址
举报
更多


上一篇|下一篇：TimerEngine












相关UML：网络引擎整体结构：SocketItem细节：先来看几个底层结构：
//重叠结构类classCOverLapped{//变量定义public:WSABUF...

			
		

	





	

		

			

				
					
python 调用加密函数dll

				
			

			

				

					thesum的专栏
				

				

					01-12
					
					988
					
				

			

		

		

			
				
test.py:
import ctypes
lib = ctypes.CDLL('TCPSocket.dll')
def opaque_ptr(name):
    cls = type(name, (ctypes.Structure,),{})
    return ctypes.POINTER(cls)
class CTCPSocket(object):
    _CTCPSo

			
		

	





	

		

			

				
					
网狐架构之登录服务器

				
			

			

				

					凉风之魅的专栏
				

				

					03-08
					
					1100
					
				

			

		

		

			
				
启动过程分析：
1：CLogonServerDlg::OnInitDialog()
m_ServiceUnits.SetServiceUnitsSink(this);
m_pIServiceUnitsSink=pIServiceUnitsSink;//同协调服务器过程
2：启动服务：
CLogonServerDlg::OnBnClickedStartService()
m_ServiceUnits...

			
		

	





	

		

			

				
					
网狐 协调服务器 作用,网狐架构之登录服务器

				
			

			

				

					weixin_33416900的博客
				

				

					08-01
					
					786
					
				

			

		

		

			
				
LogonServer.exe启动过程分析：1：CLogonServerDlg::OnInitDialog()m_ServiceUnits.SetServiceUnitsSink(this);m_pIServiceUnitsSink=pIServiceUnitsSink;//同协调服务器过程2：启动服务：CLogonServerDlg::OnBnClickedStartService()m_Ser...

			
		

	





	

		

			

				
					
Java Socket编程基础

				
			

			

				

					
				

			

		

		

			
				
"Java+Socket 教程，深入解析Java中的Socket编程技术"  在Java编程中，Socket是一种网络通信机制，允许两台计算机之间进行数据交换。本教程由developerWorks提供，旨在帮助开发者掌握Java中Socket的基础知识和实际...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值