[网络协议]深入浅出websocket

本篇博文主要是提供了一个基于tcp封装的websocket服务端，没有使用任何的网络库，这样便于自我学习，关于这个协议的一些概念的话，大家可以执行百度了解。
客户端的话，大家可以找一些在线网站模拟websocket客户端即可。代码的话，由select+tcp改装而成，主要适用于windows平台，大家如果有兴趣也可以使用epoll来实现。下面给出具体的代码，具体可以用vs进行单步调试观察一下包的格式，这样对于理解这个协议的理解是非常有帮助的。

//base64.cpp

#include "base64.h"
#include <iostream>

static const std::string base64_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";


static inline bool is_base64(unsigned char c) {
    return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
    std::string ret;
    int i = 0;
    int j = 0;
    unsigned char char_array_3[3];
    unsigned char char_array_4[4];

    while (in_len--) {
        char_array_3[i++] = *(bytes_to_encode++);
        if (i == 3) {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for (i = 0; (i < 4); i++)
                ret += base64_chars[char_array_4[i]];
            i = 0;
        }
    }

    if (i)
    {
        for (j = i; j < 3; j++)
            char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; (j < i + 1); j++)
            ret += base64_chars[char_array_4[j]];

        while ((i++ < 3))
            ret += '=';

    }
    return ret;
}

std::string base64_decode(std::string const& encoded_string) {
    size_t in_len = encoded_string.size();
    int i = 0;
    int j = 0;
    int in_ = 0;
    unsigned char char_array_4[4], char_array_3[3];
    std::string ret;

    while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
        char_array_4[i++] = encoded_string[in_]; in_++;
        if (i == 4) {
            for (i = 0; i < 4; i++)
                char_array_4[i] = base64_chars.find(char_array_4[i]);

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

            for (i = 0; (i < 3); i++)
                ret += char_array_3[i];
            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 4; j++)
            char_array_4[j] = 0;

        for (j = 0; j < 4; j++)
            char_array_4[j] = base64_chars.find(char_array_4[j]);

        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
    }

    return ret;
}

base64.h

#pragma once
#include <string>

std::string base64_encode(unsigned char const*, unsigned int len);
std::string base64_decode(std::string const& s);

//sha1.cpp

#include "sha1.h"

/*  
 *  SHA1
 *
 *  Description:
 *      This is the constructor for the sha1 class.
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
SHA1::SHA1()
{
    Reset();
}

/*  
 *  ~SHA1
 *
 *  Description:
 *      This is the destructor for the sha1 class
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
SHA1::~SHA1()
{
    // The destructor does nothing
}

/*  
 *  Reset
 *
 *  Description:
 *      This function will initialize the sha1 class member variables
 *      in preparation for computing a new message digest.
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::Reset()
{
    Length_Low          = 0;
    Length_High         = 0;
    Message_Block_Index = 0;

    H[0]        = 0x67452301;
    H[1]        = 0xEFCDAB89;
    H[2]        = 0x98BADCFE;
    H[3]        = 0x10325476;
    H[4]        = 0xC3D2E1F0;

    Computed    = false;
    Corrupted   = false;
}

/*  
 *  Result
 *
 *  Description:
 *      This function will return the 160-bit message digest into the
 *      array provided.
 *
 *  Parameters:
 *      message_digest_array: [out]
 *          This is an array of five unsigned integers which will be filled
 *          with the message digest that has been computed.
 *
 *  Returns:
 *      True if successful, false if it failed.
 *
 *  Comments:
 *
 */
bool SHA1::Result(unsigned *message_digest_array)
{
    int i;                                  // Counter

    if (Corrupted)
    {
        return false;
    }

    if (!Computed)
    {
        PadMessage();
        Computed = true;
    }

    for(i = 0; i < 5; i++)
    {
        message_digest_array[i] = H[i];
    }

    return true;
}

