Merge branch 'dev' into feature/doc

Author: potat-dev

.gitignore

@@ -32,6 +32,6 @@
 *.app
 
 # Debug files
-cmake-build-debug
+cmake-build-*
 .idea
 build

CMakeLists.txt

@@ -47,6 +47,7 @@ add_executable(STIPTest
         tests/testStipSend.cpp
         src/protocol/Connection.cpp
         src/protocol/Session.cpp
+        src/protocol/SessionKiller.cpp
 )
 
 # add sources dir

conan_provider.cmake

@@ -1,6 +1,28 @@
 # This file is managed by Conan, contents will be overwritten.
 # To keep your changes, remove these comment lines, but the plugin won't be able to modify your requirements
 
+# The MIT License (MIT)
+#
+# Copyright (c) 2024 JFrog
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
 set(CONAN_MINIMUM_VERSION 2.0.5)
 
 
@@ -628,4 +650,3 @@ if(NOT _cmake_program)
     get_filename_component(PATH_TO_CMAKE_BIN "${CMAKE_COMMAND}" DIRECTORY)
     set(PATH_TO_CMAKE_BIN "${PATH_TO_CMAKE_BIN}" CACHE INTERNAL "Path where the CMake executable is")
 endif()
-

examples/client.cpp

@@ -26,7 +26,7 @@ int main() {
         STIPClient client(socket);
         client.startListen();
 
-        Connection *connection = client.connect(server_endpoint);
+        Connection *connection = client.connect(server_endpoint, 1000, 3);
         std::cout << "Connection accepted\n\n" << std::endl;
 //        connection->send("Hello, I'm Ilya");
 

src/client/STIPClient.cpp

@@ -4,6 +4,13 @@
 
 
 #include "STIPClient.h"
+#include <future>
+#include <chrono>
+
+#include "protocol/errors/STIP_errors.h"
+#include "protocol/Commands.h"
+
+using namespace std::chrono_literals;
 
 namespace STIP {
 
@@ -24,39 +31,62 @@ namespace STIP {
                 return;
 //            throw boost::system::system_error(error);
             }
-            std::cout << "Получен запрос от " << remote_endpoint.address() << ":" << remote_endpoint.port() << std::endl;
+            std::cout << "Получен запрос от " << remote_endpoint.address() << ":" << remote_endpoint.port()
+                      << std::endl;
 
             connectionManager->accept(remote_endpoint, packet[0]);
         }
     }
 
 
-    Connection *STIPClient::connect(udp::endpoint &targetEndpoint) {
-        // TODO: Add error handling
+    Connection *STIPClient::connect(udp::endpoint &targetEndpoint, std::chrono::milliseconds timeout) {
 
         auto *connection = new Connection(targetEndpoint, socket);
         this->connectionManager->addConnection(targetEndpoint, connection);
-        STIP_PACKET packet[1] = {};
-        packet[0].header.command = 100;
-        packet[0].header.size = sizeof(int);
 
-        this->socket->send_to(boost::asio::buffer(packet, packet[0].header.size), targetEndpoint);
-        bool result = false;
-        STIP_PACKET response = connection->getPacket(result);
 
-        // TODO: Add better error handling
-        if (!result) {
-            throw std::runtime_error("Error while waiting for response");
-        }
-        if (response.header.command == 101) {
-            packet[0].header.command = 102;
-            packet[0].header.size = sizeof(int);
-            this->socket->send_to(boost::asio::buffer(packet, packet[0].header.size), targetEndpoint);
+        STIP_PACKET initPacket[1] = {};
+        initPacket[0].header.command = Command::CONNECTION_SYN;
+        initPacket[0].header.size = sizeof(int);
+
+        this->socket->send_to(boost::asio::buffer(initPacket, initPacket[0].header.size), targetEndpoint);
+        std::future<bool> response_future = std::async(std::launch::async, [connection]() {
+            bool result = false;
+            STIP_PACKET response{};
+            do {
+                response = connection->getPacket(result);
+            } while (result && response.header.command != Command::CONNECTION_SYN_ACK);
+
+            return result;
+        });
+
+        std::future_status status;
+        do {
+            switch (status = response_future.wait_for(timeout); status) {
+                case std::future_status::timeout:
+                    connection->cancelPacketWaiting();
+                    connectionManager->remove(targetEndpoint);
+                    delete connection;
+                    throw STIP::errors::STIPTimeoutException("Timeout while connecting");
+                    break;
+            }
+        } while (status == std::future_status::deferred);
+
+        if (response_future.get()) {
+            initPacket[0].header.command = Command::CONNECTION_ACK;
+            initPacket[0].header.size = sizeof(int);
+            this->socket->send_to(boost::asio::buffer(initPacket, initPacket[0].header.size), targetEndpoint);
             connection->setConnectionStatus(102);
             connection->startProcessing();
             return connection;
         }
-        throw std::runtime_error("Error while connecting");
+    }
+
+    Connection *STIPClient::connect(udp::endpoint &targetEndpoint) {
+        return connect(
+                targetEndpoint,
+                std::chrono::milliseconds(10000)
+        );
     }
 
     void STIPClient::startListen() {

src/client/STIPClient.h

@@ -18,6 +18,8 @@ namespace STIP {
 
         void stopListen();
 
+        Connection *connect(udp::endpoint &targetEndpoint, std::chrono::milliseconds timeout);
+
         Connection *connect(udp::endpoint &targetEndpoint);
 
     private:

src/protocol/Commands.h

@@ -0,0 +1,84 @@
+//
+// Created by Serge on 12.04.2024.
+//
+
+#ifndef RABBIT_COMMANDS_H
+#define RABBIT_COMMANDS_H
+#include <ostream>
+
+namespace STIP {
+    enum class Command : int {
+        MSG_INIT_REQUEST = 0,
+        MSG_INIT_RESPONSE_SUCCESS = 1,
+        MSG_INIT_RESPONSE_FAILURE = 2,
+
+        MSG_SEND_DATA_PART = 3,
+
+        MSG_REQUEST_ALL_RECEIVED = 4,
+        MSG_RESPONSE_ALL_RECEIVED = 5,
+        MSG_RESPONSE_RESEND = 6,
+
+        MSG_KILLED = 7,
+
+
+        PING_ASK = 10,
+        PING_ANSWER = 11,
+
+
+        CONNECTION_SYN = 100,
+        CONNECTION_SYN_ACK = 101,
+        CONNECTION_ACK = 102,
+        CONNECTION_FIN = 103,
+    };
+
+    inline std::ostream& operator<<(std::ostream & os, const Command &command) {
+        switch (command) {
+            case Command::MSG_INIT_REQUEST:
+                os << "MSG_INIT_REQUEST";
+                break;
+            case Command::MSG_INIT_RESPONSE_SUCCESS:
+                os << "MSG_INIT_RESPONSE_SUCCESS";
+                break;
+            case Command::MSG_INIT_RESPONSE_FAILURE:
+                os << "MSG_INIT_RESPONSE_FAILURE";
+                break;
+            case Command::MSG_SEND_DATA_PART:
+                os << "MSG_SEND_DATA_PART";
+                break;
+            case Command::MSG_REQUEST_ALL_RECEIVED:
+                os << "MSG_REQUEST_ALL_RECEIVED";
+                break;
+            case Command::MSG_RESPONSE_ALL_RECEIVED:
+                os << "MSG_RESPONSE_ALL_RECEIVED";
+                break;
+            case Command::MSG_RESPONSE_RESEND:
+                os << "MSG_RESPONSE_RESEND";
+                break;
+            case Command::MSG_KILLED:
+                os << "MSG_KILLED";
+                break;
+            case Command::PING_ASK:
+                os << "PING_ASK";
+                break;
+            case Command::PING_ANSWER:
+                os << "PING_ANSWER";
+                break;
+            case Command::CONNECTION_SYN:
+                os << "CONNECTION_SYN";
+                break;
+            case Command::CONNECTION_SYN_ACK:
+                os << "CONNECTION_SYN_ACK";
+                break;
+            case Command::CONNECTION_ACK:
+                os << "CONNECTION_ACK";
+                break;
+            case Command::CONNECTION_FIN:
+                os << "CONNECTION_FIN";
+                break;
+        }
+        os << " (" << static_cast<int>(command) << ")";
+        return os;
+    }
+}
+
+#endif //RABBIT_COMMANDS_H