fix code syle(spaces->tabs, tabulations)

Signed-off-by: R4SAS <r4sas@i2pmail.org>

daemon/Daemon.cpp

@@ -172,10 +172,13 @@ namespace i2p
 			SetMaxNumTransitTunnels (transitTunnels);
 
 			bool isFloodfill; i2p::config::GetOption("floodfill", isFloodfill);
-			if (isFloodfill) {
+			if (isFloodfill)
+			{
 				LogPrint(eLogInfo, "Daemon: router will be floodfill");
 				i2p::context.SetFloodfill (true);
-			}	else {
+			}
+			else
+			{
 				i2p::context.SetFloodfill (false);
 			}
 
@@ -243,7 +246,8 @@ namespace i2p
 					i2p::transport::transports.RestrictRoutesToFamilies(fams);
 					restricted  = fams.size() > 0;
 				}
-				if (routers.length() > 0) {
+				if (routers.length() > 0)
+				{
 					std::set<i2p::data::IdentHash> idents;
 					size_t pos = 0, comma;
 					do
@@ -279,7 +283,8 @@ namespace i2p
 			i2p::data::netdb.Start();
 
 			bool upnp; i2p::config::GetOption("upnp.enabled", upnp);
-			if (upnp) {
+			if (upnp)
+			{
 				d.UPnP = std::unique_ptr<i2p::transport::UPnP>(new i2p::transport::UPnP);
 				d.UPnP->Start ();
 			}
@@ -310,7 +315,8 @@ namespace i2p
 			}
 
 			bool http; i2p::config::GetOption("http.enabled", http);
-			if (http) {
+			if (http)
+			{
 				std::string httpAddr; i2p::config::GetOption("http.address", httpAddr);
 				uint16_t    httpPort; i2p::config::GetOption("http.port", httpPort);
 				LogPrint(eLogInfo, "Daemon: starting webconsole at ", httpAddr, ":", httpPort);
@@ -326,7 +332,6 @@ namespace i2p
 				}
 			}
 
-
 			LogPrint(eLogInfo, "Daemon: starting Tunnels");
 			i2p::tunnel::tunnels.Start();
 

daemon/Daemon.h

@@ -13,6 +13,7 @@ namespace util
 	class Daemon_Singleton
 	{
 		public:
+
 			virtual bool init(int argc, char* argv[], std::shared_ptr<std::ostream> logstream);
 			virtual bool init(int argc, char* argv[]);
 			virtual bool start();
@@ -23,6 +24,7 @@ namespace util
 			bool running;
 
 		protected:
+
 			Daemon_Singleton();
 			virtual ~Daemon_Singleton();
 
@@ -39,6 +41,7 @@ namespace util
 	class DaemonQT: public i2p::util::Daemon_Singleton
 	{
 		public:
+
 			static DaemonQT& Instance()
 			{
 				static DaemonQT instance;
@@ -51,6 +54,7 @@ namespace util
 	class DaemonWin32 : public Daemon_Singleton
 	{
 		public:
+
 			static DaemonWin32& Instance()
 			{
 				static DaemonWin32 instance;
@@ -72,6 +76,7 @@ namespace util
 	class DaemonAndroid: public i2p::util::Daemon_Singleton
 	{
 		public:
+
 			static DaemonAndroid& Instance()
 			{
 				static DaemonAndroid instance;
@@ -83,6 +88,7 @@ namespace util
 	class DaemonLinux : public Daemon_Singleton
 	{
 		public:
+
 			static DaemonLinux& Instance()
 			{
 				static DaemonLinux instance;
@@ -94,10 +100,12 @@ namespace util
 			void run ();
 
 		private:
+
 			std::string pidfile;
 			int pidFH;
 
 		public:
+
 			int gracefulShutdownInterval; // in seconds
 	};
 #endif

daemon/I2PControl.cpp

@@ -80,8 +80,7 @@ namespace client
 		m_RouterInfoHandlers["i2p.router.net.bw.outbound.1s"]        = &I2PControlService::OutboundBandwidth1S;
 		m_RouterInfoHandlers["i2p.router.net.status"]                = &I2PControlService::NetStatusHandler;
 		m_RouterInfoHandlers["i2p.router.net.tunnels.participating"] = &I2PControlService::TunnelsParticipatingHandler;
-		m_RouterInfoHandlers["i2p.router.net.tunnels.successrate"] =
+		m_RouterInfoHandlers["i2p.router.net.tunnels.successrate"]   = &I2PControlService::TunnelsSuccessRateHandler;
-&I2PControlService::TunnelsSuccessRateHandler;
 		m_RouterInfoHandlers["i2p.router.net.total.received.bytes"]  = &I2PControlService::NetTotalReceivedBytes;
 		m_RouterInfoHandlers["i2p.router.net.total.sent.bytes"]      = &I2PControlService::NetTotalSentBytes;
 

daemon/I2PControl.h

@@ -27,6 +27,7 @@ namespace client
 	class I2PControlService
 	{
 		typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;
+
 		public:
 
 			I2PControlService (const std::string& address, int port);

daemon/UnixDaemon.cpp

@@ -196,5 +196,4 @@ namespace i2p
 		}
 	}
 }
-
 #endif

daemon/i2pd.cpp

@@ -2,7 +2,6 @@
 #include "Daemon.h"
 
 #if defined(QT_GUI_LIB)
-
 namespace i2p
 {
 namespace qt
@@ -10,11 +9,11 @@ namespace qt
 	int RunQT (int argc, char* argv[]);
 }
 }
+
 int main( int argc, char* argv[] )
 {
 	return i2p::qt::RunQT (argc, argv);
 }
-
 #else
 int main( int argc, char* argv[] )
 {

libi2pd/Base.cpp

@@ -7,7 +7,8 @@ namespace i2p
 {
 namespace data
 {
-	static const char T32[32] = {
+	static const char T32[32] =
+	{
 		'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
 		'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
 		'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
@@ -29,7 +30,8 @@ namespace data
 	* Direct Substitution Table
 	*/
 
-	static const char T64[64] = {
+	static const char T64[64] =
+	{
 		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
 		'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
 		'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
@@ -67,14 +69,12 @@ namespace data
 	*
 	*/
 
-	size_t                                /* Number of bytes in the encoded buffer */
+	size_t ByteStreamToBase64 (   /* Number of bytes in the encoded buffer */
-	ByteStreamToBase64 (
 		const uint8_t * InBuffer, /* Input buffer, binary data */
 		size_t InCount,           /* Number of bytes in the input buffer */
 		char * OutBuffer,         /* output buffer */
 		size_t len                /* length of output buffer */
 	)
-
 	{
 		unsigned char * ps;
 		unsigned char * pd;
@@ -92,9 +92,12 @@ namespace data
 			outCount = 4 * n;
 		else
 			outCount = 4 * (n + 1);
+
 		if (outCount > len) return 0;
+
 		pd = (unsigned char *)OutBuffer;
-		for ( i = 0; i<n; i++ ){
+		for ( i = 0; i < n; i++ )
+		{
 			acc_1 = *ps++;
 			acc_2 = (acc_1 << 4) & 0x30;
 			acc_1 >>= 2;                 /* base64 digit #1 */
@@ -110,7 +113,8 @@ namespace data
 			acc_2 &= 0x3f;               /* base64 digit #4 */
 			*pd++ = T64[acc_2];
 		}
-		if ( m == 1 ){
+		if ( m == 1 )
+		{
 			acc_1 = *ps++;
 			acc_2 = (acc_1 << 4) & 0x3f; /* base64 digit #2 */
 			acc_1 >>= 2;                 /* base64 digit #1 */
@@ -120,7 +124,8 @@ namespace data
 			*pd++ = P64;
 
 		}
-		else if ( m == 2 ){
+		else if ( m == 2 )
+		{
 			acc_1 = *ps++;
 			acc_2 = (acc_1 << 4) & 0x3f;
 			acc_1 >>= 2;                 /* base64 digit #1 */
@@ -147,8 +152,7 @@ namespace data
 	*
 	*/
 
-	size_t                              /* Number of output bytes */
+	size_t Base64ToByteStream ( /* Number of output bytes */
-	Base64ToByteStream (
 		const char * InBuffer,  /* BASE64 encoded buffer */
 		size_t InCount,         /* Number of input bytes */
 		uint8_t * OutBuffer,    /* output buffer length */
@@ -164,36 +168,46 @@ namespace data
 		int             m;
 		size_t          outCount;
 
-		if (isFirstTime) iT64Build();
+		if (isFirstTime)
+			iT64Build();
+
 		n = InCount / 4;
 		m = InCount % 4;
+
 		if (InCount && !m)
 			outCount = 3 * n;
-		else {
+		else
+		{
 			outCount = 0;
 			return 0;
 		}
 
 		ps = (unsigned char *)(InBuffer + InCount - 1);
-		while ( *ps-- == P64 ) outCount--;
+		while ( *ps-- == P64 )
+			outCount--;
 		ps = (unsigned char *)InBuffer;
 
-		if (outCount > len) return -1;
+		if (outCount > len)
+			return -1;
+
 		pd = OutBuffer;
 		auto endOfOutBuffer = OutBuffer + outCount;
-		for ( i = 0; i < n; i++ ){
+		for ( i = 0; i < n; i++ )
+		{
 			acc_1 = iT64[*ps++];
 			acc_2 = iT64[*ps++];
 			acc_1 <<= 2;
 			acc_1 |= acc_2 >> 4;
 			*pd++ = acc_1;
-			 if (pd >= endOfOutBuffer) break;
+			if (pd >= endOfOutBuffer)
+				break;
 
 			acc_2 <<= 4;
 			acc_1 = iT64[*ps++];
 			acc_2 |= acc_1 >> 2;
 			*pd++ = acc_2;
-			  if (pd >= endOfOutBuffer) break;
+			if (pd >= endOfOutBuffer)
+				break;
 
 			acc_2 = iT64[*ps++];
 			acc_2 |= acc_1 << 6;
@@ -206,7 +220,9 @@ namespace data
 	size_t Base64EncodingBufferSize (const size_t input_size)
 	{
 		auto d = div (input_size, 3);
-		if (d.rem) d.quot++;
+		if (d.rem)
+			d.quot++;
+
 		return 4 * d.quot;
 	}
 
@@ -218,8 +234,11 @@ namespace data
 		str[l] = 0;
 		// replace '-' by '+' and '~' by '/'
 		for (size_t i = 0; i < l; i++)
-			if (str[i] == '-') str[i] = '+';
+			if (str[i] == '-')
-			else if (str[i] == '~') str[i] = '/';
+				str[i] = '+';
+			else if (str[i] == '~')
+				str[i] = '/';
+
 		std::string s(str);
 		delete[] str;
 		return s;
@@ -302,4 +321,3 @@ namespace data
 	}
 }
 }
-

libi2pd/Blinding.cpp

@@ -314,4 +314,3 @@ namespace data
 
 }
 }
-

libi2pd/ChaCha20.cpp

@@ -78,7 +78,6 @@ void block (Chacha20State &input, int rounds)
 	}
 	x += input;
 	input.block << x;
-
 }
 
 void Chacha20Init (Chacha20State& state, const uint8_t * nonce, const uint8_t * key, uint32_t counter)
@@ -130,9 +129,9 @@ void Chacha20Encrypt (Chacha20State& state, uint8_t * buf, size_t sz)
 		}
 	}
 }
+
 } // namespace chacha
+} // namespace crypto
+} // namespace i2p
 
-}
-}
 #endif
-

libi2pd/ChaCha20.h

@@ -64,9 +64,9 @@ namespace chacha
 	void Chacha20Init (Chacha20State& state, const uint8_t * nonce, const uint8_t * key, uint32_t counter);
 	void Chacha20SetCounter (Chacha20State& state, uint32_t counter);
 	void Chacha20Encrypt (Chacha20State& state, uint8_t * buf, size_t sz); // encrypt buf in place
-}
+} // namespace chacha
-} 
+} // namespace crypto
-}
+} // namespace i2p
-#endif
 
 #endif
+#endif

libi2pd/Config.h

@@ -63,7 +63,8 @@ namespace config {
 	 */
 	void Finalize();
 
-  /* @brief  Accessor to parameters by name
+	/**
+	 * @brief  Accessor to parameters by name
 	 * @param  name  Name of the requested parameter
 	 * @param  value Variable where to store option
 	 * @return this function returns false if parameter not found
@@ -71,7 +72,8 @@ namespace config {
 	 * Example: uint16_t port; GetOption("sam.port", port);
 	 */
 	template<typename T>
-  bool GetOption(const char *name, T& value) {
+	bool GetOption(const char *name, T& value)
+	{
 		if (!m_Options.count(name))
 			return false;
 		value = m_Options[name].as<T>();
@@ -96,7 +98,8 @@ namespace config {
 	 * Example: uint16_t port = 2827; SetOption("bob.port", port);
 	 */
 	template<typename T>
-  bool SetOption(const char *name, const T& value) {
+	bool SetOption(const char *name, const T& value)
+	{
 		if (!m_Options.count(name))
 			return false;
 		m_Options.at(name).value() = value;

libi2pd/Crypto.cpp

@@ -884,7 +884,6 @@ namespace crypto
 		}
 	}
 
-
 	void CBCEncryption::Encrypt (int numBlocks, const ChipherBlock * in, ChipherBlock * out)
 	{
 #ifdef __AES__
@@ -1364,4 +1363,3 @@ namespace crypto
 	}
 }
 }
-

libi2pd/CryptoKey.cpp

@@ -178,4 +178,3 @@ namespace crypto
 	}
 }
 }
-

libi2pd/CryptoKey.h

@@ -153,4 +153,3 @@ namespace crypto
 }
 
 #endif
-

libi2pd/CryptoWorker.h

@@ -77,5 +77,4 @@ namespace worker
 }
 }
 
