跨平台服务器

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <windows.h>
#include <WinSock2.h>
#pragma comment(lib , "ws2_32.lib")
#else
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>

#define SOCKET int
#define INVALID_SOCKET (SOCKET) (-0)
#define SOCKET_ERROR            (-1)
#endif
#include <thread>
#include <cstdio>
#include <vector>

enum CMD {
    CMD_LOGIN,
        CMD_LOGIN_RESULT,
        CMD_LOGOUT,
        CMD_LOGOUT_RESULT,
        CMD_NEW_USER_JOIN,
        CMD_ERROR
};

struct DataHeader {
    short dataLength;  // 包体长度
    short cmd;         
};

// DataPackage
struct Login : public DataHeader{  
    Login() {
        dataLength = sizeof(Login);
            cmd = CMD_LOGIN;
    }
    char userName[32];
        char PassWord[32];
};

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

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

struct LoginOutResult : public DataHeader {
    LoginOutResult() {
        dataLength = sizeof(LoginOutResult);
            cmd = CMD_LOGIN_RESULT;
            result = 0;
    }
    int result;
};

struct NewUserJoin : public DataHeader {
    NewUserJoin() {
        dataLength = sizeof(NewUserJoin);
            cmd = CMD_NEW_USER_JOIN;
            sock = 0;
    }
    int sock;
};

std::vector<SOCKET> g_clients;

int processor(SOCKET csock) {
    // 缓冲区
    char szRecv[1024] = {};
        // 接收客户端的请求数据
        int len = recv(csock, szRecv, sizeof(DataHeader), 0);
        DataHeader* header = (DataHeader*)szRecv;
        if (len <= 0) {
            printf("client = <Socket = %d> exit\n" , csock);
                return -1;
        }
    // 处理请求
    switch (header->cmd) {
        case CMD_LOGIN:
                       {
                           recv(csock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
                               Login* login = (Login*)szRecv;
                               printf("收到<Socket = %d>:CMD_LOGIN , 数据长度: %d , 用户名:%s"
                                       "密码: %s \n", csock , login->dataLength, login->userName, login->PassWord);
                               // 忽略判断用户名密码是否正确的过程
                               LoginResult ret;
                               send(csock, (char*)&ret, sizeof(LoginResult), 0);
                       }
                       break;
        case CMD_LOGOUT:
                        {
                            recv(csock, szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);
                                LogOut* logout = (LogOut*)szRecv;
                                printf("收到<Socket = %d>:CMD_LOGIN , 数据长度: %d , 用户名:%s"
                                        "\n", csock , logout->dataLength, logout->userName);
                                // 忽略判断用户名密码是否正确的过程
                                LoginResult ret;
                                send(csock, (char*)&ret, sizeof(LoginResult), 0);
                        }
                        break;
        default:
                {
                    DataHeader header = { 0 , CMD_ERROR };
                        send(csock, (char*)&header, sizeof(DataHeader), 0);
                }
                break;
    }
    return 0;
}

int main()
{
#ifdef _WIN32
    // 启动Windows socket 2.x环境
    WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
        //-----------------
#endif
        
        // 用Socket API建立简易TCP服务器端
        // 1建立一个Socket
        SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        // 2 bind 绑定用于接收客户端连接的网络端口
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(4567);
#ifdef _WIN32
        _sin.sin_addr.S_un.S_addr = INADDR_ANY;
#else
        _sin.sin_addr.s_addr = INADDR_ANY;//inet_addr("127.0.0.1");
#endif
    if (bind(sock, (sockaddr*)&_sin, sizeof(_sin)) == SOCKET_ERROR) {
        printf("Bind Port Error\n");
    }
    else {
        printf("Bind Port Success\n");
    }
    // 3 listen 监听网络端口
    if (listen(sock, 5) == SOCKET_ERROR) {
        printf("listen failed\n");
    }
    else {
        printf("listen success\n");
    }
    while (true) {
        // 伯克利套接字 BSD Socket
        fd_set fdRead;
        fd_set fdWrite;
        fd_set fdExcep;
        //清理集合
        FD_ZERO(&fdRead);
        FD_ZERO(&fdWrite);
        FD_ZERO(&fdExcep);
        //描述符(socket)加入集合
        FD_SET(sock, &fdRead);
        FD_SET(sock, &fdWrite);
        FD_SET(sock, &fdExcep);
        
        SOCKET maxSock = sock;
        for (int i = (int)g_clients.size() - 1 ; i >= 0 ; i--) {
                FD_SET(g_clients[i], &fdRead);
                if(maxSock < g_clients[i]){
                    maxSock = g_clients[i];
                }
            }
        // nfds是一个整数值,是指fd_set集合中所有描述符(socket)的范围，而不是数量
        // 既是所有文件描述符的最大值+1,在Windows中这个参数可以写0
        timeval t = {1 ,0};
        int ret = select(maxSock + 1, &fdRead, &fdWrite, &fdExcep, &t);
        if (ret < 0) {
            printf("select massion end\n");
            break;
        }
        //判断socket是否在集合中
        if (FD_ISSET(sock, &fdRead)) {
            FD_CLR(sock, &fdRead);
                // 4 accept 等待客户端连接
                sockaddr_in clientAddr = {};
                int cAddrlen = sizeof(sockaddr_in);
                SOCKET csock = INVALID_SOCKET;
#ifdef _WIN32
                csock = accept(sock, (sockaddr*)&clientAddr, &cAddrlen);
#else
                csock = accept(sock, (sockaddr*)&clientAddr, (socklen_t *)&cAddrlen);
#endif
                if (csock == INVALID_SOCKET) {
                    printf("failed , recieve a invalid client socket\n");
                }
                else {
                    for (int i = g_clients.size() - 1; i >= 0; i--) {
                        NewUserJoin userJoin;
                            send(g_clients[i], (const char*)&userJoin, sizeof(NewUserJoin), 0);
                    }
                    g_clients.push_back(csock);
                        printf("new client join:socket = %d , IP = %s \n", csock, inet_ntoa(clientAddr.sin_addr));
                }
        }
        for(int i = (int)g_clients.size() - 1 ; i >= 0 ; i--){
            if(FD_ISSET(g_clients[i] , &fdRead)){
                if(-1 == processor(g_clients[i])){
                    // std::vector<SOCKET>::iterator iter   
                    auto iter = g_clients.begin() + i;
                    if( iter != g_clients.end()){
                        g_clients.erase(iter);
                    }
                }
            }
        }       
        printf("空闲时间...\n");
    }
#ifdef _WIN32 
    for (int i = g_clients.size() - 1; i >= 0; i--) {
        closesocket(g_clients[i]);
    }
    // 6 关闭套接字
    closesocket(sock);
        WSACleanup();
#else
        for (int i = g_clients.size() - 1; i >= 0; i--) {
            close(g_clients[i]);
        }
    close(sock);
#endif
    printf("任务完成\n");
        getchar();
        return 0;
}

简锋/服务器编程

内容风险标识

评论 (0)

简锋/服务器编程 .gitee-modal { width: 500px !important; }

内容风险标识