/*  
 *  Input
 *
 *  Description:
 *      This function accepts an array of octets as the next portion of
 *      the message.
 *
 *  Parameters:
 *      message_array: [in]
 *          An array of characters representing the next portion of the
 *          message.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::Input(   const unsigned char *message_array,
                    unsigned            length)
{
    if (!length)
    {
        return;
    }

    if (Computed || Corrupted)
    {
        Corrupted = true;
        return;
    }

    while(length-- && !Corrupted)
    {
        Message_Block[Message_Block_Index++] = (*message_array & 0xFF);

        Length_Low += 8;
        Length_Low &= 0xFFFFFFFF;               // Force it to 32 bits
        if (Length_Low == 0)
        {
            Length_High++;
            Length_High &= 0xFFFFFFFF;          // Force it to 32 bits
            if (Length_High == 0)
            {
                Corrupted = true;               // Message is too long
            }
        }

        if (Message_Block_Index == 64)
        {
            ProcessMessageBlock();
        }

        message_array++;
    }
}

/*  
 *  Input
 *
 *  Description:
 *      This function accepts an array of octets as the next portion of
 *      the message.
 *
 *  Parameters:
 *      message_array: [in]
 *          An array of characters representing the next portion of the
 *          message.
 *      length: [in]
 *          The length of the message_array
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::Input(   const char  *message_array,
                    unsigned    length)
{
    Input((unsigned char *) message_array, length);
}

/*  
 *  Input
 *
 *  Description:
 *      This function accepts a single octets as the next message element.
 *
 *  Parameters:
 *      message_element: [in]
 *          The next octet in the message.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::Input(unsigned char message_element)
{
    Input(&message_element, 1);
}

/*  
 *  Input
 *
 *  Description:
 *      This function accepts a single octet as the next message element.
 *
 *  Parameters:
 *      message_element: [in]
 *          The next octet in the message.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::Input(char message_element)
{
    Input((unsigned char *) &message_element, 1);
}

/*  
 *  operator<<
 *
 *  Description:
 *      This operator makes it convenient to provide character strings to
 *      the SHA1 object for processing.
 *
 *  Parameters:
 *      message_array: [in]
 *          The character array to take as input.
 *
 *  Returns:
 *      A reference to the SHA1 object.
 *
 *  Comments:
 *      Each character is assumed to hold 8 bits of information.
 *
 */
SHA1& SHA1::operator<<(const char *message_array)
{
    const char *p = message_array;

    while(*p)
    {
        Input(*p);
        p++;
    }

    return *this;
}

/*  
 *  operator<<
 *
 *  Description:
 *      This operator makes it convenient to provide character strings to
 *      the SHA1 object for processing.
 *
 *  Parameters:
 *      message_array: [in]
 *          The character array to take as input.
 *
 *  Returns:
 *      A reference to the SHA1 object.
 *
 *  Comments:
 *      Each character is assumed to hold 8 bits of information.
 *
 */
SHA1& SHA1::operator<<(const unsigned char *message_array)
{
    const unsigned char *p = message_array;

    while(*p)
    {
        Input(*p);
        p++;
    }

    return *this;
}

/*  
 *  operator<<
 *
 *  Description:
 *      This function provides the next octet in the message.
 *
 *  Parameters:
 *      message_element: [in]
 *          The next octet in the message
 *
 *  Returns:
 *      A reference to the SHA1 object.
 *
 *  Comments:
 *      The character is assumed to hold 8 bits of information.
 *
 */
SHA1& SHA1::operator<<(const char message_element)
{
    Input((unsigned char *) &message_element, 1);

    return *this;
}

/*  
 *  operator<<
 *
 *  Description:
 *      This function provides the next octet in the message.
 *
 *  Parameters:
 *      message_element: [in]
 *          The next octet in the message
 *
 *  Returns:
 *      A reference to the SHA1 object.
 *
 *  Comments:
 *      The character is assumed to hold 8 bits of information.
 *
 */
SHA1& SHA1::operator<<(const unsigned char message_element)
{
    Input(&message_element, 1);

    return *this;
}

/*  
 *  ProcessMessageBlock
 *
 *  Description:
 *      This function will process the next 512 bits of the message
 *      stored in the Message_Block array.
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *      Many of the variable names in this function, especially the single
 *      character names, were used because those were the names used
 *      in the publication.
 *
 */
