cocos2d-x socket

cocos2d-x版本 3.9

纯C++Socket，不用依赖其他库，windows mac iphone android 通用

GameSocket.h

#pragma once
#include "cocos2d.h"
#ifdef _WIN32
#include <windows.h>
#include <WinSock.h>
#pragma comment(lib, "ws2_32.lib")
#else
#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SOCKET int
#define SOCKET_ERROR -1
#define INVALID_SOCKET -1

#endif
#include "TypeDefine.h"
USING_NS_CC;

#define BLOCKSECONDS	30			// INIT函数阻塞时间
#define BUFFER_SIZE (40 * 1024)//可以根据实际情况改大小

class GameSocket
{
public:

GameSocket(void);
bool	Create(const char* pszServerIP, int nServerPort, int nBlockSec = BLOCKSECONDS, bool bKeepAlive = false);
bool	SendMsg(void* pBuf, int nSize);
bool	ReceiveMsg(void* pBuf, int& nSize);
bool	Check(void);
void	Destroy(void);
SOCKET	GetSocket(void) const { return m_sockClient; }
private:
bool	recvFromSock(void);		// 从网络中读取尽可能多的数据
bool    hasError();			// 是否发生错误，注意，异步模式未完成非错误
void    closeSocket();

SOCKET	m_sockClient;

// 发送数据缓冲
char	m_bufOutput[BUFFER_SIZE];	//? 可优化为指针数组
int		m_nOutbufLen;

// 环形缓冲区
char	m_bufInput[BUFFER_SIZE];
int		m_nInbufLen;

};

GameSocket.cpp

<pre name="code" class="cpp">#include "GameSocket.h"

GameSocket::GameSocket()
{
// 初始化
memset(m_bufOutput, 0, sizeof(m_bufOutput));
memset(m_bufInput, 0, sizeof(m_bufInput));
}

void GameSocket::closeSocket()
{
#ifdef WIN32
closesocket(m_sockClient);
WSACleanup();
#else
close(m_sockClient);
#endif
}

bool GameSocket::Create(const char* pszServerIP, int nServerPort, int nBlockSec, bool bKeepAlive /*= FALSE*/)
{
// 检查参数
if(pszServerIP == 0 || strlen(pszServerIP) > 15)
{
return false;
}

#ifdef WIN32
WSADATA wsaData;
WORD version = MAKEWORD(2, 0);
int ret = WSAStartup(version, &wsaData);//win sock start up
if (ret != 0)
{
return false;
}
#endif

// 创建主套接字
m_sockClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(m_sockClient == INVALID_SOCKET)
{
closeSocket();
return false;
}

// 设置SOCKET为KEEPALIVE
if(bKeepAlive)
{
int		optval=1;
if(setsockopt(m_sockClient, SOL_SOCKET, SO_KEEPALIVE, (char *) &optval, sizeof(optval)))
{
closeSocket();
return false;
}
}

#ifdef WIN32
DWORD nMode = 1;
int nRes = ioctlsocket(m_sockClient, FIONBIO, &nMode);
if (nRes == SOCKET_ERROR) {
closeSocket();
return false;
}
#else
// 设置为非阻塞方式
fcntl(m_sockClient, F_SETFL, O_NONBLOCK);
#endif

unsigned long serveraddr = inet_addr(pszServerIP);
if(serveraddr == INADDR_NONE)	// 检查IP地址格式错误
{
closeSocket();
return false;
}

sockaddr_in	addr_in;
memset((void *)&addr_in, 0, sizeof(addr_in));
addr_in.sin_family = AF_INET;
addr_in.sin_port = htons(nServerPort);
addr_in.sin_addr.s_addr = serveraddr;

if(::connect(m_sockClient, (sockaddr *)&addr_in, sizeof(addr_in)) == SOCKET_ERROR)
{
if (hasError())
{
closeSocket();
return false;
}
else	// WSAWOLDBLOCK
{
timeval timeout;
timeout.tv_sec	= nBlockSec;
timeout.tv_usec	= 0;
fd_set writeset, exceptset;
FD_ZERO(&writeset);
FD_ZERO(&exceptset);
FD_SET(m_sockClient, &writeset);
FD_SET(m_sockClient, &exceptset);

int ret = select(FD_SETSIZE, NULL, &writeset, &exceptset, &timeout);
if (ret == 0 || ret < 0)
{
closeSocket();
return false;
}
else	// ret > 0
{
ret = FD_ISSET(m_sockClient, &exceptset);
if(ret)		// or (!FD_ISSET(m_sockClient, &writeset)
{
closeSocket();
return false;
}
}
}
}

m_nInbufLen		= 0;
m_nOutbufLen	= 0;

struct linger so_linger;
so_linger.l_onoff = 1;
so_linger.l_linger = 500;
setsockopt(m_sockClient, SOL_SOCKET, SO_LINGER, (const char*)&so_linger, sizeof(so_linger));

return true;
}

bool GameSocket::SendMsg(void* pBuf, int nSize)
{
if(pBuf == 0 || nSize <= 0)
{
return false;
}

if (m_sockClient == INVALID_SOCKET)
{
return false;
}
ssize_t outsize = send(m_sockClient, (char*)pBuf, nSize, 0);
if (outsize < 0)
{
if (hasError())
{
Destroy();
return false;
}
}
return true;
}