-
 #endif

libi2pd/Datagram.cpp

@@ -114,7 +114,6 @@ namespace datagram
 			LogPrint (eLogWarning, "Datagram: decompression failed");
 	}
 
-		
 	std::shared_ptr<I2NPMessage> DatagramDestination::CreateDataMessage (
 		const std::vector<std::pair<const uint8_t *, size_t> >& payloads,
 		uint16_t fromPort, uint16_t toPort, bool isRaw, bool checksum)
@@ -384,4 +383,3 @@ namespace datagram
 	}
 }
 }
-

libi2pd/Datagram.h

@@ -37,7 +37,9 @@ namespace datagram
 
 	class DatagramSession : public std::enable_shared_from_this<DatagramSession>
 	{
+
 		public:
+
 			DatagramSession(std::shared_ptr<i2p::client::ClientDestination> localDestination, const i2p::data::IdentHash & remoteIdent);
 
 			void Start ();
@@ -84,6 +86,7 @@ namespace datagram
 			void HandleLeaseSetUpdated(std::shared_ptr<i2p::data::LeaseSet> ls);
 
 		private:
+
 			std::shared_ptr<i2p::client::ClientDestination> m_LocalDestination;
 			i2p::data::IdentHash m_RemoteIdent;
 			std::shared_ptr<const i2p::data::LeaseSet> m_RemoteLeaseSet;
@@ -104,10 +107,8 @@ namespace datagram
 		typedef std::function<void (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)> Receiver;
 		typedef std::function<void (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)> RawReceiver;
 
-		
 		public:
 
-
 			DatagramDestination (std::shared_ptr<i2p::client::ClientDestination> owner, bool gzip);
 			~DatagramDestination ();
 

libi2pd/Destination.cpp

@@ -160,7 +160,6 @@ namespace client
 
 	bool LeaseSetDestination::Reconfigure(std::map<std::string, std::string> params)
 	{
-		
 		auto itr = params.find("i2cp.dontPublishLeaseSet");
 		if (itr != params.end())
 		{

libi2pd/Destination.h

@@ -94,7 +94,6 @@ namespace client
 			}
 		};
 
-
 		public:
 
 			LeaseSetDestination (boost::asio::io_service& service, bool isPublic, const std::map<std::string, std::string> * params = nullptr);

libi2pd/ECIESX25519AEADRatchetSession.cpp

@@ -432,7 +432,7 @@ namespace garlic
 		i2p::crypto::HKDF (m_CK, sharedSecret, 32, "", m_CK); // [chainKey, key] = HKDF(chainKey, sharedSecret, "", 64)
 		uint8_t nonce[12];
 		CreateNonce (0, nonce);
-        // calulate hash for zero length
+		// calculate hash for zero length
 		if (!i2p::crypto::AEADChaCha20Poly1305 (nonce /* can be anything */, 0, m_H, 32, m_CK + 32, nonce, out + offset, 16, true)) // encrypt, ciphertext = ENCRYPT(k, n, ZEROLEN, ad)
 		{
 			LogPrint (eLogWarning, "Garlic: Reply key section AEAD encryption failed");
@@ -469,7 +469,7 @@ namespace garlic
 		uint64_t tag = m_NSRTagset->GetNextSessionTag (); // next tag
 		memcpy (out, &tag, 8);
 		memcpy (out + 8, m_NSREncodedKey, 32);
-		// recalculte h with new tag
+		// recalculate h with new tag
 		memcpy (m_H, m_NSRH, 32);
 		MixHash ((const uint8_t *)&tag, 8); // h = SHA256(h || tag)
 		MixHash (m_EphemeralKeys.GetPublicKey (), 32); // h = SHA256(h || bepk)
@@ -518,8 +518,8 @@ namespace garlic
 		}
 		uint8_t nonce[12];
 		CreateNonce (0, nonce);
-        // calulate hash for zero length
+		// calculate hash for zero length
-		if (!i2p::crypto::AEADChaCha20Poly1305 (buf, 0, m_H, 32, m_CK + 32, nonce, sharedSecret/* can be anyting */, 0, false)) // decrypt, DECRYPT(k, n, ZEROLEN, ad) verification only
+		if (!i2p::crypto::AEADChaCha20Poly1305 (buf, 0, m_H, 32, m_CK + 32, nonce, sharedSecret/* can be anything */, 0, false)) // decrypt, DECRYPT(k, n, ZEROLEN, ad) verification only
 		{
 			LogPrint (eLogWarning, "Garlic: Reply key section AEAD decryption failed");
 			return false;
@@ -909,5 +909,3 @@ namespace garlic
 
 }
 }