void SHA1::ProcessMessageBlock()
{
    const unsigned K[] =    {               // Constants defined for SHA-1
                                0x5A827999,
                                0x6ED9EBA1,
                                0x8F1BBCDC,
                                0xCA62C1D6
                            };
    int         t;                          // Loop counter
    unsigned    temp;                       // Temporary word value
    unsigned    W[80];                      // Word sequence
    unsigned    A, B, C, D, E;              // Word buffers

    /*
     *  Initialize the first 16 words in the array W
     */
    for(t = 0; t < 16; t++)
    {
        W[t] = ((unsigned) Message_Block[t * 4]) << 24;
        W[t] |= ((unsigned) Message_Block[t * 4 + 1]) << 16;
        W[t] |= ((unsigned) Message_Block[t * 4 + 2]) << 8;
        W[t] |= ((unsigned) Message_Block[t * 4 + 3]);
    }

    for(t = 16; t < 80; t++)
    {
       W[t] = CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
    }

    A = H[0];
    B = H[1];
    C = H[2];
    D = H[3];
    E = H[4];

    for(t = 0; t < 20; t++)
    {
        temp = CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30,B);
        B = A;
        A = temp;
    }

    for(t = 20; t < 40; t++)
    {
        temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30,B);
        B = A;
        A = temp;
    }

    for(t = 40; t < 60; t++)
    {
        temp = CircularShift(5,A) +
               ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30,B);
        B = A;
        A = temp;
    }

    for(t = 60; t < 80; t++)
    {
        temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
        temp &= 0xFFFFFFFF;
        E = D;
        D = C;
        C = CircularShift(30,B);
        B = A;
        A = temp;
    }

    H[0] = (H[0] + A) & 0xFFFFFFFF;
    H[1] = (H[1] + B) & 0xFFFFFFFF;
    H[2] = (H[2] + C) & 0xFFFFFFFF;
    H[3] = (H[3] + D) & 0xFFFFFFFF;
    H[4] = (H[4] + E) & 0xFFFFFFFF;

    Message_Block_Index = 0;
}

/*  
 *  PadMessage
 *
 *  Description:
 *      According to the standard, the message must be padded to an even
 *      512 bits.  The first padding bit must be a '1'.  The last 64 bits
 *      represent the length of the original message.  All bits in between
 *      should be 0.  This function will pad the message according to those
 *      rules by filling the message_block array accordingly.  It will also
 *      call ProcessMessageBlock() appropriately.  When it returns, it
 *      can be assumed that the message digest has been computed.
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1::PadMessage()
{
    /*
     *  Check to see if the current message block is too small to hold
     *  the initial padding bits and length.  If so, we will pad the
     *  block, process it, and then continue padding into a second block.
     */
    if (Message_Block_Index > 55)
    {
        Message_Block[Message_Block_Index++] = 0x80;
        while(Message_Block_Index < 64)
        {
            Message_Block[Message_Block_Index++] = 0;
        }

        ProcessMessageBlock();

        while(Message_Block_Index < 56)
        {
            Message_Block[Message_Block_Index++] = 0;
        }
    }
    else
    {
        Message_Block[Message_Block_Index++] = 0x80;
        while(Message_Block_Index < 56)
        {
            Message_Block[Message_Block_Index++] = 0;
        }

    }

    /*
     *  Store the message length as the last 8 octets
     */
    Message_Block[56] = (Length_High >> 24) & 0xFF;
    Message_Block[57] = (Length_High >> 16) & 0xFF;
    Message_Block[58] = (Length_High >> 8) & 0xFF;
    Message_Block[59] = (Length_High) & 0xFF;
    Message_Block[60] = (Length_Low >> 24) & 0xFF;
    Message_Block[61] = (Length_Low >> 16) & 0xFF;
    Message_Block[62] = (Length_Low >> 8) & 0xFF;
    Message_Block[63] = (Length_Low) & 0xFF;

    ProcessMessageBlock();
}


/*  
 *  CircularShift
 *
 *  Description:
 *      This member function will perform a circular shifting operation.
 *
 *  Parameters:
 *      bits: [in]
 *          The number of bits to shift (1-31)
 *      word: [in]
 *          The value to shift (assumes a 32-bit integer)
 *
 *  Returns:
 *      The shifted value.
 *
 *  Comments:
 *
 */
unsigned SHA1::CircularShift(int bits, unsigned word)
{
    return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32-bits));
}

