socket 编程4 server端加入select 以便处理更多client

select(_sock + 1, &fdRead, &fdWrite, &fdExcept, NULL);

select最后一个参数有三种情况：

    timeout == NULL  等待无限长的时间。等待可以被一个信号中断。当有一个描述符做好准备或者是捕获到一个信号时函数会返回。如果捕获到一个信号， select函数将返回 -1,并将变量 erro设为 EINTR。

    timeout->tv_sec == 0 &&timeout->tv_usec == 0不等待，直接返回。加入描述符集的描述符都会被测试，并且返回满足要求的描述符的个数。这种方法通过轮询，无阻塞地获得了多个文件描述符状态。

    timeout->tv_sec !=0 ||timeout->tv_usec!= 0 等待指定的时间。当有描述符符合条件或者超过超时时间的话，函数返回。在超时时间即将用完但又没有描述符合条件的话，返回 0。对于第一种情况，等待也会被信号所中断。

 

#define WIN32_LEAN_AND_MEAN
#include <WinSock2.h>
#include <windows.h>
#include <WS2tcpip.h>
#include <stdio.h>
#include <vector>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
struct DataProgram
{
    int age;
    char name[36];
};

enum CMD
{
    CMD_LOGIN = 1,
    CMD_LOGIN_RESULT,
    CMD_LOGOUT,
    CMD_LOGOUT_RESULT,
    CMD_ERROR
};

struct DataHeader
{
    short cmd;
    short dataLength;
};

struct Login : public DataHeader
{
    Login()
    {
        cmd = CMD_LOGIN;
        dataLength = sizeof(Login);
    }
    char username[32];
    char passwd[32];
};

struct LoginResult : public DataHeader
{
    LoginResult()
    {
        cmd = CMD_LOGIN_RESULT;
        dataLength = sizeof(LoginResult);
    }
    short result;
};

struct Logout : public DataHeader
{
    Logout()
    {
        cmd = CMD_LOGOUT;
        dataLength = sizeof(Logout);
    }
    char username[32];
};

struct LogoutResult:public DataHeader
{
    LogoutResult()
    {
        cmd = CMD_LOGOUT_RESULT;
        dataLength = sizeof(LogoutResult);
    }
    short result;
};

vector<SOCKET> g_clients;

int parseData(SOCKET _csock)
{
    char szRecv[1024] = {}; //缓冲区
    int len = recv(_csock, szRecv, sizeof(DataHeader), 0);
    DataHeader * header = (DataHeader*)szRecv;
    if (len > 0)
    {
        printf("cmd=%d datalen=%d\n", header->cmd, header->dataLength);
        switch (header->cmd)
        {
            case CMD_LOGIN:
            {
                recv(_csock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
                Login *login = (Login *)szRecv;
                printf("login<client=%d> name=%s,passwd=%s\n",_csock,login->username, login->passwd);

                LoginResult loginresult = {};
                loginresult.result = 1;
                send(_csock, (const char *)&loginresult, sizeof(LoginResult), 0);
                return 0;
            }
            case CMD_LOGOUT:
            {
                recv(_csock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
                Logout *logout = (Logout *)szRecv;
                printf("logout<client=%d> name=%s\n",_csock, logout->username);

                LogoutResult logoutresult = {};
                logoutresult.result = 1;
                send(_csock, (const char *)&logoutresult, sizeof(LogoutResult), 0);
                return 0;
            }
            default:
            {
                header->cmd = CMD_ERROR;
                header->dataLength = 0;
                printf("cmd error\n");
                send(_csock, (const char *)&header, sizeof(header), 0);
                return 0;
            }
        }
    }
    else
    {
        printf("logout<client=%d> exit\n", _csock);
        closesocket(_csock);
        return -1;
    }
    return 0;
}

int main()
{
    WORD ver = MAKEWORD(2, 2);
    WSADATA dat;
    WSAStartup(ver,&dat);
    //SOCK_DGRAM IPPROTO_UDP
    SOCKET _sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (_sock == INVALID_SOCKET)
    {
        printf("socket create failed\n");
    }
    else
    {
        printf("socket create sucess\n");
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_addr.S_un.S_addr = INADDR_ANY;//inet_addr("127.0.0.1")
        //_sin.sin_addr.s_addr = htonl(INADDR_ANY);
        _sin.sin_port = htons(4567);
        int bindresult = bind(_sock, (sockaddr *)&_sin, sizeof(_sin));
        if (bindresult == SOCKET_ERROR)
        {
            printf("socket bind Failed\n");
        }
        else
        {
            printf("socket bind sucess\n");
            int listenresult = listen(_sock, 5);
            if (listenresult == SOCKET_ERROR)
            {
                printf("socket listen failed\n");
            }
            else
            {
                printf("socket listen sucess\n");
                while (true)
                {
                    
                    fd_set fdRead;
                    fd_set fdWrite;
                    fd_set fdExcept;
                    FD_ZERO(&fdRead);
                    FD_ZERO(&fdWrite);
                    FD_ZERO(&fdExcept);

                    FD_SET(_sock, &fdRead);
                    FD_SET(_sock, &fdWrite);
                    FD_SET(_sock, &fdExcept);

                    for (size_t i = 0;i < g_clients.size();i++)
                    {
                        FD_SET(g_clients[i], &fdRead);
                    }

                    //nfds是一个整数值,是指fd_set中所有文件描述符(_socket)的范围而不是数量
                    //即是所有文件描述符最大值+1，在windows中这个参数可以写0
                    timeval t = { 1,0 };
                    int ret = select(_sock + 1, &fdRead, &fdWrite, &fdExcept, &t);
                    /*
                    负值：select错误
                    正值：某些文件可读写或出错
                    0：等待超时，没有可读写或错误的文件
                    */
                    if (ret < 0)
                    {
                        printf("select任务结束.\n");
                        break;
                    }

                    if (FD_ISSET(_sock,&fdRead))
                    {
                        FD_CLR(_sock, &fdRead);
                        sockaddr_in clientAddr = {};
                        int nAddrLen = sizeof(clientAddr);
                        SOCKET _csock = INVALID_SOCKET;
                        _csock = accept(_sock, (sockaddr *)&clientAddr, &nAddrLen);
                        if (_csock == INVALID_SOCKET)
                        {
                            printf("Error,接受到无效客户端socket....\n");
                        }
                        char str[INET_ADDRSTRLEN];
                        printf("new client<%d>:%s-%d-%d\n",_csock, inet_ntop(AF_INET, &clientAddr.sin_addr, str, sizeof(str)),
                            clientAddr.sin_port,
                            clientAddr.sin_family);
                        //inet_ntoa(clientAddr.sin_addr)

                        g_clients.push_back(_csock);
                    }
                    for (size_t i = 0; i < fdRead.fd_count; i++)
                    {
                        int j = parseData(fdRead.fd_array[i]);
                        if (j == -1)
                        {
                            auto iter = find(g_clients.begin(), g_clients.end(), fdRead.fd_array[i]);
                            if (iter != g_clients.end())
                            {
                                g_clients.erase(iter);
                            }
                        }
                    }
                    printf("hello world\n");
                }
                
            }
        }
    }
    closesocket(_sock);
    WSACleanup();
    getchar();
    return 0;
}

 

非常不错的服务器编程教程 

https://study.163.com/course/introduction/1006470001.htm?share=1&shareId=1023405782&utm_campaign=share&utm_medium=iphoneShare&utm_source=weixin&utm_u=1023405782