chore(aliases): remove SteadyTimer alias

Implement command-line interface for port scanning with IP validation and option
parsing. Add core scanning logic using Boost.Asio for asynchronous socket
checks, including timeout handling and port probing. Update xmake.lua to
configure build target and include necessary files.

.gitignore

@@ -2,3 +2,4 @@
 .xmake
 build
 compile_commands.json
+ignore

src/cli/portscan_cli.cpp

@@ -0,0 +1,26 @@
+#include "portscan_cli.hpp"
+#include <boost/program_options/value_semantic.hpp>
+#include <cassert>
+
+PortScanCli::PortScanCli()
+    : CliBase("Port Scanner Options")
+    , ip_("")
+{
+}
+
+void PortScanCli::setupOptions()
+{
+    // clang-format off
+    desc_.add_options()
+        ("help,h",     "Show help")
+        ("ip,H",       withDefault(ip_, "<IP>"),    "Local IPv4 to scan");
+    // clang-format on
+}
+
+std::string PortScanCli::getIp() const
+{
+    if (vm_["ip"].empty() == 0) {
+        return "127.0.0.1";
+    }
+    return vm_.at("ip").as<std::string>();
+}

src/cli/portscan_cli.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "cli_base.hpp"
+#include "option_utils.hpp"
+#include <string>
+
+class PortScanCli : public CliBase, protected OptionUtils
+{
+  public:
+    PortScanCli();
+
+    std::string getIp() const;
+
+  protected:
+    void setupOptions() override;
+
+  private:
+    std::string ip_;
+};

src/common/aliases.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/program_options.hpp>
+#include <boost/system/error_code.hpp>
+
+// --- Error handling ---
+using ErrorCode = boost::system::error_code;
+
+// --- Asio types ---
+using IoContext = boost::asio::io_context;
+using SteadyTimer = boost::asio::steady_timer;
+
+// --- Ip types ---
+using IpAddress = boost::asio::ip::address;
+
+// --- TCP types ---
+using TcpSocket = boost::asio::ip::tcp::socket;
+using TcpAcceptor = boost::asio::ip::tcp::acceptor;
+using TcpEndpoint = boost::asio::ip::tcp::endpoint;
+
+// --- UDP types ---
+using UdpSocket = boost::asio::ip::udp::socket;
+using UdpEndpoint = boost::asio::ip::udp::endpoint;
+
+// --- Program options ---
+using OptionsDescription = boost::program_options::options_description;
+using VariablesMap = boost::program_options::variables_map;

src/common/cli_base.cpp

@@ -0,0 +1,34 @@
+#include "cli_base.hpp"
+#include <boost/program_options/parsers.hpp>
+#include <iostream>
+
+CliBase::CliBase(const std::string &title)
+    : desc_(title)
+    , help_(false)
+{
+}
+
+void CliBase::parse(int argc, char *argv[])
+{
+    using namespace boost::program_options;
+
+    setupOptions(); // must be first
+
+    parsed_options parsed = parse_command_line(argc, argv, desc_);
+    store(parsed, vm_);
+    notify(vm_);
+
+    if (vm_.count("help")) {
+        help_ = true;
+    }
+}
+
+bool CliBase::isHelp() const
+{
+    return help_;
+}
+
+void CliBase::printHelp() const
+{
+    std::cout << desc_ << "\n";
+}

src/common/cli_base.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <string>
+
+class CliBase
+{
+  public:
+    CliBase(const std::string &title);
+
+    virtual ~CliBase() = default;
+
+    // parse argc/argv
+    void parse(int argc, char *argv[]);
+
+    bool isHelp() const;
+    void printHelp() const;
+
+  protected:
+    // children add their specific options here
+    virtual void setupOptions() = 0;
+
+    boost::program_options::options_description desc_;
+    boost::program_options::variables_map vm_;
+    bool help_;
+};

src/common/logger.cpp

@@ -1,5 +1,4 @@
 #include "logger.hpp"
-
 #include <boost/date_time/posix_time/posix_time_io.hpp>
 
 void Logger::init(bool toConsole, const std::string_view filePath)