-
-

libi2pd/Ed25519.cpp

@@ -597,4 +597,3 @@ namespace crypto
 	}
 }
 }
-

libi2pd/Ed25519.h

@@ -128,6 +128,4 @@ namespace crypto
 }
 }
 
-
 #endif
-

libi2pd/Elligator.cpp

@@ -204,4 +204,3 @@ namespace crypto
 	}
 }
 }
-

libi2pd/Elligator.h

@@ -35,5 +35,3 @@ namespace crypto
 }
 
 #endif
-
-

libi2pd/FS.h

@@ -35,8 +35,10 @@ namespace fs {
 	 * std::vector<std::string> files;
 	 * h.Traverse(files);   <- finds all files in storage and saves in given vector
 	 */
-  class HashedStorage {
+	class HashedStorage
+	{
 		protected:
+
 			std::string root;    /**< path to storage with it's name included */
 			std::string name;    /**< name of the storage */
 			std::string prefix1; /**< hashed directory prefix */
@@ -44,6 +46,7 @@ namespace fs {
 			std::string suffix;  /**< suffix of file in storage (extension) */
 
 		public:
+
 			typedef std::function<void(const std::string &)> FilenameVisitor;
 			HashedStorage(const char *n, const char *p1, const char *p2, const char *s):
 				name(n), prefix1(p1), prefix2(p2), suffix(s) {};

libi2pd/Family.cpp

@@ -179,4 +179,3 @@ namespace data
 	}
 }
 }
-

libi2pd/Garlic.h

@@ -143,6 +143,7 @@ namespace garlic
 			std::shared_ptr<GarlicRoutingPath> m_SharedRoutingPath;
 
 		public:
+
 			// for HTTP only
 			virtual size_t GetNumOutgoingTags () const { return 0; };
 	};
@@ -196,6 +197,7 @@ namespace garlic
 			i2p::crypto::CBCEncryption m_Encryption;
 
 		public:
+
 			// for HTTP only
 			size_t GetNumOutgoingTags () const { return m_SessionTags.size (); };
 	};

libi2pd/Gzip.h

@@ -45,7 +45,6 @@ namespace data
 
 	size_t GzipNoCompression (const uint8_t * in, uint16_t inLen, uint8_t * out, size_t outLen); // for < 64K
 	size_t GzipNoCompression (const std::vector<std::pair<const uint8_t *, size_t> >& bufs, uint8_t * out, size_t outLen); // for total size < 64K
