Change structure of code base

include/client.hpp

@@ -6,16 +6,15 @@
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <unistd.h>
-
+#include <netdb.h>
-const int PORT = 8080;
-
 class Client{
 private:
     int sock;
 public:
-    Client() : sock(0){};
+    Client();
-    void run();
+    void run(const std::string& h = "localhost", const unsigned short p = 1024u);
     int ping(struct sockaddr_in);
+    void game();
 };
 
 #endif

include/maze.hpp

@@ -30,9 +30,5 @@ class Maze{
         bool is_wall(int, int) const;
 
         void set_moves_left(int);
-        
-		//void generate_maze();
-		//void print_maze_info();
-        //void play_game();
 };
 #endif

include/server.hpp

@@ -7,19 +7,20 @@
 #include <thread>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <netdb.h>
 #include <unistd.h>
 #include <cstring>
 
-const int PORT = 8080;
+const int MAX_CLIENTS = 512;
-const int MAX_CLIENTS = 100;
 
 class Server {
 private:
     bool service_mode;
+    int server_fd;
     void handle_client(int client_socket, bool _mode); // Принимает клиентский сокет
     bool check_status(Maze& maze);
 public:
-    Server() : service_mode(false){};
+    Server(const std::string& h = "localhost", const unsigned short p = 1024u, bool service_mode = false);
     void start(); // Запуск сервера
 };
 

src/client/client.cpp

@@ -11,41 +11,49 @@ void print_instructions() {
 }
 
 int Client::ping(struct sockaddr_in address){
-    return connect(sock, (struct sockaddr*)&address, sizeof(address)) > 0;
+    return connect(sock, (struct sockaddr*)&address, sizeof(address)) != 0;
 }
 
-void Client::run() {
+Client::Client(){
-    struct sockaddr_in serv_addr;
-
     // Создание сокета
     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
         throw std::runtime_error("[Client::request] connect(2) call error");
     }
+}
+
+void Client::run(const std::string& h, const unsigned short p) {
+    struct sockaddr_in serv_addr;
 
     serv_addr.sin_family = AF_INET;
-    serv_addr.sin_port = htons(PORT);
 
-    // Преобразование IP-адреса из текстового вида в бинарный
+    hostent* host_name;
-    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
+    host_name = gethostbyname(h.c_str()); // Преобразование названия хоста в IP-адрес.
-        throw std::runtime_error("[Client::request] connect(2) call error");
+    if (host_name == nullptr) {
+        throw std::runtime_error("Error in gethostbyname");
     }
+    
+    serv_addr.sin_port = htons(p);
+    memcpy(&serv_addr.sin_addr.s_addr, host_name->h_addr, host_name->h_length);
 
     // Подключение к серверу
     if (ping(serv_addr)) {
-        throw std::runtime_error("Connection lost!");
+        throw std::runtime_error("Invalid hostname:port");
     }
 
     std::cout << "Подключено к серверу. Введите ваше имя: ";
     std::string player_name;
     std::getline(std::cin, player_name);
 
-    if (ping(serv_addr)) {
+    if (!ping(serv_addr)) {
         throw std::runtime_error("Connection lost!");
     }
+
     // Отправка имени игрока на сервер
     send(sock, player_name.c_str(), player_name.size(), 0);
-    std::cout << "Игра началась!\n";
+}
 
+void Client::game(){
+    std::cout << "Игра началась!\n";
     print_instructions();
 
     char buffer[1024] = {0};
@@ -74,6 +82,5 @@ void Client::run() {
             break;
         }
     }
-
     close(sock);
 }

src/client/client_main.cpp

@@ -1,9 +1,27 @@
 #include "client.hpp"
 