src/common/option_utils.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <boost/program_options.hpp>
+
+class OptionUtils
+{
+  public:
+    template <typename T>
+    using OptionValue = boost::program_options::typed_value<T> *;
+
+    template <typename T>
+    static OptionValue<T>
+    withDefault(const T &value, const char *name = nullptr);
+
+  protected:
+    OptionUtils() = default;
+    ~OptionUtils() = default;
+};
+
+#include "option_utils.tpp"

src/common/option_utils.tpp

@@ -0,0 +1,13 @@
+#pragma once
+#include "option_utils.hpp"
+
+template <typename T>
+OptionUtils::OptionValue<T>
+OptionUtils::withDefault(const T &value, const char *name)
+{
+    auto v = boost::program_options::value<T>()->default_value(value);
+    if (name) {
+        v->value_name(name); // Optional
+    }
+    return v;
+}

src/core/port_scanner.cpp

@@ -0,0 +1,142 @@
+#include "port_scanner.hpp"
+#include "logger.hpp"
+#include <boost/asio.hpp>
+#include <string>
+
+PortScanner::PortScanner(
+    const std::string &ip, const std::vector<uint16_t> &ports
+)
+    : ports_(ports)
+{
+    ErrorCode ec;
+    addr_ = boost::asio::ip::make_address(ip, ec);
+    ip_ok_ = !ec;
+
+    if (!ip_ok_) {
+        Logger::error(std::string("PortScanner: invalid IP: ") + ip);
+    } else {
+        Logger::debug(std::string("PortScanner: using IP: ") + ip);
+    }
+}
+
+void PortScanner::setTimeoutMs(int ms)
+{
+    if (ms > 0) {
+        timeout_ms_ = ms;
+        Logger::debug(
+            std::string("PortScanner: timeout set to ")
+            + std::to_string(timeout_ms_) + " ms"
+        );
+    }
+}
+
+void PortScanner::run()
+{
+    if (!ip_ok_) {
+        Logger::error("PortScanner::run - aborting: ip not ok");
+        return;
+    }
+    for (uint16_t p : ports_) {
+        if (probe(p)) {
+            Logger::info(std::to_string(p));
+        }
+    }
+}
+
+bool PortScanner::probe(uint16_t port)
+{
+    TcpSocket s(io_);
+    SteadyTimer t(io_);
+    auto ep = endpoint(port);
+
+    Logger::debug(
+        std::string("PortScanner::probe - probing port ") + std::to_string(port)
+    );
+
+    armTimer(t, s);
+    armConnect(s, ep);
+    runUntilDone();
+    cancelTimer(t);
+    drainLeftovers();
+    close(s);
+
+    if (ok_) {
+        Logger::debug(std::string("Port ") + std::to_string(port) + " is OPEN");
+    } else {
+        Logger::debug(
+            std::string("Port ") + std::to_string(port) + " is CLOSED/FILTERED"
+        );
+    }
+
+    return ok_;
+}
+
+TcpEndpoint PortScanner::endpoint(uint16_t port) const
+{
+    return TcpEndpoint(addr_, port);
+}
+
+void PortScanner::armTimer(SteadyTimer &t, TcpSocket &s)
+{
+    t.expires_after(std::chrono::milliseconds(timeout_ms_));
+
+    auto onTimeout = [&s](const ErrorCode &ec) {
+        if (!ec) {
+            Logger::debug("Timer expired -> cancelling socket");
+            s.cancel();
+        }
+    };
+
+    t.async_wait(onTimeout);
+}
+
+void PortScanner::armConnect(TcpSocket &s, const TcpEndpoint &ep)
+{
+    ok_ = false;
+    done_ = false;
+
+    auto onConnect = [this](const ErrorCode &ec) {
+        if (!ec) {
+            ok_ = true;
+            Logger::debug("async_connect succeeded");
+        } else {
+            ok_ = false;
+            Logger::debug(std::string("async_connect failed: ") + ec.message());
+        }
+        done_ = true;
+    };
+
+    s.async_connect(ep, onConnect);
+}
+
+void PortScanner::runUntilDone()
+{
+    io_.restart();
+    while (!done_ && io_.run_one()) {
+    }
+}
+
+void PortScanner::cancelTimer(SteadyTimer &t)
+{
+    ErrorCode ec;
+    t.cancel();
+    if (ec) {
+        Logger::warn(std::string("cancelTimer: ") + ec.message());
+    }
+}
+
+void PortScanner::drainLeftovers()
+{
+    io_.restart();
+    while (io_.run_one()) {
+        continue;
+    }
+}
+
+void PortScanner::close(TcpSocket &s)
+{
+    ErrorCode ig;
+    if (s.close(ig)) {
+        Logger::warn(std::string("close socket failed: ") + ig.message());
+    }
+}

