socket网络服务实战

一、epoll模型的构建

由于网络服务高并发的需求，一般socket网络模型都采用epoll模型，有关epoll模型的原理在相关论坛中有许多讲述，在此不做重复讲解，主要讲一讲epoll模型的封装实现。

EPoller类的具体实现如下代码所示：

class EPoller
{
public:

    int Create(int maxfd);
    void JoinSocket(Socket* sock, unsigned int flag);
    void DelSocket(CEpollSocket* sock);
    int  LoopForEvent(int timeout);
    int  EpollWait(int timeout);
protected:
    int epoll_fd;    //epoll文件描述符
    epoll_event* p_events;  //用于保存epoll_wait返回的事件
    int max_fd;      //最大监听的文件描述符数量

};

// 创建epoll模型
int EPoller::Create(int maxfd)
{
    max_fd = maxfd ;
    epoll_fd = epoll_create(maxfd);

    p_events = new epoll_event[maxfd];
    memset(p_events, , sizeof(epoll_event) * maxfd);
    return ;
}

//将某个fd添加至监听的队列中，并利用flag设置监听的事件类型
//其中Socket为基类
int EPoller::JoinSocket(Socket* sock, unsigned int flag)
{
    int fd = sock->GetSockHandle();
    epoll_event event;
    event.data.ptr = sock;
    event.events = flag|EPOLLHUP|EPOLLERR;

    if (epoll_ctl(_epoll_fd, EPOLL_CTL_MOD , fd, &ev) < )
    {
        if (epoll_ctl(_epoll_fd, EPOLL_CTL_ADD , fd, &ev) < )
        {
            return -;
        }
    }

    return ;
}

//删除指定的fd
int EPoller::DelSocket(Socket* sock)
{
    int fd = sock->GetSockHandle();//利用Socket对象取得相应的文件句柄
    if ( fd >  )
    {
        epoll_event ev;
        ev.data.ptr = sock;
        ev.events = ;
        if (epoll_ctl(_epoll_fd, EPOLL_CTL_DEL, fd, &ev) < )
        {
            return -;
        }

        return ;
    }

    return -;
}

//等待监控的事件触发
int EPoller::EpollWait(int timeout)
{
    int fd;
    int nfds;
    Socket*  sock;
    unsigned int flag;

    nfds = epoll_wait(epoll_fd, p_events, max_fd, timeout);
    if (nfds < )
    {
        return -;
    }
    else if ( nfds ==  )
    {
        return  ;
    }

    for (int i=; i<nfds; i++)
    {
        sock = (Socket*)((p_events+i)->data.ptr);
        if ( sock == NULL )
        {
            continue;
        }
        flag = (p_events+i)->events;
        if (flag & EPOLLIN)
        {
            sock->Recv();
        }
        else if (flag & EPOLLOUT)
        {
            sock->Send();
        }
        else if (flag & EPOLLHUP)
        {
            sock->Close();
        }
        else if (flag & EPOLLERR)
        {
            sock->Error();
        }
    }

    return nfds ;
}
// 循环等待事件的触发
int EPoller::LoopForEvent(int timeout)
{
    while(true)
    {
        int result = EpollWait(timeout);
        if( result <=  )
        {
            return result;
        }
    }
}

其中的Socket类型作为其他网络通信服务类的基类，主要为其他的socket网络通信类提供一个统一的入口，其结构定义如下：

class Socket
{
    friend class EPoller;
public:
    int GetSockHandle();
    virtual int SendMsg(char* buffer, int length);

protected:
    virtual int Recv();
    virtual int Send();
    virtual int Close();
    virtual int Error();

    EPoller* epoller;
    int fd;

}

int Socket::SendMsg(char* buff, int len)
{
　　int ret;
　　int send_len = 0;
　　int _len = len;
　　errno = 0;
　　while(_len > 0)
　　{
　　　　ret = send(fd, (void*)(buff+send_len), _len, 0);
　　　　if (ret <= 0)
　　　　{
　　　　　　if (errno == EINTR || errno == EAGAIN)
　　　　　　{
　　　　　　　　usleep(10);
　　　　　　　　continue;
　　　　　　}
　　　　　　break;
　　　　}
　　　　send_len += ret;
　　　　_len -= ret;
　　}
　　return send_len;
}

二、UDP网络通信的实现

//Udp创建socket的流程
int CreateUdpSocket()
{
    // 1.创建socket
    sock_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    // 2.设置非阻塞
    fcntl(sock_fd, F_GETFL, );
    fcntl(sock_fd, F_SETFL, val | O_NONBLOCK);

    // 3.绑定端口与ip
    struct sockaddr_in addr;
    string ip = "0.0.0.0";
    addr.sin_family = AF_INET;
    addr.sin_port = htons();
    ip2uint(ip.c_str(), &(addr.sin_addr));
    bind(sock_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));

    // 4.设置socket缓存大小
    int recv_buf_size = ;
    int send_buf_size = ;
    setsockopt(sock_fd, SOL_SOCKET, SO_RCVBUF, (char *)&recv_buf_size, sizeof(recv_buf_size));
    setsockopt(sock_fd, SOL_SOCKET, SO_SNDBUF, (char *)&send_buf_size, sizeof(send_buf_size));
    return ;
}