bool GameSocket::ReceiveMsg(void* pBuf, int& nSize)
{
//检查参数
if(pBuf == NULL || nSize <= 0)
{
return false;
}

if (m_sockClient == INVALID_SOCKET)
{
return false;
}

// 检查是否有一个消息(小于2则无法获取到消息长度)
if(m_nInbufLen < 2)
{
//  如果没有请求成功  或者   如果没有数据则直接返回
if(!recvFromSock() || m_nInbufLen < 2)// 这个m_nInbufLen更新了
{
return false;
}
}

// 检测消息包尺寸错误
if (m_nInbufLen <= 0 || m_nInbufLen > BUFFER_SIZE)
{
m_nInbufLen = 0;		// 直接清空INBUF
return false;
}

// 复制出一个消息
memcpy(pBuf, m_bufInput , m_nInbufLen + sizeof(UINT32));
nSize = m_nInbufLen;

// 重新计算环形缓冲区头部位置
m_nInbufLen = 0;
return	true;
}

bool GameSocket::hasError()
{
#ifdef WIN32
int err = WSAGetLastError();
if (err !=  WSAEWOULDBLOCK)
{
#else
int err = errno;
if(err != EINPROGRESS && err != EAGAIN)
{
#endif
return false;
}

return false;
}

// 从网络中读取尽可能多的数据，实际向服务器请求数据的地方
bool GameSocket::recvFromSock(void)
{
if (m_nInbufLen >= BUFFER_SIZE || m_sockClient == INVALID_SOCKET)
{
return false;
}

// 接收头 我的消息结构是4个字节消息头 存的是消息大小 后面跟的消息体  可以根据实际情况去改
UINT32 nBuffSize = 0;
int inlen = recv(m_sockClient, (char*)&nBuffSize, sizeof(UINT32), 0);
if(inlen > 0)
{
// 有接收到数据
if (inlen > BUFFER_SIZE)
{
return false;
}

//接收消息体
inlen = recv(m_sockClient, m_bufInput, nBuffSize + sizeof(UINT32), 0);
if (inlen > 0)
{
m_nInbufLen = inlen;
if (m_nInbufLen > BUFFER_SIZE)
{
return false;
}
}
else if (inlen == 0)
{
Destroy();
return false;
}
else
{
// 连接已断开或者错误（包括阻塞）
if (hasError())
{
Destroy();
return false;
}
}
}
else if(inlen == 0)
{
Destroy();
return false;
}
else
{
// 连接已断开或者错误（包括阻塞）
if (hasError())
{
Destroy();
return false;
}
}

return true;
}

bool GameSocket::Check(void)
{
// 检查状态
if (m_sockClient == INVALID_SOCKET)
{
return false;
}

char buf[1];
ssize_t	ret = recv(m_sockClient, buf, 1, MSG_PEEK);
if(ret == 0)
{
Destroy();
return false;
}
else if(ret < 0)
{
if (hasError())
{
Destroy();
return false;
}
else
{	// 阻塞
return true;
}
}
else
{	// 有数据
return true;
}

return true;
}

void GameSocket::Destroy(void)
{
// 关闭
struct linger so_linger;
so_linger.l_onoff = 1;
so_linger.l_linger = 500;
int ret = setsockopt(m_sockClient, SOL_SOCKET, SO_LINGER, (const char*)&so_linger, sizeof(so_linger));

closeSocket();

m_sockClient = INVALID_SOCKET;
m_nInbufLen = 0;
m_nOutbufLen = 0;

memset(m_bufOutput, 0, sizeof(m_bufOutput));
memset(m_bufInput, 0, sizeof(m_bufInput));
}

TypeDefine.h

#ifndef WIN32
typedef char        INT8;
typedef short       INT16;
typedef int        INT32;
typedef long long   INT64;
typedef unsigned char       UINT8;
typedef unsigned short      UINT16;
typedef unsigned int       UINT32;
typedef unsigned long long  UINT64;
#endif

用法

1.连接

<pre name="code" class="cpp">GameSocket* m_pSocket = new GameSocket();
bool isCreate = m_pSocket->Create([ip], [port]);
if (!isCreate)
{
CCLOG(" socket connect[%s:%d] fail!", [ip], [port]);
}

2.发消息

bool isSend = m_pSocket->SendMsg([buffer], [buffSize]);
if (!isSend)
{
CCLOG("send world message fail!");
}

3.接收消息

<pre name="code" class="cpp">// 接收消息处理（放到游戏主循环中，每帧处理）
if (m_pSocket == nullptr)
{
return;
}

if (!m_pSocket->Check())
{
m_pSocket = nullptr;
// 掉线了
return;
}

// 接收数据（取得缓冲区中的所有消息，直到缓冲区为空）
while (true)
{
char pbufMsg[BUFFER_SIZE] = { 0 };
int nSize = sizeof(pbufMsg);
if (m_pSocket == nullptr)
{
break;
}
if (!m_pSocket->ReceiveMsg(pbufMsg, nSize))
{
break;
}
//pbufMsg, nSize 这是接收回来的消息内容和大小 根据实际情况进行处理
}