use lock_guard for streams mutex

Author: pobregat0

daemon/I2PControl.cpp

@@ -90,6 +90,7 @@ namespace client
 		m_MethodHandlers["RouterManager"]      = &I2PControlService::RouterManagerHandler;
 		m_MethodHandlers["NetworkSetting"]     = &I2PControlHandlers::NetworkSettingHandler;
 		m_MethodHandlers["ClientServicesInfo"] = &I2PControlHandlers::ClientServicesInfoHandler;
+		m_MethodHandlers["LocalDestinationInfo"] = &I2PControlHandlers::LocalDestinationInfoHandler;
 
 		// I2PControl
 		m_I2PControlHandlers["i2pcontrol.password"] = &I2PControlService::PasswordHandler;
@@ -465,6 +466,7 @@ namespace client
 		X509_NAME_add_entry_by_txt (name, "C",  MBSTRING_ASC, (unsigned char *)"A1", -1, -1, 0); // country (Anonymous proxy)
 		X509_NAME_add_entry_by_txt (name, "O",  MBSTRING_ASC, (unsigned char *)I2P_CONTROL_CERTIFICATE_ORGANIZATION, -1, -1, 0); // organization
 		X509_NAME_add_entry_by_txt (name, "CN", MBSTRING_ASC, (unsigned char *)I2P_CONTROL_CERTIFICATE_COMMON_NAME, -1, -1, 0); // common name
+		X509_set_subject_name (x509, name);
 		X509_set_issuer_name (x509, name); // set issuer to ourselves
 		X509_sign (x509, pkey, EVP_sha1 ()); // sign, last param must be NULL for EdDSA
 		X509_NAME_free (name);

daemon/I2PControlHandlers.cpp

@@ -100,6 +100,53 @@ namespace client
 		ss << "\"" << name << "\":" << buf.str();
 	}
 
+// LocalDestinationInfo
+
+	void I2PControlHandlers::LocalDestinationInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
+	{
+		auto& addressBook = i2p::client::context.GetAddressBook ();
+		auto addr = addressBook.GetAddress (params.get<std::string> ("destination", ""));
+		auto dest = addr && addr->IsIdentHash () ?
+			i2p::client::context.FindLocalDestination (addr->identHash) : nullptr;
+		if (!dest)
+		{
+			InsertParam (results, "error", std::string ("destination not found"));
+			return;
+		}
+		InsertParam (results, "destination", addressBook.ToAddress (dest->GetIdentHash ()));
+
+		// arrays are written by hand: write_json makes an array only below the root
+		results << ",\"leasesets\":[";
+		bool first = true;
+		for (const auto& it: dest->GetLeaseSetsList ())
+		{
+			if (!it) continue;
+			boost::property_tree::ptree ls;
+			ls.put ("address", addressBook.ToAddress (it->GetIdentHash ()));
+			ls.put ("type", (int)it->GetStoreType ());
+			ls.put ("encType", (int)it->GetEncryptionType ());
+			if (!first) results << ",";
+			first = false;
+			boost::property_tree::write_json (results, ls, false);
+		}
+		results << "],\"streams\":[";
+		first = true;
+		for (const auto& it: dest->GetAllStreams ())
+		{
+			if (!it) continue;
+			auto identity = it->GetRemoteIdentity ();
+			boost::property_tree::ptree st;
+			st.put ("id", it->GetRecvStreamID ());
+			st.put ("destination", identity ? addressBook.ToAddress (identity->GetIdentHash ()) : "");
+			st.put ("sent", it->GetNumSentBytes ());
+			st.put ("received", it->GetNumReceivedBytes ());
+			if (!first) results << ",";
+			first = false;
+			boost::property_tree::write_json (results, st, false);
+		}
+		results << "]";
+	}
+
 // RouterInfo
 
 	void I2PControlHandlers::RouterInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
@@ -308,13 +355,15 @@ namespace client
 
 	void I2PControlHandlers::ClientServicesInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
 	{
+		bool first = true;
 		for (auto it = params.begin (); it != params.end (); it++)
 		{
 			LogPrint (eLogDebug, "I2PControl: ClientServicesInfo request: ", it->first);
 			auto it1 = m_ClientServicesInfoHandlers.find (it->first);
 			if (it1 != m_ClientServicesInfoHandlers.end ())
 			{
-				if (it != params.begin ()) results << ",";
+				if (!first) results << ",";
+				else first = false;
 				(this->*(it1->second))(results);
 			}
 			else

daemon/I2PControlHandlers.h

@@ -29,6 +29,7 @@ namespace client
 			void RouterInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results);
 			void NetworkSettingHandler (const boost::property_tree::ptree& params, std::ostringstream& results);
 			void ClientServicesInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results);
+			void LocalDestinationInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results);
 
 		protected:
 

libi2pd/Destination.cpp

