TCPServer.cpp

#include <bits/stdc++.h>
#include <unistd.h>
#include <cstring>      // Needed for memset
#include <sys/socket.h> // Needed for the socket functions
#include <netdb.h>      // Needed for the socket functions
#include <netinet/in.h> // Needed for internet addresses
#include "Server.hpp"

using namespace std;

map<string, vector<Question>> topic_questions;
map<string, int> active_users; // <userd id , active count>

class ServerSocket {
    private:
    int socket_fd, port;
    struct sockaddr_in server_address, client_address;
    socklen_t client_address_length;
    map<int, ClientBuffers> client_buffers; // <client_socket_id , buffers>
    int buffer_size;

    public:
    ServerSocket(int port, int buffer_size){
        this->port = port;
        this->buffer_size = buffer_size;
        bzero(&server_address, sizeof(server_address));

        server_address.sin_family = AF_INET;
        server_address.sin_addr.s_addr = htonl(INADDR_ANY);
        server_address.sin_port = htons(port);

        socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    }

    int _listen(int max_connections){
        int bind_result = bind(socket_fd,
                                (struct sockaddr *)&server_address,
                                sizeof(server_address));
        int listen_result = listen(socket_fd, max_connections);
        if (bind_result || listen_result) return -1;
        return listen_result;
    }
    int _accept() {
        client_address_length = sizeof(client_address_length);
        int client_socket_fd = accept(socket_fd, (struct sockaddr *)&client_address,
                                        &client_address_length);
        if (client_socket_fd == -1) return -1;
        setup_client(client_socket_fd);
        return client_socket_fd;
    }
    void setup_client(int client_socket_fd) {
        client_buffers[client_socket_fd] = ClientBuffers(buffer_size);
    }
    void remove_client(int client_socket_fd) {
        client_buffers[client_socket_fd]._free();
        client_buffers.erase(client_socket_fd);
    }

    string get_message(int client_socket_fd) {
        char *header = client_buffers[client_socket_fd].read_header;
        char *read_buffer = client_buffers[client_socket_fd].read_buffer;
        memset(header, 0, sizeof(header));
        int read_result = -1;
        read_result = read(client_socket_fd, header, 16);
        cout << read_result << endl;
        if (read_result > 0){
            int read_size = stoi(string(header));
            cout << read_size << endl;
            memset(read_buffer, 0, sizeof(read_buffer));
            read_result = read(client_socket_fd, read_buffer,read_size);
            if (read_result > 0) return string(read_buffer).substr(0,read_size);
        }
        cerr << "Unable to recieve message from client socket " << client_socket_fd << endl;
        return "";
    }
    int _send(int client_socket_fd, string message) {
        char *header = client_buffers[client_socket_fd].write_header;
        char *write_buffer = client_buffers[client_socket_fd].write_buffer;

        memset(header, 0, sizeof(header));
        string write_size = to_string(message.length());
        copy(write_size.begin(), write_size.end(), header);
        int write_result = write(client_socket_fd, header, 16); // sending size of message

        if (write_result > 0) {
            write_result = write(client_socket_fd, message.c_str(), message.length());
        }
        if (write_result <= 0)
            cerr << "Unable to send to client socket fd : " << client_socket_fd << endl;
        return write_result;
    }

    void _close() {
        for (auto i : client_buffers) i.second._free();
        close(socket_fd);
    }

    ~ServerSocket(){
        _close();
    }
};

void ask_questions(ServerSocket server_socket, int client_socket_fd) {
    string header = server_socket.get_message(client_socket_fd);
    cout << "client header"<<header << endl;
    vector<string> splits = split_str(header, '|');
    string user_id = splits[0];
    string request_type = splits[1];
    if (request_type == "get_ques") {
        int score = 0;
        string mode = splits[2];
        if (mode == "A") {
            string topic = splits[3];
            for (Question i : topic_questions[topic]) {
                server_socket._send(client_socket_fd,i.serialize());
                string ans = server_socket.get_message(client_socket_fd);
                bool correct = (ans[0]-'A' == ANSWER[i.get_id()].first);
                if (correct) score++;
                server_socket._send(client_socket_fd,serialize_answer(ANSWER[i.get_id()]));
            }
            server_socket._send(client_socket_fd, "stream-end");
        }
    }
}

string serialize_active_users() {
    string s = "";
    for (auto i : active_users) s += i.first + "-";
    return s;
}

int main()
{
    topic_questions["T"] = read_questions("Questions/threads.txt");
    ServerSocket server_socket = ServerSocket(PORT, BUFFER_SIZE);
    int available = server_socket._listen(5);
    if (available == -1) {
        cerr << "Unable to listen to the port" << endl;
        return 1;
    }
    cout << "Listening at port: " << PORT << endl;

    while (1) {
        int client_socket_fd = server_socket._accept();
        if (client_socket_fd == -1) continue;
        cout << "Connected to client socket fd : " << client_socket_fd << endl;
        string user_id = split_str(server_socket.get_message(client_socket_fd), '|')[0];
        cout << "User id " << user_id << '\n';
        if (active_users.count(user_id)) active_users[user_id]++;
        else active_users[user_id] = 1;
        ask_questions(server_socket, client_socket_fd);
        active_users[user_id]--;
        server_socket.remove_client(client_socket_fd);
    }
    server_socket._close();
}