address.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
 
namespace librats {
 
struct Address {
    std::string ip;
    uint16_t    port = 0;
 
    Address() = default;
    Address(std::string ip, uint16_t port) : ip(std::move(ip)), port(port) {}
 
    static std::optional<Address> parse(std::string_view text) {
        if (!text.empty() && text.front() == '[') {
            // Bracketed IPv6: [ip]:port
            const auto close = text.find(']');
            if (close == std::string_view::npos || close + 1 >= text.size() || text[close + 1] != ':')
                return std::nullopt;
            const auto host = text.substr(1, close - 1);
            if (host.empty()) return std::nullopt;
            const auto port = parse_port(text.substr(close + 2));
            if (!port) return std::nullopt;
            return Address{std::string(host), *port};
        }
        const auto colon = text.rfind(':');
        if (colon == std::string_view::npos || colon == 0 || colon + 1 == text.size())
            return std::nullopt;
        const auto host = text.substr(0, colon);
        // A bare IPv6 literal carries its own colons; without brackets the port is
        // ambiguous, so reject it rather than guess.
        if (host.find(':') != std::string_view::npos) return std::nullopt;
        const auto port = parse_port(text.substr(colon + 1));
        if (!port) return std::nullopt;
        return Address{std::string(host), *port};
    }
 
    std::string to_string() const {
        if (ip.find(':') != std::string::npos)
            return "[" + ip + "]:" + std::to_string(port);
        return ip + ":" + std::to_string(port);
    }
 
    bool operator==(const Address& o) const { return ip == o.ip && port == o.port; }
    bool operator!=(const Address& o) const { return !(*this == o); }
 
private:
    static std::optional<uint16_t> parse_port(std::string_view text) {
        if (text.empty()) return std::nullopt;
        unsigned long port = 0;
        for (char c : text) {
            if (c < '0' || c > '9') return std::nullopt;
            port = port * 10 + static_cast<unsigned>(c - '0');
            if (port > 65535) return std::nullopt;
        }
        if (port == 0) return std::nullopt;
        return static_cast<uint16_t>(port);
    }
};
 
} // namespace librats
 
namespace std {
template<>
struct hash<librats::Address> {
    std::size_t operator()(const librats::Address& a) const noexcept {
        return std::hash<std::string>{}(a.ip + ":" + std::to_string(a.port));
    }
};
} // namespace std