//sha1.h

#ifndef _SHA1_H_
#define _SHA1_H_

class SHA1
{
    public:

        SHA1();
        virtual ~SHA1();

        /*
         *  Re-initialize the class
         */
        void Reset();

        /*
         *  Returns the message digest
         */
        bool Result(unsigned *message_digest_array);

        /*
         *  Provide input to SHA1
         */
        void Input( const unsigned char *message_array,
                    unsigned            length);
        void Input( const char  *message_array,
                    unsigned    length);
        void Input(unsigned char message_element);
        void Input(char message_element);
        SHA1& operator<<(const char *message_array);
        SHA1& operator<<(const unsigned char *message_array);
        SHA1& operator<<(const char message_element);
        SHA1& operator<<(const unsigned char message_element);

    private:

        /*
         *  Process the next 512 bits of the message
         */
        void ProcessMessageBlock();

        /*
         *  Pads the current message block to 512 bits
         */
        void PadMessage();

        /*
         *  Performs a circular left shift operation
         */
        inline unsigned CircularShift(int bits, unsigned word);

        unsigned H[5];                      // Message digest buffers

        unsigned Length_Low;                // Message length in bits
        unsigned Length_High;               // Message length in bits

        unsigned char Message_Block[64];    // 512-bit message blocks
        int Message_Block_Index;            // Index into message block array

        bool Computed;                      // Is the digest computed?
        bool Corrupted;                     // Is the message digest corruped?
    
};

#endif // _SHA1_H_

上面几个文件提供的接口可以用来进行数据的加密，
这个如果大家有需要可以考虑一下，具体的用法，可以看如下的文件。(当然，如果服务端使用了，客户端那么也是需要使用的)

#include "debug_log.h"

void DEBUG_LOG(const char* msg, ...) {
    char message[256] = { 0 };
    va_list args;
    va_start(args, msg);
    vsprintf(message, msg, args);
    va_end(args);
    Debug_LOG::log()->write_log(message);
}

Debug_LOG* Debug_LOG::m_log = NULL;

Debug_LOG::Debug_LOG() :
    tim(0),
    t(NULL),
    fp(NULL),
    filepath(),
    message(),
    last_log_time()
{
#ifdef __WRITE_FILE__
    create_log_file();
#endif
}

Debug_LOG::~Debug_LOG() {
#ifdef __WRITE_FILE__
    fclose(fp);
#endif
}

void Debug_LOG::create_log_file() {
    if (fp != NULL)
        fclose(fp);

    sprintf(filepath, "./log/debuglog_");
    time(&tim);
    t = localtime(&tim);
    memcpy(&last_log_time, t, sizeof(struct tm));
    sprintf(filepath + 15, "%02d_%02d", t->tm_mon + 1, t->tm_mday);
    fp = fopen(filepath, "a+");
}

Debug_LOG* Debug_LOG::log() {
    if (m_log == NULL) {
        m_log = new Debug_LOG();
    }
    return m_log;
}

void Debug_LOG::write_log(const char* msg) {
    time(&tim);
    t = localtime(&tim);
    sprintf(message, "[%02d:%02d:%02d] %s\n", t->tm_hour, t->tm_min, t->tm_sec, msg);
#ifdef __WRITE_FILE__
    if (t->tm_mday != last_log_time.tm_mday || t->tm_mon != last_log_time.tm_mon
        || t->tm_year != last_log_time.tm_year)
        create_log_file();
    fwrite(message, strlen(message), 1, fp);
    fflush(fp);
#else
    printf("\n%s", message);
    fflush(stdout);
#endif
}

#pragma once

#ifndef __debug_log__
#define __debug_log__

//#define __WRITE_FILE__

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdarg.h>

void DEBUG_LOG(const char* msg, ...);

class Debug_LOG 
{
private:
    Debug_LOG();
    ~Debug_LOG();
    void create_log_file();
public:
    static Debug_LOG* log();
    void write_log(const char* msg);
private:
    static Debug_LOG* m_log;
    time_t tim;
    struct tm* t;
    FILE* fp;
    char filepath[32];
    char message[256];
    struct tm last_log_time;
};

#endif

这两个是用来调试的。

//以下的代码是核心部分。

#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include "debug_log.h"
#include "network_interface.h"
#include "websocket_respond.h"
#include "websocket_request.h"
#include <winsock2.h>
#include "windows.h"
#include "time.h"
WEB_SOCKET_ISH5_MAP websocket_ish5run_map_;
WEB_SOCKET_ISH5_MAP websocket_ish5configdata_map_;
WEB_SOCKET_ISH5_MAP websocket_ish5gamedata_map_;
/*静态变量初始化*/
Network_Interface* Network_Interface::m_network_interface = NULL;
/***************************************************************
 * @file       network_interface.cpp
 * @brief      socket初始化
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
Network_Interface::Network_Interface() : listenfd_(0), websocket_handler_map_()
{
    if(init() != 0)
    {
        exit(1);
    }
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      销毁网络相关dll
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
Network_Interface::~Network_Interface() 
{
    WSACleanup();
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      一直在这个循环里等待连接
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Network_Interface::run()
{
    select_loop();
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      生成一个实例
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
Network_Interface* Network_Interface::get_share_network_interface()
{
    if(m_network_interface == NULL)
        m_network_interface = new Network_Interface();
    return m_network_interface;
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      socket初始化
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Network_Interface::init() 
{
    WSADATA wsaData;
    int err = WSAStartup(MAKEWORD(2, 2), &wsaData); 
    if(err != 0)
    {
        std::cout << "Load WinSock Failed!\n";
        return -1;
    }
    listenfd_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listenfd_ == -1) 
    {
        DEBUG_LOG("create socket error!\n");
        return -1;
    }
    /*设置套接字选项，注意是处于socket和bind之间*/
    int option = 1;
    if(setsockopt(listenfd_, SOL_SOCKET, SO_REUSEADDR, (char*)&option, sizeof(int)) < 0)
    {
        return -1;
    }
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(sockaddr_in));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);
    if(bind(listenfd_, (struct sockaddr*)(&server_addr), sizeof(server_addr)) == -1) 
    {
        DEBUG_LOG("bind socket error!\n");
        return -1;
    }
    if(listen(listenfd_, 15) == -1) 
    {
        DEBUG_LOG("listen socket error!\n");
        return -1;
    }
    /*先清零*/
    FD_ZERO(&reads);
    /*把监听套接字这一项加进来*/
    FD_SET(listenfd_, &reads);
    /*目前最大的监听套接字描述符是listenfd_*/
    fd_max = listenfd_;
    return 0;
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      select_event事件，用于往select_event添加或者删除
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Network_Interface::select_event(int fd, bool flag)
{
    if(flag)
    {
        /*更新当前最大的套接字文件描述符*/
        if(fd_max < fd)
        {
            fd_max = fd;
        }
        /*加进来，后续有IO事件来时select函数会从内核态得到通知，
        这样select函数就会被唤醒了，函数流程接着往下走*/
        FD_SET(fd, &reads);
        /*根据fd来new一个对象，用来操作后续的相关业务逻辑*/
        websocket_handler_map_[fd] = new Websocket_Handler(fd);
        /*根据这个map关系判断怎么回复数据*/
        websocket_ish5run_map_[fd] = true;
        if(fd != listenfd_)
        {
            DEBUG_LOG("fd: %d add select loop", fd);
        }
    }
    else
    {
        /*如果函数流程走到这里，就是对方关闭了连接，先把fd从reads里面清除*/
        FD_CLR(fd, &reads);
        /*关闭连接*/
        closesocket(fd);
        /*删除new出来的实例，因为已经关闭了，就delete吧*/
        delete websocket_handler_map_[fd];
        /*从map当中移除这个节点*/
        websocket_handler_map_.erase(fd);   
        /*退出了移除相应的节点,相应的值会变成false*/
        websocket_ish5run_map_.erase(fd);
        websocket_ish5configdata_map_.erase(fd);
        websocket_ish5gamedata_map_.erase(fd);
        DEBUG_LOG("fd: %d del select loop", fd);
    }
}
/***************************************************************
 * @file       network_interface.cpp
 * @brief      select_loop等待新的连接或者在已经建立连接的基础上收发数据
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Network_Interface::select_loop()
{
    /*struct timeval timeout;
    timeout.tv_sec = 5;
    timeout.tv_usec = 5000;*/
    struct sockaddr_in clnt_adr;
    int fd_num, i, fd = 0, bufflen = 0;
    int clilen = sizeof(SOCKADDR);
    while(true) 
    {
        /*这个赋值一定要有，因为select函数返回时cpy_reads的值，只会是
        当前活跃状态下的socket，reads用来记录所有的事件，而cpy_reads
        记录当前活跃的状态*/
        cpy_reads = reads;
        /*等于负一？出错了，直接退出吧*/
        if((fd_num = select(fd_max + 1, &cpy_reads, 0, 0, /*&timeout先阻塞处理*/ NULL)) == -1)
            break;
        /*等于0，说明超时了，没有事件来，但是这里是用的阻塞，所以应该不会返回0*/
        if(fd_num == 0)
            continue;
        /*有事件来了，开始从0到最大的文件描述符遍历吧*/
        for(i = 0; i < fd_max + 1; i++)
        {
            /*从活跃状态下判断是新连接还是以前的连接发数据过来*/
            if(FD_ISSET(i, &cpy_reads))
            {
                /*如果是新的连接进来就*/
                if(i == listenfd_) 
                {
                    fd = accept(listenfd_, (struct sockaddr*)&clnt_adr, &clilen);   
                    select_event(fd, true);
                }
                else/*以往的连接发送的数据*/
                {
                    /*根据特定的socket与客户端建立联系*/
                    Websocket_Handler* handler = websocket_handler_map_[i];
                    if(handler == NULL)
                    {
                        continue;
                    }
                    /*将收到的数据放在handler->getbuff()里面*/
                    if((bufflen = recv(i, handler->getbuff(), BUFFLEN, 0)) == 0)
                    {
                        /*如果bufflen等于0，说明是对方关闭了连接*/
                        select_event(i, false);
                    }
                    /*websocket关闭的时候第一次会收到一个bufflen等于8的包，第二次才会收到
                    bufflen等于0的数据包，这里等于8的话，直接返回去吧，如果数据的长度真的
                    等于8？现在没有这种情况，有再考虑吧*/
                    else if(bufflen == 8)
                    {
                        continue;
                    }
                    else if(bufflen < 0)/*小于0说明肯定有错误，先返回去吧*/
                    {
                        break;
                    }
                    else
                    {
                        handler->process();
                    }
                }
            }
        }
    }
    return 0;
}

