proxy: don't use shared_ptr for Identity

include/opendht/dht_proxy_server.h

@@ -79,7 +79,7 @@ public:
      * it will fails silently
      */
     DhtProxyServer(
-       std::shared_ptr<dht::crypto::Identity> identity,
+       dht::crypto::Identity identity,
        std::shared_ptr<DhtRunner> dht, in_port_t port = 8000, const std::string& pushServer = "",
        std::shared_ptr<dht::Logger> logger = {});
 
@@ -327,7 +327,6 @@ private:
     std::unique_ptr<restinio::http_server_t<RestRouterTraits>> httpServer_;
     std::unique_ptr<asio::const_buffer> pk_;
     std::unique_ptr<asio::const_buffer> cc_;
-    std::shared_ptr<dht::crypto::Identity> serverIdentity_;
 
     // http client
     std::pair<std::string, std::string> pushHostPort_;

src/dht_proxy_server.cpp

@@ -88,11 +88,11 @@ struct RestRouterTraits : public restinio::default_traits_t
 };
 
 DhtProxyServer::DhtProxyServer(
-    std::shared_ptr<dht::crypto::Identity> identity,
+    dht::crypto::Identity identity,
     std::shared_ptr<DhtRunner> dht, in_port_t port, const std::string& pushServer,
     std::shared_ptr<dht::Logger> logger
 )
-    :   dht_(dht), serverIdentity_(identity), logger_(logger), lockListener_(std::make_shared<std::mutex>()),
+    :   dht_(dht), logger_(logger), lockListener_(std::make_shared<std::mutex>()),
         listeners_(std::make_shared<std::map<restinio::connection_id_t, http::ListenerSession>>()),
         connListener_(std::make_shared<http::ConnectionListener>(dht, listeners_, lockListener_, logger)),
         pushServer_(pushServer)
@@ -115,7 +115,7 @@ DhtProxyServer::DhtProxyServer(
     jsonBuilder_["commentStyle"] = "None";
     jsonBuilder_["indentation"] = "";
 
-    if (identity){
+    if (identity.first and identity.second) {
         // define tls context
         asio::ssl::context tls_context { asio::ssl::context::sslv23 };
         tls_context.set_options(asio::ssl::context::default_workarounds
@@ -124,13 +124,13 @@ DhtProxyServer::DhtProxyServer(
         // save keys in memory & set in tls context
         asio::error_code ec;
         // node private key
-        auto pk = identity->first->serialize(); // returns Blob
+        auto pk = identity.first->serialize(); // returns Blob
         pk_ = std::make_unique<asio::const_buffer>(static_cast<void*>(pk.data()), (std::size_t) pk.size());
         tls_context.use_private_key(*pk_, asio::ssl::context::file_format::pem, ec);
         if (ec)
             throw std::runtime_error("Error setting node's private key: " + ec.message());
         // certificate chain
-        auto cc = identity->second->toString(true/*chain*/);
+        auto cc = identity.second->toString(true/*chain*/);
         cc_ = std::make_unique<asio::const_buffer>(static_cast<const void*>(cc.data()), (std::size_t) cc.size());
         tls_context.use_certificate_chain(*cc_, ec);
         if (ec)

tests/dhtproxytester.cpp

@@ -41,10 +41,8 @@ DhtProxyTester::setUp() {
     nodeProxy->run(0, /*identity*/{}, /*threaded*/true);
     nodeProxy->bootstrap(nodePeer.getBound());
 
-    serverCAIdentity = std::make_unique<dht::crypto::Identity>(
-        dht::crypto::generateEcIdentity("DHT Node CA"));
-    serverIdentity = std::make_shared<dht::crypto::Identity>(
-        dht::crypto::generateIdentity("DHT Node", *serverCAIdentity));
+    auto serverCAIdentity = dht::crypto::generateEcIdentity("DHT Node CA");
+    auto serverIdentity = dht::crypto::generateIdentity("DHT Node", serverCAIdentity);
 
     serverProxy = std::unique_ptr<dht::DhtProxyServer>(
         new dht::DhtProxyServer(
@@ -52,7 +50,7 @@ DhtProxyTester::setUp() {
             /*https*/serverIdentity,
             nodeProxy, 8080, /*pushServer*/"127.0.0.1:8090", logger));
 
-    clientConfig.client_cert = serverIdentity->second;
+    clientConfig.client_cert = serverIdentity.second;
     clientConfig.dht_config.node_config.maintain_storage = false;
     clientConfig.threaded = true;
     clientConfig.push_node_id = "dhtnode";

tests/dhtproxytester.h

@@ -66,11 +66,6 @@ class DhtProxyTester : public CppUnit::TestFixture {
 
     std::shared_ptr<dht::DhtRunner> nodeClient;
     std::shared_ptr<dht::DhtRunner> nodeProxy;
-
-#ifdef OPENDHT_PUSH_NOTIFICATIONS
-    std::shared_ptr<dht::crypto::Identity> serverIdentity;
-    std::unique_ptr<dht::crypto::Identity> serverCAIdentity;
-#endif
     std::unique_ptr<dht::DhtProxyServer> serverProxy;
 
     dht::DhtRunner::Context clientContext {};

tools/dhtnode.cpp

@@ -227,8 +227,7 @@ void cmd_loop(std::shared_ptr<DhtRunner>& node, dht_params& params
                 unsigned int port = std::stoi(idstr);
                 proxies.emplace(port, std::unique_ptr<DhtProxyServer>(
                     new DhtProxyServer(
-                        params.generate_identity ? std::make_shared<dht::crypto::Identity>(params.id) : nullptr,
-                        node, port
+                        params.generate_identity ? params.id : dht::crypto::Identity{}, node, port
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
                         ,pushServer
 #endif
@@ -562,7 +561,7 @@ main(int argc, char **argv)
 #ifdef OPENDHT_PROXY_SERVER
             proxies.emplace(params.proxyserver, std::unique_ptr<DhtProxyServer>(
                 new DhtProxyServer(
-                    params.generate_identity ? std::make_shared<dht::crypto::Identity>(params.id) : nullptr,
+                    params.generate_identity ? params.id : dht::crypto::Identity{},
                     node, params.proxyserver, params.pushserver, context.logger)));
 #else
             std::cerr << "DHT proxy server requested but OpenDHT built without proxy server support." << std::endl;