cn-lab5-server-except

#include "stdafx.h"
#include <chrono>
#include <exception>
#include <iostream>
#include <map>
#include <regex>
#include <string>
#include <thread>
#include <vector>
#include <winsock2.h>

#pragma comment(lib, "ws2_32.lib")

using namespace std;
using namespace std::chrono;

typedef long long ll;
typedef unsigned long long ull;
typedef time_point<system_clock, milliseconds> timepoint;

vector<thread> connected_clients_list;

timepoint str_to_tp(const string _tp) {
    milliseconds tp_m(stoull(_tp));
    timepoint tp(tp_m);
    return tp;
}

class wsa_exception : public exception {
private:
    static map<const string, const string> description_list;
    const int error_code;
    const string error_message;
public:
    wsa_exception(string s)
        : error_code(WSAGetLastError()), error_message(s) {};
    int code() const {
        return error_code;
    }
    string message() const {
        return error_message;
    }
    virtual const char * what() const override {
        try {
            return description_list.at(error_message).c_str() + ' ' + error_code;
        }
        catch (out_of_range) {
            return "unkwown WSA error" + ' ' + error_code;
        }
    }
};

map<const string, const string> wsa_exception::description_list = {
    { "&wsa_error_accept", "accept error " },
    { "&wsa_error_recv", "recv error " } };

class Message {
private:
    timepoint tp;
    string dest_num;
    string text;
    bool deletable;
public:
    Message(const timepoint &_tp, const string &_dest_num, const string &_text, const bool &_deletable)
        : tp(_tp), dest_num(_dest_num), text(_text), deletable(_deletable) {};
    string get_dest_number() const {
        return dest_num;
    }
    bool is_deletable() const {
        return deletable;
    }
    timepoint get_tp() const {
        return tp;
    }
};

class MessageList {
private:
    vector<Message> messages;
public:
    void add(const string &_tp, const string &_dest_number, const string &_text, const bool &_deletable = false) {
        timepoint tp = str_to_tp(_tp);
        messages.emplace_back(tp, _dest_number, _text, _deletable);
    }
    void remove(const string &_timepoint, const string &_dest_number) {
        for (auto i = messages.rbegin(); i != messages.rend(); i++)
            if (i->get_dest_number() == _dest_number) {
                if (i->is_deletable() == true) {
                    timepoint tp = str_to_tp(_timepoint);
                    milliseconds period(60000);
                    if (duration_cast<milliseconds>(tp - i->get_tp()) <= period) {
                        messages.erase(next(i).base());
                        return;
                    }
                    throw exception("&del_fail_too_late");
                }
                throw exception("&del_fail_not_deletable");
            }
        throw exception("&del_fail_no_such_addressee");
    }
};

map<const string, MessageList> client_message_list;

class Network {
private:
    SOCKET main_sock;
    map<string, pair<sockaddr_in, SOCKET>> client_list;
    string receive(const SOCKET sock) const {
        char recv_buff[65536];
        int len = recv(sock, &recv_buff[0], sizeof(recv_buff) - 1, 0);
        if (len == -1)
            throw wsa_exception("&wsa_error_recv");
        recv_buff[len] = 0;
        string s = recv_buff;
        return s;
    }
public:
    Network() {
        WSAData wsadata;
        WSAStartup(0x0202, &wsadata);
        cout << "WinSock2 initialized" << endl;
    }
    ~Network() {
        WSACleanup();
    }
    void start(const int &port) {
        main_sock = socket(AF_INET, SOCK_STREAM, 0);
        cout << "Main socket created successfully" << endl;
        sockaddr_in addr_local;
        addr_local.sin_family = AF_INET;
        addr_local.sin_addr.S_un.S_addr = 0;
        addr_local.sin_port = htons(port);
        ::bind(main_sock, (sockaddr *)&addr_local, sizeof(addr_local));
        cout << "Port " << ntohs(addr_local.sin_port) << " bound successful" << endl;
        listen(main_sock, SOMAXCONN);
        cout << "Listening port 5005" << endl;
    }
    void stop() {
        for (auto pair : client_list) {
            send(pair.first, "&server_stop");
            closesocket(pair.second.second);
        }
        closesocket(main_sock);
    }
    void send(const string &num, const string &s) const {
        ::send(client_list.at(num).second, s.c_str(), s.length(), 0);
    }
    string receive(const string &num) const {
        char recv_buff[65536];
        int len = recv(client_list.at(num).second, &recv_buff[0], sizeof(recv_buff) - 1, 0);
        if (len == -1)
            throw wsa_exception("&wsa_error_recv");
        recv_buff[len] = 0;
        string s = recv_buff;
        return s;
    }
    string accept() {
        sockaddr_in client_addr;
        int client_addr_size = sizeof(client_addr);
        SOCKET client_sock = ::accept(main_sock, (sockaddr *)&client_addr, &client_addr_size);
        if (client_sock == INVALID_SOCKET)
            throw wsa_exception("&wsa_error_accept");
        string num;
        try {
            num = receive(client_sock);
        }
        catch (...) {
            rethrow_exception;
        }
        cout << num << " connected" << endl;
        client_list.try_emplace(num, make_pair(client_addr, client_sock));
        return num;
    }
}network;