src/core/port_scanner.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include "aliases.hpp"
+#include <boost/asio.hpp>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+class PortScanner
+{
+  public:
+    PortScanner(const std::string &ip, const std::vector<uint16_t> &ports);
+
+    void setTimeoutMs(int ms);
+
+    void run();
+
+  private:
+    bool probe(uint16_t port);
+    TcpEndpoint endpoint(uint16_t port) const;
+
+    void armTimer(SteadyTimer &t, TcpSocket &s);
+    void armConnect(TcpSocket &s, const TcpEndpoint &ep);
+    void runUntilDone();
+    void cancelTimer(SteadyTimer &t);
+    void drainLeftovers();
+    void close(TcpSocket &s);
+
+  private:
+    IoContext io_;
+    IpAddress addr_;
+    std::vector<uint16_t> ports_;
+
+    int timeout_ms_{300};
+    bool ip_ok_{false};
+    bool ok_{false};
+    bool done_{false};
+};

src/main.cpp

@@ -1,16 +1,38 @@
-#include <boost/asio.hpp>
-#include <iostream>
+#include "cli_base.hpp"
+#include "logger.hpp"
+#include "port_scanner.hpp"
+#include "portscan_cli.hpp"
 
-int main()
+#include <string>
+#include <vector>
+
+static std::vector<uint16_t> allPorts()
 {
-    std::cout << "Hello, Boost + C++23 + xmake!\n";
+    std::vector<uint16_t> v;
+    v.reserve(65535);
+    for (uint32_t p = 1; p <= 65535; ++p) {
+        v.push_back(static_cast<uint16_t>(p));
+    }
+    return v;
+}
 
-    boost::asio::io_context io;
-    boost::asio::steady_timer timer(io, std::chrono::seconds(1));
-    timer.async_wait([](const boost::system::error_code &) {
-        std::cout << "Timer fired after 1 second!\n";
-    });
+int main(int argc, char **argv)
+{
+    Logger::init(true);
 
-    io.run();
+    PortScanCli cli;
+    cli.parse(argc, argv);
+    if (cli.isHelp()) {
+        cli.printHelp();
+        return 0;
+    }
+
+    const std::string ip = cli.getIp();
+    auto ports = allPorts();
+
+    Logger::info("Starting full port scan (1..65535)...");
+    PortScanner scanner(ip, ports);
+    scanner.run();
+    Logger::info("Scan completed.");
     return 0;
 }

xmake.lua

@@ -2,16 +2,18 @@ set_languages "c++23"
 
 add_rules("plugin.compile_commands.autoupdate", { outputdir = "." })
 
-add_requires("boost", {
-    system = true, -- sudo pacman -S boost
-
+add_requires("cmake::Boost", {
+    alias = "boost",
+    system = true,
     configs = {
-        all = false,
-        system = true, -- asio
+        components = { "program_options", "log" },
     },
 })
 
-target "app"
-set_kind "binary"
-add_files "src/*.cpp"
-add_links "boost_system"
+target "port_scanner"
+do
+    set_kind "binary"
+    add_files("src/main.cpp", "src/cli/*.cpp", "src/common/*.cpp", "src/core/*.cpp")
+    add_includedirs("src", "src/cli", "src/common", "src/core", { public = true })
+    add_packages "boost"
+end