[make] change daemon sources list, add unix/win32 depending on system

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

.github/workflows/docker.yml

@@ -1,6 +1,11 @@
 name: Build containers
 
-on: [push]
+on:
+  push:
+    branches:
+    - openssl
+    tags:
+    - '*'
 
 jobs:
   docker:
@@ -58,6 +63,8 @@ jobs:
           push: true
           tags: |
             purplei2p/i2pd:latest
+            purplei2p/i2pd:latest-release
             purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}
             ghcr.io/purplei2p/i2pd:latest
+            ghcr.io/purplei2p/i2pd:latest-release
             ghcr.io/purplei2p/i2pd:release-${{ env.RELEASE_VERSION }}

.gitignore

@@ -8,12 +8,15 @@ netDb
 /libi2pd.a
 /libi2pdclient.a
 /libi2pdlang.a
+/libi2pdwebconsole.a
 /libi2pd.so
 /libi2pdclient.so
 /libi2pdlang.so
+/libi2pdwebconsole.so
 /libi2pd.dll
 /libi2pdclient.dll
 /libi2pdlang.dll
+/libi2pdwebconsole.dll
 *.exe
 
 

ChangeLog

@@ -1,6 +1,40 @@
 # for this file format description,
 # see https://github.com/olivierlacan/keep-a-changelog
 
+## [2.42.1] - 2022-05-24
+### Fixed
+- Incorrect jump link in HTTP Proxy
+
+## [2.42.0] - 2022-05-22
+### Added
+- Preliminary SSU2 implementation
+- Tunnel length variance
+- Localization to French
+- Daily cleanup of obsolete peer profiles
+- Ordered jump services list in HTTP proxy
+- Win32 service
+- Show port for local non-published SSU addresses in web console
+### Changed
+- Maximum RouterInfo length increased to 3K
+- Skip unknown addresses in RouterInfo
+- Don't pick own router for peer test
+- Reseeds list
+- Internal numeric id for families
+- Use ipv6 preference only when netinet headers not used
+- Close stream if delete requested
+- Remove version from title in web console
+- Drop MESHNET build option
+- Set data path before initialization
+- Don't show registration block in web console if token is not provided
+### Fixed
+- Encrypted LeaseSet for EdDSA signature
+- Clients tunnels are not built if clock is not synced on start
+- Incorrect processing of i2cp.dontPublishLeaseSet param
+- UDP tunnels reload
+- Build for LibreSSL 3.5.2
+- Race condition in short tunnel build message
+- Race condition in local RouterInfo buffer allocation
+
 ## [2.41.0] - 2022-02-20
 ### Added
 - Clock syncronization through SSU

Makefile

@@ -4,7 +4,7 @@ SYS := $(shell $(CXX) -dumpmachine)
 
 ifneq (, $(findstring darwin, $(SYS)))
 	SHARED_SUFFIX = dylib
-else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
+else ifneq (, $(findstring mingw, $(SYS))$(findstring windows-gnu, $(SYS))$(findstring cygwin, $(SYS)))
 	SHARED_SUFFIX = dll
 else
 	SHARED_SUFFIX = so
@@ -12,19 +12,22 @@ endif
 
 SHLIB := libi2pd.$(SHARED_SUFFIX)
 ARLIB := libi2pd.a
-SHLIB_LANG := libi2pdlang.$(SHARED_SUFFIX)
-ARLIB_LANG := libi2pdlang.a
 SHLIB_CLIENT := libi2pdclient.$(SHARED_SUFFIX)
 ARLIB_CLIENT := libi2pdclient.a
+SHLIB_LANG := libi2pdlang.$(SHARED_SUFFIX)
+ARLIB_LANG := libi2pdlang.a
+SHLIB_WEBCONSOLE := libi2pdwebconsole.$(SHARED_SUFFIX)
+ARLIB_WEBCONSOLE := libi2pdwebconsole.a
 SHLIB_WRAP := libi2pdwrapper.$(SHARED_SUFFIX)
 ARLIB_WRAP := libi2pdwrapper.a
 I2PD := i2pd
 
 LIB_SRC_DIR := libi2pd
 LIB_CLIENT_SRC_DIR := libi2pd_client
-WRAP_SRC_DIR := libi2pd_wrapper
+WEBCONSOLE_SRC_DIR := libi2pd_webconsole
 LANG_SRC_DIR := i18n
 DAEMON_SRC_DIR := daemon
+WRAP_SRC_DIR := libi2pd_wrapper
 
 # import source files lists
 include filelist.mk
@@ -40,12 +43,6 @@ USE_GIT_VERSION := $(or $(USE_GIT_VERSION),no)
 # for MacOS only, waiting for "1", not "yes"
 HOMEBREW        := $(or $(HOMEBREW),0)
 
-# Client protocols
-USE_I2PC        := $(or $(USE_I2PC),yes)
-USE_I2CP        := $(or $(USE_I2CP),yes)
-USE_SAM         := $(or $(USE_SAM),yes)
-USE_BOB         := $(or $(USE_BOB),yes)
-
 ifeq ($(DEBUG),yes)
 	CXX_DEBUG = -g
 else
@@ -53,34 +50,21 @@ else
 	LD_DEBUG = -s
 endif
 
-ifeq ($(USE_I2PC),yes)
-	NEEDED_CXXFLAGS += -DWITH_I2PC
-endif
-ifeq ($(USE_I2CP),yes)
-	NEEDED_CXXFLAGS += -DWITH_I2CP
-endif
-ifeq ($(USE_SAM),yes)
-	NEEDED_CXXFLAGS += -DWITH_SAM
-endif
-ifeq ($(USE_BOB),yes)
-	NEEDED_CXXFLAGS += -DWITH_BOB
-endif
-
 ifneq (, $(findstring darwin, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/DaemonUnix.cpp
 	ifeq ($(HOMEBREW),1)
 		include Makefile.homebrew
 	else
 		include Makefile.osx
 	endif
 else ifneq (, $(findstring linux, $(SYS))$(findstring gnu, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/DaemonUnix.cpp
 	include Makefile.linux
 else ifneq (, $(findstring freebsd, $(SYS))$(findstring openbsd, $(SYS)))
-	DAEMON_SRC += $(DAEMON_SRC_DIR)/UnixDaemon.cpp
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/DaemonUnix.cpp
 	include Makefile.bsd
-else ifneq (, $(findstring mingw, $(SYS))$(findstring cygwin, $(SYS)))
-	DAEMON_SRC += Win32/DaemonWin32.cpp Win32/Win32App.cpp Win32/Win32Service.cpp Win32/Win32NetState.cpp
+else ifneq (, $(findstring mingw, $(SYS))$(findstring windows-gnu, $(SYS))$(findstring cygwin, $(SYS)))
+	DAEMON_SRC += $(DAEMON_SRC_DIR)/DaemonWin32.cpp Win32/Win32App.cpp Win32/Win32Service.cpp Win32/Win32NetState.cpp
 	include Makefile.mingw
 else # not supported
 	$(error Not supported platform)
@@ -91,31 +75,34 @@ ifeq ($(USE_GIT_VERSION),yes)
 	NEEDED_CXXFLAGS += -DGITVER=\"$(GIT_VERSION)\"
 endif
 
-NEEDED_CXXFLAGS += -MMD -MP -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR) -I$(LANG_SRC_DIR)
+NEEDED_CXXFLAGS += -MMD -MP -I$(LIB_SRC_DIR) -I$(LIB_CLIENT_SRC_DIR) -I$(LANG_SRC_DIR) -I$(WEBCONSOLE_SRC_DIR) -DOPENSSL_SUPPRESS_DEPRECATED
 
 LIB_OBJS        += $(patsubst %.cpp,obj/%.o,$(LIB_SRC))
 LIB_CLIENT_OBJS += $(patsubst %.cpp,obj/%.o,$(LIB_CLIENT_SRC))
 LANG_OBJS       += $(patsubst %.cpp,obj/%.o,$(LANG_SRC))
+WEBCONSOLE_OBJS += $(patsubst %.cpp,obj/%.o,$(WEBCONSOLE_SRC))
 DAEMON_OBJS     += $(patsubst %.cpp,obj/%.o,$(DAEMON_SRC))
 WRAP_LIB_OBJS   += $(patsubst %.cpp,obj/%.o,$(WRAP_LIB_SRC))
-DEPS            += $(LIB_OBJS:.o=.d) $(LIB_CLIENT_OBJS:.o=.d) $(LANG_OBJS:.o=.d) $(DAEMON_OBJS:.o=.d) $(WRAP_LIB_OBJS:.o=.d)
+DEPS            += $(LIB_OBJS:.o=.d) $(LIB_CLIENT_OBJS:.o=.d) $(LANG_OBJS:.o=.d) $(WEBCONSOLE_OBJS:.o=.d) $(DAEMON_OBJS:.o=.d) $(WRAP_LIB_OBJS:.o=.d)
 
 ## Build all code (libi2pd, libi2pdclient, libi2pdlang), link it to .a and build binary
-all: $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG) $(I2PD)
+all: $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG) $(ARLIB_WEBCONSOLE) $(I2PD)
 
 mk_obj_dir:
 	@mkdir -p obj/$(LIB_SRC_DIR)
 	@mkdir -p obj/$(LIB_CLIENT_SRC_DIR)
 	@mkdir -p obj/$(LANG_SRC_DIR)
+	@mkdir -p obj/$(WEBCONSOLE_SRC_DIR)
 	@mkdir -p obj/$(DAEMON_SRC_DIR)
 	@mkdir -p obj/$(WRAP_SRC_DIR)
 	@mkdir -p obj/Win32
 
-api: $(SHLIB) $(ARLIB)
-client: $(SHLIB_CLIENT) $(ARLIB_CLIENT)
-lang:  $(SHLIB_LANG) $(ARLIB_LANG)
-api_client: api client lang
-wrapper: api_client $(SHLIB_WRAP) $(ARLIB_WRAP)
+api:        $(SHLIB) $(ARLIB)
+client:     $(SHLIB_CLIENT) $(ARLIB_CLIENT)
+lang:       $(SHLIB_LANG) $(ARLIB_LANG)
+webconsole: $(SHLIB_WEBCONSOLE) $(ARLIB_WEBCONSOLE)
+api_client: api client lang webconsole
+wrapper:    api_client $(SHLIB_WRAP) $(ARLIB_WRAP)
 
 ## NOTE: The NEEDED_CXXFLAGS are here so that CXXFLAGS can be specified at build time
 ## **without** overwriting the CXXFLAGS which we need in order to build.
@@ -130,7 +117,7 @@ obj/%.o: %.cpp | mk_obj_dir
 # '-' is 'ignore if missing' on first run
 -include $(DEPS)
 
-$(I2PD): $(DAEMON_OBJS) $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG)
+$(I2PD): $(DAEMON_OBJS) $(ARLIB_WEBCONSOLE) $(ARLIB) $(ARLIB_CLIENT) $(ARLIB_LANG)
 	$(CXX) -o $@ $(LDFLAGS) $^ $(LDLIBS)
 
 $(SHLIB): $(LIB_OBJS) $(SHLIB_LANG)
@@ -143,12 +130,17 @@ ifneq ($(USE_STATIC),yes)
 	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS) $(SHLIB) $(SHLIB_LANG)
 endif
 
-$(SHLIB_WRAP): $(WRAP_LIB_OBJS)
+$(SHLIB_LANG): $(LANG_OBJS)
 ifneq ($(USE_STATIC),yes)
 	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
 endif
 
-$(SHLIB_LANG): $(LANG_OBJS)
+$(SHLIB_WEBCONSOLE): $(WEBCONSOLE_OBJS) $(SHLIB) $(SHLIB_CLIENT) $(SHLIB_LANG)
+ifneq ($(USE_STATIC),yes)
+	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS) $(SHLIB) $(SHLIB_CLIENT) $(SHLIB_LANG)
+endif
+
+$(SHLIB_WRAP): $(WRAP_LIB_OBJS)
 ifneq ($(USE_STATIC),yes)
 	$(CXX) $(LDFLAGS) -shared -o $@ $^ $(LDLIBS)
 endif
@@ -159,18 +151,21 @@ $(ARLIB): $(LIB_OBJS)
 $(ARLIB_CLIENT): $(LIB_CLIENT_OBJS)
 	$(AR) -r $@ $^
 
-$(ARLIB_WRAP): $(WRAP_LIB_OBJS)
+$(ARLIB_LANG): $(LANG_OBJS)
 	$(AR) -r $@ $^
 
-$(ARLIB_LANG): $(LANG_OBJS)
+$(ARLIB_WEBCONSOLE): $(WEBCONSOLE_OBJS)
+	$(AR) -r $@ $^
+
+$(ARLIB_WRAP): $(WRAP_LIB_OBJS)
 	$(AR) -r $@ $^
 
 clean:
 	$(RM) -r obj
 	$(RM) -r docs/generated
-	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT) $(SHLIB_LANG) $(ARLIB_LANG) $(SHLIB_WRAP) $(ARLIB_WRAP)
+	$(RM) $(I2PD) $(SHLIB) $(ARLIB) $(SHLIB_CLIENT) $(ARLIB_CLIENT) $(SHLIB_LANG) $(ARLIB_LANG) $(SHLIB_WEBCONSOLE) $(ARLIB_WEBCONSOLE) $(SHLIB_WRAP) $(ARLIB_WRAP)
 
-strip: $(I2PD) $(SHLIB) $(SHLIB_CLIENT) $(SHLIB_LANG)
+strip: $(I2PD) $(SHLIB) $(SHLIB_CLIENT) $(SHLIB_LANG) $(SHLIB_WEBCONSOLE)
 	strip $^
 
 LATEST_TAG=$(shell git describe --tags --abbrev=0 openssl)

Makefile.mingw

@@ -3,19 +3,11 @@ USE_WIN32_APP := yes
 
 WINDRES = windres
 
-CXXFLAGS := $(CXX_DEBUG) -DWIN32_LEAN_AND_MEAN -fPIC -msse
-INCFLAGS = -I$(DAEMON_SRC_DIR) -IWin32
+CXXFLAGS := $(CXX_DEBUG) -fPIC -msse
+INCFLAGS = -IWin32
 LDFLAGS := ${LD_DEBUG} -static
 
-# detect proper flag for c++11 support by compilers
-CXXVER := $(shell $(CXX) -dumpversion)
-ifeq ($(shell expr match ${CXXVER} "[4]\.[7-9]\|4\.1[0-9]\|[5-6]"),4) # gcc 4.7 - 6
-	NEEDED_CXXFLAGS += -std=c++11
-else ifeq ($(shell expr match ${CXXVER} "[1,7-9]"),1) # gcc >= 7
-	NEEDED_CXXFLAGS += -std=c++17
-else # not supported
-$(error Compiler too old)
-endif
+NEEDED_CXXFLAGS += -std=c++17 -DWIN32_LEAN_AND_MEAN
 
 # Boost libraries suffix
 BOOST_SUFFIX = -mt

Win32/Win32App.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -18,7 +18,7 @@
 #include "Tunnel.h"
 #include "version.h"
 #include "resource.h"
-#include "Daemon.h"
+
 #include "Win32App.h"
 #include "Win32NetState.h"
 
@@ -55,13 +55,15 @@ namespace win32
 		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_ABOUT, "&About...");
 		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
 		if(!i2p::context.AcceptsTunnels())
-			InsertMenu (hPopup, -1,
-				i2p::util::DaemonWin32::Instance ().isGraceful ? MF_BYPOSITION | MF_STRING | MF_GRAYED : MF_BYPOSITION | MF_STRING,
-				ID_ACCEPT_TRANSIT, "Accept &transit");
+			if(m_getIsGraceful)
+				if(m_getIsGraceful())
+					InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING | MF_GRAYED, ID_ACCEPT_TRANSIT, "Accept &transit");
+			else 
+				InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_ACCEPT_TRANSIT, "Accept &transit");
 		else
 			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_DECLINE_TRANSIT, "Decline &transit");
 		InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_RELOAD, "&Reload tunnels config");
-		if (!i2p::util::DaemonWin32::Instance ().isGraceful)
+		if (!m_getIsGraceful)
 			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_GRACEFUL_SHUTDOWN, "&Graceful shutdown");
 		else
 			InsertMenu (hPopup, -1, MF_BYPOSITION | MF_STRING, ID_STOP_GRACEFUL_SHUTDOWN, "Stop &graceful shutdown");
@@ -270,7 +272,7 @@ namespace win32
 						SetTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER, 10*60*1000, nullptr); // 10 minutes
 						SetTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_TIMER, 1000, nullptr); // check tunnels every second
 						g_GracefulShutdownEndtime = GetTickCount() + 10*60*1000;
-						i2p::util::DaemonWin32::Instance ().isGraceful = true;
+						if (m_setIsGraceful) m_setIsGraceful(true);
 						return 0;
 					}
 					case ID_STOP_GRACEFUL_SHUTDOWN:
@@ -279,7 +281,7 @@ namespace win32
 						KillTimer (hWnd, IDT_GRACEFUL_SHUTDOWN_TIMER);
 						KillTimer (hWnd, IDT_GRACEFUL_TUNNELCHECK_TIMER);
 						g_GracefulShutdownEndtime = 0;
-						i2p::util::DaemonWin32::Instance ().isGraceful = false;
+						if (m_setIsGraceful) m_setIsGraceful(false);
 						return 0;
 					}
 					case ID_RELOAD:

Win32/Win32App.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -22,6 +22,15 @@ namespace win32
 	int RunWin32App ();
 	bool GracefulShutdown ();
 	bool StopGracefulShutdown ();
+
+	inline typedef std::function<void (bool)> DaemonSetIsGraceful;
+	inline DaemonSetIsGraceful m_setIsGraceful;
+	inline void SetIsGraceful (const DaemonSetIsGraceful& f) { m_setIsGraceful = f; };
+
+	inline typedef std::function<bool ()> DaemonGetIsGraceful;
+	inline DaemonGetIsGraceful m_getIsGraceful;
+	inline void GetIsGraceful (const DaemonGetIsGraceful& f) { m_getIsGraceful = f; };
+
 }
 }
 #endif // WIN32APP_H__

Win32/Win32Service.cpp

@@ -10,7 +10,6 @@
 #include <assert.h>
 #include <windows.h>
 
-#include "Daemon.h"
 #include "Log.h"
 
 I2PService *I2PService::s_service = NULL;
@@ -132,7 +131,13 @@ void I2PService::Start(DWORD dwArgc, PSTR *pszArgv)
 void I2PService::OnStart(DWORD dwArgc, PSTR *pszArgv)
 {
 	LogPrint(eLogInfo, "Win32Service: in OnStart (", EVENTLOG_INFORMATION_TYPE, ")");
-	Daemon.start();
+	if(m_daemonStart)
+		m_daemonStart();
+	else
+	{
+		LogPrint(eLogError, "Win32Service: failed to start: Unable to call callback");
+		SetServiceStatus(SERVICE_STOPPED);
+	}
 	_worker = new std::thread(std::bind(&I2PService::WorkerThread, this));
 }
 
@@ -171,7 +176,11 @@ void I2PService::OnStop()
 {
 	// Log a service stop message to the Application log.
 	LogPrint(eLogInfo, "Win32Service: in OnStop (", EVENTLOG_INFORMATION_TYPE, ")");
-	Daemon.stop();
+	if(m_daemonStop)
+		m_daemonStop();
+	else
+		LogPrint(eLogError, "Win32Service: failed to stop: Unable to call callback");
+
 	m_fStopping = TRUE;
 	if (WaitForSingleObject(m_hStoppedEvent, INFINITE) != WAIT_OBJECT_0)
 	{

Win32/Win32Service.h

@@ -6,9 +6,10 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifndef WIN_32_SERVICE_H__
-#define WIN_32_SERVICE_H__
+#ifndef WIN32SERVICE_H__
+#define WIN32SERVICE_H__
 
+#include <functional>
 #include <thread>
 #include <windows.h>
 
@@ -29,6 +30,13 @@ class I2PService
 		static BOOL Run(I2PService &service);
 		void Stop();
 
+		typedef std::function<bool ()> DaemonStart;
+		void SetDaemonStart (const DaemonStart& f) { m_daemonStart = f; };
+
+		typedef std::function<bool ()> DaemonStop;
+		void SetDaemonStop (const DaemonStop& f) { m_daemonStop = f; };
+
+
 	protected:
 
 		virtual void OnStart(DWORD dwArgc, PSTR *pszArgv);
@@ -58,6 +66,11 @@ class I2PService
 		HANDLE m_hStoppedEvent;
 
 		std::thread* _worker;
+
+	private:
+
+		DaemonStart m_daemonStart;
+		DaemonStop m_daemonStop;
 };
 
-#endif // WIN_32_SERVICE_H__
+#endif // WIN32SERVICE_H__

build/CMakeLists.txt

@@ -33,11 +33,13 @@ target_architecture(ARCHITECTURE)
 
 set(LIBI2PD_SRC_DIR ../libi2pd)
 set(LIBI2PD_CLIENT_SRC_DIR ../libi2pd_client)
+set(WEBCONSOLE_SRC_DIR ../libi2pd_webconsole)
 set(LANG_SRC_DIR ../i18n)
 set(DAEMON_SRC_DIR ../daemon)
 
 include_directories(${LIBI2PD_SRC_DIR})
 include_directories(${LIBI2PD_CLIENT_SRC_DIR})
+include_directories(${WEBCONSOLE_SRC_DIR})
 include_directories(${LANG_SRC_DIR})
 include_directories(${DAEMON_SRC_DIR})
 
@@ -68,6 +70,18 @@ if(WITH_LIBRARY)
     COMPONENT Libraries)
 endif()
 
+FILE(GLOB WEBCONSOLE_SRC ${WEBCONSOLE_SRC_DIR}/*.cpp)
+add_library(libi2pdwebconsole ${WEBCONSOLE_SRC})
+set_target_properties(libi2pdwebconsole PROPERTIES PREFIX "")
+
+if(WITH_LIBRARY)
+  install(TARGETS libi2pdwebconsole
+    EXPORT libi2pdwebconsole
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    COMPONENT Libraries)
+endif()
+
 FILE(GLOB LANG_SRC ${LANG_SRC_DIR}/*.cpp)
 add_library(libi2pdlang ${LANG_SRC})
 set_target_properties(libi2pdlang PROPERTIES PREFIX "")
@@ -82,7 +96,6 @@ endif()
 
 set(DAEMON_SRC
   "${DAEMON_SRC_DIR}/Daemon.cpp"
-  "${DAEMON_SRC_DIR}/HTTPServer.cpp"
   "${DAEMON_SRC_DIR}/I2PControl.cpp"
   "${DAEMON_SRC_DIR}/i2pd.cpp"
   "${DAEMON_SRC_DIR}/UPnP.cpp"
@@ -135,7 +148,7 @@ endif()
 
 # compiler flags customization(by system)
 if(UNIX)
-  list(APPEND DAEMON_SRC "${DAEMON_SRC_DIR}/UnixDaemon.cpp")
+  list(APPEND DAEMON_SRC "${DAEMON_SRC_DIR}/DaemonUnix.cpp")
   if(NOT(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD" OR APPLE))
     # "'sleep_for' is not a member of 'std::this_thread'" in gcc 4.7/4.8
     add_definitions("-D_GLIBCXX_USE_NANOSLEEP=1")
@@ -165,20 +178,8 @@ endif()
 
 
 # libraries
-# TODO: once CMake 3.1+ becomes mainstream, see e.g. http://stackoverflow.com/a/29871891/673826
-# use imported Threads::Threads instead
 set(THREADS_PREFER_PTHREAD_FLAG ON)
-if(IOS)
-  set(CMAKE_THREAD_LIBS_INIT "-lpthread")
-  set(CMAKE_HAVE_THREADS_LIBRARY 1)
-  set(CMAKE_USE_WIN32_THREADS_INIT 0)
-  set(CMAKE_USE_PTHREADS_INIT 1)
-else()
-  find_package(Threads REQUIRED)
-endif()
-if(THREADS_HAVE_PTHREAD_ARG) # compile time flag
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
-endif()
+find_package(Threads REQUIRED)
 
 if(WITH_STATIC)
   set(Boost_USE_STATIC_LIBS ON)
@@ -197,7 +198,7 @@ else()
   add_definitions(-DBOOST_SYSTEM_DYN_LINK -DBOOST_FILESYSTEM_DYN_LINK -DBOOST_PROGRAM_OPTIONS_DYN_LINK -DBOOST_DATE_TIME_DYN_LINK -DBOOST_REGEX_DYN_LINK)
 endif()
 
-target_link_libraries(libi2pdclient libi2pd libi2pdlang)
+target_link_libraries(libi2pdwebconsole libi2pdclient libi2pd libi2pdlang)
 
 find_package(Boost COMPONENTS system filesystem program_options date_time REQUIRED)
 if(NOT DEFINED Boost_INCLUDE_DIRS)
@@ -210,7 +211,7 @@ if(NOT DEFINED OPENSSL_INCLUDE_DIR)
 endif()
 
 if(OPENSSL_VERSION VERSION_GREATER_EQUAL "3.0.0")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
+  add_definitions(-DOPENSSL_SUPPRESS_DEPRECATED)
 endif()
 
 if(WITH_UPNP)
@@ -278,7 +279,7 @@ if(WITH_BINARY)
   endif()
 
   target_link_libraries(libi2pd ${Boost_LIBRARIES} ${ZLIB_LIBRARY})
-  target_link_libraries("${PROJECT_NAME}" libi2pd libi2pdclient libi2pdlang ${DL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${UPNP_LIB} ${ZLIB_LIBRARY} ${CMAKE_THREAD_LIBS_INIT} ${DL_LIB} ${CMAKE_REQUIRED_LIBRARIES})
+  target_link_libraries("${PROJECT_NAME}" libi2pdwebconsole libi2pd libi2pdclient libi2pdlang ${DL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${UPNP_LIB} ${ZLIB_LIBRARY} Threads::Threads ${DL_LIB} ${CMAKE_REQUIRED_LIBRARIES})
 
   install(TARGETS "${PROJECT_NAME}" RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime)
   set(APPS "\${CMAKE_INSTALL_PREFIX}/bin/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX}")

build/build_mingw.cmd

@@ -52,22 +52,28 @@ REM converting configuration files to DOS format (make usable in Windows Notepad
 %xSH% "unix2dos contrib/i2pd.conf contrib/tunnels.conf contrib/tunnels.d/* contrib/webconsole/style.css" >> build\build.log 2>&1
 
 REM Prepare binary signing command if signing key and password provided
-if defined SIGNKEY (
-  if defined SIGNPASS (
-    echo Signing options found
+if defined SIGN (
+  echo Signing enabled
 
-    for %%X in (signtool.exe) do (set xSIGNTOOL=%%~$PATH:X)
-    if not defined xSIGNTOOL (
-      if not defined SIGNTOOL (
-        echo Error: Can't find signtool. Please provide path to binary using SIGNTOOL variable.
-        exit /b 1
-      ) else (
-        set "xSIGNTOOL=%SIGNTOOL%"
-      )
+  for %%X in (signtool.exe) do (set xSIGNTOOL=%%~$PATH:X)
+  if not defined xSIGNTOOL (
+    if not defined SIGNTOOL (
+      echo Error: Can't find signtool. Please provide path to binary using SIGNTOOL variable.
+      exit /b 1
+    ) else (
+      set "xSIGNTOOL=%SIGNTOOL%"
     )
-
-    set "xSIGNOPTS=sign /tr http://timestamp.digicert.com /td sha256 /fd sha256 /f ^"%SIGNKEY%^" /p ^"%SIGNPASS%^""
   )
+
+  if defined SIGNKEY (
+    set "xSIGNKEYOPTS=/f ^"%SIGNKEY%^""
+  )
+
+  if defined SIGNPASS (
+    set "xSIGNPASSOPTS=/p ^"%SIGNPASS%^""
+  )
+
+  set "xSIGNOPTS=sign /tr http://timestamp.digicert.com /td sha256 /fd sha256 %xSIGNKEYOPTS% %xSIGNPASSOPTS%"
 )
 
 REM starting building

contrib/i2pd.conf

@@ -110,8 +110,8 @@ port = 7070
 # user = i2pd
 # pass = changeme
 ## Select webconsole language
-## Currently supported english (default), afrikaans, armenian, german, russian,
-## turkmen, ukrainian and uzbek languages
+## Currently supported english (default), afrikaans, armenian, french, german,
+## russian, turkmen, ukrainian and uzbek languages
 # lang = english
 
 [httpproxy]

contrib/rpm/i2pd-git.spec

@@ -1,7 +1,7 @@
 %define git_hash %(git rev-parse HEAD | cut -c -7)
 
 Name:          i2pd-git
-Version:       2.41.0
+Version:       2.42.1
 Release:       git%{git_hash}%{?dist}
 Summary:       I2P router written in C++
 Conflicts:     i2pd
@@ -164,6 +164,12 @@ getent passwd i2pd >/dev/null || \
 
 
 %changelog
+* Tue May 24 2022 r4sas <r4sas@i2pmail.org> - 2.42.1
+- update to 2.42.1
+
+* Sun May 22 2022 orignal <orignal@i2pmail.org> - 2.42.0
+- update to 2.42.0
+
 * Sun Feb 20 2022 r4sas <r4sas@i2pmail.org> - 2.41.0
 - update to 2.41.0
 - fixed build on Fedora Copr over openssl trunk code

contrib/rpm/i2pd.spec

@@ -1,5 +1,5 @@
 Name:          i2pd
-Version:       2.41.0
+Version:       2.42.1
 Release:       1%{?dist}
 Summary:       I2P router written in C++
 Conflicts:     i2pd-git
@@ -161,6 +161,12 @@ getent passwd i2pd >/dev/null || \
 
 
 %changelog
+* Tue May 24 2022 r4sas <r4sas@i2pmail.org> - 2.42.1
+- update to 2.42.1
+
+* Sun May 22 2022 orignal <orignal@i2pmail.org> - 2.42.0
+- update to 2.42.0
+
 * Sun Feb 20 2022 r4sas <r4sas@i2pmail.org> - 2.41.0
 - update to 2.41.0
 

daemon/Daemon.cpp

@@ -26,9 +26,7 @@
 #include "Streaming.h"
 #include "Destination.h"
 #include "HTTPServer.h"
-#ifdef WITH_I2PC
 #include "I2PControl.h"
-#endif
 #include "ClientContext.h"
 #include "Crypto.h"
 #include "UPnP.h"
@@ -47,9 +45,7 @@ namespace util
 		~Daemon_Singleton_Private() {};
 
 		std::unique_ptr<i2p::http::HTTPServer> httpServer;
-#ifdef WITH_I2PC
 		std::unique_ptr<i2p::client::I2PControlService> m_I2PControlService;
-#endif
 		std::unique_ptr<i2p::transport::UPnP> UPnP;
 		std::unique_ptr<i2p::util::NTPTimeSync> m_NTPSync;
 	};
@@ -62,9 +58,7 @@ namespace util
 	bool Daemon_Singleton::IsService () const
 	{
 		bool service = false;
-#ifndef _WIN32
 		i2p::config::GetOption("service", service);
-#endif
 		return service;
 	}
 
@@ -83,7 +77,7 @@ namespace util
 		i2p::config::Init();
 		i2p::config::ParseCmdline(argc, argv);
 
-		std::string config;  i2p::config::GetOption("conf", config);
+		std::string config; i2p::config::GetOption("conf", config);
 		std::string datadir;
 		if(DaemonDataDir != "") {
 			datadir = DaemonDataDir;
@@ -115,9 +109,9 @@ namespace util
 
 		certsdir = i2p::fs::GetCertsDir();
 
-		std::string logs     = ""; i2p::config::GetOption("log",      logs);
-		std::string logfile  = ""; i2p::config::GetOption("logfile",  logfile);
-		std::string loglevel = ""; i2p::config::GetOption("loglevel", loglevel);
+		std::string logs     = ""; i2p::config::GetOption("log",        logs);
+		std::string logfile  = ""; i2p::config::GetOption("logfile",    logfile);
+		std::string loglevel = ""; i2p::config::GetOption("loglevel",   loglevel);
 		bool logclftime;           i2p::config::GetOption("logclftime", logclftime);
 
 		/* setup logging */
@@ -258,17 +252,17 @@ namespace util
 		}
 		bool ssu2; i2p::config::GetOption("ssu2.enabled", ssu2);
 		if (ssu2)
-		{	
+		{
 			bool published; i2p::config::GetOption("ssu2.published", published);
 			if (published)
 			{
 				uint16_t ssu2port; i2p::config::GetOption("ssu2.port", ssu2port);
 				i2p::context.PublishSSU2Address (ssu2port, true, ipv4, ipv6); // publish
-			}	
+			}
 			else
 				i2p::context.PublishSSU2Address (0, false, ipv4, ipv6); // unpublish
 		}