class Commands {
private:
    map<string, void(Commands::*)(const smatch &, const string &) const> command_list;
    void sms(const smatch &input, const string &num) const {
        if (input.str(3) == "-d") {
            client_message_list.at(num).add(input.str(1), input.str(4), input.str(5), true);
            cout << "Message from " << num << " to " << input.str(4) << " send success" << endl;
        }
        else {
            client_message_list.at(num).add(input.str(1), input.str(3), input.str(4));
            cout << "Message from " << num << " to " << input.str(3) << " send success" << endl;
        }
        network.send(num, "&sms_success");
    }
    void del(const smatch &input, const string &num) const {
        try {
            client_message_list.at(num).remove(input.str(1), input.str(3));
        }
        catch (exception e) {
            cout << "Message from " << num << " to " << input.str(3) << " delete failed: " << e.what() << endl;
            network.send(num, e.what());
            return;
        }
        cout << "Message from " << num << " to " << input.str(3) << " delete success" << endl;
        network.send(num, "&del_success");
    }
public:
    Commands() {
        command_list.emplace("sms", &Commands::sms);
        command_list.emplace("del", &Commands::del);
    }
    void exec(const smatch &input, const string &num) const {
        (this->*command_list.at(input.str(2)))(input, num);
    }
}commands;

void client_process(const string &num) {
    client_message_list.try_emplace(num);
    while (true) {
        string s;
        try {
            s = network.receive(num);
        }
        catch (wsa_exception e) {
            auto error = WSAGetLastError();
            if (error == 0)
                break;
            if (error != 10004 && error != 10053)
                cout << e.what() << error << endl;
            return;
        }
        regex pattern(R"(^(\d+)\s(".+"|[.\S]+)\s*(".*"|[.\S]*)\s*(".*"|[.\S]*)\s*(".*"|[.\S]*)\s*$)");
        smatch match_results;
        regex_match(s, match_results, pattern);
        commands.exec(match_results, num);
    }
    cout << num << " disconnected" << endl;
}

void port_listen() {
    while (true) {
        string num;
        try {
            num = network.accept();
        }
        catch (wsa_exception e) {
            if (e.code() != 0 && e.code() != 10004 && e.code() != 10053)
                cout << e.what() << endl;
            return;
        }
        catch (exception e) {
            cout << e.what() << endl;
            return;
        }
        catch (...) {
            cout << "exception was thrown" << endl;
            return;
        }
        connected_clients_list.emplace_back(client_process, num);
    }
}

int main()
{
    cout << "cn-lab5 var10 server was started" << endl;
    network.start(5005);
    thread listen(port_listen);
    string s;
    do {
        cin >> s;
    } while (s != "stop" && s != "exit");

    network.stop();
    if (listen.joinable())
        listen.join();
    for (auto i = 0; i < connected_clients_list.size(); i++)
        if (connected_clients_list.at(i).joinable())
            connected_clients_list.at(i).join();
    cout << "cn-lab5 var10 server was stopped" << endl;
    return 0;
}