windows warnings, tabulation workaround

Win32/DaemonWin32.cpp

@@ -6,7 +6,6 @@
 #include "Log.h"
 
 #ifdef _WIN32
-
 #include "Win32/Win32Service.h"
 #ifdef WIN32_APP
 #include "Win32/Win32App.h"
@@ -109,4 +108,4 @@ namespace util
 	}
 }
 }
-#endif
+#endif //_WIN32

Win32/Win32Service.cpp

@@ -15,7 +15,6 @@ I2PService *I2PService::s_service = NULL;
 BOOL I2PService::isService()
 {
 	BOOL bIsService = FALSE;
-
 	HWINSTA hWinStation = GetProcessWindowStation();
 	if (hWinStation != NULL)
 	{
@@ -31,28 +30,23 @@ BOOL I2PService::isService()
 BOOL I2PService::Run(I2PService &service)
 {
 	s_service = &service;
-
 	SERVICE_TABLE_ENTRY serviceTable[] =
 	{
 		{ service.m_name, ServiceMain },
 		{ NULL, NULL }
 	};
-
 	return StartServiceCtrlDispatcher(serviceTable);
 }
 
-
 void WINAPI I2PService::ServiceMain(DWORD dwArgc, PSTR *pszArgv)
 {
 	assert(s_service != NULL);
-
 	s_service->m_statusHandle = RegisterServiceCtrlHandler(
 		s_service->m_name, ServiceCtrlHandler);
 	if (s_service->m_statusHandle == NULL)
 	{
 		throw GetLastError();
 	}
-
 	s_service->Start(dwArgc, pszArgv);
 }
 
@@ -76,11 +70,8 @@ I2PService::I2PService(PSTR pszServiceName,
 	BOOL fCanPauseContinue)
 {
 	m_name = (pszServiceName == NULL) ? (PSTR)"" : pszServiceName;
-
 	m_statusHandle = NULL;
-
 	m_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
-
 	m_status.dwCurrentState = SERVICE_START_PENDING;
 
 	DWORD dwControlsAccepted = 0;
@@ -90,15 +81,13 @@ I2PService::I2PService(PSTR pszServiceName,
 		dwControlsAccepted |= SERVICE_ACCEPT_SHUTDOWN;
 	if (fCanPauseContinue)
 		dwControlsAccepted |= SERVICE_ACCEPT_PAUSE_CONTINUE;
-	m_status.dwControlsAccepted = dwControlsAccepted;
 
+	m_status.dwControlsAccepted = dwControlsAccepted;
 	m_status.dwWin32ExitCode = NO_ERROR;
 	m_status.dwServiceSpecificExitCode = 0;
 	m_status.dwCheckPoint = 0;
 	m_status.dwWaitHint = 0;
-
 	m_fStopping = FALSE;
-
 	// Create a manual-reset event that is not signaled at first to indicate
 	// the stopped signal of the service.
 	m_hStoppedEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -108,7 +97,6 @@ I2PService::I2PService(PSTR pszServiceName,
 	}
 }
 
-
 I2PService::~I2PService(void)
 {
 	if (m_hStoppedEvent)
@@ -118,92 +106,73 @@ I2PService::~I2PService(void)
 	}
 }
 
-
 void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
 {
 	try
 	{
 		SetServiceStatus(SERVICE_START_PENDING);
-
 		OnStart(dwArgc, pszArgv);
-
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (DWORD dwError)
 	{
 		LogPrint(eLogError, "Win32Service Start", dwError);
-
 		SetServiceStatus(SERVICE_STOPPED, dwError);
 	}
 	catch (...)
 	{
 		LogPrint(eLogError, "Win32Service failed to start.", EVENTLOG_ERROR_TYPE);
-
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 }
 
-
 void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
 {
 	LogPrint(eLogInfo, "Win32Service in OnStart", EVENTLOG_INFORMATION_TYPE);
-
 	Daemon.start();
-
 	//i2p::util::config::OptionParser(dwArgc, pszArgv);
 	//i2p::util::filesystem::ReadConfigFile(i2p::util::config::mapArgs, i2p::util::config::mapMultiArgs);
 	//i2p::context.OverrideNTCPAddress(i2p::util::config::GetCharArg("-host", "127.0.0.1"),
 	//	i2p::util::config::GetArg("-port", 17070));
-
 	_worker = new std::thread(std::bind(&I2PService::WorkerThread, this));
 }
 
-
 void I2PService::WorkerThread()
 {
 	while (!m_fStopping)
 	{
 		::Sleep(1000); // Simulate some lengthy operations.
 	}
-
 	// Signal the stopped event.
 	SetEvent(m_hStoppedEvent);
 }
 
-
 void I2PService::Stop()
 {
 	DWORD dwOriginalState = m_status.dwCurrentState;
 	try
 	{
 		SetServiceStatus(SERVICE_STOP_PENDING);
-
 		OnStop();
-
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 	catch (DWORD dwError)
 	{
 		LogPrint(eLogInfo, "Win32Service Stop", dwError);
-
 		SetServiceStatus(dwOriginalState);
 	}
 	catch (...)
 	{
 		LogPrint(eLogError, "Win32Service failed to stop.", EVENTLOG_ERROR_TYPE);
-
 		SetServiceStatus(dwOriginalState);
 	}
 }
 
-
 void I2PService::OnStop()
 {
 	// Log a service stop message to the Application log.
 	LogPrint(eLogInfo, "Win32Service in OnStop", EVENTLOG_INFORMATION_TYPE);
-
 	Daemon.stop();
-
 	m_fStopping = TRUE;
 	if (WaitForSingleObject(m_hStoppedEvent, INFINITE) != WAIT_OBJECT_0)
 	{
@@ -213,57 +182,46 @@ void I2PService::OnStop()
 	delete _worker;
 }
 
-
 void I2PService::Pause()
 {
 	try
 	{
 		SetServiceStatus(SERVICE_PAUSE_PENDING);
-
 		OnPause();
-
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 	catch (DWORD dwError)
 	{
 		LogPrint(eLogError, "Win32Service Pause", dwError);
-
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (...)
 	{
 		LogPrint(eLogError, "Win32Service failed to pause.", EVENTLOG_ERROR_TYPE);
-
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 }
 
-
 void I2PService::OnPause()
 {
 }
 
-
 void I2PService::Continue()
 {
 	try
 	{
 		SetServiceStatus(SERVICE_CONTINUE_PENDING);
-
 		OnContinue();
-
 		SetServiceStatus(SERVICE_RUNNING);
 	}
 	catch (DWORD dwError)
 	{
 		LogPrint(eLogError, "Win32Service Continue", dwError);
-
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 	catch (...)
 	{
 		LogPrint(eLogError, "Win32Service failed to resume.", EVENTLOG_ERROR_TYPE);
-
 		SetServiceStatus(SERVICE_PAUSED);
 	}
 }
@@ -277,7 +235,6 @@ void I2PService::Shutdown()
 	try
 	{
 		OnShutdown();
-
 		SetServiceStatus(SERVICE_STOPPED);
 	}
 	catch (DWORD dwError)
@@ -299,11 +256,9 @@ void I2PService::SetServiceStatus(DWORD dwCurrentState,
 	DWORD dwWaitHint)
 {
 	static DWORD dwCheckPoint = 1;
-
 	m_status.dwCurrentState = dwCurrentState;
 	m_status.dwWin32ExitCode = dwWin32ExitCode;
 	m_status.dwWaitHint = dwWaitHint;
-
 	m_status.dwCheckPoint =
 		((dwCurrentState == SERVICE_RUNNING) ||
 		(dwCurrentState == SERVICE_STOPPED)) ?
@@ -328,7 +283,7 @@ void FreeHandles(SC_HANDLE schSCManager, SC_HANDLE schService)
 	}
 }
 
-void InstallService(PSTR pszServiceName, PSTR pszDisplayName, DWORD dwStartType, PSTR pszDependencies, PSTR pszAccount, PSTR pszPassword)
+void InstallService(PCSTR pszServiceName, PCSTR pszDisplayName, DWORD dwStartType, PCSTR pszDependencies, PCSTR pszAccount, PCSTR pszPassword)
 {
 	printf("Try to install Win32Service (%s).\n", pszServiceName);
 
@@ -383,7 +338,7 @@ void InstallService(PSTR pszServiceName, PSTR pszDisplayName, DWORD dwStartType,
 	FreeHandles(schSCManager, schService);
 }
 
-void UninstallService(PSTR pszServiceName)
+void UninstallService(PCSTR pszServiceName)
 {
 	printf("Try to uninstall Win32Service (%s).\n", pszServiceName);
 

Win32/Win32Service.h

@@ -4,7 +4,6 @@
 #include <thread>
 #include <windows.h>
 
-
 #ifdef _WIN32
 // Internal name of the service
 #define SERVICE_NAME             "i2pdService"
@@ -25,7 +24,6 @@
 #define SERVICE_PASSWORD         NULL
 #endif
 
-
 class I2PService
 {
 public:
@@ -72,13 +70,15 @@ private:
 	std::thread* _worker;
 };
 
-void InstallService(PSTR pszServiceName,
-	PSTR pszDisplayName,
+void InstallService(
+	PCSTR pszServiceName,
+	PCSTR pszDisplayName,
 	DWORD dwStartType,
-	PSTR pszDependencies,
-	PSTR pszAccount,
-	PSTR pszPassword);
+	PCSTR pszDependencies,
+	PCSTR pszAccount,
+	PCSTR pszPassword
+	);
 
-void UninstallService(PSTR pszServiceName);
+void UninstallService(PCSTR pszServiceName);
 
 #endif // WIN_32_SERVICE_H__

libi2pd_client/I2PService.cpp

@@ -104,9 +104,7 @@ namespace client
 		assert(streamRequestComplete);
 		i2p::data::IdentHash identHash;
 		if (i2p::client::context.GetAddressBook ().GetIdentHash (dest, identHash))
-		{
 			CreateStream(streamRequestComplete, identHash, port);
-		}
 		else
 		{
 			LogPrint (eLogWarning, "I2PService: Remote destination not found: ", dest);
@@ -158,16 +156,16 @@ namespace client
 	void TCPIPPipe::Terminate()
 	{
 		if(Kill()) return;
-		if (m_up) {
-			if (m_up->is_open()) {
+		if (m_up)
+		{
+			if (m_up->is_open())
 				m_up->close();
-			}
 			m_up = nullptr;
 		}
-		if (m_down) {
-			if (m_down->is_open()) {
+		if (m_down)
+		{
+			if (m_down->is_open())
 				m_down->close();
-			}
 			m_down = nullptr;
 		}
 		Done(shared_from_this());
@@ -175,13 +173,14 @@ namespace client
 
 	void TCPIPPipe::AsyncReceiveUpstream()
 	{
-		if (m_up) {
+		if (m_up)
+		{
 			m_up->async_read_some(boost::asio::buffer(m_upstream_to_down_buf, TCP_IP_PIPE_BUFFER_SIZE),
 				std::bind(&TCPIPPipe::HandleUpstreamReceived, shared_from_this(),
 				std::placeholders::_1, std::placeholders::_2));
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: upstream receive: no socket");
 		}
+		else
+			LogPrint(eLogError, "TCPIPPipe: upstream receive: no socket");
 	}
 
 	void TCPIPPipe::AsyncReceiveDownstream()
@@ -190,88 +189,90 @@ namespace client
 			m_down->async_read_some(boost::asio::buffer(m_downstream_to_up_buf, TCP_IP_PIPE_BUFFER_SIZE),
 				std::bind(&TCPIPPipe::HandleDownstreamReceived, shared_from_this(),
 				std::placeholders::_1, std::placeholders::_2));
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: downstream receive: no socket");
 		}
+		else
+			LogPrint(eLogError, "TCPIPPipe: downstream receive: no socket");
 	}
 
 	void TCPIPPipe::UpstreamWrite(size_t len)
 	{
-		if (m_up) {
+		if (m_up)
+		{
 			LogPrint(eLogDebug, "TCPIPPipe: upstream: ", (int) len, " bytes written");
 			boost::asio::async_write(*m_up, boost::asio::buffer(m_upstream_buf, len),
 				boost::asio::transfer_all(),
 				std::bind(&TCPIPPipe::HandleUpstreamWrite,
 				shared_from_this(),
-																				 std::placeholders::_1)
-															 );
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: upstream write: no socket");
+				std::placeholders::_1));
 		}
+		else
+			LogPrint(eLogError, "TCPIPPipe: upstream write: no socket");
 	}
 
 	void TCPIPPipe::DownstreamWrite(size_t len)
 	{
-		if (m_down) {
+		if (m_down)
+		{
 			LogPrint(eLogDebug, "TCPIPPipe: downstream: ", (int) len, " bytes written");
 			boost::asio::async_write(*m_down, boost::asio::buffer(m_downstream_buf, len),
 				boost::asio::transfer_all(),
 				std::bind(&TCPIPPipe::HandleDownstreamWrite,
 				shared_from_this(),
-																				 std::placeholders::_1)
-															 );
-		} else {
-			LogPrint(eLogError, "TCPIPPipe: downstream write: no socket");
+				std::placeholders::_1));
 		}
+		else
+			LogPrint(eLogError, "TCPIPPipe: downstream write: no socket");
 	}
 
 
 	void TCPIPPipe::HandleDownstreamReceived(const boost::system::error_code & ecode, std::size_t bytes_transfered)
 	{
 		LogPrint(eLogDebug, "TCPIPPipe: downstream: ", (int) bytes_transfered, " bytes received");
-		if (ecode) {
+		if (ecode)
+		{
 			LogPrint(eLogError, "TCPIPPipe: downstream read error:" , ecode.message());
 			if (ecode != boost::asio::error::operation_aborted)
 				Terminate();
 		} else {
-			if (bytes_transfered > 0 ) {
+			if (bytes_transfered > 0 )
 				memcpy(m_upstream_buf, m_downstream_to_up_buf, bytes_transfered);
-			}
 			UpstreamWrite(bytes_transfered);
 		}
 	}
 
 	void TCPIPPipe::HandleDownstreamWrite(const boost::system::error_code & ecode) {
-		if (ecode) {
+		if (ecode)
+		{
 			LogPrint(eLogError, "TCPIPPipe: downstream write error:" , ecode.message());
 			if (ecode != boost::asio::error::operation_aborted)
 				Terminate();
-		} else {
-			AsyncReceiveUpstream();
 		}
+		else
+			AsyncReceiveUpstream();
 	}
 
 	void TCPIPPipe::HandleUpstreamWrite(const boost::system::error_code & ecode) {
-		if (ecode) {
+		if (ecode)
+		{
 			LogPrint(eLogError, "TCPIPPipe: upstream write error:" , ecode.message());
 			if (ecode != boost::asio::error::operation_aborted)
 				Terminate();
-		} else {
-			AsyncReceiveDownstream();
 		}
+		else
+			AsyncReceiveDownstream();
 	}
 
 	void TCPIPPipe::HandleUpstreamReceived(const boost::system::error_code & ecode, std::size_t bytes_transfered)
 	{
 		LogPrint(eLogDebug, "TCPIPPipe: upstream ", (int)bytes_transfered, " bytes received");
-		if (ecode) {
+		if (ecode)
+		{
 			LogPrint(eLogError, "TCPIPPipe: upstream read error:" , ecode.message());
 			if (ecode != boost::asio::error::operation_aborted)
 				Terminate();
 		} else {
-			if (bytes_transfered > 0 ) {
+			if (bytes_transfered > 0 )
 				memcpy(m_downstream_buf, m_upstream_to_down_buf, bytes_transfered);
-			}
 			DownstreamWrite(bytes_transfered);
 		}
 	}

libi2pd_client/I2PService.h

@@ -18,6 +18,7 @@ namespace client
 	{
 		public:
 			typedef std::function<void(const boost::system::error_code &)> ReadyCallback;
+
 		public:
 			I2PService (std::shared_ptr<ClientDestination> localDestination  = nullptr);
 			I2PService (i2p::data::SigningKeyType kt);
@@ -61,7 +62,6 @@ namespace client
 			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;
@@ -93,6 +93,7 @@ namespace client
 			inline void Done (std::shared_ptr<I2PServiceHandler> me) { if(m_Service) m_Service->RemoveHandler(me); }
 			// Call to talk with the owner
 			inline I2PService * GetOwner() { return m_Service; }
+
 		private:
 			I2PService *m_Service;
 			std::atomic<bool> m_Dead; //To avoid cleaning up multiple times
@@ -101,11 +102,13 @@ namespace client
 	const size_t TCP_IP_PIPE_BUFFER_SIZE = 8192 * 8;
 
 	// bidirectional pipe for 2 tcp/ip sockets
-	class TCPIPPipe: public I2PServiceHandler, public std::enable_shared_from_this<TCPIPPipe> {
+	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();
@@ -116,6 +119,7 @@ namespace client
 			void HandleDownstreamWrite(const boost::system::error_code & ecode);
 			void UpstreamWrite(size_t len);
 			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];
@@ -147,6 +151,7 @@ namespace client
 
 		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);

libi2pd_client/I2PTunnel.cpp

@@ -674,7 +674,6 @@ namespace client
 		Receive();
 	}
 
-
 	void UDPSession::Receive() {
 		LogPrint(eLogDebug, "UDPSession: Receive");
 		IPSocket.async_receive_from(boost::asio::buffer(m_Buffer, I2P_UDP_MAX_MTU),
@@ -694,8 +693,6 @@ namespace client
 		}
 	}
 
-
-
 	I2PUDPServerTunnel::I2PUDPServerTunnel(const std::string & name, std::shared_ptr<i2p::client::ClientDestination> localDestination,
 		boost::asio::ip::address localAddress, boost::asio::ip::udp::endpoint forwardTo, uint16_t port) :
 		m_IsUniqueLocal(true),
@@ -764,8 +761,6 @@ namespace client
 			std::placeholders::_5));
 	}
 
-
-
 	void I2PUDPClientTunnel::Start() {
 		m_LocalDest->Start();
 		if (m_ResolveThread == nullptr)
@@ -850,7 +845,6 @@ namespace client
 		}
 		else
 			LogPrint(eLogWarning, "UDP Client: unwarrented traffic from ", from.GetIdentHash().ToBase32());
-
 	}
 
 	I2PUDPClientTunnel::~I2PUDPClientTunnel() {

libi2pd_client/I2PTunnel.h

@@ -29,7 +29,6 @@ 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,7 +40,6 @@ namespace client
 			void Connect (bool isUniqueLocal = true);
 
 		protected:
-
 			void Terminate ();
 
 			void Receive ();
@@ -56,7 +54,6 @@ 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;
@@ -67,18 +64,15 @@ 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;
 	};
@@ -86,17 +80,14 @@ 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;
@@ -106,17 +97,14 @@ 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;
@@ -127,12 +115,10 @@ 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 () {}
@@ -143,11 +129,9 @@ namespace client
 			const char* GetName() { return m_Name.c_str (); }
 
 		private:
-
 			const i2p::data::IdentHash * GetIdentHash ();
 
 		private:
-
 			std::string m_Name, m_Destination;
 			const i2p::data::IdentHash * m_DestinationIdentHash;
 			int m_DestinationPort;
@@ -225,7 +209,6 @@ 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);
 
@@ -279,7 +262,6 @@ 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);
 
@@ -301,7 +283,6 @@ namespace client
 			void SetMaxConnsPerMinute(const uint32_t conns) { m_PortDestination->SetMaxConnsPerMinute(conns); }
 
 		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);
 
@@ -310,7 +291,6 @@ 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;
@@ -323,37 +303,30 @@ 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;
 	};
-
 }
 }