/*
* Copyright (c) 2013-2022, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/

#include <stdio.h>
#include <string.h>
#include "I2PEndian.h"
#include <fstream>
#include <boost/lexical_cast.hpp>
#include <boost/make_shared.hpp>

#if (BOOST_VERSION >= 105300)
#include <boost/atomic.hpp>
#endif

#include "version.h"
#include "util.h"
#include "Crypto.h"
#include "Base.h"
#include "Timestamp.h"
#include "Log.h"
#include "NetDb.hpp"
#include "RouterContext.h"
#include "RouterInfo.h"

namespace i2p {
    namespace data {
        RouterInfo::Buffer::Buffer(const uint8_t *buf, size_t len) {
            if (len > size()) len = size();
            memcpy(data(), buf, len);
        }

        RouterInfo::RouterInfo() : m_Buffer(nullptr) {
            m_Addresses = boost::make_shared<Addresses>(); // create empty list
        }

        RouterInfo::RouterInfo(const std::string &fullPath) :
                m_FamilyID(0), m_IsUpdated(false), m_IsUnreachable(false),
                m_SupportedTransports(0), m_ReachableTransports(0),
                m_Caps(0), m_Version(0) {
            m_Addresses = boost::make_shared<Addresses>(); // create empty list
            m_Buffer = NewBuffer(); // always RouterInfo's
            ReadFromFile(fullPath);
        }

        RouterInfo::RouterInfo(std::shared_ptr<Buffer> &&buf, size_t len) :
                m_FamilyID(0), m_IsUpdated(true), m_IsUnreachable(false),
                m_SupportedTransports(0), m_ReachableTransports(0),
                m_Caps(0), m_Version(0) {
            if (len <= MAX_RI_BUFFER_SIZE) {
                m_Addresses = boost::make_shared<Addresses>(); // create empty list
                m_Buffer = buf;
                m_BufferLen = len;
                ReadFromBuffer(true);
            } else {
                LogPrint(eLogError, "RouterInfo: Buffer is too long ", len, ". Ignored");
                m_Buffer = nullptr;
                m_IsUnreachable = true;
            }
        }

        RouterInfo::RouterInfo(const uint8_t *buf, size_t len) :
                RouterInfo(std::make_shared<Buffer>(buf, len), len) {
        }

        RouterInfo::~RouterInfo() {
        }

        void RouterInfo::Update(const uint8_t *buf, size_t len) {
            if (len > MAX_RI_BUFFER_SIZE) {
                LogPrint(eLogError, "RouterInfo: Buffer is too long ", len);
                m_IsUnreachable = true;
                return;
            }
            // verify signature since we have identity already
            int l = len - m_RouterIdentity->GetSignatureLen();
            if (m_RouterIdentity->Verify(buf, l, buf + l)) {
                // clean up
                m_IsUpdated = true;
                m_IsUnreachable = false;
                m_SupportedTransports = 0;
                m_ReachableTransports = 0;
                m_Caps = 0;
                // don't clean up m_Addresses, it will be replaced in ReadFromStream
                ClearProperties();
                // copy buffer
                UpdateBuffer(buf, len);
                // skip identity
                size_t identityLen = m_RouterIdentity->GetFullLen();
                // read new RI
                std::stringstream str(std::string ((char *)m_Buffer->data() + identityLen, m_BufferLen - identityLen));
                ReadFromStream(str);
                // don't delete buffer until saved to the file
            } else {
                LogPrint(eLogError, "RouterInfo: Signature verification failed");
                m_IsUnreachable = true;
            }
        }

        void RouterInfo::SetRouterIdentity(std::shared_ptr<const IdentityEx> identity) {
            m_RouterIdentity = identity;
            m_Timestamp = i2p::util::GetMillisecondsSinceEpoch();
        }

        bool RouterInfo::LoadFile(const std::string &fullPath) {
            std::ifstream s(fullPath, std::ifstream::binary);
            if (s.is_open()) {
                s.seekg(0, std::ios::end);
                m_BufferLen = s.tellg();
                if (m_BufferLen < 40 || m_BufferLen > MAX_RI_BUFFER_SIZE) {
                    LogPrint(eLogError, "RouterInfo: File", fullPath, " is malformed");
                    return false;
                }
                s.seekg(0, std::ios::beg);
                if (!m_Buffer)
                    m_Buffer = NewBuffer();
                s.read((char *) m_Buffer->data(), m_BufferLen);
            } else {
                LogPrint(eLogError, "RouterInfo: Can't open file ", fullPath);
                return false;
            }
            return true;
        }

        void RouterInfo::ReadFromFile(const std::string &fullPath) {
            if (LoadFile(fullPath))
                ReadFromBuffer(false);
            else
                m_IsUnreachable = true;
        }

        void RouterInfo::ReadFromBuffer(bool verifySignature) {
            if (!m_Buffer) {
                m_IsUnreachable = true;
                return;
            }
            m_RouterIdentity = std::make_shared<IdentityEx>(m_Buffer->data(), m_BufferLen);
            size_t identityLen = m_RouterIdentity->GetFullLen();
            if (identityLen >= m_BufferLen) {
                LogPrint(eLogError, "RouterInfo: Identity length ", identityLen, " exceeds buffer size ", m_BufferLen);
                m_IsUnreachable = true;
                return;
            }
            if (verifySignature) {
                // reject RSA signatures
                if (m_RouterIdentity->IsRSA()) {
                    LogPrint(eLogError, "RouterInfo: RSA signature type is not allowed");
                    m_IsUnreachable = true;
                    return;
                }
                // verify signature
                int l = m_BufferLen - m_RouterIdentity->GetSignatureLen();
                if (l < 0 ||
                    !m_RouterIdentity->Verify((uint8_t *) m_Buffer->data(), l, (uint8_t *) m_Buffer->data() + l)) {
                    LogPrint(eLogError, "RouterInfo: Signature verification failed");
                    m_IsUnreachable = true;
                    return;
                }
                m_RouterIdentity->DropVerifier();
            }
            // parse RI
            std::stringstream str;
            str.write((const char *) m_Buffer->data() + identityLen, m_BufferLen - identityLen);
            ReadFromStream(str);
            if (!str) {
                LogPrint(eLogError, "RouterInfo: Malformed message");
                m_IsUnreachable = true;
            }
        }

        void RouterInfo::ReadFromStream(std::istream &s) {
            if (!s) return;
            m_Caps = 0;
            s.read((char *) &m_Timestamp, sizeof(m_Timestamp));
            m_Timestamp = be64toh(m_Timestamp);
            // read addresses
            auto addresses = boost::make_shared<Addresses>();
            uint8_t numAddresses;
            s.read((char *) &numAddresses, sizeof(numAddresses));
            addresses->reserve(numAddresses);
            for (int i = 0; i < numAddresses; i++) {
                uint8_t supportedTransports = 0;
                auto address = std::make_shared<Address>();
                uint8_t cost; // ignore
                s.read((char *) &cost, sizeof(cost));
                s.read((char *) &address->date, sizeof(address->date));
                bool isHost = false, isIntroKey = false, isStaticKey = false, isV2 = false;
                Tag<32> iV2; // for 'i' field in SSU, TODO: remove later
                char transportStyle[6];
                ReadString(transportStyle, 6, s);
                if (!strncmp(transportStyle, "NTCP", 4)) // NTCP or NTCP2
                    address->transportStyle = eTransportNTCP;
                else if (!strncmp(transportStyle, "SSU", 3)) // SSU or SSU2
                {
                    address->transportStyle = (transportStyle[3] == '2') ? eTransportSSU2 : eTransportSSU;
                    address->ssu.reset(new SSUExt());
                    address->ssu->mtu = 0;
                } else
                    address->transportStyle = eTransportUnknown;
                address->caps = 0;
                address->port = 0;
                uint16_t size, r = 0;
                s.read((char *) &size, sizeof(size));
                if (!s) return;
                size = be16toh(size);
                if (address->transportStyle == eTransportUnknown) {
                    // skip unknown address
                    s.seekg(size, std::ios_base::cur);
                    if (s) continue; else return;
                }
                while (r < size) {
                    char key[255], value[255];
                    r += ReadString(key, 255, s);
                    s.seekg(1, std::ios_base::cur);
                    r++; // =
                    r += ReadString(value, 255, s);
                    s.seekg(1, std::ios_base::cur);
                    r++; // ;
                    if (!s) return;
                    if (!strcmp(key, "host")) {
                        boost::system::error_code ecode;
                        address->host = boost::asio::ip::address::from_string(value, ecode);
                        if (!ecode && !address->host.is_unspecified()) isHost = true;
                    } else if (!strcmp(key, "port"))
                        address->port = boost::lexical_cast<int>(value);
                    else if (!strcmp(key, "mtu")) {
                        if (address->ssu)
                            address->ssu->mtu = boost::lexical_cast<int>(value);
                        else
                            LogPrint(eLogWarning, "RouterInfo: Unexpected field 'mtu' for NTCP");
                    } else if (!strcmp(key, "key")) {
                        if (address->ssu)
                            isIntroKey = (Base64ToByteStream(value, strlen(value), address->i, 32) == 32);
                        else
                            LogPrint(eLogWarning, "RouterInfo: Unexpected field 'key' for NTCP");
                    } else if (!strcmp(key, "caps"))
                        address->caps = ExtractAddressCaps(value);
                    else if (!strcmp(key, "s")) // ntcp2 or ssu2 static key
                    {
                        Base64ToByteStream(value, strlen(value), address->s, 32);
                        isStaticKey = true;
                    } else if (!strcmp(key, "i")) // ntcp2 iv or ssu2 intro
                    {
                        if (address->IsNTCP2()) {
                            Base64ToByteStream(value, strlen(value), address->i, 16);
                            address->published = true; // presence of "i" means "published" NTCP2
                        } else if (address->IsSSU2())
                            Base64ToByteStream(value, strlen(value), address->i, 32);
                        else
                            Base64ToByteStream(value, strlen(value), iV2, 32);
                    } else if (!strcmp(key, "v")) {
                        if (!strcmp(value, "2"))
                            isV2 = true;
                        else
                            LogPrint(eLogWarning, "RouterInfo: Unexpected value ", value, " for v");
                    } else if (key[0] == 'i') {
                        // introducers
                        if (!address->ssu) {
                            LogPrint(eLogError, "RouterInfo: Introducer is presented for non-SSU address. Skipped");
                            continue;
                        }
                        size_t l = strlen(key);
                        unsigned char index = key[l - 1] - '0'; // TODO:
                        key[l - 1] = 0;
                        if (index > 9) {
                            LogPrint(eLogError, "RouterInfo: Unexpected introducer's index ", index, " skipped");
                            if (s) continue; else return;
                        }
                        if (index >= address->ssu->introducers.size()) {
                            if (address->ssu->introducers.empty()) // first time
                                address->ssu->introducers.reserve(3);
                            address->ssu->introducers.resize(index + 1);
                        }
                        Introducer &introducer = address->ssu->introducers.at(index);
                        if (!strcmp(key, "ihost")) {
                            boost::system::error_code ecode;
                            introducer.iHost = boost::asio::ip::address::from_string(value, ecode);
                        } else if (!strcmp(key, "iport"))
                            introducer.iPort = boost::lexical_cast<int>(value);
                        else if (!strcmp(key, "itag"))
                            introducer.iTag = boost::lexical_cast<uint32_t>(value);
                        else if (!strcmp(key, "ikey") || !strcmp(key, "ih"))
                            Base64ToByteStream(value, strlen(value), introducer.iKey, 32);
                        else if (!strcmp(key, "iexp"))
                            introducer.iExp = boost::lexical_cast<uint32_t>(value);
                    }
                    if (!s) return;
                }
                if (address->transportStyle == eTransportNTCP) {
                    if (isStaticKey) {
                        if (isHost) {
                            if (address->host.is_v6())
                                supportedTransports |= (i2p::util::net::IsYggdrasilAddress(address->host) ? eNTCP2V6Mesh
                                                                                                          : eNTCP2V6);
                            else
                                supportedTransports |= eNTCP2V4;
                            m_ReachableTransports |= supportedTransports;
                        } else if (!address->published) {
                            if (address->caps) {
                                if (address->caps & AddressCaps::eV4) supportedTransports |= eNTCP2V4;
                                if (address->caps & AddressCaps::eV6) supportedTransports |= eNTCP2V6;
                            } else
                                supportedTransports |= eNTCP2V4; // most likely, since we don't have host
                        }
                    }
                } else if (address->transportStyle == eTransportSSU) {
                    if (isIntroKey) {
                        if (isHost)
                            supportedTransports |= address->host.is_v4() ? eSSUV4 : eSSUV6;
                        else if (address->caps & AddressCaps::eV6) {
                            supportedTransports |= eSSUV6;
                            if (address->caps & AddressCaps::eV4) supportedTransports |= eSSUV4; // in additional to v6
                        } else
                            supportedTransports |= eSSUV4; // in case if host or 6 caps is not preasented, we assume 4
                        if (address->ssu && !address->ssu->introducers.empty()) {
                            // exclude invalid introducers
                            uint32_t ts = i2p::util::GetSecondsSinceEpoch();
                            int numValid = 0;
                            for (auto &it: address->ssu->introducers) {
                                if (!it.iExp) it.iExp = m_Timestamp / 1000 + NETDB_INTRODUCEE_EXPIRATION_TIMEOUT;
                                if (ts <= it.iExp && it.iPort > 0 &&
                                    ((it.iHost.is_v4() && address->IsV4()) || (it.iHost.is_v6() && address->IsV6())))
                                    numValid++;
                                else {
                                    it.iPort = 0;
                                    if (isV2) numValid++;
                                }
                            }
                            if (numValid)
                                m_ReachableTransports |= supportedTransports;
                            else
                                address->ssu->introducers.resize(0);
                        } else if (isHost && address->port) {
                            address->published = true;
                            m_ReachableTransports |= supportedTransports;
                        }
                    }
                }
                if (address->transportStyle == eTransportSSU2 || (isV2 && address->transportStyle == eTransportSSU)) {
                    if (address->IsV4()) supportedTransports |= eSSU2V4;
                    if (address->IsV6()) supportedTransports |= eSSU2V6;
                    if (address->port) {
                        if (address->host.is_v4()) m_ReachableTransports |= eSSU2V4;
                        if (address->host.is_v6()) m_ReachableTransports |= eSSU2V6;
                    }
                    if (address->transportStyle == eTransportSSU2) {
                        if (address->port) address->published = true;
                        if (address->ssu && !address->ssu->introducers.empty()) {
                            // exclude invalid introducers
                            uint32_t ts = i2p::util::GetSecondsSinceEpoch();
                            int numValid = 0;
                            for (auto &it: address->ssu->introducers) {
                                if (it.iTag && ts <= it.iExp)
                                    numValid++;
                                else
                                    it.iTag = 0;
                            }
                            if (numValid)
                                m_ReachableTransports |= supportedTransports;
                            else
                                address->ssu->introducers.resize(0);
                        }
                    } else {
                        // create additional SSU2 address. TODO: remove later
                        auto ssu2addr = std::make_shared<Address>();
                        ssu2addr->transportStyle = eTransportSSU2;
                        ssu2addr->host = address->host;
                        ssu2addr->port = address->port;
                        ssu2addr->s = address->s;
                        ssu2addr->i = iV2;
                        ssu2addr->date = address->date;
                        ssu2addr->caps = address->caps;
                        ssu2addr->published = address->published;
                        ssu2addr->ssu.reset(new SSUExt());
                        ssu2addr->ssu->mtu = address->ssu->mtu;
                        uint32_t ts = i2p::util::GetSecondsSinceEpoch();
                        if (!address->ssu->introducers.empty()) {
                            for (const auto &introducer: address->ssu->introducers)
                                if (!introducer.iPort && introducer.iHost.is_unspecified() &&
                                    ts < introducer.iExp) // SSU2
                                    ssu2addr->ssu->introducers.push_back(introducer);
                            if (!ssu2addr->ssu->introducers.empty())
                                m_ReachableTransports |= supportedTransports;
                        }
                        addresses->push_back(ssu2addr);
                    }
                }
                if (supportedTransports) {
                    if (!(m_SupportedTransports & supportedTransports)) // avoid duplicates
                        addresses->push_back(address);
                    m_SupportedTransports |= supportedTransports;
                }
            }
#if (BOOST_VERSION >= 105300)
            boost::atomic_store (&m_Addresses, addresses);
#else
            m_Addresses = addresses; // race condition
#endif
            // read peers
            uint8_t numPeers;
            s.read((char *) &numPeers, sizeof(numPeers));
            if (!s) return;
            s.seekg(numPeers * 32, std::ios_base::cur); // TODO: read peers
            // read properties
            m_Version = 0;
            bool isNetId = false;
            std::string family;
            uint16_t size, r = 0;
            s.read((char *) &size, sizeof(size));
            if (!s) return;
            size = be16toh(size);
            while (r < size) {
                char key[255], value[255];
                r += ReadString(key, 255, s);
                s.seekg(1, std::ios_base::cur);
                r++; // =
                r += ReadString(value, 255, s);
                s.seekg(1, std::ios_base::cur);
                r++; // ;
                if (!s) return;
                SetProperty(key, value);

                // extract caps
                if (!strcmp(key, "caps"))
                    ExtractCaps(value);
                    // extract version
                else if (!strcmp(key, ROUTER_INFO_PROPERTY_VERSION)) {
                    m_Version = 0;
                    char *ch = value;
                    while (*ch) {
                        if (*ch >= '0' && *ch <= '9') {
                            m_Version *= 10;
                            m_Version += (*ch - '0');
                        }
                        ch++;
                    }
                }
                    // check netId
                else if (!strcmp(key, ROUTER_INFO_PROPERTY_NETID)) {
                    isNetId = true;
                    if (atoi(value) != i2p::context.GetNetID()) {
                        LogPrint(eLogError, "RouterInfo: Unexpected ", ROUTER_INFO_PROPERTY_NETID, "=", value);
                        m_IsUnreachable = true;
                    }
                }
                    // family
                else if (!strcmp(key, ROUTER_INFO_PROPERTY_FAMILY)) {
                    family = value;
                    boost::to_lower(family);
                } else if (!strcmp(key, ROUTER_INFO_PROPERTY_FAMILY_SIG)) {
                    if (netdb.GetFamilies().VerifyFamily(family, GetIdentHash(), value))
                        m_FamilyID = netdb.GetFamilies().GetFamilyID(family);
                    else
                        LogPrint(eLogWarning, "RouterInfo: Family ", family, " signature verification failed");
                }

                if (!s) return;
            }

            if (!m_SupportedTransports || !isNetId || !m_Version)
                SetUnreachable(true);
        }

        bool RouterInfo::IsFamily(FamilyID famid) const {
            return m_FamilyID == famid;
        }

        void RouterInfo::ExtractCaps(const char *value) {
            const char *cap = value;
            while (*cap) {
                switch (*cap) {
                    case CAPS_FLAG_FLOODFILL:
                        m_Caps |= Caps::eFloodfill;
                        break;
                    case CAPS_FLAG_HIGH_BANDWIDTH1:
                    case CAPS_FLAG_HIGH_BANDWIDTH2:
                    case CAPS_FLAG_HIGH_BANDWIDTH3:
                        m_Caps |= Caps::eHighBandwidth;
                        break;
                    case CAPS_FLAG_EXTRA_BANDWIDTH1:
                    case CAPS_FLAG_EXTRA_BANDWIDTH2:
                        m_Caps |= Caps::eExtraBandwidth | Caps::eHighBandwidth;
                        break;
                    case CAPS_FLAG_HIDDEN:
                        m_Caps |= Caps::eHidden;
                        break;
                    case CAPS_FLAG_REACHABLE:
                        m_Caps |= Caps::eReachable;
                        break;
                    case CAPS_FLAG_UNREACHABLE:
                        m_Caps |= Caps::eUnreachable;
                        break;
                    default:;
                }
                cap++;
            }
        }

        uint8_t RouterInfo::ExtractAddressCaps(const char *value) const {
            uint8_t caps = 0;
            const char *cap = value;
            while (*cap) {
                switch (*cap) {
                    case CAPS_FLAG_V4:
                        caps |= AddressCaps::eV4;
                        break;
                    case CAPS_FLAG_V6:
                        caps |= AddressCaps::eV6;
                        break;
                    case CAPS_FLAG_SSU_TESTING:
                        caps |= AddressCaps::eSSUTesting;
                        break;
                    case CAPS_FLAG_SSU_INTRODUCER:
                        caps |= AddressCaps::eSSUIntroducer;
                        break;
                    default:;
                }
                cap++;
            }
            return caps;
        }

        bool RouterInfo::IsNewer(const uint8_t *buf, size_t len) const {
            if (!m_RouterIdentity) return false;
            size_t size = m_RouterIdentity->GetFullLen();
            if (size + 8 > len) return false;
            return bufbe64toh(buf + size) > m_Timestamp;
        }

        const uint8_t *RouterInfo::LoadBuffer(const std::string &fullPath) {
            if (!m_Buffer) {
                if (LoadFile(fullPath))
                    LogPrint(eLogDebug, "RouterInfo: Buffer for ", GetIdentHashAbbreviation(GetIdentHash()),
                             " loaded from file");
            }
            return m_Buffer->data();
        }

        bool RouterInfo::SaveToFile(const std::string &fullPath) {
            if (!m_Buffer) {
                LogPrint(eLogError, "RouterInfo: Can't save, m_Buffer == NULL");
                return false;
            }
            std::ofstream f(fullPath, std::ofstream::binary | std::ofstream::out);
            if (!f.is_open()) {
                LogPrint(eLogError, "RouterInfo: Can't save to ", fullPath);
                return false;
            }
            f.write((char *) m_Buffer->data(), m_BufferLen);
            return true;
        }

        size_t RouterInfo::ReadString(char *str, size_t len, std::istream &s) const {
            uint8_t l;
            s.read((char *) &l, 1);
            if (l < len) {
                s.read(str, l);
                if (!s) l = 0; // failed, return empty string
                str[l] = 0;
            } else {
                LogPrint(eLogWarning, "RouterInfo: String length ", (int) l, " exceeds buffer size ", len);
                s.seekg(l, std::ios::cur); // skip
                str[0] = 0;
            }
            return l + 1;
        }


        void RouterInfo::AddSSUAddress(const char *host, int port, const uint8_t *key, int mtu) {
            auto addr = std::make_shared<Address>();
            addr->host = boost::asio::ip::address::from_string(host);
            addr->port = port;
            addr->transportStyle = eTransportSSU;
            addr->published = true;
            addr->caps = i2p::data::RouterInfo::eSSUTesting | i2p::data::RouterInfo::eSSUIntroducer; // BC;
            addr->date = 0;
            addr->ssu.reset(new SSUExt());
            addr->ssu->mtu = mtu;
            if (key)
                memcpy(addr->i, key, 32);
            else
                RAND_bytes(addr->i, 32);
            for (const auto &it: *m_Addresses) // don't insert same address twice
                if (*it == *addr) return;
            m_SupportedTransports |= addr->host.is_v6() ? eSSUV6 : eSSUV4;
            m_ReachableTransports |= addr->host.is_v6() ? eSSUV6 : eSSUV4;
            m_Addresses->push_back(std::move(addr));
        }

        void RouterInfo::AddNTCP2Address(const uint8_t *staticKey, const uint8_t *iv,
                                         const boost::asio::ip::address &host, int port, uint8_t caps) {
            auto addr = std::make_shared<Address>();
            addr->host = host;
            addr->port = port;
            addr->transportStyle = eTransportNTCP;
            addr->caps = caps;
            addr->date = 0;
            if (port) addr->published = true;
            memcpy(addr->s, staticKey, 32);
            memcpy(addr->i, iv, 16);
            if (addr->IsV4()) {
                m_SupportedTransports |= eNTCP2V4;
                if (addr->published) m_ReachableTransports |= eNTCP2V4;
            }
            if (addr->IsV6()) {
                m_SupportedTransports |= eNTCP2V6;
                if (addr->published) m_ReachableTransports |= eNTCP2V6;
            }
            m_Addresses->push_back(std::move(addr));
        }

        void RouterInfo::AddSSU2Address(const uint8_t *staticKey, const uint8_t *introKey, uint8_t caps) {
            auto addr = std::make_shared<Address>();
            addr->transportStyle = eTransportSSU2;
            addr->port = 0;
            addr->caps = caps;
            addr->date = 0;
            addr->ssu.reset(new SSUExt());
            addr->ssu->mtu = 0;
            memcpy(addr->s, staticKey, 32);
            memcpy(addr->i, introKey, 32);
            if (addr->IsV4()) m_SupportedTransports |= eSSU2V4;
            if (addr->IsV6()) m_SupportedTransports |= eSSU2V6;
            m_Addresses->push_back(std::move(addr));
        }

        void RouterInfo::AddSSU2Address(const uint8_t *staticKey, const uint8_t *introKey,
                                        const boost::asio::ip::address &host, int port) {
            auto addr = std::make_shared<Address>();
            addr->transportStyle = eTransportSSU2;
            addr->host = host;
            addr->port = port;
            addr->published = true;
            addr->caps = i2p::data::RouterInfo::eSSUTesting | i2p::data::RouterInfo::eSSUIntroducer; // BC;
            addr->date = 0;
            addr->ssu.reset(new SSUExt());
            addr->ssu->mtu = 0;
            memcpy(addr->s, staticKey, 32);
            memcpy(addr->i, introKey, 32);
            if (addr->IsV4()) {
                m_SupportedTransports |= eSSU2V4;
                m_ReachableTransports |= eSSU2V4;
            }
            if (addr->IsV6()) {
                m_SupportedTransports |= eSSU2V6;
                m_ReachableTransports |= eSSU2V6;
            }
            m_Addresses->push_back(std::move(addr));
        }

        bool RouterInfo::AddIntroducer(const Introducer &introducer) {
            for (auto &addr: *m_Addresses) {
                if (addr->transportStyle == eTransportSSU &&
                    ((addr->IsV4() && introducer.iHost.is_v4()) || (addr->IsV6() && introducer.iHost.is_v6()))) {
                    for (auto &intro: addr->ssu->introducers)
                        if (intro.iTag == introducer.iTag) return false; // already presented
                    addr->ssu->introducers.push_back(introducer);
                    m_ReachableTransports |= (addr->IsV4() ? eSSUV4 : eSSUV6);
                    return true;
                }
            }
            return false;
        }

        bool RouterInfo::RemoveIntroducer(const boost::asio::ip::udp::endpoint &e) {
            for (auto &addr: *m_Addresses) {
                if (addr->transportStyle == eTransportSSU &&
                    ((addr->IsV4() && e.address().is_v4()) || (addr->IsV6() && e.address().is_v6()))) {
                    for (auto it = addr->ssu->introducers.begin(); it != addr->ssu->introducers.end(); ++it)
                        if (boost::asio::ip::udp::endpoint(it->iHost, it->iPort) == e) {
                            addr->ssu->introducers.erase(it);
                            if (addr->ssu->introducers.empty())
                                m_ReachableTransports &= ~(addr->IsV4() ? eSSUV4 : eSSUV6);
                            return true;
                        }
                }
            }
            return false;
        }

        bool RouterInfo::IsSSU(bool v4only) const {
            if (v4only)
                return m_SupportedTransports & eSSUV4;
            else
                return m_SupportedTransports & (eSSUV4 | eSSUV6);
        }

        bool RouterInfo::IsNTCP2(bool v4only) const {
            if (v4only)
                return m_SupportedTransports & eNTCP2V4;
            else
                return m_SupportedTransports & (eNTCP2V4 | eNTCP2V6);
        }


        void RouterInfo::EnableV6() {
            if (!IsV6()) {
                uint8_t addressCaps = AddressCaps::eV6;
                if (IsV4()) addressCaps |= AddressCaps::eV4;
                SetUnreachableAddressesTransportCaps(addressCaps);
                UpdateSupportedTransports();
            }
        }

        void RouterInfo::EnableV4() {
            if (!IsV4()) {
                uint8_t addressCaps = AddressCaps::eV4;
                if (IsV6()) addressCaps |= AddressCaps::eV6;
                SetUnreachableAddressesTransportCaps(addressCaps);
                UpdateSupportedTransports();
            }
        }


        void RouterInfo::DisableV6() {
            if (IsV6()) {
                for (auto it = m_Addresses->begin(); it != m_Addresses->end();) {
                    auto addr = *it;
                    if (addr->IsV6()) {
                        if (addr->IsV4()) {
                            addr->caps &= ~AddressCaps::eV6;
                            ++it;
                        } else
                            it = m_Addresses->erase(it);
                    } else
                        ++it;
                }
                UpdateSupportedTransports();
            }
        }

        void RouterInfo::DisableV4() {
            if (IsV4()) {
                for (auto it = m_Addresses->begin(); it != m_Addresses->end();) {
                    auto addr = *it;
                    if (addr->IsV4()) {
                        if (addr->IsV6()) {
                            addr->caps &= ~AddressCaps::eV4;
                            ++it;
                        } else
                            it = m_Addresses->erase(it);
                    } else
                        ++it;
                }
                UpdateSupportedTransports();
            }
        }

        void RouterInfo::EnableMesh() {
            if (!IsMesh()) {
                m_SupportedTransports |= eNTCP2V6Mesh;
                m_ReachableTransports |= eNTCP2V6Mesh;
            }
        }

        void RouterInfo::DisableMesh() {
            if (IsMesh()) {
                m_SupportedTransports &= ~eNTCP2V6Mesh;
                m_ReachableTransports &= ~eNTCP2V6Mesh;
                for (auto it = m_Addresses->begin(); it != m_Addresses->end();) {
                    auto addr = *it;
                    if (i2p::util::net::IsYggdrasilAddress(addr->host))
                        it = m_Addresses->erase(it);
                    else
                        ++it;
                }
            }
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSUAddress(bool v4only) const {
            return GetAddress(
                    [v4only](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU) && (!v4only || address->IsV4());
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSUV6Address() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU) && address->IsV6();
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSU2V4Address() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU2) && address->IsV4();
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSU2V6Address() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU2) && address->IsV6();
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSU2Address(bool v4) const {
            if (v4) {
                if (m_SupportedTransports & eSSU2V4)
                    return GetSSU2V4Address();
            } else {
                if (m_SupportedTransports & eSSU2V6)
                    return GetSSU2V6Address();
            }
            return nullptr;
        }

        template<typename Filter>
        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetAddress(Filter filter) const {
            // TODO: make it more generic using comparator
#if (BOOST_VERSION >= 105300)
            auto addresses = boost::atomic_load (&m_Addresses);
#else
            auto addresses = m_Addresses;
#endif
            for (const auto &address: *addresses)
                if (filter(address)) return address;

            return nullptr;
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetNTCP2AddressWithStaticKey(const uint8_t *key) const {
            if (!key) return nullptr;
            return GetAddress(
                    [key](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return address->IsNTCP2() && !memcmp(address->s, key, 32);
                    });
        }

        std::shared_ptr<const RouterInfo::Address>
        RouterInfo::GetSSU2AddressWithStaticKey(const uint8_t *key, bool isV6) const {
            if (!key) return nullptr;
            return GetAddress(
                    [key, isV6](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return address->IsSSU2() && !memcmp(address->s, key, 32) &&
                               ((isV6 && address->IsV6()) || (!isV6 && address->IsV4()));
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetPublishedNTCP2V4Address() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return address->IsPublishedNTCP2() && address->host.is_v4();
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetPublishedNTCP2V6Address() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return address->IsPublishedNTCP2() && address->host.is_v6() &&
                               !i2p::util::net::IsYggdrasilAddress(address->host);
                    });
        }

        std::shared_ptr<const RouterInfo::Address> RouterInfo::GetYggdrasilAddress() const {
            return GetAddress(
                    [](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return address->IsPublishedNTCP2() && i2p::util::net::IsYggdrasilAddress(address->host);
                    });
        }

        std::shared_ptr<RouterProfile> RouterInfo::GetProfile() const {
            if (!m_Profile)
                m_Profile = GetRouterProfile(GetIdentHash());
            return m_Profile;
        }

        void RouterInfo::Encrypt(const uint8_t *data, uint8_t *encrypted) const {
            auto encryptor = m_RouterIdentity->CreateEncryptor(nullptr);
            if (encryptor)
                encryptor->Encrypt(data, encrypted);
        }

        bool RouterInfo::IsEligibleFloodfill() const {
            // floodfill must be reachable by ipv4, >= 0.9.38 and not DSA
            return IsReachableBy(eNTCP2V4 | eSSUV4) && m_Version >= NETDB_MIN_FLOODFILL_VERSION &&
                   GetIdentity()->GetSigningKeyType() != SIGNING_KEY_TYPE_DSA_SHA1;
        }

        bool RouterInfo::IsPeerTesting(bool v4) const {
            if (!(m_SupportedTransports & (v4 ? eSSUV4 : eSSUV6))) return false;
            return (bool) GetAddress(
                    [v4](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU) && address->IsPeerTesting() &&
                               ((v4 && address->IsV4()) || (!v4 && address->IsV6())) && address->IsReachableSSU();
                    });
        }

        bool RouterInfo::IsSSU2PeerTesting(bool v4) const {
            if (!(m_SupportedTransports & (v4 ? eSSU2V4 : eSSU2V6))) return false;
            return (bool) GetAddress(
                    [v4](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->IsSSU2()) && address->IsPeerTesting() &&
                               ((v4 && address->IsV4()) || (!v4 && address->IsV6())) && address->IsReachableSSU();
                    });
        }

        bool RouterInfo::IsIntroducer(bool v4) const {
            if (!(m_SupportedTransports & (v4 ? eSSUV4 : eSSUV6))) return false;
            return (bool) GetAddress(
                    [v4](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->transportStyle == eTransportSSU) && address->IsIntroducer() &&
                               ((v4 && address->IsV4()) || (!v4 && address->IsV6())) && !address->host.is_unspecified();
                    });
        }

        bool RouterInfo::IsSSU2Introducer(bool v4) const {
            if (!(m_SupportedTransports & (v4 ? eSSU2V4 : eSSU2V6))) return false;
            return (bool) GetAddress(
                    [v4](std::shared_ptr<const RouterInfo::Address> address) -> bool {
                        return (address->IsSSU2()) && address->IsIntroducer() &&
                               ((v4 && address->IsV4()) || (!v4 && address->IsV6())) && !address->host.is_unspecified();
                    });
        }

        void RouterInfo::SetUnreachableAddressesTransportCaps(uint8_t transports) {
            for (auto &addr: *m_Addresses) {
                // TODO: implement SSU
                if (!addr->published &&
                    (addr->transportStyle == eTransportNTCP || addr->transportStyle == eTransportSSU2)) {
                    addr->caps &= ~(eV4 | eV6);
                    addr->caps |= transports;
                }
            }
        }

        void RouterInfo::UpdateSupportedTransports() {
            m_SupportedTransports = 0;
            m_ReachableTransports = 0;
            for (const auto &addr: *m_Addresses) {
                uint8_t transports = 0;
                switch (addr->transportStyle) {
                    case eTransportNTCP:
                        if (addr->IsV4()) transports |= eNTCP2V4;
                        if (addr->IsV6())
                            transports |= (i2p::util::net::IsYggdrasilAddress(addr->host) ? eNTCP2V6Mesh : eNTCP2V6);
                        if (addr->IsPublishedNTCP2())
                            m_ReachableTransports |= transports;
                        break;
                    case eTransportSSU:
                        if (addr->IsV4()) transports |= eSSUV4;
                        if (addr->IsV6()) transports |= eSSUV6;
                        if (addr->IsReachableSSU())
                            m_ReachableTransports |= transports;
                        break;
                    case eTransportSSU2:
                        if (addr->IsV4()) transports |= eSSU2V4;
                        if (addr->IsV6()) transports |= eSSU2V6;
                        if (addr->IsReachableSSU())
                            m_ReachableTransports |= transports;
                        break;
                    default:;
                }
                m_SupportedTransports |= transports;
            }
        }

        void RouterInfo::UpdateBuffer(const uint8_t *buf, size_t len) {
            if (!m_Buffer)
                m_Buffer = NewBuffer();
            if (len > m_Buffer->size()) len = m_Buffer->size();
            memcpy(m_Buffer->data(), buf, len);
            m_BufferLen = len;
        }

        std::shared_ptr<RouterInfo::Buffer> RouterInfo::NewBuffer() const {
            return netdb.NewRouterInfoBuffer();
        }

        void RouterInfo::RefreshTimestamp() {
            m_Timestamp = i2p::util::GetMillisecondsSinceEpoch();
        }

        void LocalRouterInfo::CreateBuffer(const PrivateKeys &privateKeys) {
            RefreshTimestamp();
            std::stringstream s;
            uint8_t ident[1024];
            auto identLen = privateKeys.GetPublic()->ToBuffer(ident, 1024);
            auto signatureLen = privateKeys.GetPublic()->GetSignatureLen();
            s.write((char *) ident, identLen);
            WriteToStream(s);
            size_t len = s.str().size();
            if (len + signatureLen < MAX_RI_BUFFER_SIZE) {
                UpdateBuffer((const uint8_t *) s.str().c_str(), len);
                // signature
                privateKeys.Sign(GetBuffer(), len, GetBufferPointer(len));
                SetBufferLen(len + signatureLen);
            } else
                LogPrint(eLogError, "RouterInfo: Our RouterInfo is too long ", len + signatureLen);
        }

        void LocalRouterInfo::UpdateCaps(uint8_t caps) {
            SetCaps(caps);
            UpdateCapsProperty();
        }

        void LocalRouterInfo::UpdateCapsProperty() {
            std::string caps;
            uint8_t c = GetCaps();
            if (c & eFloodfill) {
                if (c & eExtraBandwidth)
                    caps += (c & eHighBandwidth) ?
                            CAPS_FLAG_EXTRA_BANDWIDTH2 : // 'X'
                            CAPS_FLAG_EXTRA_BANDWIDTH1; // 'P'
                else
                    caps += CAPS_FLAG_HIGH_BANDWIDTH3; // 'O'
                caps += CAPS_FLAG_FLOODFILL; // floodfill
            } else {
                if (c & eExtraBandwidth)
                    caps += (c & eHighBandwidth) ? CAPS_FLAG_EXTRA_BANDWIDTH2 /* 'X' */
                                                 : CAPS_FLAG_EXTRA_BANDWIDTH1; /*'P' */
                else
                    caps += (c & eHighBandwidth) ? CAPS_FLAG_HIGH_BANDWIDTH3 /* 'O' */
                                                 : CAPS_FLAG_LOW_BANDWIDTH2 /* 'L' */; // bandwidth
            }
            if (c & eHidden) caps += CAPS_FLAG_HIDDEN; // hidden
            if (c & eReachable) caps += CAPS_FLAG_REACHABLE; // reachable
            if (c & eUnreachable) caps += CAPS_FLAG_UNREACHABLE; // unreachable

            SetProperty("caps", caps);
        }

        void LocalRouterInfo::WriteToStream(std::ostream &s) const {
            uint64_t ts = htobe64(GetTimestamp());
            s.write((const char *) &ts, sizeof(ts));

            // addresses
            const Addresses &addresses = GetAddresses();
            uint8_t numAddresses = addresses.size();
            s.write((char *) &numAddresses, sizeof(numAddresses));
            for (const auto &addr_ptr: addresses) {
                const Address &address = *addr_ptr;
                // calculate cost
                uint8_t cost = 0x7f;
                if (address.transportStyle == eTransportNTCP)
                    cost = address.published ? COST_NTCP2_PUBLISHED : COST_NTCP2_NON_PUBLISHED;
                else if (address.transportStyle == eTransportSSU)
                    cost = address.published ? COST_SSU_DIRECT : COST_SSU_THROUGH_INTRODUCERS;
                else if (address.transportStyle == eTransportSSU2)
                    cost = address.published ? COST_SSU2_DIRECT : COST_SSU2_NON_PUBLISHED;
                s.write((const char *) &cost, sizeof(cost));
                s.write((const char *) &address.date, sizeof(address.date));
                std::stringstream properties;
                bool isPublished = false;
                if (address.transportStyle == eTransportNTCP) {
                    if (address.IsNTCP2()) {
                        WriteString("NTCP2", s);
                        if (address.IsPublishedNTCP2() && !address.host.is_unspecified() && address.port)
                            isPublished = true;
                        else {
                            WriteString("caps", properties);
                            properties << '=';
                            std::string caps;
                            if (address.IsV4()) caps += CAPS_FLAG_V4;
                            if (address.IsV6()) caps += CAPS_FLAG_V6;
                            if (caps.empty()) caps += CAPS_FLAG_V4;
                            WriteString(caps, properties);
                            properties << ';';
                        }
                    } else
                        continue; // don't write NTCP address
                } else if (address.transportStyle == eTransportSSU) {
                    WriteString("SSU", s);
                    // caps
                    WriteString("caps", properties);
                    properties << '=';
                    std::string caps;
                    if (address.IsPeerTesting()) caps += CAPS_FLAG_SSU_TESTING;
                    if (address.host.is_v4()) {
                        if (address.published) {
                            isPublished = true;
                            if (address.IsIntroducer()) caps += CAPS_FLAG_SSU_INTRODUCER;
                        } else
                            caps += CAPS_FLAG_V4;
                    } else if (address.host.is_v6()) {
                        if (address.published) {
                            isPublished = true;
                            if (address.IsIntroducer()) caps += CAPS_FLAG_SSU_INTRODUCER;
                        } else
                            caps += CAPS_FLAG_V6;
                    } else {
                        if (address.IsV4()) caps += CAPS_FLAG_V4;
                        if (address.IsV6()) caps += CAPS_FLAG_V6;
                        if (caps.empty()) caps += CAPS_FLAG_V4;
                    }
                    WriteString(caps, properties);
                    properties << ';';
                } else if (address.transportStyle == eTransportSSU2) {
                    WriteString("SSU2", s);
                    // caps
                    std::string caps;
                    if (address.published) {
                        isPublished = true;
                        if (address.IsPeerTesting()) caps += CAPS_FLAG_SSU_TESTING;
                        if (address.IsIntroducer()) caps += CAPS_FLAG_SSU_INTRODUCER;
                    } else {
                        if (address.IsV4()) caps += CAPS_FLAG_V4;
                        if (address.IsV6()) caps += CAPS_FLAG_V6;
                        if (caps.empty()) caps += CAPS_FLAG_V4;
                    }
                    if (!caps.empty()) {
                        WriteString("caps", properties);
                        properties << '=';
                        WriteString(caps, properties);
                        properties << ';';
                    }
                } else
                    WriteString("", s);

                if (isPublished && !address.host.is_unspecified()) {
                    WriteString("host", properties);
                    properties << '=';
                    WriteString(address.host.to_string(), properties);
                    properties << ';';
                }
                if ((address.IsNTCP2() && isPublished) || address.IsSSU2()) {
                    // publish i for NTCP2 or SSU2
                    WriteString("i", properties);
                    properties << '=';
                    size_t len = address.IsSSU2() ? 32 : 16;
                    WriteString(address.i.ToBase64(len), properties);
                    properties << ';';
                }
                if (address.transportStyle == eTransportSSU || address.IsSSU2()) {
                    // write introducers if any
                    if (address.ssu && !address.ssu->introducers.empty()) {
                        int i = 0;
                        for (const auto &introducer: address.ssu->introducers) {
                            if (introducer.iExp) // expiration is specified
                            {
                                WriteString("iexp" + boost::lexical_cast<std::string>(i), properties);
                                properties << '=';
                                WriteString(boost::lexical_cast<std::string>(introducer.iExp), properties);
                                properties << ';';
                            }
                            i++;
                        }
                        if (address.transportStyle == eTransportSSU) {
                            i = 0;
                            for (const auto &introducer: address.ssu->introducers) {
                                WriteString("ihost" + boost::lexical_cast<std::string>(i), properties);
                                properties << '=';
                                WriteString(introducer.iHost.to_string(), properties);
                                properties << ';';
                                i++;
                            }
                        }
                        i = 0;
                        for (const auto &introducer: address.ssu->introducers) {
                            if (address.IsSSU2())
                                WriteString("ih" + boost::lexical_cast<std::string>(i), properties);
                            else
                                WriteString("ikey" + boost::lexical_cast<std::string>(i), properties);
                            properties << '=';
                            char value[64];
                            size_t l = ByteStreamToBase64(introducer.iKey, 32, value, 64);
                            value[l] = 0;
                            WriteString(value, properties);
                            properties << ';';
                            i++;
                        }
                        if (address.transportStyle == eTransportSSU) {
                            i = 0;
                            for (const auto &introducer: address.ssu->introducers) {
                                WriteString("iport" + boost::lexical_cast<std::string>(i), properties);
                                properties << '=';
                                WriteString(boost::lexical_cast<std::string>(introducer.iPort), properties);
                                properties << ';';
                                i++;
                            }
                        }
                        i = 0;
                        for (const auto &introducer: address.ssu->introducers) {
                            WriteString("itag" + boost::lexical_cast<std::string>(i), properties);
                            properties << '=';
                            WriteString(boost::lexical_cast<std::string>(introducer.iTag), properties);
                            properties << ';';
                            i++;
                        }
                    }
                }
                if (address.transportStyle == eTransportSSU) {
                    // write intro key
                    WriteString("key", properties);
                    properties << '=';
                    char value[64];
                    size_t l = ByteStreamToBase64(address.i, 32, value, 64);
                    value[l] = 0;
                    WriteString(value, properties);
                    properties << ';';
                }
                if (address.transportStyle == eTransportSSU || address.IsSSU2()) {
                    // write mtu
                    if (address.ssu && address.ssu->mtu) {
                        WriteString("mtu", properties);
                        properties << '=';
                        WriteString(boost::lexical_cast<std::string>(address.ssu->mtu), properties);
                        properties << ';';
                    }
                }
                if ((isPublished || (address.ssu && !address.IsSSU2())) && address.port) {
                    WriteString("port", properties);
                    properties << '=';
                    WriteString(boost::lexical_cast<std::string>(address.port), properties);
                    properties << ';';
                }
                if (address.IsNTCP2() || address.IsSSU2()) {
                    // publish s and v for NTCP2 or SSU2
                    WriteString("s", properties);
                    properties << '=';
                    WriteString(address.s.ToBase64(), properties);
                    properties << ';';
                    WriteString("v", properties);
                    properties << '=';
                    WriteString("2", properties);
                    properties << ';';
                }

                uint16_t size = htobe16(properties.str().size());
                s.write((char *) &size, sizeof(size));
                s.write(properties.str().c_str(), properties.str().size());
            }

            // peers
            uint8_t numPeers = 0;
            s.write((char *) &numPeers, sizeof(numPeers));

            // properties
            std::stringstream properties;
            for (const auto &p: m_Properties) {
                WriteString(p.first, properties);
                properties << '=';
                WriteString(p.second, properties);
                properties << ';';
            }
            uint16_t size = htobe16(properties.str().size());
            s.write((char *) &size, sizeof(size));
            s.write(properties.str().c_str(), properties.str().size());
        }

        void LocalRouterInfo::SetProperty(const std::string &key, const std::string &value) {
            m_Properties[key] = value;
        }

        void LocalRouterInfo::DeleteProperty(const std::string &key) {
            m_Properties.erase(key);
        }

        std::string LocalRouterInfo::GetProperty(const std::string &key) const {
            auto it = m_Properties.find(key);
            if (it != m_Properties.end())
                return it->second;
            return "";
        }

        void LocalRouterInfo::WriteString(const std::string &str, std::ostream &s) const {
            uint8_t len = str.size();
            s.write((char *) &len, 1);
            s.write(str.c_str(), len);
        }

        std::shared_ptr<RouterInfo::Buffer> LocalRouterInfo::NewBuffer() const {
            return std::make_shared<Buffer>();
        }

        bool LocalRouterInfo::AddSSU2Introducer(const Introducer &introducer, bool v4) {
            for (auto &addr: GetAddresses()) {
                if (addr->IsSSU2() && ((v4 && addr->IsV4()) || (!v4 && addr->IsV6()))) {
                    for (auto &intro: addr->ssu->introducers)
                        if (intro.iTag == introducer.iTag) return false; // already presented
                    addr->ssu->introducers.push_back(introducer);
                    SetReachableTransports(GetReachableTransports() | ((addr->IsV4() ? eSSU2V4 : eSSU2V6)));
                    return true;
                }
            }
            return false;
        }

        bool LocalRouterInfo::RemoveSSU2Introducer(const IdentHash &h, bool v4) {
            for (auto &addr: GetAddresses()) {
                if (addr->IsSSU2() && ((v4 && addr->IsV4()) || (!v4 && addr->IsV6()))) {
                    for (auto it = addr->ssu->introducers.begin(); it != addr->ssu->introducers.end(); ++it)
                        if (h == it->iKey) {
                            addr->ssu->introducers.erase(it);
                            if (addr->ssu->introducers.empty())
                                SetReachableTransports(GetReachableTransports() & ~(addr->IsV4() ? eSSU2V4 : eSSU2V6));
                            return true;
                        }
                }
            }
            return false;
        }
    }
}