-		
+
 		bool transit; i2p::config::GetOption("notransit", transit);
 		i2p::context.SetAcceptsTunnels (!transit);
 		uint16_t transitTunnels; i2p::config::GetOption("limits.transittunnels", transitTunnels);
@@ -429,6 +423,10 @@ namespace util
 			try
 			{
 				d.httpServer = std::unique_ptr<i2p::http::HTTPServer>(new i2p::http::HTTPServer(httpAddr, httpPort));
+				d.httpServer->SetDaemonStop (std::bind (Daemon_Singleton::stop, this));
+#if ((!defined(WIN32) && !defined(QT_GUI_LIB) && !defined(ANDROID)) || defined(ANDROID_BINARY))
+				d.httpServer->SetDaemonGracefulTimer (std::bind (gracefulShutdownInterval, this));
+#endif
 				d.httpServer->Start();
 			}
 			catch (std::exception& ex)
@@ -445,7 +443,6 @@ namespace util
 		LogPrint(eLogInfo, "Daemon: Starting Client");
 		i2p::client::context.Start ();
 
-#ifdef WITH_I2PC
 		// I2P Control Protocol
 		bool i2pcontrol; i2p::config::GetOption("i2pcontrol.enabled", i2pcontrol);
 		if (i2pcontrol) {
@@ -463,7 +460,6 @@ namespace util
 				ThrowFatal ("Unable to start I2PControl service at ", i2pcpAddr, ":", i2pcpPort, ": ", ex.what ());
 			}
 		}
-#endif
 		return true;
 	}
 
@@ -496,14 +492,12 @@ namespace util
 			d.httpServer->Stop();
 			d.httpServer = nullptr;
 		}
-#ifdef WITH_I2PC
 		if (d.m_I2PControlService)
 		{
 			LogPrint(eLogInfo, "Daemon: Stopping I2PControl");
 			d.m_I2PControlService->Stop ();
 			d.m_I2PControlService = nullptr;
 		}
-#endif
 		i2p::crypto::TerminateCrypto ();
 		i2p::log::Logger().Stop();
 

daemon/Daemon.h

@@ -75,14 +75,17 @@ namespace util
 				return instance;
 			}
 
-			bool init(int argc, char* argv[]);
-			bool start();
-			bool stop();
+			bool init (int argc, char* argv[]);
+			bool start ();
+			bool stop ();
 			void run ();
 
-			bool isGraceful;
+			void SetIsGraceful (bool state) { m_isGraceful = state; };
+			const bool GetIsGraceful () { return m_isGraceful; };
 
-			DaemonWin32 ():isGraceful(false) {}
+		private:
+
+			bool m_isGraceful;
 	};
 #elif (defined(ANDROID) && !defined(ANDROID_BINARY))
 #define Daemon i2p::util::DaemonAndroid::Instance()
@@ -109,8 +112,8 @@ namespace util
 				return instance;
 			}
 
-			bool start();
-			bool stop();
+			bool start ();
+			bool stop ();
 			void run ();
 
 		private:

daemon/DaemonWin32.cpp

@@ -6,6 +6,8 @@
 * See full license text in LICENSE file at top of project tree
 */
 
+#ifdef _WIN32
+
 #include <thread>
 #include <clocale>
 #include "Config.h"
@@ -13,7 +15,6 @@
 #include "util.h"
 #include "Log.h"
 
-#ifdef _WIN32
 #include "Win32Service.h"
 #ifdef WIN32_APP
 #include <windows.h>
@@ -38,6 +39,9 @@ namespace util
 			}
 		);
 
+		i2p::win32::SetIsGraceful (std::bind (&DaemonWin32::SetIsGraceful, this, std::placeholders::_1));
+		i2p::win32::GetIsGraceful (std::bind (&DaemonWin32::GetIsGraceful, this));
+
 		if (!Daemon_Singleton::init(argc, argv))
 			return false;
 
@@ -45,6 +49,8 @@ namespace util
 		{
 			LogPrint(eLogDebug, "Daemon: running as service");
 			I2PService service((PSTR)SERVICE_NAME);
+			service.SetDaemonStart (std::bind (&DaemonWin32::start, this));
+			service.SetDaemonStop (std::bind (&DaemonWin32::stop, this));
 			if (!I2PService::Run(service))
 			{
 				LogPrint(eLogError, "Daemon: Service failed to run w/err 0x%08lx\n", GetLastError());

daemon/I2PControl.cpp

@@ -6,8 +6,6 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifdef WITH_I2PC
-
 #include <stdio.h>
 #include <sstream>
 #include <openssl/x509.h>
@@ -68,28 +66,28 @@ namespace client
 		m_SSLContext.use_private_key_file (i2pcp_key, boost::asio::ssl::context::pem);
 
 		// handlers
-		m_MethodHandlers["Authenticate"]   = &I2PControlService::AuthenticateHandler;
-		m_MethodHandlers["Echo"]           = &I2PControlService::EchoHandler;
-		m_MethodHandlers["I2PControl"]     = &I2PControlService::I2PControlHandler;
-		m_MethodHandlers["RouterInfo"]     = &I2PControlService::RouterInfoHandler;
-		m_MethodHandlers["RouterManager"]  = &I2PControlService::RouterManagerHandler;
-		m_MethodHandlers["NetworkSetting"] = &I2PControlService::NetworkSettingHandler;
-		m_MethodHandlers["ClientServicesInfo"]     = &I2PControlService::ClientServicesInfoHandler;
+		m_MethodHandlers["Authenticate"]       = &I2PControlService::AuthenticateHandler;
+		m_MethodHandlers["Echo"]               = &I2PControlService::EchoHandler;
+		m_MethodHandlers["I2PControl"]         = &I2PControlService::I2PControlHandler;
+		m_MethodHandlers["RouterInfo"]         = &I2PControlService::RouterInfoHandler;
+		m_MethodHandlers["RouterManager"]      = &I2PControlService::RouterManagerHandler;
+		m_MethodHandlers["NetworkSetting"]     = &I2PControlService::NetworkSettingHandler;
+		m_MethodHandlers["ClientServicesInfo"] = &I2PControlService::ClientServicesInfoHandler;
 
 		// I2PControl
 		m_I2PControlHandlers["i2pcontrol.password"] = &I2PControlService::PasswordHandler;
 
 		// RouterInfo
-		m_RouterInfoHandlers["i2p.router.uptime"]  = &I2PControlService::UptimeHandler;
-		m_RouterInfoHandlers["i2p.router.version"] = &I2PControlService::VersionHandler;
-		m_RouterInfoHandlers["i2p.router.status"]  = &I2PControlService::StatusHandler;
-		m_RouterInfoHandlers["i2p.router.netdb.knownpeers"]   = &I2PControlService::NetDbKnownPeersHandler;
-		m_RouterInfoHandlers["i2p.router.netdb.activepeers"]  = &I2PControlService::NetDbActivePeersHandler;
-		m_RouterInfoHandlers["i2p.router.net.bw.inbound.1s"]  = &I2PControlService::InboundBandwidth1S;
-		m_RouterInfoHandlers["i2p.router.net.bw.outbound.1s"] = &I2PControlService::OutboundBandwidth1S;
-		m_RouterInfoHandlers["i2p.router.net.status"]         = &I2PControlService::NetStatusHandler;
+		m_RouterInfoHandlers["i2p.router.uptime"]                    = &I2PControlService::UptimeHandler;
+		m_RouterInfoHandlers["i2p.router.version"]                   = &I2PControlService::VersionHandler;
+		m_RouterInfoHandlers["i2p.router.status"]                    = &I2PControlService::StatusHandler;
+		m_RouterInfoHandlers["i2p.router.netdb.knownpeers"]          = &I2PControlService::NetDbKnownPeersHandler;
+		m_RouterInfoHandlers["i2p.router.netdb.activepeers"]         = &I2PControlService::NetDbActivePeersHandler;
+		m_RouterInfoHandlers["i2p.router.net.bw.inbound.1s"]         = &I2PControlService::InboundBandwidth1S;
+		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"] = &I2PControlService::TunnelsSuccessRateHandler;
+		m_RouterInfoHandlers["i2p.router.net.tunnels.successrate"]   = &I2PControlService::TunnelsSuccessRateHandler;
 		m_RouterInfoHandlers["i2p.router.net.total.received.bytes"]  = &I2PControlService::NetTotalReceivedBytes;
 		m_RouterInfoHandlers["i2p.router.net.total.sent.bytes"]      = &I2PControlService::NetTotalSentBytes;
 
@@ -105,16 +103,10 @@ namespace client
 		// ClientServicesInfo
 		m_ClientServicesInfoHandlers["I2PTunnel"] = &I2PControlService::I2PTunnelInfoHandler;
 		m_ClientServicesInfoHandlers["HTTPProxy"] = &I2PControlService::HTTPProxyInfoHandler;
-		m_ClientServicesInfoHandlers["SOCKS"] = &I2PControlService::SOCKSInfoHandler;
-#ifdef WITH_SAM
-		m_ClientServicesInfoHandlers["SAM"] = &I2PControlService::SAMInfoHandler;
-#endif
-#ifdef WITH_BOB
-		m_ClientServicesInfoHandlers["BOB"] = &I2PControlService::BOBInfoHandler;
-#endif
-#ifdef WITH_I2CP
-		m_ClientServicesInfoHandlers["I2CP"] = &I2PControlService::I2CPInfoHandler;
-#endif
+		m_ClientServicesInfoHandlers["SOCKS"]     = &I2PControlService::SOCKSInfoHandler;
+		m_ClientServicesInfoHandlers["SAM"]       = &I2PControlService::SAMInfoHandler;
+		m_ClientServicesInfoHandlers["BOB"]       = &I2PControlService::BOBInfoHandler;
+		m_ClientServicesInfoHandlers["I2CP"]      = &I2PControlService::I2CPInfoHandler;
 	}
 
 	I2PControlService::~I2PControlService ()
@@ -175,7 +167,7 @@ namespace client
 			Accept ();
 
 		if (ecode) {
-			LogPrint (eLogError, "I2PControl: Accept error: ",  ecode.message ());
+			LogPrint (eLogError, "I2PControl: Accept error: ", ecode.message ());
 			return;
 		}
 		LogPrint (eLogDebug, "I2PControl: New request from ", socket->lowest_layer ().remote_endpoint ());
@@ -297,12 +289,12 @@ namespace client
 	{
 		ss << "\"" << name << "\":";
 		if (value.length () > 0)
-		{	
+		{
 			if (quotes)
 				ss << "\"" << value << "\"";
 			else
 				ss << value;
-		}	
+		}
 		else
 			ss << "null";
 	}
@@ -353,7 +345,8 @@ namespace client
 		}
 	}
 
-	// handlers
+// handlers
+
 	void I2PControlService::AuthenticateHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
 	{
 		int api       = params.get<int> ("API");
@@ -378,7 +371,8 @@ namespace client
 	}
 
 
-	// I2PControl
+// I2PControl
+
 	void I2PControlService::I2PControlHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
 	{
 		for (auto& it: params)
@@ -484,7 +478,7 @@ namespace client
 
 	void I2PControlService::NetTotalSentBytes (std::ostringstream& results)
 	{
-		InsertParam (results, "i2p.router.net.total.sent.bytes",     (double)i2p::transport::transports.GetTotalSentBytes ());
+		InsertParam (results, "i2p.router.net.total.sent.bytes", (double)i2p::transport::transports.GetTotalSentBytes ());
 	}
 
 
@@ -538,7 +532,7 @@ namespace client
 		i2p::data::netdb.Reseed ();
 	}
 
-	// network setting
+// network setting
 	void I2PControlService::NetworkSettingHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
 	{
 		for (auto it = params.begin (); it != params.end (); it++)
@@ -618,7 +612,8 @@ namespace client
 		EVP_PKEY_free (pkey);
 	}
 
-	// ClientServicesInfo
+// ClientServicesInfo
+
 	void I2PControlService::ClientServicesInfoHandler (const boost::property_tree::ptree& params, std::ostringstream& results)
 	{
 		for (auto it = params.begin (); it != params.end (); it++)
@@ -724,7 +719,6 @@ namespace client
 		InsertParam (results, "SOCKS", pt);
 	}
 
-#ifdef WITH_SAM
 	void I2PControlService::SAMInfoHandler (std::ostringstream& results)
 	{
 		boost::property_tree::ptree pt;
@@ -760,9 +754,7 @@ namespace client
 
 		InsertParam (results, "SAM", pt);
 	}
-#endif // WITH_SAM
 
-#ifdef WITH_BOB
 	void I2PControlService::BOBInfoHandler (std::ostringstream& results)
 	{
 		boost::property_tree::ptree pt;
@@ -777,9 +769,7 @@ namespace client
 
 		InsertParam (results, "BOB", pt);
 	}
-#endif // WITH_BOB
 
-#ifdef WITH_I2CP
 	void I2PControlService::I2CPInfoHandler (std::ostringstream& results)
 	{
 		boost::property_tree::ptree pt;
@@ -794,7 +784,5 @@ namespace client
 
 		InsertParam (results, "I2CP", pt);
 	}
-#endif // WITH_I2CP
 }
 }
-#endif // WITH_I2PC

daemon/I2PControl.h

@@ -6,8 +6,6 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifdef WITH_I2PC
-
 #ifndef I2P_CONTROL_H__
 #define I2P_CONTROL_H__
 
@@ -116,15 +114,9 @@ namespace client
 			void I2PTunnelInfoHandler (std::ostringstream& results);
 			void HTTPProxyInfoHandler (std::ostringstream& results);
 			void SOCKSInfoHandler (std::ostringstream& results);
-#ifdef WITH_SAM
 			void SAMInfoHandler (std::ostringstream& results);
-#endif
-#ifdef WITH_BOB
 			void BOBInfoHandler (std::ostringstream& results);
-#endif
-#ifdef WITH_I2CP
 			void I2CPInfoHandler (std::ostringstream& results);
-#endif
 
 		private:
 
@@ -149,4 +141,3 @@ namespace client
 }
 
 #endif
-#endif // WITH_I2PC

daemon/UPnP.cpp

@@ -93,7 +93,7 @@ namespace transport
 #endif
 
 		isError = err != UPNPDISCOVER_SUCCESS;
-#else  // MINIUPNPC_API_VERSION >= 8
+#else // MINIUPNPC_API_VERSION >= 8
 		err = 0;
 		m_Devlist = upnpDiscover (UPNP_RESPONSE_TIMEOUT, NULL, NULL, 0);
 		isError = m_Devlist == NULL;

daemon/UPnP.h

@@ -51,7 +51,7 @@ namespace transport
 		private:
 
 			void Discover ();
-			int  CheckMapping (const char* port, const char* type);
+			int CheckMapping (const char* port, const char* type);
 			void PortMapping ();
 			void TryPortMapping (std::shared_ptr<i2p::data::RouterInfo::Address> address);
 			void CloseMapping ();
@@ -80,7 +80,7 @@ namespace transport
 }
 }
 
-#else  // USE_UPNP
+#else // USE_UPNP
 namespace i2p {
 namespace transport {
 	/* class stub */

debian/changelog

@@ -1,3 +1,16 @@
+i2pd (2.42.1-1) unstable; urgency=medium
+
+  * updated to version 2.42.1/0.9.54
+  * remove -O3 optimization flag
+
+ -- r4sas <r4sas@i2pmail.org>  Tue, 24 May 2022 12:00:00 +0000
+
+i2pd (2.42.0-1) unstable; urgency=medium
+
+  * updated to version 2.42.0/0.9.54
+
+ -- orignal <orignal@i2pmail.org>  Sun, 22 May 2022 16:00:00 +0000
+
 i2pd (2.41.0-1) unstable; urgency=medium
 
   * updated to version 2.41.0/0.9.53

debian/rules

@@ -1,17 +1,12 @@
 #!/usr/bin/make -f
 #export DH_VERBOSE=1
-
-
 export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 
-
 include /usr/share/dpkg/architecture.mk
 
-export DEB_CXXFLAGS_MAINT_APPEND  = -Wall -pedantic -O3
-
+export DEB_CXXFLAGS_MAINT_APPEND  = -Wall -pedantic
 export DEB_LDFLAGS_MAINT_APPEND =
 
-
 %:
 	dh $@ --parallel
 

filelist.mk

@@ -1,26 +1,7 @@
-#LIB_SRC = \
-#  BloomFilter.cpp Gzip.cpp Crypto.cpp Datagram.cpp Garlic.cpp I2NPProtocol.cpp LeaseSet.cpp \
-#  Log.cpp NTCPSession.cpp NetDb.cpp NetDbRequests.cpp Profiling.cpp \
-#  Reseed.cpp RouterContext.cpp RouterInfo.cpp Signature.cpp SSU.cpp \
-#  SSUSession.cpp SSUData.cpp Streaming.cpp Identity.cpp TransitTunnel.cpp \
-#  Transports.cpp Tunnel.cpp TunnelEndpoint.cpp TunnelPool.cpp TunnelGateway.cpp \
-#  Destination.cpp Base.cpp I2PEndian.cpp FS.cpp Config.cpp Family.cpp \
-#  Config.cpp HTTP.cpp Timestamp.cpp util.cpp api.cpp Gost.cpp
-
 LIB_SRC = $(wildcard $(LIB_SRC_DIR)/*.cpp)
-
-#LIB_CLIENT_SRC = \
-#	AddressBook.cpp BOB.cpp ClientContext.cpp I2PTunnel.cpp I2PService.cpp MatchedDestination.cpp \
-#	SAM.cpp SOCKS.cpp HTTPProxy.cpp I2CP.cpp
-
 LIB_CLIENT_SRC = $(wildcard $(LIB_CLIENT_SRC_DIR)/*.cpp)
-
-# also: Daemon{Linux,Win32}.cpp will be added later
-#DAEMON_SRC = \
-#	HTTPServer.cpp I2PControl.cpp UPnP.cpp Daemon.cpp i2pd.cpp
-
 LANG_SRC = $(wildcard $(LANG_SRC_DIR)/*.cpp)
+WEBCONSOLE_SRC = $(wildcard $(WEBCONSOLE_SRC_DIR)/*.cpp)
 
 WRAP_LIB_SRC = $(wildcard $(WRAP_SRC_DIR)/*.cpp)
-
-DAEMON_SRC = $(wildcard $(DAEMON_SRC_DIR)/*.cpp)
+DAEMON_SRC = $(DAEMON_SRC_DIR)/Daemon.cpp $(DAEMON_SRC_DIR)/I2PControl.cpp $(DAEMON_SRC_DIR)/i2pd.cpp $(DAEMON_SRC_DIR)/UPnP.cpp

i18n/French.cpp

@@ -0,0 +1,102 @@
+/*
+* Copyright (c) 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 <map>
+#include <vector>
+#include <string>
+#include <memory>
+#include "I18N.h"
+
+// French localization file
+
+namespace i2p
+{
+namespace i18n
+{
+namespace french // language namespace
+{
+	// language name in lowercase
+	static std::string language = "french";
+
+	// See for language plural forms here:
+	// https://localization-guide.readthedocs.io/en/latest/l10n/pluralforms.html
+	static int plural (int n) {
+		return n != 1 ? 1 : 0;
+	}
+
+	static std::map<std::string, std::string> strings
+	{
+		{"KiB", "Kio"},
+		{"MiB", "Mio"},
+		{"GiB", "Gio"},
+		{"building", "En construction"},
+		{"failed", "echoué"},
+		{"expiring", "expiré"},
+		{"established", "établi"},
+		{"unknown", "inconnu"},
+		{"exploratory", "exploratoire"},
+		{"<b>i2pd</b> webconsole", "Console web <b>i2pd</b>"},
+		{"Main page", "Page principale"},
+		{"Router commands", "Commandes du routeur"},
+		{"Local Destinations", "Destinations locales"},
+		{"Tunnels", "Tunnels"},
+		{"Transit Tunnels", "Tunnels transitoires"},
+		{"I2P tunnels", "Tunnels I2P"},
+		{"SAM sessions", "Sessions SAM"},
+		{"ERROR", "ERREUR"},
+		{"OK", "OK"},
+		{"Firewalled", "Derrière un pare-feu"},
+		{"Error", "Erreur"},
+		{"Offline", "Hors ligne"},
+		{"Uptime", "Temps de fonctionnement"},
+		{"Network status", "État du réseau"},
+		{"Network status v6", "État du réseau v6"},
+		{"Stopping in", "Arrêt dans"},
+		{"Family", "Famille"},
+		{"Tunnel creation success rate", "Taux de succès de création de tunnels"},
+		{"Received", "Reçu"},
+		{"KiB/s", "kio/s"},
+		{"Sent", "Envoyé"},
+		{"Transit", "Transit"},
+		{"Hidden content. Press on text to see.", "Contenu caché. Cliquez sur le texte pour regarder."},
+		{"Router Ident", "Identifiant du routeur"},
+		{"Router Family", "Famille du routeur"},
+		{"Version", "Version"},
+		{"Our external address", "Notre adresse externe"},
+		{"Client Tunnels", "Tunnels clients"},
+		{"Services", "Services"},
+		{"Enabled", "Activé"},
+		{"Disabled", "Désactivé"},
+		{"Encrypted B33 address", "Adresse B33 chiffrée"},
+		{"Domain", "Domaine"},
+		{"<b>Note:</b> result string can be used only for registering 2LD domains (example.i2p). For registering subdomains please use i2pd-tools.", "<b>Note:</b> La chaîne résultante peut seulement être utilisée pour enregistrer les domaines 2LD (exemple.i2p). Pour enregistrer des sous-domaines, veuillez utiliser i2pd-tools."},
+		{"Address", "Adresse"},
+		{"ms", "ms"},
+		{"Outbound tunnels", "Tunnels sortants"},
+		{"Destination", "Destination"},
+		{"Local Destination", "Destination locale"},
+		{"", ""},
+	};
+
+	static std::map<std::string, std::vector<std::string>> plurals
+	{
+		{"days", {"jour", "jours"}},
+		{"hours", {"heure", "heures"}},
+		{"minutes", {"minute", "minutes"}},
+		{"seconds", {"seconde", "secondes"}},
+		{"", {"", ""}},
+	};
+
+	std::shared_ptr<const i2p::i18n::Locale> GetLocale()
+	{
+		return std::make_shared<i2p::i18n::Locale>(language, strings, plurals, [] (int n)->int { return plural(n); });
+	}
+
+} // language
+} // i18n
+} // i2p

i18n/I18N_langs.h

@@ -74,6 +74,7 @@ namespace i18n
 	namespace afrikaans { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
 	namespace armenian  { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
 	namespace english   { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
+	namespace french    { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
 	namespace german    { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
 	namespace russian   { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
 	namespace turkmen   { std::shared_ptr<const i2p::i18n::Locale> GetLocale (); }
@@ -88,6 +89,7 @@ namespace i18n
 		{ "afrikaans", {"Afrikaans", "af", i2p::i18n::afrikaans::GetLocale} },
 		{ "armenian", {"հայերէն", "hy", i2p::i18n::armenian::GetLocale} },
 		{ "english", {"English", "en", i2p::i18n::english::GetLocale} },
+		{ "french", {"Français", "fr", i2p::i18n::french::GetLocale} },
 		{ "german", {"Deutsch", "de", i2p::i18n::german::GetLocale} },
 		{ "russian", {"русский язык", "ru", i2p::i18n::russian::GetLocale} },
 		{ "turkmen", {"türkmen dili", "tk", i2p::i18n::turkmen::GetLocale} },

libi2pd/Base.h

@@ -24,8 +24,8 @@ namespace data {
 	size_t ByteStreamToBase32 (const uint8_t * InBuf, size_t len, char * outBuf, size_t outLen);
 
 	/**
-	 Compute the size for a buffer to contain encoded base64 given that the size of the input is input_size bytes
-	*/
+	 * Compute the size for a buffer to contain encoded base64 given that the size of the input is input_size bytes
+	 */
 	size_t Base64EncodingBufferSize(const size_t input_size);
 
 	std::string ToBase64Standard (const std::string& in); // using standard table, for Proxy-Authorization

libi2pd/Blinding.cpp

@@ -99,7 +99,7 @@ namespace data
 	static size_t BlindECDSA (i2p::data::SigningKeyType sigType, const uint8_t * key, const uint8_t * seed, Fn blind, Args&&...args)
 	// blind is BlindEncodedPublicKeyECDSA or BlindEncodedPrivateKeyECDSA
 	{
-		size_t publicKeyLength  = 0;
+		size_t publicKeyLength = 0;
 		EC_GROUP * group = nullptr;
 		switch (sigType)
 		{
@@ -147,8 +147,8 @@ namespace data
 		memcpy (m_PublicKey.data (), identity->GetSigningPublicKeyBuffer (), len);
 		m_SigType = identity->GetSigningKeyType ();
 		if (m_SigType == i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519)
-			m_BlindedSigType = i2p::data::SIGNING_KEY_TYPE_REDDSA_SHA512_ED25519; // 7 -> 11	
-		else		
+			m_BlindedSigType = i2p::data::SIGNING_KEY_TYPE_REDDSA_SHA512_ED25519; // 7 -> 11
+		else
 			m_BlindedSigType = m_SigType;
 	}
 

libi2pd/Blinding.h

@@ -28,8 +28,8 @@ namespace data
 
 			const uint8_t * GetPublicKey () const { return m_PublicKey.data (); };
 			size_t GetPublicKeyLen () const { return m_PublicKey.size (); };
-			SigningKeyType GetSigType () const  { return m_SigType; };
-			SigningKeyType GetBlindedSigType () const  { return m_BlindedSigType; };
+			SigningKeyType GetSigType () const { return m_SigType; };
+			SigningKeyType GetBlindedSigType () const { return m_BlindedSigType; };
 			bool IsValid () const { return GetSigType (); }; // signature type 0 means invalid
 
 			void GetSubcredential (const uint8_t * blinded, size_t len, uint8_t * subcredential) const; // 32 bytes

libi2pd/Config.cpp

@@ -78,9 +78,9 @@ namespace config {
 			("limits.coresize", value<uint32_t>()->default_value(0),          "Maximum size of corefile in Kb (0 - use system limit)")
 			("limits.openfiles", value<uint16_t>()->default_value(0),         "Maximum number of open files (0 - use system default)")
 			("limits.transittunnels", value<uint16_t>()->default_value(2500), "Maximum active transit sessions (default:2500)")
-			("limits.ntcpsoft", value<uint16_t>()->default_value(0),          "Threshold to start probabilistic backoff with ntcp sessions (default: use system limit)")
-			("limits.ntcphard", value<uint16_t>()->default_value(0),          "Maximum number of ntcp sessions (default: use system limit)")
-			("limits.ntcpthreads", value<uint16_t>()->default_value(1),       "Maximum number of threads used by NTCP DH worker (default: 1)")
+			("limits.ntcpsoft", value<uint16_t>()->default_value(0),          "Ignored")
+			("limits.ntcphard", value<uint16_t>()->default_value(0),          "Ignored")
+			("limits.ntcpthreads", value<uint16_t>()->default_value(1),       "Ignored")
 		;
 
 		options_description httpserver("HTTP Server options");
@@ -230,6 +230,7 @@ namespace config {
 
 		options_description addressbook("AddressBook options");
 		addressbook.add_options()
+			("addressbook.enabled", value<bool>()->default_value(true), "Enable address book lookups and subscritions (default: enabled)")
 			("addressbook.defaulturl", value<std::string>()->default_value(
 				"http://shx5vqsw7usdaunyzr2qmes2fq37oumybpudrd4jjj4e4vk4uusa.b32.i2p/hosts.txt"
 			),                                                                     "AddressBook subscription URL for initial setup")
@@ -272,12 +273,12 @@ namespace config {
 		;
 
 		options_description ssu2("SSU2 Options");
-		ntcp2.add_options()
+		ssu2.add_options()
 			("ssu2.enabled", value<bool>()->default_value(false),         "Enable SSU2 (default: disabled)")
 			("ssu2.published", value<bool>()->default_value(false),        "Publish SSU2 (default: disabled)")
 			("ssu2.port", value<uint16_t>()->default_value(0),            "Port to listen for incoming SSU2 packets (default: auto)")
 		;
-		
+
 		options_description nettime("Time sync options");
 		nettime.add_options()
 			("nettime.enabled", value<bool>()->default_value(false),       "Disable time sync (default: disabled)")

libi2pd/Config.h

@@ -29,16 +29,16 @@ namespace config {
 	extern boost::program_options::variables_map m_Options;
 
 	/**
-	 * @brief  Initialize list of acceptable parameters
+	 * @brief Initialize list of acceptable parameters
 	 *
 	 * Should be called before any Parse* functions.
 	 */
 	void Init();
 
 	/**
-	 * @brief  Parse cmdline parameters, and show help if requested
-	 * @param  argc  Cmdline arguments count, should be passed from main().
-	 * @param  argv  Cmdline parameters array, should be passed from main()
+	 * @brief Parse cmdline parameters, and show help if requested
+	 * @param argc Cmdline arguments count, should be passed from main().
+	 * @param argv Cmdline parameters array, should be passed from main()
 	 *
 	 * If --help is given in parameters, shows its list with description
 	 * and terminates the program with exitcode 0.
@@ -52,8 +52,8 @@ namespace config {
 	void ParseCmdline(int argc, char* argv[], bool ignoreUnknown = false);
 
 	/**
-	 * @brief  Load and parse given config file
-	 * @param  path  Path to config file
+	 * @brief Load and parse given config file
+	 * @param path Path to config file
 	 *
 	 * If error occurred when opening file path is points to,
 	 * we show the error message and terminate program.
@@ -67,14 +67,14 @@ namespace config {
 	void ParseConfig(const std::string& path);
 
 	/**
-	 * @brief  Used to combine options from cmdline, config and default values
+	 * @brief Used to combine options from cmdline, config and default values
 	 */
 	void Finalize();
 
 	/**
-	 * @brief  Accessor to parameters by name
-	 * @param  name  Name of the requested parameter
-	 * @param  value Variable where to store option
+	 * @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
 	 *
 	 * Example: uint16_t port; GetOption("sam.port", port);
@@ -98,9 +98,9 @@ namespace config {
 	bool GetOptionAsAny(const std::string& name, boost::any& value);
 
 	/**
-	 * @brief  Set value of given parameter
-	 * @param  name  Name of settable parameter
-	 * @param  value New parameter value
+	 * @brief Set value of given parameter
+	 * @param name Name of settable parameter
+	 * @param value New parameter value
 	 * @return true if value set up successful, false otherwise
 	 *
 	 * Example: uint16_t port = 2827; SetOption("bob.port", port);
@@ -116,8 +116,8 @@ namespace config {
 	}
 
 	/**
-	 * @brief  Check is value explicitly given or default
-	 * @param  name  Name of checked parameter
+	 * @brief Check is value explicitly given or default
+	 * @param name Name of checked parameter
 	 * @return true if value set to default, false otherwise
 	 */
 	bool IsDefault(const char *name);

libi2pd/Crypto.cpp

@@ -1313,8 +1313,8 @@ namespace crypto
 		for (const auto& it: bufs)
 			SHA256_Update (&ctx, it.first, it.second);
 		SHA256_Final (m_H, &ctx);
-	}	
-	
+	}
+
 	void NoiseSymmetricState::MixKey (const uint8_t * sharedSecret)
 	{
 		HKDF (m_CK, sharedSecret, 32, "", m_CK);
@@ -1330,7 +1330,7 @@ namespace crypto
 		SHA256_Init (&ctx);
 		SHA256_Update (&ctx, hh, 32);
 		SHA256_Update (&ctx, pub, 32);
-		SHA256_Final (state.m_H, &ctx);  // h = MixHash(pub) = SHA256(hh || pub)
+		SHA256_Final (state.m_H, &ctx); // h = MixHash(pub) = SHA256(hh || pub)
 	}
 
 	void InitNoiseNState (NoiseSymmetricState& state, const uint8_t * pub)
@@ -1368,12 +1368,12 @@ namespace crypto
 		}; // SHA256 ("Noise_XKchaobfse+hs1+hs2+hs3_25519_ChaChaPoly_SHA256")
 		static const uint8_t hh[32] =
 		{
-			0xdc, 0x85, 0xe6, 0xaf, 0x7b, 0x02, 0x65, 0x0c, 0xf1, 0xf9, 0x0d, 0x71, 0xfb, 0xc6, 0xd4, 0x53, 
+			0xdc, 0x85, 0xe6, 0xaf, 0x7b, 0x02, 0x65, 0x0c, 0xf1, 0xf9, 0x0d, 0x71, 0xfb, 0xc6, 0xd4, 0x53,
 			0xa7, 0xcf, 0x6d, 0xbf, 0xbd, 0x52, 0x5e, 0xa5, 0xb5, 0x79, 0x1c, 0x47, 0xb3, 0x5e, 0xbc, 0x33
 		}; // SHA256 (protocolNameHash)
 		InitNoiseState (state, protocolNameHash, hh, pub);
 	}
-	
+
 	void InitNoiseIKState (NoiseSymmetricState& state, const uint8_t * pub)
 	{
 		static const uint8_t protocolNameHash[32] =

libi2pd/Crypto.h

@@ -29,23 +29,25 @@
 #include "CPU.h"
 
 // recognize openssl version and features
-#if ((OPENSSL_VERSION_NUMBER < 0x010100000) || defined(LIBRESSL_VERSION_NUMBER)) // 1.0.2 and below or LibreSSL
-#   define LEGACY_OPENSSL 1
-#   define X509_getm_notBefore X509_get_notBefore
-#   define X509_getm_notAfter X509_get_notAfter
+#if (defined(LIBRESSL_VERSION_NUMBER) && (LIBRESSL_VERSION_NUMBER >= 0x3050200fL)) // LibreSSL 3.5.2 and above
+#	define LEGACY_OPENSSL 0
+#elif ((OPENSSL_VERSION_NUMBER < 0x010100000) || defined(LIBRESSL_VERSION_NUMBER)) // 1.0.2 and below or LibreSSL
+#	define LEGACY_OPENSSL 1
+#	define X509_getm_notBefore X509_get_notBefore
+#	define X509_getm_notAfter X509_get_notAfter
 #else
-#   define LEGACY_OPENSSL 0
-#   if (OPENSSL_VERSION_NUMBER >= 0x010101000) // 1.1.1
-#       define OPENSSL_HKDF 1
-#       define OPENSSL_EDDSA 1
-#       define OPENSSL_X25519 1
-#		if (OPENSSL_VERSION_NUMBER < 0x030000000) // 3.0.0, regression in SipHash
-#       	define OPENSSL_SIPHASH 1
+#	define LEGACY_OPENSSL 0
+#	if (OPENSSL_VERSION_NUMBER >= 0x010101000) // 1.1.1
+#		define OPENSSL_HKDF 1
+#		define OPENSSL_EDDSA 1
+#		define OPENSSL_X25519 1
+#		if (OPENSSL_VERSION_NUMBER != 0x030000000) // 3.0.0, regression in SipHash
+#			define OPENSSL_SIPHASH 1
 #		endif
-#   endif
-#   if !defined OPENSSL_NO_CHACHA && !defined OPENSSL_NO_POLY1305 // some builds might not include them
-#       define OPENSSL_AEAD_CHACHA20_POLY1305 1
-#   endif
+#	endif
+#	if !defined OPENSSL_NO_CHACHA && !defined OPENSSL_NO_POLY1305 // some builds might not include them
+#		define OPENSSL_AEAD_CHACHA20_POLY1305 1
+#	endif
 #endif
 
 namespace i2p
@@ -383,7 +385,7 @@ inline int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
 		if (dh->p) BN_free (dh->p);
 		if (dh->q) BN_free (dh->q);
 		if (dh->g) BN_free (dh->g);
-		dh->p = p; dh->q = q; dh->g = g;  return 1;
+		dh->p = p; dh->q = q; dh->g = g; return 1;
 	}
 inline int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key)
 	{

libi2pd/Datagram.cpp

@@ -324,7 +324,7 @@ namespace datagram
 
 		auto path = m_RoutingSession->GetSharedRoutingPath();
 		if (path && m_RoutingSession->IsRatchets () &&
-		    m_LastUse > m_RoutingSession->GetLastActivityTimestamp ()*1000 + DATAGRAM_SESSION_PATH_TIMEOUT)
+			m_LastUse > m_RoutingSession->GetLastActivityTimestamp ()*1000 + DATAGRAM_SESSION_PATH_TIMEOUT)
 		{
 			m_RoutingSession->SetSharedRoutingPath (nullptr);
 			path = nullptr;

libi2pd/Destination.cpp

@@ -13,7 +13,6 @@
 #include <vector>
 #include <boost/algorithm/string.hpp>
 #include "Crypto.h"
-#include "Config.h"
 #include "Log.h"
 #include "FS.h"
 #include "Timestamp.h"
@@ -36,7 +35,7 @@ namespace client
 		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 outVar  = DEFAULT_OUTBOUND_TUNNELS_LENGTH_VARIANCE;
 		int numTags = DEFAULT_TAGS_TO_SEND;
 		std::shared_ptr<std::vector<i2p::data::IdentHash> > explicitPeers;
 		try
@@ -94,9 +93,7 @@ namespace client
 				if (it != params->end ())
 				{
 					// oveeride isPublic
-					bool dontpublish = false;
-					i2p::config::GetOption (it->second, dontpublish);
-					m_IsPublic = !dontpublish;
+					m_IsPublic = (it->second != "true");
 				}
 				it = params->find (I2CP_PARAM_LEASESET_TYPE);
 				if (it != params->end ())
@@ -353,8 +350,8 @@ namespace client
 			{
 				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));
@@ -420,7 +417,7 @@ namespace client
 				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
+					it->second->GetStoreType () == buf[DATABASE_STORE_TYPE_OFFSET]) // update only if same type
 				{
 					leaseSet = it->second;
 					if (leaseSet->IsNewer (buf + offset, len - offset))
@@ -590,7 +587,7 @@ namespace client
 			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)
@@ -602,22 +599,22 @@ namespace client
 			{
 				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);
@@ -954,7 +951,7 @@ namespace client
 		for (auto& it: encryptionKeyTypes)
 		{
 			auto encryptionKey = new EncryptionKey (it);
-			if (isPublic)
+			if (IsPublic ())
 				PersistTemporaryKeys (encryptionKey, isSingleKey);
 			else
 				encryptionKey->GenerateKeys ();
@@ -969,7 +966,7 @@ namespace client
 				m_StandardEncryptionKey.reset (encryptionKey);
 		}
 
-		if (isPublic)
+		if (IsPublic ())
 			LogPrint (eLogInfo, "Destination: Local address ", GetIdentHash().ToBase32 (), " created");
 
 		try
@@ -982,7 +979,7 @@ namespace client
 					m_StreamingAckDelay = std::stoi(it->second);
 				it = params->find (I2CP_PARAM_STREAMING_ANSWER_PINGS);
 				if (it != params->end ())
-					i2p::config::GetOption (it->second, m_IsStreamingAnswerPings);
+					m_IsStreamingAnswerPings = (it->second == "true");
 
 				if (GetLeaseSetType () == i2p::data::NETDB_STORE_TYPE_ENCRYPTED_LEASESET2)
 				{

libi2pd/Destination.h

@@ -319,4 +319,5 @@ namespace client
 
 }
 }
+
 #endif

libi2pd/ECIESX25519AEADRatchetSession.h

@@ -212,7 +212,7 @@ namespace garlic
 			uint8_t m_NSREncodedKey[32], m_NSRH[32], m_NSRKey[32]; // new session reply, for incoming only
 			std::shared_ptr<i2p::crypto::X25519Keys> m_EphemeralKeys;
 			SessionState m_State = eSessionStateNew;
-			uint64_t m_SessionCreatedTimestamp = 0,  m_LastActivityTimestamp = 0, // incoming (in seconds)
+			uint64_t m_SessionCreatedTimestamp = 0, m_LastActivityTimestamp = 0, // incoming (in seconds)
 				m_LastSentTimestamp = 0; // in milliseconds
 			std::shared_ptr<RatchetTagSet> m_SendTagset, m_NSRSendTagset;
 			std::unique_ptr<i2p::data::IdentHash> m_Destination;// TODO: might not need it
@@ -229,7 +229,7 @@ namespace garlic
 			{
 				return m_Destination ? *m_Destination : i2p::data::IdentHash ();
 			}
-	 };
+	};
 
 	// single session for all incoming messages
 	class RouterIncomingRatchetSession: public ECIESX25519AEADRatchetSession