-		
 } // data
 } // i2p
 

libi2pd/Identity.h

@@ -204,7 +204,7 @@ namespace data
 	IdentHash CreateRoutingKey (const IdentHash& ident);
 	XORMetric operator^(const IdentHash& key1, const IdentHash& key2);
 
-	// destination for delivery instuctions
+	// destination for delivery instructions
 	class RoutingDestination
 	{
 		public:
@@ -235,5 +235,4 @@ namespace data
 }
 }
 
-
 #endif

libi2pd/LeaseSet.cpp

@@ -12,7 +12,6 @@ namespace i2p
 {
 namespace data
 {
-
 	LeaseSet::LeaseSet (bool storeLeases):
 		m_IsValid (false), m_StoreLeases (storeLeases), m_ExpirationTime (0), m_EncryptionKey (nullptr),
 		m_Buffer (nullptr), m_BufferLen (0)
@@ -771,8 +770,7 @@ namespace data
 	}
 
 	LocalLeaseSet2::LocalLeaseSet2 (uint8_t storeType, const i2p::data::PrivateKeys& keys,
-		const KeySections& encryptionKeys, 
+		const KeySections& encryptionKeys, std::vector<std::shared_ptr<i2p::tunnel::InboundTunnel> > tunnels,
-		std::vector<std::shared_ptr<i2p::tunnel::InboundTunnel> > tunnels, 
 		bool isPublic, bool isPublishedEncrypted):
 		LocalLeaseSet (keys.GetPublic (), nullptr, 0)
 	{

libi2pd/LeaseSet.h

@@ -245,6 +245,7 @@ namespace data
 				const KeySections& encryptionKeys,
 				std::vector<std::shared_ptr<i2p::tunnel::InboundTunnel> > tunnels,
 				bool isPublic, bool isPublishedEncrypted = false);
+
 			LocalLeaseSet2 (uint8_t storeType, std::shared_ptr<const IdentityEx> identity, const uint8_t * buf, size_t len); // from I2CP
 
 			virtual ~LocalLeaseSet2 () { delete[] m_Buffer; };

libi2pd/Log.h

@@ -157,7 +157,7 @@ namespace log {
 	ThrowFunction GetThrowFunction ();
 	void SetThrowFunction (ThrowFunction f);
 } // log
-}
+} // i2p
 
 /** internal usage only -- folding args array to single string */
 template<typename TValue>

libi2pd/NTCP2.cpp

@@ -1200,7 +1200,7 @@ namespace transport
 								continue;
 							}
 
-							LogPrint (eLogInfo, "NTCP2: Start listening v6 TCP port ", address->port);
+							LogPrint (eLogInfo, "NTCP2: Start listening v4 TCP port ", address->port);
 							auto conn = std::make_shared<NTCP2Session>(*this);
 							m_NTCP2Acceptor->async_accept(conn->GetSocket (), std::bind (&NTCP2Server::HandleAccept, this, conn, std::placeholders::_1));
 						}

libi2pd/NTCP2.h

@@ -126,7 +126,6 @@ namespace transport
 	{
 		public:
 
-
 			NTCP2Session (NTCP2Server& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter = nullptr);
 			~NTCP2Session ();
 			void Terminate ();

libi2pd/NTCPSession.cpp

@@ -736,13 +736,11 @@ namespace transport
 		}
 	}
 
-
 	void NTCPSession::SendTimeSyncMessage ()
 	{
 		Send (nullptr);
 	}
 
-
 	void NTCPSession::SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs)
 	{
 		m_Server.GetService ().post (std::bind (&NTCPSession::PostI2NPMessages, shared_from_this (), msgs));
@@ -904,7 +902,6 @@ namespace transport
 		}
 	}
 
-
 	void NTCPServer::Run ()
 	{
 		while (m_IsRunning)

libi2pd/NetDb.hpp

@@ -123,6 +123,7 @@ namespace data
 
 			std::shared_ptr<const RouterInfo> AddRouterInfo (const uint8_t * buf, int len, bool& updated);
 			std::shared_ptr<const RouterInfo> AddRouterInfo (const IdentHash& ident, const uint8_t * buf, int len, bool& updated);
+
 			template<typename Filter>
 			std::shared_ptr<const RouterInfo> GetRandomRouter (Filter filter) const;
 

libi2pd/NetDbRequests.cpp

@@ -158,4 +158,3 @@ namespace data
 	}
 }
 }
-

libi2pd/NetDbRequests.h

@@ -66,4 +66,3 @@ namespace data
 }
 
 #endif
-

libi2pd/Poly1305.cpp

@@ -12,7 +12,6 @@ namespace i2p
 {
 namespace crypto
 {
-
 	void Poly1305HMAC(uint64_t * out, const uint64_t * key, const uint8_t * buf, std::size_t sz)
 	{
 		Poly1305 p(key);

libi2pd/Poly1305.h

@@ -1,9 +1,9 @@
 /**
-   This code is licensed under the MCGSI Public License
+ * This code is licensed under the MCGSI Public License
-   Copyright 2018 Jeff Becker
+ * Copyright 2018 Jeff Becker
-
+ *
-   Kovri go write your own code
+ * Kovri go write your own code
-
+ *
  */
 #ifndef LIBI2PD_POLY1305_H
 #define LIBI2PD_POLY1305_H
@@ -24,7 +24,6 @@ namespace crypto
 
 	namespace poly1305
 	{
-
 		struct LongBlock
 		{
 			unsigned long data[17];
@@ -252,8 +251,8 @@ namespace crypto
 		poly1305::LongBlock m_HR;
 		uint8_t m_Final;
 	};
+
 	void Poly1305HMAC(uint64_t * out, const uint64_t * key, const uint8_t * buf, std::size_t sz);
-
 }
 }
 #endif

libi2pd/Reseed.cpp

@@ -32,7 +32,8 @@ namespace data
 	{
 	}
 
-        /** @brief tries to bootstrap into I2P network (from local files and servers, with respect of options)
+	/**
+	 @brief tries to bootstrap into I2P network (from local files and servers, with respect of options)
 	 */
 	void Reseeder::Bootstrap ()
 	{
@@ -67,7 +68,8 @@ namespace data
 		}
 	}
 
-        /** @brief bootstrap from random server, retry 10 times
+	/**
+	 * @brief bootstrap from random server, retry 10 times
 	 * @return number of entries added to netDb
 	 */
 	int Reseeder::ReseedFromServers ()
@@ -95,7 +97,8 @@ namespace data
 		return 0;
 	}
 
-        /** @brief bootstrap from HTTPS URL with SU3 file
+	/**
+	 * @brief bootstrap from HTTPS URL with SU3 file
 	 * @param url
 	 * @return number of entries added to netDb
 	 */
@@ -702,4 +705,3 @@ namespace data
 	}
 }
 }
-

libi2pd/RouterInfo.cpp

