services

services/arena-battle/server.cpp

@@ -0,0 +1,761 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <chrono>
+#include <thread>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+#include <mutex>
+#include <atomic>
+#include <iomanip>
+#include <ctime>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+
+struct Item {
+    int id;
+    std::string name;
+    std::string type;
+    int power;
+    int price;
+};
+
+struct Note {
+    int id;
+    char title[64];
+    char content[256];
+    std::chrono::system_clock::time_point created_at;
+};
+
+struct Fighter {
+    int id;
+    char name[32];
+    std::string fighter_class;
+    int hp;
+    int max_hp;
+    int strength;
+    int agility;
+    int gold;
+    std::vector<int> inventory;
+    std::unordered_map<int, int> equipment;
+    std::vector<Note> notes;
+    std::string auth_token;
+    std::chrono::system_clock::time_point last_activity;
+    bool active;
+};
+
+struct Battle {
+    int id;
+    int fighter1_id;
+    int fighter2_id;
+    int current_turn;
+    bool active;
+    std::vector<std::string> logs;
+    std::chrono::system_clock::time_point created_at;
+};
+
+std::map<int, Fighter> fighters;
+std::map<int, Battle> battles;
+std::map<int, Item> items;
+std::mutex state_mutex;
+
+std::atomic<int> next_fighter_id{1};
+std::atomic<int> next_battle_id{1};
+
+std::unordered_map<int, int> client_fighter;
+std::unordered_map<int, int> fighter_battle;
+
+std::ofstream log_file;
+std::mutex log_mutex;
+
+std::string get_timestamp() {
+    auto now = std::chrono::system_clock::now();
+    auto time = std::chrono::system_clock::to_time_t(now);
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
+    std::stringstream ss;
+    ss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S");
+    ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
+    return ss.str();
+}
+
+void log_event(const std::string& message) {
+    std::lock_guard<std::mutex> lock(log_mutex);
+    if (log_file.is_open()) {
+        log_file << "[" << get_timestamp() << "] " << message << std::endl;
+        log_file.flush();
+    }
+}
+
+#define LOG(msg) log_event(msg)
+
+void init_items() {
+    items[1] = {1, "Rusty Sword", "weapon", 5, 10};
+    items[2] = {2, "Steel Sword", "weapon", 10, 25};
+    items[3] = {3, "Fire Blade", "weapon", 20, 50};
+    items[4] = {4, "Leather Armor", "armor", 3, 15};
+    items[5] = {5, "Chain Mail", "armor", 8, 35};
+    items[6] = {6, "Plate Armor", "armor", 15, 75};
+    items[7] = {7, "Health Potion", "potion", 25, 5};
+    items[8] = {8, "Super Potion", "potion", 50, 12};
+}
+
+std::string trim(const std::string& str) {
+    size_t first = str.find_first_not_of(" \t\r\n");
+    if (first == std::string::npos) return "";
+    size_t last = str.find_last_not_of(" \t\r\n");
+    return str.substr(first, last - first + 1);
+}
+
+std::vector<std::string> split(const std::string& str, char delim) {
+    std::vector<std::string> tokens;
+    std::stringstream ss(str);
+    std::string token;
+    while (std::getline(ss, token, delim)) {
+        tokens.push_back(token);
+    }
+    return tokens;
+}
+
+std::chrono::system_clock::time_point now() {
+    return std::chrono::system_clock::now();
+}
+
+int64_t seconds_since(std::chrono::system_clock::time_point t) {
+    auto diff = now() - t;
+    return std::chrono::duration_cast<std::chrono::seconds>(diff).count();
+}
+
+int create_fighter(const std::string& name, const std::string& fighter_class) {
+    Fighter f;
+    f.id = next_fighter_id++;
+
+    strncpy(f.name, name.c_str(), sizeof(f.name));
+    f.name[sizeof(f.name) - 1] = '\0';
+
+    f.fighter_class = fighter_class;
+    f.hp = 100;
+    f.max_hp = 100;
+    f.strength = 10;
+    f.agility = 10;
+    f.gold = 100;
+    f.last_activity = now();
+    f.active = true;
+
+    f.auth_token = "token_" + std::to_string(f.id) + "_" + std::to_string(rand());
+
+    if (fighter_class == "warrior") {
+        f.strength = 15;
+        f.max_hp = 120;
+        f.hp = 120;
+    } else if (fighter_class == "archer") {
+        f.agility = 20;
+    } else if (fighter_class == "mage") {
+        f.strength = 20;
+        f.max_hp = 80;
+        f.hp = 80;
+    }
+    
+    fighters[f.id] = f;
+    return f.id;
+}
+
+std::string cmd_register(int client_fd, const std::vector<std::string>& args) {
+    if (args.size() < 2) return "ERROR: Usage: REGISTER <name> <class>";
+    
+    std::string name = args[0];
+    std::string fighter_class = args[1];
+    
+    if (fighter_class != "warrior" && fighter_class != "archer" && fighter_class != "mage") {
+        return "ERROR: Invalid class. Choose: warrior, archer, mage";
+    }
+    
+    if (client_fighter.count(client_fd)) {
+        return "ERROR: Already registered";
+    }
+    
+    int fid = create_fighter(name, fighter_class);
+    client_fighter[client_fd] = fid;
+    
+    std::stringstream ss;
+    ss << "OK: Registered fighter " << fid << " (" << name << ", " << fighter_class << ")";
+    ss << " HP:" << fighters[fid].hp << " STR:" << fighters[fid].strength 
+       << " AGI:" << fighters[fid].agility << " Gold:" << fighters[fid].gold;
+    ss << " TOKEN:" << fighters[fid].auth_token;
+    return ss.str();
+}
+
+std::string cmd_fighter(int client_fd, const std::vector<std::string>&) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+
+    Fighter& f = fighters[fid];
+    f.last_activity = now();
+
+    std::stringstream ss;
+    ss << "FIGHTER " << f.id << ": " << f.name << " (" << f.fighter_class << ")";
+    ss << " HP:" << f.hp << "/" << f.max_hp;
+    ss << " STR:" << f.strength << " AGI:" << f.agility;
+    ss << " Gold:" << f.gold;
+    return ss.str();
+}
+
+std::string cmd_buy(int client_fd, const std::vector<std::string>& args) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    if (args.size() < 2) return "ERROR: Usage: BUY <item_id> <quantity>";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    int item_id = std::atoi(args[0].c_str());
+    int quantity = std::atoi(args[1].c_str());
+    
+    if (!items.count(item_id)) return "ERROR: Item not found";
+    if (quantity <= 0) return "ERROR: Invalid quantity";
+    
+    Fighter& f = fighters[fid];
+    Item& item = items[item_id];
+
+    int total_price = item.price * quantity;
+
+    if (total_price < 0) {
+        f.gold += abs(total_price);
+        f.last_activity = now();
+        return "OK: Overflow exploited! Gold:" + std::to_string(f.gold);
+    }
+    
+    if (f.gold < total_price) {
+        return "ERROR: Not enough gold. Need:" + std::to_string(total_price) + 
+               " Have:" + std::to_string(f.gold);
+    }
+    
+    f.gold -= total_price;
+    for (int i = 0; i < quantity; i++) {
+        f.inventory.push_back(item_id);
+    }
+    f.last_activity = now();
+    
+    return "OK: Bought " + std::to_string(quantity) + "x " + item.name + 
+           " for " + std::to_string(total_price) + " gold. Remaining:" + std::to_string(f.gold);
+}
+
+std::string cmd_inventory(int client_fd) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    Fighter& f = fighters[fid];
+    f.last_activity = now();
+    
+    std::stringstream ss;
+    ss << "INVENTORY (Gold:" << f.gold << "): ";
+    
+    if (f.inventory.empty()) {
+        ss << "empty";
+    } else {
+        std::map<int, int> counts;
+        for (int item_id : f.inventory) {
+            counts[item_id]++;
+        }
+        bool first = true;
+        for (auto& p : counts) {
+            if (!first) ss << ", ";
+            if (items.count(p.first)) {
+                ss << items[p.first].name << "x" << p.second;
+            } else {
+                ss << "Unknown(" << p.first << ")x" << p.second;
+            }
+            first = false;
+        }
+    }
+    
+    ss << " | EQUIPPED: ";
+    if (f.equipment.empty()) {
+        ss << "none";
+    } else {
+        bool first = true;
+        for (auto& p : f.equipment) {
+            if (!first) ss << ", ";
+            if (items.count(p.second)) {
+                ss << "slot" << p.first << ":" << items[p.second].name;
+            }
+            first = false;
+        }
+    }
+    
+    return ss.str();
+}
+
+std::string cmd_equip(int client_fd, const std::vector<std::string>& args) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    if (args.size() < 2) return "ERROR: Usage: EQUIP <slot> <item_id>";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    int slot = std::atoi(args[0].c_str());
+    int item_id = std::atoi(args[1].c_str());
+    
+    Fighter& f = fighters[fid];
+
+    auto it = std::find(f.inventory.begin(), f.inventory.end(), item_id);
+    if (it == f.inventory.end()) {
+        return "ERROR: Item not in inventory";
+    }
+
+    f.inventory.erase(it);
+
+    f.equipment[slot] = item_id;
+    f.last_activity = now();
+    
+    if (items.count(item_id)) {
+        Item& item = items[item_id];
+        if (item.type == "weapon") {
+            f.strength += item.power;
+        } else if (item.type == "armor") {
+            f.max_hp += item.power * 2;
+            f.hp += item.power * 2;
+        }
+    }
+    
+    return "OK: Equipped item " + std::to_string(item_id) + " to slot " + std::to_string(slot);
+}
+
+std::string cmd_fight(int client_fd, const std::vector<std::string>& args) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    if (args.size() < 1) return "ERROR: Usage: FIGHT <opponent_id>";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    int opponent_id = std::atoi(args[0].c_str());
+    if (!fighters.count(opponent_id)) return "ERROR: Opponent not found";
+    if (opponent_id == fid) return "ERROR: Cannot fight yourself";
+    
+    Fighter& f = fighters[fid];
+    Fighter& opponent = fighters[opponent_id];
+    
+    if (fighter_battle.count(fid) || fighter_battle.count(opponent_id)) {
+        return "ERROR: Already in battle";
+    }
+    
+    // Create battle
+    Battle b;
+    b.id = next_battle_id++;
+    b.fighter1_id = fid;
+    b.fighter2_id = opponent_id;
+    b.current_turn = 1;
+    b.active = true;
+    b.created_at = now();
+    b.logs.push_back("Battle started: " + std::string(f.name) + " vs " + std::string(opponent.name));
+    
+    battles[b.id] = b;
+    fighter_battle[fid] = b.id;
+    fighter_battle[opponent_id] = b.id;
+    
+    f.last_activity = now();
+    opponent.last_activity = now();
+    
+    return "OK: Battle " + std::to_string(b.id) + " started against " + opponent.name;
+}
+
+std::string cmd_attack(int client_fd, const std::vector<std::string>&) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+
+    if (!fighter_battle.count(fid)) {
+        return "ERROR: Not in battle";
+    }
+    
+    int bid = fighter_battle[fid];
+    if (!battles.count(bid)) return "ERROR: Battle not found";
+    
+    Battle& b = battles[bid];
+    if (!b.active) return "ERROR: Battle already ended";
+    
+    Fighter& attacker = fighters[fid];
+    int defender_id = (b.fighter1_id == fid) ? b.fighter2_id : b.fighter1_id;
+    Fighter& defender = fighters[defender_id];
+    
+    // Calculate damage
+    int damage = attacker.strength + (attacker.agility / 2);
+    
+    // Apply equipment bonuses
+    for (auto& eq : attacker.equipment) {
+        if (items.count(eq.second) && items[eq.second].type == "weapon") {
+            damage += items[eq.second].power;
+        }
+    }
+    
+    // Reduce by armor
+    int armor = 0;
+    for (auto& eq : defender.equipment) {
+        if (items.count(eq.second) && items[eq.second].type == "armor") {
+            armor += items[eq.second].power;
+        }
+    }
+    damage = std::max(1, damage - armor);
+    
+    defender.hp -= damage;
+    b.logs.push_back(std::string(attacker.name) + " attacks " + std::string(defender.name) + " for " + 
+                     std::to_string(damage) + " damage (HP:" + std::to_string(defender.hp) + ")");
+    
+    attacker.last_activity = now();
+    defender.last_activity = now();
+    
+    // Check for death
+    if (defender.hp <= 0) {
+        b.active = false;
+        defender.hp = 0;
+        defender.active = false;
+        
+        // Winner gets gold
+        int reward = defender.gold / 2;
+        attacker.gold += reward;
+        defender.gold = 0;
+        
+        b.logs.push_back(std::string(attacker.name) + " wins! Gets " + std::to_string(reward) + " gold");
+        
+        fighter_battle.erase(fid);
+        fighter_battle.erase(defender_id);
+        
+        return "OK: " + std::string(defender.name) + " defeated! You get " + std::to_string(reward) + " gold";
+    }
+    
+    b.current_turn++;
+    return "OK: Dealt " + std::to_string(damage) + " damage. Enemy HP:" + std::to_string(defender.hp);
+}
+
+std::string cmd_heal(int client_fd) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    Fighter& f = fighters[fid];
+    
+    // Find health potion in inventory
+    auto it = std::find(f.inventory.begin(), f.inventory.end(), 7); // Health Potion id=7
+    if (it == f.inventory.end()) {
+        // Try super potion
+        it = std::find(f.inventory.begin(), f.inventory.end(), 8);
+        if (it != f.inventory.end()) {
+            f.inventory.erase(it);
+            int heal = 50;
+            f.hp = std::min(f.max_hp, f.hp + heal);
+            f.last_activity = now();
+            return "OK: Used Super Potion. HP:" + std::to_string(f.hp);
+        }
+        return "ERROR: No potions in inventory";
+    }
+    
+    f.inventory.erase(it);
+    int heal = 25;
+    f.hp = std::min(f.max_hp, f.hp + heal);
+    f.last_activity = now();
+    
+    return "OK: Used Health Potion. HP:" + std::to_string(f.hp);
+}
+
+std::string cmd_status(int client_fd) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    if (!fighter_battle.count(fid)) {
+        return "STATUS: Not in battle";
+    }
+    
+    int bid = fighter_battle[fid];
+    if (!battles.count(bid)) return "ERROR: Battle not found";
+    
+    Battle& b = battles[bid];
+    Fighter& f = fighters[fid];
+    int opponent_id = (b.fighter1_id == fid) ? b.fighter2_id : b.fighter1_id;
+    Fighter& opponent = fighters[opponent_id];
+    
+    std::stringstream ss;
+    ss << "BATTLE " << b.id << " (Turn " << b.current_turn << "): ";
+    ss << f.name << " HP:" << f.hp << " vs " << opponent.name << " HP:" << opponent.hp;
+    return ss.str();
+}
+
+std::string cmd_logout(int client_fd) {
+    if (client_fighter.count(client_fd)) {
+        client_fighter.erase(client_fd);
+    }
+    return "OK: Logged out";
+}
+
+std::string cmd_note_create(int client_fd, const std::vector<std::string>& args) {
+    if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
+    if (args.size() < 2) return "ERROR: Usage: NOTE_CREATE <title> <content>";
+    
+    int fid = client_fighter[client_fd];
+    if (!fighters.count(fid)) return "ERROR: Fighter not found";
+    
+    Fighter& f = fighters[fid];
+    
+    Note note;
+    note.id = f.notes.size() + 1;
+    strncpy(note.title, args[0].c_str(), sizeof(note.title) - 1);
+    note.title[sizeof(note.title) - 1] = '\0';
+    strncpy(note.content, args[1].c_str(), sizeof(note.content) - 1);
+    note.content[sizeof(note.content) - 1] = '\0';
+    note.created_at = now();
+    
+    f.notes.push_back(note);
+    f.last_activity = now();
+    
+    return "OK: Note created with id " + std::to_string(note.id);
+}
+
+std::string cmd_note_get(const std::vector<std::string>& args) {
+    if (args.size() < 1) return "ERROR: Usage: NOTE_GET <auth_token> [note_id]";
+
+    std::string auth_token = args[0];
+    int note_id = (args.size() > 1) ? std::atoi(args[1].c_str()) : -1;
+
+    Fighter* target_fighter = nullptr;
+    for (auto& fp : fighters) {
+        if (fp.second.auth_token == auth_token) {
+            target_fighter = &fp.second;
+            break;
+        }
+    }
+
+    if (!target_fighter) {
+        return "ERROR: Invalid auth token";
+    }
+
+    if (note_id < 0) {
+        std::stringstream ss;
+        ss << "NOTES: ";
+        for (const auto& note : target_fighter->notes) {
+            ss << note.id << ":" << note.title << " ";
+        }
+        return ss.str();
+    }
+
+    for (const auto& note : target_fighter->notes) {
+        if (note.id == note_id) {
+            return "NOTE " + std::to_string(note.id) + ": " + note.title + " | " + note.content;
+        }
+    }
+
+    return "ERROR: Note not found";
+}
+
+void handle_client(int client_fd) {
+    char buffer[1024];
+
+    struct sockaddr_in client_addr;
+    socklen_t client_len = sizeof(client_addr);
+    getpeername(client_fd, (struct sockaddr*)&client_addr, &client_len);
+    std::string client_str = std::string(inet_ntoa(client_addr.sin_addr)) + ":" + 
+                             std::to_string(ntohs(client_addr.sin_port));
+
+    while (true) {
+        memset(buffer, 0, sizeof(buffer));
+        int bytes_read = read(client_fd, buffer, sizeof(buffer) - 1);
+
+        if (bytes_read <= 0) {
+            break;
+        }
+
+        std::string line(buffer);
+        line = trim(line);
+
+        if (line.empty()) continue;
+
+        std::vector<std::string> parts = split(line, ' ');
+        if (parts.empty()) continue;
+
+        std::string cmd = parts[0];
+        std::vector<std::string> args(parts.begin() + 1, parts.end());
+
+        LOG(client_str + " " + line);
+
+        std::string response;
+
+        if (cmd == "REGISTER") {
+            response = cmd_register(client_fd, args);
+        } else if (cmd == "FIGHTER") {
+            response = cmd_fighter(client_fd, args);
+        } else if (cmd == "BUY") {
+            response = cmd_buy(client_fd, args);
+        } else if (cmd == "INVENTORY") {
+            response = cmd_inventory(client_fd);
+        } else if (cmd == "EQUIP") {
+            response = cmd_equip(client_fd, args);
+        } else if (cmd == "FIGHT") {
+            response = cmd_fight(client_fd, args);
+        } else if (cmd == "ATTACK") {
+            response = cmd_attack(client_fd, args);
+        } else if (cmd == "HEAL") {
+            response = cmd_heal(client_fd);
+        } else if (cmd == "STATUS") {
+            response = cmd_status(client_fd);
+        } else if (cmd == "NOTE_CREATE") {
+            response = cmd_note_create(client_fd, args);
+        } else if (cmd == "NOTE_GET") {
+            response = cmd_note_get(args);
+        } else if (cmd == "LOGOUT") {
+            response = cmd_logout(client_fd);
+        } else if (cmd == "QUIT" || cmd == "EXIT") {
+            response = "BYE";
+            write(client_fd, response.c_str(), response.length());
+            break;
+        } else {
+            response = "ERROR: Unknown command: " + cmd;
+        }
+
+        response += "\n";
+        write(client_fd, response.c_str(), response.length());
+    }
+    
+    // Cleanup
+    if (client_fighter.count(client_fd)) {
+        int fid = client_fighter[client_fd];
+        if (fighter_battle.count(fid)) {
+            int bid = fighter_battle[fid];
+            if (battles.count(bid)) {
+                battles[bid].active = false;
+            }
+            fighter_battle.erase(fid);
+        }
+        client_fighter.erase(client_fd);
+    }
+    
+    close(client_fd);
+}
+
+void cleanup_thread() {
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::minutes(5));
+
+        std::lock_guard<std::mutex> lock(state_mutex);
+
+        auto it = fighters.begin();
+        while (it != fighters.end()) {
+            int64_t inactive_seconds = seconds_since(it->second.last_activity);
+            if (inactive_seconds > 3600) {
+                int fid = it->first;
+
+                if (fighter_battle.count(fid)) {
+                    int bid = fighter_battle[fid];
+                    if (battles.count(bid)) {
+                        battles[bid].active = false;
+                    }
+                    fighter_battle.erase(fid);
+                }
+
+                for (auto cf = client_fighter.begin(); cf != client_fighter.end(); ) {
+                    if (cf->second == fid) {
+                        close(cf->first);
+                        cf = client_fighter.erase(cf);
+                    } else {
+                        ++cf;
+                    }
+                }
+
+                it = fighters.erase(it);
+                LOG("Cleanup: removed fighter " + std::to_string(fid));
+            } else {
+                ++it;
+            }
+        }
+
+        for (auto& bp : battles) {
+            if (!bp.second.active) {
+                int64_t age = seconds_since(bp.second.created_at);
+                if (age > 3600) {
+                    fighter_battle.erase(bp.second.fighter1_id);
+                    fighter_battle.erase(bp.second.fighter2_id);
+                }
+            }
+        }
+    }
+}
+
+int main(int argc, char* argv[]) {
+    int port = 31337;
+    if (argc > 1) {
+        port = std::atoi(argv[1]);
+    }
+
+    init_items();
+
+    signal(SIGPIPE, SIG_IGN);
+
+    log_file.open("logs/server.log", std::ios::app);
+    if (!log_file.is_open()) {
+        log_file.open("/var/log/arena-battle/server.log", std::ios::app);
+    }
+    if (!log_file.is_open()) {
+        log_file.open("server.log", std::ios::app);
+    }
+    LOG("Server started on port " + std::to_string(port));
+
+    std::thread cleanup(cleanup_thread);
+    cleanup.detach();
+
+    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd < 0) {
+        return 1;
+    }
+
+    int opt = 1;
+    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+    struct sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = INADDR_ANY;
+    addr.sin_port = htons(port);
+
+    if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        return 1;
+    }
+
+    if (listen(server_fd, 10) < 0) {
+        return 1;
+    }
+
+    LOG("Listening on port " + std::to_string(port));
+
+    while (true) {
+        struct sockaddr_in client_addr;
+        socklen_t client_len = sizeof(client_addr);
+
+        int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
+        if (client_fd < 0) {
+            continue;
+        }
+
+        std::string client_str = std::string(inet_ntoa(client_addr.sin_addr)) + ":" +
+                                 std::to_string(ntohs(client_addr.sin_port));
+        LOG("Connect " + client_str);
+
+        std::thread client_thread(handle_client, client_fd);
+        client_thread.detach();
+    }
+    
+    close(server_fd);
+    return 0;
+}