libi2pd/Ed25519.cpp

@@ -33,7 +33,7 @@ namespace crypto
 		BN_add (l, l, tmp);
 		BN_sub_word (two_252_2, 2); // 2^252 - 2
 
-		 // -121665*inv(121666)
+		// -121665*inv(121666)
 		d = BN_new ();
 		BN_set_word (tmp, 121666);
 		BN_mod_inverse (tmp, tmp, q, ctx);
@@ -61,7 +61,7 @@ namespace crypto
 		BN_mod (By, By, q, ctx); // % q
 
 		// precalculate Bi256 table
-		Bi256Carry = { Bx, By };  // B
+		Bi256Carry = { Bx, By }; // B
 		for (int i = 0; i < 32; i++)
 		{
 			Bi256[i][0] = Bi256Carry; // first point
@@ -215,7 +215,7 @@ namespace crypto
 		if (!t1) { t1 = BN_CTX_get (ctx); BN_mul (t1, p1.x, p1.y, ctx); }
 		if (!t2) { t2 = BN_CTX_get (ctx); BN_mul (t2, p2.x, p2.y, ctx); }
 		BN_mul (t3, t1, t2, ctx);
-		BN_mul (t3, t3, d, ctx);  // C = d*t1*t2
+		BN_mul (t3, t3, d, ctx); // C = d*t1*t2
 
 		if (p1.z)
 		{
@@ -264,9 +264,9 @@ namespace crypto
 		else
 		{
 			BN_mul (t2, p.x, p.y, ctx); // t = x*y
-			BN_sqr (t2, t2, ctx);  // t2 = t^2
+			BN_sqr (t2, t2, ctx); // t2 = t^2
 		}
-		BN_mul (t2, t2, d, ctx);  // t2 = C = d*t^2
+		BN_mul (t2, t2, d, ctx); // t2 = C = d*t^2
 		if (p.z)
 			BN_sqr (z2, p.z, ctx); // z2 = D = z^2
 		else
@@ -349,7 +349,7 @@ namespace crypto
 			BN_mod_inverse (y, p.z, q, ctx);
 			BN_mod_mul (x, p.x, y, q, ctx); // x = x/z
 			BN_mod_mul (y, p.y, y, q, ctx); // y = y/z
-			return  EDDSAPoint{x, y};
+			return EDDSAPoint{x, y};
 		}
 		else
 			return EDDSAPoint{BN_dup (p.x), BN_dup (p.y)};
@@ -506,13 +506,13 @@ namespace crypto
 			std::swap (z2, z3);
 		}
 		BN_mod_inverse (z2, z2, q, ctx);
-		BIGNUM * res =  BN_new (); // not from ctx
+		BIGNUM * res = BN_new (); // not from ctx
 		BN_mod_mul(res, x2, z2, q, ctx);
 		BN_CTX_end (ctx);
 		return res;
 	}
 
-	void Ed25519::ScalarMul (const uint8_t * p, const  uint8_t * e, uint8_t * buf, BN_CTX * ctx) const
+	void Ed25519::ScalarMul (const uint8_t * p, const uint8_t * e, uint8_t * buf, BN_CTX * ctx) const
 	{
 		BIGNUM * p1 = DecodeBN<32> (p);
 		uint8_t k[32];
@@ -524,7 +524,7 @@ namespace crypto
 		BN_free (p1); BN_free (n); BN_free (q1);
 	}
 
-	void Ed25519::ScalarMulB (const  uint8_t * e, uint8_t * buf, BN_CTX * ctx) const
+	void Ed25519::ScalarMulB (const uint8_t * e, uint8_t * buf, BN_CTX * ctx) const
 	{
 		BIGNUM *p1 = BN_new (); BN_set_word (p1, 9);
 		uint8_t k[32];

libi2pd/Ed25519.h

@@ -85,8 +85,8 @@ namespace crypto
 			EDDSAPoint DecodePublicKey (const uint8_t * buf, BN_CTX * ctx) const;
 			void EncodePublicKey (const EDDSAPoint& publicKey, uint8_t * buf, BN_CTX * ctx) const;
 #if !OPENSSL_X25519
-			void ScalarMul (const uint8_t * p, const  uint8_t * e, uint8_t * buf, BN_CTX * ctx) const; // p is point, e is number for x25519
-			void ScalarMulB (const  uint8_t * e, uint8_t * buf, BN_CTX * ctx) const;
+			void ScalarMul (const uint8_t * p, const uint8_t * e, uint8_t * buf, BN_CTX * ctx) const; // p is point, e is number for x25519
+			void ScalarMulB (const uint8_t * e, uint8_t * buf, BN_CTX * ctx) const;
 #endif
 			void BlindPublicKey (const uint8_t * pub, const uint8_t * seed, uint8_t * blinded); // for encrypted LeaseSet2, pub - 32, seed - 64, blinded - 32
 			void BlindPrivateKey (const uint8_t * priv, const uint8_t * seed, uint8_t * blindedPriv, uint8_t * blindedPub); // for encrypted LeaseSet2, pub - 32, seed - 64, blinded - 32

libi2pd/Elligator.cpp

@@ -189,7 +189,7 @@ namespace crypto
 		// assume a < p, so don't check for a % p = 0, but a = 0 only
 		if (BN_is_zero(a)) return 0;
 		BIGNUM * r = BN_CTX_get (ctx);
-		BN_mod_exp (r, a, p12, p, ctx); // 	r = a^((p-1)/2) mod p
+		BN_mod_exp (r, a, p12, p, ctx); // r = a^((p-1)/2) mod p
 		if (BN_is_word(r, 1))
 			return 1;
 		else if (BN_is_zero(r))

libi2pd/FS.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -60,10 +60,38 @@ namespace fs {
 	}
 
 	void DetectDataDir(const std::string & cmdline_param, bool isService) {
+		// with 'datadir' option
 		if (cmdline_param != "") {
 			dataDir = cmdline_param;
 			return;
 		}
+
+#if !defined(MAC_OSX) && !defined(ANDROID)
+		// with 'service' option
+		if (isService) {
+#ifdef _WIN32
+			wchar_t commonAppData[MAX_PATH];
+			if(SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, commonAppData) != S_OK)
+			{
+#ifdef WIN32_APP
+				MessageBox(NULL, TEXT("Unable to get common AppData path!"), TEXT("I2Pd: error"), MB_ICONERROR | MB_OK);
+#else
+				fprintf(stderr, "Error: Unable to get common AppData path!");
+#endif
+				exit(1);
+			}
+			else
+			{
+				dataDir = boost::filesystem::wpath(commonAppData).string() + "\\" + appName;
+			}
+#else
+			dataDir = "/var/lib/" + appName;
+#endif
+			return;
+		}
+#endif
+
+		// detect directory as usual
 #ifdef _WIN32
 		wchar_t localAppData[MAX_PATH];
 
@@ -117,12 +145,10 @@ namespace fs {
 			dataDir = std::string (ext) + "/" + appName;
 			return;
 		}
-#endif
-		// otherwise use /data/files
+#endif // ANDROID
+		// use /home/user/.i2pd or /tmp/i2pd
 		char *home = getenv("HOME");
-		if (isService) {
-			dataDir = "/var/lib/" + appName;
-		} else if (home != NULL && strlen(home) > 0) {
+		if (home != NULL && strlen(home) > 0) {
 			dataDir = std::string(home) + "/." + appName;
 		} else {
 			dataDir = "/tmp/" + appName;

libi2pd/FS.h

@@ -83,8 +83,8 @@ namespace fs {
 
 	/**
 	 * @brief Set datadir either from cmdline option or using autodetection
-	 * @param cmdline_param  Value of cmdline parameter --datadir=<something>
-	 * @param isService      Value of cmdline parameter --service
+	 * @param cmdline_param Value of cmdline parameter --datadir=<something>
+	 * @param isService Value of cmdline parameter --service
 	 *
 	 * Examples of autodetected paths:
 	 *
@@ -93,11 +93,11 @@ namespace fs {
 	 *   Mac: /Library/Application Support/i2pd/ or ~/Library/Application Support/i2pd/
 	 *   Unix: /var/lib/i2pd/ (system=1) >> ~/.i2pd/ or /tmp/i2pd/
 	 */
-	 void DetectDataDir(const std::string & cmdline_datadir, bool isService = false);
+	void DetectDataDir(const std::string & cmdline_datadir, bool isService = false);
 
 	/**
 	 * @brief Set certsdir either from cmdline option or using autodetection
-	 * @param cmdline_param  Value of cmdline parameter --certsdir=<something>
+	 * @param cmdline_param Value of cmdline parameter --certsdir=<something>
 	 *
 	 * Examples of autodetected paths:
 	 *
@@ -106,7 +106,7 @@ namespace fs {
 	 *   Mac: /Library/Application Support/i2pd/ or ~/Library/Application Support/i2pd/certificates
 	 *   Unix: /var/lib/i2pd/certificates (system=1) >> ~/.i2pd/ or /tmp/i2pd/certificates
 	 */
-	 void SetCertsDir(const std::string & cmdline_certsdir);
+	void SetCertsDir(const std::string & cmdline_certsdir);
 
 	/**
 	 * @brief Create subdirectories inside datadir
@@ -115,7 +115,7 @@ namespace fs {
 
 	/**
 	 * @brief Get list of files in directory
-	 * @param path  Path to directory
+	 * @param path Path to directory
 	 * @param files Vector to store found files
 	 * @return true on success and false if directory not exists
 	 */

libi2pd/Family.cpp

@@ -148,8 +148,8 @@ namespace data
 		if (it != m_SigningKeys.end ())
 			return it->second.second;
 		return 0;
-	}	
-	
+	}
+
 	std::string CreateFamilySignature (const std::string& family, const IdentHash& ident)
 	{
 		auto filename = i2p::fs::DataDirPath("family", (family + ".key"));

libi2pd/Garlic.cpp

@@ -293,14 +293,14 @@ namespace garlic
 		size_t size = 0;
 		if (isDestination)
 		{
-			buf[size] = eGarlicDeliveryTypeDestination << 5;//  delivery instructions flag destination
+			buf[size] = eGarlicDeliveryTypeDestination << 5;// delivery instructions flag destination
 			size++;
 			memcpy (buf + size, m_Destination->GetIdentHash (), 32);
 			size += 32;
 		}
 		else
 		{
-			buf[size] = 0;//  delivery instructions flag local
+			buf[size] = 0;// delivery instructions flag local
 			size++;
 		}
 
@@ -487,8 +487,8 @@ namespace garlic
 	void GarlicDestination::SubmitECIESx25519Key (const uint8_t * key, uint64_t tag)
 	{
 		AddECIESx25519Key (key, tag);
-	}	
-		
+	}
+
 	void GarlicDestination::HandleGarlicMessage (std::shared_ptr<I2NPMessage> msg)
 	{
 		uint8_t * buf = msg->GetPayload ();
@@ -744,7 +744,7 @@ namespace garlic
 				LogPrint (eLogError, "Garlic: Message is too short");
 				break;
 			}
-			buf += GetI2NPMessageLength (buf, len - offset); //  I2NP
+			buf += GetI2NPMessageLength (buf, len - offset); // I2NP
 			buf += 4; // CloveID
 			buf += 8; // Date
 			buf += 3; // Certificate
@@ -1024,7 +1024,7 @@ namespace garlic
 		uint32_t ts = i2p::util::GetSecondsSinceEpoch ();
 		for (auto it: files)
 			if (ts >= i2p::fs::GetLastUpdateTime (it) + INCOMING_TAGS_EXPIRATION_TIMEOUT)
-				 i2p::fs::Remove (it);
+				i2p::fs::Remove (it);
 	}
 
 	void GarlicDestination::HandleECIESx25519GarlicClove (const uint8_t * buf, size_t len)

libi2pd/Gost.cpp

@@ -96,7 +96,7 @@ namespace crypto
 		EC_POINT * C = EC_POINT_new (m_Group);
 		EC_POINT_mul (m_Group, C, z1, pub, z2, ctx); // z1*P + z2*pub
 		BIGNUM * x = BN_CTX_get (ctx);
-		GetXY  (C, x, nullptr); // Cx
+		GetXY (C, x, nullptr); // Cx
 		BN_mod (x, x, q, ctx); // Cx % q
 		bool ret = !BN_cmp (x, r); // Cx = r ?
 		EC_POINT_free (C);
@@ -111,8 +111,8 @@ namespace crypto
 		BN_CTX * ctx = BN_CTX_new ();
 		BN_CTX_start (ctx);
 		EC_POINT * C = EC_POINT_new (m_Group); // C = k*P = (rx, ry)
-		EC_POINT * Q  = nullptr;
-		if (EC_POINT_set_compressed_coordinates_GFp (m_Group, C, r, isNegativeY ? 1 : 0,  ctx))
+		EC_POINT * Q = nullptr;
+		if (EC_POINT_set_compressed_coordinates_GFp (m_Group, C, r, isNegativeY ? 1 : 0, ctx))
 		{
 			EC_POINT * S = EC_POINT_new (m_Group); // S = s*P
 			EC_POINT_mul (m_Group, S, s, nullptr, nullptr, ctx);

libi2pd/HTTP.cpp

@@ -279,7 +279,7 @@ namespace http
 				method  = tokens[0];
 				uri     = tokens[1];
 				version = tokens[2];
-				expect = HEADER_LINE;
+				expect  = HEADER_LINE;
 			}
 			else
 			{
@@ -363,7 +363,7 @@ namespace http
 			return false; /* no header */
 		if (it->second.find("gzip") != std::string::npos)
 			return true; /* gotcha! */
-		if (includingI2PGzip &&  it->second.find("x-i2p-gzip") != std::string::npos)
+		if (includingI2PGzip && it->second.find("x-i2p-gzip") != std::string::npos)
 			return true;
 		return false;
 	}
@@ -409,7 +409,7 @@ namespace http
 				/* all ok */
 				version = tokens[0];
 				status  = tokens[2];
-				expect = HEADER_LINE;
+				expect  = HEADER_LINE;
 			} else {
 				std::string line = str.substr(pos, eol - pos);
 				auto p = parse_header_line(line);
@@ -460,7 +460,7 @@ namespace http
 			case 304: ptr = "Not Modified"; break;
 			case 307: ptr = "Temporary Redirect"; break;
 			/* client error */
-			case 400: ptr = "Bad Request";  break;
+			case 400: ptr = "Bad Request"; break;
 			case 401: ptr = "Unauthorized"; break;
 			case 403: ptr = "Forbidden"; break;
 			case 404: ptr = "Not Found"; break;
@@ -471,7 +471,7 @@ namespace http
 			case 502: ptr = "Bad Gateway"; break;
 			case 503: ptr = "Not Implemented"; break;
 			case 504: ptr = "Gateway Timeout"; break;
-			default:  ptr = "Unknown Status";  break;
+			default:  ptr = "Unknown Status"; break;
 		}
 		return ptr;
 	}

libi2pd/HTTP.h

@@ -161,7 +161,7 @@ namespace http
 
 	/**
 	 * @brief Merge HTTP response content with Transfer-Encoding: chunked
-	 * @param in  Input stream
+	 * @param in Input stream
 	 * @param out Output stream
 	 * @return true on success, false otherwise
 	 */

libi2pd/I2NPProtocol.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2021, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -171,7 +171,7 @@ namespace i2p
 	std::shared_ptr<I2NPMessage> CreateLeaseSetDatabaseLookupMsg (const i2p::data::IdentHash& dest,
 		const std::set<i2p::data::IdentHash>& excludedFloodfills,
 		std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel, const uint8_t * replyKey,
-		    const uint8_t * replyTag, bool replyECIES)
+			const uint8_t * replyTag, bool replyECIES)
 	{
 		int cnt = excludedFloodfills.size ();
 		auto m = cnt > 7 ? NewI2NPMessage () : NewI2NPShortMessage ();
@@ -244,7 +244,7 @@ namespace i2p
 	}
 
 	std::shared_ptr<I2NPMessage> CreateDatabaseStoreMsg (std::shared_ptr<const i2p::data::RouterInfo> router,
-	    uint32_t replyToken, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel)
+		uint32_t replyToken, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel)
 	{
 		if (!router) // we send own RouterInfo
 			router = context.GetSharedRouterInfo ();
@@ -629,7 +629,7 @@ namespace i2p
 						// we send it to reply tunnel
 						transports.SendMessage (clearText + SHORT_REQUEST_RECORD_NEXT_IDENT_OFFSET,
 						CreateTunnelGatewayMsg (bufbe32toh (clearText + SHORT_REQUEST_RECORD_NEXT_TUNNEL_OFFSET),
-							i2p::garlic::WrapECIESX25519Message (replyMsg,  noiseState.m_CK + 32, tag)));
+							i2p::garlic::WrapECIESX25519Message (replyMsg, noiseState.m_CK + 32, tag)));
 					}
 					else
 					{
@@ -802,13 +802,8 @@ namespace i2p
 				break;
 				case eI2NPGarlic:
 				{
-					if (msg->from)
-					{
-						if (msg->from->GetTunnelPool ())
-							msg->from->GetTunnelPool ()->ProcessGarlicMessage (msg);
-						else
-							LogPrint (eLogInfo, "I2NP: Local destination for garlic doesn't exist anymore");
-					}
+					if (msg->from && msg->from->GetTunnelPool ())
+						msg->from->GetTunnelPool ()->ProcessGarlicMessage (msg);
 					else
 						i2p::context.ProcessGarlicMessage (msg);
 					break;

libi2pd/I2NPProtocol.h

@@ -150,7 +150,7 @@ namespace tunnel
 		std::shared_ptr<i2p::tunnel::InboundTunnel> from;
 
 		I2NPMessage (): buf (nullptr),len (I2NP_HEADER_SIZE + 2),
-			offset(2), maxLen (0), from (nullptr) {};  // reserve 2 bytes for NTCP header
+			offset(2), maxLen (0), from (nullptr) {}; // reserve 2 bytes for NTCP header
 
 		// header accessors
 		uint8_t * GetHeader () { return GetBuffer (); };
@@ -274,8 +274,8 @@ namespace tunnel
 		uint32_t replyTunnelID, bool exploratory = false, std::set<i2p::data::IdentHash> * excludedPeers = nullptr);
 	std::shared_ptr<I2NPMessage> CreateLeaseSetDatabaseLookupMsg (const i2p::data::IdentHash& dest,
 		const std::set<i2p::data::IdentHash>& excludedFloodfills,
-	    std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel,
-	    const uint8_t * replyKey, const uint8_t * replyTag, bool replyECIES = false);
+		std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel,
+		const uint8_t * replyKey, const uint8_t * replyTag, bool replyECIES = false);
 	std::shared_ptr<I2NPMessage> CreateDatabaseSearchReply (const i2p::data::IdentHash& ident, std::vector<i2p::data::IdentHash> routers);
 
 	std::shared_ptr<I2NPMessage> CreateDatabaseStoreMsg (std::shared_ptr<const i2p::data::RouterInfo> router = nullptr, uint32_t replyToken = 0, std::shared_ptr<const i2p::tunnel::InboundTunnel> replyTunnel = nullptr);

libi2pd/Identity.cpp