-int main(){
+int main(int argc,  char** argv){
+    int opt;
+    std::string host = "localhost";
+    short unsigned port = 1024u;
+
+    while ((opt = getopt(argc, argv, "h:p:")) != -1) {
+        switch (opt) {
+            case 'h':
+                host = optarg;
+                break;
+            case 'p':
+                port = static_cast<unsigned short>(atoi(optarg));
+                break;
+            default:
+                break;
+        }
+    }
+
     try {
         Client client;
-        client.run();
+        client.run(host, port);
+        client.game();
     } catch (const std::runtime_error& e){
         std::cerr << "Client application error: " << e.what() << std::endl;
         return 1;

src/server/server.cpp

@@ -1,5 +1,28 @@
 #include "server.hpp"
 
+Server::Server(const std::string& h, const unsigned short p, bool service_mode){
+    // Создание сокета.
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd < 0) {
+        throw std::runtime_error("[MultiprocessEchoServer::MultiprocessEchoServer] socket(2) call error");
+    }
+    // Подготовка сетевого адреса для связывания.
+    sockaddr_in server_address;
+    memset(reinterpret_cast<char*>(&server_address), '\0', sizeof(server_address));
+    server_address.sin_family = AF_INET;
+    hostent* host_name;
+    host_name = gethostbyname(h.c_str()); // Преобразование названия хоста в IP-адрес.
+    if (host_name == nullptr) {
+        throw std::runtime_error("[MultiprocessEchoServer::MultiprocessEchoServer] gethostbyname(3) call error");
+    }
+    server_address.sin_port = htons(p);
+    memcpy(&server_address.sin_addr.s_addr, host_name->h_addr, host_name->h_length);
+    if (bind(server_fd, reinterpret_cast<const sockaddr*>(&server_address), sizeof(server_address)) != 0) {
+        throw std::runtime_error("[MultiprocessEchoServer::MultiprocessEchoServer] bind(2) call error");
+    }
+    std::cout << "Сервер запущен на хосте " << h << " на порту " << p << std::endl;
+}
+
 bool Server::check_status(Maze &maze) {
     return (!maze.test_mode && maze.get_moves_left() > 0);
 }
@@ -15,7 +38,7 @@ void Server::handle_client(int client_socket, bool mode) {
     // Получение имени игрока
     int bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
     if (bytes_received <= 0) {
-        std::cerr << "Ошибка получения имени игрока.\n";
+        std::cout << "Ошибка получения имени игрока.\n";
         close(client_socket);
         return;
     }
@@ -105,41 +128,18 @@ void Server::handle_client(int client_socket, bool mode) {
 }
 
 void Server::start() {
-    int server_fd, new_socket;
+    int new_socket;
-    struct sockaddr_in address;
-    int opt = 1;
-    int addrlen = sizeof(address);
-
-    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
-        perror("Ошибка создания сокета");
-        exit(EXIT_FAILURE);
-    }
-
-    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
-        perror("Ошибка настройки сокета");
-        exit(EXIT_FAILURE);
-    }
-
-    address.sin_family = AF_INET;
-    address.sin_addr.s_addr = INADDR_ANY;
-    address.sin_port = htons(PORT);
-
-    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
-        perror("Ошибка привязки сокета");
-        exit(EXIT_FAILURE);
-    }
 
     if (listen(server_fd, MAX_CLIENTS) < 0) {
-        perror("Ошибка прослушивания");
+        throw std::runtime_error("Error in listen");
-        exit(EXIT_FAILURE);
     }
 
-    std::cout << "Сервер запущен на порту " << PORT << "\n";
+    sockaddr address;
-
+    int addrlen = sizeof(address);
+    socklen_t address_size = sizeof(address);
     while (true) {
-        if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
+        if ((new_socket = accept(server_fd, (struct sockaddr*)&address, &address_size)) < 0) {
-            perror("Ошибка принятия соединения");
+            throw std::runtime_error("Error in accept");
-            exit(EXIT_FAILURE);
         }
 
         std::cout << "Новое соединение установлено.\n";

src/server/server_main.cpp

@@ -1,9 +1,37 @@
 #include "server.hpp"
 
 int main(int argc, char **argv) {
-    
+    int opt;
-    Server server;
+    std::string host = "localhost";
-    server.start();
+    bool service_mode = false;
+    short unsigned port = 1024u;
 
+    while ((opt = getopt(argc, argv, "h:p:s:")) != -1) {
+        switch (opt) {
+            case 'h':
+                host = optarg;
+                break;
+            case 'p':
+                port = static_cast<unsigned short>(atoi(optarg));
+                break;
+            case 's':
+                service_mode = true;
+            default:
+                break;
+        }
+    }
+
+    try {
+        Server server(host, port, service_mode);
+        server.start();
+    } catch (const std::runtime_error& e){
+        std::cerr << "Client application error: " << e.what() << std::endl;
+        return 1;
+    } catch (...){
+        std::cerr << "Unexpected error in client application" << std::endl;
+        return 2;
+    }
+
+    std::cout << "Server application finished" << std::endl;
     return 0;
 }