cocos2dx 跨平台Socket

Sever和Client用的是同一个类，只是使用的函数不同

Sever运行的函数顺序是：

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();                                     //释放库

Client运行的函数顺序是：

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();                                     //释放库

Socket类：

Socket.h

#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

Socket.cpp

#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;
}