@@ -64,7 +64,7 @@ namespace data
 			{
 				case SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
 				{
-					size_t padding =  128 - i2p::crypto::ECDSAP256_KEY_LENGTH; // 64 = 128 - 64
+					size_t padding = 128 - i2p::crypto::ECDSAP256_KEY_LENGTH; // 64 = 128 - 64
 					RAND_bytes (m_StandardIdentity.signingKey, padding);
 					memcpy (m_StandardIdentity.signingKey + padding, signingKey, i2p::crypto::ECDSAP256_KEY_LENGTH);
 					break;
@@ -788,7 +788,7 @@ namespace data
 			keys.m_OfflineSignature.resize (pubKeyLen + m_Public->GetSignatureLen () + 6);
 			htobe32buf (keys.m_OfflineSignature.data (), expires); // expires
 			htobe16buf (keys.m_OfflineSignature.data () + 4, type); // type
-			GenerateSigningKeyPair (type, keys.m_SigningPrivateKey, keys.m_OfflineSignature.data () + 6); // public  key
+			GenerateSigningKeyPair (type, keys.m_SigningPrivateKey, keys.m_OfflineSignature.data () + 6); // public key
 			Sign (keys.m_OfflineSignature.data (), pubKeyLen + 6, keys.m_OfflineSignature.data () + 6 + pubKeyLen); // signature
 			// recreate signer
 			keys.m_Signer = nullptr;

libi2pd/Identity.h

@@ -120,7 +120,7 @@ namespace data
 			CryptoKeyType GetCryptoKeyType () const;
 			void DropVerifier () const; // to save memory
 
-  			bool operator == (const IdentityEx & other) const { return GetIdentHash() == other.GetIdentHash(); }
+			bool operator == (const IdentityEx & other) const { return GetIdentHash() == other.GetIdentHash(); }
 			void RecalculateIdentHash(uint8_t * buff=nullptr);
 
 			static i2p::crypto::Verifier * CreateVerifier (SigningKeyType keyType);
@@ -222,7 +222,7 @@ namespace data
 			RoutingDestination () {};
 			virtual ~RoutingDestination () {};
 
-			virtual std::shared_ptr<const IdentityEx> GetIdentity ()  const = 0;
+			virtual std::shared_ptr<const IdentityEx> GetIdentity () const = 0;
 			virtual void Encrypt (const uint8_t * data, uint8_t * encrypted) const = 0; // encrypt data for
 			virtual bool IsDestination () const = 0; // for garlic
 

libi2pd/LeaseSet.cpp

@@ -582,7 +582,7 @@ namespace data
 	// helper for ExtractClientAuthData
 	static inline bool GetAuthCookie (const uint8_t * authClients, int numClients, const uint8_t * okm, uint8_t * authCookie)
 	{
-		// try to find clientCookie_i  for clientID_i = okm[44:51]
+		// try to find clientCookie_i for clientID_i = okm[44:51]
 		for (int i = 0; i < numClients; i++)
 		{
 			if (!memcmp (okm + 44, authClients + i*40, 8)) // clientID_i
@@ -606,7 +606,7 @@ namespace data
 			{
 				const uint8_t * ephemeralPublicKey = buf + offset; offset += 32; // ephemeralPublicKey
 				uint16_t numClients = bufbe16toh (buf + offset); offset += 2; // clients
-				const uint8_t * authClients = buf + offset; offset +=  numClients*40; // authClients
+				const uint8_t * authClients = buf + offset; offset += numClients*40; // authClients
 				if (offset > len)
 				{
 					LogPrint (eLogError, "LeaseSet2: Too many clients ", numClients, " in DH auth data");
@@ -632,7 +632,7 @@ namespace data
 			{
 				const uint8_t * authSalt = buf + offset; offset += 32; // authSalt
 				uint16_t numClients = bufbe16toh (buf + offset); offset += 2; // clients
-				const uint8_t * authClients = buf + offset; offset +=  numClients*40; // authClients
+				const uint8_t * authClients = buf + offset; offset += numClients*40; // authClients
 				if (offset > len)
 				{
 					LogPrint (eLogError, "LeaseSet2: Too many clients ", numClients, " in PSK auth data");
@@ -737,7 +737,7 @@ namespace data
 			htobe64buf (m_Buffer + offset, ts);
 			offset += 8; // end date
 		}
-		//  we don't sign it yet. must be signed later on
+		// we don't sign it yet. must be signed later on
 	}
 
 	LocalLeaseSet::LocalLeaseSet (std::shared_ptr<const IdentityEx> identity, const uint8_t * buf, size_t len):
@@ -995,7 +995,7 @@ namespace data
 			ek.GenerateKeys (); // esk and epk
 			memcpy (authData, ek.GetPublicKey (), 32); authData += 32; // epk
 			htobe16buf (authData, authKeys->size ()); authData += 2; // num clients
-			uint8_t authInput[100]; //  sharedSecret || cpk_i || subcredential || publishedTimestamp
+			uint8_t authInput[100]; // sharedSecret || cpk_i || subcredential || publishedTimestamp
 			memcpy (authInput + 64, subcredential, 36);
 			for (auto& it: *authKeys)
 			{

libi2pd/LeaseSet.h

@@ -128,8 +128,8 @@ namespace data
 	};
 
 	/**
-			validate lease set buffer signature and extract expiration timestamp
-			@returns true if the leaseset is well formed and signature is valid
+	 * validate lease set buffer signature and extract expiration timestamp
+	 * @returns true if the leaseset is well formed and signature is valid
 	 */
 	bool LeaseSetBufferValidate(const uint8_t * ptr, size_t sz, uint64_t & expires);
 

libi2pd/Log.cpp

@@ -46,7 +46,7 @@ namespace log {
 
 #ifndef _WIN32
 	/**
-	 * @brief  Maps our log levels to syslog one
+	 * @brief Maps our log levels to syslog one
 	 * @return syslog priority LOG_*, as defined in syslog.h
 	 */
 	static inline int GetSyslogPrio (enum LogLevel l) {
@@ -113,11 +113,11 @@ namespace log {
 
 	std::string str_tolower(std::string s) {
 		std::transform(s.begin(), s.end(), s.begin(),
-					// static_cast<int(*)(int)>(std::tolower)         // wrong
-					// [](int c){ return std::tolower(c); }           // wrong
-					// [](char c){ return std::tolower(c); }          // wrong
-					   [](unsigned char c){ return std::tolower(c); } // correct
-					);
+			// static_cast<int(*)(int)>(std::tolower)      // wrong
+			// [](int c){ return std::tolower(c); }        // wrong
+			// [](char c){ return std::tolower(c); }       // wrong
+			[](unsigned char c){ return std::tolower(c); } // correct
+		);
 		return s;
 	}
 
@@ -170,7 +170,7 @@ namespace log {
 				break;
 			case eLogStdout:
 			default:
-				std::cout    << TimeAsString(msg->timestamp)
+				std::cout << TimeAsString(msg->timestamp)
 					<< "@" << short_tid
 					<< "/" << LogMsgColors[msg->level] << g_LogLevelStr[msg->level] << LogMsgColors[eNumLogLevels]
 					<< " - " << msg->text << std::endl;

libi2pd/Log.h

@@ -52,7 +52,7 @@ namespace log {
 	{
 		private:
 
-			enum LogType  m_Destination;
+			enum LogType m_Destination;
 			enum LogLevel m_MinLevel;
 			std::shared_ptr<std::ostream> m_LogStream;
 			std::string m_Logfile;
@@ -75,7 +75,7 @@ namespace log {
 
 			/**
 			 * @brief Makes formatted string from unix timestamp
-			 * @param ts  Second since epoch
+			 * @param ts Second since epoch
 			 *
 			 * This function internally caches the result for last provided value
 			 */
@@ -86,52 +86,52 @@ namespace log {
 			Log ();
 			~Log ();
 
-			LogType  GetLogType  () { return m_Destination; };
+			LogType GetLogType () { return m_Destination; };
 			LogLevel GetLogLevel () { return m_MinLevel; };
 
 			void Start ();
 			void Stop ();
 
 			/**
-			 * @brief  Sets minimal allowed level for log messages
-			 * @param  level  String with wanted minimal msg level
+			 * @brief Sets minimal allowed level for log messages
+			 * @param level String with wanted minimal msg level
 			 */
-			void     SetLogLevel (const std::string& level);
+			void SetLogLevel (const std::string& level);
 
 			/**
 			 * @brief Sets log destination to logfile
-			 * @param path  Path to logfile
+			 * @param path Path to logfile
 			 */
 			void SendTo (const std::string &path);
 
 			/**
 			 * @brief Sets log destination to given output stream
-			 * @param os  Output stream
+			 * @param os Output stream
 			 */
 			void SendTo (std::shared_ptr<std::ostream> os);
 
 			/**
-			 * @brief  Sets format for timestamps in log
-			 * @param  format  String with timestamp format
+			 * @brief Sets format for timestamps in log
+			 * @param format String with timestamp format
 			 */
 			void SetTimeFormat (std::string format) { m_TimeFormat = format; };
 
 	#ifndef _WIN32
 			/**
 			 * @brief Sets log destination to syslog
-			 * @param name     Wanted program name
+			 * @param name Wanted program name
 			 * @param facility Wanted log category
 			 */
 			void SendTo (const char *name, int facility);
 	#endif
 
 			/**
-			 * @brief  Format log message and write to output stream/syslog
-			 * @param  msg  Pointer to processed message
+			 * @brief Format log message and write to output stream/syslog
+			 * @param msg Pointer to processed message
 			 */
 			void Append(std::shared_ptr<i2p::log::LogMsg> &);
 
-			/** @brief  Reopen log file */
+			/** @brief Reopen log file */
 			void Reopen();
 	};
 
@@ -144,8 +144,8 @@ namespace log {
 	 */
 	struct LogMsg {
 		std::time_t timestamp;
-		std::string text; /**< message text as single string */
-		LogLevel level;   /**< message level */
+		std::string text;    /**< message text as single string */
+		LogLevel level;      /**< message level */
 		std::thread::id tid; /**< id of thread that generated message */
 
 		LogMsg (LogLevel lvl, std::time_t ts, std::string&& txt): timestamp(ts), text(std::move(txt)), level(lvl) {}
@@ -153,7 +153,7 @@ namespace log {
 
 	Log & Logger();
 
-	typedef std::function<void (const std::string&)>  ThrowFunction;
+	typedef std::function<void (const std::string&)> ThrowFunction;
 	ThrowFunction GetThrowFunction ();
 	void SetThrowFunction (ThrowFunction f);
 } // log

libi2pd/NTCP2.cpp

@@ -66,7 +66,7 @@ namespace transport
 	{
 		MixHash (sessionRequest + 32, 32); // encrypted payload
 
-		int paddingLength =  sessionRequestLen - 64;
+		int paddingLength = sessionRequestLen - 64;
 		if (paddingLength > 0)
 			MixHash (sessionRequest + 64, paddingLength);
 		MixHash (epub, 32);
@@ -130,7 +130,7 @@ namespace transport
 		// m3p2Len
 		auto bufLen = i2p::context.GetRouterInfo ().GetBufferLen ();
 		m3p2Len = bufLen + 4 + 16; // (RI header + RI + MAC for now) TODO: implement options
-		htobe16buf (options + 4,  m3p2Len);
+		htobe16buf (options + 4, m3p2Len);
 		// fill m3p2 payload (RouterInfo block)
 		m_SessionConfirmedBuffer = new uint8_t[m3p2Len + 48]; // m3p1 is 48 bytes
 		uint8_t * m3p2 = m_SessionConfirmedBuffer + 48;
@@ -231,11 +231,11 @@ namespace transport
 				auto ts = i2p::util::GetSecondsSinceEpoch ();
 				uint32_t tsA = bufbe32toh (options + 8);
 				if (tsA < ts - NTCP2_CLOCK_SKEW || tsA > ts + NTCP2_CLOCK_SKEW)
-				{	
+				{
 					LogPrint (eLogWarning, "NTCP2: SessionRequest time difference ", (int)(ts - tsA), " exceeds clock skew");
 					clockSkew = true;
 					// we send SessionCreate to let Alice know our time and then close session
-				}	
+				}
 			}
 			else
 			{
@@ -320,7 +320,7 @@ namespace transport
 	}
 
 	NTCP2Session::NTCP2Session (NTCP2Server& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter,
-	    	std::shared_ptr<const i2p::data::RouterInfo::Address> addr):
+		std::shared_ptr<const i2p::data::RouterInfo::Address> addr):
 		TransportSession (in_RemoteRouter, NTCP2_ESTABLISH_TIMEOUT),
 		m_Server (server), m_Socket (m_Server.GetService ()),
 		m_IsEstablished (false), m_IsTerminated (false),
@@ -418,7 +418,7 @@ namespace transport
 	void NTCP2Session::DeleteNextReceiveBuffer (uint64_t ts)
 	{
 		if (m_NextReceivedBuffer && !m_IsReceiving &&
-		    ts > m_LastActivityTimestamp + NTCP2_RECEIVE_BUFFER_DELETION_TIMEOUT)
+			ts > m_LastActivityTimestamp + NTCP2_RECEIVE_BUFFER_DELETION_TIMEOUT)
 		{
 			delete[] m_NextReceivedBuffer;
 			m_NextReceivedBuffer = nullptr;
@@ -484,9 +484,9 @@ namespace transport
 				if (clockSkew)
 				{
 					// we don't care about padding, send SessionCreated and close session
-					SendSessionCreated (); 
+					SendSessionCreated ();
 					m_Server.GetService ().post (std::bind (&NTCP2Session::Terminate, shared_from_this ()));
-				}	
+				}
 				else if (paddingLen > 0)
 				{
 					if (paddingLen <= NTCP2_SESSION_REQUEST_MAX_SIZE - 64) // session request is 287 bytes max
@@ -496,7 +496,7 @@ namespace transport
 					}
 					else
 					{
-						LogPrint (eLogWarning, "NTCP2: SessionRequest padding length ", (int)paddingLen,  " is too long");
+						LogPrint (eLogWarning, "NTCP2: SessionRequest padding length ", (int)paddingLen, " is too long");
 						Terminate ();
 					}
 				}
@@ -549,7 +549,7 @@ namespace transport
 					}
 					else
 					{
-						LogPrint (eLogWarning, "NTCP2: SessionCreated padding length ", (int)paddingLen,  " is too long");
+						LogPrint (eLogWarning, "NTCP2: SessionCreated padding length ", (int)paddingLen, " is too long");
 						Terminate ();
 					}
 				}
@@ -1126,11 +1126,11 @@ namespace transport
 	{
 		if (!m_SendKey ||
 #if OPENSSL_SIPHASH
-		    !m_SendMDCtx
+			!m_SendMDCtx
 #else
-		    !m_SendSipKey
+			!m_SendSipKey
 #endif
-		    ) return;
+		) return;
 		m_NextSendBuffer = new uint8_t[49]; // 49 = 12 bytes message + 16 bytes MAC + 2 bytes size + up to 19 padding block
 		// termination block
 		m_NextSendBuffer[2] = eNTCP2BlkTermination;
@@ -1164,7 +1164,7 @@ namespace transport
 		else if (m_SendQueue.size () > NTCP2_MAX_OUTGOING_QUEUE_SIZE)
 		{
 			LogPrint (eLogWarning, "NTCP2: Outgoing messages queue size to ",
-			   	GetIdentHashBase64(), " exceeds ",  NTCP2_MAX_OUTGOING_QUEUE_SIZE);
+				GetIdentHashBase64(), " exceeds ", NTCP2_MAX_OUTGOING_QUEUE_SIZE);
 			Terminate ();
 		}
 	}
@@ -1177,7 +1177,7 @@ namespace transport
 
 	NTCP2Server::NTCP2Server ():
 		RunnableServiceWithWork ("NTCP2"), m_TerminationTimer (GetService ()),
-		 m_ProxyType(eNoProxy), m_Resolver(GetService ())
+			m_ProxyType(eNoProxy), m_Resolver(GetService ())
 	{
 	}
 

libi2pd/NetDb.cpp

@@ -107,7 +107,10 @@ namespace data
 	{
 		i2p::util::SetThreadName("NetDB");
 
-		uint32_t lastSave = 0, lastPublish = 0, lastExploratory = 0, lastManageRequest = 0, lastDestinationCleanup = 0;
+		uint64_t lastSave = 0, lastPublish = 0, lastExploratory = 0, lastManageRequest = 0, lastDestinationCleanup = 0;
+		uint64_t lastProfilesCleanup = i2p::util::GetSecondsSinceEpoch ();
+		int16_t profilesCleanupVariance = 0;
+
 		while (m_IsRunning)
 		{
 			try
@@ -155,6 +158,7 @@ namespace data
 					m_Requests.ManageRequests ();
 					lastManageRequest = ts;
 				}
+
 				if (ts - lastSave >= 60) // save routers, manage leasesets and validate subscriptions every minute
 				{
 					if (lastSave)
@@ -164,12 +168,20 @@ namespace data
 					}
 					lastSave = ts;
 				}
+
 				if (ts - lastDestinationCleanup >= i2p::garlic::INCOMING_TAGS_EXPIRATION_TIMEOUT)
 				{
 					i2p::context.CleanupDestination ();
 					lastDestinationCleanup = ts;
 				}
 
+				if (ts - lastProfilesCleanup >= (uint64_t)(i2p::data::PEER_PROFILE_AUTOCLEAN_TIMEOUT + profilesCleanupVariance))
+				{
+					DeleteObsoleteProfiles ();
+					lastProfilesCleanup = ts;
+					profilesCleanupVariance = (rand () % (2 * i2p::data::PEER_PROFILE_AUTOCLEAN_VARIANCE) - i2p::data::PEER_PROFILE_AUTOCLEAN_VARIANCE);
+				}
+
 				// publish
 				if (!m_HiddenMode && i2p::transport::transports.IsOnline ())
 				{
@@ -195,6 +207,7 @@ namespace data
 						lastPublish = ts;
 					}
 				}
+
 				if (ts - lastExploratory >= 30) // exploratory every 30 seconds
 				{
 					auto numRouters = m_RouterInfos.size ();
@@ -476,7 +489,7 @@ namespace data
 	{
 		auto r = std::make_shared<RouterInfo>(path);
 		if (r->GetRouterIdentity () && !r->IsUnreachable () && r->HasValidAddresses () &&
-		    ts < r->GetTimestamp () + 24*60*60*NETDB_MAX_OFFLINE_EXPIRATION_TIMEOUT*1000LL)
+			ts < r->GetTimestamp () + 24*60*60*NETDB_MAX_OFFLINE_EXPIRATION_TIMEOUT*1000LL)
 		{
 			r->DeleteBuffer ();
 			if (m_RouterInfos.emplace (r->GetIdentHash (), r).second)
@@ -607,7 +620,7 @@ namespace data
 			}
 			// make router reachable back if too few routers or floodfills
 			if (it.second->IsUnreachable () && (total - deletedCount < NETDB_MIN_ROUTERS ||
-			    (it.second->IsFloodfill () && totalFloodfills - deletedFloodfillsCount < NETDB_MIN_FLOODFILLS)))
+				(it.second->IsFloodfill () && totalFloodfills - deletedFloodfillsCount < NETDB_MIN_FLOODFILLS)))
 				it.second->SetUnreachable (false);
 			// find & mark expired routers
 			if (!it.second->IsReachable () && it.second->IsSSU (false))
@@ -630,7 +643,7 @@ namespace data
 		} // m_RouterInfos iteration
 
 		m_RouterInfoBuffersPool.CleanUpMt ();
-			
+
 		if (updatedCount > 0)
 			LogPrint (eLogInfo, "NetDb: Saved ", updatedCount, " new/updated routers");
 		if (deletedCount > 0)
@@ -659,7 +672,7 @@ namespace data
 					else
 						++it;
 			}
-		}	
+		}
 	}
 
 	void NetDb::RequestDestination (const IdentHash& destination, RequestedDestination::RequestComplete requestComplete, bool direct)
@@ -675,7 +688,7 @@ namespace data
 		if (floodfill)
 		{
 			if (direct && !floodfill->IsReachableFrom (i2p::context.GetRouterInfo ()) &&
-			    !i2p::transport::transports.IsConnected (floodfill->GetIdentHash ()))
+				!i2p::transport::transports.IsConnected (floodfill->GetIdentHash ()))
 				direct = false; // floodfill can't be reached directly
 			if (direct)
 				transports.SendMessage (floodfill->GetIdentHash (), dest->CreateRequestMessage (floodfill->GetIdentHash ()));
@@ -958,7 +971,7 @@ namespace data
 		else
 		{
 			if (lookupType == DATABASE_LOOKUP_TYPE_ROUTERINFO_LOOKUP ||
-			    lookupType == DATABASE_LOOKUP_TYPE_NORMAL_LOOKUP)
+				lookupType == DATABASE_LOOKUP_TYPE_NORMAL_LOOKUP)
 			{
 				auto router = FindRouter (ident);
 				if (router)
@@ -1123,7 +1136,7 @@ namespace data
 			m_PublishExcluded.insert (floodfill->GetIdentHash ());
 			m_PublishReplyToken = replyToken;
 			if (floodfill->IsReachableFrom (i2p::context.GetRouterInfo ()) || // are we able to connect?
-			    i2p::transport::transports.IsConnected (floodfill->GetIdentHash ()))  // already connected ?
+				i2p::transport::transports.IsConnected (floodfill->GetIdentHash ())) // already connected ?
 				// send directly
 				transports.SendMessage (floodfill->GetIdentHash (), CreateDatabaseStoreMsg (i2p::context.GetSharedRouterInfo (), replyToken));
 			else
@@ -1190,6 +1203,16 @@ namespace data
 			});
 	}
 
+	std::shared_ptr<const RouterInfo> NetDb::GetRandomSSU2PeerTestRouter (bool v4, const std::set<IdentHash>& excluded) const
+	{
+		return GetRandomRouter (
+			[v4, &excluded](std::shared_ptr<const RouterInfo> router)->bool
+			{
+				return !router->IsHidden () && router->IsECIES () &&
+					router->IsSSU2PeerTesting (v4) && !excluded.count (router->GetIdentHash ());
+			});
+	}
+	
 	std::shared_ptr<const RouterInfo> NetDb::GetRandomSSUV6Router () const
 	{
 		return GetRandomRouter (
@@ -1364,7 +1387,7 @@ namespace data
 		return res;
 	}
 
-	std::shared_ptr<const RouterInfo> NetDb::GetRandomRouterInFamily (FamilyID fam) const 
+	std::shared_ptr<const RouterInfo> NetDb::GetRandomRouterInFamily (FamilyID fam) const
 	{
 		return GetRandomRouter(
 			[fam](std::shared_ptr<const RouterInfo> router)->bool

libi2pd/NetDb.hpp

@@ -90,6 +90,7 @@ namespace data
 			std::shared_ptr<const RouterInfo> GetRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith, bool reverse) const;
 			std::shared_ptr<const RouterInfo> GetHighBandwidthRandomRouter (std::shared_ptr<const RouterInfo> compatibleWith, bool reverse) const;
 			std::shared_ptr<const RouterInfo> GetRandomPeerTestRouter (bool v4, const std::set<IdentHash>& excluded) const;
+			std::shared_ptr<const RouterInfo> GetRandomSSU2PeerTestRouter (bool v4, const std::set<IdentHash>& excluded) const;
 			std::shared_ptr<const RouterInfo> GetRandomSSUV6Router () const; // TODO: change to v6 peer test later
 			std::shared_ptr<const RouterInfo> GetRandomIntroducer (bool v4, const std::set<IdentHash>& excluded) const;
 			std::shared_ptr<const RouterInfo> GetClosestFloodfill (const IdentHash& destination, const std::set<IdentHash>& excluded, bool closeThanUsOnly = false) const;
@@ -123,7 +124,7 @@ namespace data
 
 			void ClearRouterInfos () { m_RouterInfos.clear (); };
 			std::shared_ptr<RouterInfo::Buffer> NewRouterInfoBuffer () { return m_RouterInfoBuffersPool.AcquireSharedMt (); };
-			
+
 			uint32_t GetPublishReplyToken () const { return m_PublishReplyToken; };
 
 		private:

libi2pd/NetDbRequests.h

@@ -60,7 +60,7 @@ namespace data
 			void Start ();
 			void Stop ();
 
-			 std::shared_ptr<RequestedDestination> CreateRequest (const IdentHash& destination, bool isExploratory, RequestedDestination::RequestComplete requestComplete = nullptr);
+			std::shared_ptr<RequestedDestination> CreateRequest (const IdentHash& destination, bool isExploratory, RequestedDestination::RequestComplete requestComplete = nullptr);
 			void RequestComplete (const IdentHash& ident, std::shared_ptr<RouterInfo> r);
 			std::shared_ptr<RequestedDestination> FindRequest (const IdentHash& ident) const;
 			void ManageRequests ();

libi2pd/Poly1305.cpp

@@ -1,12 +1,13 @@
-#include "Poly1305.h"
 /**
-   This code is licensed under the MCGSI Public License
-   Copyright 2018 Jeff Becker
-
-   Kovri go write your own code
-
+ * This code is licensed under the MCGSI Public License
+ * Copyright 2018 Jeff Becker
+ *
+ *Kovri go write your own code
+ *
  */
 
+#include "Poly1305.h"
+
 #if !OPENSSL_AEAD_CHACHA20_POLY1305
 namespace i2p
 {

libi2pd/Poly1305.h

@@ -5,6 +5,7 @@
  * Kovri go write your own code
  *
  */
+
 #ifndef LIBI2PD_POLY1305_H
 #define LIBI2PD_POLY1305_H
 #include <cstdint>

libi2pd/Profiling.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -29,6 +29,8 @@ namespace data
 	const char PEER_PROFILE_USAGE_REJECTED[] = "rejected";
 
 	const int PEER_PROFILE_EXPIRATION_TIMEOUT = 72; // in hours (3 days)
+	const int PEER_PROFILE_AUTOCLEAN_TIMEOUT = 24 * 3600; // in seconds (1 day)
+	const int PEER_PROFILE_AUTOCLEAN_VARIANCE = 3 * 3600; // in seconds (3 hours)
 
 	class RouterProfile
 	{

libi2pd/Queue.h

@@ -28,7 +28,7 @@ namespace util
 
 			void Put (Element e)
 			{
-				std::unique_lock<std::mutex>  l(m_QueueMutex);
+				std::unique_lock<std::mutex> l(m_QueueMutex);
 				m_Queue.push (std::move(e));
 				m_NonEmpty.notify_one ();
 			}
@@ -38,7 +38,7 @@ namespace util
 			{
 				if (!vec.empty ())
 				{
-					std::unique_lock<std::mutex>  l(m_QueueMutex);
+					std::unique_lock<std::mutex> l(m_QueueMutex);
 					for (const auto& it: vec)
 						m_Queue.push (std::move(it));
 					m_NonEmpty.notify_one ();

libi2pd/Reseed.cpp

@@ -187,31 +187,31 @@ namespace data
 		}
 		s.seekg (1, std::ios::cur); // su3 file format version
 		SigningKeyType signatureType;
-		s.read ((char *)&signatureType, 2);  // signature type
+		s.read ((char *)&signatureType, 2); // signature type
 		signatureType = be16toh (signatureType);
 		uint16_t signatureLength;
-		s.read ((char *)&signatureLength, 2);  // signature length
+		s.read ((char *)&signatureLength, 2); // signature length
 		signatureLength = be16toh (signatureLength);
 		s.seekg (1, std::ios::cur); // unused
 		uint8_t versionLength;
-		s.read ((char *)&versionLength, 1);  // version length
+		s.read ((char *)&versionLength, 1); // version length
 		s.seekg (1, std::ios::cur); // unused
 		uint8_t signerIDLength;
-		s.read ((char *)&signerIDLength, 1);  // signer ID length
+		s.read ((char *)&signerIDLength, 1); // signer ID length
 		uint64_t contentLength;
-		s.read ((char *)&contentLength, 8);  // content length
+		s.read ((char *)&contentLength, 8); // content length
 		contentLength = be64toh (contentLength);
 		s.seekg (1, std::ios::cur); // unused
 		uint8_t fileType;
-		s.read ((char *)&fileType, 1);  // file type
-		if (fileType != 0x00) //  zip file
+		s.read ((char *)&fileType, 1); // file type
+		if (fileType != 0x00) // zip file
 		{
 			LogPrint (eLogError, "Reseed: Can't handle file type ", (int)fileType);
 			return 0;
 		}
 		s.seekg (1, std::ios::cur); // unused
 		uint8_t contentType;
-		s.read ((char *)&contentType, 1);  // content type
+		s.read ((char *)&contentType, 1); // content type
 		if (contentType != 0x03) // reseed data
 		{
 			LogPrint (eLogError, "Reseed: Unexpected content type ", (int)contentType);
@@ -688,7 +688,7 @@ namespace data
 				{
 					boost::asio::ip::tcp::endpoint ep = *it;
 					if ((ep.address ().is_v4 () && i2p::context.SupportsV4 ()) ||
-					    (ep.address ().is_v6 () && i2p::context.SupportsV6 ()))
+						(ep.address ().is_v6 () && i2p::context.SupportsV6 ()))
 					{
 						s.lowest_layer().connect (ep, ecode);
 						if (!ecode)

libi2pd/RouterContext.cpp

@@ -65,13 +65,13 @@ namespace i2p
 			port = rand () % (30777 - 9111) + 9111; // I2P network ports range
 			if (port == 9150) port = 9151; // Tor browser
 		}
-		bool ipv4;           i2p::config::GetOption("ipv4", ipv4);
-		bool ipv6;           i2p::config::GetOption("ipv6", ipv6);
-		bool ssu;            i2p::config::GetOption("ssu", ssu);
-		bool ntcp2;          i2p::config::GetOption("ntcp2.enabled", ntcp2);
-		bool ssu2;			 i2p::config::GetOption("ssu2.enabled", ssu2);
-		bool ygg;            i2p::config::GetOption("meshnets.yggdrasil", ygg);
-		bool nat;            i2p::config::GetOption("nat", nat);
+		bool ipv4;  i2p::config::GetOption("ipv4", ipv4);
+		bool ipv6;  i2p::config::GetOption("ipv6", ipv6);
+		bool ssu;   i2p::config::GetOption("ssu", ssu);
+		bool ntcp2; i2p::config::GetOption("ntcp2.enabled", ntcp2);
+		bool ssu2;  i2p::config::GetOption("ssu2.enabled", ssu2);
+		bool ygg;   i2p::config::GetOption("meshnets.yggdrasil", ygg);
+		bool nat;   i2p::config::GetOption("nat", nat);
 
 		if ((ntcp2 || ygg) && !m_NTCP2Keys)
 			NewNTCP2Keys ();
@@ -123,11 +123,11 @@ namespace i2p
 				if (ssu2Published)
 					routerInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, boost::asio::ip::address_v4::from_string (host), port);
 				else
-				{	
+				{
 					addressCaps |= i2p::data::RouterInfo::AddressCaps::eV4;
 					routerInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro);
-				}	
-			}	
+				}
+			}
 		}
 		if (ipv6)
 		{
@@ -168,12 +168,12 @@ namespace i2p
 				if (ssu2Published)
 					routerInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, boost::asio::ip::address_v6::from_string (host), port);
 				else
-				{	
+				{
 					if (!ipv4) // no other ssu2 addresses yet
 						routerInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro);
 					addressCaps |= i2p::data::RouterInfo::AddressCaps::eV6;
-				}	
-			}	
+				}
+			}
 		}
 		if (ygg)
 		{
@@ -224,7 +224,7 @@ namespace i2p
 		std::ofstream fk (i2p::fs::DataDirPath (SSU2_KEYS), std::ofstream::binary | std::ofstream::out);
 		fk.write ((char *)m_SSU2Keys.get (), sizeof (SSU2PrivateKeys));
 	}
-		
+
 	void RouterContext::SetStatus (RouterStatus status)
 	{
 		if (status != m_Status)
@@ -313,7 +313,7 @@ namespace i2p
 		if (updated)
 			UpdateRouterInfo ();
 	}
-		
+
 	void RouterContext::UpdateNTCP2Address (bool enable)
 	{
 		auto& addresses = m_RouterInfo.GetAddresses ();
@@ -360,8 +360,8 @@ namespace i2p
 		}
 		if (updated)
 			UpdateRouterInfo ();
-	}	
-		
+	}
+
 	void RouterContext::UpdateSSU2Address (bool enable)
 	{
 		auto& addresses = m_RouterInfo.GetAddresses ();
@@ -392,14 +392,14 @@ namespace i2p
 		if (updated)
 			UpdateRouterInfo ();
 	}
-		
+
 	void RouterContext::UpdateAddress (const boost::asio::ip::address& host)
 	{
 		bool updated = false;
 		for (auto& address : m_RouterInfo.GetAddresses ())
 		{
 			if (address->host != host && address->IsCompatible (host) &&
-			    !i2p::util::net::IsYggdrasilAddress (address->host))
+				!i2p::util::net::IsYggdrasilAddress (address->host))
 			{
 				address->host = host;
 				if (host.is_v6 () && address->transportStyle == i2p::data::RouterInfo::eTransportSSU)
@@ -643,12 +643,12 @@ namespace i2p
 						break;
 						case i2p::data::RouterInfo::eTransportNTCP:
 							foundNTCP2 = true;
-						break;	
+						break;
 						case i2p::data::RouterInfo::eTransportSSU2:
 							foundSSU2 = true;
-						break;	
+						break;
 						default: ;
-					}	
+					}
 				}
 				port = addr->port;
 			}
@@ -690,17 +690,17 @@ namespace i2p
 			{
 				bool ssu2; i2p::config::GetOption("ssu2.enabled", ssu2);
 				if (ssu2)
-				{	
+				{
 					bool ssu2Published; i2p::config::GetOption("ssu2.published", ssu2Published);
 					if (ssu2Published)
 					{
 						uint16_t ssu2Port; i2p::config::GetOption ("ssu2.port", ssu2Port);
 						m_RouterInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, boost::asio::ip::address::from_string ("::1"), ssu2Port);
-					}	
+					}
 					else
 						m_RouterInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, i2p::data::RouterInfo::eV6);
-				}	
-			}	
+				}
+			}
 			m_RouterInfo.EnableV6 ();
 		}
 		else
@@ -731,12 +731,12 @@ namespace i2p
 						break;
 						case i2p::data::RouterInfo::eTransportNTCP:
 							foundNTCP2 = true;
-						break;	
+						break;
 						case i2p::data::RouterInfo::eTransportSSU2:
 							foundSSU2 = true;
-						break;	
+						break;
 						default: ;
-					}	
+					}
 				}
 				if (addr->port) port = addr->port;
 			}
@@ -776,11 +776,11 @@ namespace i2p
 					{
 						uint16_t ssu2Port; i2p::config::GetOption ("ssu2.port", ssu2Port);
 						m_RouterInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, boost::asio::ip::address::from_string ("127.0.0.1"), ssu2Port);
-					}	
+					}
 					else
 						m_RouterInfo.AddSSU2Address (m_SSU2Keys->staticPublicKey, m_SSU2Keys->intro, i2p::data::RouterInfo::eV6);
-				}	
-			}	
+				}
+			}
 			m_RouterInfo.EnableV4 ();
 		}
 		else
@@ -883,7 +883,7 @@ namespace i2p
 		}
 		std::shared_ptr<const i2p::data::IdentityEx> oldIdentity;
 		if (m_Keys.GetPublic ()->GetSigningKeyType () == i2p::data::SIGNING_KEY_TYPE_DSA_SHA1 ||
-		    m_Keys.GetPublic ()->GetCryptoKeyType () == i2p::data::CRYPTO_KEY_TYPE_ELGAMAL)
+			m_Keys.GetPublic ()->GetCryptoKeyType () == i2p::data::CRYPTO_KEY_TYPE_ELGAMAL)
 		{
 			// update keys
 			LogPrint (eLogInfo, "Router: router keys are obsolete. Creating new");
@@ -935,7 +935,7 @@ namespace i2p
 			UpdateNTCP2Address (true); // enable NTCP2
 		}
 		else
-			UpdateNTCP2Address (false);	 // disable NTCP2
+			UpdateNTCP2Address (false); // disable NTCP2
 
 		// read SSU2
 		bool ssu2; i2p::config::GetOption("ssu2.enabled", ssu2);
@@ -960,7 +960,7 @@ namespace i2p
 		}
 		else
 			UpdateSSU2Address (false); // disable SSU2
-		
+
 		return true;
 	}
 
@@ -1103,5 +1103,5 @@ namespace i2p
 				delete x;
 		}
 		return *m_SSU2StaticKeys;
-	}	
+	}
 }

libi2pd/RouterContext.h

@@ -68,7 +68,7 @@ namespace garlic
 				uint8_t staticPrivateKey[32];
 				uint8_t intro[32];
 			};
-			
+
 		public:
 
 			RouterContext ();
@@ -86,7 +86,7 @@ namespace garlic
 				return std::shared_ptr<i2p::garlic::GarlicDestination> (this,
 					[](i2p::garlic::GarlicDestination *) {});
 			}
-			
+
 			const uint8_t * GetNTCP2StaticPublicKey () const { return m_NTCP2Keys ? m_NTCP2Keys->staticPublicKey : nullptr; };
 			const uint8_t * GetNTCP2StaticPrivateKey () const { return m_NTCP2Keys ? m_NTCP2Keys->staticPrivateKey : nullptr; };
 			const uint8_t * GetNTCP2IV () const { return m_NTCP2Keys ? m_NTCP2Keys->iv : nullptr; };
@@ -96,7 +96,7 @@ namespace garlic
 			const uint8_t * GetSSU2StaticPrivateKey () const { return m_SSU2Keys ? m_SSU2Keys->staticPrivateKey : nullptr; };
 			const uint8_t * GetSSU2IntroKey () const { return m_SSU2Keys ? m_SSU2Keys->intro : nullptr; };
 			i2p::crypto::X25519Keys& GetSSU2StaticKeys ();
-			
+
 			uint32_t GetUptime () const; // in seconds
 			uint64_t GetLastUpdateTime () const { return m_LastUpdateTime; };
 			uint64_t GetBandwidthLimit () const { return m_BandwidthLimit; };

libi2pd/RouterInfo.cpp