@@ -173,7 +173,6 @@ namespace data
 			LogPrint (eLogError, "RouterInfo: malformed message");
 			m_IsUnreachable = true;
 		}
-
 	}
 
 	void RouterInfo::ReadFromStream (std::istream& s)
@@ -384,7 +383,8 @@ namespace data
 			SetUnreachable (true);
 	}
 
-  bool RouterInfo::IsFamily(const std::string & fam) const {
+	bool RouterInfo::IsFamily(const std::string & fam) const
+	{
 		return m_Family == fam;
 	}
 

libi2pd/SSU.cpp

@@ -826,4 +826,3 @@ namespace transport
 	}
 }
 }
-

libi2pd/SSU.h

@@ -135,4 +135,3 @@ namespace transport
 }
 
 #endif
-

libi2pd/SSUData.cpp

@@ -504,4 +504,3 @@ namespace transport
 	}
 }
 }
-

libi2pd/SSUData.h

@@ -128,4 +128,3 @@ namespace transport
 }
 
 #endif
-

libi2pd/SSUSession.cpp

@@ -1206,4 +1206,3 @@ namespace transport
 	}
 }
 }
-

libi2pd/SSUSession.h

@@ -158,10 +158,7 @@ namespace transport
 			std::unique_ptr<SignedData> m_SignedData; // we need it for SessionConfirmed only
 			std::map<uint32_t, std::shared_ptr<const i2p::data::RouterInfo> > m_RelayRequests; // nonce->Charlie
 	};
-
-
 }
 }
 
 #endif
-

libi2pd/Signature.cpp

@@ -135,5 +135,3 @@ namespace crypto
 #endif
 }
 }
-
-

libi2pd/Signature.h

@@ -527,4 +527,3 @@ namespace crypto
 }
 
 #endif
-

libi2pd/Siphash.h

@@ -1,9 +1,9 @@
 /**
-   This code is licensed under the MCGSI Public License
+ * This code is licensed under the MCGSI Public License
-   Copyright 2018 Jeff Becker
+ * Copyright 2018 Jeff Becker
-
+ *
-   Kovri go write your own code
+ * Kovri go write your own code
-
+ *
  */
 #ifndef SIPHASH_H
 #define SIPHASH_H

libi2pd/Tag.h

@@ -16,7 +16,6 @@
 
 namespace i2p {
 namespace data {
-
 	template<size_t sz>
 	class Tag
 	{
@@ -89,7 +88,6 @@ private:
 				uint64_t ll[sz/8];
 			};
 	};
-
 } // data
 } // i2p
 

libi2pd/Timestamp.cpp

@@ -200,4 +200,3 @@ namespace util
 	}
 }
 }
-

libi2pd/Timestamp.h

@@ -46,4 +46,3 @@ namespace util
 }
 
 #endif
-

libi2pd/TunnelEndpoint.cpp

@@ -64,8 +64,7 @@ namespace tunnel
 							m.hash = i2p::data::IdentHash (fragment);
 							fragment += 32; // to hash
 						break;
-						default:
+						default: ;
-							;
 					}
 
 					bool isFragmented = flag & 0x08;

libi2pd/TunnelGateway.cpp

@@ -219,4 +219,3 @@ namespace tunnel
 	}
 }
 }
-

libi2pd/TunnelPool.cpp

@@ -16,7 +16,6 @@ namespace i2p
 {
 namespace tunnel
 {
-
 	TunnelPool::TunnelPool (int numInboundHops, int numOutboundHops, int numInboundTunnels, int numOutboundTunnels):
 		m_NumInboundHops (numInboundHops), m_NumOutboundHops (numOutboundHops),
 		m_NumInboundTunnels (numInboundTunnels), m_NumOutboundTunnels (numOutboundTunnels), m_IsActive (true),
@@ -67,7 +66,8 @@ namespace tunnel
 		m_Tests.clear ();
 	}
 
-	bool TunnelPool::Reconfigure(int inHops, int outHops, int inQuant, int outQuant)	{
+	bool TunnelPool::Reconfigure(int inHops, int outHops, int inQuant, int outQuant)
+	{
 		if( inHops >= 0 && outHops >= 0 && inQuant > 0 && outQuant > 0)
 		{
 			m_NumInboundHops = inHops;

libi2pd/api.cpp

@@ -133,4 +133,3 @@ namespace api
 	}
 }
 }
-

libi2pd/api.h

@@ -35,4 +35,3 @@ namespace api
 }
 
 #endif
-

libi2pd/util.cpp

@@ -261,7 +261,9 @@ namespace net
 			sockaddr_in6 inputAddress;
 			inetpton(AF_INET6, localAddressUniversal.c_str(), &(inputAddress.sin6_addr));
 			return GetMTUWindowsIpv6(inputAddress, fallback);
-		} else {
+		}
+		else
+		{
 			LogPrint(eLogError, "NetIface: GetMTU(): address family is not supported");
 			return fallback;
 		}
@@ -379,7 +381,6 @@ namespace net
 			LogPrint(eLogWarning, "NetIface: cannot find ipv4 address for interface ", ifname);
 		}
 		return boost::asio::ip::address::from_string(fallback);
-
 #endif
 	}
 }

libi2pd_client/AddressBook.h

@@ -160,5 +160,3 @@ namespace client
 }
 
 #endif
-
-

libi2pd_client/BOB.cpp

@@ -624,8 +624,7 @@ namespace client
 		}
 		// trying to request
 		auto s = shared_from_this ();
-		auto requstCallback = 
+		auto requstCallback = [s](std::shared_ptr<i2p::data::LeaseSet> ls)
-			[s](std::shared_ptr<i2p::data::LeaseSet> ls)
 			{
 				if (ls)
 					s->SendReplyOK (ls->GetIdentity ()->ToBase64 ().c_str ());
@@ -860,4 +859,3 @@ namespace client
 	}
 }
 }
-

libi2pd_client/BOB.h

@@ -269,4 +269,3 @@ namespace client
 }
 
 #endif
-

libi2pd_client/ClientContext.cpp

@@ -769,9 +769,9 @@ namespace client
 			std::string httpProxyKeys;         i2p::config::GetOption("httpproxy.keys",          httpProxyKeys);
 			std::string httpProxyAddr;         i2p::config::GetOption("httpproxy.address",       httpProxyAddr);
 			uint16_t    httpProxyPort;         i2p::config::GetOption("httpproxy.port",          httpProxyPort);
-			i2p::data::SigningKeyType sigType; i2p::config::GetOption("httpproxy.signaturetype", sigType);
 			std::string httpOutProxyURL;       i2p::config::GetOption("httpproxy.outproxy",      httpOutProxyURL);
 			bool        httpAddresshelper;     i2p::config::GetOption("httpproxy.addresshelper", httpAddresshelper);