@@ -1447,13 +1447,12 @@ namespace client
 	{
 		std::vector<std::shared_ptr<const i2p::stream::Stream> > ret;
 		if (m_StreamingDestination)
+			ret = m_StreamingDestination->GetStreamsList ();
+		for (auto& it: m_StreamingDestinationsByPorts)
 		{
-			for (auto& it: m_StreamingDestination->GetStreams ())
-				ret.push_back (it.second);
+			auto streams = it.second->GetStreamsList ();
+			ret.insert (ret.end (), streams.begin (), streams.end ());
 		}
-		for (auto& it: m_StreamingDestinationsByPorts)
-			for (auto& it1: it.second->GetStreams ())
-				ret.push_back (it1.second);
 		return ret;
 	}
 

libi2pd/Destination.h

@@ -12,6 +12,7 @@
 #include <string.h>
 #include <thread>
 #include <mutex>
+#include <vector>
 #include <memory>
 #include <map>
 #include <unordered_map>
@@ -235,6 +236,16 @@ namespace client
 			// for HTTP only
 			int GetNumRemoteLeaseSets () const { return m_RemoteLeaseSets.size (); };
 			const decltype(m_RemoteLeaseSets)& GetLeaseSets () const { return m_RemoteLeaseSets; };
+			// copy for other threads, unlike GetLeaseSets which hands out the container itself
+			std::vector<std::shared_ptr<i2p::data::LeaseSet> > GetLeaseSetsList () const
+			{
+				std::lock_guard<std::mutex> lock(m_RemoteLeaseSetsMutex);
+				std::vector<std::shared_ptr<i2p::data::LeaseSet> > leaseSets;
+				leaseSets.reserve (m_RemoteLeaseSets.size ());
+				for (const auto& it: m_RemoteLeaseSets)
+					leaseSets.push_back (it.second);
+				return leaseSets;
+			}
 			bool IsEncryptedLeaseSet () const { return m_LeaseSetType == i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2; };
 			bool IsPerClientAuth () const { return m_AuthType > 0; };
 	};

libi2pd/Streaming.cpp

@@ -2162,7 +2162,7 @@ namespace stream
 		m_PendingIncomingTimer.cancel ();
 		m_PendingIncomingStreams.clear ();
 		{
-			std::unique_lock<std::mutex> l(m_StreamsMutex);
+			std::lock_guard<std::mutex> l(m_StreamsMutex);
 			for (auto it: m_Streams)
 				it.second->Terminate (false); // we delete here
 			m_Streams.clear ();
@@ -2326,7 +2326,7 @@ namespace stream
 	std::shared_ptr<Stream> StreamingDestination::CreateNewOutgoingStream (std::shared_ptr<const i2p::data::LeaseSet> remote, int port)
 	{
 		auto s = std::make_shared<Stream> (m_Owner->GetService (), *this, remote, port);
-		std::unique_lock<std::mutex> l(m_StreamsMutex);
+		std::lock_guard<std::mutex> l(m_StreamsMutex);
 		m_Streams.emplace (s->GetRecvStreamID (), s);
 		return s;
 	}
@@ -2340,7 +2340,7 @@ namespace stream
 	std::shared_ptr<Stream> StreamingDestination::CreateNewIncomingStream (uint32_t receiveStreamID)
 	{
 		auto s = std::make_shared<Stream> (m_Owner->GetService (), *this);
-		std::unique_lock<std::mutex> l(m_StreamsMutex);
+		std::lock_guard<std::mutex> l(m_StreamsMutex);
 		m_Streams.emplace (s->GetRecvStreamID (), s);
 		m_IncomingStreams.emplace (receiveStreamID, s);
 		return s;
@@ -2350,7 +2350,7 @@ namespace stream
 	{
 		if (stream)
 		{
-			std::unique_lock<std::mutex> l(m_StreamsMutex);
+			std::lock_guard<std::mutex> l(m_StreamsMutex);
 			m_Streams.erase (stream->GetRecvStreamID ());
 			if (stream->IsIncoming ())
 				m_IncomingStreams.erase (stream->GetSendStreamID ());
@@ -2375,6 +2375,15 @@ namespace stream
 		}
 	}
 
+	std::vector<std::shared_ptr<const Stream> > StreamingDestination::GetStreamsList ()
+	{
+		std::vector<std::shared_ptr<const Stream> > streams;
+		std::lock_guard<std::mutex> l(m_StreamsMutex);
+		for (const auto& it: m_Streams)
+			streams.push_back (it.second);
+		return streams;
+	}
+
 	bool StreamingDestination::DeleteStream (uint32_t recvStreamID)
 	{
 		auto it = m_Streams.find (recvStreamID);

libi2pd/Streaming.h

@@ -14,6 +14,7 @@
 #include <unordered_map>
 #include <set>
 #include <queue>
+#include <vector>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -391,6 +392,9 @@ namespace stream
 
 			// for HTTP only
 			const decltype(m_Streams)& GetStreams () const { return m_Streams; };
+
+			// copy for other threads, unlike GetStreams which hands out the map itself
+			std::vector<std::shared_ptr<const Stream> > GetStreamsList ();
 	};
 
 //-------------------------------------------------