@@ -33,16 +33,16 @@ namespace data
 	{
 		if (len > size ()) len = size ();
 		memcpy (data (), buf, len);
-	}		
-	
+	}
+
 	RouterInfo::RouterInfo (): m_Buffer (nullptr)
 	{
 		m_Addresses = boost::make_shared<Addresses>(); // create empty list
 	}
 
 	RouterInfo::RouterInfo (const std::string& fullPath):
-		m_FamilyID (0), m_IsUpdated (false), m_IsUnreachable (false), 
-		m_SupportedTransports (0),m_ReachableTransports (0), 
+		m_FamilyID (0), m_IsUpdated (false), m_IsUnreachable (false),
+		m_SupportedTransports (0),m_ReachableTransports (0),
 		m_Caps (0), m_Version (0)
 	{
 		m_Addresses = boost::make_shared<Addresses>(); // create empty list
@@ -51,8 +51,8 @@ namespace data
 	}
 
 	RouterInfo::RouterInfo (std::shared_ptr<Buffer>&& buf, size_t len):
-		m_FamilyID (0), m_IsUpdated (true), m_IsUnreachable (false), 
-		m_SupportedTransports (0), m_ReachableTransports (0), 
+		m_FamilyID (0), m_IsUpdated (true), m_IsUnreachable (false),
+		m_SupportedTransports (0), m_ReachableTransports (0),
 		m_Caps (0), m_Version (0)
 	{
 		if (len <= MAX_RI_BUFFER_SIZE)
@@ -68,12 +68,12 @@ namespace data
 			m_Buffer = nullptr;
 			m_IsUnreachable = true;
 		}
-	}	
-		
+	}
+
 	RouterInfo::RouterInfo (const uint8_t * buf, size_t len):
 		RouterInfo (std::make_shared<Buffer> (buf, len), len)
 	{
-	}		
+	}
 
 	RouterInfo::~RouterInfo ()
 	{
@@ -160,7 +160,7 @@ namespace data
 		{
 			m_IsUnreachable = true;
 			return;
-		}	
+		}
 		m_RouterIdentity = std::make_shared<IdentityEx>(m_Buffer->data (), m_BufferLen);
 		size_t identityLen = m_RouterIdentity->GetFullLen ();
 		if (identityLen >= m_BufferLen)
@@ -241,7 +241,7 @@ namespace data
 				// skip unknown address
 				s.seekg (size, std::ios_base::cur);
 				if (s) continue; else return;
-			}	
+			}
 			while (r < size)
 			{
 				char key[255], value[255];
@@ -288,7 +288,7 @@ namespace data
 					}
 					else if (address->IsSSU2 ())
 						Base64ToByteStream (value, strlen (value), address->i, 32);
-					else	
+					else
 						Base64ToByteStream (value, strlen (value), iV2, 32);
 				}
 				else if (!strcmp (key, "v"))
@@ -297,7 +297,7 @@ namespace data
 						isV2 = true;
 					else
 						LogPrint (eLogWarning, "RouterInfo: Unexpected value ", value, " for v");
-				}	
+				}
 				else if (key[0] == 'i')
 				{
 					// introducers
@@ -344,7 +344,7 @@ namespace data
 					if (isHost)
 					{
 						if (address->host.is_v6 ())
-							supportedTransports |= (i2p::util::net::IsYggdrasilAddress (address->host) ? eNTCP2V6Mesh :  eNTCP2V6);
+							supportedTransports |= (i2p::util::net::IsYggdrasilAddress (address->host) ? eNTCP2V6Mesh : eNTCP2V6);
 						else
 							supportedTransports |= eNTCP2V4;
 						m_ReachableTransports |= supportedTransports;
@@ -366,7 +366,7 @@ namespace data
 				if (isIntroKey)
 				{
 					if (isHost)
-						supportedTransports |= address->host.is_v4 () ? eSSUV4 :  eSSUV6;
+						supportedTransports |= address->host.is_v4 () ? eSSUV4 : eSSUV6;
 					else if (address->caps & AddressCaps::eV6)
 					{
 						supportedTransports |= eSSUV6;
@@ -383,7 +383,7 @@ namespace data
 						{
 							if (!it.iExp) it.iExp = m_Timestamp/1000 + NETDB_INTRODUCEE_EXPIRATION_TIMEOUT;
 							if (ts <= it.iExp && it.iPort > 0 &&
-							    ((it.iHost.is_v4 () && address->IsV4 ()) || (it.iHost.is_v6 () && address->IsV6 ())))
+								((it.iHost.is_v4 () && address->IsV4 ()) || (it.iHost.is_v6 () && address->IsV6 ())))
 								numValid++;
 							else
 								it.iPort = 0;
@@ -408,12 +408,12 @@ namespace data
 				{
 					if (address->host.is_v4 ()) m_ReachableTransports |= eSSU2V4;
 					if (address->host.is_v6 ()) m_ReachableTransports |= eSSU2V6;
-				}	
-			}	
-			if (supportedTransports) 
+				}
+			}
+			if (supportedTransports)
 			{
 				if (!(m_SupportedTransports & supportedTransports)) // avoid duplicates
-				{	
+				{
 					addresses->push_back(address);
 					if (address->transportStyle == eTransportSSU && isV2)
 					{
@@ -427,10 +427,10 @@ namespace data
 						ssu2addr->ssu.reset (new SSUExt ()); ssu2addr->ssu->mtu = address->ssu->mtu;
 						for (const auto& introducer: address->ssu->introducers)
 							if (!introducer.iPort) // SSU2
-								ssu2addr->ssu->introducers.push_back (introducer);	
+								ssu2addr->ssu->introducers.push_back (introducer);
 						addresses->push_back(ssu2addr);
-					}	
-				}	
+					}
+				}
 				m_SupportedTransports |= supportedTransports;
 			}
 		}
@@ -483,10 +483,10 @@ namespace data
 			{
 				isNetId = true;
 				if (atoi (value) != i2p::context.GetNetID ())
-				{	
+				{
 					LogPrint (eLogError, "RouterInfo: Unexpected ", ROUTER_INFO_PROPERTY_NETID, "=", value);
 					m_IsUnreachable = true;
-				}	
+				}
 			}
 			// family
 			else if (!strcmp (key, ROUTER_INFO_PROPERTY_FAMILY))
@@ -498,7 +498,7 @@ namespace data
 			{
 				if (netdb.GetFamilies ().VerifyFamily (family, GetIdentHash (), value))
 					m_FamilyID = netdb.GetFamilies ().GetFamilyID (family);
-				else	
+				else
 					LogPrint (eLogWarning, "RouterInfo: Family ", family, " signature verification failed");
 			}
 
@@ -689,7 +689,7 @@ namespace data
 		if (addr->IsV4 ()) m_SupportedTransports |= eSSU2V4;
 		if (addr->IsV6 ()) m_SupportedTransports |= eSSU2V6;
 		m_Addresses->push_back(std::move(addr));
-	}	
+	}
 
 	void RouterInfo::AddSSU2Address (const uint8_t * staticKey, const uint8_t * introKey,
 		const boost::asio::ip::address& host, int port)
@@ -706,24 +706,24 @@ namespace data
 		memcpy (addr->s, staticKey, 32);
 		memcpy (addr->i, introKey, 32);
 		if (addr->IsV4 ())
-		{	
+		{
 			m_SupportedTransports |= eSSU2V4;
 			m_ReachableTransports |= eSSU2V4;
-		}	
+		}
 		if (addr->IsV6 ())
-		{	
+		{
 			m_SupportedTransports |= eSSU2V6;
 			m_ReachableTransports |= eSSU2V6;
-		}	
+		}
 		m_Addresses->push_back(std::move(addr));
-	}	
-		
+	}
+
 	bool RouterInfo::AddIntroducer (const Introducer& introducer)
 	{
 		for (auto& addr : *m_Addresses)
 		{
 			if (addr->transportStyle == eTransportSSU &&
-			   ((addr->IsV4 () && introducer.iHost.is_v4 ()) || (addr->IsV6 () && introducer.iHost.is_v6 ())))
+				((addr->IsV4 () && introducer.iHost.is_v4 ()) || (addr->IsV6 () && introducer.iHost.is_v6 ())))
 			{
 				for (auto& intro: addr->ssu->introducers)
 					if (intro.iTag == introducer.iTag) return false; // already presented
@@ -740,7 +740,7 @@ namespace data
 		for (auto& addr: *m_Addresses)
 		{
 			if (addr->transportStyle == eTransportSSU &&
-			   ((addr->IsV4 () && e.address ().is_v4 ()) || (addr->IsV6 () && e.address ().is_v6 ())))
+				((addr->IsV4 () && e.address ().is_v4 ()) || (addr->IsV6 () && e.address ().is_v6 ())))
 			{
 				for (auto it = addr->ssu->introducers.begin (); it != addr->ssu->introducers.end (); ++it)
 					if (boost::asio::ip::udp::endpoint (it->iHost, it->iPort) == e)
@@ -894,8 +894,8 @@ namespace data
 			{
 				return (address->transportStyle == eTransportSSU2) && address->IsV4();
 			});
-	}	
-		
+	}
+
 	std::shared_ptr<const RouterInfo::Address> RouterInfo::GetSSU2V6Address () const
 	{
 		return GetAddress (
@@ -903,8 +903,8 @@ namespace data
 			{
 				return (address->transportStyle == eTransportSSU2) && address->IsV6();
 			});
-	}	
-		
+	}
+
 	template<typename Filter>
 	std::shared_ptr<const RouterInfo::Address> RouterInfo::GetAddress (Filter filter) const
 	{
@@ -939,7 +939,7 @@ namespace data
 				return address->IsSSU2 () && !memcmp (address->s, key, 32) && address->IsV6 () == isV6;
 			});
 	}
-		
+
 	std::shared_ptr<const RouterInfo::Address> RouterInfo::GetPublishedNTCP2V4Address () const
 	{
 		return GetAddress (
@@ -1000,6 +1000,17 @@ namespace data
 			});
 	}
 
+	bool RouterInfo::IsSSU2PeerTesting (bool v4) const
+	{
+		if (!(m_SupportedTransports & (v4 ? eSSU2V4 : eSSU2V6))) return false;
+		return (bool)GetAddress (
+			[v4](std::shared_ptr<const RouterInfo::Address> address)->bool
+			{
+				return (address->IsSSU2 ()) && address->IsPeerTesting () &&
+					((v4 && address->IsV4 ()) || (!v4 && address->IsV6 ())) && address->IsReachableSSU ();
+			});
+	}	
+		
 	bool RouterInfo::IsIntroducer (bool v4) const
 	{
 		if (!(m_SupportedTransports & (v4 ? eSSUV4 : eSSUV6))) return false;
@@ -1057,17 +1068,17 @@ namespace data
 		if (len > m_Buffer->size ()) len = m_Buffer->size ();
 		memcpy (m_Buffer->data (), buf, len);
 		m_BufferLen = len;
-	}	
+	}
 
 	std::shared_ptr<RouterInfo::Buffer> RouterInfo::NewBuffer () const
 	{
 		return netdb.NewRouterInfoBuffer ();
-	}	
-		
+	}
+
 	void RouterInfo::RefreshTimestamp ()
 	{
-		m_Timestamp = i2p::util::GetMillisecondsSinceEpoch (); 
-	}	
+		m_Timestamp = i2p::util::GetMillisecondsSinceEpoch ();
+	}
 
 	void LocalRouterInfo::CreateBuffer (const PrivateKeys& privateKeys)
 	{
@@ -1088,13 +1099,13 @@ namespace data
 		}
 		else
 			LogPrint (eLogError, "RouterInfo: Our RouterInfo is too long ", len + signatureLen);
-	}	
+	}
 
 	void LocalRouterInfo::UpdateCaps (uint8_t caps)
 	{
 		SetCaps (caps);
 		UpdateCapsProperty ();
-	}	
+	}
 
 	void LocalRouterInfo::UpdateCapsProperty ()
 	{
@@ -1153,7 +1164,7 @@ namespace data
 				{
 					WriteString ("NTCP2", s);
 					if (address.IsPublishedNTCP2 () && !address.host.is_unspecified () && address.port)
-						 isPublished = true;
+						isPublished = true;
 					else
 					{
 						WriteString ("caps", properties);
@@ -1212,12 +1223,12 @@ namespace data
 				// caps
 				std::string caps;
 				if (address.published)
-				{	
+				{
 					isPublished = true;
 					if (address.IsIntroducer ()) caps += CAPS_FLAG_SSU_INTRODUCER;
-				}	
+				}
 				else
-				{	
+				{
 					if (address.IsV4 ()) caps += CAPS_FLAG_V4;
 					if (address.IsV6 ()) caps += CAPS_FLAG_V6;
 					if (caps.empty ()) caps += CAPS_FLAG_V4;
@@ -1228,8 +1239,8 @@ namespace data
 					properties << '=';
 					WriteString (caps, properties);
 					properties << ';';
-				}	
-			}	
+				}
+			}
 			else
 				WriteString ("", s);
 
@@ -1265,7 +1276,7 @@ namespace data
 						i++;
 					}
 					if (address.transportStyle == eTransportSSU)
-					{	
+					{
 						i = 0;
 						for (const auto& introducer: address.ssu->introducers)
 						{
@@ -1275,13 +1286,13 @@ namespace data
 							properties << ';';
 							i++;
 						}
-					}	
+					}
 					i = 0;
 					for (const auto& introducer: address.ssu->introducers)
 					{
 						if (address.IsSSU2 ())
 							WriteString ("ih" + boost::lexical_cast<std::string>(i), properties);
-						else	
+						else
 							WriteString ("ikey" + boost::lexical_cast<std::string>(i), properties);
 						properties << '=';
 						char value[64];
@@ -1302,7 +1313,7 @@ namespace data
 							properties << ';';
 							i++;
 						}
-					}	
+					}
 					i = 0;
 					for (const auto& introducer: address.ssu->introducers)
 					{
@@ -1326,7 +1337,7 @@ namespace data
 				properties << ';';
 			}
 			if (address.transportStyle == eTransportSSU || address.IsSSU2 ())
-			{	
+			{
 				// write mtu
 				if (address.ssu && address.ssu->mtu)
 				{
@@ -1373,7 +1384,7 @@ namespace data
 		uint16_t size = htobe16 (properties.str ().size ());
 		s.write ((char *)&size, sizeof (size));
 		s.write (properties.str ().c_str (), properties.str ().size ());
-	}	
+	}
 
 	void LocalRouterInfo::SetProperty (const std::string& key, const std::string& value)
 	{
@@ -1391,18 +1402,18 @@ namespace data
 		if (it != m_Properties.end ())
 			return it->second;
 		return "";
-	}	
+	}
 
 	void LocalRouterInfo::WriteString (const std::string& str, std::ostream& s) const
 	{
 		uint8_t len = str.size ();
 		s.write ((char *)&len, 1);
 		s.write (str.c_str (), len);
-	}	
+	}
 
 	std::shared_ptr<RouterInfo::Buffer> LocalRouterInfo::NewBuffer () const
 	{
 		return std::make_shared<Buffer> ();
-	}		
+	}
 }
 }

libi2pd/RouterInfo.h

@@ -56,7 +56,7 @@ namespace data
 	const uint8_t COST_SSU_DIRECT = 9;
 	const uint8_t COST_SSU_THROUGH_INTRODUCERS = 11;
 	const uint8_t COST_SSU2_NON_PUBLISHED = 15;
-	
+
 	const size_t MAX_RI_BUFFER_SIZE = 3072; // if RouterInfo exceeds 3K we consider it as malformed, might extend later
 	class RouterInfo: public RoutingDestination
 	{
@@ -146,11 +146,11 @@ namespace data
 					return !(*this == other);
 				}
 
-				bool IsNTCP2 () const { return  transportStyle == eTransportNTCP; };
-				bool IsSSU2 () const { return  transportStyle == eTransportSSU2; };
+				bool IsNTCP2 () const { return transportStyle == eTransportNTCP; };
+				bool IsSSU2 () const { return transportStyle == eTransportSSU2; };
 				bool IsPublishedNTCP2 () const { return IsNTCP2 () && published; };
 				bool IsReachableSSU () const { return (bool)ssu && (published || UsesIntroducer ()); };
-				bool UsesIntroducer () const { return  (bool)ssu && !ssu->introducers.empty (); };
+				bool UsesIntroducer () const { return (bool)ssu && !ssu->introducers.empty (); };
 
 				bool IsIntroducer () const { return caps & eSSUIntroducer; };
 				bool IsPeerTesting () const { return caps & eSSUTesting; };
@@ -166,7 +166,7 @@ namespace data
 					Buffer () = default;
 					Buffer (const uint8_t * buf, size_t len);
 			};
-		
+
 			typedef std::vector<std::shared_ptr<Address> > Addresses;
 
 			RouterInfo (const std::string& fullPath);
@@ -181,7 +181,7 @@ namespace data
 			std::string GetIdentHashBase64 () const { return GetIdentHash ().ToBase64 (); };
 			uint64_t GetTimestamp () const { return m_Timestamp; };
 			int GetVersion () const { return m_Version; };
-			virtual void SetProperty (const std::string& key, const std::string& value) {}; 
+			virtual void SetProperty (const std::string& key, const std::string& value) {};
 			virtual void ClearProperties () {};
 			Addresses& GetAddresses () { return *m_Addresses; }; // should be called for local RI only, otherwise must return shared_ptr
 			std::shared_ptr<const Address> GetNTCP2AddressWithStaticKey (const uint8_t * key) const;
@@ -232,6 +232,7 @@ namespace data
 			bool IsExtraBandwidth () const { return m_Caps & RouterInfo::eExtraBandwidth; };
 			bool IsEligibleFloodfill () const;
 			bool IsPeerTesting (bool v4) const;
+			bool IsSSU2PeerTesting (bool v4) const;
 			bool IsIntroducer (bool v4) const;
 
 			uint8_t GetCaps () const { return m_Caps; };
@@ -272,7 +273,7 @@ namespace data
 			void SetBufferLen (size_t len) { m_BufferLen = len; };
 			void RefreshTimestamp ();
 			const Addresses& GetAddresses () const { return *m_Addresses; };
-		
+
 		private:
 
 			bool LoadFile (const std::string& fullPath);
@@ -285,7 +286,7 @@ namespace data
 			template<typename Filter>
 			std::shared_ptr<const Address> GetAddress (Filter filter) const;
 			virtual std::shared_ptr<Buffer> NewBuffer () const;
-		
+
 		private:
 
 			FamilyID m_FamilyID;
@@ -309,22 +310,22 @@ namespace data
 			void CreateBuffer (const PrivateKeys& privateKeys);
 			void UpdateCaps (uint8_t caps);
 
-			void SetProperty (const std::string& key, const std::string& value) override; 
-			void DeleteProperty (const std::string& key); 
-			std::string GetProperty (const std::string& key) const; 
+			void SetProperty (const std::string& key, const std::string& value) override;
+			void DeleteProperty (const std::string& key);
+			std::string GetProperty (const std::string& key) const;
 			void ClearProperties () override { m_Properties.clear (); };
-			
+
 		private:
 
 			void WriteToStream (std::ostream& s) const;
 			void UpdateCapsProperty ();
 			void WriteString (const std::string& str, std::ostream& s) const;
 			std::shared_ptr<Buffer> NewBuffer () const override;
-			
+
 		private:
 
-			std::map<std::string, std::string> m_Properties;		
-	};	
+			std::map<std::string, std::string> m_Properties;
+	};
 }
 }
 

libi2pd/SSU.cpp

@@ -273,14 +273,14 @@ namespace transport
 	void SSUServer::HandleReceivedFrom (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet)
 	{
 		if (!ecode
-		    || ecode == boost::asio::error::connection_refused
-		    || ecode == boost::asio::error::connection_reset
-		    || ecode == boost::asio::error::network_unreachable
-		    || ecode == boost::asio::error::host_unreachable
+			|| ecode == boost::asio::error::connection_refused
+			|| ecode == boost::asio::error::connection_reset
+			|| ecode == boost::asio::error::network_unreachable
+			|| ecode == boost::asio::error::host_unreachable
 #ifdef _WIN32 // windows can throw WinAPI error, which is not handled by ASIO
-		    || ecode.value() == boost::winapi::ERROR_CONNECTION_REFUSED_
-		    || ecode.value() == boost::winapi::ERROR_NETWORK_UNREACHABLE_
-		    || ecode.value() == boost::winapi::ERROR_HOST_UNREACHABLE_
+			|| ecode.value() == boost::winapi::ERROR_CONNECTION_REFUSED_
+			|| ecode.value() == boost::winapi::ERROR_NETWORK_UNREACHABLE_
+			|| ecode.value() == boost::winapi::ERROR_HOST_UNREACHABLE_
 #endif
 		)
 		// just try continue reading when received ICMP response otherwise socket can crash,
@@ -332,14 +332,14 @@ namespace transport
 	void SSUServer::HandleReceivedFromV6 (const boost::system::error_code& ecode, std::size_t bytes_transferred, SSUPacket * packet)
 	{
 		if (!ecode
-		    || ecode == boost::asio::error::connection_refused
-		    || ecode == boost::asio::error::connection_reset
-		    || ecode == boost::asio::error::network_unreachable
-		    || ecode == boost::asio::error::host_unreachable
+			|| ecode == boost::asio::error::connection_refused
+			|| ecode == boost::asio::error::connection_reset
+			|| ecode == boost::asio::error::network_unreachable
+			|| ecode == boost::asio::error::host_unreachable
 #ifdef _WIN32 // windows can throw WinAPI error, which is not handled by ASIO
-		    || ecode.value() == boost::winapi::ERROR_CONNECTION_REFUSED_
-		    || ecode.value() == boost::winapi::ERROR_NETWORK_UNREACHABLE_
-		    || ecode.value() == boost::winapi::ERROR_HOST_UNREACHABLE_
+			|| ecode.value() == boost::winapi::ERROR_CONNECTION_REFUSED_
+			|| ecode.value() == boost::winapi::ERROR_NETWORK_UNREACHABLE_
+			|| ecode.value() == boost::winapi::ERROR_HOST_UNREACHABLE_
 #endif
 		)
 		// just try continue reading when received ICMP response otherwise socket can crash,
@@ -582,7 +582,7 @@ namespace transport
 							"] through introducer ", introducer->iHost, ":", introducer->iPort);
 					session->WaitForIntroduction ();
 					if ((address->host.is_v4 () && i2p::context.GetStatus () == eRouterStatusFirewalled) ||
-					    (address->host.is_v6 () && i2p::context.GetStatusV6 () == eRouterStatusFirewalled))
+						(address->host.is_v6 () && i2p::context.GetStatusV6 () == eRouterStatusFirewalled))
 					{
 						uint8_t buf[1];
 						Send (buf, 0, remoteEndpoint); // send HolePunch
@@ -676,7 +676,7 @@ namespace transport
 		for (const auto& s : sessions)
 		{
 			if (s.second->GetRelayTag () && s.second->GetState () == eSessionStateEstablished &&
-			    ts < s.second->GetCreationTime () + SSU_TO_INTRODUCER_SESSION_EXPIRATION)
+				ts < s.second->GetCreationTime () + SSU_TO_INTRODUCER_SESSION_EXPIRATION)
 				ret.push_back (s.second);
 			else if (s.second->GetRemoteIdentity ())
 				excluded.insert (s.second->GetRemoteIdentity ()->GetIdentHash ());

libi2pd/SSU2.h

@@ -9,237 +9,26 @@
 #ifndef SSU2_H__
 #define SSU2_H__
 
-#include <memory>
-#include <functional>
-#include <map>
-#include <set>
 #include <unordered_map>
-#include <boost/asio.hpp>
-#include "Crypto.h"
-#include "RouterInfo.h"
-#include "TransportSession.h"
+#include "util.h"
+#include "SSU2Session.h"
 
 namespace i2p
 {
 namespace transport
 {
-	const int SSU2_CONNECT_TIMEOUT = 5; // 5 seconds
-	const int SSU2_TERMINATION_TIMEOUT = 330; // 5.5 minutes
 	const int SSU2_TERMINATION_CHECK_TIMEOUT = 30; // 30 seconds
-	const int SSU2_TOKEN_EXPIRATION_TIMEOUT = 9; // in seconds
-	const int SSU2_RELAY_NONCE_EXPIRATION_TIMEOUT = 10; // in seconds
 	const size_t SSU2_SOCKET_RECEIVE_BUFFER_SIZE = 0x1FFFF; // 128K
 	const size_t SSU2_SOCKET_SEND_BUFFER_SIZE = 0x1FFFF; // 128K
-	const size_t SSU2_MTU = 1488;
-	const size_t SSU2_MAX_PAYLOAD_SIZE = SSU2_MTU - 32;
-	const int SSU2_RESEND_INTERVAL = 3; // in seconds
-	const int SSU2_MAX_NUM_RESENDS = 5;
-	const int SSU2_INCOMPLETE_MESSAGES_CLEANUP_TIMEOUT = 30; // in seconds	
-	const size_t SSU2_MAX_WINDOW_SIZE = 128; // in packets
-	
-	enum SSU2MessageType
-	{
-		eSSU2SessionRequest = 0,
-		eSSU2SessionCreated = 1,
-		eSSU2SessionConfirmed = 2,
-		eSSU2Data = 6,
-		eSSU2Retry = 9,
-		eSSU2TokenRequest = 10
-	};
-
-	enum SSU2BlockType
-	{
-		eSSU2BlkDateTime = 0,
-		eSSU2BlkOptions, // 1
-		eSSU2BlkRouterInfo, // 2
-		eSSU2BlkI2NPMessage, // 3
-		eSSU2BlkFirstFragment, // 4
-		eSSU2BlkFollowOnFragment, // 5
-		eSSU2BlkTermination, // 6
-		eSSU2BlkRelayRequest, // 7
-		eSSU2BlkRelayResponse, // 8
-		eSSU2BlkRelayIntro, // 9
-		eSSU2BlkPeerTest, // 10
-		eSSU2BlkNextNonce, // 11
-		eSSU2BlkAck, // 12
-		eSSU2BlkAddress, // 13
-		eSSU2BlkIntroKey, // 14
-		eSSU2BlkRelayTagRequest, // 15
-		eSSU2BlkRelayTag, // 16
-		eSSU2BlkNewToken, // 17
-		eSSU2BlkPathChallenge, // 18
-		eSSU2BlkPathResponse, // 19
-		eSSU2BlkFirstPacketNumber, // 20
-		eSSU2BlkPadding = 254
-	};
-
-	enum SSU2SessionState
-	{
-		eSSU2SessionStateUnknown,
-		eSSU2SessionStateIntroduced,
-		eSSU2SessionStateEstablished,
-		eSSU2SessionStateTerminated,
-		eSSU2SessionStateFailed
-	};
-
-	struct SSU2IncompleteMessage
-	{
-		struct Fragment
-		{
-			uint8_t buf[SSU2_MTU];
-			size_t len;
-			bool isLast;
-		};
 		
-		std::shared_ptr<I2NPMessage> msg;
-		int nextFragmentNum;
-		uint32_t lastFragmentInsertTime; // in seconds
-		std::map<int, std::shared_ptr<Fragment> > outOfSequenceFragments; 
-	};	
-	
-	// RouterInfo flags
-	const uint8_t SSU2_ROUTER_INFO_FLAG_REQUEST_FLOOD = 0x01;
-	const uint8_t SSU2_ROUTER_INFO_FLAG_GZIP = 0x02;	
-	
-	class SSU2Server;
-	class SSU2Session: public TransportSession, public std::enable_shared_from_this<SSU2Session>
-	{
-		union Header
-		{
-			uint64_t ll[2];
-			uint8_t buf[16];
-			struct
-			{
-				uint64_t connID;
-				uint32_t packetNum;
-				uint8_t type;
-				uint8_t flags[3];
-			} h;
-		};
-
-		struct SentPacket
-		{
-			uint8_t payload[SSU2_MAX_PAYLOAD_SIZE];
-			size_t payloadSize = 0;    
-			uint32_t nextResendTime; // in seconds
-			int numResends = 0;
-		};	
-
-		struct SessionConfirmedFragment
-		{
-			Header header;
-			uint8_t payload[SSU2_MAX_PAYLOAD_SIZE];
-			size_t payloadSize;
-		};	
-
-		typedef std::function<void ()> OnEstablished;
-		
-		public:
-
-			SSU2Session (SSU2Server& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter = nullptr,
-				std::shared_ptr<const i2p::data::RouterInfo::Address> addr = nullptr);
-			~SSU2Session ();
-
-			void SetRemoteEndpoint (const boost::asio::ip::udp::endpoint& ep) { m_RemoteEndpoint = ep; };
-			const boost::asio::ip::udp::endpoint& GetRemoteEndpoint () const { return m_RemoteEndpoint; };
-			void SetOnEstablished (OnEstablished e) { m_OnEstablished = e; };
-			
-			void Connect ();
-			bool Introduce (std::shared_ptr<SSU2Session> session, uint32_t relayTag);
-			void Terminate ();
-			void TerminateByTimeout ();
-			void CleanUp (uint64_t ts);
-			void FlushData ();
-			void Done () override;
-			void SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs) override;
-			void Resend (uint64_t ts);
-			bool IsEstablished () const { return m_State == eSSU2SessionStateEstablished; };
-			uint64_t GetConnID () const { return m_SourceConnID; };
-			SSU2SessionState GetState () const { return m_State; };
-			void SetState (SSU2SessionState state) { m_State = state; };
-			
-			bool ProcessFirstIncomingMessage (uint64_t connID, uint8_t * buf, size_t len);
-			bool ProcessSessionCreated (uint8_t * buf, size_t len);
-			bool ProcessSessionConfirmed (uint8_t * buf, size_t len);
-			bool ProcessRetry (uint8_t * buf, size_t len);
-			void ProcessData (uint8_t * buf, size_t len);
-			
-		private:
-
-			void Established ();
-			void PostI2NPMessages (std::vector<std::shared_ptr<I2NPMessage> > msgs);
-			bool SendQueue ();
-			void SendFragmentedMessage (std::shared_ptr<I2NPMessage> msg);
-			
-			void ProcessSessionRequest (Header& header, uint8_t * buf, size_t len);
-			void ProcessTokenRequest (Header& header, uint8_t * buf, size_t len);
-			
-			void SendSessionRequest (uint64_t token = 0);
-			void SendSessionCreated (const uint8_t * X);
-			void SendSessionConfirmed (const uint8_t * Y);
-			void KDFDataPhase (uint8_t * keydata_ab, uint8_t * keydata_ba);
-			void SendTokenRequest ();
-			void SendRetry ();
-			uint32_t SendData (const uint8_t * buf, size_t len); // returns packet num
-			void SendQuickAck ();
-			void SendTermination ();
-			
-			void HandlePayload (const uint8_t * buf, size_t len); 
-			void HandleAck (const uint8_t * buf, size_t len);
-			void HandleAckRange (uint32_t firstPacketNum, uint32_t lastPacketNum);
-			bool ExtractEndpoint (const uint8_t * buf, size_t size, boost::asio::ip::udp::endpoint& ep);
-			size_t CreateEndpoint (uint8_t * buf, size_t len, const boost::asio::ip::udp::endpoint& ep);
-			std::shared_ptr<const i2p::data::RouterInfo> ExtractRouterInfo (const uint8_t * buf, size_t size);
-			void CreateNonce (uint64_t seqn, uint8_t * nonce);
-			bool UpdateReceivePacketNum (uint32_t packetNum); // for Ack, returns false if duplicate
-			void HandleFirstFragment (const uint8_t * buf, size_t len);
-			void HandleFollowOnFragment (const uint8_t * buf, size_t len);
-			bool ConcatOutOfSequenceFragments (std::shared_ptr<SSU2IncompleteMessage> m); // true if message complete
-			void HandleRelayRequest (const uint8_t * buf, size_t len);
-			void HandleRelayIntro (const uint8_t * buf, size_t len);
-			void HandleRelayResponse (const uint8_t * buf, size_t len);
-			
-			size_t CreateAddressBlock (const boost::asio::ip::udp::endpoint& ep, uint8_t * buf, size_t len);
-			size_t CreateAckBlock (uint8_t * buf, size_t len);
-			size_t CreatePaddingBlock (uint8_t * buf, size_t len, size_t minSize = 0);
-			size_t CreateI2NPBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage>&& msg);
-			size_t CreateFirstFragmentBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage> msg);
-			size_t CreateFollowOnFragmentBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage> msg, uint8_t& fragmentNum, uint32_t msgID);
-			size_t CreateRelayIntroBlock (uint8_t * buf, size_t len, const uint8_t * introData, size_t introDataLen);
-			size_t CreateRelayResponseBlock (uint8_t * buf, size_t len, uint32_t nonce); // Charlie
-						
-		private:
-
-			SSU2Server& m_Server;
-			std::shared_ptr<i2p::crypto::X25519Keys> m_EphemeralKeys;
-			std::unique_ptr<i2p::crypto::NoiseSymmetricState> m_NoiseState;
-			std::unique_ptr<SessionConfirmedFragment> m_SessionConfirmedFragment1; // for Bob if applicable
-			std::shared_ptr<const i2p::data::RouterInfo::Address> m_Address;
-			boost::asio::ip::udp::endpoint m_RemoteEndpoint;
-			uint64_t m_DestConnID, m_SourceConnID;
-			SSU2SessionState m_State;
-			uint8_t m_KeyDataSend[64], m_KeyDataReceive[64]; 
-			uint32_t m_SendPacketNum, m_ReceivePacketNum;
-			std::set<uint32_t> m_OutOfSequencePackets; // packet nums > receive packet num
-			std::map<uint32_t, std::shared_ptr<SentPacket> > m_SentPackets; // packetNum -> packet
-			std::map<uint32_t, std::shared_ptr<SSU2IncompleteMessage> > m_IncompleteMessages; // I2NP
-			std::map<uint32_t, std::pair <std::shared_ptr<SSU2Session>, uint64_t > > m_RelaySessions; // nonce->(Alice, timestamp) for Bob or nonce->(Charlie, timestamp) for Alice 
-			std::list<std::shared_ptr<I2NPMessage> > m_SendQueue;
-			i2p::I2NPMessagesHandler m_Handler;
-			bool m_IsDataReceived;
-			size_t m_WindowSize;
-			uint32_t m_RelayTag; // between Bob and Charlie
-			OnEstablished m_OnEstablished; // callback from Established
-	};
-
-	class SSU2Server:  private i2p::util::RunnableServiceWithWork
+	class SSU2Server: private i2p::util::RunnableServiceWithWork
 	{
 		struct Packet
 		{
-			uint8_t buf[SSU2_MTU]; 
+			uint8_t buf[SSU2_MTU];
 			size_t len;
 			boost::asio::ip::udp::endpoint from;
-		};	
+		};
 
 		class ReceiveService: public i2p::util::RunnableService
 		{
@@ -249,8 +38,8 @@ namespace transport
 				boost::asio::io_service& GetService () { return GetIOService (); };
 				void Start () { StartIOService (); };
 				void Stop () { StopIOService (); };
-		};	
-		
+		};
+
 		public:
 
 			SSU2Server ();
