/*
* 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 <algorithm>
#include <cassert>
#include <string>
#include <set>
#include <vector>
#include <boost/algorithm/string.hpp>
#include "Crypto.h"
#include "Log.h"
#include "FS.h"
#include "Timestamp.h"
#include "NetDb.hpp"
#include "Destination.h"

namespace i2p {
    namespace client {
        LeaseSetDestination::LeaseSetDestination(boost::asio::io_service &service,
                                                 bool isPublic, const std::map<std::string, std::string> *params) :
                m_Service(service), m_IsPublic(isPublic), m_PublishReplyToken(0),
                m_LastSubmissionTime(0), m_PublishConfirmationTimer(m_Service),
                m_PublishVerificationTimer(m_Service), m_PublishDelayTimer(m_Service), m_CleanupTimer(m_Service),
                m_LeaseSetType(DEFAULT_LEASESET_TYPE), m_AuthType(i2p::data::ENCRYPTED_LEASESET_AUTH_TYPE_NONE) {
            int inLen = DEFAULT_INBOUND_TUNNEL_LENGTH;
            int inQty = DEFAULT_INBOUND_TUNNELS_QUANTITY;
            int outLen = DEFAULT_OUTBOUND_TUNNEL_LENGTH;
            int outQty = DEFAULT_OUTBOUND_TUNNELS_QUANTITY;
            int inVar = DEFAULT_INBOUND_TUNNELS_LENGTH_VARIANCE;
            int outVar = DEFAULT_OUTBOUND_TUNNELS_LENGTH_VARIANCE;
            int numTags = DEFAULT_TAGS_TO_SEND;
            std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers;
            try {
                if (params) {
                    auto it = params->find(I2CP_PARAM_INBOUND_TUNNEL_LENGTH);
                    if (it != params->end())
                        inLen = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH);
                    if (it != params->end())
                        outLen = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_INBOUND_TUNNELS_QUANTITY);
                    if (it != params->end())
                        inQty = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY);
                    if (it != params->end())
                        outQty = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_INBOUND_TUNNELS_LENGTH_VARIANCE);
                    if (it != params->end())
                        inVar = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_OUTBOUND_TUNNELS_LENGTH_VARIANCE);
                    if (it != params->end())
                        outVar = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_TAGS_TO_SEND);
                    if (it != params->end())
                        numTags = std::stoi(it->second);
                    LogPrint(eLogInfo, "Destination: Parameters for tunnel set to: ", inQty, " inbound (", inLen,
                             " hops), ", outQty, " outbound (", outLen, " hops), ", numTags, " tags");
                    it = params->find(I2CP_PARAM_RATCHET_INBOUND_TAGS);
                    if (it != params->end())
                        SetNumRatchetInboundTags(std::stoi(it->second));
                    it = params->find(I2CP_PARAM_EXPLICIT_PEERS);
                    if (it != params->end()) {
                        explicitPeers = std::make_shared<std::vector<i2p::data::IdentHash> >();
                        std::stringstream ss(it->second);
                        std::string b64;
                        while (std::getline(ss, b64, ',')) {
                            i2p::data::IdentHash ident;
                            ident.FromBase64(b64);
                            explicitPeers->push_back(ident);
                            LogPrint(eLogInfo, "Destination: Added to explicit peers list: ", b64);
                        }
                    }
                    it = params->find(I2CP_PARAM_INBOUND_NICKNAME);
                    if (it != params->end()) m_Nickname = it->second;
                    else // try outbound
                    {
                        it = params->find(I2CP_PARAM_OUTBOUND_NICKNAME);
                        if (it != params->end()) m_Nickname = it->second;
                        // otherwise we set default nickname in Start when we know local address
                    }
                    it = params->find(I2CP_PARAM_DONT_PUBLISH_LEASESET);
                    if (it != params->end()) {
                        // oveeride isPublic
                        m_IsPublic = (it->second != "true");
                    }
                    it = params->find(I2CP_PARAM_LEASESET_TYPE);
                    if (it != params->end())
                        m_LeaseSetType = std::stoi(it->second);
                    if (m_LeaseSetType == i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2) {
                        // authentication for encrypted LeaseSet
                        it = params->find(I2CP_PARAM_LEASESET_AUTH_TYPE);
                        if (it != params->end()) {
                            auto authType = std::stoi(it->second);
                            if (authType >= i2p::data::ENCRYPTED_LEASESET_AUTH_TYPE_NONE &&
                                authType <= i2p::data::ENCRYPTED_LEASESET_AUTH_TYPE_PSK)
                                m_AuthType = authType;
                            else
                                LogPrint(eLogError, "Destination: Unknown auth type ", authType);
                        }
                    }
                    it = params->find(I2CP_PARAM_LEASESET_PRIV_KEY);
                    if (it != params->end()) {
                        m_LeaseSetPrivKey.reset(new i2p::data::Tag<32>());
                        if (m_LeaseSetPrivKey->FromBase64(it->second) != 32) {
                            LogPrint(eLogError, "Destination: Invalid value i2cp.leaseSetPrivKey ", it->second);
                            m_LeaseSetPrivKey.reset(nullptr);
                        }
                    }
                }
            }
            catch (std::exception &ex) {
                LogPrint(eLogError, "Destination: Unable to parse parameters for destination: ", ex.what());
            }
            SetNumTags(numTags);
            m_Pool = i2p::tunnel::tunnels.CreateTunnelPool(inLen, outLen, inQty, outQty, inVar, outVar);
            if (explicitPeers)
                m_Pool->SetExplicitPeers(explicitPeers);
            if (params) {
                auto itr = params->find(I2CP_PARAM_MAX_TUNNEL_LATENCY);
                if (itr != params->end()) {
                    auto maxlatency = std::stoi(itr->second);
                    itr = params->find(I2CP_PARAM_MIN_TUNNEL_LATENCY);
                    if (itr != params->end()) {
                        auto minlatency = std::stoi(itr->second);
                        if (minlatency > 0 && maxlatency > 0) {
                            // set tunnel pool latency
                            LogPrint(eLogInfo, "Destination: Requiring tunnel latency [", minlatency, "ms, ",
                                     maxlatency, "ms]");
                            m_Pool->RequireLatency(minlatency, maxlatency);
                        }
                    }
                }
            }
        }

        LeaseSetDestination::~LeaseSetDestination() {
            if (m_Pool)
                i2p::tunnel::tunnels.DeleteTunnelPool(m_Pool);
            for (auto &it: m_LeaseSetRequests)
                it.second->Complete(nullptr);
        }

        void LeaseSetDestination::Start() {
            if (m_Nickname.empty())
                m_Nickname = i2p::data::GetIdentHashAbbreviation(GetIdentHash()); // set default nickname
            LoadTags();
            m_Pool->SetLocalDestination(shared_from_this());
            m_Pool->SetActive(true);
            m_CleanupTimer.expires_from_now(boost::posix_time::minutes(DESTINATION_CLEANUP_TIMEOUT));
            m_CleanupTimer.async_wait(std::bind(&LeaseSetDestination::HandleCleanupTimer,
                                                shared_from_this(), std::placeholders::_1));
        }

        void LeaseSetDestination::Stop() {
            m_CleanupTimer.cancel();
            m_PublishConfirmationTimer.cancel();
            m_PublishVerificationTimer.cancel();
            if (m_Pool) {
                m_Pool->SetLocalDestination(nullptr);
                i2p::tunnel::tunnels.StopTunnelPool(m_Pool);
            }
            SaveTags();
            CleanUp(); // GarlicDestination
        }

        bool LeaseSetDestination::Reconfigure(std::map<std::string, std::string> params) {
            auto itr = params.find("i2cp.dontPublishLeaseSet");
            if (itr != params.end()) {
                m_IsPublic = itr->second != "true";
            }

            int inLen, outLen, inQuant, outQuant, numTags, minLatency, maxLatency;
            std::map<std::string, int &> intOpts = {
                    {I2CP_PARAM_INBOUND_TUNNEL_LENGTH,     inLen},
                    {I2CP_PARAM_OUTBOUND_TUNNEL_LENGTH,    outLen},
                    {I2CP_PARAM_INBOUND_TUNNELS_QUANTITY,  inQuant},
                    {I2CP_PARAM_OUTBOUND_TUNNELS_QUANTITY, outQuant},
                    {I2CP_PARAM_TAGS_TO_SEND,              numTags},
                    {I2CP_PARAM_MIN_TUNNEL_LATENCY,        minLatency},
                    {I2CP_PARAM_MAX_TUNNEL_LATENCY,        maxLatency}
            };

            auto pool = GetTunnelPool();
            inLen = pool->GetNumInboundHops();
            outLen = pool->GetNumOutboundHops();
            inQuant = pool->GetNumInboundTunnels();
            outQuant = pool->GetNumOutboundTunnels();
            minLatency = 0;
            maxLatency = 0;

            for (auto &opt: intOpts) {
                itr = params.find(opt.first);
                if (itr != params.end()) {
                    opt.second = std::stoi(itr->second);
                }
            }
            pool->RequireLatency(minLatency, maxLatency);
            return pool->Reconfigure(inLen, outLen, inQuant, outQuant);
        }

        std::shared_ptr<i2p::data::LeaseSet> LeaseSetDestination::FindLeaseSet(const i2p::data::IdentHash &ident) {
            std::shared_ptr<i2p::data::LeaseSet> remoteLS;
            {
                std::lock_guard<std::mutex> lock(m_RemoteLeaseSetsMutex);
                auto it = m_RemoteLeaseSets.find(ident);
                if (it != m_RemoteLeaseSets.end())
                    remoteLS = it->second;
            }

            if (remoteLS) {
                if (!remoteLS->IsExpired()) {
                    if (remoteLS->ExpiresSoon()) {
                        LogPrint(eLogDebug, "Destination: Lease Set expires soon, updating before expire");
                        // update now before expiration for smooth handover
                        auto s = shared_from_this();
                        RequestDestination(ident, [s, ident](std::shared_ptr<i2p::data::LeaseSet> ls) {
                            if (ls && !ls->IsExpired()) {
                                ls->PopulateLeases();
                                {
                                    std::lock_guard<std::mutex> _lock(s->m_RemoteLeaseSetsMutex);
                                    s->m_RemoteLeaseSets[ident] = ls;
                                }
                            }
                        });
                    }
                    return remoteLS;
                } else {
                    LogPrint(eLogWarning, "Destination: Remote LeaseSet expired");
                    std::lock_guard<std::mutex> lock(m_RemoteLeaseSetsMutex);
                    m_RemoteLeaseSets.erase(ident);
                    return nullptr;
                }
            } else {
                auto ls = i2p::data::netdb.FindLeaseSet(ident);
                if (ls && !ls->IsExpired()) {
                    ls->PopulateLeases(); // since we don't store them in netdb
                    std::lock_guard<std::mutex> _lock(m_RemoteLeaseSetsMutex);
                    m_RemoteLeaseSets[ident] = ls;
                    return ls;
                }
            }
            return nullptr;
        }

        std::shared_ptr<const i2p::data::LocalLeaseSet> LeaseSetDestination::GetLeaseSet() {
            if (!m_Pool) return nullptr;
            if (!m_LeaseSet)
                UpdateLeaseSet();
            auto ls = GetLeaseSetMt();
            return (ls && ls->GetInnerLeaseSet()) ? ls->GetInnerLeaseSet() : ls; // always non-encrypted
        }

        std::shared_ptr<const i2p::data::LocalLeaseSet> LeaseSetDestination::GetLeaseSetMt() {
            std::lock_guard<std::mutex> l(m_LeaseSetMutex);
            return m_LeaseSet;
        }

        void LeaseSetDestination::SetLeaseSet(std::shared_ptr<const i2p::data::LocalLeaseSet> newLeaseSet) {
            {
                std::lock_guard<std::mutex> l(m_LeaseSetMutex);
                m_LeaseSet = newLeaseSet;
            }
            i2p::garlic::GarlicDestination::SetLeaseSetUpdated();
            if (m_IsPublic) {
                auto s = shared_from_this();
                m_Service.post([s](void) {
                    s->m_PublishVerificationTimer.cancel();
                    s->Publish();
                });
            }
        }

        void LeaseSetDestination::UpdateLeaseSet() {
            int numTunnels = m_Pool->GetNumInboundTunnels() + 2; // 2 backup tunnels
            if (numTunnels > i2p::data::MAX_NUM_LEASES) numTunnels = i2p::data::MAX_NUM_LEASES; // 16 tunnels maximum
            auto tunnels = m_Pool->GetInboundTunnels(numTunnels);
            if (!tunnels.empty())
                CreateNewLeaseSet(tunnels);
            else
                LogPrint(eLogInfo, "Destination: No inbound tunnels for LeaseSet");
        }

        bool LeaseSetDestination::SubmitSessionKey(const uint8_t *key, const uint8_t *tag) {
            struct {
                uint8_t k[32], t[32];
            } data;
            memcpy(data.k, key, 32);
            memcpy(data.t, tag, 32);
            auto s = shared_from_this();
            m_Service.post([s, data](void) {
                s->AddSessionKey(data.k, data.t);
            });
            return true;
        }

        void LeaseSetDestination::SubmitECIESx25519Key(const uint8_t *key, uint64_t tag) {
            struct {
                uint8_t k[32];
                uint64_t t;
            } data;
            memcpy(data.k, key, 32);
            data.t = tag;
            auto s = shared_from_this();
            m_Service.post([s, data](void) {
                s->AddECIESx25519Key(data.k, data.t);
            });
        }

        void LeaseSetDestination::ProcessGarlicMessage(std::shared_ptr<I2NPMessage> msg) {
            m_Service.post(std::bind(&LeaseSetDestination::HandleGarlicMessage, shared_from_this(), msg));
        }

        void LeaseSetDestination::ProcessDeliveryStatusMessage(std::shared_ptr<I2NPMessage> msg) {
            uint32_t msgID = bufbe32toh(msg->GetPayload() + DELIVERY_STATUS_MSGID_OFFSET);
            m_Service.post(std::bind(&LeaseSetDestination::HandleDeliveryStatusMessage, shared_from_this(), msgID));
        }

        void LeaseSetDestination::HandleI2NPMessage(const uint8_t *buf, size_t len) {
            I2NPMessageType typeID = (I2NPMessageType) (buf[I2NP_HEADER_TYPEID_OFFSET]);
            uint32_t msgID = bufbe32toh(buf + I2NP_HEADER_MSGID_OFFSET);
            LeaseSetDestination::HandleCloveI2NPMessage(typeID, buf + I2NP_HEADER_SIZE,
                                                        GetI2NPMessageLength(buf, len) - I2NP_HEADER_SIZE, msgID);
        }

        bool LeaseSetDestination::HandleCloveI2NPMessage(I2NPMessageType typeID, const uint8_t *payload, size_t len,
                                                         uint32_t msgID) {
            switch (typeID) {
                case eI2NPData:
                    HandleDataMessage(payload, len);
                    break;
                case eI2NPDeliveryStatus:
                    // we assume tunnel tests non-encrypted
                    HandleDeliveryStatusMessage(bufbe32toh(payload + DELIVERY_STATUS_MSGID_OFFSET));
                    break;
                case eI2NPDatabaseStore:
                    HandleDatabaseStoreMessage(payload, len);
                    break;
                case eI2NPDatabaseSearchReply:
                    HandleDatabaseSearchReplyMessage(payload, len);
                    break;
                case eI2NPShortTunnelBuildReply: // might come as garlic encrypted
                    i2p::HandleI2NPMessage(CreateI2NPMessage(typeID, payload, len, msgID));
                    break;
                default:
                    LogPrint(eLogWarning, "Destination: Unexpected I2NP message type ", typeID);
                    return false;
            }
            return true;
        }

        void LeaseSetDestination::HandleDatabaseStoreMessage(const uint8_t *buf, size_t len) {
            uint32_t replyToken = bufbe32toh(buf + DATABASE_STORE_REPLY_TOKEN_OFFSET);
            size_t offset = DATABASE_STORE_HEADER_SIZE;
            if (replyToken) {
                LogPrint(eLogInfo, "Destination: Reply token is ignored for DatabaseStore");
                offset += 36;
            }
            i2p::data::IdentHash key(buf + DATABASE_STORE_KEY_OFFSET);
            std::shared_ptr<i2p::data::LeaseSet> leaseSet;
            switch (buf[DATABASE_STORE_TYPE_OFFSET]) {
                case i2p::data::NETDB_STORE_TYPE_LEASESET: // 1
                case i2p::data::NETDB_STORE_TYPE_STANDARD_LEASESET2: // 3
                {
                    LogPrint(eLogDebug, "Destination: Remote LeaseSet");
                    std::lock_guard<std::mutex> lock(m_RemoteLeaseSetsMutex);
                    auto it = m_RemoteLeaseSets.find(key);
                    if (it != m_RemoteLeaseSets.end() &&
                        it->second->GetStoreType() == buf[DATABASE_STORE_TYPE_OFFSET]) // update only if same type
                    {
                        leaseSet = it->second;
                        if (leaseSet->IsNewer(buf + offset, len - offset)) {
                            leaseSet->Update(buf + offset, len - offset);
                            if (leaseSet->IsValid() && leaseSet->GetIdentHash() == key && !leaseSet->IsExpired())
                                LogPrint(eLogDebug, "Destination: Remote LeaseSet updated");
                            else {
                                LogPrint(eLogDebug, "Destination: Remote LeaseSet update failed");
                                m_RemoteLeaseSets.erase(it);
                                leaseSet = nullptr;
                            }
                        } else
                            LogPrint(eLogDebug, "Destination: Remote LeaseSet is older. Not updated");
                    } else {
                        // add or replace
                        if (buf[DATABASE_STORE_TYPE_OFFSET] == i2p::data::NETDB_STORE_TYPE_LEASESET)
                            leaseSet = std::make_shared<i2p::data::LeaseSet>(buf + offset, len - offset); // LeaseSet
                        else
                            leaseSet = std::make_shared<i2p::data::LeaseSet2>(buf[DATABASE_STORE_TYPE_OFFSET],
                                                                              buf + offset, len - offset, true,
                                                                              GetPreferredCryptoType()); // LeaseSet2
                        if (leaseSet->IsValid() && leaseSet->GetIdentHash() == key && !leaseSet->IsExpired()) {
                            if (leaseSet->GetIdentHash() != GetIdentHash()) {
                                LogPrint(eLogDebug, "Destination: New remote LeaseSet added");
                                m_RemoteLeaseSets[key] = leaseSet;
                            } else
                                LogPrint(eLogDebug, "Destination: Own remote LeaseSet dropped");
                        } else {
                            LogPrint(eLogError, "Destination: New remote LeaseSet failed");
                            leaseSet = nullptr;
                        }
                    }
                    break;
                }
                case i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2: // 5
                {
                    auto it2 = m_LeaseSetRequests.find(key);
                    if (it2 != m_LeaseSetRequests.end() && it2->second->requestedBlindedKey) {
                        auto ls2 = std::make_shared<i2p::data::LeaseSet2>(buf + offset, len - offset,
                                                                          it2->second->requestedBlindedKey,
                                                                          m_LeaseSetPrivKey
                                                                          ? ((const uint8_t *) *m_LeaseSetPrivKey)
                                                                          : nullptr, GetPreferredCryptoType());
                        if (ls2->IsValid()) {
                            m_RemoteLeaseSets[ls2->GetIdentHash()] = ls2; // ident is not key
                            m_RemoteLeaseSets[key] = ls2; // also store as key for next lookup
                            leaseSet = ls2;
                        }
                    } else
                        LogPrint(eLogInfo, "Destination: Couldn't find request for encrypted LeaseSet2");
                    break;
                }
                default:
                    LogPrint(eLogError, "Destination: Unexpected client's DatabaseStore type ",
                             buf[DATABASE_STORE_TYPE_OFFSET], ", dropped");
            }

            auto it1 = m_LeaseSetRequests.find(key);
            if (it1 != m_LeaseSetRequests.end()) {
                it1->second->requestTimeoutTimer.cancel();
                if (it1->second) it1->second->Complete(leaseSet);
                m_LeaseSetRequests.erase(it1);
            }
        }

        void LeaseSetDestination::HandleDatabaseSearchReplyMessage(const uint8_t *buf, size_t len) {
            i2p::data::IdentHash key(buf);
            int num = buf[32]; // num
            LogPrint(eLogDebug, "Destination: DatabaseSearchReply for ", key.ToBase64(), " num=", num);
            auto it = m_LeaseSetRequests.find(key);
            if (it != m_LeaseSetRequests.end()) {
                auto request = it->second;
                bool found = false;
                if (request->excluded.size() < MAX_NUM_FLOODFILLS_PER_REQUEST) {
                    for (int i = 0; i < num; i++) {
                        i2p::data::IdentHash peerHash(buf + 33 + i * 32);
                        if (!request->excluded.count(peerHash) && !i2p::data::netdb.FindRouter(peerHash)) {
                            LogPrint(eLogInfo, "Destination: Found new floodfill, request it");
                            i2p::data::netdb.RequestDestination(peerHash, nullptr, false); // through exploratory
                        }
                    }

                    auto floodfill = i2p::data::netdb.GetClosestFloodfill(key, request->excluded);
                    if (floodfill) {
                        LogPrint(eLogInfo, "Destination: Requesting ", key.ToBase64(), " at ",
                                 floodfill->GetIdentHash().ToBase64());
                        if (SendLeaseSetRequest(key, floodfill, request))
                            found = true;
                    }
                }
                if (!found) {
                    LogPrint(eLogInfo, "Destination: ", key.ToBase64(), " was not found on ",
                             MAX_NUM_FLOODFILLS_PER_REQUEST, " floodfills");
                    request->Complete(nullptr);
                    m_LeaseSetRequests.erase(key);
                }
            } else
                LogPrint(eLogWarning, "Destination: Request for ", key.ToBase64(), " not found");
        }

        void LeaseSetDestination::HandleDeliveryStatusMessage(uint32_t msgID) {
            if (msgID == m_PublishReplyToken) {
                LogPrint(eLogDebug, "Destination: Publishing LeaseSet confirmed for ", GetIdentHash().ToBase32());
                m_ExcludedFloodfills.clear();
                m_PublishReplyToken = 0;
                // schedule verification
                m_PublishVerificationTimer.expires_from_now(boost::posix_time::seconds(PUBLISH_VERIFICATION_TIMEOUT));
                m_PublishVerificationTimer.async_wait(std::bind(&LeaseSetDestination::HandlePublishVerificationTimer,
                                                                shared_from_this(), std::placeholders::_1));
            } else
                i2p::garlic::GarlicDestination::HandleDeliveryStatusMessage(msgID);
        }

        void LeaseSetDestination::SetLeaseSetUpdated() {
            UpdateLeaseSet();
        }

        void LeaseSetDestination::Publish() {
            auto leaseSet = GetLeaseSetMt();
            if (!leaseSet || !m_Pool) {
                LogPrint(eLogError, "Destination: Can't publish non-existing LeaseSet");
                return;
            }
            if (m_PublishReplyToken) {
                LogPrint(eLogDebug, "Destination: Publishing LeaseSet is pending");
                return;
            }
            auto ts = i2p::util::GetSecondsSinceEpoch();
            if (ts < m_LastSubmissionTime + PUBLISH_MIN_INTERVAL) {
                LogPrint(eLogDebug, "Destination: Publishing LeaseSet is too fast. Wait for ", PUBLISH_MIN_INTERVAL,
                         " seconds");
                m_PublishDelayTimer.cancel();
                m_PublishDelayTimer.expires_from_now(boost::posix_time::seconds(PUBLISH_MIN_INTERVAL));
                m_PublishDelayTimer.async_wait(std::bind(&LeaseSetDestination::HandlePublishDelayTimer,
                                                         shared_from_this(), std::placeholders::_1));
                return;
            }
            if (!m_Pool->GetInboundTunnels().size() || !m_Pool->GetOutboundTunnels().size()) {
                LogPrint(eLogError, "Destination: Can't publish LeaseSet. Destination is not ready");
                return;
            }
            auto floodfill = i2p::data::netdb.GetClosestFloodfill(leaseSet->GetIdentHash(), m_ExcludedFloodfills);
            if (!floodfill) {
                LogPrint(eLogError, "Destination: Can't publish LeaseSet, no more floodfills found");
                m_ExcludedFloodfills.clear();
                return;
            }
            auto outbound = m_Pool->GetNextOutboundTunnel(nullptr, floodfill->GetCompatibleTransports(false));
            auto inbound = m_Pool->GetNextInboundTunnel(nullptr, floodfill->GetCompatibleTransports(true));
            if (!outbound || !inbound) {
                LogPrint(eLogInfo, "Destination: No compatible tunnels with ", floodfill->GetIdentHash().ToBase64(),
                         ". Trying another floodfill");
                m_ExcludedFloodfills.insert(floodfill->GetIdentHash());
                floodfill = i2p::data::netdb.GetClosestFloodfill(leaseSet->GetIdentHash(), m_ExcludedFloodfills);
                if (floodfill) {
                    outbound = m_Pool->GetNextOutboundTunnel(nullptr, floodfill->GetCompatibleTransports(false));
                    if (outbound) {
                        inbound = m_Pool->GetNextInboundTunnel(nullptr, floodfill->GetCompatibleTransports(true));
                        if (!inbound)
                            LogPrint(eLogError, "Destination: Can't publish LeaseSet. No inbound tunnels");
                    } else
                        LogPrint(eLogError, "Destination: Can't publish LeaseSet. No outbound tunnels");
                } else
                    LogPrint(eLogError, "Destination: Can't publish LeaseSet, no more floodfills found");
                if (!floodfill || !outbound || !inbound) {
                    m_ExcludedFloodfills.clear();
                    return;
                }
            }
            m_ExcludedFloodfills.insert(floodfill->GetIdentHash());
            LogPrint(eLogDebug, "Destination: Publish LeaseSet of ", GetIdentHash().ToBase32());
            RAND_bytes((uint8_t * ) & m_PublishReplyToken, 4);
            auto msg = WrapMessageForRouter(floodfill,
                                            i2p::CreateDatabaseStoreMsg(leaseSet, m_PublishReplyToken, inbound));
            m_PublishConfirmationTimer.expires_from_now(boost::posix_time::seconds(PUBLISH_CONFIRMATION_TIMEOUT));
            m_PublishConfirmationTimer.async_wait(std::bind(&LeaseSetDestination::HandlePublishConfirmationTimer,
                                                            shared_from_this(), std::placeholders::_1));
            outbound->SendTunnelDataMsg(floodfill->GetIdentHash(), 0, msg);
            m_LastSubmissionTime = ts;
        }

        void LeaseSetDestination::HandlePublishConfirmationTimer(const boost::system::error_code &ecode) {
            if (ecode != boost::asio::error::operation_aborted) {
                if (m_PublishReplyToken) {
                    m_PublishReplyToken = 0;
                    if (GetIdentity()->GetCryptoKeyType() == i2p::data::CRYPTO_KEY_TYPE_ELGAMAL) {
                        LogPrint(eLogWarning, "Destination: Publish confirmation was not received in ",
                                 PUBLISH_CONFIRMATION_TIMEOUT, " seconds, will try again");
                        Publish();
                    } else {
                        LogPrint(eLogWarning, "Destination: Publish confirmation was not received in ",
                                 PUBLISH_CONFIRMATION_TIMEOUT, " seconds from Java floodfill for crypto type ",
                                 (int) GetIdentity()->GetCryptoKeyType());
                        // Java floodfill never sends confirmation back for unknown crypto type
                        // assume it successive and try to verify
                        m_PublishVerificationTimer.expires_from_now(
                                boost::posix_time::seconds(PUBLISH_VERIFICATION_TIMEOUT));
                        m_PublishVerificationTimer.async_wait(
                                std::bind(&LeaseSetDestination::HandlePublishVerificationTimer,
                                          shared_from_this(), std::placeholders::_1));

                    }
                }
            }
        }

        void LeaseSetDestination::HandlePublishVerificationTimer(const boost::system::error_code &ecode) {
            if (ecode != boost::asio::error::operation_aborted) {
                auto ls = GetLeaseSetMt();
                if (!ls) {
                    LogPrint(eLogWarning, "Destination: Couldn't verify LeaseSet for ", GetIdentHash().ToBase32());
                    return;
                }
                auto s = shared_from_this();
                RequestLeaseSet(ls->GetStoreHash(),
                                [s, ls](std::shared_ptr<const i2p::data::LeaseSet> leaseSet) {
                                    if (leaseSet) {
                                        if (*ls == *leaseSet) {
                                            // we got latest LeasetSet
                                            LogPrint(eLogDebug, "Destination: Published LeaseSet verified for ",
                                                     s->GetIdentHash().ToBase32());
                                            s->m_PublishVerificationTimer.expires_from_now(
                                                    boost::posix_time::seconds(PUBLISH_REGULAR_VERIFICATION_INTERNAL));
                                            s->m_PublishVerificationTimer.async_wait(
                                                    std::bind(&LeaseSetDestination::HandlePublishVerificationTimer, s,
                                                              std::placeholders::_1));
                                            return;
                                        } else
                                            LogPrint(eLogDebug,
                                                     "Destination: LeaseSet is different than just published for ",
                                                     s->GetIdentHash().ToBase32());
                                    } else
                                        LogPrint(eLogWarning, "Destination: Couldn't find published LeaseSet for ",
                                                 s->GetIdentHash().ToBase32());
                                    // we have to publish again
                                    s->Publish();
                                });
            }
        }

        void LeaseSetDestination::HandlePublishDelayTimer(const boost::system::error_code &ecode) {
            if (ecode != boost::asio::error::operation_aborted)
                Publish();
        }

        bool
        LeaseSetDestination::RequestDestination(const i2p::data::IdentHash &dest, RequestComplete requestComplete) {
            if (!m_Pool || !IsReady()) {
                if (requestComplete)
                    m_Service.post([requestComplete](void) { requestComplete(nullptr); });
                return false;
            }
            m_Service.post(std::bind(&LeaseSetDestination::RequestLeaseSet, shared_from_this(), dest, requestComplete,
                                     nullptr));
            return true;
        }

        bool LeaseSetDestination::RequestDestinationWithEncryptedLeaseSet(
                std::shared_ptr<const i2p::data::BlindedPublicKey> dest, RequestComplete requestComplete) {
            if (!dest || !m_Pool || !IsReady()) {
                if (requestComplete)
                    m_Service.post([requestComplete](void) { requestComplete(nullptr); });
                return false;
            }
            auto storeHash = dest->GetStoreHash();
            auto leaseSet = FindLeaseSet(storeHash);
            if (leaseSet) {
                if (requestComplete)
                    m_Service.post([requestComplete, leaseSet](void) { requestComplete(leaseSet); });
                return true;
            }
            m_Service.post(
                    std::bind(&LeaseSetDestination::RequestLeaseSet, shared_from_this(), storeHash, requestComplete,
                              dest));
            return true;
        }

        void LeaseSetDestination::CancelDestinationRequest(const i2p::data::IdentHash &dest, bool notify) {
            auto s = shared_from_this();
            m_Service.post([dest, notify, s](void) {
                auto it = s->m_LeaseSetRequests.find(dest);
                if (it != s->m_LeaseSetRequests.end()) {
                    auto requestComplete = it->second;
                    s->m_LeaseSetRequests.erase(it);
                    if (notify && requestComplete) requestComplete->Complete(nullptr);
                }
            });
        }

        void LeaseSetDestination::CancelDestinationRequestWithEncryptedLeaseSet(
                std::shared_ptr<const i2p::data::BlindedPublicKey> dest, bool notify) {
            if (dest)
                CancelDestinationRequest(dest->GetStoreHash(), notify);
        }

        void LeaseSetDestination::RequestLeaseSet(const i2p::data::IdentHash &dest, RequestComplete requestComplete,
                                                  std::shared_ptr<const i2p::data::BlindedPublicKey> requestedBlindedKey) {
            std::set<i2p::data::IdentHash> excluded;
            auto floodfill = i2p::data::netdb.GetClosestFloodfill(dest, excluded);
            if (floodfill) {
                auto request = std::make_shared<LeaseSetRequest>(m_Service);
                request->requestedBlindedKey = requestedBlindedKey; // for encrypted LeaseSet2
                if (requestComplete)
                    request->requestComplete.push_back(requestComplete);
                auto ts = i2p::util::GetSecondsSinceEpoch();
                auto ret = m_LeaseSetRequests.insert(
                        std::pair<i2p::data::IdentHash, std::shared_ptr<LeaseSetRequest> >(dest, request));
                if (ret.second) // inserted
                {
                    request->requestTime = ts;
                    if (!SendLeaseSetRequest(dest, floodfill, request)) {
                        // request failed
                        m_LeaseSetRequests.erase(ret.first);
                        if (requestComplete) requestComplete(nullptr);
                    }
                } else // duplicate
                {
                    LogPrint(eLogInfo, "Destination: Request of LeaseSet ", dest.ToBase64(), " is pending already");
                    if (ts > ret.first->second->requestTime + MAX_LEASESET_REQUEST_TIMEOUT) {
                        // something went wrong
                        m_LeaseSetRequests.erase(ret.first);
                        if (requestComplete) requestComplete(nullptr);
                    } else if (requestComplete)
                        ret.first->second->requestComplete.push_back(requestComplete);
                }
            } else {
                LogPrint(eLogError, "Destination: Can't request LeaseSet, no floodfills found");
                if (requestComplete) requestComplete(nullptr);
            }
        }

        bool LeaseSetDestination::SendLeaseSetRequest(const i2p::data::IdentHash &dest,
                                                      std::shared_ptr<const i2p::data::RouterInfo> nextFloodfill,
                                                      std::shared_ptr<LeaseSetRequest> request) {
            if (!request->replyTunnel || !request->replyTunnel->IsEstablished())
                request->replyTunnel = m_Pool->GetNextInboundTunnel(nullptr,
                                                                    nextFloodfill->GetCompatibleTransports(true));
            if (!request->replyTunnel)
                LogPrint(eLogError, "Destination: Can't send LeaseSet request, no inbound tunnels found");
            if (!request->outboundTunnel || !request->outboundTunnel->IsEstablished())
                request->outboundTunnel = m_Pool->GetNextOutboundTunnel(nullptr,
                                                                        nextFloodfill->GetCompatibleTransports(false));
            if (!request->outboundTunnel)
                LogPrint(eLogError, "Destination: Can't send LeaseSet request, no outbound tunnels found");

            if (request->replyTunnel && request->outboundTunnel) {
                request->excluded.insert(nextFloodfill->GetIdentHash());
                request->requestTimeoutTimer.cancel();

                bool isECIES = SupportsEncryptionType(i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD) &&
                               nextFloodfill->GetVersion() >= MAKE_VERSION_NUMBER(0, 9, 46); // >= 0.9.46;
                uint8_t replyKey[32], replyTag[32];
                RAND_bytes(replyKey, 32); // random session key
                RAND_bytes(replyTag, isECIES ? 8 : 32); // random session tag
                if (isECIES)
                    AddECIESx25519Key(replyKey, replyTag);
                else
                    AddSessionKey(replyKey, replyTag);
                auto msg = WrapMessageForRouter(nextFloodfill, CreateLeaseSetDatabaseLookupMsg(dest,
                                                                                               request->excluded,
                                                                                               request->replyTunnel,
                                                                                               replyKey, replyTag,
                                                                                               isECIES));
                request->outboundTunnel->SendTunnelDataMsg(
                        {
                                i2p::tunnel::TunnelMessageBlock
                                        {
                                                i2p::tunnel::eDeliveryTypeRouter,
                                                nextFloodfill->GetIdentHash(), 0, msg
                                        }
                        });
                request->requestTimeoutTimer.expires_from_now(boost::posix_time::seconds(LEASESET_REQUEST_TIMEOUT));
                request->requestTimeoutTimer.async_wait(std::bind(&LeaseSetDestination::HandleRequestTimoutTimer,
                                                                  shared_from_this(), std::placeholders::_1, dest));
            } else
                return false;
            return true;
        }

        void LeaseSetDestination::HandleRequestTimoutTimer(const boost::system::error_code &ecode,
                                                           const i2p::data::IdentHash &dest) {
            if (ecode != boost::asio::error::operation_aborted) {
                auto it = m_LeaseSetRequests.find(dest);
                if (it != m_LeaseSetRequests.end()) {
                    bool done = false;
                    uint64_t ts = i2p::util::GetSecondsSinceEpoch();
                    if (ts < it->second->requestTime + MAX_LEASESET_REQUEST_TIMEOUT) {
                        auto floodfill = i2p::data::netdb.GetClosestFloodfill(dest, it->second->excluded);
                        if (floodfill) {
                            // reset tunnels, because one them might fail
                            it->second->outboundTunnel = nullptr;
                            it->second->replyTunnel = nullptr;
                            done = !SendLeaseSetRequest(dest, floodfill, it->second);
                        } else
                            done = true;
                    } else {
                        LogPrint(eLogWarning, "Destination: ", dest.ToBase64(), " was not found within ",
                                 MAX_LEASESET_REQUEST_TIMEOUT, " seconds");
                        done = true;
                    }

                    if (done) {
                        auto requestComplete = it->second;
                        m_LeaseSetRequests.erase(it);
                        if (requestComplete) requestComplete->Complete(nullptr);
                    }
                }
            }
        }

        void LeaseSetDestination::HandleCleanupTimer(const boost::system::error_code &ecode) {
            if (ecode != boost::asio::error::operation_aborted) {
                CleanupExpiredTags();
                CleanupRemoteLeaseSets();
                CleanupDestination();
                m_CleanupTimer.expires_from_now(boost::posix_time::minutes(DESTINATION_CLEANUP_TIMEOUT));
                m_CleanupTimer.async_wait(std::bind(&LeaseSetDestination::HandleCleanupTimer,
                                                    shared_from_this(), std::placeholders::_1));
            }
        }

        void LeaseSetDestination::CleanupRemoteLeaseSets() {
            auto ts = i2p::util::GetMillisecondsSinceEpoch();
            std::lock_guard<std::mutex> lock(m_RemoteLeaseSetsMutex);
            for (auto it = m_RemoteLeaseSets.begin(); it != m_RemoteLeaseSets.end();) {
                if (it->second->IsEmpty() || ts > it->second->GetExpirationTime()) // leaseset expired
                {
                    LogPrint(eLogWarning, "Destination: Remote LeaseSet ", it->second->GetIdentHash().ToBase64(),
                             " expired");
                    it = m_RemoteLeaseSets.erase(it);
                } else
                    ++it;
            }
        }

        i2p::data::CryptoKeyType LeaseSetDestination::GetPreferredCryptoType() const {
            if (SupportsEncryptionType(i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD))
                return i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD;
            return i2p::data::CRYPTO_KEY_TYPE_ELGAMAL;
        }

        ClientDestination::ClientDestination(boost::asio::io_service &service, const i2p::data::PrivateKeys &keys,
                                             bool isPublic, const std::map<std::string, std::string> *params) :
                LeaseSetDestination(service, isPublic, params),
                m_Keys(keys), m_StreamingAckDelay(DEFAULT_INITIAL_ACK_DELAY),
                m_IsStreamingAnswerPings(DEFAULT_ANSWER_PINGS),
                m_DatagramDestination(nullptr), m_RefCounter(0),
                m_ReadyChecker(service) {
            if (keys.IsOfflineSignature() && GetLeaseSetType() == i2p::data::NETDB_STORE_TYPE_LEASESET)
                SetLeaseSetType(
                        i2p::data::NETDB_STORE_TYPE_STANDARD_LEASESET2); // offline keys can be published with LS2 only

            // extract encryption type params for LS2
            std::set<i2p::data::CryptoKeyType> encryptionKeyTypes;
            if (params) {
                auto it = params->find(I2CP_PARAM_LEASESET_ENCRYPTION_TYPE);
                if (it != params->end()) {
                    // comma-separated values
                    std::vector<std::string> values;
                    boost::split(values, it->second, boost::is_any_of(","));
                    for (auto &it1: values) {
                        try {
                            encryptionKeyTypes.insert(std::stoi(it1));
                        }
                        catch (std::exception &ex) {
                            LogPrint(eLogInfo, "Destination: Unexpected crypto type ", it1, ". ", ex.what());
                            continue;
                        }
                    }
                }
            }
            // if no param or valid crypto type use from identity
            bool isSingleKey = false;
            if (encryptionKeyTypes.empty()) {
                isSingleKey = true;
                encryptionKeyTypes.insert(GetIdentity()->GetCryptoKeyType());
            }

            for (auto &it: encryptionKeyTypes) {
                auto encryptionKey = new EncryptionKey(it);
                if (IsPublic())
                    PersistTemporaryKeys(encryptionKey, isSingleKey);
                else
                    encryptionKey->GenerateKeys();
                encryptionKey->CreateDecryptor();
                if (it == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD) {
                    m_ECIESx25519EncryptionKey.reset(encryptionKey);
                    if (GetLeaseSetType() == i2p::data::NETDB_STORE_TYPE_LEASESET)
                        SetLeaseSetType(i2p::data::NETDB_STORE_TYPE_STANDARD_LEASESET2); // Rathets must use LeaseSet2
                } else
                    m_StandardEncryptionKey.reset(encryptionKey);
            }

            if (IsPublic())
                LogPrint(eLogInfo, "Destination: Local address ", GetIdentHash().ToBase32(), " created");

            try {
                if (params) {
                    // extract streaming params
                    auto it = params->find(I2CP_PARAM_STREAMING_INITIAL_ACK_DELAY);
                    if (it != params->end())
                        m_StreamingAckDelay = std::stoi(it->second);
                    it = params->find(I2CP_PARAM_STREAMING_ANSWER_PINGS);
                    if (it != params->end())
                        m_IsStreamingAnswerPings = (it->second == "true");

                    if (GetLeaseSetType() == i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2) {
                        // authentication for encrypted LeaseSet
                        auto authType = GetAuthType();
                        if (authType > 0) {
                            m_AuthKeys = std::make_shared<std::vector<i2p::data::AuthPublicKey> >();
                            if (authType == i2p::data::ENCRYPTED_LEASESET_AUTH_TYPE_DH)
                                ReadAuthKey(I2CP_PARAM_LEASESET_CLIENT_DH, params);
                            else if (authType == i2p::data::ENCRYPTED_LEASESET_AUTH_TYPE_PSK)
                                ReadAuthKey(I2CP_PARAM_LEASESET_CLIENT_PSK, params);
                            else
                                LogPrint(eLogError, "Destination: Unexpected auth type ", authType);
                            if (m_AuthKeys->size())
                                LogPrint(eLogInfo, "Destination: ", m_AuthKeys->size(), " auth keys read");
                            else {
                                LogPrint(eLogError, "Destination: No auth keys read for auth type ", authType);
                                m_AuthKeys = nullptr;
                            }
                        }
                    }
                }
            }
            catch (std::exception &ex) {
                LogPrint(eLogError, "Destination: Unable to parse parameters for destination: ", ex.what());
            }
        }

        ClientDestination::~ClientDestination() {
        }

        void ClientDestination::Start() {
            LeaseSetDestination::Start();
            m_StreamingDestination = std::make_shared<i2p::stream::StreamingDestination>(GetSharedFromThis()); // TODO:
            m_StreamingDestination->Start();
            for (auto &it: m_StreamingDestinationsByPorts)
                it.second->Start();
        }

        void ClientDestination::Stop() {
            LeaseSetDestination::Stop();
            m_ReadyChecker.cancel();
            m_StreamingDestination->Stop();
            //m_StreamingDestination->SetOwner (nullptr);
            m_StreamingDestination = nullptr;
            for (auto &it: m_StreamingDestinationsByPorts) {
                it.second->Stop();
                //it.second->SetOwner (nullptr);
            }
            m_StreamingDestinationsByPorts.clear();
            if (m_DatagramDestination) {
                delete m_DatagramDestination;
                m_DatagramDestination = nullptr;
            }
        }

        void ClientDestination::HandleDataMessage(const uint8_t *buf, size_t len) {
            uint32_t length = bufbe32toh(buf);
            if (length > len - 4) {
                LogPrint(eLogError, "Destination: Data message length ", length, " exceeds buffer length ", len);
                return;
            }
            buf += 4;
            // we assume I2CP payload
            uint16_t fromPort = bufbe16toh(buf + 4), // source
            toPort = bufbe16toh(buf + 6); // destination
            switch (buf[9]) {
                case PROTOCOL_TYPE_STREAMING: {
                    // streaming protocol
                    auto dest = GetStreamingDestination(toPort);
                    if (dest)
                        dest->HandleDataMessagePayload(buf, length);
                    else
                        LogPrint(eLogError, "Destination: Missing streaming destination");
                }
                    break;
                case PROTOCOL_TYPE_DATAGRAM:
                    // datagram protocol
                    if (m_DatagramDestination)
                        m_DatagramDestination->HandleDataMessagePayload(fromPort, toPort, buf, length);
                    else
                        LogPrint(eLogError, "Destination: Missing datagram destination");
                    break;
                case PROTOCOL_TYPE_RAW:
                    // raw datagram
                    if (m_DatagramDestination)
                        m_DatagramDestination->HandleDataMessagePayload(fromPort, toPort, buf, length, true);
                    else
                        LogPrint(eLogError, "Destination: Missing raw datagram destination");
                    break;
                default:
                    LogPrint(eLogError, "Destination: Data: Unexpected protocol ", buf[9]);
            }
        }

        void
        ClientDestination::CreateStream(StreamRequestComplete streamRequestComplete, const i2p::data::IdentHash &dest,
                                        int port) {
            if (!streamRequestComplete) {
                LogPrint(eLogError, "Destination: Request callback is not specified in CreateStream");
                return;
            }
            auto leaseSet = FindLeaseSet(dest);
            if (leaseSet)
                streamRequestComplete(CreateStream(leaseSet, port));
            else {
                auto s = GetSharedFromThis();
                RequestDestination(dest,
                                   [s, streamRequestComplete, port](std::shared_ptr<const i2p::data::LeaseSet> ls) {
                                       if (ls)
                                           streamRequestComplete(s->CreateStream(ls, port));
                                       else
                                           streamRequestComplete(nullptr);
                                   });
            }
        }

        void ClientDestination::CreateStream(StreamRequestComplete streamRequestComplete,
                                             std::shared_ptr<const i2p::data::BlindedPublicKey> dest, int port) {
            if (!streamRequestComplete) {
                LogPrint(eLogError, "Destination: Request callback is not specified in CreateStream");
                return;
            }
            auto s = GetSharedFromThis();
            RequestDestinationWithEncryptedLeaseSet(dest,
                                                    [s, streamRequestComplete, port](
                                                            std::shared_ptr<i2p::data::LeaseSet> ls) {
                                                        if (ls)
                                                            streamRequestComplete(s->CreateStream(ls, port));
                                                        else
                                                            streamRequestComplete(nullptr);
                                                    });
        }

        std::shared_ptr<i2p::stream::Stream>
        ClientDestination::CreateStream(std::shared_ptr<const i2p::data::LeaseSet> remote, int port) {
            if (m_StreamingDestination)
                return m_StreamingDestination->CreateNewOutgoingStream(remote, port);
            else
                return nullptr;
        }

        void ClientDestination::SendPing(const i2p::data::IdentHash &to) {
            if (m_StreamingDestination) {
                auto leaseSet = FindLeaseSet(to);
                if (leaseSet)
                    m_StreamingDestination->SendPing(leaseSet);
                else {
                    auto s = m_StreamingDestination;
                    RequestDestination(to,
                                       [s](std::shared_ptr<const i2p::data::LeaseSet> ls) {
                                           if (ls) s->SendPing(ls);
                                       });
                }
            }
        }

        void ClientDestination::SendPing(std::shared_ptr<const i2p::data::BlindedPublicKey> to) {
            auto s = m_StreamingDestination;
            RequestDestinationWithEncryptedLeaseSet(to,
                                                    [s](std::shared_ptr<const i2p::data::LeaseSet> ls) {
                                                        if (ls) s->SendPing(ls);
                                                    });
        }

        std::shared_ptr<i2p::stream::StreamingDestination> ClientDestination::GetStreamingDestination(int port) const {
            if (port) {
                auto it = m_StreamingDestinationsByPorts.find(port);
                if (it != m_StreamingDestinationsByPorts.end())
                    return it->second;
            }
            // if port is zero or not found, use default destination
            return m_StreamingDestination;
        }

        void ClientDestination::AcceptStreams(const i2p::stream::StreamingDestination::Acceptor &acceptor) {
            if (m_StreamingDestination)
                m_StreamingDestination->SetAcceptor(acceptor);
        }

        void ClientDestination::StopAcceptingStreams() {
            if (m_StreamingDestination)
                m_StreamingDestination->ResetAcceptor();
        }

        bool ClientDestination::IsAcceptingStreams() const {
            if (m_StreamingDestination)
                return m_StreamingDestination->IsAcceptorSet();
            return false;
        }

        void ClientDestination::AcceptOnce(const i2p::stream::StreamingDestination::Acceptor &acceptor) {
            if (m_StreamingDestination)
                m_StreamingDestination->AcceptOnce(acceptor);
        }

        std::shared_ptr<i2p::stream::StreamingDestination>
        ClientDestination::CreateStreamingDestination(int port, bool gzip) {
            auto dest = std::make_shared<i2p::stream::StreamingDestination>(GetSharedFromThis(), port, gzip);
            if (port)
                m_StreamingDestinationsByPorts[port] = dest;
            else // update default
                m_StreamingDestination = dest;
            return dest;
        }

        std::shared_ptr<i2p::stream::StreamingDestination> ClientDestination::RemoveStreamingDestination(int port) {
            if (port) {
                auto it = m_StreamingDestinationsByPorts.find(port);
                if (it != m_StreamingDestinationsByPorts.end()) {
                    auto ret = it->second;
                    m_StreamingDestinationsByPorts.erase(it);
                    return ret;
                }
            }
            return nullptr;
        }

        i2p::datagram::DatagramDestination *ClientDestination::CreateDatagramDestination(bool gzip) {
            if (m_DatagramDestination == nullptr)
                m_DatagramDestination = new i2p::datagram::DatagramDestination(GetSharedFromThis(), gzip);
            return m_DatagramDestination;
        }

        std::vector<std::shared_ptr<const i2p::stream::Stream> > ClientDestination::GetAllStreams() const {
            std::vector<std::shared_ptr<const i2p::stream::Stream> > ret;
            if (m_StreamingDestination) {
                for (auto &it: m_StreamingDestination->GetStreams())
                    ret.push_back(it.second);
            }
            for (auto &it: m_StreamingDestinationsByPorts)
                for (auto &it1: it.second->GetStreams())
                    ret.push_back(it1.second);
            return ret;
        }

        void ClientDestination::PersistTemporaryKeys(EncryptionKey *keys, bool isSingleKey) {
            if (!keys) return;
            std::string ident = GetIdentHash().ToBase32();
            std::string path = i2p::fs::DataDirPath("destinations",
                                                    isSingleKey ? (ident + ".dat") : (ident + "." +
                                                                                      std::to_string(keys->keyType) +
                                                                                      ".dat"));
            std::ifstream f(path, std::ifstream::binary);

            if (f) {
                f.read((char *) keys->pub, 256);
                f.read((char *) keys->priv, 256);
                return;
            }

            LogPrint(eLogInfo, "Destination: Creating new temporary keys of type for address ", ident, ".b32.i2p");
            memset(keys->priv, 0, 256);
            memset(keys->pub, 0, 256);
            keys->GenerateKeys();
            // TODO:: persist crypto key type
            std::ofstream f1(path, std::ofstream::binary | std::ofstream::out);
            if (f1) {
                f1.write((char *) keys->pub, 256);
                f1.write((char *) keys->priv, 256);
                return;
            }
            LogPrint(eLogError, "Destinations: Can't save keys to ", path);
        }

        void
        ClientDestination::CreateNewLeaseSet(const std::vector<std::shared_ptr<i2p::tunnel::InboundTunnel> > &tunnels) {
            std::shared_ptr<i2p::data::LocalLeaseSet> leaseSet;
            if (GetLeaseSetType() == i2p::data::NETDB_STORE_TYPE_LEASESET) {
                if (m_StandardEncryptionKey) {
                    leaseSet = std::make_shared<i2p::data::LocalLeaseSet>(GetIdentity(), m_StandardEncryptionKey->pub,
                                                                          tunnels);
                    // sign
                    Sign(leaseSet->GetBuffer(), leaseSet->GetBufferLen() - leaseSet->GetSignatureLen(),
                         leaseSet->GetSignature());
                } else
                    LogPrint(eLogError, "Destinations: Wrong encryption key type for LeaseSet type 1");
            } else {
                // standard LS2 (type 3) first
                i2p::data::LocalLeaseSet2::KeySections keySections;
                if (m_ECIESx25519EncryptionKey)
                    keySections.push_back({m_ECIESx25519EncryptionKey->keyType, 32, m_ECIESx25519EncryptionKey->pub});
                if (m_StandardEncryptionKey)
                    keySections.push_back({m_StandardEncryptionKey->keyType,
                                           (uint16_t) m_StandardEncryptionKey->decryptor->GetPublicKeyLen(),
                                           m_StandardEncryptionKey->pub});

                bool isPublishedEncrypted = GetLeaseSetType() == i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2;
                auto ls2 = std::make_shared<i2p::data::LocalLeaseSet2>(i2p::data::NETDB_STORE_TYPE_STANDARD_LEASESET2,
                                                                       m_Keys, keySections, tunnels, IsPublic(),
                                                                       isPublishedEncrypted);
                if (isPublishedEncrypted) // encrypt if type 5
                    ls2 = std::make_shared<i2p::data::LocalEncryptedLeaseSet2>(ls2, m_Keys, GetAuthType(), m_AuthKeys);
                leaseSet = ls2;
            }
            SetLeaseSet(leaseSet);
        }

        void ClientDestination::CleanupDestination() {
            if (m_DatagramDestination) m_DatagramDestination->CleanUp();
        }

        bool ClientDestination::Decrypt(const uint8_t *encrypted, uint8_t *data,
                                        i2p::data::CryptoKeyType preferredCrypto) const {
            if (preferredCrypto == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD)
                if (m_ECIESx25519EncryptionKey && m_ECIESx25519EncryptionKey->decryptor)
                    return m_ECIESx25519EncryptionKey->decryptor->Decrypt(encrypted, data);
            if (m_StandardEncryptionKey && m_StandardEncryptionKey->decryptor)
                return m_StandardEncryptionKey->decryptor->Decrypt(encrypted, data);
            else
                LogPrint(eLogError, "Destinations: Decryptor is not set");
            return false;
        }

        bool ClientDestination::SupportsEncryptionType(i2p::data::CryptoKeyType keyType) const {
            return keyType == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD ? (bool) m_ECIESx25519EncryptionKey
                                                                           : (bool) m_StandardEncryptionKey;
        }

        const uint8_t *ClientDestination::GetEncryptionPublicKey(i2p::data::CryptoKeyType keyType) const {
            if (keyType == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD)
                return m_ECIESx25519EncryptionKey ? m_ECIESx25519EncryptionKey->pub : nullptr;
            return m_StandardEncryptionKey ? m_StandardEncryptionKey->pub : nullptr;
        }

        void
        ClientDestination::ReadAuthKey(const std::string &group, const std::map<std::string, std::string> *params) {
            for (auto it: *params)
                if (it.first.length() >= group.length() && !it.first.compare(0, group.length(), group)) {
                    auto pos = it.second.find(':');
                    if (pos != std::string::npos) {
                        i2p::data::AuthPublicKey pubKey;
                        if (pubKey.FromBase64(it.second.substr(pos + 1)))
                            m_AuthKeys->push_back(pubKey);
                        else
                            LogPrint(eLogError, "Destination: Unexpected auth key ", it.second.substr(pos + 1));
                    }
                }
        }

        bool ClientDestination::DeleteStream(uint32_t recvStreamID) {
            if (m_StreamingDestination->DeleteStream(recvStreamID))
                return true;
            for (auto it: m_StreamingDestinationsByPorts)
                if (it.second->DeleteStream(recvStreamID))
                    return true;
            return false;
        }

        RunnableClientDestination::RunnableClientDestination(const i2p::data::PrivateKeys &keys, bool isPublic,
                                                             const std::map<std::string, std::string> *params) :
                RunnableService("Destination"),
                ClientDestination(GetIOService(), keys, isPublic, params) {
        }

        RunnableClientDestination::~RunnableClientDestination() {
            if (IsRunning())
                Stop();
        }

        void RunnableClientDestination::Start() {
            if (!IsRunning()) {
                ClientDestination::Start();
                StartIOService();
            }
        }

        void RunnableClientDestination::Stop() {
            if (IsRunning()) {
                ClientDestination::Stop();
                StopIOService();
            }
        }

    }
}