问C++ TcpServer类

EN

#ifndef PACKET
#define PACKET
#define MAX_NAME_LEN 24
#include <stdio.h>
struct Packet
{
    Packet();
    ~Packet();
    char name[MAX_NAME_LEN];
    char buf[BUFSIZ];
};
#endif

#include "packet.hpp"
Packet::Packet() {};
Packet::~Packet() {};

#ifndef TCP_SERVER
#define TCP_SERVER
#include <netinet/in.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
struct server_info
{
    char ip_str[INET_ADDRSTRLEN] = {'\0'};
    int port;
};

class Tcp_Server
{
public:
    Tcp_Server(int port);               // Initializer
    ~Tcp_Server();                      // Destructor
    /***
     * select(), blocking method
     * Return 0 if it's a listening socket.
     * Return 1 if it's a usual socket.
     */
    int WaitingForActions();        
    int NewConnectionHandler();         // If new client. Return socket number.
    virtual int NewMessageHandler() = 0;// This method shouldn't be implement, look at the inheritance classes.
    struct server_info GetServerInfo(); // Fill and return server_info structure.
    int GetCurrentFds();
protected:
    int listen_socket;                  // Listening socket
    struct sockaddr_in serv_addr;       // Structure with information about socket (adress, port etc.)
    struct server_info server_info;     // Information about server in readable form, returned by function.
    fd_set connections;                 // Set of clients
    int max_socket;                     // Number of maximum existing descriptor
    int current_socket;                 // Number of the processed descriptor
};
#endif

#include "tcp_server.hpp"
Tcp_Server::Tcp_Server(int port)
{
    int param = 1;      // Parametr for setsockopt(), maybe we can change it to bool.
    char ip_str[INET_ADDRSTRLEN] = {'\0'};

    if((listen_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        throw "Can't create a socket!\n";
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(port);
    
    if(setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, ¶m, sizeof(param)) < 0)
    {
        throw "setsockopt() error!\n";
    }
    
    if(bind(listen_socket, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
    {
        throw "bind() error!\n";
    }

    listen(listen_socket, 5);

    FD_ZERO(&connections);
    FD_SET(listen_socket, &connections);
    max_socket = listen_socket;
}

Tcp_Server::~Tcp_Server()
{
    for(int i = 0; i <= max_socket; i++)
    {
        if(i == listen_socket)
        {
            shutdown(i, SHUT_RDWR);
            close(i);
            FD_CLR(i, &connections);
        }
        if(FD_ISSET(i, &connections))
        {
            shutdown(i, SHUT_RDWR);
            close(i);
            FD_CLR(i, &connections);
        }
    }
}

int Tcp_Server::WaitingForActions()
{
    fd_set tmp_set = connections;

    if(select(max_socket + 1, &tmp_set, NULL, NULL, NULL) < 0)
    {
        throw "error in select \n";  
        fprintf(stderr, "error in select \n");
    }

    for(int i = 0; i <= max_socket; i++)
    {
        if(FD_ISSET(i, &tmp_set))
        {
            current_socket = i;
            if(i == listen_socket)  // Если запрос к слушающему сокету
            {
               return 0;
            }
            else
            {
                return 1;
            }
        }
    }
    return -1;
};

int Tcp_Server::NewConnectionHandler()
{
    int new_sock = accept(listen_socket, NULL, NULL);
    if(new_sock < 0)
    {
        throw "accept() error\n";
    }
    else
    {
        FD_SET(new_sock, &connections);
        if(new_sock > max_socket)
        {
            max_socket = new_sock;
        }
    }
    return new_sock;
}

struct server_info Tcp_Server::GetServerInfo()
{
    memset(&server_info, 0, sizeof(server_info));
    inet_ntop(AF_INET, &(serv_addr.sin_addr), server_info.ip_str, INET_ADDRSTRLEN);
    server_info.port = ntohs(serv_addr.sin_port);
    return server_info;
}

int Tcp_Server::GetCurrentFds()
{
    return current_socket;
}

#ifndef TCP_CHAT_SERVER
#define TCP_CHAT_SERVER
#include "tcp_server.hpp"
#include "packet.hpp"
class Tcp_Chat_Server : public Tcp_Server
{
public:
    Tcp_Chat_Server(int port);
    virtual int NewMessageHandler();
};
#endif

#include "tcp_chat_server.hpp"
Tcp_Chat_Server::Tcp_Chat_Server(int port) : Tcp_Server(port) {};

int Tcp_Chat_Server::NewMessageHandler()
{
    Packet packet;
    int bytes = recv(current_socket, &packet, sizeof(packet), 0);
    if(bytes <= 0)
    {
        close(current_socket);
        FD_CLR(current_socket, &connections);
        return bytes;
    }
    else
    {
        for(int i = 0; i <= max_socket; i++)
        {
            if(i == current_socket || i == listen_socket)
            {
                continue;
            }
            if(FD_ISSET(i, &connections))
            {
                if((send(i, &packet, sizeof(packet), 0)) <= 0)
                {
                    return -1;
                }
            }
        }
        fprintf(stdout, "%s : %s", packet.name, packet.buf);
        memset(&packet, '\0', sizeof(packet));
    }
    return bytes;
}