@@ -259,34 +48,35 @@ namespace transport
 			void Start ();
 			void Stop ();
 			boost::asio::io_service& GetService () { return GetIOService (); };
-			
+
 			void AddSession (std::shared_ptr<SSU2Session> session);
 			void RemoveSession (uint64_t connID);
 			void AddSessionByRouterHash (std::shared_ptr<SSU2Session> session);
 			void AddPendingOutgoingSession (std::shared_ptr<SSU2Session> session);
-
+			std::shared_ptr<SSU2Session> FindSession (const i2p::data::IdentHash& ident) const;
+		
 			void AddRelay (uint32_t tag, std::shared_ptr<SSU2Session> relay);
-			void RemoveRelay (uint32_t tag);	
+			void RemoveRelay (uint32_t tag);
 			std::shared_ptr<SSU2Session> FindRelaySession (uint32_t tag);
-			
-			void Send (const uint8_t * header, size_t headerLen, const uint8_t * payload, size_t payloadLen, 
+
+			void Send (const uint8_t * header, size_t headerLen, const uint8_t * payload, size_t payloadLen,
 				const boost::asio::ip::udp::endpoint& to);
-			void Send (const uint8_t * header, size_t headerLen, const uint8_t * headerX, size_t headerXLen, 
+			void Send (const uint8_t * header, size_t headerLen, const uint8_t * headerX, size_t headerXLen,
 				const uint8_t * payload, size_t payloadLen, const boost::asio::ip::udp::endpoint& to);
-			void SendHolePunch (const boost::asio::ip::udp::endpoint& to);
-			
+
 			bool CreateSession (std::shared_ptr<const i2p::data::RouterInfo> router,
 				std::shared_ptr<const i2p::data::RouterInfo::Address> address);
-
+			bool StartPeerTest (std::shared_ptr<const i2p::data::RouterInfo> router, bool v4);
+			
 			void UpdateOutgoingToken (const boost::asio::ip::udp::endpoint& ep, uint64_t token, uint32_t exp);
 			uint64_t FindOutgoingToken (const boost::asio::ip::udp::endpoint& ep) const;
 			uint64_t GetIncomingToken (const boost::asio::ip::udp::endpoint& ep);
-			
+
 		private:
 
 			boost::asio::ip::udp::socket& OpenSocket (const boost::asio::ip::udp::endpoint& localEndpoint);
 			void Receive (boost::asio::ip::udp::socket& socket);
-			void HandleReceivedFrom (const boost::system::error_code& ecode, size_t bytes_transferred, 
+			void HandleReceivedFrom (const boost::system::error_code& ecode, size_t bytes_transferred,
 				Packet * packet, boost::asio::ip::udp::socket& socket);
 			void HandleReceivedPacket (Packet * packet);
 			void HandleReceivedPackets (std::vector<Packet *> packets);
@@ -300,16 +90,16 @@ namespace transport
 
 			void ConnectThroughIntroducer (std::shared_ptr<const i2p::data::RouterInfo> router,
 				std::shared_ptr<const i2p::data::RouterInfo::Address> address);
-			
+
 		private:
 
-			ReceiveService m_ReceiveService; 
+			ReceiveService m_ReceiveService;
 			boost::asio::ip::udp::socket m_SocketV4, m_SocketV6;
 			std::unordered_map<uint64_t, std::shared_ptr<SSU2Session> > m_Sessions;
 			std::map<i2p::data::IdentHash, std::shared_ptr<SSU2Session> > m_SessionsByRouterHash;
 			std::map<boost::asio::ip::udp::endpoint, std::shared_ptr<SSU2Session> > m_PendingOutgoingSessions;
 			std::map<boost::asio::ip::udp::endpoint, std::pair<uint64_t, uint32_t> > m_IncomingTokens, m_OutgoingTokens; // remote endpoint -> (token, expires in seconds)
-			std::map<uint32_t, std::shared_ptr<SSU2Session> > m_Relays; // we are introducer, relay tag -> session 
+			std::map<uint32_t, std::shared_ptr<SSU2Session> > m_Relays; // we are introducer, relay tag -> session
 			i2p::util::MemoryPoolMt<Packet> m_PacketsPool;
 			boost::asio::deadline_timer m_TerminationTimer, m_ResendTimer;
 			std::shared_ptr<SSU2Session> m_LastSession;
@@ -317,8 +107,8 @@ namespace transport
 		public:
 
 			// for HTTP/I2PControl
-			const decltype(m_Sessions)& GetSSU2Sessions () const { return m_Sessions; };	
-	};	
+			const decltype(m_Sessions)& GetSSU2Sessions () const { return m_Sessions; };
+	};
 }
 }
 

libi2pd/SSU2Session.h

@@ -0,0 +1,273 @@
+/*
+* Copyright (c) 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
+*/
+
+#ifndef SSU2_SESSION_H__
+#define SSU2_SESSION_H__
+
+#include <memory>
+#include <functional>
+#include <map>
+#include <set>
+#include <list>
+#include <boost/asio.hpp>
+#include "Crypto.h"
+#include "RouterInfo.h"
+#include "TransportSession.h"
+
+namespace i2p
+{
+namespace transport
+{
+	const int SSU2_CONNECT_TIMEOUT = 5; // 5 seconds
+	const int SSU2_TERMINATION_TIMEOUT = 330; // 5.5 minutes
+	const int SSU2_TOKEN_EXPIRATION_TIMEOUT = 9; // in seconds
+	const int SSU2_RELAY_NONCE_EXPIRATION_TIMEOUT = 10; // in seconds
+	const int SSU2_PEER_TEST_EXPIRATION_TIMEOUT = 60; // 60 seconds
+	const size_t SSU2_MTU = 1488;
+	const size_t SSU2_MAX_PAYLOAD_SIZE = SSU2_MTU - 32;
+	const int SSU2_RESEND_INTERVAL = 3; // in seconds
+	const int SSU2_MAX_NUM_RESENDS = 5;
+	const int SSU2_INCOMPLETE_MESSAGES_CLEANUP_TIMEOUT = 30; // in seconds
+	const size_t SSU2_MAX_WINDOW_SIZE = 128; // in packets
+
+	enum SSU2MessageType
+	{
+		eSSU2SessionRequest = 0,
+		eSSU2SessionCreated = 1,
+		eSSU2SessionConfirmed = 2,
+		eSSU2Data = 6,
+		eSSU2PeerTest = 7,
+		eSSU2Retry = 9,
+		eSSU2TokenRequest = 10,
+		eSSU2HolePunch = 11
+	};
+
+	enum SSU2BlockType
+	{
+		eSSU2BlkDateTime = 0,
+		eSSU2BlkOptions, // 1
+		eSSU2BlkRouterInfo, // 2
+		eSSU2BlkI2NPMessage, // 3
+		eSSU2BlkFirstFragment, // 4
+		eSSU2BlkFollowOnFragment, // 5
+		eSSU2BlkTermination, // 6
+		eSSU2BlkRelayRequest, // 7
+		eSSU2BlkRelayResponse, // 8
+		eSSU2BlkRelayIntro, // 9
+		eSSU2BlkPeerTest, // 10
+		eSSU2BlkNextNonce, // 11
+		eSSU2BlkAck, // 12
+		eSSU2BlkAddress, // 13
+		eSSU2BlkIntroKey, // 14
+		eSSU2BlkRelayTagRequest, // 15
+		eSSU2BlkRelayTag, // 16
+		eSSU2BlkNewToken, // 17
+		eSSU2BlkPathChallenge, // 18
+		eSSU2BlkPathResponse, // 19
+		eSSU2BlkFirstPacketNumber, // 20
+		eSSU2BlkPadding = 254
+	};
+
+	enum SSU2SessionState
+	{
+		eSSU2SessionStateUnknown,
+		eSSU2SessionStateIntroduced,
+		eSSU2SessionStatePeerTest,
+		eSSU2SessionStateEstablished,
+		eSSU2SessionStateTerminated,
+		eSSU2SessionStateFailed
+	};
+
+	enum SSU2PeerTestCode
+	{
+		eSSU2PeerTestCodeAccept = 0,
+		eSSU2PeerTestCodeBobReasonUnspecified = 1,
+		eSSU2PeerTestCodeBobNoCharlieAvailable = 2,
+		eSSU2PeerTestCodeBobLimitExceeded = 3,
+		eSSU2PeerTestCodeBobSignatureFailure = 4,
+		eSSU2PeerTestCodeCharlieReasonUnspecified = 64,
+		eSSU2PeerTestCodeCharlieUnsupportedAddress = 65,
+		eSSU2PeerTestCodeCharlieLimitExceeded = 66,
+		eSSU2PeerTestCodeCharlieSignatureFailure = 67,
+		eSSU2PeerTestCodeCharlieAliceIsAlreadyConnected = 68,
+		eSSU2PeerTestCodeCharlieAliceIsBanned = 69,
+		eSSU2PeerTestCodeCharlieAliceIsUnknown = 70,
+		eSSU2PeerTestCodeUnspecified = 128
+	};	
+
+	struct SSU2IncompleteMessage
+	{
+		struct Fragment
+		{
+			uint8_t buf[SSU2_MTU];
+			size_t len;
+			bool isLast;
+		};
+
+		std::shared_ptr<I2NPMessage> msg;
+		int nextFragmentNum;
+		uint32_t lastFragmentInsertTime; // in seconds
+		std::map<int, std::shared_ptr<Fragment> > outOfSequenceFragments;
+	};
+
+	// RouterInfo flags
+	const uint8_t SSU2_ROUTER_INFO_FLAG_REQUEST_FLOOD = 0x01;
+	const uint8_t SSU2_ROUTER_INFO_FLAG_GZIP = 0x02;
+
+	class SSU2Server;
+	class SSU2Session: public TransportSession, public std::enable_shared_from_this<SSU2Session>
+	{
+		union Header
+		{
+			uint64_t ll[2];
+			uint8_t buf[16];
+			struct
+			{
+				uint64_t connID;
+				uint32_t packetNum;
+				uint8_t type;
+				uint8_t flags[3];
+			} h;
+		};
+
+		struct SentPacket
+		{
+			uint8_t payload[SSU2_MAX_PAYLOAD_SIZE];
+			size_t payloadSize = 0;
+			uint32_t nextResendTime; // in seconds
+			int numResends = 0;
+		};
+
+		struct SessionConfirmedFragment
+		{
+			Header header;
+			uint8_t payload[SSU2_MAX_PAYLOAD_SIZE];
+			size_t payloadSize;
+		};
+
+		typedef std::function<void ()> OnEstablished;
+
+		public:
+
+			SSU2Session (SSU2Server& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter = nullptr,
+				std::shared_ptr<const i2p::data::RouterInfo::Address> addr = nullptr);
+			~SSU2Session ();
+
+			void SetRemoteEndpoint (const boost::asio::ip::udp::endpoint& ep) { m_RemoteEndpoint = ep; };
+			const boost::asio::ip::udp::endpoint& GetRemoteEndpoint () const { return m_RemoteEndpoint; };
+			void SetOnEstablished (OnEstablished e) { m_OnEstablished = e; };
+
+			void Connect ();
+			bool Introduce (std::shared_ptr<SSU2Session> session, uint32_t relayTag);
+			void SendPeerTest (); // Alice, Data message
+			void Terminate ();
+			void TerminateByTimeout ();
+			void CleanUp (uint64_t ts);
+			void FlushData ();
+			void Done () override;
+			void SendI2NPMessages (const std::vector<std::shared_ptr<I2NPMessage> >& msgs) override;
+			void Resend (uint64_t ts);
+			bool IsEstablished () const { return m_State == eSSU2SessionStateEstablished; };
+			uint64_t GetConnID () const { return m_SourceConnID; };
+			SSU2SessionState GetState () const { return m_State; };
+			void SetState (SSU2SessionState state) { m_State = state; };
+
+			bool ProcessFirstIncomingMessage (uint64_t connID, uint8_t * buf, size_t len);
+			bool ProcessSessionCreated (uint8_t * buf, size_t len);
+			bool ProcessSessionConfirmed (uint8_t * buf, size_t len);
+			bool ProcessRetry (uint8_t * buf, size_t len);
+			bool ProcessHolePunch (uint8_t * buf, size_t len);
+			bool ProcessPeerTest (uint8_t * buf, size_t len);
+			void ProcessData (uint8_t * buf, size_t len);
+
+		private:
+
+			void Established ();
+			void PostI2NPMessages (std::vector<std::shared_ptr<I2NPMessage> > msgs);
+			bool SendQueue ();
+			void SendFragmentedMessage (std::shared_ptr<I2NPMessage> msg);
+
+			void ProcessSessionRequest (Header& header, uint8_t * buf, size_t len);
+			void ProcessTokenRequest (Header& header, uint8_t * buf, size_t len);
+
+			void SendSessionRequest (uint64_t token = 0);
+			void SendSessionCreated (const uint8_t * X);
+			void SendSessionConfirmed (const uint8_t * Y);
+			void KDFDataPhase (uint8_t * keydata_ab, uint8_t * keydata_ba);
+			void SendTokenRequest ();
+			void SendRetry ();
+			uint32_t SendData (const uint8_t * buf, size_t len); // returns packet num
+			void SendQuickAck ();
+			void SendTermination ();
+			void SendHolePunch (uint32_t nonce, const boost::asio::ip::udp::endpoint& ep, const uint8_t * introKey);
+			void SendPeerTest (uint8_t msg, const uint8_t * signedData, size_t signedDataLen, const uint8_t * introKey); // PeerTest message 
+			
+			void HandlePayload (const uint8_t * buf, size_t len);
+			void HandleAck (const uint8_t * buf, size_t len);
+			void HandleAckRange (uint32_t firstPacketNum, uint32_t lastPacketNum);
+			bool ExtractEndpoint (const uint8_t * buf, size_t size, boost::asio::ip::udp::endpoint& ep);
+			size_t CreateEndpoint (uint8_t * buf, size_t len, const boost::asio::ip::udp::endpoint& ep);
+			std::shared_ptr<const i2p::data::RouterInfo::Address> FindLocalAddress () const;
+			std::shared_ptr<const i2p::data::RouterInfo> ExtractRouterInfo (const uint8_t * buf, size_t size);
+			void CreateNonce (uint64_t seqn, uint8_t * nonce);
+			bool UpdateReceivePacketNum (uint32_t packetNum); // for Ack, returns false if duplicate
+			void HandleFirstFragment (const uint8_t * buf, size_t len);
+			void HandleFollowOnFragment (const uint8_t * buf, size_t len);
+			bool ConcatOutOfSequenceFragments (std::shared_ptr<SSU2IncompleteMessage> m); // true if message complete
+			void HandleRelayRequest (const uint8_t * buf, size_t len);
+			void HandleRelayIntro (const uint8_t * buf, size_t len);
+			void HandleRelayResponse (const uint8_t * buf, size_t len);
+			void HandlePeerTest (const uint8_t * buf, size_t len);
+
+			size_t CreateAddressBlock (uint8_t * buf, size_t len, const boost::asio::ip::udp::endpoint& ep);
+			size_t CreateRouterInfoBlock (uint8_t * buf, size_t len, std::shared_ptr<const i2p::data::RouterInfo> r);
+			size_t CreateAckBlock (uint8_t * buf, size_t len);
+			size_t CreatePaddingBlock (uint8_t * buf, size_t len, size_t minSize = 0);
+			size_t CreateI2NPBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage>&& msg);
+			size_t CreateFirstFragmentBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage> msg);
+			size_t CreateFollowOnFragmentBlock (uint8_t * buf, size_t len, std::shared_ptr<I2NPMessage> msg, uint8_t& fragmentNum, uint32_t msgID);
+			size_t CreateRelayIntroBlock (uint8_t * buf, size_t len, const uint8_t * introData, size_t introDataLen);
+			size_t CreateRelayResponseBlock (uint8_t * buf, size_t len, uint32_t nonce); // Charlie
+			size_t CreatePeerTestBlock (uint8_t * buf, size_t len, uint8_t msg, SSU2PeerTestCode code, const uint8_t * routerHash, const uint8_t * signedData, size_t signedDataLen);
+			size_t CreatePeerTestBlock (uint8_t * buf, size_t len, uint32_t nonce); // Alice
+
+		private:
+
+			SSU2Server& m_Server;
+			std::shared_ptr<i2p::crypto::X25519Keys> m_EphemeralKeys;
+			std::unique_ptr<i2p::crypto::NoiseSymmetricState> m_NoiseState;
+			std::unique_ptr<SessionConfirmedFragment> m_SessionConfirmedFragment1; // for Bob if applicable
+			std::shared_ptr<const i2p::data::RouterInfo::Address> m_Address;
+			boost::asio::ip::udp::endpoint m_RemoteEndpoint;
+			uint64_t m_DestConnID, m_SourceConnID;
+			SSU2SessionState m_State;
+			uint8_t m_KeyDataSend[64], m_KeyDataReceive[64];
+			uint32_t m_SendPacketNum, m_ReceivePacketNum;
+			std::set<uint32_t> m_OutOfSequencePackets; // packet nums > receive packet num
+			std::map<uint32_t, std::shared_ptr<SentPacket> > m_SentPackets; // packetNum -> packet
+			std::map<uint32_t, std::shared_ptr<SSU2IncompleteMessage> > m_IncompleteMessages; // I2NP
+			std::map<uint32_t, std::pair <std::shared_ptr<SSU2Session>, uint64_t > > m_RelaySessions; // nonce->(Alice, timestamp) for Bob or nonce->(Charlie, timestamp) for Alice
+			std::map<uint32_t, std::pair <std::shared_ptr<SSU2Session>, uint64_t > > m_PeerTests; // same as for relay sessions
+			std::list<std::shared_ptr<I2NPMessage> > m_SendQueue;
+			i2p::I2NPMessagesHandler m_Handler;
+			bool m_IsDataReceived;
+			size_t m_WindowSize;
+			uint32_t m_RelayTag; // between Bob and Charlie
+			OnEstablished m_OnEstablished; // callback from Established
+	};
+
+	inline uint64_t CreateHeaderMask (const uint8_t * kh, const uint8_t * nonce)
+	{
+		uint64_t data = 0;
+		i2p::crypto::ChaCha20 ((uint8_t *)&data, 8, kh, nonce, (uint8_t *)&data);
+		return data;
+	}
+}
+}
+
+#endif

libi2pd/SSUData.cpp

@@ -171,7 +171,7 @@ namespace transport
 				return;
 			}
 
-			//  find message with msgID
+			// find message with msgID
 			auto it = m_IncompleteMessages.find (msgID);
 			if (it == m_IncompleteMessages.end ())
 			{
@@ -318,7 +318,7 @@ namespace transport
 			sentMessage->numResends = 0;
 		}
 		auto& fragments = sentMessage->fragments;
-		size_t payloadSize = m_PacketSize - sizeof (SSUHeader) - 9; // 9  =  flag + #frg(1) + messageID(4) + frag info (3)
+		size_t payloadSize = m_PacketSize - sizeof (SSUHeader) - 9; // 9 = flag + #frg(1) + messageID(4) + frag info (3)
 		size_t len = msg->GetLength ();
 		uint8_t * msgBuf = msg->GetSSUHeader ();
 

libi2pd/SSUSession.cpp

@@ -296,8 +296,8 @@ namespace transport
 					{
 						LogPrint (eLogWarning, "SSU: Clock adjusted by ", -offset, " seconds");
 						i2p::util::AdjustTimeOffset (-offset);
-					}	
-				}	
+					}
+				}
 				else if (std::abs (offset) > SSU_CLOCK_SKEW)
 				{
 					LogPrint (eLogError, "SSU: Clock skew detected ", offset, ". Check your clock");
@@ -388,11 +388,11 @@ namespace transport
 		// fill extended options, 3 bytes extended options don't change message size
 		bool isV4 = m_RemoteEndpoint.address ().is_v4 ();
 		if ((isV4 && i2p::context.GetStatus () == eRouterStatusOK) ||
-		    (!isV4 && i2p::context.GetStatusV6 () == eRouterStatusOK)) // we don't need relays
+			(!isV4 && i2p::context.GetStatusV6 () == eRouterStatusOK)) // we don't need relays
 		{
 			// tell out peer to now assign relay tag
 			flag = SSU_HEADER_EXTENDED_OPTIONS_INCLUDED;
-			*payload = 2; payload++; //  1 byte length
+			*payload = 2; payload++; // 1 byte length
 			uint16_t flags = 0; // clear EXTENDED_OPTIONS_FLAG_REQUEST_RELAY_TAG
 			htobe16buf (payload, flags);
 			payload += 2;
@@ -1020,7 +1020,7 @@ namespace transport
 		for (auto it = m_RelayRequests.begin (); it != m_RelayRequests.end ();)
 		{
 			if (ts > it->second.second + SSU_CONNECT_TIMEOUT)
-				it =  m_RelayRequests.erase (it);
+				it = m_RelayRequests.erase (it);
 			else
 				++it;
 		}

libi2pd/Signature.cpp

@@ -130,7 +130,7 @@ namespace crypto
 		else
 		{
 			size_t l = 64;
-			uint8_t sig[64];  // temporary buffer for signature. openssl issue #7232
+			uint8_t sig[64]; // temporary buffer for signature. openssl issue #7232
 			EVP_DigestSign (m_MDCtx, sig, &l, buf, len);
 			memcpy (signature, sig, 64);
 		}

libi2pd/Streaming.cpp

@@ -1249,7 +1249,7 @@ namespace stream
 		return s;
 	}
 
-	void  StreamingDestination::SendPing (std::shared_ptr<const i2p::data::LeaseSet> remote)
+	void StreamingDestination::SendPing (std::shared_ptr<const i2p::data::LeaseSet> remote)
 	{
 		auto s = std::make_shared<Stream> (m_Owner->GetService (), *this, remote, 0);
 		s->SendPing ();
@@ -1277,7 +1277,7 @@ namespace stream
 		{
 			m_PacketsPool.CleanUp ();
 			m_I2NPMsgsPool.CleanUp ();
-		}	
+		}
 	}
 
 	bool StreamingDestination::DeleteStream (uint32_t recvStreamID)
@@ -1285,7 +1285,13 @@ namespace stream
 		auto it = m_Streams.find (recvStreamID);
 		if (it == m_Streams.end ())
 			return false;
-		DeleteStream (it->second);
+		auto s = it->second;
+		m_Owner->GetService ().post ([this, s] ()
+			{
+				s->Close (); // try to send FIN
+				s->Terminate (false);
+				DeleteStream (s);
+			});
 		return true;
 	}
 

libi2pd/Timestamp.cpp

@@ -254,6 +254,6 @@ namespace util
 	void AdjustTimeOffset (int64_t offset)
 	{
 		g_TimeOffset += offset;
-	}	
+	}
 }
 }

libi2pd/Timestamp.h

@@ -27,7 +27,7 @@ namespace util
 	void GetCurrentDate (char * date); // returns date as YYYYMMDD string, 9 bytes
 	void GetDateString (uint64_t timestamp, char * date); // timestap is seconds since epoch, returns date as YYYYMMDD string, 9 bytes
 	void AdjustTimeOffset (int64_t offset); // in seconds from current
-	
+
 	class NTPTimeSync
 	{
 		public:

libi2pd/Transports.cpp

@@ -219,7 +219,7 @@ namespace transport
 		}
 		// create SSU2 server
 		if (enableSSU2) m_SSU2Server = new SSU2Server ();
-		
+
 		// bind to interfaces
 		bool ipv4; i2p::config::GetOption("ipv4", ipv4);
 		if (ipv4)
@@ -268,6 +268,7 @@ namespace transport
 
 		// start servers
 		if (m_NTCP2Server) m_NTCP2Server->Start ();
+		if (m_SSU2Server) m_SSU2Server->Start ();
 		if (m_SSUServer)
 		{
 			LogPrint (eLogInfo, "Transports: Start listening UDP port ", ssuPort);
@@ -284,8 +285,7 @@ namespace transport
 			}
 			if (m_SSUServer) DetectExternalIP ();
 		}
-		if (m_SSU2Server) m_SSU2Server->Start ();
-		
+
 		m_PeerCleanupTimer->expires_from_now (boost::posix_time::seconds(5*SESSION_CREATION_TIMEOUT));
 		m_PeerCleanupTimer->async_wait (std::bind (&Transports::HandlePeerCleanupTimer, this, std::placeholders::_1));
 
@@ -307,14 +307,14 @@ namespace transport
 			delete m_SSUServer;
 			m_SSUServer = nullptr;
 		}
-		
+
 		if (m_SSU2Server)
 		{
 			m_SSU2Server->Stop ();
 			delete m_SSU2Server;
 			m_SSU2Server = nullptr;
 		}
-		
+
 		if (m_NTCP2Server)
 		{
 			m_NTCP2Server->Stop ();
@@ -569,7 +569,7 @@ namespace transport
 				}
 				else
 					peer.numAttempts += 2;
-			}	
+			}
 			LogPrint (eLogInfo, "Transports: No compatble NTCP2 or SSU addresses available");
 			i2p::data::netdb.SetUnreachable (ident, true); // we are here because all connection attempts failed
 			peer.Done ();
@@ -654,6 +654,16 @@ namespace transport
 			}
 			if (!statusChanged)
 				LogPrint (eLogWarning, "Transports: Can't find routers for peer test IPv4");
+
+			// SSU2
+			if (m_SSU2Server)
+			{
+				excluded.clear ();
+				excluded.insert (i2p::context.GetIdentHash ());
+				auto router = i2p::data::netdb.GetRandomSSU2PeerTestRouter (true, excluded); // v4
+				if (router)
+					m_SSU2Server->StartPeerTest (router, true);
+			}	
 		}
 		if (ipv6 && i2p::context.SupportsV6 ())
 		{
@@ -681,6 +691,16 @@ namespace transport
 			}
 			if (!statusChanged)
 				LogPrint (eLogWarning, "Transports: Can't find routers for peer test IPv6");
+
+			// SSU2
+			if (m_SSU2Server)
+			{
+				excluded.clear ();
+				excluded.insert (i2p::context.GetIdentHash ());
+				auto router = i2p::data::netdb.GetRandomSSU2PeerTestRouter (false, excluded); // v6
+				if (router)
+					m_SSU2Server->StartPeerTest (router, false);
+			}	
 		}
 	}
 
@@ -829,18 +849,18 @@ namespace transport
 		}
 		return i2p::data::netdb.FindRouter (ident);
 	}
-		
+
 	void Transports::RestrictRoutesToFamilies(const std::set<std::string>& families)
 	{
 		std::lock_guard<std::mutex> lock(m_FamilyMutex);
 		m_TrustedFamilies.clear();
 		for (auto fam : families)
-		{	
+		{
 			boost::to_lower (fam);
 			auto id = i2p::data::netdb.GetFamilies ().GetFamilyID (fam);
-			if (id)	
+			if (id)
 				m_TrustedFamilies.push_back (id);
-		}	
+		}
 	}
 
 	void Transports::RestrictRoutesToRouters(std::set<i2p::data::IdentHash> routers)

libi2pd/Tunnel.cpp

@@ -108,7 +108,7 @@ namespace tunnel
 		else
 		{
 			if (m_Config->IsShort () && m_Config->GetLastHop () &&
-			    m_Config->GetLastHop ()->ident->GetIdentHash () != m_Config->GetLastHop ()->nextIdent)
+				m_Config->GetLastHop ()->ident->GetIdentHash () != m_Config->GetLastHop ()->nextIdent)
 			{
 				// add garlic key/tag for reply
 				uint8_t key[32];
@@ -403,7 +403,7 @@ namespace tunnel
 		return tunnel;
 	}
 
-	std::shared_ptr<TunnelPool> Tunnels::CreateTunnelPool (int numInboundHops, int numOutboundHops, 
+	std::shared_ptr<TunnelPool> Tunnels::CreateTunnelPool (int numInboundHops, int numOutboundHops,
 		int numInboundTunnels, int numOutboundTunnels, int inboundVariance, int outboundVariance)
 	{
 		auto pool = std::make_shared<TunnelPool> (numInboundHops, numOutboundHops, numInboundTunnels, numOutboundTunnels, inboundVariance, outboundVariance);
@@ -822,7 +822,7 @@ namespace tunnel
 
 	template<class TTunnel>
 	std::shared_ptr<TTunnel> Tunnels::CreateTunnel (std::shared_ptr<TunnelConfig> config,
-	    std::shared_ptr<TunnelPool> pool, std::shared_ptr<OutboundTunnel> outboundTunnel)
+		std::shared_ptr<TunnelPool> pool, std::shared_ptr<OutboundTunnel> outboundTunnel)
 	{
 		auto newTunnel = std::make_shared<TTunnel> (config);
 		newTunnel->SetTunnelPool (pool);

libi2pd/Tunnel.h

@@ -215,7 +215,7 @@ namespace tunnel
 			void PostTunnelData (const std::vector<std::shared_ptr<I2NPMessage> >& msgs);
 			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<InboundTunnel> tunnel);
 			void AddPendingTunnel (uint32_t replyMsgID, std::shared_ptr<OutboundTunnel> tunnel);
-			std::shared_ptr<TunnelPool> CreateTunnelPool (int numInboundHops, int numOuboundHops, 
+			std::shared_ptr<TunnelPool> CreateTunnelPool (int numInboundHops, int numOuboundHops,
 				int numInboundTunnels, int numOutboundTunnels, int inboundVariance, int outboundVariance);
 			void DeleteTunnelPool (std::shared_ptr<TunnelPool> pool);
 			void StopTunnelPool (std::shared_ptr<TunnelPool> pool);
@@ -226,7 +226,7 @@ namespace tunnel
 
 			template<class TTunnel>
 			std::shared_ptr<TTunnel> CreateTunnel (std::shared_ptr<TunnelConfig> config,
-			    std::shared_ptr<TunnelPool> pool, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
+				std::shared_ptr<TunnelPool> pool, std::shared_ptr<OutboundTunnel> outboundTunnel = nullptr);
 
 			template<class TTunnel>
 			std::shared_ptr<TTunnel> GetPendingTunnel (uint32_t replyMsgID, const std::map<uint32_t, std::shared_ptr<TTunnel> >& pendingTunnels);

libi2pd/TunnelConfig.cpp

@@ -167,7 +167,7 @@ namespace tunnel
 		memset (clearText + SHORT_REQUEST_RECORD_MORE_FLAGS_OFFSET, 0, 2);
 		clearText[SHORT_REQUEST_RECORD_LAYER_ENCRYPTION_TYPE] = 0; // AES
 		htobe32buf (clearText + SHORT_REQUEST_RECORD_REQUEST_TIME_OFFSET, i2p::util::GetMinutesSinceEpoch ());
-        htobe32buf (clearText + SHORT_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET , 600); // +10 minutes
+		htobe32buf (clearText + SHORT_REQUEST_RECORD_REQUEST_EXPIRATION_OFFSET , 600); // +10 minutes
 		htobe32buf (clearText + SHORT_REQUEST_RECORD_SEND_MSG_ID_OFFSET, replyMsgID);
 		memset (clearText + SHORT_REQUEST_RECORD_PADDING_OFFSET, 0, SHORT_REQUEST_RECORD_CLEAR_TEXT_SIZE - SHORT_REQUEST_RECORD_PADDING_OFFSET);
 		// encrypt

libi2pd/TunnelConfig.h

@@ -91,7 +91,7 @@ namespace tunnel
 
 			TunnelConfig (const std::vector<std::shared_ptr<const i2p::data::IdentityEx> >& peers,
 				uint32_t replyTunnelID, const i2p::data::IdentHash& replyIdent, bool isShort,
-			    i2p::data::RouterInfo::CompatibleTransports farEndTransports = i2p::data::RouterInfo::eAllTransports): // outbound
+				i2p::data::RouterInfo::CompatibleTransports farEndTransports = i2p::data::RouterInfo::eAllTransports): // outbound
 				m_IsShort (isShort), m_FarEndTransports (farEndTransports)
 			{
 				CreatePeers (peers);

libi2pd/TunnelPool.cpp

@@ -30,7 +30,7 @@ namespace tunnel
 		{
 			peers.push_back (r->GetRouterIdentity ());
 			if (r->GetVersion () < i2p::data::NETDB_MIN_SHORT_TUNNEL_BUILD_VERSION ||
-			    r->GetRouterIdentity ()->GetCryptoKeyType () != i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD)
+				r->GetRouterIdentity ()->GetCryptoKeyType () != i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD)
 				isShort = false;
 		}
 	}