+			i2p::data::SigningKeyType sigType; i2p::config::GetOption("httpproxy.signaturetype", sigType);
 			LogPrint(eLogInfo, "Clients: starting HTTP Proxy at ", httpProxyAddr, ":", httpProxyPort);
 			if (httpProxyKeys.length () > 0)
 			{

libi2pd_client/ClientContext.h

@@ -78,7 +78,8 @@ namespace client
 			std::shared_ptr<ClientDestination> CreateNewLocalDestination (boost::asio::io_service& service,
 				const i2p::data::PrivateKeys& keys, bool isPublic = true,
 				const std::map<std::string, std::string> * params = nullptr); // same as previous but on external io_service
-			std::shared_ptr<ClientDestination> CreateNewMatchedTunnelDestination(const i2p::data::PrivateKeys &keys, const std::string & name, const std::map<std::string, std::string> * params = nullptr);
+			std::shared_ptr<ClientDestination> CreateNewMatchedTunnelDestination(const i2p::data::PrivateKeys &keys,
+				const std::string & name, const std::map<std::string, std::string> * params = nullptr);
 			void DeleteLocalDestination (std::shared_ptr<ClientDestination> destination);
 			std::shared_ptr<ClientDestination> FindLocalDestination (const i2p::data::IdentHash& destination) const;
 			bool LoadPrivateKeys (i2p::data::PrivateKeys& keys, const std::string& filename,
@@ -141,6 +142,7 @@ namespace client
 			std::unique_ptr<boost::asio::deadline_timer> m_CleanupUDPTimer;
 
 		public:
+
 			// for HTTP
 			const decltype(m_Destinations)& GetDestinations () const { return m_Destinations; };
 			const decltype(m_ClientTunnels)& GetClientTunnels () const { return m_ClientTunnels; };

libi2pd_client/HTTPProxy.cpp

@@ -406,7 +406,7 @@ namespace proxy {
 	void HTTPReqHandler::ForwardToUpstreamProxy()
 	{
 		LogPrint(eLogDebug, "HTTPProxy: forward to upstream");
-		// build http requset
+		// build http request
 
 		m_ClientRequestURL = m_RequestURL;
 		LogPrint(eLogDebug, "HTTPProxy: ", m_ClientRequestURL.host);
@@ -562,14 +562,16 @@ namespace proxy {
 		if(m_ClientRequest.method == "CONNECT") {
 			m_ClientResponse.code = 200;
 			m_send_buf = m_ClientResponse.to_string();
-			boost::asio::async_write(*m_sock, boost::asio::buffer(m_send_buf), boost::asio::transfer_all(), [&] (const boost::system::error_code & ec, std::size_t transferred) {
+			boost::asio::async_write(*m_sock, boost::asio::buffer(m_send_buf), boost::asio::transfer_all(), [&] (const boost::system::error_code & ec, std::size_t transferred)
+				{
 					if(ec) GenericProxyError("socks proxy error", ec.message().c_str());
 					else HandoverToUpstreamProxy();
 				});
 		} else {
 			m_send_buf = m_ClientRequestBuffer.str();
 			LogPrint(eLogDebug, "HTTPProxy: send ", m_send_buf.size(), " bytes");
-			boost::asio::async_write(*m_proxysock, boost::asio::buffer(m_send_buf), boost::asio::transfer_all(), [&](const boost::system::error_code & ec, std::size_t transferred) {
+			boost::asio::async_write(*m_proxysock, boost::asio::buffer(m_send_buf), boost::asio::transfer_all(), [&](const boost::system::error_code & ec, std::size_t transferred)
+				{
 					if(ec) GenericProxyError("failed to send request to upstream", ec.message().c_str());
 					else HandoverToUpstreamProxy();
 				});

libi2pd_client/HTTPProxy.h

@@ -6,6 +6,7 @@ namespace proxy {
 	class HTTPProxy: public i2p::client::TCPIPAcceptor
 	{
 		public:
+
 			HTTPProxy(const std::string& name, const std::string& address, int port, const std::string & outproxy, bool addresshelper, std::shared_ptr<i2p::client::ClientDestination> localDestination);
 			HTTPProxy(const std::string& name, const std::string& address, int port, std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr) :
 				HTTPProxy(name, address, port, "", true, localDestination) {} ;
@@ -15,11 +16,13 @@ namespace proxy {
 			bool GetHelperSupport() { return m_Addresshelper; }
 
 		protected:
+
 			// Implements TCPIPAcceptor
 			std::shared_ptr<i2p::client::I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
 			const char* GetName() { return m_Name.c_str (); }
 
 		private:
+
 			std::string m_Name;
 			std::string m_OutproxyUrl;
 			bool m_Addresshelper;

libi2pd_client/I2CP.cpp

@@ -899,4 +899,3 @@ namespace client
 	}
 }
 }
-

libi2pd_client/I2CP.h

@@ -220,4 +220,3 @@ namespace client
 }
 
 #endif
-

libi2pd_client/I2PService.cpp

@@ -115,14 +115,16 @@ namespace client
 	{
 		if(m_ConnectTimeout && !m_LocalDestination->IsReady())
 		{
-			AddReadyCallback([this, streamRequestComplete, address, port] (const boost::system::error_code & ec) {
+			AddReadyCallback([this, streamRequestComplete, address, port] (const boost::system::error_code & ec)
+				{
 					if(ec)
 					{
 						LogPrint(eLogWarning, "I2PService::CreateStream() ", ec.message());
 						streamRequestComplete(nullptr);
 					}
 					else
-					{	if (address->IsIdentHash ())
+					{
+						if (address->IsIdentHash ())
 							this->m_LocalDestination->CreateStream(streamRequestComplete, address->identHash, port);
 						else
 							this->m_LocalDestination->CreateStream (streamRequestComplete, address->blindedPublicKey, port);

libi2pd_client/I2PService.h

@@ -18,9 +18,11 @@ namespace client
 	class I2PService : public std::enable_shared_from_this<I2PService>
 	{
 		public:
+
 			typedef std::function<void(const boost::system::error_code &)> ReadyCallback;
 
 		public:
+
 			I2PService (std::shared_ptr<ClientDestination> localDestination = nullptr);
 			I2PService (i2p::data::SigningKeyType kt);
 			virtual ~I2PService ();
@@ -59,10 +61,12 @@ namespace client
 			virtual const char* GetName() { return "Generic I2P Service"; }
 
 		private:
+
 			void TriggerReadyCheckTimer();
 			void HandleReadyCheckTimer(const boost::system::error_code & ec);
 
 		private:
+
 			std::shared_ptr<ClientDestination> m_LocalDestination;
 			std::unordered_set<std::shared_ptr<I2PServiceHandler> > m_Handlers;
 			std::mutex m_HandlersMutex;
@@ -74,6 +78,7 @@ namespace client
 			const size_t NEVER_TIMES_OUT = 0;
 
 		public:
+
 			bool isUpdated; // transient, used during reload only
 	};
 
@@ -81,6 +86,7 @@ namespace client
 	class I2PServiceHandler
 	{
 		public:
+
 			I2PServiceHandler(I2PService * parent) : m_Service(parent), m_Dead(false) { }
 			virtual ~I2PServiceHandler() { }
 			//If you override this make sure you call it from the children
@@ -89,6 +95,7 @@ namespace client
 			void Terminate () { Kill (); };
 
 		protected:
+
 			// Call when terminating or handing over to avoid race conditions
 			inline bool Kill () { return m_Dead.exchange(true); }
 			// Call to know if the handler is dead
@@ -99,6 +106,7 @@ namespace client
 			inline I2PService * GetOwner() { return m_Service; }
 
 		private:
+
 			I2PService *m_Service;
 			std::atomic<bool> m_Dead; //To avoid cleaning up multiple times
 	};
@@ -109,11 +117,13 @@ namespace client
 	class TCPIPPipe: public I2PServiceHandler, public std::enable_shared_from_this<TCPIPPipe>
 	{
 		public:
+
 			TCPIPPipe(I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> upstream, std::shared_ptr<boost::asio::ip::tcp::socket> downstream);
 			~TCPIPPipe();
 			void Start();
 
 		protected:
+
 			void Terminate();
 			void AsyncReceiveUpstream();
 			void AsyncReceiveDownstream();
@@ -125,6 +135,7 @@ namespace client
 			void DownstreamWrite(size_t len);
 
 		private:
+
 			uint8_t m_upstream_to_down_buf[TCP_IP_PIPE_BUFFER_SIZE], m_downstream_to_up_buf[TCP_IP_PIPE_BUFFER_SIZE];
 			uint8_t m_upstream_buf[TCP_IP_PIPE_BUFFER_SIZE], m_downstream_buf[TCP_IP_PIPE_BUFFER_SIZE];
 			std::shared_ptr<boost::asio::ip::tcp::socket> m_up, m_down;
@@ -135,6 +146,7 @@ namespace client
 	class TCPIPAcceptor: public I2PService
 	{
 		public:
+
 			TCPIPAcceptor (const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination = nullptr) :
 				I2PService(localDestination),
 				m_LocalEndpoint (boost::asio::ip::address::from_string(address), port),
@@ -154,9 +166,11 @@ namespace client
 			virtual const char* GetName() { return "Generic TCP/IP accepting daemon"; }
 
 		protected:
+
 			virtual std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket) = 0;
 
 		private:
+
 			void Accept();
 			void HandleAccept(const boost::system::error_code& ecode, std::shared_ptr<boost::asio::ip::tcp::socket> socket);
 			boost::asio::ip::tcp::endpoint m_LocalEndpoint;

libi2pd_client/I2PTunnel.h

@@ -30,6 +30,7 @@ namespace client
 	class I2PTunnelConnection: public I2PServiceHandler, public std::enable_shared_from_this<I2PTunnelConnection>
 	{
 		public:
+
 			I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
 				std::shared_ptr<const i2p::data::LeaseSet> leaseSet, int port = 0); // to I2P
 			I2PTunnelConnection (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
@@ -41,6 +42,7 @@ namespace client
 			void Connect (bool isUniqueLocal = true);
 
 		protected:
+
 			void Terminate ();
 
 			void Receive ();
@@ -55,6 +57,7 @@ namespace client
 			std::shared_ptr<const boost::asio::ip::tcp::socket> GetSocket () const { return m_Socket; };
 
 		private:
+
 			uint8_t m_Buffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE], m_StreamBuffer[I2P_TUNNEL_CONNECTION_BUFFER_SIZE];
 			std::shared_ptr<boost::asio::ip::tcp::socket> m_Socket;
 			std::shared_ptr<i2p::stream::Stream> m_Stream;
@@ -65,15 +68,18 @@ namespace client
 	class I2PClientTunnelConnectionHTTP: public I2PTunnelConnection
 	{
 		public:
+
 			I2PClientTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<boost::asio::ip::tcp::socket> socket,
 				std::shared_ptr<i2p::stream::Stream> stream):
 				I2PTunnelConnection (owner, socket, stream), m_HeaderSent (false),
 				m_ConnectionSent (false), m_ProxyConnectionSent (false) {};
 
 		protected:
+
 			void Write (const uint8_t * buf, size_t len);
 
 		private:
+
 			std::stringstream m_InHeader, m_OutHeader;
 			bool m_HeaderSent, m_ConnectionSent, m_ProxyConnectionSent;
 	};
@@ -81,14 +87,17 @@ namespace client
 	class I2PServerTunnelConnectionHTTP: public I2PTunnelConnection
 	{
 		public:
+
 			I2PServerTunnelConnectionHTTP (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
 				std::shared_ptr<boost::asio::ip::tcp::socket> socket,
 				const boost::asio::ip::tcp::endpoint& target, const std::string& host);
 
 		protected:
+
 			void Write (const uint8_t * buf, size_t len);
 
 		private:
+
 			std::string m_Host;
 			std::stringstream m_InHeader, m_OutHeader;
 			bool m_HeaderSent;
@@ -98,14 +107,17 @@ namespace client
 	class I2PTunnelConnectionIRC: public I2PTunnelConnection
 	{
 		public:
+
 			I2PTunnelConnectionIRC (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
 				std::shared_ptr<boost::asio::ip::tcp::socket> socket,
 				const boost::asio::ip::tcp::endpoint& target, const std::string& m_WebircPass);
 
 		protected:
+
 			void Write (const uint8_t * buf, size_t len);
 
 		private:
+
 			std::shared_ptr<const i2p::data::IdentityEx> m_From;
 			std::stringstream m_OutPacket, m_InPacket;
 			bool m_NeedsWebIrc;
@@ -116,10 +128,12 @@ namespace client
 	class I2PClientTunnel: public TCPIPAcceptor
 	{
 		protected:
+
 			// Implements TCPIPAcceptor
 			std::shared_ptr<I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
 
 		public:
+
 			I2PClientTunnel (const std::string& name, const std::string& destination,
 				const std::string& address, int port, std::shared_ptr<ClientDestination> localDestination, int destinationPort = 0);
 			~I2PClientTunnel () {}
@@ -130,9 +144,11 @@ namespace client
 			const char* GetName() { return m_Name.c_str (); }
 
 		private:
+
 			std::shared_ptr<const Address> GetAddress ();
 
 		private:
+
 			std::string m_Name, m_Destination;
 			std::shared_ptr<const Address> m_Address;
 			int m_DestinationPort;
@@ -195,6 +211,7 @@ namespace client
 	class I2PUDPServerTunnel
 	{
 		public:
+
 			I2PUDPServerTunnel(const std::string & name,
 				std::shared_ptr<i2p::client::ClientDestination> localDestination,
 				boost::asio::ip::address localAddress,
@@ -210,10 +227,12 @@ namespace client
 			void SetUniqueLocal(bool isUniqueLocal = true) { m_IsUniqueLocal = isUniqueLocal; }
 
 		private:
+
 			void HandleRecvFromI2P(const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
 			UDPSessionPtr ObtainUDPSession(const i2p::data::IdentityEx& from, uint16_t localPort, uint16_t remotePort);
 
 		private:
+
 			bool m_IsUniqueLocal;
 			const std::string m_Name;
 			boost::asio::ip::address m_LocalAddress;
@@ -226,6 +245,7 @@ namespace client
 	class I2PUDPClientTunnel
 	{
 		public:
+
 			I2PUDPClientTunnel(const std::string & name, const std::string &remoteDest,
 				boost::asio::ip::udp::endpoint localEndpoint, std::shared_ptr<i2p::client::ClientDestination> localDestination,
 				uint16_t remotePort, bool gzip);
@@ -240,6 +260,7 @@ namespace client
 			void ExpireStale(const uint64_t delta=I2P_UDP_SESSION_TIMEOUT);
 
 		private:
+
 			typedef std::pair<boost::asio::ip::udp::endpoint, uint64_t> UDPConvo;
 			void RecvFromLocal();
 			void HandleRecvFromLocal(const boost::system::error_code & e, std::size_t transferred);
@@ -263,6 +284,7 @@ namespace client
 	class I2PServerTunnel: public I2PService
 	{
 		public:
+
 			I2PServerTunnel (const std::string& name, const std::string& address, int port,
 				std::shared_ptr<ClientDestination> localDestination, int inport = 0, bool gzip = true);
 
@@ -282,6 +304,7 @@ namespace client
 			const char* GetName() { return m_Name.c_str (); }
 
 		private:
+
 			void HandleResolve (const boost::system::error_code& ecode, boost::asio::ip::tcp::resolver::iterator it,
 				std::shared_ptr<boost::asio::ip::tcp::resolver> resolver);
 
@@ -290,6 +313,7 @@ namespace client
 			virtual std::shared_ptr<I2PTunnelConnection> CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
 
 		private:
+
 			bool m_IsUniqueLocal;
 			std::string m_Name, m_Address;
 			int m_Port;
@@ -302,28 +326,34 @@ namespace client
 	class I2PServerTunnelHTTP: public I2PServerTunnel
 	{
 		public:
+
 			I2PServerTunnelHTTP (const std::string& name, const std::string& address, int port,
 				std::shared_ptr<ClientDestination> localDestination, const std::string& host,
 				int inport = 0, bool gzip = true);
 
 		private:
+
 			std::shared_ptr<I2PTunnelConnection> CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
 
 		private:
+
 			std::string m_Host;
 	};
 
 	class I2PServerTunnelIRC: public I2PServerTunnel
 	{
 		public:
+
 			I2PServerTunnelIRC (const std::string& name, const std::string& address, int port,
 				std::shared_ptr<ClientDestination> localDestination, const std::string& webircpass,
 				int inport = 0, bool gzip = true);
 
 		private:
+
 			std::shared_ptr<I2PTunnelConnection> CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream);
 
 		private:
+
 			std::string m_WebircPass;
 	};
 }

libi2pd_client/MatchedDestination.h

@@ -8,22 +8,26 @@ namespace i2p
 namespace client
 {
 	/**
-		 client tunnel that uses same OBEP as IBGW of each remote lease for a remote destination
+	 * client tunnel that uses same OBEP as IBGW of each remote lease for a remote destination
 	 */
 	class MatchedTunnelDestination : public RunnableClientDestination, public i2p::tunnel::ITunnelPeerSelector
 	{
 		public:
-		MatchedTunnelDestination(const i2p::data::PrivateKeys& keys, const std::string & remoteName, const std::map<std::string, std::string> * params = nullptr);
+
+			MatchedTunnelDestination(const i2p::data::PrivateKeys& keys, const std::string & remoteName,
+				const std::map<std::string, std::string> * params = nullptr);
 			void Start();
 			void Stop();
 
 			bool SelectPeers(i2p::tunnel::Path & peers, int hops, bool inbound);
 
 		private:
+
 			void ResolveCurrentLeaseSet();
 			void HandleFoundCurrentLeaseSet(std::shared_ptr<const i2p::data::LeaseSet> ls);
 
 		private:
+
 			std::string m_RemoteName;
 			i2p::data::IdentHash m_RemoteIdent;
 			std::shared_ptr<const i2p::data::LeaseSet> m_RemoteLeaseSet;

libi2pd_client/SAM.cpp

@@ -54,8 +54,7 @@ namespace client
 				}
 				break;
 			}
-			default:
+			default: ;
-				;
 		}
 		m_SocketType = eSAMSocketTypeTerminated;
 		if (m_Socket.is_open ())

libi2pd_client/SAM.h

@@ -99,6 +99,7 @@ namespace client
 			bool IsSession(const std::string & id) const;
 
 		private:
+
 			void TerminateClose() { Terminate(nullptr); }
 
 			void HandleHandshakeReceived (const boost::system::error_code& ecode, std::size_t bytes_transferred);

libi2pd_client/SOCKS.cpp

@@ -41,6 +41,7 @@ namespace proxy
 	class SOCKSHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this<SOCKSHandler>
 	{
 		private:
+
 			enum state
 			{
 				GET_SOCKSV,
@@ -165,6 +166,7 @@ namespace proxy
 			const uint16_t m_UpstreamProxyPort;
 
 		public:
+
 			SOCKSHandler(SOCKSServer * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock, const std::string & upstreamAddr, const uint16_t upstreamPort, const bool useUpstream) :
 				I2PServiceHandler(parent),
 				m_proxy_resolver(parent->GetService()),
@@ -652,8 +654,7 @@ namespace proxy
 		LogPrint(eLogDebug, "SOCKS: async upstream sock read");
 		if (m_upstreamSock) {
 			m_upstreamSock->async_read_some(boost::asio::buffer(m_upstream_response, SOCKS_UPSTREAM_SOCKS4A_REPLY_SIZE),
-				std::bind(&SOCKSHandler::HandleUpstreamSockRecv, shared_from_this(),
+				std::bind(&SOCKSHandler::HandleUpstreamSockRecv, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
-				std::placeholders::_1, std::placeholders::_2));
 		} else {
 			LogPrint(eLogError, "SOCKS: no upstream socket for read");
 			SocksRequestFailed(SOCKS5_GEN_FAIL);

libi2pd_client/SOCKS.h

@@ -14,6 +14,7 @@ namespace proxy
 	class SOCKSServer: public i2p::client::TCPIPAcceptor
 	{
 		public:
+
 			SOCKSServer(const std::string& name, const std::string& address, int port, bool outEnable, const std::string& outAddress, uint16_t outPort,
 				std::shared_ptr<i2p::client::ClientDestination> localDestination = nullptr);
 			~SOCKSServer() {};
@@ -21,6 +22,7 @@ namespace proxy
 			void SetUpstreamProxy(const std::string & addr, const uint16_t port);
 
 		protected:
+
 			// Implements TCPIPAcceptor
 			std::shared_ptr<i2p::client::I2PServiceHandler> CreateHandler(std::shared_ptr<boost::asio::ip::tcp::socket> socket);
 			const char* GetName() { return m_Name.c_str (); }