cocos2dx 跨平台Socket

Socket.Init();                                      //初始化库
Socket.Create(AF_INET,SOCK_STREAM,0);               //创建socket
Socket.Bind(5010);                                  //绑定端口
Socket.Listen();                                    //开启监听
Socket.Accept(clientsocket,ipClient);               //接受一个客户端请求
clientsocket.Recv(recvBuf,64,0);                    //接收消息
clientsocket.Send("lidaha",strlen("lihaha")+1,0);   //发送消息
Socket.Close();                                     //关闭socket
Socket.Clean();                                     //释放库

Socket.Init();                                      //初始化库
Socket.Create(AF_INET,SOCK_STREAM,0);               //创建socket
Socket.Connect("127.0.0.1", 5010);                  //链接服务器
Socket.Send("lidaha",strlen("lidaha")+1, 0);        //发送数据
Socket.Recv(buf,64,0);                              //接收数据
Socket.Close();                                     //关闭socket
Socket.Clean();                                     //释放库

#ifndef _ODSOCKET_H_
#define _ODSOCKET_H_

#ifdef WIN32
#include <winsock.h>
typedef int             socklen_t;
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.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  -1
#define SOCKET_ERROR    -1

#endif

class Socket {

public:
Socket(SOCKET sock = INVALID_SOCKET);

~Socket();

bool Create(int af, int type, int protocol = 0);

bool Connect(const char* ip, unsigned short port);

bool Bind(unsigned short port);

bool Listen(int backlog = 5);

bool Accept(Socket& s, char* fromip = NULL);

int Send(const char* buf, int len, int flags = 0);

int Recv(char* buf, int len, int flags = 0);

int Close();

int GetError();

static int Init();

static int Clean();

static bool DnsParse(const char* domain, char* ip);

Socket& operator = (SOCKET s);

operator SOCKET ();

void setNonBlocking();
void setSendTimeOut(int time);
void setRecvTimeOut(int time);

protected:
SOCKET mySocket;

};
#endif

#include "Socket.h"
#include "stdio.h"

#ifdef WIN32
#pragma comment(lib, "wsock32")
#endif

Socket::Socket(SOCKET sock)
{
mySocket = sock;
}

Socket::~Socket()
{
}

int Socket::Init()
{
static bool isInit = false;
if (isInit)
return 0;
#ifdef WIN32
WSADATA wsaData;
WORD version = MAKEWORD(2, 0);
int ret = WSAStartup(version, &wsaData);//win sock start up
if (ret) {
return -1;
}
#endif
isInit = true;
return 0;
}

int Socket::Clean()
{
#ifdef WIN32
return (WSACleanup());
#endif
return 0;
}

Socket& Socket::operator = (SOCKET s)
{
mySocket = s;
return (*this);
}

Socket::operator SOCKET ()
{
return mySocket;
}

void Socket::setNonBlocking()
{
#ifdef WIN32
u_long mode = 1;
ioctlsocket(mySocket, FIONBIO, &mode);
#else
int cflags = fcntl(mySocket, F_GETFL, 0);
fcntl(mySocket, F_SETFL, cflags | O_NONBLOCK);
#endif
}

void Socket::setSendTimeOut(int time)
{
#ifdef WIN32
time *= 1000;
setsockopt(mySocket, SOL_SOCKET, SO_SNDTIMEO, (char*)&time, sizeof(int));
#else
struct timeval timeout = {time, 0};
setsockopt(mySocket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(struct timeval));
#endif
}

void Socket::setRecvTimeOut(int time)
{
#ifdef WIN32
time *= 1000;
setsockopt(mySocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&time, sizeof(int));
#else
struct timeval timeout = {time, 0};
setsockopt(mySocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(struct timeval));
#endif
}

bool Socket::Create(int af, int type, int protocol)
{
mySocket = socket(af, type, protocol);
if (mySocket == INVALID_SOCKET) {
return false;
}
return true;
}

bool Socket::Connect(const char* ip, unsigned short port)
{
struct sockaddr_in svraddr;
svraddr.sin_family = AF_INET;
svraddr.sin_addr.s_addr = inet_addr(ip);
svraddr.sin_port = htons(port);
int ret = connect(mySocket, (struct sockaddr*)&svraddr, sizeof(svraddr));
if (ret == SOCKET_ERROR) {
return false;
}
return true;
}

bool Socket::Bind(unsigned short port)
{
struct sockaddr_in svraddr;
svraddr.sin_family = AF_INET;
svraddr.sin_addr.s_addr = INADDR_ANY;
svraddr.sin_port = htons(port);

int opt = 1;
if (setsockopt(mySocket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt)) < 0)
return false;

int ret = bind(mySocket, (struct sockaddr*)&svraddr, sizeof(svraddr));
if (ret == SOCKET_ERROR) {
return false;
}
return true;
}

bool Socket::Listen(int backlog)
{
int ret = listen(mySocket, backlog);
if (ret == SOCKET_ERROR) {
return false;
}
return true;
}

bool Socket::Accept(Socket& s, char* fromip)
{
struct sockaddr_in cliaddr;
socklen_t addrlen = sizeof(cliaddr);
SOCKET sock = accept(mySocket, (struct sockaddr*)&cliaddr, &addrlen);
if (sock == SOCKET_ERROR) {
return false;
}

s = sock;
if (fromip != NULL)
sprintf(fromip, "%s", inet_ntoa(cliaddr.sin_addr));

return true;
}

int Socket::Send(const char* buf, int len, int flags)
{
int bytes;
int count = 0;

while (count < len) {

bytes = send(mySocket, buf + count, len - count, flags);
if (bytes == -1 || bytes == 0)
return -1;
count += bytes;
}

return count;
}

int Socket::Recv(char* buf, int len, int flags)
{
return (recv(mySocket, buf, len, flags));
}

int Socket::Close()
{
#ifdef WIN32
return (closesocket(mySocket));
#else
return (close(mySocket));
#endif
}

int Socket::GetError()
{
#ifdef WIN32
return (WSAGetLastError());
#else
return (-1);
#endif
}

bool Socket::DnsParse(const char* domain, char* ip)
{
struct hostent* p;
if ((p = gethostbyname(domain)) == NULL)
return false;

sprintf(ip,
"%u.%u.%u.%u",
(unsigned char)p->h_addr_list[0][0],
(unsigned char)p->h_addr_list[0][1],
(unsigned char)p->h_addr_list[0][2],
(unsigned char)p->h_addr_list[0][3]);

return true;
}