// 接收数据
if ((len = recvfrom(sock, buffer, len, , (struct sockaddr *)&addr, &addrlen)) < )
{
    if (errno == EAGAIN || errno == EINTR)
    {
        len = ;
        return ;
    }
    else
    {
        return -;
    }
}

三、TCP网络通信的实现

//Tcp创建
bool CreateTcpServer()
{
     //建立TCP套接字
    sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    struct sockaddr_in svr_addr= {};
    svr_addr.sin_port = htons(port);
    svr_addr.sin_family = AF_INET;
    inet_pton(AF_INET, ip.c_str(), &(svr_addr.sin_addr));

    // 绑定ip地址
    if(bind(sock_fd, (struct sockaddr*)&svr_addr, sizeof(struct sockaddr_in)) < )

    // 设置socket属性
    int recv_buf_size =  * ;
    int send_buf_size =  * ;
    if (setsockopt(_sock_fd, SOL_SOCKET, SO_RCVBUF, (char*)&recv_buf_size, sizeof(recv_buf_size)) < )
    if(setsockopt(_sock_fd, SOL_SOCKET, SO_SNDBUF, (char*)&send_buf_size, sizeof(send_buf_size)) < )
    int reuse=;
    if(setsockopt(_sock_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse)) < )

    // 设置非阻塞
    int val = fcntl(_sock_fd, F_GETFL, );
    if(fcntl(_sock_fd, F_SETFL, val | O_NONBLOCK) == -)

    // 监听socket
    if(listen(sock_fd,) < )
    {
        close(sock_fd);
        sock_fd = -;
        return false;
    }
    return true ;
}
// 一种hash值的生成算法
int string2hash(const char * str, const int& len, const int& hash_size)
{
    int hashvalue = ;
    for (int i = len-; i < len; ++i)
    {
        hashvalue = ((unsigned char)(*(str + i)) + hashvalue) % hash_size;
    }
    return hashvalue;
}

//接收数据流程
int TCP_recv()
{
    char recv_buff[];
    int total_recv_len = ;

    int clientfd = accept(_sock_fd,(struct sockaddr *)NULL,(socklen_t*)NULL);
    if (clientfd <= )
    {
        return -;
    }

    //设置发送缓冲区和接收缓冲区大小
    int send_buff_size = ;
    int recv_buff_size = ;
    int set_result = ;
    set_result = setsockopt(clientfd, SOL_SOCKET, SO_RCVBUF, (char*)&recv_buff_size, sizeof(recv_buff_size));
    set_result = setsockopt(clientfd, SOL_SOCKET, SO_SNDBUF, (char*)&send_buff_size, sizeof(send_buff_size));

    int free_len = sizeof(recv_buff) - total_recv_len ;
    if(free_len <=  || total_recv_len >= )
    {
        //包太长了
        return ;
    }

    //接收数据
    int recv_len =  ;
    do
    {
        recv_len = recv(sock_fd, &recv_buff[total_recv_len], free_len, );
    }
    while((recv_len < ) && (errno == EINTR));

    if(recv_len <= )
    {
        // 对端连接关闭
        if( recv_len ==  )
        {
            return ;
        }
        else if( errno == EAGAIN)
        {
            //暂时阻塞
            return ;
        }
        else
        {
            return ;
        }
    }

    total_recv_len += recv_len;
    // 解析命令
    int offset = ParseCmd(recv_buff, total_recv_len);
    if( == offset)
    {
        //未接收完
        return ;
    }
    // 完成解析后，将已处理后的数据清空，使留下的未处理数据移到缓存区的起始位置。
    else if( < offset)
    {
        //解析成功,单条命令
        total_recv_len =  total_recv_len - offset;
        memmove(recv_buff, recv_buff + offset, total_recv_len);
    }

    return ;

}

// 与服务端建立socket长连接的方法
    int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    int recv_buf_size = ;
    int send_buf_size = ;

    setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *)&recv_buf_size, sizeof(recv_buf_size));
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *)&send_buf_size, sizeof(send_buf_size));

    struct sockaddr_in addr;
    memset(&addr, , sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());

    int argc = fcntl(fd, F_GETFL, );
    if (fcntl(fd, F_SETFL, argc | O_NONBLOCK) == -)
    {
        close(fd);
        return false;
    }

    int ret = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    if ( > ret)
    {
        bool bConnected = false;

        struct pollfd conncet_client[];
        int _nfd = ;
        memset(&_conncet_client[], , sizeof(pollfd));
        conncet_client[].fd = fd;
        conncet_client[].events = POLLOUT;

        int can_write = ::poll(_conncet_client, _nfd, (int)());
        if (can_write >  && (_conncet_client[].revents & POLLOUT) > )
        {
            bConnected = true;
        }
    }