@@ -40,11 +40,11 @@ namespace tunnel
 		std::reverse (peers.begin (), peers.end ());
 	}
 
-	TunnelPool::TunnelPool (int numInboundHops, int numOutboundHops, int numInboundTunnels, 
+	TunnelPool::TunnelPool (int numInboundHops, int numOutboundHops, int numInboundTunnels,
 		int numOutboundTunnels, int inboundVariance, int outboundVariance):
 		m_NumInboundHops (numInboundHops), m_NumOutboundHops (numOutboundHops),
 		m_NumInboundTunnels (numInboundTunnels), m_NumOutboundTunnels (numOutboundTunnels),
-		m_InboundVariance (inboundVariance), m_OutboundVariance (outboundVariance), 
+		m_InboundVariance (inboundVariance), m_OutboundVariance (outboundVariance),
 		m_IsActive (true), m_CustomPeerSelector(nullptr)
 	{
 		if (m_NumInboundTunnels > TUNNEL_POOL_MAX_INBOUND_TUNNELS_QUANTITY)
@@ -54,11 +54,11 @@ namespace tunnel
 		if (m_InboundVariance < 0 && m_NumInboundHops + m_InboundVariance <= 0)
 			m_InboundVariance = m_NumInboundHops ? -m_NumInboundHops + 1 : 0;
 		if (m_OutboundVariance < 0 && m_NumOutboundHops + m_OutboundVariance <= 0)
-			m_OutboundVariance = m_NumOutboundHops ? -m_NumOutboundHops + 1 : 0;	
+			m_OutboundVariance = m_NumOutboundHops ? -m_NumOutboundHops + 1 : 0;
 		if (m_InboundVariance > 0 && m_NumInboundHops + m_InboundVariance > STANDARD_NUM_RECORDS)
 			m_InboundVariance = (m_NumInboundHops < STANDARD_NUM_RECORDS) ? STANDARD_NUM_RECORDS - m_NumInboundHops : 0;
 		if (m_OutboundVariance > 0 && m_NumOutboundHops + m_OutboundVariance > STANDARD_NUM_RECORDS)
-			m_OutboundVariance = (m_NumOutboundHops < STANDARD_NUM_RECORDS) ? STANDARD_NUM_RECORDS - m_NumOutboundHops : 0;	
+			m_OutboundVariance = (m_NumOutboundHops < STANDARD_NUM_RECORDS) ? STANDARD_NUM_RECORDS - m_NumOutboundHops : 0;
 		m_NextManageTime = i2p::util::GetSecondsSinceEpoch () + rand () % TUNNEL_POOL_MANAGE_INTERVAL;
 	}
 
@@ -227,7 +227,7 @@ namespace tunnel
 			if (it->IsEstablished () && it != excluded && (compatible & it->GetFarEndTransports ()))
 			{
 				if (it->IsSlow () || (HasLatencyRequirement() && it->LatencyIsKnown() &&
-				    !it->LatencyFitsRange(m_MinLatency, m_MaxLatency)))
+					!it->LatencyFitsRange(m_MinLatency, m_MaxLatency)))
 				{
 					i++; skipped = true;
 					continue;
@@ -423,7 +423,7 @@ namespace tunnel
 			LogPrint (eLogDebug, "Tunnels: Test of ", msgID, " successful. ", dlt, " milliseconds");
 			int numHops = 0;
 			if (test.first) numHops += test.first->GetNumHops ();
-			if (test.second) numHops += test.second->GetNumHops ();	
+			if (test.second) numHops += test.second->GetNumHops ();
 			// restore from test failed state if any
 			if (test.first)
 			{
@@ -431,7 +431,7 @@ namespace tunnel
 					test.first->SetState (eTunnelStateEstablished);
 				// update latency
 				uint64_t latency = 0;
-				if (numHops) latency = dlt*test.first->GetNumHops ()/numHops; 
+				if (numHops) latency = dlt*test.first->GetNumHops ()/numHops;
 				if (!latency) latency = dlt/2;
 				test.first->AddLatencySample(latency);
 			}
@@ -441,7 +441,7 @@ namespace tunnel
 					test.second->SetState (eTunnelStateEstablished);
 				// update latency
 				uint64_t latency = 0;
-				if (numHops) latency = dlt*test.second->GetNumHops ()/numHops; 
+				if (numHops) latency = dlt*test.second->GetNumHops ()/numHops;
 				if (!latency) latency = dlt/2;
 				test.second->AddLatencySample(latency);
 			}
@@ -511,7 +511,7 @@ namespace tunnel
 				return false;
 			}
 			if ((i == numHops - 1) && (!hop->IsV4 () || // doesn't support ipv4
-				(inbound && !hop->IsReachable ())))  // IBGW is not reachable
+				(inbound && !hop->IsReachable ()))) // IBGW is not reachable
 			{
 				auto hop1 = nextHop (prevHop, true);
 				if (hop1) hop = hop1;
@@ -530,25 +530,25 @@ namespace tunnel
 		// calculate num hops
 		int numHops;
 		if (isInbound)
-		{	
-			numHops = m_NumInboundHops; 
+		{
+			numHops = m_NumInboundHops;
 			if (m_InboundVariance)
 			{
 				int offset = rand () % (std::abs (m_InboundVariance) + 1);
 				if (m_InboundVariance < 0) offset = -offset;
 				numHops += offset;
-			}	
+			}
 		}
 		else
-		{	
+		{
 			numHops = m_NumOutboundHops;
 			if (m_OutboundVariance)
 			{
 				int offset = rand () % (std::abs (m_OutboundVariance) + 1);
 				if (m_OutboundVariance < 0) offset = -offset;
 				numHops += offset;
-			}	
-		}	
+			}
+		}
 		// peers is empty
 		if (numHops <= 0) return true;
 		// custom peer selector in use ?
@@ -715,7 +715,7 @@ namespace tunnel
 		auto tunnel = tunnels.CreateInboundTunnel (
 			m_NumOutboundHops > 0 ? std::make_shared<TunnelConfig>(outboundTunnel->GetInvertedPeers (),
 				outboundTunnel->IsShortBuildMessage ()) : nullptr,
-		    shared_from_this (), outboundTunnel);
+				shared_from_this (), outboundTunnel);
 		if (tunnel->IsEstablished ()) // zero hops
 			TunnelCreated (tunnel);
 	}

libi2pd/TunnelPool.h

@@ -61,7 +61,7 @@ namespace tunnel
 	{
 		public:
 
-			TunnelPool (int numInboundHops, int numOutboundHops, int numInboundTunnels, 
+			TunnelPool (int numInboundHops, int numOutboundHops, int numInboundTunnels,
 				int numOutboundTunnels, int inboundVariance, int outboundVariance);
 			~TunnelPool ();
 
@@ -131,7 +131,7 @@ namespace tunnel
 		private:
 
 			std::shared_ptr<i2p::garlic::GarlicDestination> m_LocalDestination;
-			int m_NumInboundHops, m_NumOutboundHops, m_NumInboundTunnels, m_NumOutboundTunnels, 
+			int m_NumInboundHops, m_NumOutboundHops, m_NumInboundTunnels, m_NumOutboundTunnels,
 				m_InboundVariance, m_OutboundVariance;
 			std::shared_ptr<std::vector<i2p::data::IdentHash> > m_ExplicitPeers;
 			mutable std::mutex m_InboundTunnelsMutex;

libi2pd/util.cpp

@@ -32,10 +32,6 @@
 #include <iphlpapi.h>
 #include <shlobj.h>
 
-#ifdef _MSC_VER
-#pragma comment(lib, "IPHLPAPI.lib")
-#endif // _MSC_VER
-
 #define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
 #define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
 
@@ -521,7 +517,7 @@ namespace net
 
 	bool IsLocalAddress (const boost::asio::ip::address& addr)
 	{
-		auto mtu =  // TODO: implement better
+		auto mtu = // TODO: implement better
 #ifdef _WIN32
 		GetMTUWindows(addr, 0);
 #else

libi2pd/version.h

@@ -16,8 +16,8 @@
 #define MAKE_VERSION_NUMBER(a,b,c) ((a*100+b)*100+c)
 
 #define I2PD_VERSION_MAJOR 2
-#define I2PD_VERSION_MINOR 41
-#define I2PD_VERSION_MICRO 0
+#define I2PD_VERSION_MINOR 42
+#define I2PD_VERSION_MICRO 1
 #define I2PD_VERSION_PATCH 0
 #ifdef GITVER
 	#define I2PD_VERSION GITVER
@@ -31,7 +31,7 @@
 
 #define I2P_VERSION_MAJOR 0
 #define I2P_VERSION_MINOR 9
-#define I2P_VERSION_MICRO 53
+#define I2P_VERSION_MICRO 54
 #define I2P_VERSION_PATCH 0
 #define I2P_VERSION MAKE_VERSION(I2P_VERSION_MAJOR, I2P_VERSION_MINOR, I2P_VERSION_MICRO)
 #define I2P_VERSION_NUMBER MAKE_VERSION_NUMBER(I2P_VERSION_MAJOR, I2P_VERSION_MINOR, I2P_VERSION_MICRO)

libi2pd_client/AddressBook.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -299,7 +299,8 @@ namespace client
 	}
 
 	AddressBook::AddressBook (): m_Storage(nullptr), m_IsLoaded (false), m_IsDownloading (false),
-		m_NumRetries (0), m_DefaultSubscription (nullptr), m_SubscriptionsUpdateTimer (nullptr)
+		m_NumRetries (0), m_DefaultSubscription (nullptr), m_SubscriptionsUpdateTimer (nullptr),
+		m_IsEnabled (true)
 	{
 	}
 
@@ -310,12 +311,16 @@ namespace client
 
 	void AddressBook::Start ()
 	{
-		if (!m_Storage)
-			m_Storage = new AddressBookFilesystemStorage;
-		m_Storage->Init();
-		LoadHosts (); /* try storage, then hosts.txt, then download */
-		StartSubscriptions ();
-		StartLookups ();
+		i2p::config::GetOption("addressbook.enabled", m_IsEnabled);
+		if (m_IsEnabled)
+		{	
+			if (!m_Storage)
+				m_Storage = new AddressBookFilesystemStorage;
+			m_Storage->Init();
+			LoadHosts (); /* try storage, then hosts.txt, then download */
+			StartSubscriptions ();
+			StartLookups ();
+		}	
 	}
 
 	void AddressBook::StartResolvers ()
@@ -370,9 +375,10 @@ namespace client
 			pos = address.find (".i2p");
 			if (pos != std::string::npos)
 			{
+				if (!m_IsEnabled) return nullptr;
 				auto addr = FindAddress (address);
 				if (!addr)
-					 LookupAddress (address); // TODO:
+					LookupAddress (address); // TODO:
 				return addr;
 			}
 		}
@@ -494,7 +500,7 @@ namespace client
 				auto it = m_Addresses.find (name);
 				if (it != m_Addresses.end ()) // already exists ?
 				{
-					if (it->second->IsIdentHash () && it->second->identHash != ident->GetIdentHash () &&  // address changed?
+					if (it->second->IsIdentHash () && it->second->identHash != ident->GetIdentHash () && // address changed?
 						ident->GetSigningKeyType () != i2p::data::SIGNING_KEY_TYPE_DSA_SHA1) // don't replace by DSA
 					{
 						it->second->identHash = ident->GetIdentHash ();
@@ -858,9 +864,9 @@ namespace client
 		if (!m_LastModified.empty())
 			req.AddHeader("If-Modified-Since", m_LastModified);
 		/* convert url to relative */
-		url.schema = "";
-		url.host   = "";
-		req.uri    = url.to_string();
+		url.schema  = "";
+		url.host    = "";
+		req.uri     = url.to_string();
 		req.version = "HTTP/1.1";
 		auto stream = i2p::client::context.GetSharedLocalDestination ()->CreateStream (leaseSet, dest_port);
 		std::string request = req.to_string();

libi2pd_client/AddressBook.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -116,7 +116,7 @@ namespace client
 		private:
 
 			std::mutex m_AddressBookMutex;
-			std::map<std::string, std::shared_ptr<Address> >  m_Addresses;
+			std::map<std::string, std::shared_ptr<Address> > m_Addresses;
 			std::map<i2p::data::IdentHash, std::shared_ptr<AddressResolver> > m_Resolvers; // local destination->resolver
 			std::mutex m_LookupsMutex;
 			std::map<uint32_t, std::string> m_Lookups; // nonce -> address
@@ -126,6 +126,7 @@ namespace client
 			std::vector<std::shared_ptr<AddressBookSubscription> > m_Subscriptions;
 			std::shared_ptr<AddressBookSubscription> m_DefaultSubscription; // in case if we don't know any addresses yet
 			boost::asio::deadline_timer * m_SubscriptionsUpdateTimer;
+			bool m_IsEnabled;
 	};
 
 	class AddressBookSubscription
@@ -162,7 +163,7 @@ namespace client
 		private:
 
 			std::shared_ptr<ClientDestination> m_LocalDestination;
-			std::map<std::string, i2p::data::IdentHash>  m_LocalAddresses;
+			std::map<std::string, i2p::data::IdentHash> m_LocalAddresses;
 	};
 }
 }

libi2pd_client/BOB.cpp

@@ -1,13 +1,11 @@
 /*
-* Copyright (c) 2013-2020, The PurpleI2P Project
+* 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
 */
 
-#ifdef WITH_BOB
-
 #include <string.h>
 #include "Log.h"
 #include "ClientContext.h"
@@ -706,7 +704,7 @@ namespace client
 			msg += operand;
 			*(const_cast<char *>(value)) = '=';
 			msg += " set to ";
-			msg += value;
+			msg += value + 1;
 			SendReplyOK (msg.c_str ());
 		}
 		else
@@ -886,4 +884,3 @@ namespace client
 	}
 }
 }
-#endif // WITH_BOB

libi2pd_client/BOB.h

@@ -6,8 +6,6 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifdef WITH_BOB
-
 #ifndef BOB_H__
 #define BOB_H__
 
@@ -279,5 +277,5 @@ namespace client
 	};
 }
 }
+
 #endif
-#endif // WITH_BOB

libi2pd_client/ClientContext.cpp

@@ -26,16 +26,8 @@ namespace client
 	ClientContext context;
 
 	ClientContext::ClientContext (): m_SharedLocalDestination (nullptr),
-		m_HttpProxy (nullptr), m_SocksProxy (nullptr)
-#ifdef WITH_SAM
-		, m_SamBridge (nullptr)
-#endif
-#ifdef WITH_BOB
-		, m_BOBCommandChannel (nullptr)
-#endif
-#ifdef WITH_I2CP
-		, m_I2CPServer (nullptr)
-#endif
+		m_HttpProxy (nullptr), m_SocksProxy (nullptr), m_SamBridge (nullptr),
+		m_BOBCommandChannel (nullptr), m_I2CPServer (nullptr)
 	{
 	}
 
@@ -43,15 +35,9 @@ namespace client
 	{
 		delete m_HttpProxy;
 		delete m_SocksProxy;
-#ifdef WITH_SAM
 		delete m_SamBridge;
-#endif
-#ifdef WITH_BOB
 		delete m_BOBCommandChannel;
-#endif
-#ifdef WITH_I2CP
 		delete m_I2CPServer;
-#endif
 	}
 
 	void ClientContext::Start ()
@@ -72,7 +58,6 @@ namespace client
 		// I2P tunnels
 		ReadTunnels ();
 
-#ifdef WITH_SAM
 		// SAM
 		bool sam; i2p::config::GetOption("sam.enabled", sam);
 		if (sam)
@@ -92,9 +77,7 @@ namespace client
 				ThrowFatal ("Unable to start SAM bridge at ", samAddr, ":", samPort, ": ", e.what ());
 			}
 		}
-#endif
 
-#ifdef WITH_BOB
 		// BOB
 		bool bob; i2p::config::GetOption("bob.enabled", bob);
 		if (bob) {
@@ -112,9 +95,7 @@ namespace client
 				ThrowFatal ("Unable to start BOB bridge at ", bobAddr, ":", bobPort, ": ", e.what ());
 			}
 		}
-#endif
 
-#ifdef WITH_I2CP
 		// I2CP
 		bool i2cp; i2p::config::GetOption("i2cp.enabled", i2cp);
 		if (i2cp)
@@ -134,7 +115,6 @@ namespace client
 				ThrowFatal ("Unable to start I2CP at ", i2cpAddr, ":", i2cpPort, ": ", e.what ());
 			}
 		}
-#endif
 
 		m_AddressBook.StartResolvers ();
 
@@ -178,7 +158,6 @@ namespace client
 		}
 		m_ServerTunnels.clear ();
 
-#ifdef WITH_SAM
 		if (m_SamBridge)
 		{
 			LogPrint(eLogInfo, "Clients: Stopping SAM bridge");
@@ -186,9 +165,7 @@ namespace client
 			delete m_SamBridge;
 			m_SamBridge = nullptr;
 		}
-#endif
 
-#ifdef WITH_BOB
 		if (m_BOBCommandChannel)
 		{
 			LogPrint(eLogInfo, "Clients: Stopping BOB command channel");
@@ -196,9 +173,7 @@ namespace client
 			delete m_BOBCommandChannel;
 			m_BOBCommandChannel = nullptr;
 		}
-#endif
 
-#ifdef WITH_I2CP
 		if (m_I2CPServer)
 		{
 			LogPrint(eLogInfo, "Clients: Stopping I2CP");
@@ -206,7 +181,6 @@ namespace client
 			delete m_I2CPServer;
 			m_I2CPServer = nullptr;
 		}
-#endif
 
 		LogPrint(eLogInfo, "Clients: Stopping AddressBook");
 		m_AddressBook.Stop ();
@@ -634,21 +608,29 @@ namespace client
 					if (type == I2P_TUNNELS_SECTION_TYPE_UDPCLIENT) {
 						// udp client
 						// TODO: hostnames
-						boost::asio::ip::udp::endpoint end(boost::asio::ip::address::from_string(address), port);
+						boost::asio::ip::udp::endpoint end (boost::asio::ip::address::from_string(address), port);
 						if (!localDestination)
 							localDestination = m_SharedLocalDestination;
 
 						bool gzip = section.second.get (I2P_CLIENT_TUNNEL_GZIP, true);
-						auto clientTunnel = std::make_shared<I2PUDPClientTunnel>(name, dest, end, localDestination, destinationPort, gzip);
+						auto clientTunnel = std::make_shared<I2PUDPClientTunnel> (name, dest, end, localDestination, destinationPort, gzip);
 
-						auto ins = m_ClientForwards.insert(std::make_pair(end, clientTunnel));
+						auto ins = m_ClientForwards.insert (std::make_pair (end, clientTunnel));
 						if (ins.second)
 						{
-							clientTunnel->Start();
+							clientTunnel->Start ();
 							numClientTunnels++;
 						}
 						else
 						{
+							// TODO: update
+							if (ins.first->second->GetLocalDestination () != clientTunnel->GetLocalDestination ())
+							{
+								LogPrint (eLogInfo, "Clients: I2P UDP client tunnel destination updated");
+								ins.first->second->Stop ();
+								ins.first->second->SetLocalDestination (clientTunnel->GetLocalDestination ());
+								ins.first->second->Start ();
+							}
 							ins.first->second->isUpdated = true;
 							LogPrint(eLogError, "Clients: I2P Client forward for endpoint ", end, " already exists");
 						}
@@ -882,6 +864,8 @@ namespace client
 			uint16_t    httpProxyPort;         i2p::config::GetOption("httpproxy.port",          httpProxyPort);
 			std::string httpOutProxyURL;       i2p::config::GetOption("httpproxy.outproxy",      httpOutProxyURL);
 			bool        httpAddresshelper;     i2p::config::GetOption("httpproxy.addresshelper", httpAddresshelper);
+			if (httpAddresshelper)
+				i2p::config::GetOption("addressbook.enabled", httpAddresshelper); // addresshelper is not supported without address book	
 			i2p::data::SigningKeyType sigType; i2p::config::GetOption("httpproxy.signaturetype", sigType);
 			LogPrint(eLogInfo, "Clients: Starting HTTP Proxy at ", httpProxyAddr, ":", httpProxyPort);
 			if (httpProxyKeys.length () > 0)
@@ -916,7 +900,7 @@ namespace client
 		bool socksproxy; i2p::config::GetOption("socksproxy.enabled", socksproxy);
 		if (socksproxy)
 		{
-			std::string httpProxyKeys;         i2p::config::GetOption("httpproxy.keys",          httpProxyKeys);
+			std::string httpProxyKeys;         i2p::config::GetOption("httpproxy.keys",              httpProxyKeys);
 			// we still need httpProxyKeys to compare with sockProxyKeys
 			std::string socksProxyKeys;        i2p::config::GetOption("socksproxy.keys",             socksProxyKeys);
 			std::string socksProxyAddr;        i2p::config::GetOption("socksproxy.address",          socksProxyAddr);
@@ -1002,11 +986,11 @@ namespace client
 			}
 		}
 
-		/* // TODO: Write correct UDP tunnels stop
+		// TODO: Write correct UDP tunnels stop
 		for (auto it = m_ClientForwards.begin (); it != m_ClientForwards.end ();)
 		{
 			if(clean && !it->second->isUpdated) {
-				it->second = nullptr;
+				it->second->Stop ();
 				it = m_ClientForwards.erase(it);
 			} else {
 				it->second->isUpdated = false;
@@ -1017,13 +1001,13 @@ namespace client
 		for (auto it = m_ServerForwards.begin (); it != m_ServerForwards.end ();)
 		{
 			if(clean && !it->second->isUpdated) {
-				it->second = nullptr;
+				it->second->Stop ();
 				it = m_ServerForwards.erase(it);
 			} else {
 				it->second->isUpdated = false;
 				it++;
 			}
-		} */
+		}
 	}
 }
 }

libi2pd_client/ClientContext.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2022, The PurpleI2P Project
+* Copyright (c) 2013-2021, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -18,19 +18,9 @@
 #include "HTTPProxy.h"
 #include "SOCKS.h"
 #include "I2PTunnel.h"
-
-#ifdef WITH_SAM
 #include "SAM.h"
-#endif
-
-#ifdef WITH_BOB
 #include "BOB.h"
-#endif
-
-#ifdef WITH_I2CP
 #include "I2CP.h"
-#endif
-
 #include "AddressBook.h"
 #include "I18N_langs.h"
 
@@ -86,45 +76,31 @@ namespace client
 			void ReloadConfig ();
 
 			std::shared_ptr<ClientDestination> GetSharedLocalDestination () const { return m_SharedLocalDestination; };
-
-			std::shared_ptr<ClientDestination> CreateNewLocalDestination (
-				bool isPublic = false, // transient
+			std::shared_ptr<ClientDestination> CreateNewLocalDestination (bool isPublic = false, // transient
 				i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519,
 				i2p::data::CryptoKeyType cryptoType = i2p::data::CRYPTO_KEY_TYPE_ELGAMAL,
 				const std::map<std::string, std::string> * params = nullptr); // used by SAM only
-
 			std::shared_ptr<ClientDestination> CreateNewLocalDestination (boost::asio::io_service& service,
 				bool isPublic = false, i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519,
 				i2p::data::CryptoKeyType cryptoType = i2p::data::CRYPTO_KEY_TYPE_ELGAMAL,
 				const std::map<std::string, std::string> * params = nullptr); // same as previous but on external io_service
-
 			std::shared_ptr<ClientDestination> CreateNewLocalDestination (const i2p::data::PrivateKeys& keys, bool isPublic = true,
 				const std::map<std::string, std::string> * params = nullptr);
-
 			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);
-
 			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,
 				i2p::data::SigningKeyType sigType = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519,
 				i2p::data::CryptoKeyType cryptoType = i2p::data::CRYPTO_KEY_TYPE_ELGAMAL);
 
 			AddressBook& GetAddressBook () { return m_AddressBook; };
-#ifdef WITH_BOB
 			const BOBCommandChannel * GetBOBCommandChannel () const { return m_BOBCommandChannel; };
-#endif
-#ifdef WITH_SAM
 			const SAMBridge * GetSAMBridge () const { return m_SamBridge; };
-#endif
-#ifdef WITH_I2CP
 			const I2CPServer * GetI2CPServer () const { return m_I2CPServer; };
-#endif
 
 			std::vector<std::shared_ptr<DatagramSessionInfo> > GetForwardInfosFor(const i2p::data::IdentHash & destination);
 
@@ -166,22 +142,16 @@ namespace client
 
 			i2p::proxy::HTTPProxy * m_HttpProxy;
 			i2p::proxy::SOCKSProxy * m_SocksProxy;
-			std::map<boost::asio::ip::tcp::endpoint, std::shared_ptr<I2PService> > m_ClientTunnels; // local endpoint->tunnel
-			std::map<std::pair<i2p::data::IdentHash, int>, std::shared_ptr<I2PServerTunnel> > m_ServerTunnels; // <destination,port>->tunnel
+			std::map<boost::asio::ip::tcp::endpoint, std::shared_ptr<I2PService> > m_ClientTunnels; // local endpoint -> tunnel
+			std::map<std::pair<i2p::data::IdentHash, int>, std::shared_ptr<I2PServerTunnel> > m_ServerTunnels; // <destination,port> -> tunnel
 
 			std::mutex m_ForwardsMutex;
 			std::map<boost::asio::ip::udp::endpoint, std::shared_ptr<I2PUDPClientTunnel> > m_ClientForwards; // local endpoint -> udp tunnel
 			std::map<std::pair<i2p::data::IdentHash, int>, std::shared_ptr<I2PUDPServerTunnel> > m_ServerForwards; // <destination,port> -> udp tunnel
 
-#ifdef WITH_SAM
 			SAMBridge * m_SamBridge;
-#endif
-#ifdef WITH_BOB
 			BOBCommandChannel * m_BOBCommandChannel;
-#endif
-#ifdef WITH_I2CP
 			I2CPServer * m_I2CPServer;
-#endif
 
 			std::unique_ptr<boost::asio::deadline_timer> m_CleanupUDPTimer;
 

