Added cmd arg handling to set log level

.forgejo/workflows/pr_check.yaml

@@ -134,6 +134,8 @@ jobs:
             -GNinja -DCMAKE_BUILD_TYPE=Release   \
             -DENABLE_EXAMPLES=ON                 \
             -DENABLE_TESTS=ON                    \
+            -DMAX_LOG_LEVEL=0                    \
+            -DTEST_MAX_LOG_LEVEL=0               \
             -DCMAKE_CXX_FLAGS="-ftemplate-backtrace-limit=0"
           cmake --build ${{ github.workspace }}/build_gcc --parallel `nproc`
 
@@ -142,7 +144,7 @@ jobs:
         continue-on-error: true
         run: |
           cd ${{ github.workspace }}/build_gcc
-          ./larra_xmpp_tests
+          ./larra_xmpp_tests --log_level=0
 
       - name: Clang build (only configuring)
         id: clang_build
@@ -160,6 +162,8 @@ jobs:
             -GNinja -DCMAKE_BUILD_TYPE=Release     \
             -DENABLE_EXAMPLES=ON                   \
             -DENABLE_TESTS=ON                      \
+            -DMAX_LOG_LEVEL=0                      \
+            -DTEST_MAX_LOG_LEVEL=0                 \
             -DCMAKE_CXX_FLAGS="-stdlib=libc++ -I/home/LLVM-${LLVM_VER}/include/c++/v1 -fno-modules"
 
           echo "::group::compile_commands.json content"
@@ -200,4 +204,4 @@ jobs:
       #    export LLVM_VER=19.1.3
       #    export PATH="/home/LLVM-${LLVM_VER}/bin:${PATH}"
       #    cd ${{ github.workspace }}/build_clang
-      #    ASAN_SYMBOLIZER_PATH=llvm-symbolizer ASAN_OPTIONS=detect_stack_use_after_return=1:check_initialization_order=1:detect_leaks=1:atexit=1:abort_on_error=1 ./larra_xmpp_tests
+      #    ASAN_SYMBOLIZER_PATH=llvm-symbolizer ASAN_OPTIONS=detect_stack_use_after_return=1:check_initialization_order=1:detect_leaks=1:atexit=1:abort_on_error=1 ./larra_xmpp_tests --log_level=0

.gitignore

@@ -30,3 +30,8 @@ libxmlplusplus-prefix/
 spdlog.pc
 build*
 temp*
+/.idea/
+
+
+
+

.vscode/launch.json

@@ -9,7 +9,10 @@
             "request": "launch",
             "name": "Debug: connect",
             "program": "${workspaceFolder}/build/examples/output/connect",
-            "args": [],
+            "args": [
+                "--log_level=0"
+                // --gtest_filter=POSTIVE_PATTERNS[-NEGATIVE_PATTERNS]
+            ],
             "cwd": "${workspaceFolder}",
             "preLaunchTask": "GCC: Build"
         },
@@ -19,6 +22,7 @@
             "name": "Debug: tests",
             "program": "${workspaceFolder}/build/larra_xmpp_tests",
             "args": [
+                "--log_level=0"
                 // --gtest_filter=POSTIVE_PATTERNS[-NEGATIVE_PATTERNS]
                 // "--gtest_filter=Roster*"
             ],

.vscode/tasks.json

@@ -79,8 +79,8 @@
             "command": [
                 "cd ${workspaceFolder} &&",
                 "mkdir -p build && cd build &&",
-                "cmake cmake -Wno-dev ",
-                "   -DCMAKE_BUILD_TYPE=Debug -DENABLE_EXAMPLES=ON -DENABLE_TESTS=ON .."
+                "cmake -Wno-dev ",
+                "   -DCMAKE_BUILD_TYPE=Debug -DENABLE_EXAMPLES=ON -DENABLE_TESTS=ON -DMAX_LOG_LEVEL=0 -DTEST_MAX_LOG_LEVEL=0 .."
             ],
             "options": {
                 "env": {
@@ -138,6 +138,7 @@
                 "mkdir -p build_clang && cd build_clang &&",
                 "cmake -Wno-dev ",
                 "   -DCMAKE_BUILD_TYPE=Debug -DENABLE_EXAMPLES=ON -DENABLE_TESTS=ON ",
+                "   -DMAX_LOG_LEVEL=0 -DTEST_MAX_LOG_LEVEL=0",
                 "   -DCMAKE_CXX_FLAGS=\"-stdlib=libstdc++\"",
                 "   -DCMAKE_EXE_LINKER_FLAGS=\"-L/usr/lib/x86_64-linux-gnu -lstdc++\" .."
             ],
@@ -160,6 +161,7 @@
                 "mkdir -p build_clang && cd build_clang &&",
                 "cmake -Wno-dev ",
                 "   -DCMAKE_BUILD_TYPE=Debug -DENABLE_EXAMPLES=ON -DENABLE_TESTS=ON",
+                "   -DMAX_LOG_LEVEL=0 -DTEST_MAX_LOG_LEVEL=0",
                 //
                 // Uncomment for GCC standart library: libstdc++
                 //"   -DCMAKE_CXX_FLAGS=\"-stdlib=libstdc++ -fno-omit-frame-pointer -g -fsanitize=address,undefined,leak,function,nullability,vptr\"",
@@ -191,7 +193,7 @@
             "command": [
                 "cd ${workspaceFolder} &&",
                 "mkdir -p build_clang && cd build_clang &&",
-                "ASAN_SYMBOLIZER_PATH=llvm-symbolizer ASAN_OPTIONS=detect_stack_use_after_return=1:check_initialization_order=1:detect_leaks=1:atexit=1:abort_on_error=1 ./larra_xmpp_tests ; echo \"exit code: $?\"",
+                "ASAN_SYMBOLIZER_PATH=llvm-symbolizer ASAN_OPTIONS=detect_stack_use_after_return=1:check_initialization_order=1:detect_leaks=1:atexit=1:abort_on_error=1 ./larra_xmpp_tests --log_level=0 ; echo \"exit code: $?\"",
             ],
             "presentation": {
                 "clear": true
@@ -211,6 +213,7 @@
                 "mkdir -p build_clang && cd build_clang &&",
                 "cmake -Wno-dev ",
                 "   -DCMAKE_BUILD_TYPE=Debug -DENABLE_EXAMPLES=ON -DENABLE_TESTS=ON ",
+                "   -DMAX_LOG_LEVEL=0 -DTEST_MAX_LOG_LEVEL=0",
                 "   -DCMAKE_CXX_FLAGS=\"-stdlib=libstdc++ -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -fsanitize=memory\"",
                 "   -DCMAKE_EXE_LINKER_FLAGS=\"-L/usr/lib/x86_64-linux-gnu -lstdc++ -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -fsanitize=memory\" ..",
             ],
@@ -236,7 +239,7 @@
             "command": [
                 "cd ${workspaceFolder} &&",
                 "mkdir -p build_clang && cd build_clang &&",
-                "MSAN_SYMBOLIZER_PATH=llvm-symbolizer MSAN_OPTIONS=abort_on_error=1 ./larra_xmpp_tests ; echo \"exit code: $?\"",
+                "MSAN_SYMBOLIZER_PATH=llvm-symbolizer MSAN_OPTIONS=abort_on_error=1 ./larra_xmpp_tests --log_level=0 ; echo \"exit code: $?\"",
             ],
             "presentation": {
                 "clear": true
@@ -270,7 +273,7 @@
             "command": [
                 "cd ${workspaceFolder} &&",
                 "mkdir -p build_clang && cd build_clang &&",
-                "MSAN_SYMBOLIZER_PATH=llvm-symbolizer MSAN_OPTIONS=abort_on_error=1 ./larra_xmpp_tests ; echo \"exit code: $?\"",
+                "MSAN_SYMBOLIZER_PATH=llvm-symbolizer MSAN_OPTIONS=abort_on_error=1 ./larra_xmpp_tests --log_level=0 ; echo \"exit code: $?\"",
             ],
             "presentation": {
                 "clear": true

CMakeLists.txt

@@ -18,10 +18,12 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 set(FMT_MODULE OFF)
 set(UTEMPL_MODULE OFF)
 set(CXX_EXTENSIONS NO)
-set(BOOST_INCLUDE_LIBRARIES "pfr;asio;serialization")
+set(BOOST_INCLUDE_LIBRARIES "pfr;asio;serialization;program_options")
 option(CPM_USE_LOCAL_PACKAGES "Use local packages" ON)
 option(UTEMPL_USE_LOCAL_PACKAGE "Use utempl local package" OFF)
 option(BUILD_EXECUTABLE ON)
+set(MAX_LOG_LEVEL 2 CACHE STRING "Available log levels: 0=TRACE, 1=DEBUG, 2=INFO, 3=WARN, 4=ERROR, 5=CRITICAL, 6=OFF")
+set(TEST_MAX_LOG_LEVEL 2 CACHE STRING "Available log levels: 0=TRACE, 1=DEBUG, 2=INFO, 3=WARN, 4=ERROR, 5=CRITICAL, 6=OFF")
 set(UTEMPL_URL
   "https://sha512sum.xyz/git/sha512sum/utempl"
   CACHE STRING "utempl repository URL")
@@ -175,11 +177,11 @@ target_include_directories(larra_xmpp PUBLIC
 
 if(TARGET Boost::pfr)
   target_link_libraries(larra_xmpp PUBLIC
-    Boost::asio Boost::serialization utempl::utempl
+    Boost::asio Boost::serialization Boost::program_options utempl::utempl
     OpenSSL::SSL nameof::nameof fmt::fmt
     OpenSSL::Crypto spdlog xmlplusplus ${LIBXML2_LIBRARIES})
 else()
-  find_package(Boost 1.85.0 COMPONENTS serialization REQUIRED)
+  find_package(Boost 1.85.0 COMPONENTS serialization program_options REQUIRED)
   target_link_libraries(larra_xmpp PUBLIC
     utempl::utempl ${Boost_LIBRARIES} OpenSSL::SSL
     nameof::nameof fmt::fmt
@@ -259,6 +261,7 @@ if(ENABLE_TESTS)
   target_sources(larra_xmpp_tests PUBLIC ${SOURCES})
   target_link_libraries(larra_xmpp_tests GTest::gtest_main
     larra_xmpp)
+  target_compile_definitions(larra_xmpp_tests PRIVATE SPDLOG_ACTIVE_LEVEL=${TEST_MAX_LOG_LEVEL})
   set_property(TARGET larra_xmpp_tests PROPERTY CXX_STANDARD 23)
   include(GoogleTest)
   gtest_discover_tests(larra_xmpp_tests)
@@ -270,6 +273,7 @@ if(ENABLE_EXAMPLES)
       get_filename_component(EXAMPLE_NAME ${EXAMPLE_SRC} NAME_WE)
       add_executable(${EXAMPLE_NAME} ${EXAMPLE_SRC})
       target_link_libraries(${EXAMPLE_NAME} larra_xmpp)
+      target_compile_definitions(${EXAMPLE_NAME} PRIVATE SPDLOG_ACTIVE_LEVEL=${TEST_MAX_LOG_LEVEL})
       set_property(TARGET ${EXAMPLE_NAME} PROPERTY CXX_STANDARD 23)
       set_target_properties(${EXAMPLE_NAME} PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/examples/output")

examples/src/connect.cpp

@@ -3,11 +3,28 @@
 
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/detached.hpp>
+#include <boost/program_options.hpp>
 #include <larra/client/client.hpp>
 #include <larra/presence.hpp>
 #include <larra/printer_stream.hpp>
 #include <print>
 
+// clang-format off
+constexpr auto ToString(spdlog::level::level_enum e) {
+  switch (e) {
+    case spdlog::level::trace: return "TRACE";
+    case spdlog::level::debug: return "DEBUG";
+    case spdlog::level::info: return "INFO";
+    case spdlog::level::warn: return "WARNING";
+    case spdlog::level::err: return "ERROR";
+    case spdlog::level::critical: return "CRITICAL";
+    case spdlog::level::off: return "OFF";
+    default:
+      return "INVALID";
+  }
+}
+// clang-format on
+
 namespace iq = larra::xmpp::iq;
 
 auto Coroutine() -> boost::asio::awaitable<void> {
@@ -50,8 +67,39 @@ auto Coroutine() -> boost::asio::awaitable<void> {
   SPDLOG_INFO("Done connecting client!");
 }
 
-auto main() -> int {
-  spdlog::set_level(spdlog::level::trace);
+namespace po = boost::program_options;
+
+auto main(int argc, char** argv) -> int {
+  // Define options
+  po::options_description desc("Allowed options");
+  desc.add_options()("help,h", "Print help message")("log_level,l",
+                                                     po::value<int>()->default_value(SPDLOG_LEVEL_INFO),
+                                                     "Set log level: 0=TRACE, 1=DEBUG, 2=INFO, 3=WARN, 4=ERROR, 5=CRITICAL, 6=OFF");
+
+  // Parse command-line arguments
+  po::variables_map vm;
+  try {
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    if(vm["log_level"].as<int>() < spdlog::level::level_enum::trace || vm["log_level"].as<int>() > spdlog::level::level_enum::off) {
+      throw std::invalid_argument{
+          std::format("Invalid argument value for '--log_level' option. Check option description for more details")};
+    }
+    if(vm["log_level"].as<int>() < SPDLOG_ACTIVE_LEVEL) {
+      SPDLOG_WARN("Specified log_level '{}' is lower than max available one '{}'. Log level will be changed according to the maximum one",
+                  vm["log_level"].as<int>(),
+                  SPDLOG_ACTIVE_LEVEL);
+    }
+  } catch(const std::exception& e) {
+    SPDLOG_CRITICAL("Cmd parse error: {}", e.what());
+    return 1;
+  }
+
+  // Cmd options handling
+  spdlog::set_level(static_cast<spdlog::level::level_enum>(vm["log_level"].as<int>()));
+  std::println("\nEnvironment setup:\n\tCurrently set log level: {}\n", ToString(spdlog::get_level()));
+
   boost::asio::io_context io_context;
   boost::asio::co_spawn(io_context, Coroutine(), boost::asio::detached);
   io_context.run();

library/include/larra/client/client.hpp

@@ -84,14 +84,12 @@ struct Client {
 
     auto set_bind_response = co_await connection.template Read<Iq<::iq::Bind>>();
     std::visit(utempl::Overloaded(
-                   [](auto error) {
-                     throw "Error response on IQ: Set::Bind: ''";  // TODO(unknown): Add exact error parsing
-                   },
                    [&](::iq::ResultBind r) {
                      jid.resource = std::move(r.payload.jid->resource);
                      SPDLOG_INFO("Allocated resource: {}", jid.resource);
-                   }),
-               set_bind_response);
+                   },
+                   IqErrThrowVisitor{"Error response on IQ: Set::Bind"}),
+               std::move(set_bind_response));
     co_return;
   }
 
@@ -101,14 +99,12 @@ struct Client {
 
     const auto get_roster_response = co_await connection.template Read<Iq<::iq::Roster>>();
     std::visit(utempl::Overloaded(
-                   [](auto error) {
-                     throw "Error response on IQ: Get::Roster: ''";  // TODO(unknown): Add exact error parsing
-                   },
                    [&](::iq::ResultRoster r) {
                      roster = std::move(r.payload);
                      SPDLOG_INFO("New roster: {}", ToString(roster));
-                   }),
-               get_roster_response);
+                   },
+                   IqErrThrowVisitor{"Error response on IQ: Get::Roster"}),
+               std::move(get_roster_response));
     co_return;
   }
 
@@ -198,6 +194,174 @@ struct StartTlsRequest {
   }
 };
 
+template <typename Socket>
+auto ConnectViaProxy(Socket& socket, const NoProxy&, std::string_view host, std::uint16_t port) -> boost::asio::awaitable<void> {
+  auto executor = co_await boost::asio::this_coro::executor;
+  boost::asio::ip::tcp::resolver resolver(executor);
+  auto endpoints = co_await resolver.async_resolve(host, std::to_string(port), boost::asio::use_awaitable);
+  co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
+  co_return;
+}
+
+template <typename Socket>
+auto ConnectViaProxy(Socket& socket, const HttpProxy&, std::string_view host, std::uint16_t port) -> boost::asio::awaitable<void> {
+  constexpr std::string_view kHttpVersion = "HTTP/1.1";
+  constexpr unsigned int kSuccessStatusCode = 200;
+  constexpr std::string_view kEndOfHeaders = "\r\n\r\n";
+  constexpr int kEndOfHttpSubstring = 5;
+
+  std::string httpConnectRequest = std::format("CONNECT {}:{} {}\r\nHost: {}:{}\r\n\r\n", host, port, kHttpVersion, host, port);
+
+  co_await boost::asio::async_write(
+      socket, boost::asio::buffer(httpConnectRequest), boost::asio::transfer_all(), boost::asio::use_awaitable);
+
+  boost::asio::streambuf proxyServerResponse;
+  co_await boost::asio::async_read_until(socket, proxyServerResponse, kEndOfHeaders, boost::asio::use_awaitable);
+
+  std::istream responseStream(&proxyServerResponse);
+  std::string httpVersion;
+  unsigned int statusCode = 0;
+  std::string statusMessage;
+
+  responseStream >> httpVersion >> statusCode;
+  std::getline(responseStream, statusMessage);
+
+  if(!responseStream || httpVersion.substr(0, kEndOfHttpSubstring) != "HTTP/") {
+    throw std::runtime_error("Invalid HTTP response from proxy");
+  }
+
+  if(statusCode != kSuccessStatusCode) {
+    std::ostringstream errorStream;
+    errorStream << httpVersion << " " << statusCode << " " << statusMessage;
+    throw std::runtime_error("HTTP proxy CONNECT failed: " + errorStream.str());
+  }
+
+  co_return;
+}
+
+template <typename Socket>
+auto ConnectViaProxy(Socket& socket, const Socks5Proxy&, std::string_view address, std::uint16_t port) -> boost::asio::awaitable<void> {
+  constexpr std::array kSocks5RequestStart = {std::byte{0x05}, std::byte{0x01}, std::byte{0x00}, std::byte{0x03}};
+
+  constexpr std::size_t kSocks5RequestMaxSize = 257;
+
+  constexpr std::size_t kSocks5ReplyTypeSize = 10;
+
+  constexpr std::array kHandshakeRequest{std::byte{0x05}, std::byte{0x01}, std::byte{0x00}};
+
+  std::array<std::byte, 2> handshakeResponse;  // NOLINT
+
+  co_await boost::asio::async_write(
+      socket, boost::asio::buffer(kHandshakeRequest), boost::asio::transfer_all(), boost::asio::use_awaitable);
+  co_await boost::asio::async_read(socket, boost::asio::buffer(handshakeResponse), boost::asio::transfer_all(), boost::asio::use_awaitable);
+  if(handshakeResponse[0] != std::byte{0x05} || handshakeResponse[1] != std::byte{0x00}) {  // NOLINT
+    throw std::exception{};
+  };
+  const auto [connectRequest, size] = [&] {
+    const auto size = static_cast<std::byte>(address.size());
+    const auto htonsPort = std::bit_cast<std::array<std::byte, 2>>(htons(port));
+    auto range = std::array{std::span{kSocks5RequestStart.begin(), kSocks5RequestStart.size()},
+                            std::span{&size, 1},
+                            std::span{utils::StartLifetimeAsArray<const std::byte>(address.data(), address.size()), address.size()},
+                            std::span{htonsPort.data(), 2}} |
+                 std::views::join;
+    std::array<std::byte, kSocks5RequestMaxSize> response;  // NOLINT
+    auto sizee = std::ranges::copy(range, response.begin()).out - response.begin();
+    return std::pair{response, sizee};
+  }();
+  co_await boost::asio::async_write(
+      socket, boost::asio::buffer(connectRequest.begin(), size), boost::asio::transfer_all(), boost::asio::use_awaitable);
+  std::array<std::byte, kSocks5ReplyTypeSize> connectReplyType;  // NOLINT
+  co_await boost::asio::async_read(socket, boost::asio::buffer(connectReplyType), boost::asio::transfer_all(), boost::asio::use_awaitable);
+  if(connectReplyType[1] != std::byte{0x00}) {
+    throw std::exception{};
+  };
+  co_return;
+}
+
+template <typename ProxyType>
+auto GetProxySettings(const char* proxyEnv, std::uint16_t port) -> Proxy {
+  std::string_view rawProxyStr = proxyEnv;
+
+  const std::size_t protocolNamePos = rawProxyStr.find("://");
+  std::string_view proxyStr = protocolNamePos == std::string_view::npos ? rawProxyStr : rawProxyStr.substr(protocolNamePos + 3);
+
+  const std::size_t portPos = proxyStr.find(':');
+
+  if(portPos == std::string_view::npos) {
+    return ProxyType{std::string(proxyStr), port};
+  }
+  auto host = std::string(proxyStr.substr(0, portPos));
+  auto portStr = proxyStr.substr(portPos + 1);
+  auto portOpt = ToInt<uint16_t>(portStr);
+
+  if(!portOpt) {
+    throw std::runtime_error("Invalid port number in proxy settings");
+  }
+  return ProxyType{host, portOpt.value()};
+}
+
+inline auto GetSystemProxySettings() -> Proxy {
+  if(const char* proxyEnv = std::getenv("http_proxy")) {
+    constexpr std::uint16_t kHttpPort = 8080;
+    return GetProxySettings<HttpProxy>(proxyEnv, kHttpPort);
+  }
+  if(const char* proxyEnv = std::getenv("socks_proxy")) {
+    constexpr std::uint16_t kSocksPort = 1080;
+    return GetProxySettings<Socks5Proxy>(proxyEnv, kSocksPort);
+  }
+
+  return NoProxy{};
+}
+
+template <typename Socket>
+auto ConnectViaProxy(Socket& socket, const SystemConfiguredProxy&, std::string_view host, std::uint16_t port)
+    -> boost::asio::awaitable<void> {
+  auto proxyOpt = GetSystemProxySettings();
+
+  co_await std::visit(
+      [&](auto&& proxyVariant) -> boost::asio::awaitable<void> {     // NOLINT
+        co_await ConnectViaProxy(socket, proxyVariant, host, port);  // GCC error if co_return
+      },
+      proxyOpt);
+}
+
+template <typename Socket, typename ProxyType>
+auto ConnectToServer(Socket& socket, const ProxyType& proxy, std::string_view host, std::uint16_t port) -> boost::asio::awaitable<void> {
+  auto executor = co_await boost::asio::this_coro::executor;
+  boost::asio::ip::tcp::resolver resolver(executor);
+
+  if constexpr(!std::same_as<ProxyType, NoProxy>) {
+    auto endpoints = co_await resolver.async_resolve(proxy.hostname, std::to_string(proxy.port), boost::asio::use_awaitable);
+    co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
+    co_await ConnectViaProxy(socket, proxy, host, port);
+  }
+}
+
+template <typename Socket>
+auto ConnectToServer(Socket& socket, const SystemConfiguredProxy& proxy, std::string_view host, std::uint16_t port)
+    -> boost::asio::awaitable<void> {
+  auto executor = co_await boost::asio::this_coro::executor;
+  boost::asio::ip::tcp::resolver resolver(executor);
+  auto endpoints = co_await resolver.async_resolve(host, std::to_string(port), boost::asio::use_awaitable);
+  co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
+
+  co_await ConnectViaProxy(socket, proxy, host, port);
+}
+
+template <typename Socket>
+auto ConnectWithProxy(Socket& socket, const Proxy& proxy, std::string_view host, std::uint16_t port) -> boost::asio::awaitable<void> {
+  co_await std::visit(
+      [&socket, host, port](const auto& proxyVariant) {
+        return ConnectToServer(socket, proxyVariant, host, port);
+      },
+      proxy);
+}
+
+inline auto GetAuthData(const PlainUserAccount& account) -> std::string {
+  return EncodeBase64('\0' + account.jid.username + '\0' + account.password);
+}
+
 struct ClientCreateVisitor {
   UserAccount account;
   const Options& options;
@@ -292,8 +456,17 @@ struct ClientCreateVisitor {
                                               boost::asio::use_awaitable);
   }
 
-  auto Connect(auto& socket, boost::asio::ip::tcp::resolver::results_type resolveResults) -> boost::asio::awaitable<void> {
-    co_await boost::asio::async_connect(socket, resolveResults, boost::asio::use_awaitable);
+  template <typename Socket>
+  auto Connect(Socket& socket) -> boost::asio::awaitable<void> {
+    if(!std::holds_alternative<NoProxy>(this->options.proxy)) {
+      auto host = this->options.hostname.value_or(account.Jid().server);
+      auto port = this->options.port.value_or(kDefaultXmppPort);
+
+      co_await ConnectWithProxy(socket, this->options.proxy, host, port);
+    } else {
+      auto resolveResults = co_await this->Resolve();
+      co_await boost::asio::async_connect(socket, resolveResults, boost::asio::use_awaitable);
+    }
   }
 
   template <typename Socket>
@@ -324,7 +497,7 @@ struct ClientCreateVisitor {
   template <typename Socket>
   inline auto operator()(XmlStream<Socket> stream)
       -> boost::asio::awaitable<std::variant<Client<Socket>, Client<boost::asio::ssl::stream<Socket>>>> {
-    co_await this->Connect(stream.next_layer(), co_await this->Resolve());
+    co_await this->Connect(stream.next_layer());
 
     co_await stream.Send(UserStream{.from = account.Jid(), .to = account.Jid().server, .version = "1.0", .xmlLang = "en"});
     SPDLOG_DEBUG("UserStream sended");
@@ -347,7 +520,7 @@ struct ClientCreateVisitor {
   inline auto operator()(XmlStream<boost::asio::ssl::stream<Socket>> stream)
       -> boost::asio::awaitable<std::variant<Client<Socket>, Client<boost::asio::ssl::stream<Socket>>>> {
     auto& socket = stream.next_layer();
-    co_await this->Connect(socket.next_layer(), co_await this->Resolve());
+    co_await this->Connect(socket.next_layer());
     co_await stream.Send(
         UserStream{.from = account.Jid().Username("anonymous"), .to = account.Jid().server, .version = "1.0", .xmlLang = "en"},
         socket.next_layer());

library/include/larra/iq.hpp

@@ -1,9 +1,12 @@
 #pragma once
+#include <spdlog/spdlog.h>
+
 #include <larra/jid.hpp>
 #include <larra/serialization.hpp>
-#include <larra/stream_error.hpp>
+#include <larra/stanza_error.hpp>
 #include <larra/utils.hpp>
 #include <optional>
+#include <stdexcept>
 #include <string>
 
 namespace larra::xmpp {
@@ -115,7 +118,41 @@ using Error = BaseImplWithPayload<kErrorName, Payload>;
 
 }  // namespace iq
 
+using IqError = iq::Error<stanza::error::StanzaError>;
+
 template <typename Payload>
-using Iq = std::variant<iq::Get<Payload>, iq::Set<Payload>, iq::Result<Payload>, iq::Error<Payload>>;
+using Iq = std::variant<iq::Get<Payload>, iq::Set<Payload>, iq::Result<Payload>, IqError>;
+
+struct IqErrThrowVisitor {
+  constexpr IqErrThrowVisitor(std::string_view baseErrorMsg) : baseErrorMsg(baseErrorMsg) {
+  }
+
+  template <typename Payload>
+  void operator()(const iq::Get<Payload>&) {
+    static constexpr std::string_view getErrorMsg = ": 'Get' is an invalid type for IQ result. Expected 'Result' or 'Error'";
+
+    auto finalErrorMsg = std::string(baseErrorMsg).append(getErrorMsg);
+    SPDLOG_ERROR(finalErrorMsg);
+    throw std::runtime_error{finalErrorMsg};
+  }
+  template <typename Payload>
+  void operator()(const iq::Set<Payload>&) {
+    static constexpr std::string_view getErrorMsg = ": 'Set' is an invalid type for IQ result. Expected 'Result' or 'Error'";
+
+    auto finalErrorMsg = std::string(baseErrorMsg).append(getErrorMsg);
+    SPDLOG_ERROR(finalErrorMsg);
+    throw std::runtime_error{finalErrorMsg};
+  }
+  void operator()(IqError err) {
+    SPDLOG_ERROR(baseErrorMsg);
+    std::visit(
+        [](auto exception) {
+          throw exception;
+        },
+        std::move(err.payload));
+  }
+
+  std::string_view baseErrorMsg;
+};
 
 }  // namespace larra::xmpp

library/include/larra/stanza_error.hpp

@@ -0,0 +1,148 @@
+#pragma once
+#include <libxml++/libxml++.h>
+
+#include <larra/utils.hpp>
+#include <optional>
+#include <variant>
+
+namespace larra::xmpp::stanza::error {
+
+struct StanzaBaseError : std::exception {};
+
+// DO NOT MOVE TO ANOTHER NAMESPACE(where no heirs). VIA friend A FUNCTION IS ADDED THAT VIA ADL WILL BE SEARCHED FOR HEIRS
+// C++20 modules very unstable in clangd :(
+template <typename T>
+struct StanzaErrorImpl : StanzaBaseError {
+  static constexpr auto kDefaultName = "error";
+  static constexpr auto kDefaultNamespace = "urn:ietf:params:xml:ns:xmpp-stanzas";
+  static inline const auto kKebabCaseName = static_cast<std::string>(utils::ToKebabCaseName<T>());
+
+  static constexpr auto kErrorMessage = [] -> std::string_view {
+    static constexpr auto name = nameof::nameof_short_type<T>();
+    static constexpr auto str = [] {
+      return std::array{std::string_view{"Stanza IQ Error: "}, std::string_view{name}, std::string_view{"\0", 1}} | std::views::join;
+    };
+    static constexpr auto array = str() | std::ranges::to<utils::RangeToWrapper<std::array<char, std::ranges::distance(str())>>>();
+    return {array.data(), array.size() - 1};
+  }();
+
+  std::optional<std::string> by{};
+  std::string type;
+
+  // TODO(unknown): Add "optional text children" support for stanza error. Check  "XML Stanzas" -> "Syntax" for more details
+  static constexpr auto TryParse(xmlpp::Element* element) -> std::optional<T> {
+    if(not element) {
+      return std::nullopt;
+    }
+
+    auto by = element->get_attribute("by");
+    auto type = element->get_attribute("type");
+    if(not type) {
+      return std::nullopt;
+    }
+
+    auto node = element->get_first_child(kKebabCaseName);
+    if(not node) {
+      return std::nullopt;
+    }
+
+    T obj;
+    obj.type = type->get_value();
+    if(by) {
+      obj.by = std::optional{by->get_value()};
+    }
+    return obj;
+  }
+  static constexpr auto Parse(xmlpp::Element* element) -> T {
+    return TryParse(element).value();
+  }
+  friend constexpr auto operator<<(xmlpp::Element* element, const T& obj) -> void {
+    element->set_attribute("type", obj.type);
+    if(obj.by) {
+      element->set_attribute("by", *obj.by);
+    }
+
+    auto node = element->add_child_element(kKebabCaseName);
+    node->set_namespace_declaration(kDefaultNamespace);
+  }
+  constexpr auto operator==(const StanzaErrorImpl<T>&) const -> bool {
+    return true;
+  };
+  [[nodiscard]] constexpr auto what() const noexcept -> const char* override {
+    return kErrorMessage.data();
+  }
+};
+
+// Helper class to prevent parsing response stream into an expected return type if its name is an 'error'
+struct UnknownStanzaError : StanzaBaseError {
+  static constexpr auto kDefaultName = "stream:error";
+  static constexpr std::string_view kErrorMessage = "Unknown XMPP stream error";
+
+  static constexpr auto TryParse(xmlpp::Element* element) {
+    return std::optional{UnknownStanzaError{}};
+  }
+  static constexpr auto Parse(xmlpp::Element* element) {
+    return TryParse(element).value();
+  }
+  friend constexpr auto operator<<(xmlpp::Element* element, const UnknownStanzaError& obj) -> void {
+    throw std::runtime_error{std::format("'{}' must never be written into the real stream!", kErrorMessage)};
+  }
+  constexpr auto operator==(const UnknownStanzaError&) const -> bool {
+    return true;
+  };
+  [[nodiscard]] constexpr auto what() const noexcept -> const char* override {
+    return kErrorMessage.data();
+  }
+};
+
+struct BadRequest : StanzaErrorImpl<BadRequest> {};
+struct Conflict : StanzaErrorImpl<Conflict> {};
+struct FeatureNotImplemented : StanzaErrorImpl<FeatureNotImplemented> {};
+struct Forbidden : StanzaErrorImpl<Forbidden> {};
+struct Gone : StanzaErrorImpl<Gone> {};
+struct InternalServerError : StanzaErrorImpl<InternalServerError> {};
+struct ItemNotFound : StanzaErrorImpl<ItemNotFound> {};
+struct JidMalformed : StanzaErrorImpl<JidMalformed> {};
+struct NotAcceptable : StanzaErrorImpl<NotAcceptable> {};
+struct NotAllowed : StanzaErrorImpl<NotAllowed> {};
+struct NotAuthorized : StanzaErrorImpl<NotAuthorized> {};
+struct PolicyViolation : StanzaErrorImpl<PolicyViolation> {};
+struct RecipientUnavailable : StanzaErrorImpl<RecipientUnavailable> {};
+struct Redirect : StanzaErrorImpl<Redirect> {};
+struct RegistrationRequired : StanzaErrorImpl<RegistrationRequired> {};
+struct RemoteServerNotFound : StanzaErrorImpl<RemoteServerNotFound> {};
+struct RemoteServerTimeout : StanzaErrorImpl<RemoteServerTimeout> {};
+struct ResourceConstraint : StanzaErrorImpl<ResourceConstraint> {};
+struct ServiceUnavailable : StanzaErrorImpl<ServiceUnavailable> {};
+struct SubscriptionRequired : StanzaErrorImpl<SubscriptionRequired> {};
+struct UndefinedCondition : StanzaErrorImpl<UndefinedCondition> {};
+struct UnexpectedRequest : StanzaErrorImpl<UnexpectedRequest> {};
+
+using StanzaError = std::variant<BadRequest,
+                                 Conflict,
+                                 FeatureNotImplemented,
+                                 Forbidden,
+                                 Gone,
+                                 InternalServerError,
+                                 ItemNotFound,
+                                 JidMalformed,
+                                 NotAcceptable,
+                                 NotAllowed,
+                                 NotAuthorized,
+                                 PolicyViolation,
+                                 RecipientUnavailable,
+                                 Redirect,
+                                 RegistrationRequired,
+                                 RemoteServerNotFound,
+                                 RemoteServerTimeout,
+                                 ResourceConstraint,
+                                 ServiceUnavailable,
+                                 SubscriptionRequired,
+                                 UndefinedCondition,
+                                 UnexpectedRequest,
+                                 UnknownStanzaError>;
+
+static_assert(std::is_same_v<typename std::variant_alternative_t<std::variant_size_v<StanzaError> - 1, StanzaError>, UnknownStanzaError>,
+              "'UnknownStanzaError' must be at the end of 'StanzaError' variant");
+
+}  // namespace larra::xmpp::stanza::error

library/include/larra/stream_error.hpp

@@ -2,43 +2,10 @@
 #include <libxml++/libxml++.h>
 
 #include <larra/utils.hpp>
-#include <nameof.hpp>
-#include <ranges>
 #include <variant>
 
 namespace larra::xmpp {
 
-namespace impl {
-// std::isupper not declared as constexpr
-constexpr auto IsUpper(char ch) -> bool {
-  return ch >= 'A' && ch <= 'Z';
-}
-
-constexpr auto ToLower(char ch) -> char {
-  return (ch >= 'A' && ch <= 'Z') ? static_cast<char>(ch + ('a' - 'A')) : ch;
-}
-
-template <typename T>
-constexpr auto ToKebabCaseName() -> std::string_view {
-  static constexpr auto rawStr = nameof::nameof_short_type<T>();
-
-  constexpr auto str = [] {
-    return rawStr  //
-           | std::views::transform([](auto ch) {
-               return impl::IsUpper(ch) ? std::array<char, 2>{'-', impl::ToLower(ch)} : std::array<char, 2>{ch, '\0'};
-             })                //
-           | std::views::join  //
-           | std::views::filter([](char ch) {
-               return ch != '\0';
-             })  //
-           | std::views::drop(1);
-  };
-  static constexpr auto arr = str() | std::ranges::to<utils::RangeToWrapper<std::array<char, std::ranges::distance(str())>>>();
-  return {arr.data(), arr.size()};
-}
-
-}  // namespace impl
-
 namespace error::stream {
 
 struct BaseError : std::exception {};
@@ -48,7 +15,7 @@ struct BaseError : std::exception {};
 template <typename T>
 struct ErrorImpl : BaseError {
   static constexpr auto kDefaultName = "stream:error";
-  static inline const auto kKebabCaseName = static_cast<std::string>(impl::ToKebabCaseName<T>());
+  static inline const auto kKebabCaseName = static_cast<std::string>(utils::ToKebabCaseName<T>());
 
   static constexpr auto kErrorMessage = [] -> std::string_view {
     static constexpr auto name = nameof::nameof_short_type<T>();
@@ -85,7 +52,7 @@ struct UnknownXmppError : BaseError {
     return TryParse(element).value();
   }
   friend constexpr auto operator<<(xmlpp::Element* element, const UnknownXmppError& obj) -> void {
-    throw std::format("'{}' must never be written into the real stream!", kErrorMessage);
+    throw std::runtime_error{std::format("'{}' must never be written into the real stream!", kErrorMessage)};
   }
   [[nodiscard]] constexpr auto what() const noexcept -> const char* override {
     return kErrorMessage.data();
@@ -145,7 +112,8 @@ using StreamError = std::variant<error::stream::BadFormat,
                                  error::stream::UnsupportedVersion,
                                  error::stream::UnknownXmppError>;
 
-static_assert(!std::is_same_v<typename std::variant_alternative_t<std::variant_size_v<StreamError> - 1, StreamError>, StreamError>,
-              "'UnknownXmppError' must be at the end of 'StreamError' variant");
+static_assert(
+    std::is_same_v<typename std::variant_alternative_t<std::variant_size_v<StreamError> - 1, StreamError>, error::stream::UnknownXmppError>,
+    "'UnknownXmppError' must be at the end of 'StreamError' variant");
 
 }  // namespace larra::xmpp

library/include/larra/utils.hpp

@@ -1,5 +1,7 @@
 #pragma once
 #include <boost/pfr.hpp>
+#include <nameof.hpp>
+#include <ranges>
 #include <utempl/utils.hpp>
 
 namespace larra::xmpp::utils {
@@ -309,4 +311,31 @@ auto AccumulateFieldLength(const T& obj) -> std::size_t {
   return totalLength;
 }
 
+template <typename T>
+constexpr auto ToKebabCaseName() -> std::string_view {
+  static constexpr auto rawStr = nameof::nameof_short_type<T>();
+
+  // std::isupper and std::tolower are not declared as constexpr
+  static constexpr auto isUpper = [](char ch) {
+    return ch >= 'A' && ch <= 'Z';
+  };
+  static constexpr auto toLower = [](char ch) {
+    return (ch >= 'A' && ch <= 'Z') ? static_cast<char>(ch + ('a' - 'A')) : ch;
+  };
+
+  constexpr auto str = [] {
+    return rawStr  //
+           | std::views::transform([](auto ch) {
+               return isUpper(ch) ? std::array<char, 2>{'-', toLower(ch)} : std::array<char, 2>{ch, '\0'};
+             })                //
+           | std::views::join  //
+           | std::views::filter([](char ch) {
+               return ch != '\0';
+             })  //
+           | std::views::drop(1);
+  };
+  static constexpr auto arr = str() | std::ranges::to<utils::RangeToWrapper<std::array<char, std::ranges::distance(str())>>>();
+  return {arr.data(), arr.size()};
+}
+
 }  // namespace larra::xmpp::utils

library/src/bind.cpp

@@ -2,7 +2,7 @@
 
 namespace larra::xmpp::iq {
 auto operator<<(xmlpp::Element* element, const Bind& bind) -> void {
-  element->set_attribute("xmlns", Bind::kDefaultNamespace);
+  element->set_namespace_declaration(Bind::kDefaultNamespace);
 
   if(bind.jid) {
     auto* jid_el = element->add_child_element("jid");

library/src/roster.cpp

@@ -21,7 +21,7 @@ auto RosterItem::Parse(xmlpp::Element* element) -> RosterItem {
 }
 
 auto operator<<(xmlpp::Element* element, const Roster& self) -> void {
-  element->set_attribute("xmlns", Roster::kDefaultNamespace);
+  element->set_namespace_declaration(Roster::kDefaultNamespace);
   S::Serialize(element, self);
 }
 auto Roster::Parse(xmlpp::Element* element) -> Roster {

tests/iq.cpp

@@ -1,10 +1,23 @@
 #include <gtest/gtest.h>
+#include <spdlog/spdlog.h>
 
 #include <larra/iq.hpp>
+#include <stdexcept>
 
 namespace {
 
-static constexpr auto kExpectedData = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<iq id=\"id\" type=\"get\"><some>37</some></iq>\n";
+static constexpr auto kForbiddenErrorData = R"(<?xml version="1.0" encoding="UTF-8"?>
+<iq id="42" to="name@server/res" type="error"><error type="auth"><forbidden xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/></error>
+</iq>)";
+
+static constexpr auto kExpectedSetData = R"(<?xml version="1.0" encoding="UTF-8"?>
+<iq id="id" type="set"><some>37</some></iq>
+)";
+
+static constexpr auto kExpectedData = R"(<?xml version="1.0" encoding="UTF-8"?>
+<iq id="id" type="get"><some>37</some></iq>
+)";
+
 struct SomeStruct {
   int value;
   constexpr auto operator==(const SomeStruct&) const -> bool = default;
@@ -43,4 +56,101 @@ TEST(IQ, Parse) {
   EXPECT_EQ(S::Parse(node), iq);
 }
 
+TEST(IQ, ParseForbiddenError) {
+  std::istringstream xml_stream(kForbiddenErrorData);
+
+  xmlpp::DomParser parser;
+  parser.parse_stream(xml_stream);
+
+  using S = Serialization<Iq<SomeStruct>>;
+  xmlpp::Document* doc = parser.get_document();
+  auto iqRes = S::Parse(doc->get_root_node());
+
+  ASSERT_TRUE(std::holds_alternative<IqError>(iqRes));
+
+  auto errorRes = std::get<IqError>(iqRes);
+  ASSERT_TRUE(std::holds_alternative<stanza::error::Forbidden>(errorRes.payload));
+}
+
+TEST(IQ, IqErrThrowVisitorThrow) {
+  std::istringstream xml_stream(kForbiddenErrorData);
+
+  xmlpp::DomParser parser;
+  parser.parse_stream(xml_stream);
+
+  using S = Serialization<Iq<SomeStruct>>;
+  xmlpp::Document* doc = parser.get_document();
+  auto iqRes = S::Parse(doc->get_root_node());
+  ASSERT_TRUE(std::holds_alternative<IqError>(iqRes));
+
+  static constexpr auto visitorErrMsg = "Test Error";
+  static constexpr auto throwErrMsg = "Stanza IQ Error: Forbidden";
+  try {
+    std::visit(utempl::Overloaded([](iq::Result<SomeStruct> r) {}, IqErrThrowVisitor{visitorErrMsg}), std::move(iqRes));
+  } catch(const stanza::error::StanzaBaseError& err) {
+    ASSERT_STREQ(throwErrMsg, err.what());
+    return;
+  } catch(const std::runtime_error& err) {
+    ASSERT_TRUE(false) << "Invalid throw type throw";
+  } catch(...) {
+    ASSERT_TRUE(false) << "Unexpected throw";
+  }
+
+  ASSERT_TRUE(false) << "Expected throwing an exception due to an error in output";
+}
+
+TEST(IQ, IqErrThrowVisitorThrowGet) {
+  std::istringstream xml_stream(kExpectedData);
+
+  xmlpp::DomParser parser;
+  parser.parse_stream(xml_stream);
+
+  using S = Serialization<Iq<SomeStruct>>;
+  xmlpp::Document* doc = parser.get_document();
+  auto iqRes = S::Parse(doc->get_root_node());
+  ASSERT_TRUE(std::holds_alternative<iq::Get<SomeStruct>>(iqRes)) << "\tERROR: Unexpected parse result";
+
+  static constexpr auto visitorErrMsg = "Test Error";
+  static constexpr auto throwErrMsg = "Test Error: 'Get' is an invalid type for IQ result. Expected 'Result' or 'Error'";
+  try {
+    std::visit(utempl::Overloaded([](iq::Result<SomeStruct> r) {}, IqErrThrowVisitor{"Test Error"}), std::move(iqRes));
+  } catch(const stanza::error::StanzaBaseError& err) {
+    ASSERT_TRUE(false) << "\tERROR: Invalid throw type throw";
+  } catch(const std::runtime_error& err) {
+    ASSERT_STREQ(throwErrMsg, err.what());
+    return;
+  } catch(...) {
+    ASSERT_TRUE(false) << "\tERROR: Unexpected throw";
+  }
+
+  ASSERT_TRUE(false) << "\tERROR: Expected throwing an exception due to an error in output";
+}
+
+TEST(IQ, IqErrThrowVisitorThrowSet) {
+  std::istringstream xml_stream(kExpectedSetData);
+
+  xmlpp::DomParser parser;
+  parser.parse_stream(xml_stream);
+
+  using S = Serialization<Iq<SomeStruct>>;
+  xmlpp::Document* doc = parser.get_document();
+  auto iqRes = S::Parse(doc->get_root_node());
+  ASSERT_TRUE(std::holds_alternative<iq::Set<SomeStruct>>(iqRes)) << "\tERROR: Unexpected parse result";
+
+  static constexpr auto visitorErrMsg = "Test Error";
+  static constexpr auto throwErrMsg = "Test Error: 'Set' is an invalid type for IQ result. Expected 'Result' or 'Error'";
+  try {
+    std::visit(utempl::Overloaded([](iq::Result<SomeStruct> r) {}, IqErrThrowVisitor{"Test Error"}), std::move(iqRes));
+  } catch(const stanza::error::StanzaBaseError& err) {
+    ASSERT_TRUE(false) << "\tERROR: Invalid throw type throw";
+  } catch(const std::runtime_error& err) {
+    ASSERT_STREQ(throwErrMsg, err.what());
+    return;
+  } catch(...) {
+    ASSERT_TRUE(false) << "\tERROR: Unexpected throw";
+  }
+
+  ASSERT_TRUE(false) << "\tERROR: Expected throwing an exception due to an error in output";
+}
+
 }  // namespace larra::xmpp

tests/main.cpp

@@ -0,0 +1,61 @@
+#include <gtest/gtest.h>
+#include <spdlog/spdlog.h>
+
+#include <boost/program_options.hpp>
+#include <exception>
+#include <print>
+#include <stdexcept>
+
+// clang-format off
+constexpr auto ToString(spdlog::level::level_enum e) {
+  switch (e) {
+    case spdlog::level::trace: return "TRACE";
+    case spdlog::level::debug: return "DEBUG";
+    case spdlog::level::info: return "INFO";
+    case spdlog::level::warn: return "WARNING";
+    case spdlog::level::err: return "ERROR";
+    case spdlog::level::critical: return "CRITICAL";
+    case spdlog::level::off: return "OFF";
+    default:
+      return "INVALID";
+  }
+}
+// clang-format on
+
+namespace po = boost::program_options;
+
+auto main(int argc, char** argv) -> int {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  // Define options
+  po::options_description desc("Allowed options");
+  desc.add_options()("help,h", "Print help message")("log_level,l",
+                                                     po::value<int>()->default_value(SPDLOG_LEVEL_INFO),
+                                                     "Set log level: 0=TRACE, 1=DEBUG, 2=INFO, 3=WARN, 4=ERROR, 5=CRITICAL, 6=OFF");
+
+  // Parse command-line arguments
+  po::variables_map vm;
+  try {
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    if(vm["log_level"].as<int>() < spdlog::level::level_enum::trace || vm["log_level"].as<int>() > spdlog::level::level_enum::off) {
+      throw std::invalid_argument{
+          std::format("Invalid argument value for '--log_level' option. Check option description for more details")};
+    }
+    if(vm["log_level"].as<int>() < SPDLOG_ACTIVE_LEVEL) {
+      SPDLOG_WARN("Specified log_level '{}' is lower than max available one '{}'. Log level will be changed according to the maximum one",
+                  vm["log_level"].as<int>(),
+                  SPDLOG_ACTIVE_LEVEL);
+    }
+  } catch(const std::exception& e) {
+    SPDLOG_CRITICAL("Cmd parse error: {}", e.what());
+    return 1;
+  }
+
+  // Cmd options handling
+  spdlog::set_level(static_cast<spdlog::level::level_enum>(vm["log_level"].as<int>()));
+  std::println("\nEnvironment setup:\n\tCurrently set log level: {}\n", ToString(spdlog::get_level()));
+
+  return RUN_ALL_TESTS();
+}

tests/proxy.cpp

@@ -0,0 +1,114 @@
+#include <gtest/gtest.h>
+
+#include <larra/client/client.hpp>
+#include <larra/impl/mock_socket.hpp>
+#include <larra/proxy.hpp>
+
+using namespace larra::xmpp;
+using boost::asio::ip::tcp;
+namespace asio = boost::asio;
+
+class ProxyTest : public ::testing::Test {
+ protected:
+  boost::asio::io_context io;
+  larra::xmpp::impl::MockSocket mockSocket{io.get_executor()};
+};
+
+// Test 1: Connect via HTTP proxy with successful server response
+TEST_F(ProxyTest, ConnectViaHttpProxy_SuccessfulResponse) {
+  HttpProxy proxy{"proxy_host", 8080};
+
+  std::string targetHost = "target_host";
+  uint16_t targetPort = 80;
+
+  std::string expectedRequest =
+      std::format("CONNECT {}:{} HTTP/1.1\r\nHost: {}:{}\r\n\r\n", targetHost, targetPort, targetHost, targetPort);
+
+  std::string proxyResponse = "HTTP/1.1 200 Connection established\r\n\r\n";
+
+  mockSocket.AddReceivedData(proxyResponse);
+
+  bool connectSuccessful = false;
+
+  asio::co_spawn(
+      io,
+      [&]() -> asio::awaitable<void> {
+        try {
+          co_await client::impl::ConnectViaProxy(mockSocket, proxy, targetHost, targetPort);
+          connectSuccessful = true;
+        } catch(...) {
+          connectSuccessful = false;
+        }
+      },
+      asio::detached);
+
+  io.run();
+
+  std::string sentData = mockSocket.GetSentData();
+
+  EXPECT_EQ(sentData, expectedRequest);
+  EXPECT_TRUE(connectSuccessful);
+}
+
+// Test 2: Connect via SOCKS proxy
+TEST(Socks5ProxyTest, ConnectViaProxy) {
+  constexpr std::uint16_t kSocksPort = 1080;
+  constexpr std::uint16_t kAvailableUdpBufferSpaceForSocks = 262;
+
+  boost::asio::io_context io;
+  auto executor = io.get_executor();
+
+  larra::xmpp::impl::MockSocket socket{executor};
+
+  std::string expectedServerResponse;
+  expectedServerResponse += "\x05\x00";          // VER, METHOD
+  expectedServerResponse += "\x05\x00\x00\x01";  // VER, REP, RSV, ATYP (IPv4)
+  expectedServerResponse += "\x7F\x00\x00\x01";  // BND.ADDR (127.0.0.1)
+  expectedServerResponse += "\x1F\x90";          // BND.PORT (8080)
+
+  socket.AddReceivedData(expectedServerResponse);
+
+  Socks5Proxy proxy{.hostname = "proxy.example.com", .port = kSocksPort};
+  std::string targetHostname = "target.example.com";
+  std::uint16_t targetPort = 80;
+
+  boost::asio::co_spawn(
+      executor,
+      [&]() -> boost::asio::awaitable<void> {
+        co_await client::impl::ConnectViaProxy(socket, proxy, targetHostname, targetPort);
+
+        auto sentData = socket.GetSentData();
+
+        std::string expectedGreeting = "\x05\x01\x00";
+
+        std::array<std::uint8_t, kAvailableUdpBufferSpaceForSocks> expectedRequest{};
+        std::size_t reqLen = 0;
+
+        expectedRequest[reqLen++] = 0x05;  // VER
+        expectedRequest[reqLen++] = 0x01;  // CMD: CONNECT
+        expectedRequest[reqLen++] = 0x00;  // RSV
+        expectedRequest[reqLen++] = 0x03;  // ATYP: DOMAINNAME
+
+        expectedRequest[reqLen++] = static_cast<std::uint8_t>(targetHostname.size());  // domain length
+
+        std::memcpy(&expectedRequest[reqLen], targetHostname.data(), targetHostname.size());
+        reqLen += targetHostname.size();
+
+        std::uint16_t networkOrderPort = htons(targetPort);
+        expectedRequest[reqLen++] = static_cast<std::uint8_t>((networkOrderPort >> 8) & 0xFF);
+        expectedRequest[reqLen++] = static_cast<std::uint8_t>(networkOrderPort & 0xFF);
+
+        std::string expectedData = expectedGreeting;
+        auto transformedView = expectedRequest | std::views::take(reqLen) | std::views::transform([](std::uint8_t byte) {
+                                 return static_cast<char>(byte);
+                               });
+
+        expectedData.append(std::ranges::to<std::string>(transformedView));
+        EXPECT_EQ(sentData, expectedData);
+
+        co_return;
+      },
+      boost::asio::detached);
+
+  io.run();
+}