//

#ifndef __WEBSOCKET_HANDLER__
#define __WEBSOCKET_HANDLER__
#include <winsock2.h>
#include <iostream>
#include <map>
#include <sstream>
#include "base64.h"
#include "sha1.h"
#include "debug_log.h"
#include "websocket_request.h"

#define MAGIC_KEY "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

enum WEBSOCKET_STATUS 
{
    WEBSOCKET_UNCONNECT = 0,
    WEBSOCKET_HANDSHARKED = 1,
};
typedef std::map<std::string, std::string> HEADER_MAP;
class Websocket_Handler 
{
public:
    Websocket_Handler(int fd);
    ~Websocket_Handler();
    int process();
    inline char* getbuff();
private:
    int handshark();
    void parse_str(char* request);
    int fetch_http_info();
    int send_data(char* buff);
private:
    Websocket_Request* request_;
    char buff_[2048];
    WEBSOCKET_STATUS status_;
    HEADER_MAP header_map_;
    int fd_;
};
    
inline char* Websocket_Handler::getbuff()
{
    return buff_;
}
#endif

//

#include <winsock2.h>
#include "websocket_request.h"
#include "network_interface.h"
#include <json/json.h>
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      构造函数初始化
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
Websocket_Request::Websocket_Request(int fd) : fd_(fd),fin_(), opcode_(), mask_(),
    masking_key_(),
    payload_length_(),
    payload_() 
{
    _M_h5aes.setkey("DlClientPost2019");/*设置加密的key*/
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对配置信息的处理
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Websocket_Request::runconfigdata(char *str, int len, int socket)
{
    char* runconfigdata = new char[len + 1];
    memcpy(runconfigdata, str, len + 1);
    printf("\n\nrunconfigdata = %s\n", str);
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对游戏信息的处理
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Websocket_Request::rungamedata(char* str, int len, int socket)
{
  //。。。。
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对客户端发送的数据做的处理
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::websockettoh5(char *content, int length, int fd)
{
    /*这个应该是协议栈发心跳包过来，我们不处理，直接返回吧*/
    if(length == 30)
    {
        return 0;
    }
    printf("content = %s,length = %d\n", content,length);
    /*记得是申请length + 1长度的内存，把字符串结尾的\0也加上*/
    char* data = new char[length + 1];
    memcpy(data, content, length + 1);
    printf("data = %s,length = %d\n", data, length);
    /*解密*/
    BYTE* de_base64;
    BYTE* de_payload;
    int ret = _M_h5aes.base64_decode((char*)data, &de_base64);
    if(ret > 0)
    {
        ret = _M_h5aes.decrypt(de_base64, ret, &de_payload);
        if(ret > 0)
        {
            de_payload[ret] = 0;
        }
        else
        {
            return 0;
        }
        printf("\n\nde_payload = %s,ret = %d\n", de_payload, ret);
    }
    else
    {
        return 0;
    }
    /*将解密后的数据转成json格式*/
    Json::Value command;
    Json::Reader read;
    read.parse((char *)de_payload, (char *)de_payload + ret, command);
    /*最后拿到手的数据*/
    std::cout << command <<std::endl;
    //...下面是业务逻辑处理
    }
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      解码，拿到加密以后的数据
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_websocket_info(char *msg)
{
    /*这几步是解码，我们不用管*/
    int pos = 0;
    fetch_fin(msg, pos);
    fetch_opcode(msg, pos);
    fetch_mask(msg, pos);
    fetch_payload_length(msg, pos);
    fetch_masking_key(msg, pos);
    fetch_payload(msg, pos);
    /*解码以后拿到了加密后的数据和长度*/
    return websockettoh5(payload_, payload_length_, fd_);
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      解码，拿到加密以后的数据
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Websocket_Request::reset()
{
    fin_ = 0;
    opcode_ = 0;
    mask_ = 0;
    memset(masking_key_, 0, sizeof(masking_key_));
    payload_length_ = 0;
    memset(payload_, 0, sizeof(payload_));
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_fin(char *msg, int &pos)
{
    fin_ = (unsigned char)msg[pos] >> 7;
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_opcode(char *msg, int &pos)
{
    opcode_ = msg[pos] & 0x0f;
    pos++;
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_mask(char *msg, int &pos)
{
    mask_ = (unsigned char)msg[pos] >> 7;
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_masking_key(char *msg, int &pos)
{
    if(mask_ != 1)
        return 0;
    for(int i = 0; i < 4; i++)
        masking_key_[i] = msg[pos + i];
    pos += 4;
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_payload_length(char *msg, int &pos)
{
    payload_length_ = msg[pos] & 0x7f;
    pos++;
    if(payload_length_ == 126)
    {
        uint16_t length = 0;
        memcpy(&length, msg + pos, 2);
        pos += 2;
        payload_length_ = ntohs(length);
    }
    else if(payload_length_ == 127)
    {
        uint32_t length = 0;
        memcpy(&length, msg + pos, 4);
        pos += 4;
        payload_length_ = ntohl(length);
    }
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      针对websocket协议做的处理，我们不用管
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
int Websocket_Request::fetch_payload(char *msg, int &pos)
{
    memset(payload_, 0, sizeof(payload_));
    if(mask_ != 1)
    {
        memcpy(payload_, msg + pos, payload_length_);
    }
    else
    {
        for(int i = 0; i < payload_length_; i++)
        {
            int j = i % 4;
            payload_[i] = msg[pos + i] ^ masking_key_[j];
        }
    }
    pos += payload_length_;
    return 0;
}
/***************************************************************
 * @file       websocket_request.cpp
 * @brief      一些打印信息
 * @author     酸菜。
 * @version    v1
 * @date       2021/9/2
 **************************************************************/
void Websocket_Request::print()
{
    DEBUG_LOG("WEBSOCKET PROTOCOL\n"
        "FIN: %d\n"
        "OPCODE: %d\n"
        "MASK: %d\n"
        "PAYLOADLEN: %d\n"
        "PAYLOAD: %s",
        fin_, opcode_, mask_, payload_length_, payload_);
    reset();
}

//

#ifndef __WEBSOCKET_REQUEST__
#define __WEBSOCKET_REQUEST__

#include <stdint.h>
#include "debug_log.h"
#include <DL_AES.h>
class Websocket_Request 
{
public:
    Websocket_Request() {};
    Websocket_Request(int fd);
    ~Websocket_Request() {};
    int fetch_websocket_info(char *msg);
    void runconfigdata(char* str, int len, int socket);
    void rungamedata(char* str, int len, int socket);
    void print();
    void reset();
    int websockettoh5(char *content, int length,int fd);
private:
    int fetch_fin(char *msg, int &pos);
    int fetch_opcode(char *msg, int &pos);
    int fetch_mask(char *msg, int &pos);
    int fetch_masking_key(char *msg, int &pos);
    int fetch_payload_length(char *msg, int &pos);
    int fetch_payload(char *msg, int &pos);
private:
    DL_AES               _M_h5aes;
    uint8_t fin_;
    uint8_t opcode_;
    uint8_t mask_;
    uint8_t masking_key_[4];
    uint64_t payload_length_;
    char payload_[2048];
    int fd_;
};

#endif

//以下这个类的话，主要用来回复客户端。

#include "websocket_respond.h"
#include "websocket_handler.h"
#include <json/json.h>
/*给客户端发送数据也需要进行加密处理*/
void Websocket_Respond::respondClient(int sockClient, int state, int type, int info, bool finalFragment)
{
    Json::Value  _M_reply;
    _M_reply["state"] = state;
    _M_reply["gcode"] = type;
    if (info == 1)
    {
        _M_reply["type"] = "configData";
    }
    else if(info == 2)
    {
        _M_reply["type"] = "gameData";
    }
    Json::FastWriter fast;
    std::string str = fast.write(_M_reply);
    /*加密*/
    DL_AES dlaes;
    dlaes.setkey((const char*)"DlClientPost2019");
    unsigned char* _ect;
    char* _base64;
    int len = dlaes.encrypt((unsigned char*)str.c_str(), str.length(),&_ect);
    int length = dlaes.base64_encode(_ect, len, &_base64);
    /*加上websocket头*/
    int realDateLength = 0;
    if(length < 126)
    {
        realDateLength = length + 2;
    }
    else if(length < 65536) 
    {
        realDateLength = length + 4;
    }
    else
    {
        realDateLength = length + 10;
    }
    unsigned char* buf = (unsigned char*)malloc(realDateLength);;
    char* charbuf = (char*)malloc(realDateLength);
    int first = 0x00;
    int tmp = 0;
    if(finalFragment) 
    {
        //数据一次性发送完毕
        first = first + 0x80;
        first = first + 0x1;
    }
    buf[0] = first;
    tmp = 1;
    unsigned int nuNum = (unsigned)length;
    if(length < 126) 
    {
        buf[1] = length;
        tmp = 2;
    }
    else if (length < 65536)
    {
        buf[1] = 126;
        buf[2] = nuNum >> 8;
        buf[3] = length & 0xFF;
        tmp = 4;
    }
    else
    {
        //数据长度超过65536
        buf[1] = 127;
        buf[2] = 0;
        buf[3] = 0;
        buf[4] = 0;
        buf[5] = 0;
        buf[6] = nuNum >> 24;
        buf[7] = nuNum >> 16;
        buf[8] = nuNum >> 8;
        buf[9] = nuNum & 0xFF;
        tmp = 10;
    }
    for(int i = 0; i < length; i++)
    {
        buf[tmp + i] = _base64[i];
    }
    memcpy(charbuf, buf, realDateLength);
    /*最后发送数据*/
    send(sockClient, charbuf, realDateLength, 0);
}

//

#ifndef __WEBSOCKET_RESPOND__
#define __WEBSOCKET_RESPOND__
class Websocket_Respond 
{
public:
    Websocket_Respond() {};
    ~Websocket_Respond() {};
public:
    void respondClient(int sockClient, int state, int type, int info, bool finalFragment);
};
#endif