libi2pd_client/HTTPProxy.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2021, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -32,7 +32,13 @@
 
 namespace i2p {
 namespace proxy {
-	std::map<std::string, std::string> jumpservices = {
+	static const std::vector<std::string> jumporder = {
+		"reg.i2p",
+		"stats.i2p",
+		"identiguy.i2p",
+	};
+
+	static const std::map<std::string, std::string> jumpservices = {
 		{ "reg.i2p",       "http://shx5vqsw7usdaunyzr2qmes2fq37oumybpudrd4jjj4e4vk4uusa.b32.i2p/jump/" },
 		{ "identiguy.i2p", "http://3mzmrus2oron5fxptw7hw2puho3bnqmw2hqy7nw64dsrrjwdilva.b32.i2p/cgi-bin/query?hostname=" },
 		{ "stats.i2p",     "http://7tbay5p4kzeekxvyvbf6v7eauazemsnnl2aoyqhg5jzpr5eke7tq.b32.i2p/cgi-bin/jump.cgi?a=" },
@@ -174,8 +180,11 @@ namespace proxy {
 		   << "<p>" << tr("Remote host not found in router's addressbook") << "</p>\r\n"
 		   << "<p>" << tr("You may try to find this host on jump services below") << ":</p>\r\n"
 		   << "<ul>\r\n";
-		for (const auto& js : jumpservices) {
-			ss << "  <li><a href=\"" << js.second << host << "\">" << js.first << "</a></li>\r\n";
+		for (const auto& jump : jumporder)
+		{
+			auto js = jumpservices.find (jump);
+			if (js != jumpservices.end())
+				ss << "  <li><a href=\"" << js->second << host << "\">" << js->first << "</a></li>\r\n";
 		}
 		ss << "</ul>\r\n";
 		std::string content = ss.str();
@@ -237,14 +246,14 @@ namespace proxy {
 
 		/**
 		 * according to i2p ticket #1862:
-		 * leave Referrer if requested URL with same schema, host and port,
+		 * leave Referer if requested URL with same schema, host and port,
 		 * otherwise, drop it.
 		 */
-		if(req.GetHeader("Referrer") != "") {
+		if(req.GetHeader("Referer") != "") {
 			i2p::http::URL reqURL; reqURL.parse(req.uri);
-			i2p::http::URL refURL; refURL.parse(req.GetHeader("Referrer"));
+			i2p::http::URL refURL; refURL.parse(req.GetHeader("Referer"));
 			if(!boost::iequals(reqURL.schema, refURL.schema) || !boost::iequals(reqURL.host, refURL.host) || reqURL.port != refURL.port)
-				req.RemoveHeader("Referrer");
+				req.RemoveHeader("Referer");
 		}
 
 		/* add headers */

libi2pd_client/I2CP.cpp

@@ -6,8 +6,6 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifdef WITH_I2CP
-
 #include <string.h>
 #include <stdlib.h>
 #include <openssl/rand.h>
@@ -26,7 +24,7 @@ namespace client
 {
 
 	I2CPDestination::I2CPDestination (boost::asio::io_service& service, std::shared_ptr<I2CPSession> owner,
-	    std::shared_ptr<const i2p::data::IdentityEx> identity, bool isPublic, const std::map<std::string, std::string>& params):
+		std::shared_ptr<const i2p::data::IdentityEx> identity, bool isPublic, const std::map<std::string, std::string>& params):
 		LeaseSetDestination (service, isPublic, &params),
 		m_Owner (owner), m_Identity (identity), m_EncryptionKeyType (m_Identity->GetCryptoKeyType ()),
 		m_IsCreatingLeaseSet (false), m_LeaseSetCreationTimer (service)
@@ -455,8 +453,8 @@ namespace client
 			{
 				auto len = m_SendQueue.Get (m_SendBuffer, I2CP_MAX_MESSAGE_LENGTH);
 				boost::asio::async_write (*socket, boost::asio::buffer (m_SendBuffer, len),
-				    boost::asio::transfer_all (),std::bind(&I2CPSession::HandleI2CPMessageSent,
-				    shared_from_this (), std::placeholders::_1, std::placeholders::_2));
+					boost::asio::transfer_all (),std::bind(&I2CPSession::HandleI2CPMessageSent,
+					shared_from_this (), std::placeholders::_1, std::placeholders::_2));
 			}
 			else
 				m_IsSending = false;
@@ -526,31 +524,21 @@ namespace client
 
 	void I2CPSession::CreateSessionMessageHandler (const uint8_t * buf, size_t len)
 	{
-		if (m_Destination || !m_Owner.InsertSession (shared_from_this ()))
-		{
-			LogPrint (eLogError, "I2CP: Session already exists");
-			SendSessionStatusMessage (eI2CPSessionStatusRefused); // refused
-			return;
-		}
-
 		RAND_bytes ((uint8_t *)&m_SessionID, 2);
 		auto identity = std::make_shared<i2p::data::IdentityEx>();
 		size_t offset = identity->FromBuffer (buf, len);
-
 		if (!offset)
 		{
 			LogPrint (eLogError, "I2CP: Create session malformed identity");
 			SendSessionStatusMessage (eI2CPSessionStatusInvalid); // invalid
 			return;
 		}
-
 		if (m_Owner.FindSessionByIdentHash (identity->GetIdentHash ()))
 		{
 			LogPrint (eLogError, "I2CP: Create session duplicate address ", identity->GetIdentHash ().ToBase32 ());
 			SendSessionStatusMessage (eI2CPSessionStatusInvalid); // invalid
 			return;
 		}
-
 		uint16_t optionsSize = bufbe16toh (buf + offset);
 		offset += 2;
 		if (optionsSize > len - offset)
@@ -559,27 +547,42 @@ namespace client
 			SendSessionStatusMessage (eI2CPSessionStatusInvalid); // invalid
 			return;
 		}
-
 		std::map<std::string, std::string> params;
 		ExtractMapping (buf + offset, optionsSize, params);
 		offset += optionsSize; // options
 		if (params[I2CP_PARAM_MESSAGE_RELIABILITY] == "none") m_IsSendAccepted = false;
 
 		offset += 8; // date
-		if (!identity->Verify (buf, offset, buf + offset)) // signature
+		if (identity->Verify (buf, offset, buf + offset)) // signature
+		{
+			if (!m_Destination)
+			{
+				m_Destination = m_Owner.IsSingleThread () ?
+					std::make_shared<I2CPDestination>(m_Owner.GetService (), shared_from_this (), identity, true, params):
+					std::make_shared<RunnableI2CPDestination>(shared_from_this (), identity, true, params);
+				if (m_Owner.InsertSession (shared_from_this ()))
+				{
+					SendSessionStatusMessage (eI2CPSessionStatusCreated); // created
+					LogPrint (eLogDebug, "I2CP: Session ", m_SessionID, " created");
+					m_Destination->Start ();
+				}
+				else
+				{
+					LogPrint (eLogError, "I2CP: Session already exists");
+					SendSessionStatusMessage (eI2CPSessionStatusRefused);
+				}
+			}
+			else
+			{
+				LogPrint (eLogError, "I2CP: Session already exists");
+				SendSessionStatusMessage (eI2CPSessionStatusRefused); // refused
+			}
+		}
+		else
 		{
 			LogPrint (eLogError, "I2CP: Create session signature verification failed");
 			SendSessionStatusMessage (eI2CPSessionStatusInvalid); // invalid
-			return;
 		}
-
-		m_Destination = m_Owner.IsSingleThread () ?
-			std::make_shared<I2CPDestination>(m_Owner.GetService (), shared_from_this (), identity, true, params):
-			std::make_shared<RunnableI2CPDestination>(shared_from_this (), identity, true, params);
-
-		SendSessionStatusMessage (eI2CPSessionStatusCreated); // created
-		LogPrint (eLogDebug, "I2CP: Session ", m_SessionID, " created");
-		m_Destination->Start ();
 	}
 
 	void I2CPSession::DestroySessionMessageHandler (const uint8_t * buf, size_t len)
@@ -709,7 +712,7 @@ namespace client
 				{
 					if (offset + 4 > len) return;
 					uint16_t keyType = bufbe16toh (buf + offset); offset += 2; // encryption type
-					uint16_t keyLen = bufbe16toh (buf + offset); offset += 2;  // private key length
+					uint16_t keyLen = bufbe16toh (buf + offset); offset += 2; // private key length
 					if (offset + keyLen > len) return;
 					if (keyType == i2p::data::CRYPTO_KEY_TYPE_ECIES_X25519_AEAD)
 						m_Destination->SetECIESx25519EncryptionPrivateKey (buf + offset);
@@ -1037,4 +1040,3 @@ namespace client
 	}
 }
 }
-#endif // WITH_I2CP

libi2pd_client/I2CP.h

@@ -6,8 +6,6 @@
 * See full license text in LICENSE file at top of project tree
 */
 
-#ifdef WITH_I2CP
-
 #ifndef I2CP_H__
 #define I2CP_H__
 
@@ -71,7 +69,7 @@ namespace client
 		eI2CPSessionStatusInvalid = 3,
 		eI2CPSessionStatusRefused = 4
 	};
-	
+
 	// params
 	const char I2CP_PARAM_MESSAGE_RELIABILITY[] = "i2cp.messageReliability";
 
@@ -251,4 +249,3 @@ namespace client
 }
 
 #endif
-#endif // WITH_I2CP

libi2pd_client/I2PTunnel.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2021, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -7,6 +7,7 @@
 */
 
 #include <cassert>
+#include <boost/algorithm/string.hpp>
 #include "Base.h"
 #include "Log.h"
 #include "Destination.h"
@@ -340,7 +341,7 @@ namespace client
 			m_InHeader.clear ();
 			m_InHeader.write ((const char *)buf, len);
 			std::string line;
-			bool endOfHeader = false;
+			bool endOfHeader = false, connection = false;
 			while (!endOfHeader)
 			{
 				std::getline(m_InHeader, line);
@@ -349,9 +350,33 @@ namespace client
 					if (line == "\r") endOfHeader = true;
 					else
 					{
-						if (m_Host.length () > 0 && !line.compare(0, 5, "Host:"))
+						// strip up some headers
+						static const std::vector<std::string> excluded // list of excluded headers
+						{
+							"Keep-Alive:", "X-I2P" 
+						};
+						bool matched = false;
+						for (const auto& it: excluded)
+							if (boost::iequals (line.substr (0, it.length ()), it))
+							{
+								matched = true;
+								break;
+							}
+						if (matched) break;
+
+						// replace some headers
+						if (!m_Host.empty () && boost::iequals (line.substr (0, 5), "Host:"))
 							m_OutHeader << "Host: " << m_Host << "\r\n"; // override host
-						else
+						else if (boost::iequals (line.substr (0, 11), "Connection:"))
+						{
+							auto x = line.find("pgrade");
+							if (x != std::string::npos && x && std::tolower(line[x - 1]) != 'u') // upgrade or Upgrade
+								m_OutHeader << line << "\n";
+							else
+								m_OutHeader << "Connection: close\r\n";
+							connection = true;
+						}	
+						else // forward as is	
 							m_OutHeader << line << "\n";
 					}
 				}
@@ -361,6 +386,9 @@ namespace client
 
 			if (endOfHeader)
 			{
+				// add Connection if not presented
+				if (!connection)
+					m_OutHeader << "Connection: close\r\n";
 				// add X-I2P fields
 				if (m_From)
 				{
@@ -583,7 +611,7 @@ namespace client
 	{
 		if (m_KeepAliveTimer)
 		{
-			m_KeepAliveTimer->expires_from_now (boost::posix_time::seconds(m_KeepAliveInterval));
+			m_KeepAliveTimer->expires_from_now (boost::posix_time::seconds (m_KeepAliveInterval));
 			m_KeepAliveTimer->async_wait (std::bind (&I2PClientTunnel::HandleKeepAliveTimer,
 				this, std::placeholders::_1));
 		}
@@ -796,7 +824,8 @@ namespace client
 		}
 	}
 
-	void I2PUDPServerTunnel::ExpireStale(const uint64_t delta) {
+	void I2PUDPServerTunnel::ExpireStale(const uint64_t delta)
+	{
 		std::lock_guard<std::mutex> lock(m_SessionsMutex);
 		uint64_t now = i2p::util::GetMillisecondsSinceEpoch();
 		auto itr = m_Sessions.begin();
@@ -808,7 +837,8 @@ namespace client
 		}
 	}
 
-	void I2PUDPClientTunnel::ExpireStale(const uint64_t delta) {
+	void I2PUDPClientTunnel::ExpireStale(const uint64_t delta)
+	{
 		std::lock_guard<std::mutex> lock(m_SessionsMutex);
 		uint64_t now = i2p::util::GetMillisecondsSinceEpoch();
 		std::vector<uint16_t> removePorts;
@@ -864,7 +894,8 @@ namespace client
 		Receive();
 	}
 
-	void UDPSession::Receive() {
+	void UDPSession::Receive()
+	{
 		LogPrint(eLogDebug, "UDPSession: Receive");
 		IPSocket.async_receive_from(boost::asio::buffer(m_Buffer, I2P_UDP_MAX_MTU),
 			FromEndpoint, std::bind(&UDPSession::HandleReceived, this, std::placeholders::_1, std::placeholders::_2));
@@ -901,230 +932,241 @@ namespace client
 			LogPrint(eLogError, "UDPSession: ", ecode.message());
 	}
 
-	I2PUDPServerTunnel::I2PUDPServerTunnel(const std::string & name, std::shared_ptr<i2p::client::ClientDestination> localDestination,
+	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, bool gzip) :
-		m_IsUniqueLocal(true),
-		m_Name(name),
-		m_LocalAddress(localAddress),
-		m_RemoteEndpoint(forwardTo)
+		m_IsUniqueLocal (true), m_Name (name), m_LocalAddress (localAddress), 
+		m_RemoteEndpoint (forwardTo), m_LocalDest (localDestination), m_Gzip (gzip)
 	{
-		m_LocalDest = localDestination;
-		m_LocalDest->Start();
-		auto dgram = m_LocalDest->CreateDatagramDestination(gzip);
-		dgram->SetReceiver(std::bind(&I2PUDPServerTunnel::HandleRecvFromI2P, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
-		dgram->SetRawReceiver(std::bind(&I2PUDPServerTunnel::HandleRecvFromI2PRaw, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
 	}
 
-	I2PUDPServerTunnel::~I2PUDPServerTunnel()
+	I2PUDPServerTunnel::~I2PUDPServerTunnel ()
 	{
-		auto dgram = m_LocalDest->GetDatagramDestination();
-		if (dgram) dgram->ResetReceiver();
-
-		LogPrint(eLogInfo, "UDPServer: Done");
+		Stop ();
 	}
 
-	void I2PUDPServerTunnel::Start()
+	void I2PUDPServerTunnel::Start ()
 	{
-		m_LocalDest->Start();
+		m_LocalDest->Start ();
+
+		auto dgram = m_LocalDest->CreateDatagramDestination (m_Gzip);
+		dgram->SetReceiver (std::bind (&I2PUDPServerTunnel::HandleRecvFromI2P, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4, std::placeholders::_5));
+		dgram->SetRawReceiver (std::bind (&I2PUDPServerTunnel::HandleRecvFromI2PRaw, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
 	}
 
-	std::vector<std::shared_ptr<DatagramSessionInfo> > I2PUDPServerTunnel::GetSessions()
+	void I2PUDPServerTunnel::Stop ()
+	{
+		auto dgram = m_LocalDest->GetDatagramDestination ();
+		if (dgram) dgram->ResetReceiver ();
+	}
+
+	std::vector<std::shared_ptr<DatagramSessionInfo> > I2PUDPServerTunnel::GetSessions ()
 	{
 		std::vector<std::shared_ptr<DatagramSessionInfo> > sessions;
-		std::lock_guard<std::mutex> lock(m_SessionsMutex);
+		std::lock_guard<std::mutex> lock (m_SessionsMutex);
 
-		for ( UDPSessionPtr s : m_Sessions )
+		for (UDPSessionPtr s: m_Sessions)
 		{
 			if (!s->m_Destination) continue;
-			auto info = s->m_Destination->GetInfoForRemote(s->Identity);
-			if(!info) continue;
+			auto info = s->m_Destination->GetInfoForRemote (s->Identity);
+			if (!info) continue;
 
-			auto sinfo = std::make_shared<DatagramSessionInfo>();
+			auto sinfo = std::make_shared<DatagramSessionInfo> ();
 			sinfo->Name = m_Name;
-			sinfo->LocalIdent = std::make_shared<i2p::data::IdentHash>(m_LocalDest->GetIdentHash().data());
-			sinfo->RemoteIdent = std::make_shared<i2p::data::IdentHash>(s->Identity.data());
+			sinfo->LocalIdent = std::make_shared<i2p::data::IdentHash> (m_LocalDest->GetIdentHash ().data ());
+			sinfo->RemoteIdent = std::make_shared<i2p::data::IdentHash> (s->Identity.data ());
 			sinfo->CurrentIBGW = info->IBGW;
 			sinfo->CurrentOBEP = info->OBEP;
-			sessions.push_back(sinfo);
+			sessions.push_back (sinfo);
 		}
 		return sessions;
 	}
 
-	I2PUDPClientTunnel::I2PUDPClientTunnel(const std::string & name, const std::string &remoteDest,
+	I2PUDPClientTunnel::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) :
-		m_Name(name),
-		m_RemoteDest(remoteDest),
-		m_LocalDest(localDestination),
-		m_LocalEndpoint(localEndpoint),
-		m_RemoteIdent(nullptr),
-		m_ResolveThread(nullptr),
-		m_LocalSocket(localDestination->GetService(), localEndpoint),
-		RemotePort(remotePort), m_LastPort (0),
-		m_cancel_resolve(false)
+		m_Name (name), m_RemoteDest (remoteDest), m_LocalDest (localDestination), m_LocalEndpoint (localEndpoint),
+		m_RemoteIdent (nullptr), m_ResolveThread (nullptr), m_LocalSocket (nullptr), RemotePort (remotePort),
+		m_LastPort (0), m_cancel_resolve (false), m_Gzip (gzip)
 	{
-		m_LocalSocket.set_option (boost::asio::socket_base::receive_buffer_size (I2P_UDP_MAX_MTU));
-		m_LocalSocket.set_option (boost::asio::socket_base::reuse_address (true));
+	}
 
-		auto dgram = m_LocalDest->CreateDatagramDestination(gzip);
-		dgram->SetReceiver(std::bind(&I2PUDPClientTunnel::HandleRecvFromI2P, this,
+	I2PUDPClientTunnel::~I2PUDPClientTunnel ()
+	{
+		Stop ();
+	}
+
+	void I2PUDPClientTunnel::Start ()
+	{
+		// Reset flag in case of tunnel reload
+		if (m_cancel_resolve) m_cancel_resolve = false;
+
+		m_LocalSocket.reset (new boost::asio::ip::udp::socket (m_LocalDest->GetService (), m_LocalEndpoint));
+		m_LocalSocket->set_option (boost::asio::socket_base::receive_buffer_size (I2P_UDP_MAX_MTU));
+		m_LocalSocket->set_option (boost::asio::socket_base::reuse_address (true));
+
+		auto dgram = m_LocalDest->CreateDatagramDestination (m_Gzip);
+		dgram->SetReceiver (std::bind (&I2PUDPClientTunnel::HandleRecvFromI2P, this,
 			std::placeholders::_1, std::placeholders::_2,
 			std::placeholders::_3, std::placeholders::_4,
 			std::placeholders::_5));
-		dgram->SetRawReceiver(std::bind(&I2PUDPClientTunnel::HandleRecvFromI2PRaw, this,
+		dgram->SetRawReceiver (std::bind (&I2PUDPClientTunnel::HandleRecvFromI2PRaw, this,
 			std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
-	}
 
-	void I2PUDPClientTunnel::Start() {
-		m_LocalDest->Start();
+		m_LocalDest->Start ();
 		if (m_ResolveThread == nullptr)
-			m_ResolveThread = new std::thread(std::bind(&I2PUDPClientTunnel::TryResolving, this));
-		RecvFromLocal();
+			m_ResolveThread = new std::thread (std::bind (&I2PUDPClientTunnel::TryResolving, this));
+		RecvFromLocal ();
 	}
 
-	void I2PUDPClientTunnel::RecvFromLocal()
+	void I2PUDPClientTunnel::Stop ()
 	{
-		m_LocalSocket.async_receive_from(boost::asio::buffer(m_RecvBuff, I2P_UDP_MAX_MTU),
-			m_RecvEndpoint, std::bind(&I2PUDPClientTunnel::HandleRecvFromLocal, this, std::placeholders::_1, std::placeholders::_2));
+		auto dgram = m_LocalDest->GetDatagramDestination ();
+		if (dgram) dgram->ResetReceiver ();
+		m_cancel_resolve = true;
+
+		m_Sessions.clear();
+
+		if(m_LocalSocket && m_LocalSocket->is_open ())
+			m_LocalSocket->close ();
+
+		if(m_ResolveThread)
+		{
+			m_ResolveThread->join ();
+			delete m_ResolveThread;
+			m_ResolveThread = nullptr;
+		}
+		if (m_RemoteIdent)
+		{
+			delete m_RemoteIdent;
+			m_RemoteIdent = nullptr;
+		}
 	}
 
-	void I2PUDPClientTunnel::HandleRecvFromLocal(const boost::system::error_code & ec, std::size_t transferred)
+	void I2PUDPClientTunnel::RecvFromLocal ()
 	{
-		if(m_cancel_resolve) {
-			LogPrint(eLogDebug, "UDP Client: Ignoring incomming data: stopping");
+		m_LocalSocket->async_receive_from (boost::asio::buffer (m_RecvBuff, I2P_UDP_MAX_MTU),
+			m_RecvEndpoint, std::bind (&I2PUDPClientTunnel::HandleRecvFromLocal, this, std::placeholders::_1, std::placeholders::_2));
+	}
+
+	void I2PUDPClientTunnel::HandleRecvFromLocal (const boost::system::error_code & ec, std::size_t transferred)
+	{
+		if (m_cancel_resolve) {
+			LogPrint (eLogDebug, "UDP Client: Ignoring incomming data: stopping");
 			return;
 		}
-		if(ec) {
-			LogPrint(eLogError, "UDP Client: Reading from socket error: ", ec.message(), ". Restarting listener...");
-			RecvFromLocal(); // Restart listener and continue work
+		if (ec) {
+			LogPrint (eLogError, "UDP Client: Reading from socket error: ", ec.message (), ". Restarting listener...");
+			RecvFromLocal (); // Restart listener and continue work
 			return;
 		}
-		if(!m_RemoteIdent) {
-			LogPrint(eLogWarning, "UDP Client: Remote endpoint not resolved yet");
-			RecvFromLocal();
+		if (!m_RemoteIdent) {
+			LogPrint (eLogWarning, "UDP Client: Remote endpoint not resolved yet");
+			RecvFromLocal ();
 			return; // drop, remote not resolved
 		}
-		auto remotePort = m_RecvEndpoint.port();
+		auto remotePort = m_RecvEndpoint.port ();
 		if (!m_LastPort || m_LastPort != remotePort)
 		{
-			auto itr = m_Sessions.find(remotePort);
-			if (itr != m_Sessions.end())
+			auto itr = m_Sessions.find (remotePort);
+			if (itr != m_Sessions.end ())
 				m_LastSession = itr->second;
 			else
 			{
-				m_LastSession = std::make_shared<UDPConvo>(boost::asio::ip::udp::endpoint(m_RecvEndpoint), 0);
+				m_LastSession = std::make_shared<UDPConvo> (boost::asio::ip::udp::endpoint (m_RecvEndpoint), 0);
 				m_Sessions.emplace (remotePort, m_LastSession);
 			}
 			m_LastPort = remotePort;
 		}
 		// send off to remote i2p destination
-		auto ts = i2p::util::GetMillisecondsSinceEpoch();
-		LogPrint(eLogDebug, "UDP Client: Send ", transferred, " to ", m_RemoteIdent->ToBase32(), ":", RemotePort);
-		auto session = m_LocalDest->GetDatagramDestination()->GetSession (*m_RemoteIdent);
+		auto ts = i2p::util::GetMillisecondsSinceEpoch ();
+		LogPrint (eLogDebug, "UDP Client: Send ", transferred, " to ", m_RemoteIdent->ToBase32 (), ":", RemotePort);
+		auto session = m_LocalDest->GetDatagramDestination ()->GetSession (*m_RemoteIdent);
 		if (ts > m_LastSession->second + I2P_UDP_REPLIABLE_DATAGRAM_INTERVAL)
-			m_LocalDest->GetDatagramDestination()->SendDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
+			m_LocalDest->GetDatagramDestination ()->SendDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
 		else
-			m_LocalDest->GetDatagramDestination()->SendRawDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
+			m_LocalDest->GetDatagramDestination ()->SendRawDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
 		size_t numPackets = 0;
 		while (numPackets < i2p::datagram::DATAGRAM_SEND_QUEUE_MAX_SIZE)
 		{
 			boost::system::error_code ec;
-			size_t moreBytes = m_LocalSocket.available(ec);
+			size_t moreBytes = m_LocalSocket->available (ec);
 			if (ec || !moreBytes) break;
-			transferred = m_LocalSocket.receive_from (boost::asio::buffer (m_RecvBuff, I2P_UDP_MAX_MTU), m_RecvEndpoint, 0, ec);
-			remotePort = m_RecvEndpoint.port();
+			transferred = m_LocalSocket->receive_from (boost::asio::buffer (m_RecvBuff, I2P_UDP_MAX_MTU), m_RecvEndpoint, 0, ec);
+			remotePort = m_RecvEndpoint.port ();
 			// TODO: check remotePort
-			m_LocalDest->GetDatagramDestination()->SendRawDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
+			m_LocalDest->GetDatagramDestination ()->SendRawDatagram (session, m_RecvBuff, transferred, remotePort, RemotePort);
 			numPackets++;
 		}
 		if (numPackets)
-			LogPrint(eLogDebug, "UDP Client: Sent ", numPackets, " more packets to ", m_RemoteIdent->ToBase32());
-		m_LocalDest->GetDatagramDestination()->FlushSendQueue (session);
+			LogPrint (eLogDebug, "UDP Client: Sent ", numPackets, " more packets to ", m_RemoteIdent->ToBase32 ());
+		m_LocalDest->GetDatagramDestination ()->FlushSendQueue (session);
 
 		// mark convo as active
 		if (m_LastSession)
 			m_LastSession->second = ts;
-		RecvFromLocal();
+		RecvFromLocal ();
 	}
 
-	std::vector<std::shared_ptr<DatagramSessionInfo> > I2PUDPClientTunnel::GetSessions()
+	std::vector<std::shared_ptr<DatagramSessionInfo> > I2PUDPClientTunnel::GetSessions ()
 	{
 		// TODO: implement
 		std::vector<std::shared_ptr<DatagramSessionInfo> > infos;
 		return infos;
 	}
 
-	void I2PUDPClientTunnel::TryResolving() {
-		i2p::util::SetThreadName("UDP Resolver");
-		LogPrint(eLogInfo, "UDP Tunnel: Trying to resolve ", m_RemoteDest);
+	void I2PUDPClientTunnel::TryResolving ()
+	{
+		i2p::util::SetThreadName ("UDP Resolver");
+		LogPrint (eLogInfo, "UDP Tunnel: Trying to resolve ", m_RemoteDest);
 
 		std::shared_ptr<const Address> addr;
-		while(!(addr = context.GetAddressBook().GetAddress(m_RemoteDest)) && !m_cancel_resolve)
+		while (!(addr = context.GetAddressBook().GetAddress(m_RemoteDest)) && !m_cancel_resolve)
 		{
-			LogPrint(eLogWarning, "UDP Tunnel: Failed to lookup ", m_RemoteDest);
-			std::this_thread::sleep_for(std::chrono::seconds(1));
+			LogPrint (eLogWarning, "UDP Tunnel: Failed to lookup ", m_RemoteDest);
+			std::this_thread::sleep_for (std::chrono::seconds (1));
 		}
-		if(m_cancel_resolve)
+		if (m_cancel_resolve)
 		{
 			LogPrint(eLogError, "UDP Tunnel: Lookup of ", m_RemoteDest, " was cancelled");
 			return;
 		}
 		if (!addr || !addr->IsIdentHash ())
 		{
-			LogPrint(eLogError, "UDP Tunnel: ", m_RemoteDest, " not found");
+			LogPrint (eLogError, "UDP Tunnel: ", m_RemoteDest, " not found");
 			return;
 		}
 		m_RemoteIdent = new i2p::data::IdentHash;
 		*m_RemoteIdent = addr->identHash;
-		LogPrint(eLogInfo, "UDP Tunnel: Resolved ", m_RemoteDest, " to ", m_RemoteIdent->ToBase32());
+		LogPrint(eLogInfo, "UDP Tunnel: Resolved ", m_RemoteDest, " to ", m_RemoteIdent->ToBase32 ());
 	}
 
-	void I2PUDPClientTunnel::HandleRecvFromI2P(const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
+	void I2PUDPClientTunnel::HandleRecvFromI2P (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
 	{
-		if(m_RemoteIdent && from.GetIdentHash() == *m_RemoteIdent)
+		if (m_RemoteIdent && from.GetIdentHash() == *m_RemoteIdent)
 			HandleRecvFromI2PRaw (fromPort, toPort, buf, len);
 		else
-			LogPrint(eLogWarning, "UDP Client: Unwarranted traffic from ", from.GetIdentHash().ToBase32());
+			LogPrint(eLogWarning, "UDP Client: Unwarranted traffic from ", from.GetIdentHash().ToBase32 ());
 	}
 
-	void I2PUDPClientTunnel::HandleRecvFromI2PRaw(uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
+	void I2PUDPClientTunnel::HandleRecvFromI2PRaw (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len)
 	{
-		auto itr = m_Sessions.find(toPort);
+		auto itr = m_Sessions.find (toPort);
 		// found convo ?
-		if(itr != m_Sessions.end())
+		if (itr != m_Sessions.end ())
 		{
 			// found convo
 			if (len > 0)
 			{
-				LogPrint(eLogDebug, "UDP Client: Got ", len, "B from ", m_RemoteIdent ? m_RemoteIdent->ToBase32() : "");
-				m_LocalSocket.send_to(boost::asio::buffer(buf, len), itr->second->first);
+				LogPrint (eLogDebug, "UDP Client: Got ", len, "B from ", m_RemoteIdent ? m_RemoteIdent->ToBase32 () : "");
+				m_LocalSocket->send_to (boost::asio::buffer (buf, len), itr->second->first);
 				// mark convo as active
-				itr->second->second = i2p::util::GetMillisecondsSinceEpoch();
+				itr->second->second = i2p::util::GetMillisecondsSinceEpoch ();
 			}
 		}
 		else
-			LogPrint(eLogWarning, "UDP Client: Not tracking udp session using port ", (int) toPort);
-	}
-
-	I2PUDPClientTunnel::~I2PUDPClientTunnel()
-	{
-		auto dgram = m_LocalDest->GetDatagramDestination();
-		if (dgram) dgram->ResetReceiver();
-		m_cancel_resolve = true;
-
-		m_Sessions.clear();
-
-		if(m_LocalSocket.is_open())
-			m_LocalSocket.close();
-
-		if(m_ResolveThread)
-		{
-			m_ResolveThread->join();
-			delete m_ResolveThread;
-			m_ResolveThread = nullptr;
-		}
-		if (m_RemoteIdent) delete m_RemoteIdent;
+			LogPrint (eLogWarning, "UDP Client: Not tracking udp session using port ", (int) toPort);
 	}
 }
 }
+

libi2pd_client/I2PTunnel.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2013-2021, The PurpleI2P Project
+* Copyright (c) 2013-2022, The PurpleI2P Project
 *
 * This file is part of Purple i2pd project and licensed under BSD3
 *
@@ -31,7 +31,7 @@ namespace client
 	const int I2P_TUNNEL_CONNECTION_MAX_IDLE = 3600; // in seconds
 	const int I2P_TUNNEL_DESTINATION_REQUEST_TIMEOUT = 10; // in seconds
 	// for HTTP tunnels
-	const char X_I2P_DEST_HASH[] = "X-I2P-DestHash"; // hash  in base64
+	const char X_I2P_DEST_HASH[] = "X-I2P-DestHash"; // hash in base64
 	const char X_I2P_DEST_B64[] = "X-I2P-DestB64"; // full address in base64
 	const char X_I2P_DEST_B32[] = "X-I2P-DestB32"; // .b32.i2p address
 
@@ -43,7 +43,7 @@ namespace client
 				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,
 				std::shared_ptr<i2p::stream::Stream> stream); // to I2P using simplified API
-			I2PTunnelConnection (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,  std::shared_ptr<boost::asio::ip::tcp::socket> socket,
+			I2PTunnelConnection (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, bool quiet = true); // from I2P
 			~I2PTunnelConnection ();
 			void I2PConnect (const uint8_t * msg = nullptr, size_t len = 0);
@@ -230,25 +230,27 @@ namespace client
 	{
 		public:
 
-			I2PUDPServerTunnel(const std::string & name,
+			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, bool gzip);
-			~I2PUDPServerTunnel();
+			~I2PUDPServerTunnel ();
+
 			/** expire stale udp conversations */
-			void ExpireStale(const uint64_t delta=I2P_UDP_SESSION_TIMEOUT);
-			void Start();
-			const char * GetName() const { return m_Name.c_str(); }
-			std::vector<std::shared_ptr<DatagramSessionInfo> > GetSessions();
+			void ExpireStale (const uint64_t delta=I2P_UDP_SESSION_TIMEOUT);
+			void Start ();
+			void Stop ();
+			const char * GetName () const { return m_Name.c_str(); }
+			std::vector<std::shared_ptr<DatagramSessionInfo> > GetSessions ();
 			std::shared_ptr<ClientDestination> GetLocalDestination () const { return m_LocalDest; }
 
-			void SetUniqueLocal(bool isUniqueLocal = true) { m_IsUniqueLocal = isUniqueLocal; }
+			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);
+			void HandleRecvFromI2P (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
 			void HandleRecvFromI2PRaw (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);
+			UDPSessionPtr ObtainUDPSession (const i2p::data::IdentityEx& from, uint16_t localPort, uint16_t remotePort);
 
 		private:
 
@@ -260,6 +262,7 @@ namespace client
 			std::vector<UDPSessionPtr> m_Sessions;
 			std::shared_ptr<i2p::client::ClientDestination> m_LocalDest;
 			UDPSessionPtr m_LastSession;
+			bool m_Gzip;
 
 		public:
 
@@ -270,27 +273,36 @@ namespace client
 	{
 		public:
 
-			I2PUDPClientTunnel(const std::string & name, const std::string &remoteDest,
+			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);
-			~I2PUDPClientTunnel();
-			void Start();
-			const char * GetName() const { return m_Name.c_str(); }
-			std::vector<std::shared_ptr<DatagramSessionInfo> > GetSessions();
+			~I2PUDPClientTunnel ();
 
-			bool IsLocalDestination(const i2p::data::IdentHash & destination) const { return destination == m_LocalDest->GetIdentHash(); }
+			void Start ();
+			void Stop ();
+			const char * GetName () const { return m_Name.c_str(); }
+			std::vector<std::shared_ptr<DatagramSessionInfo> > GetSessions ();
+
+			bool IsLocalDestination (const i2p::data::IdentHash & destination) const { return destination == m_LocalDest->GetIdentHash(); }
 
 			std::shared_ptr<ClientDestination> GetLocalDestination () const { return m_LocalDest; }
-			void ExpireStale(const uint64_t delta=I2P_UDP_SESSION_TIMEOUT);
+			inline void SetLocalDestination (std::shared_ptr<ClientDestination> dest)
+			{
+				if (m_LocalDest) m_LocalDest->Release ();
+				if (dest) dest->Acquire ();
+				m_LocalDest = dest;
+			}
+
+			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);
-			void HandleRecvFromI2P(const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
-			void HandleRecvFromI2PRaw(uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
-			void TryResolving();
+			void RecvFromLocal ();
+			void HandleRecvFromLocal (const boost::system::error_code & e, std::size_t transferred);
+			void HandleRecvFromI2P (const i2p::data::IdentityEx& from, uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
+			void HandleRecvFromI2PRaw (uint16_t fromPort, uint16_t toPort, const uint8_t * buf, size_t len);
+			void TryResolving ();
 
 		private:
 
@@ -302,11 +314,12 @@ namespace client
 			const boost::asio::ip::udp::endpoint m_LocalEndpoint;
 			i2p::data::IdentHash * m_RemoteIdent;
 			std::thread * m_ResolveThread;
-			boost::asio::ip::udp::socket m_LocalSocket;
+			std::unique_ptr<boost::asio::ip::udp::socket> m_LocalSocket;
 			boost::asio::ip::udp::endpoint m_RecvEndpoint;
 			uint8_t m_RecvBuff[I2P_UDP_MAX_MTU];
 			uint16_t RemotePort, m_LastPort;
 			bool m_cancel_resolve;
+			bool m_Gzip;
 			std::shared_ptr<UDPConvo> m_LastSession;
 
 		public: