Merge pull request #3846

e18cb33e update checkpoints (Riccardo Spagni) f1cdcba9 update checkpoints for point release (Riccardo Spagni) ed273a88 bump version for point release (Riccardo Spagni)
update checkpoints
2025-12-10 06:40:55 -08:00 · 2018-05-23 21:21:59 +02:00 · 2018-05-23 21:16:57 +02:00 · 2018-05-23 21:13:54 +02:00 · 2018-05-23 21:10:06 +02:00 · 2018-05-23 20:42:57 +02:00
1100 changed files with 56477 additions and 250544 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1 +0,0 @@
-*
--- a/.gitignore
+++ b/.gitignore
@@ -61,7 +61,7 @@ CMakeCache.txt
 CMakeFiles
 cmake_install.cmake
 install_manifest.txt
-*.cmake
+cmake-build-debug/

 ### Linux ###
 *~
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,8 @@
+[submodule "external/unbound"]
+	path = external/unbound
+	url = https://github.com/monero-project/unbound
+	branch = monero
+[submodule "external/miniupnp"]
+	path = external/miniupnp
+	url = https://github.com/monero-project/miniupnp
+	branch = monero
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 #
 # All rights reserved.
 #
@@ -27,6 +27,14 @@
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 # Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+list(INSERT CMAKE_MODULE_PATH 0
+  "${CMAKE_SOURCE_DIR}/cmake")
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include(CheckLinkerFlag)
+include(CheckLibraryExists)
+include(CheckFunctionExists)
+
 if (IOS)
    INCLUDE(CmakeLists_IOS.txt)
 endif()
@@ -48,6 +56,47 @@ function (die msg)
  message(FATAL_ERROR "${BoldRed}${msg}${ColourReset}")
 endfunction ()

+function (add_c_flag_if_supported flag var)
+  string(REPLACE "-" "_" supported ${flag}_c)
+  check_c_compiler_flag(${flag} ${supported})
+  if(${${supported}})
+    set(${var} "${${var}} ${flag}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+function (add_cxx_flag_if_supported flag var)
+  string(REPLACE "-" "_" supported ${flag}_cxx)
+  check_cxx_compiler_flag(${flag} ${supported})
+  if(${${supported}})
+    set(${var} "${${var}} ${flag}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+function (add_linker_flag_if_supported flag var)
+  string(REPLACE "-" "_" supported ${flag}_ld)
+  string(REPLACE "," "_" supported ${flag}_ld)
+  check_linker_flag(${flag} ${supported})
+  if(${${supported}})
+    set(${var} "${${var}} ${flag}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+function (add_definition_if_function_found function var)
+  string(REPLACE "-" "_" supported ${function}_function)
+  check_function_exists(${function} ${supported})
+  if(${${supported}})
+    add_definitions("-D${var}")
+  endif()
+endfunction()
+
+function (add_definition_if_library_exists library function header var)
+  string(REPLACE "-" "_" supported ${function}_library)
+  check_library_exists(${library} ${function} ${header} ${supported})
+  if(${${supported}})
+    add_definitions("-D${var}")
+  endif()
+endfunction()
+
 if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
  message(STATUS "Setting default build type: ${CMAKE_BUILD_TYPE}")
@@ -147,6 +196,7 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 enable_testing()

 option(BUILD_DOCUMENTATION "Build the Doxygen documentation." ON)
+option(BUILD_TESTS "Build tests." OFF)

 # Check whether we're on a 32-bit or 64-bit system
 if(CMAKE_SIZEOF_VOID_P EQUAL "8")
@@ -186,7 +236,7 @@ endif()
 # elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")
 #   set(BSDI TRUE)

-include_directories(external/easylogging++ src contrib/epee/include external "${CMAKE_BINARY_DIR}/version")
+include_directories(external/easylogging++ src contrib/epee/include external)

 if(APPLE)
  include_directories(SYSTEM /usr/include/malloc)
@@ -209,11 +259,11 @@ endif()

 if (BUILD_SHARED_LIBS)
  message(STATUS "Building internal libraries with position independent code")
-  set(PIC_FLAG "-fPIC")
  add_definitions("-DBUILD_SHARED_LIBS")
 else()
  message(STATUS "Building internal libraries as static")
 endif()
+set(PIC_FLAG "-fPIC")

 if(MINGW)
  string(REGEX MATCH "^[^/]:/[^/]*" msys2_install_path "${CMAKE_C_COMPILER}")
@@ -234,10 +284,21 @@ if(STATIC)
  else()
    set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DZMQ_STATIC")
+endif()
+
+if(SANITIZE)
+  if (MSVC)
+    message(FATAL_ERROR "Cannot sanitize with MSVC")
+  else()
+    message(STATUS "Using ASAN")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
+  endif()
 endif()

 # Set default blockchain storage location:
-# memory was the default in Cryptonote before Monero implimented LMDB, it still works but is unneccessary.
+# memory was the default in Cryptonote before Monero implemented LMDB, it still works but is unnecessary.
 # set(DATABASE memory)
 set(DATABASE lmdb)

@@ -292,11 +353,13 @@ add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")

 # Can't install hook in static build on OSX, because OSX linker does not support --wrap
 # On ARM, having libunwind package (with .so's only) installed breaks static link.
+# When possible, avoid stack tracing using libunwind in favor of using easylogging++.
 if (APPLE)
  set(DEFAULT_STACK_TRACE OFF)
  set(LIBUNWIND_LIBRARIES "")
 elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT MINGW)
  set(DEFAULT_STACK_TRACE ON)
+  set(STACK_TRACE_LIB "easylogging++") # for diag output only
  set(LIBUNWIND_LIBRARIES "")
 elseif (ARM AND STATIC)
  set(DEFAULT_STACK_TRACE OFF)
@@ -305,6 +368,7 @@ else()
  find_package(Libunwind)
  if(LIBUNWIND_FOUND)
    set(DEFAULT_STACK_TRACE ON)
+    set(STACK_TRACE_LIB "libunwind") # for diag output only
  else()
    set(DEFAULT_STACK_TRACE OFF)
    set(LIBUNWIND_LIBRARIES "")
@@ -314,12 +378,22 @@ endif()
 option(STACK_TRACE "Install a hook that dumps stack on exception" ${DEFAULT_STACK_TRACE})

 if(STACK_TRACE)
-  message(STATUS "Stack trace on exception enabled")
+  message(STATUS "Stack trace on exception enabled (using ${STACK_TRACE_LIB})")
 else()
  message(STATUS "Stack trace on exception disabled")
 endif()

-# Handle OpenSSL, used for sha256sum on binary updates
+if (UNIX AND NOT APPLE)
+  # Note that at the time of this writing the -Wstrict-prototypes flag added below will make this fail
+  set(THREADS_PREFER_PTHREAD_FLAG ON)
+  find_package(Threads)
+endif()
+
+# Handle OpenSSL, used for sha256sum on binary updates and light wallet ssl http
+if (CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads")
+endif ()
+
 if (APPLE AND NOT IOS)
  if (NOT OpenSSL_DIR)
      EXECUTE_PROCESS(COMMAND brew --prefix openssl
@@ -330,29 +404,31 @@ if (APPLE AND NOT IOS)
 endif()

 find_package(OpenSSL REQUIRED)
+message(STATUS "Using OpenSSL include dir at ${OPENSSL_INCLUDE_DIR}")
+include_directories(${OPENSSL_INCLUDE_DIR})
 if(STATIC AND NOT IOS)
  if(UNIX)
-    set(OPENSSL_LIBRARIES "${OPENSSL_LIBRARIES};${CMAKE_DL_LIBS}")
+    set(OPENSSL_LIBRARIES "${OPENSSL_LIBRARIES};${CMAKE_DL_LIBS};${CMAKE_THREAD_LIBS_INIT}")
  endif()
 endif()

-if (UNIX AND NOT APPLE)
-  # Note that at the time of this writing the -Wstrict-prototypes flag added below will make this fail
-  set(THREADS_PREFER_PTHREAD_FLAG ON)
-  find_package(Threads)
-endif()
+find_package(PCSC)
+
+add_definition_if_library_exists(c memset_s "string.h" HAVE_MEMSET_S)
+add_definition_if_library_exists(c explicit_bzero "strings.h" HAVE_EXPLICIT_BZERO)
+add_definition_if_function_found(strptime HAVE_STRPTIME)

 add_definitions(-DAUTO_INITIALIZE_EASYLOGGINGPP)

-add_subdirectory(external)
+# Generate header for embedded translations
+include(ExternalProject)
+ExternalProject_Add(generate_translations_header
+  SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/translations"
+  BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/translations"
+  INSTALL_COMMAND cmake -E echo "")
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/translations")

-# Final setup for miniupnpc
-if(UPNP_STATIC OR IOS)
-  add_definitions("-DUPNP_STATIC")
-else()
-  add_definitions("-DUPNP_DYNAMIC")
-  include_directories(${UPNP_INCLUDE})
-endif()
+add_subdirectory(external)

 # Final setup for libunbound
 include_directories(${UNBOUND_INCLUDE})
@@ -374,6 +450,16 @@ endif()
 include_directories(${LIBUNWIND_INCLUDE})
 link_directories(${LIBUNWIND_LIBRARY_DIRS})

+# Final setup for libpcsc
+if (PCSC_FOUND) 
+  message(STATUS "Using PCSC include dir at ${PCSC_INCLUDE_DIR}")
+  add_definitions(-DHAVE_PCSC)
+  include_directories(${PCSC_INCLUDE_DIR})
+  link_directories(${LIBPCSC_LIBRARY_DIRS})
+else (PCSC_FOUND)
+  message(STATUS "Could not find PCSC")
+endif()
+
 if(MSVC)
  add_definitions("/bigobj /MP /W3 /GS- /D_CRT_SECURE_NO_WARNINGS /wd4996 /wd4345 /D_WIN32_WINNT=0x0600 /DWIN32_LEAN_AND_MEAN /DGTEST_HAS_TR1_TUPLE=0 /FIinline_c.h /D__SSE4_1__")
  # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Dinline=__inline")
@@ -407,7 +493,7 @@ else()
      set(WARNINGS "${WARNINGS} -Wno-error=inline-asm")
    endif()
  else()
-    set(WARNINGS "${WARNINGS} -Wlogical-op -Wno-error=maybe-uninitialized")
+    set(WARNINGS "${WARNINGS} -Wlogical-op -Wno-error=maybe-uninitialized -Wno-error=cpp")
  endif()
  if(MINGW)
    set(WARNINGS "${WARNINGS} -Wno-error=unused-value -Wno-error=unused-but-set-variable")
@@ -449,9 +535,59 @@ else()
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-strict-aliasing")

+  # if those don't work for your compiler, single it out where appropriate
+  if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(C_SECURITY_FLAGS "${C_SECURITY_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1")
+    set(CXX_SECURITY_FLAGS "${CXX_SECURITY_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1")
+  endif()
+
+  # warnings
+  add_c_flag_if_supported(-Wformat C_SECURITY_FLAGS)
+  add_cxx_flag_if_supported(-Wformat CXX_SECURITY_FLAGS)
+  add_c_flag_if_supported(-Wformat-security C_SECURITY_FLAGS)
+  add_cxx_flag_if_supported(-Wformat-security CXX_SECURITY_FLAGS)
+
+  # -fstack-protector
+  add_c_flag_if_supported(-fstack-protector C_SECURITY_FLAGS)
+  add_cxx_flag_if_supported(-fstack-protector CXX_SECURITY_FLAGS)
+  add_c_flag_if_supported(-fstack-protector-strong C_SECURITY_FLAGS)
+  add_cxx_flag_if_supported(-fstack-protector-strong CXX_SECURITY_FLAGS)
+
+  # linker
+  if (NOT WIN32)
+    # Windows binaries die on startup with PIE
+    add_linker_flag_if_supported(-pie LD_SECURITY_FLAGS)
+  endif()
+  add_linker_flag_if_supported(-Wl,-z,relro LD_SECURITY_FLAGS)
+  add_linker_flag_if_supported(-Wl,-z,now LD_SECURITY_FLAGS)
+  add_linker_flag_if_supported(-Wl,-z,noexecstack noexecstack_SUPPORTED)
+  if (noexecstack_SUPPORTED)
+    set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecstack")
+    set(LD_RAW_FLAGS ${LD_RAW_FLAGS} -z noexecstack)
+  endif()
+  add_linker_flag_if_supported(-Wl,-z,noexecheap noexecheap_SUPPORTED)
+  if (noexecheap_SUPPORTED)
+    set(LD_SECURITY_FLAGS "${LD_SECURITY_FLAGS} -Wl,-z,noexecheap")
+    set(LD_RAW_FLAGS ${LD_RAW_FLAGS} -z noexecheap)
+  endif()
+
+  # some windows linker bits
+  if (WIN32)
+    add_linker_flag_if_supported(-Wl,--dynamicbase LD_SECURITY_FLAGS)
+    add_linker_flag_if_supported(-Wl,--nxcompat LD_SECURITY_FLAGS)
+  endif()
+
+  message(STATUS "Using C security hardening flags: ${C_SECURITY_FLAGS}")
+  message(STATUS "Using C++ security hardening flags: ${CXX_SECURITY_FLAGS}")
+  message(STATUS "Using linker security hardening flags: ${LD_SECURITY_FLAGS}")
+
  option(NO_AES "Explicitly disable AES support" ${NO_AES})

-  if(NOT NO_AES AND NOT ARM AND NOT PPC64LE)
+  if(NO_AES)
+    message(STATUS "AES support explicitly disabled")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNO_AES")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNO_AES")
+  elseif(NOT ARM AND NOT PPC64LE)
    message(STATUS "AES support enabled")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
@@ -473,8 +609,9 @@ else()
    message(STATUS "AES support disabled")
  endif()

-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_FLAG} ${WARNINGS} ${C_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG}")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_CPP_FLAG} ${WARNINGS} ${CXX_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG}")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_FLAG} ${WARNINGS} ${C_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG} ${C_SECURITY_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_CPP_FLAG} ${WARNINGS} ${CXX_WARNINGS} ${ARCH_FLAG} ${COVERAGE_FLAGS} ${PIC_FLAG} ${CXX_SECURITY_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LD_SECURITY_FLAGS}")

  # With GCC 6.1.1 the compiled binary malfunctions due to aliasing. Until that
  # is fixed in the code (Issue #847), force compiler to be conservative.
@@ -561,6 +698,7 @@ else()
  if(ANDROID AND NOT BUILD_GUI_DEPS STREQUAL "ON" OR IOS)
    #From Android 5: "only position independent executables (PIE) are supported" 
    message(STATUS "Enabling PIE executable")
+    set(PIC_FLAG "")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIE")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIE")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_CXX_FLAGS} -fPIE -pie")
@@ -640,18 +778,24 @@ if(STATIC)
  set(Boost_USE_STATIC_LIBS ON)
  set(Boost_USE_STATIC_RUNTIME ON)
 endif()
-find_package(Boost 1.58 QUIET REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options)
+find_package(Boost 1.58 QUIET REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options locale)

 set(CMAKE_FIND_LIBRARY_SUFFIXES ${OLD_LIB_SUFFIXES})
 if(NOT Boost_FOUND)
  die("Could not find Boost libraries, please make sure you have installed Boost or libboost-all-dev (1.58) or the equivalent")
 elseif(Boost_FOUND)
  message(STATUS "Found Boost Version: ${Boost_VERSION}")
+  if (Boost_VERSION VERSION_LESS 106200 AND NOT (OPENSSL_VERSION VERSION_LESS 1.1))
+      message(FATAL_ERROR "Boost older than 1.62 is too old to link with OpenSSL 1.1 or newer. "
+                          "Update Boost or install OpenSSL 1.0 and set path to it when running cmake: "
+                          "cmake -DOPENSSL_ROOT_DIR='/usr/include/openssl-1.0;/usr/lib/openssl-1.0'")
+  endif()
 endif()

 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 if(MINGW)
  set(EXTRA_LIBRARIES mswsock;ws2_32;iphlpapi)
+  set(ICU_LIBRARIES ${Boost_LOCALE_LIBRARY} icuio icuin icuuc icudt icutu iconv)
 elseif(APPLE OR OPENBSD OR ANDROID)
  set(EXTRA_LIBRARIES "")
 elseif(FREEBSD)
@@ -659,6 +803,8 @@ elseif(FREEBSD)
 elseif(DRAGONFLY)
  find_library(COMPAT compat)
  set(EXTRA_LIBRARIES execinfo ${COMPAT})
+elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
+  set(EXTRA_LIBRARIES socket nsl resolv)
 elseif(NOT MSVC)
  find_library(RT rt)
  set(EXTRA_LIBRARIES ${RT})
@@ -672,8 +818,8 @@ if(USE_READLINE)
  if(READLINE_FOUND AND GNU_READLINE_FOUND)
    add_definitions(-DHAVE_READLINE)
    include_directories(${Readline_INCLUDE_DIR})
-    list(APPEND EXTRA_LIBRARIES ${Readline_LIBRARY})
    message(STATUS "Found readline library at: ${Readline_ROOT_DIR}")
+    set(EPEE_READLINE epee_readline)
  else()
    message(STATUS "Could not find GNU readline library so building without readline support")
  endif()
@@ -682,33 +828,40 @@ endif()
 if(ANDROID)
  set(ATOMIC libatomic.a)
 endif()
-if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS)
+if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS AND NOT FREEBSD)
  find_library(ATOMIC atomic)
  list(APPEND EXTRA_LIBRARIES ${ATOMIC})
 endif()

-include(version.cmake)
+find_path(ZMQ_INCLUDE_PATH zmq.hpp)
+find_library(ZMQ_LIB zmq)
+find_library(PGM_LIBRARY pgm)
+find_library(NORM_LIBRARY norm)
+find_library(SODIUM_LIBRARY sodium)

-function (treat_warnings_as_errors dirs)
-  foreach(dir ${ARGV})
-    set_property(DIRECTORY ${dir}
-      APPEND PROPERTY COMPILE_FLAGS "-Werror")
-  endforeach()
-endfunction()
+if(NOT ZMQ_INCLUDE_PATH)
+  message(FATAL_ERROR "Could not find required header zmq.hpp")
+endif()
+if(NOT ZMQ_LIB)
+  message(FATAL_ERROR "Could not find required libzmq")
+endif()
+if(PGM_LIBRARY)
+  set(ZMQ_LIB "${ZMQ_LIB};${PGM_LIBRARY}")
+endif()
+if(NORM_LIBRARY)
+  set(ZMQ_LIB "${ZMQ_LIB};${NORM_LIBRARY}")
+endif()
+if(SODIUM_LIBRARY)
+  set(ZMQ_LIB "${ZMQ_LIB};${SODIUM_LIBRARY}")
+endif()

 add_subdirectory(contrib)
 add_subdirectory(src)

-treat_warnings_as_errors(contrib src)
-
-option(BUILD_TESTS "Build tests." OFF)
-
 if(BUILD_TESTS)
  add_subdirectory(tests)
 endif()

-
-
 if(BUILD_DOCUMENTATION)
  set(DOC_GRAPHS "YES" CACHE STRING "Create dependency graphs (needs graphviz)")
  set(DOC_FULLGRAPHS "NO" CACHE STRING "Create call/callee graphs (large)")
@@ -739,3 +892,4 @@ option(BUILD_GUI_DEPS "Build GUI dependencies." OFF)
 option(INSTALL_VENDORED_LIBUNBOUND "Install libunbound binary built from source vendored with this repo." OFF)


+CHECK_C_COMPILER_FLAG(-std=c11 HAVE_C11)
--- a/CMakeLists_IOS.txt
+++ b/CMakeLists_IOS.txt
@@ -1,4 +1,4 @@
-# Portions Copyright (c) 2017, The Monero Project
+# Portions Copyright (c) 2017-2018, The Monero Project
 # This file is based off of the https://code.google.com/archive/p/ios-cmake/
 # It has been altered for Monero iOS development
 #
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -6,13 +6,13 @@ if you want to help that way. Testing is invaluable in making a piece
 of software solid and usable.


-## General Guidelines
+## General guidelines

 * Comments are encouraged.
 * If modifying code for which Doxygen headers exist, that header must be modified to match.
 * Tests would be nice to have if you're adding functionality.

-Patches are preferably to be sent via a github pull request. If that
+Patches are preferably to be sent via a Github pull request. If that
 can't be done, patches in "git format-patch" format can be sent
 (eg, posted to fpaste.org with a long enough timeout and a link
 posted to #monero-dev on irc.freenode.net).
@@ -21,20 +21,151 @@ Patches should be self contained. A good rule of thumb is to have
 one patch per separate issue, feature, or logical change. Also, no
 other changes, such as random whitespace changes or reindentation.
 Following the code style of the particular chunk of code you're
-modifying is encourgaged. Proper squashing should be done (eg, if
+modifying is encouraged. Proper squashing should be done (eg, if
 you're making a buggy patch, then a later patch to fix the bug,
 both patches should be merged).

-## Commits and Pull Requests
+If you've made random unrelated changes (either because your editor
+is annoying or you made them for other reasons), you can select
+what changes go into the coming commit using git add -p, which
+walks you through all the changes and asks whether or not to
+include this particular change. This helps create clean patches
+without any irrelevant changes. git diff will show you the changes
+in your tree. git diff --cached will show what is currently staged
+for commit. As you add hunks with git add -p, those hunks will
+"move" from the git diff output to the git diff --cached output,
+so you can see clearly what your commit is going to look like.
+
+## Commits and pull requests

 Commit messages should be sensible. That means a subject line that
 describes the patch, with an optional longer body that gives details,
 documentation, etc.

-When submitting a pull request on github, make sure your branch is
+When submitting a pull request on Github, make sure your branch is
 rebased. No merge commits nor stray commits from other people in
 your submitted branch, please. You may be asked to rebase if there
 are conflicts (even trivially resolvable ones).

 PGP signing commits is strongly encouraged. That should explain why
 the previous paragraph is here.
+
+# [Code of Conduct (22/C4.1)](http://rfc.zeromq.org/spec:22)
+
+## License
+
+Copyright (c) 2009-2015 Pieter Hintjens.
+Copyright (c) 2017-2018 The Monero Project.
+
+This Specification is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
+
+This Specification is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program; if not, see <http://www.gnu.org/licenses>.
+
+## Language
+
+The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.
+
+The "Monero Maintainer Team" is defined in this document as the following users:
+- fluffypony
+- moneromooo
+- hyc
+
+## Goals
+
+C4 is meant to provide a reusable optimal collaboration model for open source software projects. It has these specific goals:
+
+- To maximize the scale and diversity of the community around a project, by reducing the friction for new Contributors and creating a scaled participation model with strong positive feedbacks;
+- To relieve dependencies on key individuals by separating different skill sets so that there is a larger pool of competence in any required domain;
+- To allow the project to develop faster and more accurately, by increasing the diversity of the decision making process;
+- To support the natural life cycle of project versions from experimental through to stable, by allowing safe experimentation, rapid failure, and isolation of stable code;
+- To reduce the internal complexity of project repositories, thus making it easier for Contributors to participate and reducing the scope for error;
+- To enforce collective ownership of the project, which increases economic incentive to Contributors and reduces the risk of hijack by hostile entities.
+
+## Design
+
+### Preliminaries
+
+- The project SHALL use the git distributed revision control system.
+- The project SHALL be hosted on github.com or equivalent, herein called the "Platform".
+- The project SHALL use the Platform issue tracker.
+  - Non-GitHub example:
+    - "Platform" could be a vanilla git repo and Trac hosted on the same machine/network.
+    - The Platform issue tracker would be Trac.
+- The project SHOULD have clearly documented guidelines for code style.
+- A "Contributor" is a person who wishes to provide a patch, being a set of commits that solve some clearly identified problem.
+- A "Maintainer" is a person who merges patches to the project. Maintainers are not developers; their job is to enforce process.
+- Contributors SHALL NOT have commit access to the repository unless they are also Maintainers.
+- Maintainers SHALL have commit access to the repository.
+- Everyone, without distinction or discrimination, SHALL have an equal right to become a Contributor under the terms of this contract.
+
+### Licensing and ownership
+
+- The project SHALL use a share-alike license, such as BSD-3, the GPLv3 or a variant thereof (LGPL, AGPL), or the MPLv2.
+- All contributions to the project source code ("patches") SHALL use the same license as the project.
+- All patches are owned by their authors. There SHALL NOT be any copyright assignment process.
+- The copyrights in the project SHALL be owned collectively by all its Contributors.
+- Each Contributor SHALL be responsible for identifying themselves in the project Contributor list.
+
+### Patch requirements
+
+- Maintainers MUST have a Platform account and SHOULD use their real names or a well-known alias.
+- Contributors SHOULD have a Platform account and MAY use their real names or a well-known alias.
+- A patch SHOULD be a minimal and accurate answer to exactly one identified and agreed problem.
+- A patch MUST adhere to the code style guidelines of the project if these are defined.
+- A patch MUST adhere to the "Evolution of Public Contracts" guidelines defined below.
+- A patch SHALL NOT include non-trivial code from other projects unless the Contributor is the original author of that code.
+- A patch MUST compile cleanly and pass project self-tests on at least the principle target platform.
+- A patch commit message SHOULD consist of a single short (less than 50 character) line summarizing the change, optionally followed by a blank line and then a more thorough description.
+- A "Correct Patch" is one that satisfies the above requirements.
+
+### Development process
+
+- Change on the project SHALL be governed by the pattern of accurately identifying problems and applying minimal, accurate solutions to these problems.
+- To request changes, a user SHOULD log an issue on the project Platform issue tracker.
+- The user or Contributor SHOULD write the issue by describing the problem they face or observe.
+- The user or Contributor SHOULD seek consensus on the accuracy of their observation, and the value of solving the problem.
+- Users SHALL NOT log feature requests, ideas, or suggestions unrelated to Monero code or Monero's dependency code or Monero's potential/future dependency code or research which successfully implements Monero.
+- Users SHALL NOT log any solutions to problems (verifiable or hypothetical) of which are not explicitly documented and/or not provable and/or cannot be reasonably proven.
+- Thus, the release history of the project SHALL be a list of meaningful issues logged and solved.
+- To work on an issue, a Contributor SHALL fork the project repository and then work on their forked repository.
+- To submit a patch, a Contributor SHALL create a Platform pull request back to the project.
+- A Contributor SHALL NOT commit changes directly to the project.
+- To discuss a patch, people MAY comment on the Platform pull request, on the commit, or elsewhere.
+- To accept or reject a patch, a Maintainer SHALL use the Platform interface.
+- Maintainers SHOULD NOT merge their own patches except in exceptional cases, such as non-responsiveness from other Maintainers for an extended period (more than 30 days) or unless urgent as defined by the Monero Maintainers Team.
+- Maintainers SHALL NOT make value judgments on correct patches unless the Maintainer (as may happen in rare circumstances) is a core code developer.
+- Maintainers MUST NOT merge pull requests in less than 168 hours (1 week) unless deemed urgent by at least 2 people from the Monero Maintainer Team.
+- The Contributor MAY tag an issue as "Ready" after making a pull request for the issue.
+- The user who created an issue SHOULD close the issue after checking the patch is successful.
+- Maintainers SHOULD ask for improvements to incorrect patches and SHOULD reject incorrect patches if the Contributor does not respond constructively.
+- Any Contributor who has value judgments on a correct patch SHOULD express these via their own patches.
+- Maintainers MAY commit changes to non-source documentation directly to the project.
+
+### Creating stable releases
+
+- The project SHALL have one branch ("master") that always holds the latest in-progress version and SHOULD always build.
+- The project SHALL NOT use topic branches for any reason. Personal forks MAY use topic branches.
+- To make a stable release someone SHALL fork the repository by copying it and thus become maintainer of this repository.
+- Forking a project for stabilization MAY be done unilaterally and without agreement of project maintainers.
+- A patch to a stabilization project declared "stable" SHALL be accompanied by a reproducible test case.
+
+### Evolution of public contracts
+
+- All Public Contracts (APIs or protocols) SHALL be documented.
+- All Public Contracts SHOULD have space for extensibility and experimentation.
+- A patch that modifies a stable Public Contract SHOULD not break existing applications unless there is overriding consensus on the value of doing this.
+- A patch that introduces new features to a Public Contract SHOULD do so using new names.
+- Old names SHOULD be deprecated in a systematic fashion by marking new names as "experimental" until they are stable, then marking the old names as "deprecated".
+- When sufficient time has passed, old deprecated names SHOULD be marked "legacy" and eventually removed.
+- Old names SHALL NOT be reused by new features.
+- When old names are removed, their implementations MUST provoke an exception (assertion) if used by applications.
+
+### Project administration
+
+- The project founders SHALL act as Administrators to manage the set of project Maintainers.
+- The Administrators SHALL ensure their own succession over time by promoting the most effective Maintainers.
+- A new Contributor who makes a correct patch SHALL be invited to become a Maintainer.
+- Administrators MAY remove Maintainers who are inactive for an extended period of time, or who repeatedly fail to apply this process accurately.
+- Administrators SHOULD block or ban "bad actors" who cause stress and pain to others in the project. This should be done after public discussion, with a chance for all parties to speak. A bad actor is someone who repeatedly ignores the rules and culture of the project, who is needlessly argumentative or hostile, or who is offensive, and who is unable to self-correct their behavior when asked to do so by others.
--- a/132
+++ b/132
@@ -1,29 +1,107 @@
+# Multistage docker build, requires docker 17.05
+
+# builder stage
+FROM ubuntu:16.04 as builder
+
+RUN apt-get update && \
+    apt-get --no-install-recommends --yes install \
+        ca-certificates \
+        cmake \
+        g++ \
+        make \
+        pkg-config \
+        graphviz \
+        doxygen \
+        git \
+        curl \
+        libtool-bin \
+        autoconf \
+        automake
+
+WORKDIR /usr/local
+
+## Boost
+ARG BOOST_VERSION=1_66_0
+ARG BOOST_VERSION_DOT=1.66.0
+ARG BOOST_HASH=5721818253e6a0989583192f96782c4a98eb6204965316df9f5ad75819225ca9
+RUN curl -s -L -o  boost_${BOOST_VERSION}.tar.bz2 https://dl.bintray.com/boostorg/release/${BOOST_VERSION_DOT}/source/boost_${BOOST_VERSION}.tar.bz2 \
+    && echo "${BOOST_HASH} boost_${BOOST_VERSION}.tar.bz2" | sha256sum -c \
+    && tar -xvf boost_${BOOST_VERSION}.tar.bz2 \
+    && cd boost_${BOOST_VERSION} \
+    && ./bootstrap.sh \
+    && ./b2 --build-type=minimal link=static runtime-link=static --with-chrono --with-date_time --with-filesystem --with-program_options --with-regex --with-serialization --with-system --with-thread --with-locale threading=multi threadapi=pthread cflags="-fPIC" cxxflags="-fPIC" stage
+ENV BOOST_ROOT /usr/local/boost_${BOOST_VERSION}
+
+# OpenSSL
+ARG OPENSSL_VERSION=1.0.2n
+ARG OPENSSL_HASH=370babb75f278c39e0c50e8c4e7493bc0f18db6867478341a832a982fd15a8fe
+RUN curl -s -O https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz \
+    && echo "${OPENSSL_HASH} openssl-${OPENSSL_VERSION}.tar.gz" | sha256sum -c \
+    && tar -xzf openssl-${OPENSSL_VERSION}.tar.gz \
+    && cd openssl-${OPENSSL_VERSION} \
+    && ./Configure linux-x86_64 no-shared --static -fPIC \
+    && make build_crypto build_ssl \
+    && make install
+ENV OPENSSL_ROOT_DIR=/usr/local/openssl-${OPENSSL_VERSION}
+
+# ZMQ
+ARG ZMQ_VERSION=v4.2.3
+ARG ZMQ_HASH=3226b8ebddd9c6c738ba42986822c26418a49afb
+RUN git clone https://github.com/zeromq/libzmq.git -b ${ZMQ_VERSION} \
+    && cd libzmq \
+    && test `git rev-parse HEAD` = ${ZMQ_HASH} || exit 1 \
+    && ./autogen.sh \
+    && CFLAGS="-fPIC" CXXFLAGS="-fPIC" ./configure --enable-static --disable-shared \
+    && make \
+    && make install \
+    && ldconfig
+
+# zmq.hpp
+ARG CPPZMQ_HASH=6aa3ab686e916cb0e62df7fa7d12e0b13ae9fae6
+RUN git clone https://github.com/zeromq/cppzmq.git -b ${ZMQ_VERSION} \
+    && cd cppzmq \
+    && test `git rev-parse HEAD` = ${CPPZMQ_HASH} || exit 1 \
+    && mv *.hpp /usr/local/include
+
+# Readline
+ARG READLINE_VERSION=7.0
+ARG READLINE_HASH=750d437185286f40a369e1e4f4764eda932b9459b5ec9a731628393dd3d32334
+RUN curl -s -O https://ftp.gnu.org/gnu/readline/readline-${READLINE_VERSION}.tar.gz \
+    && echo "${READLINE_HASH} readline-${READLINE_VERSION}.tar.gz" | sha256sum -c \
+    && tar -xzf readline-${READLINE_VERSION}.tar.gz \
+    && cd readline-${READLINE_VERSION} \
+    && CFLAGS="-fPIC" CXXFLAGS="-fPIC" ./configure \
+    && make \
+    && make install
+
+# Sodium
+ARG SODIUM_VERSION=1.0.16
+ARG SODIUM_HASH=675149b9b8b66ff44152553fb3ebf9858128363d
+RUN git clone https://github.com/jedisct1/libsodium.git -b ${SODIUM_VERSION} \
+    && cd libsodium \
+    && test `git rev-parse HEAD` = ${SODIUM_HASH} || exit 1 \
+    && ./autogen.sh \
+    && CFLAGS="-fPIC" CXXFLAGS="-fPIC" ./configure \
+    && make \
+    && make check \
+    && make install
+
+WORKDIR /src
+COPY . .
+
+ARG NPROC
+RUN rm -rf build && \
+    if [ -z "$NPROC" ];then make -j$(nproc) release-static;else make -j$NPROC release-static;fi
+
+# runtime stage
 FROM ubuntu:16.04

-ENV SRC_DIR /usr/local/src/monero
+RUN apt-get update && \
+    apt-get --no-install-recommends --yes install ca-certificates && \
+    apt-get clean && \
+    rm -rf /var/lib/apt

-RUN set -x \
-  && buildDeps=' \
-      ca-certificates \
-      cmake \
-      g++ \
-      git \
-      libboost1.58-all-dev \
-      libssl-dev \
-      make \
-      pkg-config \
-  ' \
-  && apt-get -qq update \
-  && apt-get -qq --no-install-recommends install $buildDeps
-
-RUN git clone https://github.com/monero-project/monero.git $SRC_DIR
-WORKDIR $SRC_DIR
-RUN make -j$(nproc) release-static
-
-RUN cp build/release/bin/* /usr/local/bin/ \
-  \
-  && rm -r $SRC_DIR \
-  && apt-get -qq --auto-remove purge $buildDeps
+COPY --from=builder /src/build/release/bin/* /usr/local/bin/

 # Contains the blockchain
 VOLUME /root/.bitmonero
@@ -33,13 +111,7 @@ VOLUME /root/.bitmonero
 # monero-wallet-cli
 VOLUME /wallet

-ENV LOG_LEVEL 0
-ENV P2P_BIND_IP 0.0.0.0
-ENV P2P_BIND_PORT 18080
-ENV RPC_BIND_IP 127.0.0.1
-ENV RPC_BIND_PORT 18081
-
 EXPOSE 18080
 EXPOSE 18081

-CMD monerod --log-level=$LOG_LEVEL --p2p-bind-ip=$P2P_BIND_IP --p2p-bind-port=$P2P_BIND_PORT --rpc-bind-ip=$RPC_BIND_IP --rpc-bind-port=$RPC_BIND_PORT
+ENTRYPOINT ["monerod", "--p2p-bind-ip=0.0.0.0", "--p2p-bind-port=18080", "--rpc-bind-ip=0.0.0.0", "--rpc-bind-port=18081", "--non-interactive", "--confirm-external-bind"] 
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017, The Monero Project
+Copyright (c) 2014-2018, The Monero Project

 All rights reserved.

--- a/8
+++ b/8
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 #
 # All rights reserved.
 #
@@ -35,9 +35,11 @@ cmake-debug:
 debug: cmake-debug
 	cd build/debug && $(MAKE)

+# Temporarily disable some tests:
+#  * libwallet_api_tests fail (Issue #895)
 debug-test:
 	mkdir -p build/debug
-	cd build/debug && cmake -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Debug ../.. && $(MAKE) && $(MAKE) test
+	cd build/debug && cmake -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=Debug ../.. &&  $(MAKE) && $(MAKE) ARGS="-E libwallet_api_tests" test

 debug-all:
 	mkdir -p build/debug
@@ -114,7 +116,7 @@ release-static-win32:

 fuzz:
 	mkdir -p build/fuzz
-	cd build/fuzz && cmake -D BUILD_TESTS=ON -D USE_LTO=OFF -D CMAKE_C_COMPILER=afl-gcc -D CMAKE_CXX_COMPILER=afl-g++ -D ARCH="x86-64" -D CMAKE_BUILD_TYPE=fuzz -D BUILD_TAG="linux-x64" ../.. && $(MAKE)
+	cd build/fuzz && cmake -D STATIC=ON -D SANITIZE=ON -D BUILD_TESTS=ON -D USE_LTO=OFF -D CMAKE_C_COMPILER=afl-gcc -D CMAKE_CXX_COMPILER=afl-g++ -D ARCH="x86-64" -D CMAKE_BUILD_TYPE=fuzz -D BUILD_TAG="linux-x64" ../.. && $(MAKE)

 clean:
 	@echo "WARNING: Back-up your wallet if it exists within ./build!" ; \
--- a/README.i18n.md
+++ b/README.i18n.md
@@ -1,7 +1,7 @@
 Monero daemon internationalization
 ==================================

-The Monero command line tools can be translated in various languages.
+The Monero command line tools can be translated in various languages. If you wish to contribute and need help/support, contact the [Monero Localization Workgroup on Taiga](https://taiga.getmonero.org/project/erciccione-monero-localization/) or come chat on `#monero-translations` (Freenode/IRC, riot/matrix, MatterMost)

 In order to use the same translation workflow as the [Monero Core GUI](https://github.com/monero-project/monero-core), they use Qt Linguist translation files.  However, to avoid the dependencies on Qt this normally implies, they use a custom loader to read those files at runtime.

--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
 # Monero

-Copyright (c) 2014-2017, The Monero Project
-Portions Copyright (c) 2012-2013, The Cryptonote developers
+Copyright (c) 2014-2018 The Monero Project.   
+Portions Copyright (c) 2012-2013 The Cryptonote developers.

-## Development Resources
+## Development resources

 - Web: [getmonero.org](https://getmonero.org)
 - Forum: [forum.getmonero.org](https://forum.getmonero.org)
@@ -11,6 +11,16 @@ Portions Copyright (c) 2012-2013, The Cryptonote developers
 - GitHub: [https://github.com/monero-project/monero](https://github.com/monero-project/monero)
 - IRC: [#monero-dev on Freenode](http://webchat.freenode.net/?randomnick=1&channels=%23monero-dev&prompt=1&uio=d4)

+## Vulnerability response
+
+- Our [Vulnerability Response Process](https://github.com/monero-project/meta/blob/master/VULNERABILITY_RESPONSE_PROCESS.md) encourages responsible disclosure
+- We are also available via [HackerOne](https://hackerone.com/monero)
+
+
+## Announcements
+
+You can subscribe to an [announcement listserv](https://lists.getmonero.org) to get critical announcements from the Monero core team. The announcement list can be very helpful for knowing when software updates are needed.
+
 ## Build

 | Operating System      | Processor | Status |
@@ -45,7 +55,7 @@ Monero is a private, secure, untraceable, decentralised digital currency. You ar

 **Untraceability:** By taking advantage of ring signatures, a special property of a certain type of cryptography, Monero is able to ensure that transactions are not only untraceable, but have an optional measure of ambiguity that ensures that transactions cannot easily be tied back to an individual user or computer.

-## About this Project
+## About this project

 This is the core implementation of Monero. It is open source and completely free to use without restrictions, except for those specified in the license agreement below. There are no restrictions on anyone creating an alternative implementation of Monero that uses the protocol and network in a compatible manner.

@@ -53,18 +63,14 @@ As with many development projects, the repository on Github is considered to be

 **Anyone is welcome to contribute to Monero's codebase!** If you have a fix or code change, feel free to submit it as a pull request directly to the "master" branch. In cases where the change is relatively small or does not affect other parts of the codebase it may be merged in immediately by any one of the collaborators. On the other hand, if the change is particularly large or complex, it is expected that it will be discussed at length either well in advance of the pull request being submitted, or even directly on the pull request.

-## Supporting the Project
+## Supporting the project

-Monero development can be supported directly through donations.
-
-Both Monero and Bitcoin donations can be made to donate.getmonero.org if using a client that supports the [OpenAlias](https://openalias.org) standard
+Monero is a 100% community-sponsored endeavor. If you want to join our efforts, the easiest thing you can do is support the project financially. Both Monero and Bitcoin donations can be made to **donate.getmonero.org** if using a client that supports the [OpenAlias](https://openalias.org) standard. Alternatively you can send XMR to the Monero donation address via the `donate` command (type `help` in the command-line wallet for details).

 The Monero donation address is: `44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A` (viewkey: `f359631075708155cc3d92a32b75a7d02a5dcf27756707b47a2b31b21c389501`)

 The Bitcoin donation address is: `1KTexdemPdxSBcG55heUuTjDRYqbC5ZL8H`

-*Note: you can easily donate XMR to the Monero donation address by using the `donate` command. Type `help` in the command-line wallet for details.*
-
 Core development funding and/or some supporting services are also graciously provided by sponsors:

 [<img width="80" src="https://static.getmonero.org/images/sponsors/mymonero.png"/>](https://mymonero.com)
@@ -81,28 +87,33 @@ There are also several mining pools that kindly donate a portion of their fees,

 See [LICENSE](LICENSE).

-# Contributing
+## Contributing

 If you want to help out, see [CONTRIBUTING](CONTRIBUTING.md) for a set of guidelines.

-## Vulnerability Response Process
+## Scheduled software upgrades

-See [Vulnerability Response Process](VULNERABILITY_RESPONSE_PROCESS.md).
-
-## Monero software updates and consensus protocol changes (hard fork schedule)
-
-Monero uses a fixed-schedule hard fork mechanism to implement new features. This means that users of Monero (end users and service providers) need to run current versions and update their software on a regular schedule. Here is the current schedule, versions, and compatibility.
+Monero uses a fixed-schedule software upgrade (hard fork) mechanism to implement new features. This means that users of Monero (end users and service providers) should run current versions and upgrade their software on a regular schedule. Software upgrades occur during the months of April and October. The required software for these upgrades will be available prior to the scheduled date. Please check the repository prior to this date for the proper Monero software version. Below is the historical schedule and the projected schedule for the next upgrade.
 Dates are provided in the format YYYY-MM-DD. 


-| Fork Date              | Consensus version | Minimum Monero Version | Recommended Monero Version | Details            |  
-| ----------------- | ----------------- | ---------------------- | -------------------------- | ------------------ |
-| 2016-09-21        | v3                | v0.9.4                 | v0.10.0                    | Splits coinbase into denominations  |
-| 2017-01-05        | v4                | v0.10.1                 | v0.10.2.1                   | Allow normal and RingCT transactions |
-| 2017-04-15        | v5                | v0.10.3.0               | v0.10.3.1                    | Adjusted minimum blocksize and fee algorithm      |
-| 2017-09-21        | v6                | Not determined as of 2017-03-27                | Not determined as of 2017-03-27                    | Allow only RingCT transactions      |
+| Software upgrade block height | Date       | Fork version | Minimum Monero version | Recommended Monero version | Details                                                                            |  
+| ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
+| 1009827                        | 2016-03-22 | v2                | v0.9.4                 | v0.9.4                     | Allow only >= ringsize 3, blocktime = 120 seconds, fee-free blocksize 60 kb       |
+| 1141317                        | 2016-09-21 | v3                | v0.9.4                 | v0.10.0                    | Splits coinbase into denominations  |
+| 1220516                        | 2017-01-05 | v4                | v0.10.1                | v0.10.2.1                  | Allow normal and RingCT transactions |
+| 1288616                        | 2017-04-15 | v5                | v0.10.3.0              | v0.10.3.1                  | Adjusted minimum blocksize and fee algorithm      |
+| 1400000                        | 2017-09-16 | v6                | v0.11.0.0              | v0.11.0.0                  | Allow only RingCT transactions, allow only >= ringsize 5      |
+| 1546000                        | 2018-04-06 | v7                | v0.12.0.0              | v0.12.0.0                  | Cryptonight variant 1, ringsize >= 7, sorted inputs
+| XXXXXXX                        | 2018-10-XX | XX                | XXXXXXXXX              | XXXXXXXXX                  | X

-## Installing Monero from a Package
+X's indicate that these details have not been determined as of commit date.
+
+## Release staging schedule and protocol
+
+Approximately three months prior to a scheduled software upgrade, a branch from Master will be created with the new release version tag. Pull requests that address bugs should then be made to both Master and the new release branch. Pull requests that require extensive review and testing (generally, optimizations and new features) should *not* be made to the release branch. 
+
+## Installing Monero from a package

 Packages are available for

@@ -114,7 +125,15 @@ Installing a snap is very quick. Snaps are secure. They are isolated with all of

 * Arch Linux (via [AUR](https://aur.archlinux.org/)):
  - Stable release: [`monero`](https://aur.archlinux.org/packages/monero)
-  - Bleeding edge: [`bitmonero-git`](https://aur.archlinux.org/packages/bitmonero-git)
+  - Bleeding edge: [`monero-git`](https://aur.archlinux.org/packages/monero-git)
+
+* Void Linux:
+
+    xbps-install -S monero
+
+* GuixSD
+
+        guix package -i monero

 * OS X via [Homebrew](http://brew.sh)

@@ -123,7 +142,11 @@ Installing a snap is very quick. Snaps are secure. They are isolated with all of

 * Docker

+        # Build using all available cores
        docker build -t monero .
+
+        # or build using a specific number of cores (reduce RAM requirement)
+        docker build --build-arg NPROC=1 -t monero .
     
        # either run in foreground
        docker run -it -v /monero/chain:/root/.bitmonero -v /monero/wallet:/wallet -p 18080:18080 monero
@@ -133,11 +156,11 @@ Installing a snap is very quick. Snaps are secure. They are isolated with all of

 Packaging for your favorite distribution would be a welcome contribution!

-## Compiling Monero from Source
+## Compiling Monero from source

 ### Dependencies

-The following table summarizes the tools and libraries required to build.  A
+The following table summarizes the tools and libraries required to build. A
 few of the libraries are also included in this repository (marked as
 "Vendored"). By default, the build uses the library installed on the system,
 and ignores the vendored sources. However, if no library is found installed on
@@ -146,26 +169,40 @@ sources are also used for statically-linked builds because distribution
 packages often include only shared library binaries (`.so`) but not static
 library archives (`.a`).

-| Dep            | Min. Version  | Vendored | Debian/Ubuntu Pkg  | Arch Pkg       | Optional | Purpose        |
-| -------------- | ------------- | ---------| ------------------ | -------------- | -------- | -------------- |
-| GCC            | 4.7.3         | NO       | `build-essential`  | `base-devel`   | NO       |                |
-| CMake          | 3.0.0         | NO       | `cmake`            | `cmake`        | NO       |                |
-| pkg-config     | any           | NO       | `pkg-config`       | `base-devel`   | NO       |                |
-| Boost          | 1.58          | NO       | `libboost-all-dev` | `boost`        | NO       | C++ libraries  |
-| OpenSSL        | basically any | NO       | `libssl-dev`       | `openssl`      | NO       | sha256 sum     |
-| libunbound     | 1.4.16        | YES      | `libunbound-dev`   | `unbound`      | NO       | DNS resolver   |
-| libminiupnpc   | 2.0           | YES      | `libminiupnpc-dev` | `miniupnpc`    | YES      | NAT punching   |
-| libunwind      | any           | NO       | `libunwind8-dev`   | `libunwind`    | YES      | Stack traces   |
-| liblzma        | any           | NO       | `liblzma-dev`      | `xz`           | YES      | For libunwind  |
-| ldns           | 1.6.17        | NO       | `libldns-dev`      | `ldns`         | YES      | SSL toolkit    |
-| expat          | 1.1           | NO       | `libexpat1-dev`    | `expat`        | YES      | XML parsing    |
-| GTest          | 1.5           | YES      | `libgtest-dev`^    | `gtest`        | YES      | Test suite     |
-| Doxygen        | any           | NO       | `doxygen`          | `doxygen`      | YES      | Documentation  |
-| Graphviz       | any           | NO       | `graphviz`         | `graphviz`     | YES      | Documentation  |
+| Dep          | Min. version  | Vendored | Debian/Ubuntu pkg  | Arch pkg     | Fedora            | Optional | Purpose        |
+| ------------ | ------------- | -------- | ------------------ | ------------ | ----------------- | -------- | -------------- |
+| GCC          | 4.7.3         | NO       | `build-essential`  | `base-devel` | `gcc`             | NO       |                |
+| CMake        | 3.0.0         | NO       | `cmake`            | `cmake`      | `cmake`           | NO       |                |
+| pkg-config   | any           | NO       | `pkg-config`       | `base-devel` | `pkgconf`         | NO       |                |
+| Boost        | 1.58          | NO       | `libboost-all-dev` | `boost`      | `boost-devel`     | NO       | C++ libraries  |
+| OpenSSL      | basically any | NO       | `libssl-dev`       | `openssl`    | `openssl-devel`   | NO       | sha256 sum     |
+| libzmq       | 3.0.0         | NO       | `libzmq3-dev`      | `zeromq`     | `cppzmq-devel`    | NO       | ZeroMQ library |
+| libunbound   | 1.4.16        | YES      | `libunbound-dev`   | `unbound`    | `unbound-devel`   | NO       | DNS resolver   |
+| libsodium    | ?             | NO       | `libsodium-dev`    | ?            | `libsodium-devel` | NO       | libsodium      |
+| libminiupnpc | 2.0           | YES      | `libminiupnpc-dev` | `miniupnpc`  | `miniupnpc-devel` | YES      | NAT punching   |
+| libunwind    | any           | NO       | `libunwind8-dev`   | `libunwind`  | `libunwind-devel` | YES      | Stack traces   |
+| liblzma      | any           | NO       | `liblzma-dev`      | `xz`         | `xz-devel`        | YES      | For libunwind  |
+| libreadline  | 6.3.0         | NO       | `libreadline6-dev` | `readline`   | `readline-devel`  | YES      | Input editing  |
+| ldns         | 1.6.17        | NO       | `libldns-dev`      | `ldns`       | `ldns-devel`      | YES      | SSL toolkit    |
+| expat        | 1.1           | NO       | `libexpat1-dev`    | `expat`      | `expat-devel`     | YES      | XML parsing    |
+| GTest        | 1.5           | YES      | `libgtest-dev`^    | `gtest`      | `gtest-devel`     | YES      | Test suite     |
+| Doxygen      | any           | NO       | `doxygen`          | `doxygen`    | `doxygen`         | YES      | Documentation  |
+| Graphviz     | any           | NO       | `graphviz`         | `graphviz`   | `graphviz`        | YES      | Documentation  |
+

 [^] On Debian/Ubuntu `libgtest-dev` only includes sources and headers. You must
 build the library binary manually. This can be done with the following command ```sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake . && sudo make && sudo mv libg* /usr/lib/ ```

+### Cloning the repository
+
+Clone recursively to pull-in needed submodule(s):
+
+`$ git clone --recursive https://github.com/monero-project/monero`
+
+If you already have a repo cloned, initialize and update:
+
+`$ cd monero && git submodule init && git submodule update`
+
 ### Build instructions

 Monero uses the CMake build system and a top-level [Makefile](Makefile) that
@@ -184,6 +221,9 @@ invokes cmake commands as needed.
    this to be worthwhile, the machine should have one core and about 2GB of RAM
    available per thread.

+    *Note*: If cmake can not find zmq.hpp file on OS X, installing `zmq.hpp` from
+    https://github.com/zeromq/cppzmq to `/usr/local/include` should fix that error.
+
 * The resulting executables can be found in `build/release/bin`

 * Add `PATH="$PATH:$HOME/monero/build/release/bin"` to `.profile`
@@ -194,7 +234,7 @@ invokes cmake commands as needed.

        make release-test

-    *NOTE*: `coretests` test may take a few hours to complete.
+    *NOTE*: `core_tests` test may take a few hours to complete.

 * **Optional**: to build binaries suitable for debugging:

@@ -204,17 +244,19 @@ invokes cmake commands as needed.

         make release-static

+Dependencies need to be built with -fPIC. Static libraries usually aren't, so you may have to build them yourself with -fPIC. Refer to their documentation for how to build them.
+
 * **Optional**: build documentation in `doc/html` (omit `HAVE_DOT=YES` if `graphviz` is not installed):

        HAVE_DOT=YES doxygen Doxyfile

-#### On the Raspberry Pi 2
+#### On the Raspberry Pi

-Tested on a Raspberry Pi 2 with a clean install of minimal Debian Jessie from https://www.raspberrypi.org/downloads/raspbian/
+Tested on a Raspberry Pi Zero with a clean install of minimal Raspbian Stretch (2017-09-07 or later) from https://www.raspberrypi.org/downloads/raspbian/. If you are using Raspian Jessie, [please see note in the following section](#note-for-raspbian-jessie-users). 

 * `apt-get update && apt-get upgrade` to install all of the latest software

-* Install the dependencies for Monero except libunwind and libboost-all-dev
+* Install the dependencies for Monero from the 'Debian' column in the table above.

 * Increase the system swap size:
 ```	
@@ -223,6 +265,41 @@ Tested on a Raspberry Pi 2 with a clean install of minimal Debian Jessie from ht
 	CONF_SWAPSIZE=1024  
 	sudo /etc/init.d/dphys-swapfile start  
 ```
+* Clone monero and checkout most recent release version:
+```
+        git clone https://github.com/monero-project/monero.git
+	cd monero
+	git checkout tags/v0.11.1.0
+```
+* Build:
+```
+        make release
+```
+* Wait 4-6 hours
+
+* The resulting executables can be found in `build/release/bin`
+
+* Add `PATH="$PATH:$HOME/monero/build/release/bin"` to `.profile`
+
+* Run Monero with `monerod --detach`
+
+* You may wish to reduce the size of the swap file after the build has finished, and delete the boost directory from your home directory
+
+#### *Note for Raspbian Jessie users:*
+
+If you are using the older Raspbian Jessie image, compiling Monero is a bit more complicated. The version of Boost available in the Debian Jessie repositories is too old to use with Monero, and thus you must compile a newer version yourself. The following explains the extra steps, and has been tested on a Raspberry Pi 2 with a clean install of minimal Raspbian Jessie.
+
+* As before, `apt-get update && apt-get upgrade` to install all of the latest software, and increase the system swap size
+
+```	
+	sudo /etc/init.d/dphys-swapfile stop  
+	sudo nano /etc/dphys-swapfile  
+	CONF_SWAPSIZE=1024  
+	sudo /etc/init.d/dphys-swapfile start  
+```
+
+* Then, install the dependencies for Monero except `libunwind` and `libboost-all-dev`
+
 * Install the latest version of boost (this may first require invoking `apt-get remove --purge libboost*` to remove a previous version if you're not using a clean install):
 ```
 	cd  
@@ -238,20 +315,7 @@ Tested on a Raspberry Pi 2 with a clean install of minimal Debian Jessie from ht
 ```
 * Wait ~4 hours

-* Change to the root of the source code directory and build:
-```
-        cd monero
-        make release
-```
-* Wait ~4 hours
-
-* The resulting executables can be found in `build/release/bin`
-
-* Add `PATH="$PATH:$HOME/monero/build/release/bin"` to `.profile`
-
-* Run Monero with `monerod --detach`
-
-* You may wish to reduce the size of the swap file after the build has finished, and delete the boost directory from your home directory
+* From here, follow the [general Raspberry Pi instructions](#on-the-raspberry-pi) from the "Clone monero and checkout most recent release version" step.

 #### On Windows:

@@ -261,7 +325,7 @@ POSIX system. The toolchain runs within the environment and *cross-compiles*
 binaries that can run outside of the environment as a regular Windows
 application.

-**Preparing the Build Environment**
+**Preparing the build environment**

 * Download and install the [MSYS2 installer](http://msys2.github.io), either the 64-bit or the 32-bit package, depending on your system.
 * Open the MSYS shell via the `MSYS2 Shell` shortcut
@@ -280,11 +344,11 @@ application.

    To build for 64-bit Windows:

-        pacman -S mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-boost
+        pacman -S mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium

    To build for 32-bit Windows:
 
-        pacman -S mingw-w64-i686-toolchain make mingw-w64-i686-cmake mingw-w64-i686-boost
+        pacman -S mingw-w64-i686-toolchain make mingw-w64-i686-cmake mingw-w64-i686-boost mingw-w64-i686-openssl mingw-w64-i686-zeromq mingw-w64-i686-libsodium

 * Open the MingW shell via `MinGW-w64-Win64 Shell` shortcut on 64-bit Windows
  or `MinGW-w64-Win64 Shell` shortcut on 32-bit Windows. Note that if you are
@@ -310,6 +374,8 @@ We expect to add Monero into the ports tree in the near future, which will aid i

 ### On OpenBSD:

+#### OpenBSD < 6.2
+
 This has been tested on OpenBSD 5.8.

 You will need to add a few packages to your system. `pkg_add db cmake gcc gcc-libs g++ miniupnpc gtest`.
@@ -323,6 +389,90 @@ You will have to add the serialization, date_time, and regex modules to Boost wh

 To build: `env CC=egcc CXX=eg++ CPP=ecpp DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/path/to/the/boost/you/built make release-static-64`

+#### OpenBSD >= 6.2
+
+You will need to add a few packages to your system. `pkg_add cmake miniupnpc zeromq libiconv`.
+
+The doxygen and graphviz packages are optional and require the xbase set.
+
+
+Build the Boost library using clang. This guide is derived from: https://github.com/bitcoin/bitcoin/blob/master/doc/build-openbsd.md
+
+We assume you are compiling with a non-root user and you have `doas` enabled.
+
+Note: do not use the boost package provided by OpenBSD, as we are installing boost to `/usr/local`.
+
+```
+# Create boost building directory
+mkdir ~/boost
+cd ~/boost
+
+# Fetch boost source
+ftp -o boost_1_64_0.tar.bz2 https://netcologne.dl.sourceforge.net/project/boost/boost/1.64.0/boost_1_64_0.tar.bz2 
+
+# MUST output: (SHA256) boost_1_64_0.tar.bz2: OK
+echo "7bcc5caace97baa948931d712ea5f37038dbb1c5d89b43ad4def4ed7cb683332 boost_1_64_0.tar.bz2" | sha256 -c
+tar xfj boost_1_64_0.tar.bz2
+
+# Fetch and apply boost patches, required for OpenBSD
+ftp -o boost_test_impl_execution_monitor_ipp.patch https://raw.githubusercontent.com/openbsd/ports/bee9e6df517077a7269ff0dfd57995f5c6a10379/devel/boost/patches/patch-boost_test_impl_execution_monitor_ipp
+ftp -o boost_config_platform_bsd_hpp.patch https://raw.githubusercontent.com/openbsd/ports/90658284fb786f5a60dd9d6e8d14500c167bdaa0/devel/boost/patches/patch-boost_config_platform_bsd_hpp
+
+# MUST output: (SHA256) boost_config_platform_bsd_hpp.patch: OK
+echo "1f5e59d1154f16ee1e0cc169395f30d5e7d22a5bd9f86358f738b0ccaea5e51d boost_config_platform_bsd_hpp.patch" | sha256 -c
+# MUST output: (SHA256) boost_test_impl_execution_monitor_ipp.patch: OK
+echo "30cec182a1437d40c3e0bd9a866ab5ddc1400a56185b7e671bb3782634ed0206 boost_test_impl_execution_monitor_ipp.patch" | sha256 -c
+
+cd boost_1_64_0
+patch -p0 < ../boost_test_impl_execution_monitor_ipp.patch
+patch -p0 < ../boost_config_platform_bsd_hpp.patch
+
+# Start building boost
+echo 'using clang : : c++ : <cxxflags>"-fvisibility=hidden -fPIC" <linkflags>"" <archiver>"ar" <striper>"strip"  <ranlib>"ranlib" <rc>"" : ;' > user-config.jam
+./bootstrap.sh --without-icu --with-libraries=chrono,filesystem,program_options,system,thread,test,date_time,regex,serialization,locale --with-toolset=clang
+./b2 toolset=clang cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" -sICONV_PATH=/usr/local
+doas ./b2 -d0 runtime-link=shared threadapi=pthread threading=multi link=static variant=release --layout=tagged --build-type=complete --user-config=user-config.jam -sNO_BZIP2=1 -sICONV_PATH=/usr/local --prefix=/usr/local install
+```
+
+Build cppzmq
+
+Build the cppzmq bindings.
+
+We assume you are compiling with a non-root user and you have `doas` enabled.
+
+```
+# Create cppzmq building directory
+mkdir ~/cppzmq
+cd ~/cppzmq
+
+# Fetch cppzmq source
+ftp -o cppzmq-4.2.3.tar.gz https://github.com/zeromq/cppzmq/archive/v4.2.3.tar.gz
+
+# MUST output: (SHA256) cppzmq-4.2.3.tar.gz: OK
+echo "3e6b57bf49115f4ae893b1ff7848ead7267013087dc7be1ab27636a97144d373 cppzmq-4.2.3.tar.gz" | sha256 -c
+tar xfz cppzmq-4.2.3.tar.gz
+
+# Start building cppzmq
+cd cppzmq-4.2.3
+mkdir build
+cd build
+cmake ..
+doas make install
+```
+
+Build monero: `env DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/usr/local make release-static`
+
+### On Solaris:
+
+The default Solaris linker can't be used, you have to install GNU ld, then run cmake manually with the path to your copy of GNU ld:
+
+        mkdir -p build/release
+        cd build/release
+        cmake -DCMAKE_LINKER=/path/to/ld -D CMAKE_BUILD_TYPE=Release ../..
+        cd ../..
+
+Then you can run make as usual.
+
 ### On Linux for Android (using docker):

        # Build image (select android64.Dockerfile for aarch64)
@@ -332,15 +482,15 @@ To build: `env CC=egcc CXX=eg++ CPP=ecpp DEVELOPER_LOCAL_TOOLS=1 BOOST_ROOT=/pat
        # Get binaries
        docker cp monero-android:/opt/android/monero/build/release/bin .

-### Building Portable Statically Linked Binaries
+### Building portable statically linked binaries

 By default, in either dynamically or statically linked builds, binaries target the specific host processor on which the build happens and are not portable to other processors. Portable binaries can be built using the following targets:

-* ```make release-static-64``` builds binaries on Linux on x86_64 portable across POSIX systems on x86_64 processors
-* ```make release-static-32``` builds binaries on Linux on x86_64 or i686 portable across POSIX systems on i686 processors
-* ```make release-static-armv8``` builds binaries on Linux portable across POSIX systems on armv8 processors
-* ```make release-static-armv7``` builds binaries on Linux portable across POSIX systems on armv7 processors
-* ```make release-static-armv6``` builds binaries on Linux portable across POSIX systems on armv6 processors
+* ```make release-static-linux-x86_64``` builds binaries on Linux on x86_64 portable across POSIX systems on x86_64 processors
+* ```make release-static-linux-i686``` builds binaries on Linux on x86_64 or i686 portable across POSIX systems on i686 processors
+* ```make release-static-linux-armv8``` builds binaries on Linux portable across POSIX systems on armv8 processors
+* ```make release-static-linux-armv7``` builds binaries on Linux portable across POSIX systems on armv7 processors
+* ```make release-static-linux-armv6``` builds binaries on Linux portable across POSIX systems on armv6 processors
 * ```make release-static-win64``` builds binaries on 64-bit Windows portable across 64-bit Windows systems
 * ```make release-static-win32``` builds binaries on 64-bit or 32-bit Windows portable across 32-bit Windows systems

@@ -378,35 +528,45 @@ See [README.i18n.md](README.i18n.md).

 ## Using Tor

-While Monero isn't made to integrate with Tor, it can be used wrapped with torsocks, if you add --p2p-bind-ip 127.0.0.1 to the monerod command line. You also want to set DNS requests to go over TCP, so they'll be routed through Tor, by setting DNS_PUBLIC=tcp. You may also disable IGD (UPnP port forwarding negotiation), which is pointless with Tor. To allow local connections from the wallet, you might have to add TORSOCKS_ALLOW_INBOUND=1, some OSes need it and some don't. Example:
+While Monero isn't made to integrate with Tor, it can be used wrapped with torsocks, by
+setting the following configuration parameters and environment variables:

-`DNS_PUBLIC=tcp torsocks monerod --p2p-bind-ip 127.0.0.1 --no-igd`
+* `--p2p-bind-ip 127.0.0.1` on the command line or `p2p-bind-ip=127.0.0.1` in
+  monerod.conf to disable listening for connections on external interfaces.
+* `--no-igd` on the command line or `no-igd=1` in monerod.conf to disable IGD
+  (UPnP port forwarding negotiation), which is pointless with Tor.
+* `DNS_PUBLIC=tcp` or `DNS_PUBLIC=tcp://x.x.x.x` where x.x.x.x is the IP of the
+  desired DNS server, for DNS requests to go over TCP, so that they are routed
+  through Tor. When IP is not specified, monerod uses the default list of
+  servers defined in [src/common/dns_utils.cpp](src/common/dns_utils.cpp).
+* `TORSOCKS_ALLOW_INBOUND=1` to tell torsocks to allow monerod to bind to interfaces
+   to accept connections from the wallet. On some Linux systems, torsocks
+   allows binding to localhost by default, so setting this variable is only
+   necessary to allow binding to local LAN/VPN interfaces to allow wallets to
+   connect from remote hosts. On other systems, it may be needed for local wallets
+   as well.
+* Do NOT pass `--detach` when running through torsocks with systemd, (see
+  [utils/systemd/monerod.service](utils/systemd/monerod.service) for details).

-or:
+Example command line to start monerod through Tor:

-`DNS_PUBLIC=tcp TORSOCKS_ALLOW_INBOUND=1 torsocks monerod --p2p-bind-ip 127.0.0.1 --no-igd`
+    DNS_PUBLIC=tcp torsocks monerod --p2p-bind-ip 127.0.0.1 --no-igd

-TAILS ships with a very restrictive set of firewall rules. Therefore, you need to add a rule to allow this connection too, in addition to telling torsocks to allow inbound connections. Full example:
+### Using Tor on Tails

-`sudo iptables -I OUTPUT 2 -p tcp -d 127.0.0.1 -m tcp --dport 18081 -j ACCEPT`
+TAILS ships with a very restrictive set of firewall rules. Therefore, you need
+to add a rule to allow this connection too, in addition to telling torsocks to
+allow inbound connections. Full example:

-`DNS_PUBLIC=tcp torsocks ./monerod --p2p-bind-ip 127.0.0.1 --no-igd --rpc-bind-ip 127.0.0.1 --data-dir /home/amnesia/Persistent/your/directory/to/the/blockchain`
+    sudo iptables -I OUTPUT 2 -p tcp -d 127.0.0.1 -m tcp --dport 18081 -j ACCEPT
+    DNS_PUBLIC=tcp torsocks ./monerod --p2p-bind-ip 127.0.0.1 --no-igd --rpc-bind-ip 127.0.0.1 \
+        --data-dir /home/amnesia/Persistent/your/directory/to/the/blockchain

-`./monero-wallet-cli`
+## Debugging

-## Using readline
+This section contains general instructions for debugging failed installs or problems encountered with Monero. First ensure you are running the latest version built from the Github repo.

-While monerod and monero-wallet-cli do not use readline directly, most of the functionality can be obtained by running them via rlwrap. This allows command recall, edit capabilities, etc. It does not give autocompletion without an extra completion file, however. To use rlwrap, simply prepend `rlwrap` to the command line, eg:
-
-`rlwrap bin/monero-wallet-cli --wallet-file /path/to/wallet`
-
-Note: rlwrap will save things like your seed and private keys, if you supply them on prompt. You may want to not use rlwrap when you use simplewallet to restore from seed, etc.
-
-# Debugging
-
-This section contains general instructions for debugging failed installs or problems encountered with Monero. First ensure you are running the latest version built from the github repo.
-
-## Obtaining Stack Traces and Core Dumps on Unix Systems
+### Obtaining stack traces and core dumps on Unix systems

 We generally use the tool `gdb` (GNU debugger) to provide stack trace functionality, and `ulimit` to provide core dumps in builds which crash or segfault.

@@ -426,9 +586,11 @@ Type `thread apply all bt` within gdb in order to obtain the stack trace

 Enter `ulimit -c unlimited` on the command line to enable unlimited filesizes for core dumps

+Enter `echo core | sudo tee /proc/sys/kernel/core_pattern` to stop cores from being hijacked by other tools
+
 Run the build.

-When it terminates with an output along the lines of "Segmentation fault (core dumped)", there should be a core dump file in the same directory as monerod.
+When it terminates with an output along the lines of "Segmentation fault (core dumped)", there should be a core dump file in the same directory as monerod. It may be named just `core`, or `core.xxxx` with numbers appended.

 You can now analyse this core dump with `gdb` as follows:

@@ -444,13 +606,13 @@ Pass command-line options with `--args` followed by the relevant arguments

 Type `run` to run monerod

-## Analysing Memory Corruption
+### Analysing memory corruption

 We use the tool `valgrind` for this.

 Run with `valgrind /path/to/monerod`. It will be slow.

-## LMDB
+### LMDB

 Instructions for debugging suspected blockchain corruption as per @HYC

--- a/VULNERABILITY_RESPONSE_PROCESS.md
+++ b/VULNERABILITY_RESPONSE_PROCESS.md
@@ -1,143 +0,0 @@
-# Monero Vulnerability Response Process
-
-## Preamble
-
-Researchers/Hackers: while you research/hack, we ask that you please refrain from committing the following:
- Denial of Service / Active exploiting against the network
- Social Engineering of Monero staff or contractors
- Any physical or electronic attempts against Monero community property and/or data centers
-
-## I. Point of Contacts for Security Issues
-
-```
-ric@getmonero.org
-BDA6 BD70 42B7 21C4 67A9  759D 7455 C5E3 C0CD CEB9
-
-luigi1111@getmonero.org
-8777 AB8F 778E E894 87A2  F8E7 F4AC A018 3641 E010
-
-moneromooo.monero@gmail.com
-48B0 8161 FBDA DFE3 93AD  FC3E 686F 0745 4D6C EFC3
-```
-
-## II. Security Response Team
-
- fluffypony
- luigi1111
- moneromooo
-
-## III. Incident Response
-
-1. Researcher submits report via one or both of two methods:
-    - a. Email
-    - b. [HackerOne](https://hackerone.com/monero)
-
-2. Response Team designates a Response Manager who is in charge of the particular report based on availability and/or knowledge-set
-
-3. In no more than 3 working days, Response Team should gratefully respond to researcher using only encrypted, secure channels
-
-4. Response Manager makes inquiries to satisfy any needed information to confirm if submission is indeed a vulnerability
-    - a. If submission proves to be vulnerable, proceed to next step
-    - b. If not vulnerable:
-      - i. Response Manager responds with reasons why submission is not a vulnerability
-      - ii. Response Manager moves discussion to a new or existing ticket on GitHub if necessary
-
-5. If over email, Response Manager opens a HackerOne issue for new submission
-
-6. Establish severity of vulnerability:
-    - a. HIGH: impacts network as a whole, has potential to break entire network, results in the loss of monero, or is on a scale of great catastrophe
-    - b. MEDIUM: impacts individual nodes, wallets, or must be carefully exploited
-    - c. LOW: is not easily exploitable
-
-7. Respond according to the severity of the vulnerability:
-    - a. HIGH severities must be notified on website and reddit /r/Monero within 3 working days of classification
-      - i. The notification should list appropriate steps for users to take, if any
-      - ii. The notification must not include any details that could suggest an exploitation path
-      - iii. The latter takes precedence over the former
-    - b. MEDIUM and HIGH severities will require a Point Release
-    - c. LOW severities will be addressed in the next Regular Release
-
-8. Response Team applies appropriate patch(es)
-    - a. Response Manager designates a PRIVATE git "hotfix branch" to work in
-    - b. Patches are reviewed with the researcher
-    - c. Any messages associated with PUBLIC commits during the time of review should not make reference to the security nature of the PRIVATE branch or its commits
-    - d. Vulnerability announcement is drafted
-      - i. Include the severity of the vulnerability
-      - ii. Include all vulnerable systems/apps/code
-      - iii. Include solutions (if any) if patch cannot be applied
-    - e. Release date is discussed
-
-9. At release date, Response Team coordinates with developers to finalize update:
-    - a. Response Manager propagates the "hotfix branch" to trunk
-    - b. Response Manager includes vulnerability announcement draft in release notes
-    - c. Proceed with the Point or Regular Release
-
-## IV. Post-release Disclosure Process
-
-1. Response Team has 90 days to fulfill all points within section III
-
-2. If the Incident Response process in section III is successfully completed:
-    - a. Response Manager contacts researcher and asks if researcher wishes for credit
-    - b. Finalize vulnerability announcement draft and include the following:
-      - i. Project name and URL
-      - ii. Versions known to be affected
-      - iii. Versions known to be not affected (for example, the vulnerable code was introduced in a recent version, and older versions are therefore unaffected)
-      - iv. Versions not checked
-      - v. Type of vulnerability and its impact
-      - vi. If already obtained or applicable, a CVE-ID
-      - vii. The planned, coordinated release date
-      - viii. Mitigating factors (for example, the vulnerability is only exposed in uncommon, non-default configurations)
-      - ix. Workarounds (configuration changes users can make to reduce their exposure to the vulnerability)
-      - x. If applicable, credits to the original reporter
-    - c. Release finalized vulnerability announcement on website and reddit /r/Monero
-    - d. For HIGH severities, release finalized vulnerability announcement on well-known mailing lists:
-      - i. oss-security@lists.openwall.com
-      - ii. bugtraq@securityfocus.com
-    - e. If applicable, developers request a CVE-ID
-      - i. The commit that applied the fix is made reference too in a future commit and includes a CVE-ID
-
-3. If the Incident Response process in section III is *not* successfully completed:
-    - a. Response Team and developers organize an IRC meeting to discuss why/what points in section III were not resolved and how the team can resolve them in the future
-    - b. Any developer meetings immediately following the incident should include points made in section V
-    - c. If disputes arise about whether or when to disclose information about a vulnerability, the Response Team will publicly discuss the issue via IRC and attempt to reach consensus
-    - d. If consensus on a timely disclosure is not met (no later than 90 days), the researcher (after 90 days) has every right to expose the vulnerability to the public
-
-## V. Incident Analysis
-
-1. Isolate codebase
-    - a. Response Team and developers should coordinate to work on the following:
-      - i. Problematic implementation of classes/libraries/functions, etc.
-      - ii. Focus on apps/distro packaging, etc.
-      - iii. Operator/config error, etc.
-
-2. Auditing
-    - a. Response Team and developers should coordinate to work on the following:
-      - i. Auditing of problem area(s) as discussed in point 1
-      - ii. Generate internal reports and store for future reference
-      - iii. If results are not sensitive, share with the public via IRC or GitHub
-
-3. Response Team has 45 days following completion of section III to ensure completion of section V
-
-## VI. Resolutions
-
-Any further questions or resolutions regarding the incident(s) between the researcher and response + development team after public disclosure can be addressed via the following:
-
- [GitHub](https://github.com/monero-project/monero/issues/)
- [HackerOne](https://hackerone.com/monero)
- [Reddit /r/Monero](https://reddit.com/r/Monero/)
- IRC
- Email
-
-## VII. Continuous Improvement
-
-1. Response Team and developers should hold annual meetings to review the previous year's incidents
-
-2. Response Team or designated person(s) should give a brief presentation, including:
-    - a. Areas of Monero affected by the incidents
-    - b. Any network downtime or monetary cost (if any) of the incidents
-    - c. Ways in which the incidents could have been avoided (if any)
-    - d. How effective this process was in dealing with the incidents
-
-3. After the presentation, Response Team and developers should discuss:
-    - a. Potential changes to development processes to reduce future incidents
-    - b. Potential changes to this process to improve future responses
--- a/cmake/32-bit-toolchain.cmake
+++ b/cmake/32-bit-toolchain.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
--- a/cmake/64-bit-toolchain.cmake
+++ b/cmake/64-bit-toolchain.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
--- a/cmake/CheckLinkerFlag.c
+++ b/cmake/CheckLinkerFlag.c
@@ -0,0 +1,14 @@
+#ifdef __CLASSIC_C__
+int main()
+{
+  int ac;
+  char* av[];
+#else
+int main(int ac, char* av[])
+{
+#endif
+  if (ac > 1000) {
+    return *av[0];
+  }
+  return 0;
+}
--- a/cmake/CheckLinkerFlag.cmake
+++ b/cmake/CheckLinkerFlag.cmake
@@ -0,0 +1,47 @@
+include(CheckCCompilerFlag)
+
+macro(CHECK_LINKER_FLAG flag VARIABLE)
+  if(NOT DEFINED "${VARIABLE}")
+    if(NOT CMAKE_REQUIRED_QUIET)
+      message(STATUS "Looking for ${flag} linker flag")
+    endif()
+
+    set(_cle_source ${CMAKE_SOURCE_DIR}/cmake/CheckLinkerFlag.c)
+
+    set(saved_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+    set(CMAKE_C_FLAGS "${flag}")
+    try_compile(${VARIABLE}
+      ${CMAKE_BINARY_DIR}
+      ${_cle_source}
+      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${flag}
+      CMAKE_FLAGS
+      OUTPUT_VARIABLE OUTPUT)
+    unset(_cle_source)
+    set(CMAKE_C_FLAGS ${saved_CMAKE_C_FLAGS})
+    unset(saved_CMAKE_C_FLAGS)
+
+    if ("${OUTPUT}" MATCHES "warning.*ignored")
+      set(${VARIABLE} 0)
+    endif()
+
+    if(${VARIABLE})
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(STATUS "Looking for ${flag} linker flag - found")
+      endif()
+      set(${VARIABLE} 1 CACHE INTERNAL "Have linker flag ${flag}")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+        "Determining if the ${flag} linker flag is supported "
+        "passed with the following output:\n"
+        "${OUTPUT}\n\n")
+    else()
+      if(NOT CMAKE_REQUIRED_QUIET)
+        message(STATUS "Looking for ${flag} linker flag - not found")
+      endif()
+      set(${VARIABLE} "" CACHE INTERNAL "Have linker flag ${flag}")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if the ${flag} linker flag is suppored "
+        "failed with the following output:\n"
+        "${OUTPUT}\n\n")
+    endif()
+  endif()
+endmacro()
--- a/cmake/FindMiniupnpc.cmake
+++ b/cmake/FindMiniupnpc.cmake
@@ -46,13 +46,13 @@ IF(MINIUPNPC_FOUND)
  file(STRINGS "${MINIUPNP_INCLUDE_DIR}/miniupnpc.h" MINIUPNPC_API_VERSION_STR REGEX "^#define[\t ]+MINIUPNPC_API_VERSION[\t ]+[0-9]+")
  if(MINIUPNPC_API_VERSION_STR MATCHES "^#define[\t ]+MINIUPNPC_API_VERSION[\t ]+([0-9]+)")
    set(MINIUPNPC_API_VERSION "${CMAKE_MATCH_1}")
+	if (${MINIUPNPC_API_VERSION} GREATER "10" OR ${MINIUPNPC_API_VERSION} EQUAL "10")
+		message(STATUS "Found miniupnpc API version " ${MINIUPNPC_API_VERSION})
+		set(MINIUPNP_FOUND true)
+		set(MINIUPNPC_VERSION_1_7_OR_HIGHER true)
+	endif()
  endif()

- if (${MINIUPNPC_API_VERSION} GREATER "10" OR ${MINIUPNPC_API_VERSION} EQUAL "10")
-	message(STATUS "Found miniupnpc API version " ${MINIUPNPC_API_VERSION})
-	set(MINIUPNP_FOUND true)
-	set(MINIUPNPC_VERSION_1_7_OR_HIGHER true)
-  endif()
 ENDIF()

 mark_as_advanced(MINIUPNP_INCLUDE_DIR MINIUPNP_LIBRARY MINIUPNP_STATIC_LIBRARY)
--- a/cmake/FindPCSC.cmake
+++ b/cmake/FindPCSC.cmake
@@ -0,0 +1,50 @@
+# - Find PCSC
+# Find the native PCSC includes and library
+#
+#  PCSC_INCLUDE_DIR - where to find winscard.h, wintypes.h, etc.
+#  PCSC_LIBRARIES   - List of libraries when using PCSC.
+#  PCSC_FOUND       - True if PCSC found.
+
+
+IF (PCSC_INCLUDE_DIR AND PCSC_LIBRARIES)
+  # Already in cache, be silent
+  SET(PCSC_FIND_QUIETLY TRUE)
+ENDIF (PCSC_INCLUDE_DIR AND PCSC_LIBRARIES)
+
+IF (NOT WIN32)
+  FIND_PACKAGE(PkgConfig)
+  PKG_CHECK_MODULES(PC_PCSC libpcsclite)
+ENDIF (NOT WIN32)
+
+FIND_PATH(PCSC_INCLUDE_DIR winscard.h
+  HINTS
+  IF (WIN32)
+  ${MSYS2_FOLDER}/mingw64/x86_64-w64-mingw32/include
+  ENDIF (WIN32)
+  /usr/include/PCSC
+  ${PC_PCSC_INCLUDEDIR}
+  ${PC_PCSC_INCLUDE_DIRS}
+  PATH_SUFFIXES PCSC
+  )
+
+FIND_LIBRARY(PCSC_LIBRARY NAMES pcsclite libpcsclite WinSCard PCSC
+  HINTS
+  IF (WIN32)
+  ${MSYS2_FOLDER}/mingw64/x86_64-w64-mingw32/lib
+  ENDIF (WIN32)
+  ${PC_PCSC_LIBDIR}
+  ${PC_PCSC_LIBRARY_DIRS}
+  )
+
+# handle the QUIETLY and REQUIRED arguments and set PCSC_FOUND to TRUE if 
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(PCSC DEFAULT_MSG PCSC_LIBRARY PCSC_INCLUDE_DIR)
+
+IF(PCSC_FOUND)
+  SET( PCSC_LIBRARIES ${PCSC_LIBRARY} )
+ELSE(PCSC_FOUND)
+  SET( PCSC_LIBRARIES )
+ENDIF(PCSC_FOUND)
+
+MARK_AS_ADVANCED( PCSC_LIBRARY PCSC_INCLUDE_DIR )
--- a/cmake/FindReadline.cmake
+++ b/cmake/FindReadline.cmake
@@ -15,8 +15,11 @@
 #
 #  READLINE_FOUND            System has readline, include and lib dirs found
 #  GNU_READLINE_FOUND        Version of readline found is GNU readline, not libedit!
+#  LIBEDIT_FOUND             Version of readline found is libedit, not GNU readline!
 #  Readline_INCLUDE_DIR      The readline include directories. 
 #  Readline_LIBRARY          The readline library.
+#  GNU_READLINE_LIBRARY      The GNU readline library or empty string.
+#  LIBEDIT_LIBRARY           The libedit library or empty string.

 find_path(Readline_ROOT_DIR
    NAMES include/readline/readline.h
@@ -36,14 +39,18 @@ find_library(Readline_LIBRARY
    NO_DEFAULT_PATH
 )

-if(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY)
+find_library(Termcap_LIBRARY
+  NAMES tinfo termcap ncursesw ncurses cursesw curses
+)
+
+if(Readline_INCLUDE_DIR AND Readline_LIBRARY)
  set(READLINE_FOUND TRUE)
-else(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY)
+else(Readline_INCLUDE_DIR AND Readline_LIBRARY)
  FIND_LIBRARY(Readline_LIBRARY NAMES readline PATHS Readline_ROOT_DIR)
  include(FindPackageHandleStandardArgs)
  FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARY )
  MARK_AS_ADVANCED(Readline_INCLUDE_DIR Readline_LIBRARY)
-endif(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY)
+endif(Readline_INCLUDE_DIR AND Readline_LIBRARY)

 mark_as_advanced(
    Readline_ROOT_DIR
@@ -53,14 +60,30 @@ mark_as_advanced(

 set(CMAKE_REQUIRED_INCLUDES ${Readline_INCLUDE_DIR})
 set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARY})
-INCLUDE(CheckCXXSourceCompiles) 
-CHECK_CXX_SOURCE_COMPILES(
-"
-#include <stdio.h>
-#include <readline/readline.h>
-int
-main()
-{
-  char * s  = rl_copy_text(0, 0);
-}
-" GNU_READLINE_FOUND)
+
+include(CheckFunctionExists)
+check_function_exists(rl_copy_text HAVE_COPY_TEXT)
+check_function_exists(rl_filename_completion_function HAVE_COMPLETION_FUNCTION)
+
+if(NOT HAVE_COMPLETION_FUNCTION)
+  set(CMAKE_REQUIRED_LIBRARIES ${Readline_LIBRARY} ${Termcap_LIBRARY})
+  check_function_exists(rl_copy_text HAVE_COPY_TEXT_TC)
+  check_function_exists(rl_filename_completion_function HAVE_COMPLETION_FUNCTION_TC)
+  set(HAVE_COMPLETION_FUNCTION ${HAVE_COMPLETION_FUNCTION_TC})
+  set(HAVE_COPY_TEXT ${HAVE_COPY_TEXT_TC})
+  if(HAVE_COMPLETION_FUNCTION)
+    set(Readline_LIBRARY ${Readline_LIBRARY} ${Termcap_LIBRARY})
+  endif(HAVE_COMPLETION_FUNCTION)
+endif(NOT HAVE_COMPLETION_FUNCTION)
+
+set(LIBEDIT_LIBRARY "")
+set(GNU_READLINE_LIBRARY "")
+
+if(HAVE_COMPLETION_FUNCTION AND HAVE_COPY_TEXT)
+  set(GNU_READLINE_FOUND TRUE)
+  set(GNU_READLINE_LIBRARY ${Readline_LIBRARY})
+elseif(READLINE_FOUND AND NOT HAVE_COPY_TEXT)
+  set(LIBEDIT_FOUND TRUE)
+  set(LIBEDIT_LIBRARY ${Readline_LIBRARY})
+endif(HAVE_COMPLETION_FUNCTION AND HAVE_COPY_TEXT)
+
--- a/cmake/FindUnbound.cmake
+++ b/cmake/FindUnbound.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without modification, are
--- a/cmake/GenVersion.cmake
+++ b/cmake/GenVersion.cmake
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -36,7 +36,7 @@ if(RET)
 	
    message(WARNING "Cannot determine current commit. Make sure that you are building either from a Git working tree or from a source archive.")
    set(VERSIONTAG "unknown")
-    configure_file("src/version.h.in" "${TO}")
+    configure_file("src/version.cpp.in" "${TO}")
 else()
 	message(STATUS "You are currently on commit ${COMMIT}")
 	
@@ -59,5 +59,5 @@ else()
        endif()
    endif()	    

-    configure_file("src/version.h.in" "${TO}")
+    configure_file("src/version.cpp.in" "${TO}")
 endif()
--- a/cmake/Version.cmake
+++ b/cmake/Version.cmake
@@ -0,0 +1,52 @@
+# Copyright (c) 2014-2018, The Monero Project
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without modification, are
+# permitted provided that the following conditions are met:
+# 
+# 1. Redistributions of source code must retain the above copyright notice, this list of
+#    conditions and the following disclaimer.
+# 
+# 2. Redistributions in binary form must reproduce the above copyright notice, this list
+#    of conditions and the following disclaimer in the documentation and/or other
+#    materials provided with the distribution.
+# 
+# 3. Neither the name of the copyright holder nor the names of its contributors may be
+#    used to endorse or promote products derived from this software without specific
+#    prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+# THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+function (write_static_version_header hash)
+  set(VERSIONTAG "${hash}")
+  configure_file("${CMAKE_SOURCE_DIR}/src/version.cpp.in" "${CMAKE_BINARY_DIR}/version.cpp")
+endfunction ()
+
+find_package(Git QUIET)
+if ("$Format:$" STREQUAL "")
+  # We're in a tarball; use hard-coded variables.
+  write_static_version_header("release")
+elseif (GIT_FOUND OR Git_FOUND)
+  message(STATUS "Found Git: ${GIT_EXECUTABLE}")
+  add_custom_command(
+    OUTPUT            "${CMAKE_BINARY_DIR}/version.cpp"
+    COMMAND           "${CMAKE_COMMAND}"
+                      "-D" "GIT=${GIT_EXECUTABLE}"
+                      "-D" "TO=${CMAKE_BINARY_DIR}/version.cpp"
+                      "-P" "cmake/GenVersion.cmake"
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
+else()
+  message(STATUS "WARNING: Git was not found!")
+  write_static_version_header("unknown")
+endif ()
+add_custom_target(genversion ALL
+  DEPENDS "${CMAKE_BINARY_DIR}/version.cpp")
--- a/cmake/test-static-assert.c
+++ b/cmake/test-static-assert.c
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
--- a/cmake/test-static-assert.cpp
+++ b/cmake/test-static-assert.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -26,5 +26,10 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+# warnings are cleared only for GCC on Linux
+if (NOT (MINGW OR APPLE OR FREEBSD OR OPENBSD OR DRAGONFLY))
+  add_compile_options("${WARNINGS_AS_ERRORS_FLAG}") # applies only to targets that follow
+endif()
+
 add_subdirectory(epee)

--- a/contrib/epee/CMakeLists.txt
+++ b/contrib/epee/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
--- a/contrib/epee/include/console_handler.h
+++ b/contrib/epee/include/console_handler.h
@@ -27,6 +27,7 @@
 #pragma once

 #include "misc_log_ex.h"
+#include "string_tools.h"
 #include <atomic>
 #include <condition_variable>
 #include <functional>
@@ -37,6 +38,8 @@
 #include <stdio.h>
 #endif
 #include <boost/thread.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>

 #ifdef HAVE_READLINE
  #include "readline_buffer.h"
@@ -52,11 +55,10 @@ namespace epee
      , m_has_read_request(false)
      , m_read_status(state_init)
    {
-      m_reader_thread = boost::thread(std::bind(&async_stdin_reader::reader_thread_func, this));
 #ifdef HAVE_READLINE
      m_readline_buffer.start();
-      m_readline_thread = boost::thread(std::bind(&async_stdin_reader::readline_thread_func, this));
 #endif
+      m_reader_thread = boost::thread(std::bind(&async_stdin_reader::reader_thread_func, this));
    }

    ~async_stdin_reader()
@@ -115,7 +117,6 @@ namespace epee
        m_reader_thread.join();
 #ifdef HAVE_READLINE
        m_readline_buffer.stop();
-        m_readline_thread.join();
 #endif
      }
    }
@@ -193,16 +194,6 @@ namespace epee
      return true;
    }

-#ifdef HAVE_READLINE
-    void readline_thread_func()
-    {
-      while (m_run.load(std::memory_order_relaxed))
-      {
-        m_readline_buffer.process();
-      }
-    }
-#endif
-
    void reader_thread_func()
    {
      while (true)
@@ -212,12 +203,20 @@ namespace epee

        std::string line;
        bool read_ok = true;
+#ifdef HAVE_READLINE
+reread:
+#endif
        if (wait_stdin_data())
        {
          if (m_run.load(std::memory_order_relaxed))
          {
 #ifdef HAVE_READLINE
-            m_readline_buffer.get_line(line);
+            switch (m_readline_buffer.get_line(line))
+            {
+            case rdln::empty:   goto eof;
+            case rdln::partial: goto reread;
+            case rdln::full:    break;
+            }
 #else
            std::getline(std::cin, line);
 #endif
@@ -229,6 +228,9 @@ namespace epee
          read_ok = false;
        }
        if (std::cin.eof()) {
+#ifdef HAVE_READLINE
+eof:
+#endif
          m_read_status = state_eos;
          m_response_cv.notify_one();
          break;
@@ -263,7 +265,6 @@ namespace epee
    boost::thread m_reader_thread;
    std::atomic<bool> m_run;
 #ifdef HAVE_READLINE
-    boost::thread m_readline_thread;
    rdln::readline_buffer m_readline_buffer;
 #endif

@@ -458,29 +459,35 @@ namespace epee
  class command_handler {
  public:
    typedef boost::function<bool (const std::vector<std::string> &)> callback;
-    typedef std::map<std::string, std::pair<callback, std::string> > lookup;
+    typedef std::map<std::string, std::pair<callback, std::pair<std::string, std::string>>> lookup;

    std::string get_usage()
    {
      std::stringstream ss;
-      size_t max_command_len = 0;
-      for(auto& x:m_command_handlers)
-        if(x.first.size() > max_command_len)
-          max_command_len = x.first.size();

      for(auto& x:m_command_handlers)
      {
-        ss.width(max_command_len + 3);
-        ss << std::left <<  x.first << x.second.second << ENDL;
+        ss << x.second.second.first << ENDL;
      }
      return ss.str();
    }

-    void set_handler(const std::string& cmd, const callback& hndlr, const std::string& usage = "")
+    std::pair<std::string, std::string> get_documentation(const std::vector<std::string>& cmd)
+    {
+      if(cmd.empty())
+        return std::make_pair("", "");
+      auto it = m_command_handlers.find(cmd.front());
+      if(it == m_command_handlers.end())
+        return std::make_pair("", "");
+      return it->second.second;
+    }
+
+    void set_handler(const std::string& cmd, const callback& hndlr, const std::string& usage = "", const std::string& description = "")
    {
      lookup::mapped_type & vt = m_command_handlers[cmd];
      vt.first = hndlr;
-      vt.second = usage;
+      vt.second.first = description.empty() ? cmd : usage;
+      vt.second.second = description.empty() ? usage : description;
 #ifdef HAVE_READLINE
      rdln::readline_buffer::add_completion(cmd);
 #endif
--- a/contrib/epee/include/copyable_atomic.h
+++ b/contrib/epee/include/copyable_atomic.h
@@ -35,6 +35,8 @@ namespace epee
  public:
    copyable_atomic()
    {};
+    copyable_atomic(uint32_t value)
+    { store(value); }
    copyable_atomic(const copyable_atomic& a):std::atomic<uint32_t>(a.load())
    {}
    copyable_atomic& operator= (const copyable_atomic& a)
--- a/contrib/epee/include/file_io_utils.h
+++ b/contrib/epee/include/file_io_utils.h
@@ -29,7 +29,33 @@
 #define _FILE_IO_UTILS_H_

 #include <iostream>
-#include <boost/filesystem.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+// On Windows there is a problem with non-ASCII characters in path and file names
+// as far as support by the standard components used is concerned:
+
+// The various file stream classes, e.g. std::ifstream and std::ofstream, are
+// part of the GNU C++ Library / libstdc++. On the most basic level they use the
+// fopen() call as defined / made accessible to programs compiled within MSYS2
+// by the stdio.h header file maintained by the MinGW project.
+
+// The critical point: The implementation of fopen() is part of MSVCRT, the
+// Microsoft Visual C/C++ Runtime Library, and this method does NOT offer any
+// Unicode support.
+
+// Monero code that would want to continue to use the normal file stream classes
+// but WITH Unicode support could therefore not solve this problem on its own,
+// but 2 different projects from 2 different maintaining groups would need changes
+// in this particular direction - something probably difficult to achieve and
+// with a long time to wait until all new versions / releases arrive.
+
+// Implemented solution approach: Circumvent the problem by stopping to use std
+// file stream classes on Windows and directly use Unicode-capable WIN32 API
+// calls. Most of the code doing so is concentrated in this header file here.

 namespace epee
 {
@@ -45,7 +71,22 @@ namespace file_io_utils
 	inline
 		bool save_string_to_file(const std::string& path_to_file, const std::string& str)
 	{
-
+#ifdef WIN32
+                WCHAR wide_path[1000];
+                int chars = MultiByteToWideChar(CP_UTF8, 0, path_to_file.c_str(), path_to_file.size() + 1, wide_path, 1000);
+                if (chars == 0)
+                    return false;
+                HANDLE file_handle = CreateFileW(wide_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                DWORD bytes_written;
+                DWORD bytes_to_write = (DWORD)str.size();
+                BOOL result = WriteFile(file_handle, str.data(), bytes_to_write, &bytes_written, NULL);
+                CloseHandle(file_handle);
+                if (bytes_written != bytes_to_write)
+                    result = FALSE;
+                return result;
+#else
 		try
 		{
 			std::ofstream fstream;
@@ -60,10 +101,11 @@ namespace file_io_utils
 		{
 			return false;
 		}
+#endif
 	}

 	inline
-	bool get_file_time(const std::string& path_to_file, OUT time_t& ft)
+	bool get_file_time(const std::string& path_to_file, time_t& ft)
 	{
 		boost::system::error_code ec;
 		ft = boost::filesystem::last_write_time(boost::filesystem::path(path_to_file), ec);
@@ -88,6 +130,27 @@ namespace file_io_utils
 	inline
 		bool load_file_to_string(const std::string& path_to_file, std::string& target_str)
 	{
+#ifdef WIN32
+                WCHAR wide_path[1000];
+                int chars = MultiByteToWideChar(CP_UTF8, 0, path_to_file.c_str(), path_to_file.size() + 1, wide_path, 1000);
+                if (chars == 0)
+                    return false;
+                HANDLE file_handle = CreateFileW(wide_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                DWORD file_size = GetFileSize(file_handle, NULL);
+                if ((file_size == INVALID_FILE_SIZE) || (file_size > 1000000000)) {
+                    CloseHandle(file_handle);
+                    return false;
+                }
+                target_str.resize(file_size);
+                DWORD bytes_read;
+                BOOL result = ReadFile(file_handle, &target_str[0], file_size, &bytes_read, NULL);
+                CloseHandle(file_handle);
+                if (bytes_read != file_size)
+                    result = FALSE;
+                return result;
+#else
 		try
 		{
 			std::ifstream fstream;
@@ -112,11 +175,13 @@ namespace file_io_utils
 		{
 			return false;
 		}
+#endif
 	}

 	inline
 		bool append_string_to_file(const std::string& path_to_file, const std::string& str)
 	{
+                // No special Windows implementation because so far not used in Monero code
 		try
 		{
 			std::ofstream fstream;
@@ -132,6 +197,43 @@ namespace file_io_utils
 			return false;
 		}
 	}
+
+	inline
+		bool get_file_size(const std::string& path_to_file, uint64_t &size)
+	{
+#ifdef WIN32
+                WCHAR wide_path[1000];
+                int chars = MultiByteToWideChar(CP_UTF8, 0, path_to_file.c_str(), path_to_file.size() + 1, wide_path, 1000);
+                if (chars == 0)
+                    return false;
+                HANDLE file_handle = CreateFileW(wide_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+                if (file_handle == INVALID_HANDLE_VALUE)
+                    return false;
+                LARGE_INTEGER file_size;
+                BOOL result = GetFileSizeEx(file_handle, &file_size);
+                CloseHandle(file_handle);
+                if (result) {
+                    size = file_size.QuadPart;
+                }
+                return size;
+#else
+		try
+		{
+			std::ifstream fstream;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::in | std::ios::ate);
+			size = fstream.tellg();
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+#endif
+	}
+
 }
 }

--- a/contrib/epee/include/hex.h
+++ b/contrib/epee/include/hex.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017, The Monero Project
+// Copyright (c) 2017-2018, The Monero Project
 //
 // All rights reserved.
 //
--- a/contrib/epee/include/math_helper.h
+++ b/contrib/epee/include/math_helper.h
@@ -37,6 +37,7 @@
 #include <boost/uuid/random_generator.hpp>

 #include "misc_os_dependent.h"
+#include "syncobj.h"

 namespace epee
 {
--- a/contrib/epee/include/memwipe.h
+++ b/contrib/epee/include/memwipe.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2017-2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#pragma once
+
+#ifdef __cplusplus
+#include <array>
+
+extern "C" {
+#endif
+
+void *memwipe(void *src, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+namespace tools {
+
+  /// Scrubs data in the contained type upon destruction.
+  ///
+  /// Primarily useful for making sure that private keys don't stick around in
+  /// memory after the objects that held them have gone out of scope.
+  template <class T>
+  struct scrubbed : public T {
+    using type = T;
+
+    ~scrubbed() {
+      scrub();
+    }
+
+    /// Destroy the contents of the contained type.
+    void scrub() {
+      static_assert(std::is_pod<T>::value,
+                    "T cannot be auto-scrubbed. T must be POD.");
+      static_assert(std::is_trivially_destructible<T>::value,
+                    "T cannot be auto-scrubbed. T must be trivially destructable.");
+      memwipe(this, sizeof(T));
+    }
+  };
+
+  template<typename T>
+  T& unwrap(scrubbed<T>& src) { return src; }
+
+  template<typename T>
+  const T& unwrap(scrubbed<T> const& src) { return src; }
+
+  template <class T, size_t N>
+  using scrubbed_arr = scrubbed<std::array<T, N>>;
+} // namespace tools
+
+#endif // __cplusplus
--- a/contrib/epee/include/misc_log_ex.h
+++ b/contrib/epee/include/misc_log_ex.h
@@ -28,30 +28,12 @@
 #ifndef _MISC_LOG_EX_H_
 #define _MISC_LOG_EX_H_

-#include "static_initializer.h"
-#include "string_tools.h"
-#include "time_helper.h"
-#include "misc_os_dependent.h"
-
-#include "syncobj.h"
-
-#include <iostream>
-#include <sstream>
-#include <iomanip>
-#include <fstream>
-#include <algorithm>
-#include <list>
-#include <map>
 #include <string>
-#include <time.h>
-#include <boost/cstdint.hpp>
-#include <boost/thread.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>

 #include "easylogging++.h"

 #define MONERO_DEFAULT_LOG_CATEGORY "default"
+#define MAX_LOG_FILE_SIZE 104850000 // 100 MB - 7600 bytes

 #define MCFATAL(cat,x) CLOG(FATAL,cat) << x
 #define MCERROR(cat,x) CLOG(ERROR,cat) << x
@@ -104,9 +86,9 @@
 #define _dbg2(x) MDEBUG(x)
 #define _dbg1(x) MDEBUG(x)
 #define _info(x) MINFO(x)
-#define _note(x) MINFO(x)
-#define _fact(x) MINFO(x)
-#define _mark(x) MINFO(x)
+#define _note(x) MDEBUG(x)
+#define _fact(x) MDEBUG(x)
+#define _mark(x) MDEBUG(x)
 #define _warn(x) MWARNING(x)
 #define _erro(x) MERROR(x)

@@ -123,8 +105,9 @@
 #endif

 std::string mlog_get_default_log_path(const char *default_filename);
-void mlog_configure(const std::string &filename_base, bool console);
+void mlog_configure(const std::string &filename_base, bool console, const std::size_t max_log_file_size = MAX_LOG_FILE_SIZE);
 void mlog_set_categories(const char *categories);
+std::string mlog_get_categories();
 void mlog_set_log_level(int level);
 void mlog_set_log(const char *log);

@@ -167,7 +150,7 @@ namespace debug


 #define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());}
-#define CHECK_AND_ASSERT_THROW_MES(expr, message) {if(!(expr)) ASSERT_MES_AND_THROW(message);}
+#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0)


 #ifndef CHECK_AND_ASSERT
--- a/contrib/epee/include/misc_os_dependent.h
+++ b/contrib/epee/include/misc_os_dependent.h
@@ -23,6 +23,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
+#ifdef _WIN32
+#include <Winsock2.h>
+#endif
+
 #ifdef WIN32
  #ifndef WIN32_LEAN_AND_MEAN 
  #define WIN32_LEAN_AND_MEAN
@@ -42,6 +46,9 @@
 #include <mach/mach.h>
 #endif

+#include <iostream>
+#include <boost/lexical_cast.hpp>
+
 #pragma once 
 namespace epee
 {
@@ -68,13 +75,13 @@ namespace misc_utils
                clock_get_time(cclock, &mts);
                mach_port_deallocate(mach_task_self(), cclock);

-                return (mts.tv_sec * 1000000000) + (mts.tv_nsec);
+                return ((uint64_t)mts.tv_sec * 1000000000) + (mts.tv_nsec);
 #else
                struct timespec ts;
                if(clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
                        return 0;
                }
-                return (ts.tv_sec * 1000000000) + (ts.tv_nsec);
+                return ((uint64_t)ts.tv_sec * 1000000000) + (ts.tv_nsec);
 #endif
        }

--- a/contrib/epee/include/net/abstract_tcp_server.h
+++ b/contrib/epee/include/net/abstract_tcp_server.h
@@ -305,7 +305,7 @@ namespace net_utils
 		m_connections.back().powner = this;
 		m_connections.back().m_self_it = --m_connections.end();
 		m_connections.back().m_context.m_remote_address = remote_address;
-		m_connections.back().m_htread = threads_helper::create_thread(ConnectionHandlerProc, &m_connections.back());
+		m_connections.back().m_htread = threads_helper::create_thread(ConnectionHandlerProc, &m_connections.back()); // ugh, seems very risky

 		return true;
 	}
--- a/contrib/epee/include/net/abstract_tcp_server2.h
+++ b/contrib/epee/include/net/abstract_tcp_server2.h
@@ -54,8 +54,8 @@
 #include <boost/thread/thread.hpp>
 #include "net_utils_base.h"
 #include "syncobj.h"
-#include "../../../../src/p2p/connection_basic.hpp"
-#include "../../../../src/p2p/network_throttle-detail.hpp"
+#include "connection_basic.hpp"
+#include "network_throttle-detail.hpp"

 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"
@@ -207,12 +207,18 @@ namespace net_utils

    bool connect(const std::string& adr, const std::string& port, uint32_t conn_timeot, t_connection_context& cn, const std::string& bind_ip = "0.0.0.0");
    template<class t_callback>
-    bool connect_async(const std::string& adr, const std::string& port, uint32_t conn_timeot, t_callback cb, const std::string& bind_ip = "0.0.0.0");
+    bool connect_async(const std::string& adr, const std::string& port, uint32_t conn_timeot, const t_callback &cb, const std::string& bind_ip = "0.0.0.0");

    typename t_protocol_handler::config_type& get_config_object(){return m_config;}

    int get_binded_port(){return m_port;}

+    long get_connections_count() const
+    {
+      auto connections_count = (m_sock_count > 0) ? (m_sock_count - 1) : 0; // Socket count minus listening socket
+      return connections_count;
+    }
+
    boost::asio::io_service& get_io_service(){return io_service_;}

    struct idle_callback_conext_base
@@ -281,8 +287,6 @@ namespace net_utils

    bool is_thread_worker();

-    bool cleanup_connections();
-
    /// The io_service used to perform asynchronous operations.
    std::unique_ptr<boost::asio::io_service> m_io_service_local_instance;
    boost::asio::io_service& io_service_;    
@@ -309,7 +313,7 @@ namespace net_utils
    connection_ptr new_connection_;

    boost::mutex connections_mutex;
-    std::deque<std::pair<boost::system_time, connection_ptr>> connections_;
+    std::set<connection_ptr> connections_;

  }; // class <>boosted_tcp_server

--- a/contrib/epee/include/net/abstract_tcp_server2.inl
+++ b/contrib/epee/include/net/abstract_tcp_server2.inl
@@ -41,7 +41,8 @@
 #include <boost/utility/value_init.hpp>
 #include <boost/asio/deadline_timer.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp> // TODO
-#include <boost/thread/v2/thread.hpp> // TODO
+#include <boost/thread/thread.hpp> // TODO
+#include <boost/thread/condition_variable.hpp> // TODO
 #include "misc_language.h"
 #include "pragma_comp_defs.h"

@@ -54,8 +55,6 @@
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"

-#define CONNECTION_CLEANUP_TIME 30 // seconds
-
 PRAGMA_WARNING_PUSH
 namespace epee
 {
@@ -82,7 +81,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 		m_throttle_speed_in("speed_in", "throttle_speed_in"),
 		m_throttle_speed_out("speed_out", "throttle_speed_out")
  {
-    MINFO("test, connection constructor set m_connection_type="<<m_connection_type);
+    MDEBUG("test, connection constructor set m_connection_type="<<m_connection_type);
  }
 PRAGMA_WARNING_DISABLE_VS(4355)
  //---------------------------------------------------------------------------------
@@ -139,14 +138,14 @@ PRAGMA_WARNING_DISABLE_VS(4355)
    CHECK_AND_NO_ASSERT_MES(!ec, false, "Failed to get local endpoint: " << ec.message() << ':' << ec.value());

    context = boost::value_initialized<t_connection_context>();
-    long ip_ = boost::asio::detail::socket_ops::host_to_network_long(remote_ep.address().to_v4().to_ulong());
+    const unsigned long ip_{boost::asio::detail::socket_ops::host_to_network_long(remote_ep.address().to_v4().to_ulong())};

    // create a random uuid
    boost::uuids::uuid random_uuid;
    // that stuff turns out to be included, even though it's from src... Taking advantage
    random_uuid = crypto::rand<boost::uuids::uuid>();

-    context.set_details(random_uuid, new epee::net_utils::ipv4_network_address(ip_, remote_ep.port()), is_income);
+    context.set_details(random_uuid, epee::net_utils::ipv4_network_address(ip_, remote_ep.port()), is_income);
    _dbg3("[sock " << socket_.native_handle() << "] new connection from " << print_connection_context_short(context) <<
      " to " << local_ep.address().to_string() << ':' << local_ep.port() <<
      ", total sockets objects " << m_ref_sock_count);
@@ -266,7 +265,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
      address = endpoint.address().to_string();
      port = boost::lexical_cast<std::string>(endpoint.port());
    }
-    MINFO(" connection type " << to_string( m_connection_type ) << " "
+    MDEBUG(" connection type " << to_string( m_connection_type ) << " "
        << socket_.local_endpoint().address().to_string() << ":" << socket_.local_endpoint().port()
        << " <--> " << address << ":" << port);
  }
@@ -288,7 +287,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
    
    {
 			CRITICAL_REGION_LOCAL(	epee::net_utils::network_throttle_manager::network_throttle_manager::m_lock_get_global_throttle_in );
-			epee::net_utils::network_throttle_manager::network_throttle_manager::get_global_throttle_in().handle_trafic_exact(bytes_transferred * 1024);
+			epee::net_utils::network_throttle_manager::network_throttle_manager::get_global_throttle_in().handle_trafic_exact(bytes_transferred);
 		}

 		double delay=0; // will be calculated - how much we should sleep to obey speed limit etc
@@ -299,7 +298,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 			{
 				{ //_scope_dbg1("CRITICAL_REGION_LOCAL");
 					CRITICAL_REGION_LOCAL(	epee::net_utils::network_throttle_manager::m_lock_get_global_throttle_in );
-					delay = epee::net_utils::network_throttle_manager::get_global_throttle_in().get_sleep_time_after_tick( bytes_transferred ); // decission from global throttle
+					delay = epee::net_utils::network_throttle_manager::get_global_throttle_in().get_sleep_time_after_tick( bytes_transferred );
 				}
 				
 				delay *= 0.5;
@@ -484,9 +483,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
    //some data should be wrote to stream
    //request complete
    
-		if (speed_limit_is_enabled()) {
-			sleep_before_packet(cb, 1, 1);
-		}
+    // No sleeping here; sleeping is done once and for all in "handle_write"

    m_send_que_lock.lock(); // *** critical ***
    epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){m_send_que_lock.unlock();});
@@ -609,6 +606,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
    }
    logger_handle_net_write(cb);

+                // The single sleeping that is needed for correctly handling "out" speed throttling
 		if (speed_limit_is_enabled()) {
 			sleep_before_packet(cb, 1, 1);
 		}
@@ -738,7 +736,17 @@ PRAGMA_WARNING_DISABLE_VS(4355)
      boost::asio::placeholders::error));

    return true;
-    CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::init_server", false);
+    }
+    catch (const std::exception &e)
+    {
+      MFATAL("Error starting server: " << e.what());
+      return false;
+    }
+    catch (...)
+    {
+      MFATAL("Error starting server");
+      return false;
+    }
  }
  //-----------------------------------------------------------------------------
 PUSH_WARNINGS
@@ -808,7 +816,6 @@ POP_WARNINGS
    m_threads_count = threads_count;
    m_main_thread_id = boost::this_thread::get_id();
    MLOG_SET_THREAD_NAME("[SRV_MAIN]");
-    add_idle_handler(boost::bind(&boosted_tcp_server::cleanup_connections, this), 5000);
    while(!m_stop_signal_sent)
    {

@@ -898,7 +905,7 @@ POP_WARNINGS
    connections_mutex.lock();
    for (auto &c: connections_)
    {
-      c.second->cancel();
+      c->cancel();
    }
    connections_.clear();
    connections_mutex.unlock();
@@ -907,19 +914,6 @@ POP_WARNINGS
  }
  //---------------------------------------------------------------------------------
  template<class t_protocol_handler>
-  bool boosted_tcp_server<t_protocol_handler>::cleanup_connections()
-  {
-    connections_mutex.lock();
-    boost::system_time cutoff = boost::get_system_time() - boost::posix_time::seconds(CONNECTION_CLEANUP_TIME);
-    while (!connections_.empty() && connections_.front().first < cutoff)
-    {
-      connections_.pop_front();
-    }
-    connections_mutex.unlock();
-    return true;
-  }
-  //---------------------------------------------------------------------------------
-  template<class t_protocol_handler>
  bool boosted_tcp_server<t_protocol_handler>::is_stop_signal_sent()
  {
    return m_stop_signal_sent;
@@ -942,6 +936,9 @@ POP_WARNINGS
        boost::bind(&boosted_tcp_server<t_protocol_handler>::handle_accept, this,
        boost::asio::placeholders::error));

+      boost::asio::socket_base::keep_alive opt(true);
+      conn->socket().set_option(opt);
+
      conn->start(true, 1 < m_threads_count);
      conn->save_dbg_log();
    }else
@@ -958,9 +955,10 @@ POP_WARNINGS

    connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_sock_number, m_pfilter, m_connection_type) );
    connections_mutex.lock();
-    connections_.push_back(std::make_pair(boost::get_system_time(), new_connection_l));
+    connections_.insert(new_connection_l);
    MDEBUG("connections_ size now " << connections_.size());
    connections_mutex.unlock();
+    epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ CRITICAL_REGION_LOCAL(connections_mutex); connections_.erase(new_connection_l); });
    boost::asio::ip::tcp::socket&  sock_ = new_connection_l->socket();
    
    //////////////////////////////////////////////////////////////////////////
@@ -1038,6 +1036,10 @@ POP_WARNINGS

    _dbg3("Connected success to " << adr << ':' << port);

+    // start adds the connection to the config object's list, so we don't need to have it locally anymore
+    connections_mutex.lock();
+    connections_.erase(new_connection_l);
+    connections_mutex.unlock();
    bool r = new_connection_l->start(false, 1 < m_threads_count);
    if (r)
    {
@@ -1057,14 +1059,15 @@ POP_WARNINGS
  }
  //---------------------------------------------------------------------------------
  template<class t_protocol_handler> template<class t_callback>
-  bool boosted_tcp_server<t_protocol_handler>::connect_async(const std::string& adr, const std::string& port, uint32_t conn_timeout, t_callback cb, const std::string& bind_ip)
+  bool boosted_tcp_server<t_protocol_handler>::connect_async(const std::string& adr, const std::string& port, uint32_t conn_timeout, const t_callback &cb, const std::string& bind_ip)
  {
    TRY_ENTRY();    
    connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_sock_number, m_pfilter, m_connection_type) );
    connections_mutex.lock();
-    connections_.push_back(std::make_pair(boost::get_system_time(), new_connection_l));
+    connections_.insert(new_connection_l);
    MDEBUG("connections_ size now " << connections_.size());
    connections_mutex.unlock();
+    epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ CRITICAL_REGION_LOCAL(connections_mutex); connections_.erase(new_connection_l); });
    boost::asio::ip::tcp::socket&  sock_ = new_connection_l->socket();
    
    //////////////////////////////////////////////////////////////////////////
@@ -1113,6 +1116,11 @@ POP_WARNINGS
          {
            _dbg3("[sock " << new_connection_l->socket().native_handle() << "] Connected success to " << adr << ':' << port <<
              " from " << lep.address().to_string() << ':' << lep.port());
+
+            // start adds the connection to the config object's list, so we don't need to have it locally anymore
+            connections_mutex.lock();
+            connections_.erase(new_connection_l);
+            connections_mutex.unlock();
            bool r = new_connection_l->start(false, 1 < m_threads_count);
            if (r)
            {
--- a/contrib/epee/include/net/connection_basic.hpp
+++ b/contrib/epee/include/net/connection_basic.hpp
@@ -8,7 +8,7 @@
 // ! (how ever if in some wonderful juristdictions that is not the case, then why not make another sub-class withat that members and licence it as epee part)
 // ! Working on above premise, IF this is valid in your juristdictions, then consider this code as released as:

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
--- a/contrib/epee/include/net/http_auth.h
+++ b/contrib/epee/include/net/http_auth.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 //
 // All rights reserved.
 //
@@ -33,7 +33,7 @@
 #include <functional>
 #include <string>
 #include <utility>
-
+#include "wipeable_string.h"
 #include "http_base.h"

 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -48,12 +48,12 @@ namespace net_utils
    struct login
    {
      login() : username(), password() {}
-      login(std::string username_, std::string password_)
+      login(std::string username_, wipeable_string password_)
        : username(std::move(username_)), password(std::move(password_))
      {}

      std::string username;
-      std::string password;
+      wipeable_string password;
    };

    //! Implements RFC 2617 digest auth. Digests from RFC 7616 can be added.
@@ -71,8 +71,8 @@ namespace net_utils
        std::uint32_t counter;
      };

-      http_server_auth() : user() {}
-      http_server_auth(login credentials);
+      http_server_auth() : user(), rng() {}
+      http_server_auth(login credentials, std::function<void(size_t, uint8_t*)> r);

      //! \return Auth response, or `boost::none` iff `request` had valid auth.
      boost::optional<http_response_info> get_response(const http_request_info& request)
@@ -81,10 +81,13 @@ namespace net_utils
          return do_get_response(request);
        return boost::none;
      }
+
    private:
      boost::optional<http_response_info> do_get_response(const http_request_info& request);

      boost::optional<session> user;
+
+      std::function<void(size_t, uint8_t*)> rng;
    };

    //! Implements RFC 2617 digest auth. Digests from RFC 7616 can be added.
--- a/contrib/epee/include/net/http_base.h
+++ b/contrib/epee/include/net/http_base.h
@@ -46,6 +46,7 @@ namespace net_utils
 	{

 		enum http_method{
+			http_method_options,
 			http_method_get,
 			http_method_post,
 			http_method_put,
@@ -115,6 +116,7 @@ namespace net_utils
 			std::string m_host;             //"Host:"
 			std::string m_cookie;			//"Cookie:"
 			std::string m_user_agent;	//"User-Agent:"
+			std::string m_origin;           //"Origin:"
 			fields_list m_etc_fields;

 			void clear()
@@ -128,6 +130,7 @@ namespace net_utils
 				m_host.clear();
 				m_cookie.clear();
 				m_user_agent.clear();
+				m_origin.clear();
 				m_etc_fields.clear();
 			}
 		};
@@ -155,7 +158,8 @@ namespace net_utils
 			http_request_info():m_http_method(http_method_unknown), 
 				m_http_ver_hi(0), 
 				m_http_ver_lo(0), 
-				m_have_to_block(false)
+				m_have_to_block(false),
+				m_full_request_buf_size(0)
 			{}

 			http_method			  m_http_method;
--- a/contrib/epee/include/net/http_client.h
+++ b/contrib/epee/include/net/http_client.h
@@ -27,6 +27,7 @@


 #pragma once
+#include <ctype.h>
 #include <boost/shared_ptr.hpp>
 #include <boost/regex.hpp>
 #include <boost/lexical_cast.hpp>
@@ -50,6 +51,7 @@
 #include "http_auth.h"
 #include "to_nonconst_iterator.h"
 #include "net_parse_helpers.h"
+#include "syncobj.h"

 //#include "shlwapi.h"

@@ -66,8 +68,6 @@ namespace epee
 namespace net_utils
 {

-using namespace std; 
-
 	/*struct url 
 	{
 	public:
@@ -237,7 +237,8 @@ using namespace std;
 	namespace http
 	{

-		class http_simple_client: public i_target_handler
+		template<typename net_client_type>
+		class http_simple_client_template: public i_target_handler
 		{
 		private:
 			enum reciev_machine_state
@@ -260,7 +261,7 @@ using namespace std;
 			};


-			blocked_mode_client m_net_client;
+			net_client_type m_net_client;
 			std::string m_host_buff;
 			std::string m_port;
 			http_client_auth m_auth;
@@ -274,9 +275,10 @@ using namespace std;
 			chunked_state m_chunked_state;
 			std::string m_chunked_cache;
 			critical_section m_lock;
+			bool m_ssl;

 		public:
-			explicit http_simple_client()
+			explicit http_simple_client_template()
 				: i_target_handler()
 				, m_net_client()
 				, m_host_buff()
@@ -291,30 +293,35 @@ using namespace std;
 				, m_chunked_state()
 				, m_chunked_cache()
 				, m_lock()
+				, m_ssl(false)
 			{}

-			bool set_server(const std::string& address, boost::optional<login> user)
+			const std::string &get_host() const { return m_host_buff; };
+			const std::string &get_port() const { return m_port; };
+
+			bool set_server(const std::string& address, boost::optional<login> user, bool ssl = false)
 			{
 				http::url_content parsed{};
 				const bool r = parse_url(address, parsed);
 				CHECK_AND_ASSERT_MES(r, false, "failed to parse url: " << address);
-				set_server(std::move(parsed.host), std::to_string(parsed.port), std::move(user));
+				set_server(std::move(parsed.host), std::to_string(parsed.port), std::move(user), ssl);
 				return true;
 			}

-			void set_server(std::string host, std::string port, boost::optional<login> user)
+			void set_server(std::string host, std::string port, boost::optional<login> user, bool ssl = false)
 			{
 				CRITICAL_REGION_LOCAL(m_lock);
 				disconnect();
 				m_host_buff = std::move(host);
 				m_port = std::move(port);
                                m_auth = user ? http_client_auth{std::move(*user)} : http_client_auth{};
+				m_ssl = ssl;
 			}

      bool connect(std::chrono::milliseconds timeout)
      {
        CRITICAL_REGION_LOCAL(m_lock);
-        return m_net_client.connect(m_host_buff, m_port, timeout);
+        return m_net_client.connect(m_host_buff, m_port, timeout, m_ssl);
      }
 			//---------------------------------------------------------------------------
 			bool disconnect()
@@ -389,7 +396,6 @@ using namespace std;
 						res = m_net_client.send(body, timeout);
 					CHECK_AND_ASSERT_MES(res, false, "HTTP_CLIENT: Failed to SEND");

-
 					m_response_info.clear();
 					m_state = reciev_machine_state_header;
 					if (!handle_reciev(timeout))
@@ -424,6 +430,15 @@ using namespace std;
 				CRITICAL_REGION_LOCAL(m_lock);
 				return invoke(uri, "POST", body, timeout, ppresponse_info, additional_params);
 			}
+			//---------------------------------------------------------------------------
+			bool test(const std::string &s, std::chrono::milliseconds timeout) // TEST FUNC ONLY
+			{
+				CRITICAL_REGION_LOCAL(m_lock);
+				m_net_client.set_test_data(s);
+				m_state = reciev_machine_state_header;
+				return handle_reciev(timeout);
+			}
+			//---------------------------------------------------------------------------
 		private: 
 			//---------------------------------------------------------------------------
 			inline bool handle_reciev(std::chrono::milliseconds timeout)
@@ -738,85 +753,107 @@ using namespace std;
 				return true;
 			}
 			//---------------------------------------------------------------------------
-			inline
-				bool parse_header(http_header_info& body_info, const std::string& m_cache_to_process)
-			{ 
-				MTRACE("http_stream_filter::parse_cached_header(*)");
-				
-				STATIC_REGEXP_EXPR_1(rexp_mach_field, 
-					"\n?((Connection)|(Referer)|(Content-Length)|(Content-Type)|(Transfer-Encoding)|(Content-Encoding)|(Host)|(Cookie)|(User-Agent)"
-					//  12            3         4                5              6                   7                  8      9        10
-					"|([\\w-]+?)) ?: ?((.*?)(\r?\n))[^\t ]",	
-					//11             1213   14
-					boost::regex::icase | boost::regex::normal);
-
-				boost::smatch		result;
-				std::string::const_iterator it_current_bound = m_cache_to_process.begin();
-				std::string::const_iterator it_end_bound = m_cache_to_process.end();
-
-
-
-				//lookup all fields and fill well-known fields
-				while( boost::regex_search( it_current_bound, it_end_bound, result, rexp_mach_field, boost::match_default) && result[0].matched) 
-				{
-					const size_t field_val = 13;
-					//const size_t field_etc_name = 11;
-
-					int i = 2; //start position = 2
-					if(result[i++].matched)//"Connection"
-						body_info.m_connection = result[field_val];
-					else if(result[i++].matched)//"Referrer"
-						body_info.m_referer = result[field_val];
-					else if(result[i++].matched)//"Content-Length"
-						body_info.m_content_length = result[field_val];
-					else if(result[i++].matched)//"Content-Type"
-						body_info.m_content_type = result[field_val];
-					else if(result[i++].matched)//"Transfer-Encoding"
-						body_info.m_transfer_encoding = result[field_val];
-					else if(result[i++].matched)//"Content-Encoding"
-						body_info.m_content_encoding = result[field_val];
-					else if(result[i++].matched)//"Host"
-					{	body_info.m_host = result[field_val];
-					string_tools::trim(body_info.m_host);
-					}
-					else if(result[i++].matched)//"Cookie"
-						body_info.m_cookie = result[field_val];
-					else if(result[i++].matched)//"User-Agent"
-						body_info.m_user_agent = result[field_val];
-					else if(result[i++].matched)//e.t.c (HAVE TO BE MATCHED!)
-						body_info.m_etc_fields.emplace_back(result[11], result[field_val]);
-					else
-					{CHECK_AND_ASSERT_MES(false, false, "http_stream_filter::parse_cached_header() not matched last entry in:"<<m_cache_to_process);}
-
-					it_current_bound = result[(int)result.size()-1]. first;
-				}
-				return  true;
-
-			}
-			inline
-				bool analize_first_response_line()
+			inline bool parse_header(http_header_info& body_info, const std::string& m_cache_to_process)
 			{
+				MTRACE("http_stream_filter::parse_cached_header(*)");

-				//First line response, look like this:  "HTTP/1.1 200 OK"
-				STATIC_REGEXP_EXPR_1(rexp_match_first_response_line, "^HTTP/(\\d+).(\\d+) ((\\d)\\d{2})( [^\n]*)?\r?\n", boost::regex::icase | boost::regex::normal);
-				//															1      2      34           5        
-				//size_t match_len = 0;
-				boost::smatch result;
-				if(boost::regex_search( m_header_cache, result, rexp_match_first_response_line, boost::match_default) && result[0].matched)
+				const char *ptr = m_cache_to_process.c_str();
+				while (ptr[0] != '\r' || ptr[1] != '\n')
 				{
-					CHECK_AND_ASSERT_MES(result[1].matched&&result[2].matched, false, "http_stream_filter::handle_invoke_reply_line() assert failed...");
-					m_response_info.m_http_ver_hi   = boost::lexical_cast<int>(result[1]);
-					m_response_info.m_http_ver_lo   = boost::lexical_cast<int>(result[2]);
-					m_response_info.m_response_code = boost::lexical_cast<int>(result[3]);
-					
-					m_header_cache.erase(to_nonsonst_iterator(m_header_cache, result[0].first), to_nonsonst_iterator(m_header_cache, result[0].second));
-					return true;
-				}else
-				{
-					LOG_ERROR("http_stream_filter::handle_invoke_reply_line(): Failed to match first response line:" << m_header_cache);
-					return false;
+					// optional \n
+					if (*ptr == '\n')
+						++ptr;
+					// an identifier composed of letters or -
+					const char *key_pos = ptr;
+					while (isalnum(*ptr) || *ptr == '_' || *ptr == '-')
+						++ptr;
+					const char *key_end = ptr;
+					// optional space (not in RFC, but in previous code)
+					if (*ptr == ' ')
+						++ptr;
+					CHECK_AND_ASSERT_MES(*ptr == ':', true, "http_stream_filter::parse_cached_header() invalid header in: " << m_cache_to_process);
+					++ptr;
+					// optional whitespace, but not newlines - line folding is obsolete, let's ignore it
+					while (isblank(*ptr))
+						++ptr;
+					const char *value_pos = ptr;
+					while (*ptr != '\r' && *ptr != '\n')
+						++ptr;
+					const char *value_end = ptr;
+					// optional trailing whitespace
+					while (value_end > value_pos && isblank(*(value_end-1)))
+						--value_end;
+					if (*ptr == '\r')
+						++ptr;
+					CHECK_AND_ASSERT_MES(*ptr == '\n', true, "http_stream_filter::parse_cached_header() invalid header in: " << m_cache_to_process);
+					++ptr;
+
+					const std::string key = std::string(key_pos, key_end - key_pos);
+					const std::string value = std::string(value_pos, value_end - value_pos);
+					if (!key.empty())
+					{
+						if (!string_tools::compare_no_case(key, "Connection"))
+							body_info.m_connection = value;
+						else if(!string_tools::compare_no_case(key, "Referrer"))
+							body_info.m_referer = value;
+						else if(!string_tools::compare_no_case(key, "Content-Length"))
+							body_info.m_content_length = value;
+						else if(!string_tools::compare_no_case(key, "Content-Type"))
+							body_info.m_content_type = value;
+						else if(!string_tools::compare_no_case(key, "Transfer-Encoding"))
+							body_info.m_transfer_encoding = value;
+						else if(!string_tools::compare_no_case(key, "Content-Encoding"))
+							body_info.m_content_encoding = value;
+						else if(!string_tools::compare_no_case(key, "Host"))
+							body_info.m_host = value;
+						else if(!string_tools::compare_no_case(key, "Cookie"))
+							body_info.m_cookie = value;
+						else if(!string_tools::compare_no_case(key, "User-Agent"))
+							body_info.m_user_agent = value;
+						else if(!string_tools::compare_no_case(key, "Origin"))
+							body_info.m_origin = value;
+						else
+							body_info.m_etc_fields.emplace_back(key, value);
+					}
 				}
+				return true;
+			}
+			//---------------------------------------------------------------------------
+			inline bool analize_first_response_line()
+			{
+				//First line response, look like this:	"HTTP/1.1 200 OK"
+				const char *ptr = m_header_cache.c_str();
+				CHECK_AND_ASSERT_MES(!memcmp(ptr, "HTTP/", 5), false, "Invalid first response line: " + m_header_cache);
+				ptr += 5;
+				CHECK_AND_ASSERT_MES(isdigit(*ptr), false, "Invalid first response line: " + m_header_cache);
+				unsigned long ul;
+				char *end;
+				ul = strtoul(ptr, &end, 10);
+				CHECK_AND_ASSERT_MES(ul <= INT_MAX && *end =='.', false, "Invalid first response line: " + m_header_cache);
+				m_response_info.m_http_ver_hi = ul;
+				ptr = end + 1;
+				CHECK_AND_ASSERT_MES(isdigit(*ptr), false, "Invalid first response line: " + m_header_cache + ", ptr: " << ptr);
+				ul = strtoul(ptr, &end, 10);
+				CHECK_AND_ASSERT_MES(ul <= INT_MAX && isblank(*end), false, "Invalid first response line: " + m_header_cache + ", ptr: " << ptr);
+				m_response_info.m_http_ver_lo = ul;
+				ptr = end + 1;
+				while (isblank(*ptr))
+					++ptr;
+				CHECK_AND_ASSERT_MES(isdigit(*ptr), false, "Invalid first response line: " + m_header_cache);
+				ul = strtoul(ptr, &end, 10);
+				CHECK_AND_ASSERT_MES(ul >= 100 && ul <= 999 && isspace(*end), false, "Invalid first response line: " + m_header_cache);
+				m_response_info.m_response_code = ul;
+				ptr = end;
+				// ignore the optional text, till the end
+				while (*ptr != '\r' && *ptr != '\n')
+					++ptr;
+				if (*ptr == '\r')
+					++ptr;
+				CHECK_AND_ASSERT_MES(*ptr == '\n', false, "Invalid first response line: " << m_header_cache);
+				++ptr;

+				m_header_cache.erase(0, ptr - m_header_cache.c_str());
+				return true;
 			}
 			inline
 				bool set_reply_content_encoder()
@@ -909,7 +946,7 @@ using namespace std;
 				}else
 				{   //Apparently there are no signs of the form of transfer, will receive data until the connection is closed
 					m_state = reciev_machine_state_error;
-					MERROR("Undefinded transfer type, consider http_body_transfer_connection_close method. header: " << m_header_cache);
+					MERROR("Undefined transfer type, consider http_body_transfer_connection_close method. header: " << m_header_cache);
 					return false;
 				} 
 				return false;
@@ -951,6 +988,7 @@ using namespace std;
 				return true;
 			}
 		};
+		typedef http_simple_client_template<blocked_mode_client> http_simple_client;
 	}
 }
 }
--- a/contrib/epee/include/net/http_client_base.h
+++ b/contrib/epee/include/net/http_client_base.h
@@ -38,8 +38,8 @@ namespace epee
      virtual ~i_sub_handler(){}

      virtual bool update_in( std::string& piece_of_transfer)=0;
-      virtual void stop(std::string& OUT collect_remains)=0;
-      virtual bool update_and_stop(std::string& OUT collect_remains, bool& is_changed)
+      virtual void stop(std::string& collect_remains)=0;
+      virtual bool update_and_stop(std::string& collect_remains, bool& is_changed)
      {
        is_changed = true;
        bool res = this->update_in(collect_remains);
@@ -66,7 +66,7 @@ namespace epee
      {
        return m_powner_filter->handle_target_data(piece_of_transfer);
      }
-      virtual void stop(std::string& OUT collect_remains)
+      virtual void stop(std::string& collect_remains)
      {

      }
--- a/contrib/epee/include/net/http_protocol_handler.h
+++ b/contrib/epee/include/net/http_protocol_handler.h
@@ -54,6 +54,7 @@ namespace net_utils
 		struct http_server_config
 		{
 			std::string m_folder;
+			std::vector<std::string> m_access_control_origins;
 			boost::optional<login> m_user;
 			critical_section m_lock;
 		};
@@ -159,6 +160,7 @@ namespace net_utils
 		struct custum_handler_config: public http_server_config
 		{
 			i_http_server_handler<t_connection_context>* m_phandler;
+			std::function<void(size_t, uint8_t*)> rng;
 		};

 		/************************************************************************/
@@ -175,7 +177,7 @@ namespace net_utils
 				: simple_http_connection_handler<t_connection_context>(psnd_hndlr, config),
 					m_config(config),
 					m_conn_context(conn_context),
-					m_auth(m_config.m_user ? http_server_auth{*m_config.m_user} : http_server_auth{})
+					m_auth(m_config.m_user ? http_server_auth{*m_config.m_user, config.rng} : http_server_auth{})
 			{}
 			inline bool handle_request(const http_request_info& query_info, http_response_info& response)
 			{
@@ -193,6 +195,7 @@ namespace net_utils
 				response.m_response_code = 200;
 				response.m_response_comment = "OK";
 				response.m_body.clear();
+
 				return m_config.m_phandler->handle_http_request(query_info, response, m_conn_context);
 			}

--- a/contrib/epee/include/net/http_protocol_handler.inl
+++ b/contrib/epee/include/net/http_protocol_handler.inl
@@ -316,7 +316,10 @@ namespace net_utils
 		CHECK_AND_ASSERT_MES(result[0].matched, false, "simple_http_connection_handler::analize_http_method() assert failed...");
 		http_ver_major = boost::lexical_cast<int>(result[11]);
 		http_ver_minor = boost::lexical_cast<int>(result[12]);
-		if(result[4].matched)
+
+		if(result[3].matched)
+			method = http::http_method_options;
+		else if(result[4].matched)
 			method = http::http_method_get;
 		else if(result[5].matched)
 			method = http::http_method_head;
@@ -342,7 +345,12 @@ namespace net_utils
 		{
 			analize_http_method(result, m_query_info.m_http_method, m_query_info.m_http_ver_hi, m_query_info.m_http_ver_hi);
 			m_query_info.m_URI = result[10];
-      parse_uri(m_query_info.m_URI, m_query_info.m_uri_content);
+			if (!parse_uri(m_query_info.m_URI, m_query_info.m_uri_content))
+			{
+				m_state = http_state_error;
+				MERROR("Failed to parse URI: m_query_info.m_URI");
+				return false;
+			}
 			m_query_info.m_http_method_str = result[2];
 			m_query_info.m_full_request_str = result[0];

@@ -472,8 +480,8 @@ namespace net_utils
 	bool simple_http_connection_handler<t_connection_context>::parse_cached_header(http_header_info& body_info, const std::string& m_cache_to_process, size_t pos)
 	{ 
 		STATIC_REGEXP_EXPR_1(rexp_mach_field, 
-			"\n?((Connection)|(Referer)|(Content-Length)|(Content-Type)|(Transfer-Encoding)|(Content-Encoding)|(Host)|(Cookie)|(User-Agent)"
-			//  12            3         4                5              6                   7                  8      9        10
+			"\n?((Connection)|(Referer)|(Content-Length)|(Content-Type)|(Transfer-Encoding)|(Content-Encoding)|(Host)|(Cookie)|(User-Agent)|(Origin)"
+			//  12            3         4                5              6                   7                  8      9        10           11
 			"|([\\w-]+?)) ?: ?((.*?)(\r?\n))[^\t ]",	
 			//11             1213   14 
 			boost::regex::icase | boost::regex::normal);
@@ -487,8 +495,8 @@ namespace net_utils
 		//lookup all fields and fill well-known fields
 		while( boost::regex_search( it_current_bound, it_end_bound, result, rexp_mach_field, boost::match_default) && result[0].matched) 
 		{
-			const size_t field_val = 13;
-			const size_t field_etc_name = 11;
+			const size_t field_val = 14;
+			const size_t field_etc_name = 12;

 			int i = 2; //start position = 2
 			if(result[i++].matched)//"Connection"
@@ -509,6 +517,8 @@ namespace net_utils
 				body_info.m_cookie = result[field_val];
 			else if(result[i++].matched)//"User-Agent"
 				body_info.m_user_agent = result[field_val];
+			else if(result[i++].matched)//"Origin"
+				body_info.m_origin = result[field_val];
 			else if(result[i++].matched)//e.t.c (HAVE TO BE MATCHED!)
 				body_info.m_etc_fields.push_back(std::pair<std::string, std::string>(result[field_etc_name], result[field_val]));
 			else
@@ -537,17 +547,27 @@ namespace net_utils
  template<class t_connection_context>
 	bool simple_http_connection_handler<t_connection_context>::handle_request_and_send_response(const http::http_request_info& query_info)
 	{
-		http_response_info response;
-		bool res = handle_request(query_info, response);
+		http_response_info response{};
 		//CHECK_AND_ASSERT_MES(res, res, "handle_request(query_info, response) returned false" );
+		bool res = true;
+
+		if (query_info.m_http_method != http::http_method_options)
+		{
+			res = handle_request(query_info, response);
+		}
+		else
+		{
+			response.m_response_code = 200;
+			response.m_response_comment = "OK";
+		}

 		std::string response_data = get_response_header(response);
-		
 		//LOG_PRINT_L0("HTTP_SEND: << \r\n" << response_data + response.m_body);
+
    LOG_PRINT_L3("HTTP_RESPONSE_HEAD: << \r\n" << response_data);
 		
 		m_psnd_hndlr->do_send((void*)response_data.data(), response_data.size());
-		if(response.m_body.size() && (query_info.m_http_method != http::http_method_head))
+		if ((response.m_body.size() && (query_info.m_http_method != http::http_method_head)) || (query_info.m_http_method == http::http_method_options))
 			m_psnd_hndlr->do_send((void*)response.m_body.data(), response.m_body.size());
 		return res;
 	}
@@ -579,7 +599,6 @@ namespace net_utils
 		response.m_response_comment = "OK";
 		response.m_mime_tipe = get_file_mime_tipe(uri_to_path);

-
 		return true;
 	}
 	//-----------------------------------------------------------------------------------
@@ -591,8 +610,12 @@ namespace net_utils
 			"Server: Epee-based\r\n"
 			"Content-Length: ";
 		buf += boost::lexical_cast<std::string>(response.m_body.size()) + "\r\n";
-		buf += "Content-Type: ";
-		buf += response.m_mime_tipe + "\r\n";
+
+		if(!response.m_mime_tipe.empty())
+		{
+			buf += "Content-Type: ";
+			buf += response.m_mime_tipe + "\r\n";
+		}

 		buf += "Last-Modified: ";
 		time_t tm;
@@ -612,6 +635,22 @@ namespace net_utils
 				m_want_close = true;
 			}
 		}
+
+		// Cross-origin resource sharing
+		if(m_query_info.m_header_info.m_origin.size())
+		{
+			if (std::binary_search(m_config.m_access_control_origins.begin(), m_config.m_access_control_origins.end(), m_query_info.m_header_info.m_origin))
+			{
+				buf += "Access-Control-Allow-Origin: ";
+				buf += m_query_info.m_header_info.m_origin;
+				buf += "\r\n";
+				buf += "Access-Control-Expose-Headers: www-authenticate\r\n";
+				if (m_query_info.m_http_method == http::http_method_options)
+					buf += "Access-Control-Allow-Headers: Content-Type, Authorization, X-Requested-With\r\n";
+				buf += "Access-Control-Allow-Methods: POST, PUT, GET, OPTIONS\r\n";
+			}
+		}
+
 		//add additional fields, if it is
 		for(fields_list::const_iterator it = response.m_additional_fields.begin(); it!=response.m_additional_fields.end(); it++)
 			buf += it->first + ":" + it->second + "\r\n";
--- a/contrib/epee/include/net/http_server_impl_base.h
+++ b/contrib/epee/include/net/http_server_impl_base.h
@@ -55,16 +55,22 @@ namespace epee
        : m_net_server(external_io_service)
    {}

-    bool init(const std::string& bind_port = "0", const std::string& bind_ip = "0.0.0.0",
+    bool init(std::function<void(size_t, uint8_t*)> rng, const std::string& bind_port = "0", const std::string& bind_ip = "0.0.0.0",
+      std::vector<std::string> access_control_origins = std::vector<std::string>(),
      boost::optional<net_utils::http::login> user = boost::none)
    {

      //set self as callback handler
      m_net_server.get_config_object().m_phandler = static_cast<t_child_class*>(this);
+      m_net_server.get_config_object().rng = std::move(rng);

      //here set folder for hosting reqests
      m_net_server.get_config_object().m_folder = "";

+      //set access control allow origins if configured
+      std::sort(access_control_origins.begin(), access_control_origins.end());
+      m_net_server.get_config_object().m_access_control_origins = std::move(access_control_origins);
+
      m_net_server.get_config_object().m_user = std::move(user);

      MGINFO("Binding on " << bind_ip << ":" << bind_port);
@@ -112,6 +118,11 @@ namespace epee
      return m_net_server.get_binded_port();
    }

+    long get_connections_count() const
+    {
+      return m_net_server.get_connections_count();
+    }
+
  protected: 
    net_utils::boosted_tcp_server<net_utils::http::http_custom_handler<t_connection_context> > m_net_server;
  };
--- a/contrib/epee/include/net/levin_base.h
+++ b/contrib/epee/include/net/levin_base.h
@@ -87,6 +87,7 @@ namespace levin
    virtual void on_connection_new(t_connection_context& context){};
    virtual void on_connection_close(t_connection_context& context){};

+    virtual ~levin_commands_handler(){}
  };

 #define LEVIN_OK                                        0
--- a/contrib/epee/include/net/levin_client_async.h
+++ b/contrib/epee/include/net/levin_client_async.h
@@ -52,6 +52,7 @@ namespace levin
  class levin_client_async
 	{
    levin_commands_handler* m_pcommands_handler;
+    void (*commands_handler_destroy)(levin_commands_handler*);
 		volatile uint32_t m_is_stop;
 		volatile uint32_t m_threads_count;
 		::critical_section m_send_lock;
@@ -85,9 +86,9 @@ namespace levin
    ::critical_section m_connection_lock;
    net_utils::blocked_mode_client m_transport;
 	public:
-		levin_client_async():m_pcommands_handler(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
+		levin_client_async():m_pcommands_handler(NULL), commands_handler_destroy(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
 		{}
-		levin_client_async(const levin_client_async& /*v*/):m_pcommands_handler(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
+		levin_client_async(const levin_client_async& /*v*/):m_pcommands_handler(NULL), commands_handler_destroy(NULL), m_is_stop(0), m_threads_count(0), m_invoke_data_ready(0), m_invoke_is_active(0)
 		{}
 		~levin_client_async()
 		{
@@ -97,11 +98,16 @@ namespace levin

 			while(boost::interprocess::ipcdetail::atomic_read32(&m_threads_count))
 				::Sleep(100);
+
+			set_handler(NULL);
 		}

-		void set_handler(levin_commands_handler* phandler)
+		void set_handler(levin_commands_handler* phandler, void (*destroy)(levin_commands_handler*) = NULL)
 		{
+			if (commands_handler_destroy && m_pcommands_handler)
+				(*commands_handler_destroy)(m_pcommands_handler);
 			m_pcommands_handler = phandler;
+			m_pcommands_handler_destroy = destroy;
 		}

 		bool connect(uint32_t ip, uint32_t port, uint32_t timeout)
@@ -144,7 +150,7 @@ namespace levin
 			{
 				if( !reconnect() )
 				{
-					LOG_ERROR("Reconnect Failed. Failed to invoke() becouse not connected!");
+					LOG_ERROR("Reconnect Failed. Failed to invoke() because not connected!");
 					return false;
 				}
 			}
--- a/contrib/epee/include/net/levin_protocol_handler.h
+++ b/contrib/epee/include/net/levin_protocol_handler.h
@@ -43,6 +43,8 @@ namespace levin
 	struct protocl_handler_config
 	{
 		levin_commands_handler<t_connection_context>* m_pcommands_handler;
+		void (*m_pcommands_handler_destroy)(levin_commands_handler<t_connection_context>*);
+		~protocl_handler_config() { if (m_pcommands_handler && m_pcommands_handler_destroy) (*m_pcommands_handler_destroy)(m_pcommands_handler); }
 	};

  template<class t_connection_context = net_utils::connection_context_base>
--- a/contrib/epee/include/net/levin_protocol_handler_async.h
+++ b/contrib/epee/include/net/levin_protocol_handler_async.h
@@ -35,6 +35,8 @@

 #include "levin_base.h"
 #include "misc_language.h"
+#include "syncobj.h"
+#include "misc_os_dependent.h"

 #include <random>
 #include <chrono>
@@ -72,29 +74,36 @@ class async_protocol_handler_config

  friend class async_protocol_handler<t_connection_context>;

+  levin_commands_handler<t_connection_context>* m_pcommands_handler;
+  void (*m_pcommands_handler_destroy)(levin_commands_handler<t_connection_context>*);
+
+  void delete_connections (size_t count, bool incoming);
+
 public:
  typedef t_connection_context connection_context;
-  levin_commands_handler<t_connection_context>* m_pcommands_handler;
  uint64_t m_max_packet_size; 
  uint64_t m_invoke_timeout;

  int invoke(int command, const std::string& in_buff, std::string& buff_out, boost::uuids::uuid connection_id);
  template<class callback_t>
-  int invoke_async(int command, const std::string& in_buff, boost::uuids::uuid connection_id, callback_t cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED);
+  int invoke_async(int command, const std::string& in_buff, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED);

  int notify(int command, const std::string& in_buff, boost::uuids::uuid connection_id);
  bool close(boost::uuids::uuid connection_id);
  bool update_connection_context(const t_connection_context& contxt);
  bool request_callback(boost::uuids::uuid connection_id);
  template<class callback_t>
-  bool foreach_connection(callback_t cb);
+  bool foreach_connection(const callback_t &cb);
  template<class callback_t>
-  bool for_connection(const boost::uuids::uuid &connection_id, callback_t cb);
+  bool for_connection(const boost::uuids::uuid &connection_id, const callback_t &cb);
  size_t get_connections_count();
+  void set_handler(levin_commands_handler<t_connection_context>* handler, void (*destroy)(levin_commands_handler<t_connection_context>*) = NULL);

-  async_protocol_handler_config():m_pcommands_handler(NULL), m_max_packet_size(LEVIN_DEFAULT_MAX_PACKET_SIZE)
+  async_protocol_handler_config():m_pcommands_handler(NULL), m_pcommands_handler_destroy(NULL), m_max_packet_size(LEVIN_DEFAULT_MAX_PACKET_SIZE)
  {}
+  ~async_protocol_handler_config() { set_handler(NULL, NULL); }
  void del_out_connections(size_t count);
+  void del_in_connections(size_t count);
 };


@@ -239,7 +248,7 @@ public:
  std::list<boost::shared_ptr<invoke_response_handler_base> > m_invoke_response_handlers;
  
  template<class callback_t>
-  bool add_invoke_response_handler(callback_t cb, uint64_t timeout,  async_protocol_handler& con, int command)
+  bool add_invoke_response_handler(const callback_t &cb, uint64_t timeout,  async_protocol_handler& con, int command)
  {
    CRITICAL_REGION_LOCAL(m_invoke_response_handlers_lock);
    boost::shared_ptr<invoke_response_handler_base> handler(boost::make_shared<anvoke_handler<callback_t>>(cb, timeout, con, command));
@@ -373,12 +382,16 @@ public:
        if(m_cache_in_buffer.size() < m_current_head.m_cb)
        {
          is_continue = false;
-          if(cb >= MIN_BYTES_WANTED && !m_invoke_response_handlers.empty())
+          if(cb >= MIN_BYTES_WANTED)
          {
-            //async call scenario
-            boost::shared_ptr<invoke_response_handler_base> response_handler = m_invoke_response_handlers.front();
-            response_handler->reset_timer();
-            MDEBUG(m_connection_context << "LEVIN_PACKET partial msg received. len=" << cb);
+            CRITICAL_REGION_LOCAL(m_invoke_response_handlers_lock);
+            if (!m_invoke_response_handlers.empty())
+            {
+              //async call scenario
+              boost::shared_ptr<invoke_response_handler_base> response_handler = m_invoke_response_handlers.front();
+              response_handler->reset_timer();
+              MDEBUG(m_connection_context << "LEVIN_PACKET partial msg received. len=" << cb);
+            }
          }
          break;
        }
@@ -519,7 +532,7 @@ public:
  }

  template<class callback_t>
-  bool async_invoke(int command, const std::string& in_buff, callback_t cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
+  bool async_invoke(int command, const std::string& in_buff, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
  {
    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
      boost::bind(&async_protocol_handler::finish_outer_call, this));
@@ -721,32 +734,50 @@ void async_protocol_handler_config<t_connection_context>::del_connection(async_p
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context>
+void async_protocol_handler_config<t_connection_context>::delete_connections(size_t count, bool incoming)
+{
+  std::vector <boost::uuids::uuid> connections;
+  CRITICAL_REGION_BEGIN(m_connects_lock);
+  for (auto& c: m_connects)
+  {
+    if (c.second->m_connection_context.m_is_income == incoming)
+      connections.push_back(c.first);
+  }
+
+  // close random connections from  the provided set
+  // TODO or better just keep removing random elements (performance)
+  unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
+  shuffle(connections.begin(), connections.end(), std::default_random_engine(seed));
+  while (count > 0 && connections.size() > 0)
+  {
+    try
+    {
+      auto i = connections.end() - 1;
+      async_protocol_handler<t_connection_context> *conn = m_connects.at(*i);
+      del_connection(conn);
+      close(*i);
+      connections.erase(i);
+    }
+    catch (const std::out_of_range &e)
+    {
+      MWARNING("Connection not found in m_connects, continuing");
+    }
+    --count;
+  }
+
+  CRITICAL_REGION_END();
+}
+//------------------------------------------------------------------------------------------
+template<class t_connection_context>
 void async_protocol_handler_config<t_connection_context>::del_out_connections(size_t count)
 {
-	std::vector <boost::uuids::uuid> out_connections;
-	CRITICAL_REGION_BEGIN(m_connects_lock);
-	for (auto& c: m_connects)
-	{
-		if (!c.second->m_connection_context.m_is_income)
-			out_connections.push_back(c.first);
-	}
-	
-	if (out_connections.size() == 0)
-		return;
-
-	// close random out connections
-	// TODO or better just keep removing random elements (performance)
-	unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
-	shuffle(out_connections.begin(), out_connections.end(), std::default_random_engine(seed));
-	while (count > 0 && out_connections.size() > 0)
-	{
-		close(*out_connections.begin());
-		del_connection(m_connects.at(*out_connections.begin()));
-		out_connections.erase(out_connections.begin());
-		--count;
-	}
-	
-	CRITICAL_REGION_END();
+  delete_connections(count, false);
+}
+//------------------------------------------------------------------------------------------
+template<class t_connection_context>
+void async_protocol_handler_config<t_connection_context>::del_in_connections(size_t count)
+{
+  delete_connections(count, true);
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context>
@@ -786,7 +817,7 @@ int async_protocol_handler_config<t_connection_context>::invoke(int command, con
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
-int async_protocol_handler_config<t_connection_context>::invoke_async(int command, const std::string& in_buff, boost::uuids::uuid connection_id, callback_t cb, size_t timeout)
+int async_protocol_handler_config<t_connection_context>::invoke_async(int command, const std::string& in_buff, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout)
 {
  async_protocol_handler<t_connection_context>* aph;
  int r = find_and_lock_connection(connection_id, aph);
@@ -794,7 +825,7 @@ int async_protocol_handler_config<t_connection_context>::invoke_async(int comman
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
-bool async_protocol_handler_config<t_connection_context>::foreach_connection(callback_t cb)
+bool async_protocol_handler_config<t_connection_context>::foreach_connection(const callback_t &cb)
 {
  CRITICAL_REGION_LOCAL(m_connects_lock);
  for(auto& c: m_connects)
@@ -807,7 +838,7 @@ bool async_protocol_handler_config<t_connection_context>::foreach_connection(cal
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
-bool async_protocol_handler_config<t_connection_context>::for_connection(const boost::uuids::uuid &connection_id, callback_t cb)
+bool async_protocol_handler_config<t_connection_context>::for_connection(const boost::uuids::uuid &connection_id, const callback_t &cb)
 {
  CRITICAL_REGION_LOCAL(m_connects_lock);
  async_protocol_handler<t_connection_context>* aph = find_connection(connection_id);
@@ -826,6 +857,15 @@ size_t async_protocol_handler_config<t_connection_context>::get_connections_coun
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context>
+void async_protocol_handler_config<t_connection_context>::set_handler(levin_commands_handler<t_connection_context>* handler, void (*destroy)(levin_commands_handler<t_connection_context>*))
+{
+  if (m_pcommands_handler && m_pcommands_handler_destroy)
+    (*m_pcommands_handler_destroy)(m_pcommands_handler);
+  m_pcommands_handler = handler;
+  m_pcommands_handler_destroy = destroy;
+}
+//------------------------------------------------------------------------------------------
+template<class t_connection_context>
 int async_protocol_handler_config<t_connection_context>::notify(int command, const std::string& in_buff, boost::uuids::uuid connection_id)
 {
  async_protocol_handler<t_connection_context>* aph;
--- a/contrib/epee/include/net/net_helper.h
+++ b/contrib/epee/include/net/net_helper.h
@@ -31,21 +31,16 @@

 //#include <Winsock2.h>
 //#include <Ws2tcpip.h>
-#include <boost/lexical_cast.hpp>
-#include <iostream>
-#include <istream>
-#include <ostream>
 #include <string>
+#include <boost/version.hpp>
 #include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
 #include <boost/asio/steady_timer.hpp>
-#include <boost/preprocessor/selection/min.hpp>
 #include <boost/lambda/bind.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/interprocess/detail/atomic.hpp>
 #include "net/net_utils_base.h"
 #include "misc_language.h"
-//#include "profile_tools.h"
-#include "../string_tools.h"

 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"
@@ -85,11 +80,13 @@ namespace net_utils
 		
 	public:
 		inline
-			blocked_mode_client():m_socket(m_io_service), 
-                            m_initialized(false), 
+			blocked_mode_client():m_initialized(false), 
                            m_connected(false), 
                            m_deadline(m_io_service), 
-                            m_shutdowned(0)
+                            m_shutdowned(0),
+                            m_ssl(false),
+                            m_ctx(boost::asio::ssl::context::sslv23),
+                            m_ssl_socket(m_io_service,m_ctx)
 		{
 			
 			
@@ -113,18 +110,25 @@ namespace net_utils
 		}

    inline
-      bool connect(const std::string& addr, int port, std::chrono::milliseconds timeout, const std::string& bind_ip = "0.0.0.0")
+      bool connect(const std::string& addr, int port, std::chrono::milliseconds timeout, bool ssl = false, const std::string& bind_ip = "0.0.0.0")
    {
-      return connect(addr, std::to_string(port), timeout, bind_ip);
+      return connect(addr, std::to_string(port), timeout, ssl, bind_ip);
    }

    inline
-			bool connect(const std::string& addr, const std::string& port, std::chrono::milliseconds timeout, const std::string& bind_ip = "0.0.0.0")
+			bool connect(const std::string& addr, const std::string& port, std::chrono::milliseconds timeout, bool ssl = false, const std::string& bind_ip = "0.0.0.0")
 		{
      m_connected = false;
+      m_ssl = ssl;
 			try
 			{
-				m_socket.close();
+				m_ssl_socket.next_layer().close();
+
+				// Set SSL options
+				// disable sslv2
+				m_ctx.set_options(boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2);
+				m_ctx.set_default_verify_paths();
+
 				// Get a list of endpoints corresponding to the server name.
 				

@@ -147,11 +151,11 @@ namespace net_utils
 				boost::asio::ip::tcp::endpoint remote_endpoint(*iterator);


-				m_socket.open(remote_endpoint.protocol());
+				m_ssl_socket.next_layer().open(remote_endpoint.protocol());
 				if(bind_ip != "0.0.0.0" && bind_ip != "0" && bind_ip != "" )
 				{
 					boost::asio::ip::tcp::endpoint local_endpoint(boost::asio::ip::address::from_string(addr.c_str()), 0);
-					m_socket.bind(local_endpoint);
+					m_ssl_socket.next_layer().bind(local_endpoint);
 				}

 				
@@ -160,17 +164,24 @@ namespace net_utils

 				boost::system::error_code ec = boost::asio::error::would_block;

-				//m_socket.connect(remote_endpoint);
-				m_socket.async_connect(remote_endpoint, boost::lambda::var(ec) = boost::lambda::_1);
+				m_ssl_socket.next_layer().async_connect(remote_endpoint, boost::lambda::var(ec) = boost::lambda::_1);
 				while (ec == boost::asio::error::would_block)
 				{	
 					m_io_service.run_one(); 
 				}
 				
-				if (!ec && m_socket.is_open())
+				if (!ec && m_ssl_socket.next_layer().is_open())
 				{
 					m_connected = true;
 					m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
+					// SSL Options
+					if(m_ssl) {
+						// Disable verification of host certificate
+						m_ssl_socket.set_verify_mode(boost::asio::ssl::verify_peer);
+						// Handshake
+						m_ssl_socket.next_layer().set_option(boost::asio::ip::tcp::no_delay(true));
+						m_ssl_socket.handshake(boost::asio::ssl::stream_base::client);
+					}
 					return true;
 				}else
 				{
@@ -193,7 +204,6 @@ namespace net_utils
 			return true;
 		}

-
 		inline 
 		bool disconnect()
 		{
@@ -202,8 +212,9 @@ namespace net_utils
 				if(m_connected)
 				{
 					m_connected = false;
-					m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
-					
+					if(m_ssl)
+						shutdown_ssl();
+					m_ssl_socket.next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both);
 				}
 			}
 			
@@ -240,7 +251,7 @@ namespace net_utils
 				// object is used as a callback and will update the ec variable when the
 				// operation completes. The blocking_udp_client.cpp example shows how you
 				// can use boost::bind rather than boost::lambda.
-				boost::asio::async_write(m_socket, boost::asio::buffer(buff), boost::lambda::var(ec) = boost::lambda::_1);
+				async_write(buff.c_str(), buff.size(), ec);

 				// Block until the asynchronous operation has completed.
 				while (ec == boost::asio::error::would_block)
@@ -302,9 +313,7 @@ namespace net_utils
 				*/
 				boost::system::error_code ec;

-				size_t writen = m_socket.write_some(boost::asio::buffer(data, sz), ec);
-				
-
+				size_t writen = write(data, sz, ec);

 				if (!writen || ec)
 				{
@@ -334,10 +343,7 @@ namespace net_utils

 		bool is_connected()
 		{
-			return m_connected && m_socket.is_open();
-			//TRY_ENTRY()
-			//return m_socket.is_open();
-			//CATCH_ENTRY_L0("is_connected", false)
+			return m_connected && m_ssl_socket.next_layer().is_open();
 		}

 		inline 
@@ -369,8 +375,8 @@ namespace net_utils
 				handler_obj hndlr(ec, bytes_transfered);

 				char local_buff[10000] = {0};
-				//m_socket.async_read_some(boost::asio::buffer(local_buff, sizeof(local_buff)), hndlr);
-				boost::asio::async_read(m_socket, boost::asio::buffer(local_buff, sizeof(local_buff)), boost::asio::transfer_at_least(1), hndlr);
+				
+				async_read(local_buff, sizeof(local_buff), boost::asio::transfer_at_least(1), hndlr);

 				// Block until the asynchronous operation has completed.
 				while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
@@ -451,10 +457,8 @@ namespace net_utils

 				
 				handler_obj hndlr(ec, bytes_transfered);
-
-				//char local_buff[10000] = {0};
-				boost::asio::async_read(m_socket, boost::asio::buffer((char*)buff.data(), buff.size()), boost::asio::transfer_at_least(buff.size()), hndlr);
-
+				async_read((char*)buff.data(), buff.size(), boost::asio::transfer_at_least(buff.size()), hndlr);
+				
 				// Block until the asynchronous operation has completed.
 				while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
 				{
@@ -500,10 +504,18 @@ namespace net_utils
 		bool shutdown()
 		{
 			m_deadline.cancel();
-			boost::system::error_code ignored_ec;
-			m_socket.cancel(ignored_ec);
-			m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
-			m_socket.close(ignored_ec);
+			boost::system::error_code ec;
+			if(m_ssl)
+				shutdown_ssl();
+			m_ssl_socket.next_layer().cancel(ec);
+			if(ec)
+				MDEBUG("Problems at cancel: " << ec.message());
+			m_ssl_socket.next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
+			if(ec)
+				MDEBUG("Problems at shutdown: " << ec.message());
+			m_ssl_socket.next_layer().close(ec);
+			if(ec)
+				MDEBUG("Problems at close: " << ec.message());
 			boost::interprocess::ipcdetail::atomic_write32(&m_shutdowned, 1);
      m_connected = false;
 			return true;
@@ -520,7 +532,7 @@ namespace net_utils

 		boost::asio::ip::tcp::socket& get_socket()
 		{
-			return m_socket;
+			return m_ssl_socket.next_layer();
 		}
 		
 	private:
@@ -537,7 +549,7 @@ namespace net_utils
 				// connect(), read_line() or write_line() functions to return.
 				LOG_PRINT_L3("Timed out socket");
        m_connected = false;
-				m_socket.close();
+				m_ssl_socket.next_layer().close();

 				// There is no longer an active deadline. The expiry is set to positive
 				// infinity so that the actor takes no action until a new deadline is set.
@@ -547,12 +559,61 @@ namespace net_utils
 			// Put the actor back to sleep.
 			m_deadline.async_wait(boost::bind(&blocked_mode_client::check_deadline, this));
 		}
-		

+		void shutdown_ssl() {
+			// ssl socket shutdown blocks if server doesn't respond. We close after 2 secs
+			boost::system::error_code ec = boost::asio::error::would_block;
+			m_deadline.expires_from_now(std::chrono::milliseconds(2000));
+			m_ssl_socket.async_shutdown(boost::lambda::var(ec) = boost::lambda::_1);
+			while (ec == boost::asio::error::would_block)
+			{
+				m_io_service.run_one();
+			}
+			// Ignore "short read" error
+			if (ec.category() == boost::asio::error::get_ssl_category() &&
+			    ec.value() !=
+#if BOOST_VERSION >= 106200
+			    boost::asio::ssl::error::stream_truncated
+#else // older Boost supports only OpenSSL 1.0, so 1.0-only macros are appropriate
+			    ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ)
+#endif
+			    )
+				MDEBUG("Problems at ssl shutdown: " << ec.message());
+		}
+		
+	protected:
+		bool write(const void* data, size_t sz, boost::system::error_code& ec)
+		{
+			bool success;
+			if(m_ssl)
+				success = boost::asio::write(m_ssl_socket, boost::asio::buffer(data, sz), ec);
+			else
+				success = boost::asio::write(m_ssl_socket.next_layer(), boost::asio::buffer(data, sz), ec);
+			return success;
+		}
+		
+		void async_write(const void* data, size_t sz, boost::system::error_code& ec) 
+		{
+			if(m_ssl)
+				boost::asio::async_write(m_ssl_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
+			else
+				boost::asio::async_write(m_ssl_socket.next_layer(), boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
+		}
+		
+		void async_read(char* buff, size_t sz, boost::asio::detail::transfer_at_least_t transfer_at_least, handler_obj& hndlr)
+		{
+			if(!m_ssl)
+				boost::asio::async_read(m_ssl_socket.next_layer(), boost::asio::buffer(buff, sz), transfer_at_least, hndlr);
+			else
+				boost::asio::async_read(m_ssl_socket, boost::asio::buffer(buff, sz), transfer_at_least, hndlr);
+			
+		}
 		
 	protected:
 		boost::asio::io_service m_io_service;
-		boost::asio::ip::tcp::socket m_socket;
+		boost::asio::ssl::context m_ctx;
+		boost::asio::ssl::stream<boost::asio::ip::tcp::socket> m_ssl_socket;
+		bool m_ssl;
 		bool m_initialized;
 		bool m_connected;
 		boost::asio::steady_timer m_deadline;
@@ -618,8 +679,8 @@ namespace net_utils
 				
 				boost::system::error_code ec;

-				size_t writen = m_socket.write_some(boost::asio::buffer(data, sz), ec);
-
+				size_t writen = write(data, sz, ec);
+				
 				if (!writen || ec)
 				{
 					LOG_PRINT_L3("Problems at write: " << ec.message());
@@ -660,7 +721,7 @@ namespace net_utils
 				// asynchronous operations are cancelled. This allows the blocked
 				// connect(), read_line() or write_line() functions to return.
 				LOG_PRINT_L3("Timed out socket");
-				m_socket.close();
+				m_ssl_socket.next_layer().close();

 				// There is no longer an active deadline. The expiry is set to positive
 				// infinity so that the actor takes no action until a new deadline is set.
--- a/contrib/epee/include/net/net_parse_helpers.h
+++ b/contrib/epee/include/net/net_parse_helpers.h
@@ -103,7 +103,7 @@ namespace net_utils
    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);

    boost::smatch result;	
-    if(!boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched)
+    if(!(boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched))
    {
      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
      content.m_path = uri;
@@ -139,7 +139,7 @@ namespace net_utils
    //                                     12         34      5 6        7
    content.port = 0;
    boost::smatch result;	
-    if(!boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched)
+    if(!(boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched))
    {
      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
      //content.m_path = uri;
--- a/contrib/epee/include/net/net_utils_base.h
+++ b/contrib/epee/include/net/net_utils_base.h
@@ -29,12 +29,11 @@
 #ifndef _NET_UTILS_BASE_H_
 #define _NET_UTILS_BASE_H_

-#include <typeinfo>
-#include <boost/asio/io_service.hpp>
 #include <boost/uuid/uuid.hpp>
+#include <boost/asio/io_service.hpp>
+#include <typeinfo>
+#include <type_traits>
 #include "serialization/keyvalue_serialization.h"
-#include "net/local_ip.h"
-#include "string_tools.h"
 #include "misc_log_ex.h"

 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -44,108 +43,176 @@
 #define MAKE_IP( a1, a2, a3, a4 )	(a1|(a2<<8)|(a3<<16)|(a4<<24))
 #endif

-
 namespace epee
 {
 namespace net_utils
 {
-	struct network_address_base
+	class ipv4_network_address
 	{
-	public:
-		bool operator==(const network_address_base &other) const { return m_full_id == other.m_full_id; }
-		bool operator!=(const network_address_base &other) const { return !operator==(other); }
-		bool operator<(const network_address_base &other) const { return m_full_id < other.m_full_id; }
-		bool is_same_host(const network_address_base &other) const { return m_host_id == other.m_host_id; }
-		virtual std::string str() const = 0;
-		virtual std::string host_str() const = 0;
-		virtual bool is_loopback() const = 0;
-		virtual bool is_local() const = 0;
-		virtual uint8_t get_type_id() const = 0;
-	protected:
-		// A very simple non cryptographic hash function by Fowler, Noll, Vo
-		uint64_t fnv1a(const uint8_t *data, size_t len) const {
-			uint64_t h = 0xcbf29ce484222325;
-			while (len--)
-				h = (h ^ *data++) * 0x100000001b3;
-			return h;
-		}
-		uint64_t m_host_id;
-		uint64_t m_full_id;
-	};
-	struct ipv4_network_address: public network_address_base
-	{
-		void init_ids()
-		{
-			m_host_id = fnv1a((const uint8_t*)&m_ip, sizeof(m_ip));
-			m_full_id = fnv1a((const uint8_t*)&m_ip, sizeof(m_ip) + sizeof(m_port));
-		}
-	public:
-		ipv4_network_address(uint32_t ip, uint16_t port): network_address_base(), m_ip(ip), m_port(port) { init_ids(); }
-		uint32_t ip() const { return m_ip; }
-		uint16_t port() const { return m_port; }
-		virtual std::string str() const { return epee::string_tools::get_ip_string_from_int32(m_ip) + ":" + std::to_string(m_port); }
-		virtual std::string host_str() const { return epee::string_tools::get_ip_string_from_int32(m_ip); }
-		virtual bool is_loopback() const { return epee::net_utils::is_ip_loopback(m_ip); }
-		virtual bool is_local() const { return epee::net_utils::is_ip_local(m_ip); }
-		virtual uint8_t get_type_id() const { return ID; }
-	public: // serialization
-		static const uint8_t ID = 1;
-#pragma pack(push)
-#pragma pack(1)
 		uint32_t m_ip;
 		uint16_t m_port;
-#pragma pack(pop)
+
+	public:
+		constexpr ipv4_network_address(uint32_t ip, uint16_t port) noexcept
+			: m_ip(ip), m_port(port) {}
+
+		bool equal(const ipv4_network_address& other) const noexcept;
+		bool less(const ipv4_network_address& other) const noexcept;
+		constexpr bool is_same_host(const ipv4_network_address& other) const noexcept
+		{ return ip() == other.ip(); }
+
+		constexpr uint32_t ip() const noexcept { return m_ip; }
+		constexpr uint16_t port() const noexcept { return m_port; }
+		std::string str() const; 
+		std::string host_str() const;
+		bool is_loopback() const;
+		bool is_local() const;
+		static constexpr uint8_t get_type_id() noexcept { return ID; }
+
+		static const uint8_t ID = 1;
 		BEGIN_KV_SERIALIZE_MAP()
 			KV_SERIALIZE(m_ip)
 			KV_SERIALIZE(m_port)
-			if (!is_store)
-				const_cast<ipv4_network_address&>(this_ref).init_ids();
 		END_KV_SERIALIZE_MAP()
 	};
-	class network_address: public boost::shared_ptr<network_address_base>
+
+	inline bool operator==(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return lhs.equal(rhs); }
+	inline bool operator!=(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return !lhs.equal(rhs); }
+	inline bool operator<(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return lhs.less(rhs); }
+	inline bool operator<=(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return !rhs.less(lhs); }
+	inline bool operator>(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return rhs.less(lhs); }
+	inline bool operator>=(const ipv4_network_address& lhs, const ipv4_network_address& rhs) noexcept
+	{ return !lhs.less(rhs); }
+
+	class network_address
 	{
+		struct interface
+		{
+                        virtual ~interface() {};
+
+			virtual bool equal(const interface&) const = 0;
+			virtual bool less(const interface&) const = 0;
+			virtual bool is_same_host(const interface&) const = 0;
+
+			virtual std::string str() const = 0;
+			virtual std::string host_str() const = 0;
+			virtual bool is_loopback() const = 0;
+			virtual bool is_local() const = 0;
+			virtual uint8_t get_type_id() const = 0;
+		};
+
+		template<typename T>
+		struct implementation final : interface
+		{
+			T value;
+
+			implementation(const T& src) : value(src) {}
+			~implementation() = default;
+
+			// Type-checks for cast are done in cpp
+			static const T& cast(const interface& src) noexcept
+			{ return static_cast<const implementation<T>&>(src).value; }
+
+			virtual bool equal(const interface& other) const override
+			{ return value.equal(cast(other)); }
+
+			virtual bool less(const interface& other) const override
+			{ return value.less(cast(other)); }
+
+			virtual bool is_same_host(const interface& other) const override
+			{ return value.is_same_host(cast(other)); }
+
+			virtual std::string str() const override { return value.str(); }
+			virtual std::string host_str() const override { return value.host_str(); }
+			virtual bool is_loopback() const override { return value.is_loopback(); }
+			virtual bool is_local() const override { return value.is_local(); }
+			virtual uint8_t get_type_id() const override { return value.get_type_id(); }
+		};
+
+		std::shared_ptr<interface> self;
+
+		template<typename Type>
+		Type& as_mutable() const
+		{
+			// types `implmentation<Type>` and `implementation<const Type>` are unique
+			using Type_ = typename std::remove_const<Type>::type;
+			network_address::interface* const self_ = self.get(); // avoid clang warning in typeid
+			if (!self_ || typeid(implementation<Type_>) != typeid(*self_))
+				throw std::bad_cast{};
+			return static_cast<implementation<Type_>*>(self_)->value;
+		}
 	public:
-		network_address() {}
-		network_address(ipv4_network_address *address): boost::shared_ptr<network_address_base>(address) {}
-		bool operator==(const network_address &other) const { return (*this)->operator==(*other); }
-		bool operator!=(const network_address &other) const { return (*this)->operator!=(*other); }
-		bool operator<(const network_address &other) const { return (*this)->operator<(*other); }
-		bool is_same_host(const network_address &other) const { return (*this)->is_same_host(*other); }
-		std::string str() const { return (*this) ? (*this)->str() : "<none>"; }
-		std::string host_str() const { return (*this) ? (*this)->host_str() : "<none>"; }
-		bool is_loopback() const { return (*this)->is_loopback(); }
-		bool is_local() const { return (*this)->is_local(); }
-		uint8_t get_type_id() const { return (*this)->get_type_id(); }
-		template<typename Type> Type &as() { if (get_type_id() != Type::ID) throw std::runtime_error("Bad type"); return *(Type*)get(); }
-		template<typename Type> const Type &as() const { if (get_type_id() != Type::ID) throw std::runtime_error("Bad type"); return *(const Type*)get(); }
+		network_address() : self(nullptr) {}
+		template<typename T>
+		network_address(const T& src)
+			: self(std::make_shared<implementation<T>>(src)) {}
+		bool equal(const network_address &other) const;
+		bool less(const network_address &other) const;
+		bool is_same_host(const network_address &other) const;
+		std::string str() const { return self ? self->str() : "<none>"; }
+		std::string host_str() const { return self ? self->host_str() : "<none>"; }
+		bool is_loopback() const { return self ? self->is_loopback() : false; }
+		bool is_local() const { return self ? self->is_local() : false; }
+		uint8_t get_type_id() const { return self ? self->get_type_id() : 0; }
+		template<typename Type> const Type &as() const { return as_mutable<const Type>(); }

 		BEGIN_KV_SERIALIZE_MAP()
 			uint8_t type = is_store ? this_ref.get_type_id() : 0;
-			epee::serialization::selector<is_store>::serialize(type, stg, hparent_section, "type");
+			if (!epee::serialization::selector<is_store>::serialize(type, stg, hparent_section, "type"))
+				return false;
 			switch (type)
 			{
 				case ipv4_network_address::ID:
+				{
 					if (!is_store)
-						const_cast<network_address&>(this_ref).reset(new ipv4_network_address(0, 0));
-					KV_SERIALIZE(template as<ipv4_network_address>());
+					{
+						const_cast<network_address&>(this_ref) = ipv4_network_address{0, 0};
+						auto &addr = this_ref.template as_mutable<ipv4_network_address>();
+						if (epee::serialization::selector<is_store>::serialize(addr, stg, hparent_section, "addr"))
+							MDEBUG("Found as addr: " << this_ref.str());
+						else if (epee::serialization::selector<is_store>::serialize(addr, stg, hparent_section, "template as<ipv4_network_address>()"))
+							MDEBUG("Found as template as<ipv4_network_address>(): " << this_ref.str());
+						else if (epee::serialization::selector<is_store>::serialize(addr, stg, hparent_section, "template as_mutable<ipv4_network_address>()"))
+							MDEBUG("Found as template as_mutable<ipv4_network_address>(): " << this_ref.str());
+						else
+						{
+							MWARNING("Address not found");
+							return false;
+						}
+					}
+					else
+					{
+						auto &addr = this_ref.template as_mutable<ipv4_network_address>();
+						if (!epee::serialization::selector<is_store>::serialize(addr, stg, hparent_section, "addr"))
+							return false;
+					}
 					break;
-				default: MERROR("Unsupported network address type: " << type); return false;
+				}
+				default: MERROR("Unsupported network address type: " << (unsigned)type); return false;
 			}
 		END_KV_SERIALIZE_MAP()
 	};
-	inline bool create_network_address(network_address &address, const std::string &string, uint16_t default_port = 0)
-	{
-		uint32_t ip;
-		uint16_t port;
-		if (epee::string_tools::parse_peer_from_string(ip, port, string))
-		{
-			if (default_port && !port)
-				port = default_port;
-			address.reset(new ipv4_network_address(ip, port));
-			return true;
-		}
-		return false;
-	}
+
+	inline bool operator==(const network_address& lhs, const network_address& rhs)
+	{ return lhs.equal(rhs); }
+	inline bool operator!=(const network_address& lhs, const network_address& rhs)
+	{ return !lhs.equal(rhs); }
+	inline bool operator<(const network_address& lhs, const network_address& rhs)
+	{ return lhs.less(rhs); }
+	inline bool operator<=(const network_address& lhs, const network_address& rhs)
+	{ return !rhs.less(lhs); }
+	inline bool operator>(const network_address& lhs, const network_address& rhs)
+	{ return rhs.less(lhs); }
+	inline bool operator>=(const network_address& lhs, const network_address& rhs)
+	{ return !lhs.less(rhs); }
+
+	bool create_network_address(network_address &address, const std::string &string, uint16_t default_port = 0);
+
 	/************************************************************************/
 	/*                                                                      */
 	/************************************************************************/
@@ -179,7 +246,7 @@ namespace net_utils
    {}

    connection_context_base(): m_connection_id(),
-                               m_remote_address(new ipv4_network_address(0,0)),
+                               m_remote_address(ipv4_network_address{0,0}),
                               m_is_income(false),
                               m_started(time(NULL)),
                               m_last_recv(0),
@@ -228,21 +295,8 @@ namespace net_utils
  //some helpers


-  inline 
-    std::string print_connection_context(const connection_context_base& ctx)
-  {
-    std::stringstream ss;
-    ss << ctx.m_remote_address->str() << " " << epee::string_tools::get_str_from_guid_a(ctx.m_connection_id) << (ctx.m_is_income ? " INC":" OUT");
-    return ss.str();
-  }
-
-  inline 
-    std::string print_connection_context_short(const connection_context_base& ctx)
-  {
-    std::stringstream ss;
-    ss << ctx.m_remote_address->str() << (ctx.m_is_income ? " INC":" OUT");
-    return ss.str();
-  }
+  std::string print_connection_context(const connection_context_base& ctx);
+  std::string print_connection_context_short(const connection_context_base& ctx);

 inline MAKE_LOGGABLE(connection_context_base, ct, os)
 {
--- a/contrib/epee/include/net/network_throttle-detail.hpp
+++ b/contrib/epee/include/net/network_throttle-detail.hpp
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief implementaion for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -33,8 +33,8 @@
 /* rfree: throttle details, implementing rate limiting */


-#ifndef INCLUDED_src_p2p_throttle_detail_hpp
-#define INCLUDED_src_p2p_throttle_detail_hpp
+#ifndef INCLUDED_throttle_detail_hpp
+#define INCLUDED_throttle_detail_hpp

 #include "network_throttle.hpp"

@@ -52,8 +52,7 @@ class network_throttle : public i_network_throttle {
 		};


-		network_speed_kbps m_target_speed;
-		network_speed_kbps m_real_target_speed;
+		network_speed_bps m_target_speed;
 		size_t m_network_add_cost; // estimated add cost of headers 
 		size_t m_network_minimal_segment; // estimated minimal cost of sending 1 byte to round up to
 		size_t m_network_max_segment; // recommended max size of 1 TCP transmission
@@ -76,7 +75,6 @@ class network_throttle : public i_network_throttle {
 		virtual ~network_throttle();
 		virtual void set_name(const std::string &name);
 		virtual void set_target_speed( network_speed_kbps target );
-		virtual void set_real_target_speed( network_speed_kbps real_target ); // only for throttle_out
 		virtual network_speed_kbps get_target_speed();

 		// add information about events:
--- a/contrib/epee/include/net/network_throttle.hpp
+++ b/contrib/epee/include/net/network_throttle.hpp
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief interface for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -34,8 +34,8 @@
 /* rfree: also includes the manager for singeton/global such objects */


-#ifndef INCLUDED_p2p_network_throttle_hpp
-#define INCLUDED_p2p_network_throttle_hpp
+#ifndef INCLUDED_network_throttle_hpp
+#define INCLUDED_network_throttle_hpp

 #include <boost/asio.hpp>
 #include <string>
@@ -80,7 +80,8 @@ namespace net_utils
 {

 // just typedefs to in code define the units used. TODO later it will be enforced that casts to other numericals are only explicit to avoid mistakes? use boost::chrono?
-typedef double network_speed_kbps;
+typedef double network_speed_kbps;   // externally, for parameters and return values, all defined in kilobytes per second
+typedef double network_speed_bps;    // throttle-internally, bytes per second
 typedef double network_time_seconds;
 typedef double network_MB;

@@ -98,8 +99,6 @@ struct calculate_times_struct {
 typedef calculate_times_struct calculate_times_struct;


-namespace cryptonote { class cryptonote_protocol_handler_base; } // a friend class // TODO friend not working
-
 /*** 
@brief Access to simple throttles, with singlton to access global network limits
 */
@@ -116,12 +115,9 @@ class network_throttle_manager {
    static boost::mutex m_lock_get_global_throttle_inreq;
    static boost::mutex m_lock_get_global_throttle_out;

-		friend class cryptonote::cryptonote_protocol_handler_base; // FRIEND - to directly access global throttle-s. !! REMEMBER TO USE LOCKS!
 		friend class connection_basic; // FRIEND - to directly access global throttle-s. !! REMEMBER TO USE LOCKS!
 		friend class connection_basic_pimpl; // ditto

-		static int xxx;
-
 	public:
 		static i_network_throttle & get_global_throttle_in(); ///< singleton ; for friend class ; caller MUST use proper locks! like m_lock_get_global_throttle_in
 		static i_network_throttle & get_global_throttle_inreq(); ///< ditto ; use lock ... use m_lock_get_global_throttle_inreq obviously
@@ -137,7 +133,6 @@ class i_network_throttle {
 	public:
 		virtual void set_name(const std::string &name)=0;
 		virtual void set_target_speed( network_speed_kbps target )=0;
-		virtual void set_real_target_speed(network_speed_kbps real_target)=0;
 		virtual network_speed_kbps get_target_speed()=0;

 		virtual void handle_trafic_exact(size_t packet_size) =0; // count the new traffic/packet; the size is exact considering all network costs
--- a/contrib/epee/include/profile_tools.h
+++ b/contrib/epee/include/profile_tools.h
@@ -28,6 +28,8 @@
 #ifndef _PROFILE_TOOLS_H_
 #define _PROFILE_TOOLS_H_

+#include "misc_os_dependent.h"
+
 namespace epee
 {

--- a/contrib/epee/include/readline_buffer.h
+++ b/contrib/epee/include/readline_buffer.h
@@ -2,31 +2,29 @@

 #include <streambuf>
 #include <sstream>
-#include <iostream>
 #include <vector>
-#include <algorithm>

 namespace rdln
 {
+  typedef enum { empty, partial, full } linestatus;
  class readline_buffer : public std::stringbuf
  {
  public:
    readline_buffer();
    void start();
    void stop();
-    int process();
    bool is_running() const
    {
      return m_cout_buf != NULL;
    }
-    void get_line(std::string& line) const;
+    linestatus get_line(std::string& line) const;
    void set_prompt(const std::string& prompt);
    static void add_completion(const std::string& command);
    static const std::vector<std::string>& get_completions();
    
  protected:
    virtual int sync();
-    
+
  private:
    std::streambuf* m_cout_buf;
    static std::vector<std::string>& completion_commands();
--- a/contrib/epee/include/reg_exp_definer.h
+++ b/contrib/epee/include/reg_exp_definer.h
@@ -29,7 +29,7 @@
 #define _REG_EXP_DEFINER_H_

 #include <boost/interprocess/detail/atomic.hpp>
-
+#include "syncobj.h"

 namespace epee
 {
--- a/contrib/epee/include/serialization/keyvalue_serialization.h
+++ b/contrib/epee/include/serialization/keyvalue_serialization.h
@@ -31,7 +31,6 @@
 #include "misc_log_ex.h"
 #include "enableable.h"
 #include "keyvalue_serialization_overloads.h"
-#include "serialization/serialization.h"

 namespace epee
 {
--- a/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
+++ b/contrib/epee/include/serialization/keyvalue_serialization_overloads.h
@@ -26,6 +26,13 @@

 #pragma once

+#include <set>
+#include <list>
+#include <vector>
+#include <deque>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/contains_fwd.hpp>
+
 namespace epee
 {
  namespace serialization
@@ -73,7 +80,7 @@ namespace epee
    template<class serializible_type, class t_storage>
    static bool unserialize_t_obj(serializible_type& obj, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
    {
-      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, true);
+      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, false);
      if(!hchild_section) return false;
      return obj._load(stg, hchild_section);
    }
@@ -90,7 +97,7 @@ namespace epee
    static bool unserialize_t_obj(enableable<serializible_type>& obj, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
    {
      obj.enabled = false;
-      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, true);
+      typename t_storage::hsection	hchild_section = stg.open_section(pname, hparent_section, false);
      if(!hchild_section) return false;
      obj.enabled = true;
      return obj.v._load(stg, hchild_section);
@@ -117,9 +124,9 @@ namespace epee
      typename stl_container::value_type exchange_val;
      typename t_storage::harray hval_array = stg.get_first_value(pname, exchange_val, hparent_section);
      if(!hval_array) return false;
-      container.push_back(std::move(exchange_val));
+      container.insert(container.end(), std::move(exchange_val));
      while(stg.get_next_value(hval_array, exchange_val))
-        container.push_back(std::move(exchange_val));
+        container.insert(container.end(), std::move(exchange_val));
      return true;
    }//--------------------------------------------------------------------------------------------------------------------
    template<class stl_container, class t_storage>
@@ -152,7 +159,7 @@ namespace epee
          "size in blob " << loaded_size << " not have not zero modulo for sizeof(value_type) = " << sizeof(typename stl_container::value_type));
        size_t count = (loaded_size/sizeof(typename stl_container::value_type));
        for(size_t i = 0; i < count; i++)
-          container.push_back(*(pelem++));
+          container.insert(container.end(), *(pelem++));
      }
      return res;
    }
@@ -186,12 +193,12 @@ namespace epee
      typename t_storage::harray hsec_array = stg.get_first_section(pname, hchild_section, hparent_section);
      if(!hsec_array || !hchild_section) return false;
      res = val._load(stg, hchild_section);
-      container.push_back(val);
+      container.insert(container.end(), val);
      while(stg.get_next_section(hsec_array, hchild_section))
      {
        typename stl_container::value_type val_l = typename stl_container::value_type();
        res |= val_l._load(stg, hchild_section);
-        container.push_back(std::move(val_l));
+        container.insert(container.end(), std::move(val_l));
      }
      return res;
    }
@@ -227,6 +234,18 @@ namespace epee
      } 
      //-------------------------------------------------------------------------------------------------------------------
      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_val(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
      static bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
      {
        return serialize_stl_container_t_val(d, stg, hparent_section, pname);
@@ -238,6 +257,18 @@ namespace epee
        return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
      } 
      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_val(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_val(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
    };
    template<>
    struct kv_serialization_overloads_impl_is_base_serializable_types<false>
@@ -268,6 +299,18 @@ namespace epee
      } 
      //-------------------------------------------------------------------------------------------------------------------
      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
      static bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
      {
        return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
@@ -278,6 +321,18 @@ namespace epee
      {
        return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
      } 
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return serialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      }
+      //-------------------------------------------------------------------------------------------------------------------
+      template<class t_type, class t_storage>
+      static bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+      {
+        return unserialize_stl_container_t_obj(d, stg, hparent_section, pname);
+      } 
    };
    template<class t_storage>
    struct base_serializable_types: public boost::mpl::vector<uint64_t, uint32_t, uint16_t, uint8_t, int64_t, int32_t, int16_t, int8_t, double, bool, std::string, typename t_storage::meta_entry>::type
@@ -353,6 +408,18 @@ namespace epee
    } 
    //-------------------------------------------------------------------------------------------------------------------
    template<class t_type, class t_storage>
+    bool kv_serialize(const std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::deque<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
+    } 
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
    bool kv_serialize(const std::list<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
    {
      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
@@ -363,5 +430,17 @@ namespace epee
    {
      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
    } 
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_serialize(const std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_serialize(d, stg, hparent_section, pname);
+    }
+    //-------------------------------------------------------------------------------------------------------------------
+    template<class t_type, class t_storage>
+    bool kv_unserialize(std::set<t_type>& d, t_storage& stg, typename t_storage::hsection hparent_section, const char* pname)
+    {
+      return kv_serialization_overloads_impl_is_base_serializable_types<boost::mpl::contains<base_serializable_types<t_storage>, typename std::remove_const<t_type>::type>::value>::kv_unserialize(d, stg, hparent_section, pname);
+    } 
  }
 }
--- a/contrib/epee/include/span.h
+++ b/contrib/epee/include/span.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017, The Monero Project
+// Copyright (c) 2017-2018, The Monero Project
 //
 // All rights reserved.
 //
@@ -108,7 +108,7 @@ namespace epee
  template<typename T>
  constexpr bool has_padding() noexcept
  {
-    return !std::is_pod<T>() || alignof(T) != 1;
+    return !std::is_standard_layout<T>() || alignof(T) != 1;
  }

  //! \return Cast data from `src` as `span<const std::uint8_t>`.
--- a/contrib/epee/include/storages/http_abstract_invoke.h
+++ b/contrib/epee/include/storages/http_abstract_invoke.h
@@ -44,8 +44,11 @@ namespace epee
      if(!serialization::store_t_to_json(out_struct, req_param))
        return false;

+      http::fields_list additional_params;
+      additional_params.push_back(std::make_pair("Content-Type","application/json; charset=utf-8"));
+
      const http::http_response_info* pri = NULL;
-      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri)))
+      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri), std::move(additional_params)))
      {
        LOG_PRINT_L1("Failed to invoke http request to  " << uri);
        return false;
@@ -112,7 +115,7 @@ namespace epee
      }
      if(resp_t.error.code || resp_t.error.message.size())
      {
-        LOG_ERROR("RPC call of \"" << method_name << "\" returned error: " << resp_t.error.code << ", message: " << resp_t.error.message);
+        LOG_ERROR("RPC call of \"" << req_t.method << "\" returned error: " << resp_t.error.code << ", message: " << resp_t.error.message);
        return false;
      }
      result_struct = resp_t.result;
--- a/contrib/epee/include/storages/levin_abstract_invoke2.h
+++ b/contrib/epee/include/storages/levin_abstract_invoke2.h
@@ -60,8 +60,7 @@ namespace epee
        LOG_ERROR("Failed to load_from_binary on command " << command);
        return false;
      }
-      result_struct.load(stg_ret);
-      return true;
+      return result_struct.load(stg_ret);
    }

    template<class t_arg, class t_transport>
@@ -105,13 +104,11 @@ namespace epee
        LOG_ERROR("Failed to load_from_binary on command " << command);
        return false;
      }
-      result_struct.load(stg_ret);
-
-      return true;
+      return result_struct.load(stg_ret);
    }

    template<class t_result, class t_arg, class callback_t, class t_transport>
-    bool async_invoke_remote_command2(boost::uuids::uuid conn_id, int command, const t_arg& out_struct, t_transport& transport, callback_t cb, size_t inv_timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
+    bool async_invoke_remote_command2(boost::uuids::uuid conn_id, int command, const t_arg& out_struct, t_transport& transport, const callback_t &cb, size_t inv_timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
    {
      typename serialization::portable_storage stg;
      const_cast<t_arg&>(out_struct).store(stg);//TODO: add true const support to searilzation
@@ -133,7 +130,12 @@ namespace epee
          cb(LEVIN_ERROR_FORMAT, result_struct, context);
          return false;
        }
-        result_struct.load(stg_ret);
+        if (!result_struct.load(stg_ret))
+        {
+          LOG_ERROR("Failed to load result struct on command " << command);
+          cb(LEVIN_ERROR_FORMAT, result_struct, context);
+          return false;
+        }
        cb(code, result_struct, context);
        return true;
      }, inv_timeout);
@@ -176,7 +178,11 @@ namespace epee
      boost::value_initialized<t_in_type> in_struct;
      boost::value_initialized<t_out_type> out_struct;

-      static_cast<t_in_type&>(in_struct).load(strg);
+      if (!static_cast<t_in_type&>(in_struct).load(strg))
+      {
+        LOG_ERROR("Failed to load in_struct in command " << command);
+        return -1;
+      }
      int res = cb(command, static_cast<t_in_type&>(in_struct), static_cast<t_out_type&>(out_struct), context);
      serialization::portable_storage strg_out;
      static_cast<t_out_type&>(out_struct).store(strg_out);
@@ -200,7 +206,11 @@ namespace epee
        return -1;
      }
      boost::value_initialized<t_in_type> in_struct;
-      static_cast<t_in_type&>(in_struct).load(strg);
+      if (!static_cast<t_in_type&>(in_struct).load(strg))
+      {
+        LOG_ERROR("Failed to load in_struct in notify " << command);
+        return -1;
+      }
      return cb(command, in_struct, context);
    }

--- a/contrib/epee/include/storages/portable_storage_from_json.h
+++ b/contrib/epee/include/storages/portable_storage_from_json.h
@@ -25,6 +25,8 @@
 // 

 #pragma once
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include "parserse_base_utils.h"
 #include "file_io_utils.h"

--- a/contrib/epee/include/storages/portable_storage_to_bin.h
+++ b/contrib/epee/include/storages/portable_storage_to_bin.h
@@ -28,6 +28,7 @@

 #pragma once 

+#include "pragma_comp_defs.h"
 #include "misc_language.h"
 #include "portable_storage_base.h"

@@ -47,6 +48,9 @@ namespace epee

    PRAGMA_WARNING_PUSH
      PRAGMA_GCC("GCC diagnostic ignored \"-Wstrict-aliasing\"")
+#ifdef __clang__
+      PRAGMA_GCC("GCC diagnostic ignored \"-Wtautological-constant-out-of-range-compare\"")
+#endif
      template<class t_stream>
    size_t pack_varint(t_stream& strm, size_t val)
    {   //the first two bits always reserved for size information
--- a/contrib/epee/include/storages/portable_storage_val_converters.h
+++ b/contrib/epee/include/storages/portable_storage_val_converters.h
@@ -28,6 +28,9 @@

 #pragma once

+#include <time.h>
+#include <boost/regex.hpp>
+
 #include "misc_language.h"
 #include "portable_storage_base.h"
 #include "warnings.h"
@@ -131,6 +134,36 @@ POP_WARNINGS
      }
    };

+    // For MyMonero/OpenMonero backend compatibility
+    // MyMonero backend sends amount, fees and timestamp values as strings.
+    // Until MM backend is updated, this is needed for compatibility between OpenMonero and MyMonero. 
+    template<>
+    struct convert_to_integral<std::string, uint64_t, false>
+    {
+      static void convert(const std::string& from, uint64_t& to)
+      {
+        MTRACE("Converting std::string to uint64_t. Source: " << from);
+        // String only contains digits
+        if(std::all_of(from.begin(), from.end(), ::isdigit))
+          to = boost::lexical_cast<uint64_t>(from);
+        // MyMonero ISO 8061 timestamp (2017-05-06T16:27:06Z)
+        else if (boost::regex_match (from, boost::regex("\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\dZ")))
+        {
+          // Convert to unix timestamp
+#ifdef HAVE_STRPTIME
+          struct tm tm;
+          if (strptime(from.c_str(), "%Y-%m-%dT%H:%M:%S", &tm))
+#else
+          std::tm tm = {};
+          std::istringstream ss(from);
+          if (ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S"))
+#endif
+            to = std::mktime(&tm);
+        } else
+          ASSERT_AND_THROW_WRONG_CONVERSION();
+      }
+    };
+
    template<class from_type, class to_type>
    struct is_convertable: std::integral_constant<bool,
                            std::is_integral<to_type>::value &&
--- a/contrib/epee/include/string_tools.h
+++ b/contrib/epee/include/string_tools.h
@@ -35,6 +35,7 @@
 # include <windows.h>
 #endif

+#include <string.h>
 #include <locale>
 #include <cstdlib>
 #include <string>
@@ -42,8 +43,9 @@
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include "hex.h"
+#include "memwipe.h"
 #include "span.h"
 #include "warnings.h"

@@ -160,7 +162,7 @@ DISABLE_GCC_WARNING(maybe-uninitialized)
      val = boost::lexical_cast<XType>(str_id);
      return true;
    }
-    catch(std::exception& /*e*/)
+    catch(const std::exception& /*e*/)
    {
      //const char* pmsg = e.what();
      return false;
@@ -314,10 +316,22 @@ POP_WARNINGS
    return str;
  }
  //----------------------------------------------------------------------------
+  inline std::string pad_string(std::string s, size_t n, char c = ' ', bool prepend = false)
+  {
+    if (s.size() < n)
+    {
+      if (prepend)
+        s = std::string(n - s.size(), c) + s;
+      else
+        s.append(n - s.size(), c);
+    }
+    return s;
+  }
+  //----------------------------------------------------------------------------
  template<class t_pod_type>
  std::string pod_to_hex(const t_pod_type& s)
  {
-    static_assert(std::is_pod<t_pod_type>::value, "expected pod type");
+    static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
    return to_hex::string(as_byte_span(s));
  }
  //----------------------------------------------------------------------------
@@ -337,6 +351,14 @@ POP_WARNINGS
    s = *(t_pod_type*)bin_buff.data();
    return true;
  }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  bool hex_to_pod(const std::string& hex_str, tools::scrubbed<t_pod_type>& s)
+  {
+    return hex_to_pod(hex_str, unwrap(s));
+  }
+  //----------------------------------------------------------------------------
+  bool validate_hex(uint64_t length, const std::string& str);
  //----------------------------------------------------------------------------
 	inline std::string get_extension(const std::string& str)
 	{
--- a/contrib/epee/include/syncobj.h
+++ b/contrib/epee/include/syncobj.h
@@ -31,10 +31,11 @@
 #define __WINH_OBJ_H__

 #include <boost/chrono/duration.hpp>
+#include <boost/thread/condition_variable.hpp>
 #include <boost/thread/locks.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/v2/thread.hpp>
+#include <boost/thread/thread.hpp>

 namespace epee
 {
--- a/contrib/epee/include/wipeable_string.h
+++ b/contrib/epee/include/wipeable_string.h
@@ -0,0 +1,67 @@
+// Copyright (c) 2017-2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <stddef.h>
+#include <vector>
+#include <string>
+
+namespace epee
+{
+  class wipeable_string
+  {
+  public:
+    wipeable_string() {}
+    wipeable_string(const wipeable_string &other);
+    wipeable_string(wipeable_string &&other);
+    wipeable_string(const std::string &other);
+    wipeable_string(std::string &&other);
+    wipeable_string(const char *s);
+    ~wipeable_string();
+    void wipe();
+    void push_back(char c);
+    void pop_back();
+    const char *data() const noexcept { return buffer.data(); }
+    size_t size() const noexcept { return buffer.size(); }
+    bool empty() const noexcept { return buffer.empty(); }
+    void resize(size_t sz);
+    void reserve(size_t sz);
+    void clear();
+    bool operator==(const wipeable_string &other) const noexcept { return buffer == other.buffer; }
+    bool operator!=(const wipeable_string &other) const noexcept { return buffer != other.buffer; }
+    wipeable_string &operator=(wipeable_string &&other);
+    wipeable_string &operator=(const wipeable_string &other);
+
+  private:
+    void grow(size_t sz, size_t reserved = 0);
+
+  private:
+    std::vector<char> buffer;
+  };
+}
--- a/contrib/epee/src/CMakeLists.txt
+++ b/contrib/epee/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -26,10 +26,14 @@
 # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 # THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp net_utils_base.cpp string_tools.cpp wipeable_string.cpp memwipe.c
+    connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp)
 if (USE_READLINE AND GNU_READLINE_FOUND)
-  add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp string_tools.cpp readline_buffer.cpp)
-else()
-  add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp string_tools.cpp)
+  add_library(epee_readline STATIC readline_buffer.cpp)
+endif()
+
+if(HAVE_C11)
+SET_PROPERTY(SOURCE memwipe.c PROPERTY COMPILE_FLAGS -std=c11)
 endif()

 # Build and install libepee if we're building for GUI
@@ -41,12 +45,24 @@ if (BUILD_GUI_DEPS)
    endif()
    install(TARGETS epee
        ARCHIVE DESTINATION ${lib_folder})
+    if (USE_READLINE AND GNU_READLINE_FOUND)
+      install(TARGETS epee_readline
+          ARCHIVE DESTINATION ${lib_folder})
+    endif()
 endif()

 target_link_libraries(epee
  PUBLIC
-    cncrypto
    easylogging
    ${Boost_FILESYSTEM_LIBRARY}
  PRIVATE
+    ${OPENSSL_LIBRARIES}
    ${EXTRA_LIBRARIES})
+
+if (USE_READLINE AND GNU_READLINE_FOUND)
+  target_link_libraries(epee_readline
+    PUBLIC
+      easylogging
+    PRIVATE
+    ${GNU_READLINE_LIBRARY})
+endif()
--- a/contrib/epee/src/connection_basic.cpp
+++ b/contrib/epee/src/connection_basic.cpp
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief base for connection, contains e.g. the ratelimit hooks

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -32,7 +32,7 @@

 /* rfree: implementation for the non-template base, can be used by connection<> template class in abstract_tcp_server2 file  */

-#include "connection_basic.hpp"
+#include "net/connection_basic.hpp"

 #include <boost/asio.hpp>
 #include <string>
@@ -77,8 +77,7 @@
 #include "net/abstract_tcp_server2.h"

 // TODO:
-#include "network_throttle-detail.hpp"
-#include "cryptonote_core/cryptonote_core.h"
+#include "net/network_throttle-detail.hpp"

 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.p2p"
@@ -158,7 +157,7 @@ connection_basic::connection_basic(boost::asio::io_service& io_service, std::ato
 	++ref_sock_count; // increase the global counter
 	mI->m_peer_number = sock_number.fetch_add(1); // use, and increase the generated number

-	string remote_addr_str = "?";
+	std::string remote_addr_str = "?";
 	try { boost::system::error_code e; remote_addr_str = socket_.remote_endpoint(e).address().to_string(); } catch(...){} ;

 	_note("Spawned connection p2p#"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_ref_sock_count);
@@ -166,21 +165,16 @@ connection_basic::connection_basic(boost::asio::io_service& io_service, std::ato
 }

 connection_basic::~connection_basic() noexcept(false) {
-	string remote_addr_str = "?";
+	std::string remote_addr_str = "?";
 	m_ref_sock_count--;
 	try { boost::system::error_code e; remote_addr_str = socket_.remote_endpoint(e).address().to_string(); } catch(...){} ;
 	_note("Destructing connection p2p#"<<mI->m_peer_number << " to " << remote_addr_str);
 }

 void connection_basic::set_rate_up_limit(uint64_t limit) {
-	
-	// TODO remove __SCALING_FACTOR...
-	const double SCALING_FACTOR = 2.1; // to acheve the best performance
-	limit *= SCALING_FACTOR;
 	{
 		CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
 		network_throttle_manager::get_global_throttle_out().set_target_speed(limit);
-		network_throttle_manager::get_global_throttle_out().set_real_target_speed(limit / SCALING_FACTOR);
 	}
 	save_limit_to_file(limit);
 }
@@ -238,7 +232,7 @@ void connection_basic::sleep_before_packet(size_t packet_size, int phase,  int q

 		{ 
 			CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
-			delay = network_throttle_manager::get_global_throttle_out().get_sleep_time_after_tick( packet_size ); // decission from global
+			delay = network_throttle_manager::get_global_throttle_out().get_sleep_time_after_tick( packet_size );
 		}

 		delay *= 0.50;
@@ -252,7 +246,7 @@ void connection_basic::sleep_before_packet(size_t packet_size, int phase,  int q
 // XXX LATER XXX
 	{
 	  CRITICAL_REGION_LOCAL(	network_throttle_manager::m_lock_get_global_throttle_out );
-		network_throttle_manager::get_global_throttle_out().handle_trafic_exact( packet_size * 700); // increase counter - global
+		network_throttle_manager::get_global_throttle_out().handle_trafic_exact( packet_size ); // increase counter - global
 	}

 }
@@ -262,13 +256,13 @@ void connection_basic::set_start_time() {
 }

 void connection_basic::do_send_handler_write(const void* ptr , size_t cb ) {
-	sleep_before_packet(cb,1,-1);
+        // No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
 	MTRACE("handler_write (direct) - before ASIO write, for packet="<<cb<<" B (after sleep)");
 	set_start_time();
 }

 void connection_basic::do_send_handler_write_from_queue( const boost::system::error_code& e, size_t cb, int q_len ) {
-	sleep_before_packet(cb,2,q_len);
+        // No sleeping here; sleeping is done once and for all in connection<t_protocol_handler>::handle_write
 	MTRACE("handler_write (after write, from queue="<<q_len<<") - before ASIO write, for packet="<<cb<<" B (after sleep)");

 	set_start_time();
--- a/contrib/epee/src/hex.cpp
+++ b/contrib/epee/src/hex.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017, The Monero Project
+// Copyright (c) 2017-2018, The Monero Project
 //
 // All rights reserved.
 //
--- a/contrib/epee/src/http_auth.cpp
+++ b/contrib/epee/src/http_auth.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 //
 // All rights reserved.
 //
@@ -66,7 +66,6 @@
 #include <tuple>
 #include <type_traits>

-#include "crypto/crypto.h"
 #include "hex.h"
 #include "md5_l.h"
 #include "string_coding.h"
@@ -125,6 +124,14 @@ namespace
      {
        (*this)(boost::string_ref(arg));
      }
+      void operator()(const epee::wipeable_string& arg) const
+      {
+        md5::MD5Update(
+          std::addressof(ctx),
+          reinterpret_cast<const std::uint8_t*>(arg.data()),
+          arg.size()
+        );
+      }

      md5::MD5_CTX& ctx;
    };
@@ -703,8 +710,8 @@ namespace epee
  {
    namespace http
    {
-      http_server_auth::http_server_auth(login credentials)
-        : user(session{std::move(credentials)}) {
+      http_server_auth::http_server_auth(login credentials, std::function<void(size_t, uint8_t*)> r)
+        : user(session{std::move(credentials)}), rng(std::move(r)) {
      }

      boost::optional<http_response_info> http_server_auth::do_get_response(const http_request_info& request)
@@ -738,7 +745,7 @@ namespace epee
        user->counter = 0;
        {
          std::array<std::uint8_t, 16> rand_128bit{{}};
-          crypto::rand(rand_128bit.size(), rand_128bit.data());
+          rng(rand_128bit.size(), rand_128bit.data());
          user->nonce = string_encoding::base64_encode(rand_128bit.data(), rand_128bit.size());
        }
        return create_digest_response(user->nonce, is_stale);
--- a/contrib/epee/src/memwipe.c
+++ b/contrib/epee/src/memwipe.c
@@ -0,0 +1,113 @@
+// Copyright (c) 2017-2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Parts of this file Copyright (c) 2009-2015 The Bitcoin Core developers
+
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#ifdef HAVE_EXPLICIT_BZERO
+#include <strings.h>
+#endif
+#include "memwipe.h"
+
+#if defined(_MSC_VER)
+#define SCARECROW \
+    __asm;
+#else
+#define SCARECROW \
+    __asm__ __volatile__("" : : "r"(ptr) : "memory");
+#endif
+
+#ifdef HAVE_MEMSET_S
+
+void *memwipe(void *ptr, size_t n)
+{
+  if (memset_s(ptr, n, 0, n))
+  {
+#ifdef NDEBUG
+    fprintf(stderr, "Error: memset_s failed\n");
+    _exit(1);
+#else
+    abort();
+#endif
+  }
+  SCARECROW // might as well...
+  return ptr;
+}
+
+#elif defined HAVE_EXPLICIT_BZERO
+
+void *memwipe(void *ptr, size_t n)
+{
+  explicit_bzero(ptr, n);
+  SCARECROW
+  return ptr;
+}
+
+#else
+
+/* The memory_cleanse implementation is taken from Bitcoin */
+
+/* Compilers have a bad habit of removing "superfluous" memset calls that
+ * are trying to zero memory. For example, when memset()ing a buffer and
+ * then free()ing it, the compiler might decide that the memset is
+ * unobservable and thus can be removed.
+ *
+ * Previously we used OpenSSL which tried to stop this by a) implementing
+ * memset in assembly on x86 and b) putting the function in its own file
+ * for other platforms.
+ *
+ * This change removes those tricks in favour of using asm directives to
+ * scare the compiler away. As best as our compiler folks can tell, this is
+ * sufficient and will continue to be so.
+ *
+ * Adam Langley <agl@google.com>
+ * Commit: ad1907fe73334d6c696c8539646c21b11178f20f
+ * BoringSSL (LICENSE: ISC)
+ */
+static void memory_cleanse(void *ptr, size_t len)
+{
+    memset(ptr, 0, len);
+
+    /* As best as we can tell, this is sufficient to break any optimisations that
+       might try to eliminate "superfluous" memsets. If there's an easy way to
+       detect memset_s, it would be better to use that. */
+    SCARECROW
+}
+
+void *memwipe(void *ptr, size_t n)
+{
+  memory_cleanse(ptr, n);
+  SCARECROW
+  return ptr;
+}
+
+#endif
--- a/contrib/epee/src/mlog.cpp
+++ b/contrib/epee/src/mlog.cpp
@@ -28,7 +28,11 @@
 #ifndef _MLOG_H_
 #define _MLOG_H_

+#include <time.h>
 #include <atomic>
+#include <boost/filesystem.hpp>
+#include <boost/algorithm/string.hpp>
+#include "string_tools.h"
 #include "misc_log_ex.h"

 #undef MONERO_DEFAULT_LOG_CATEGORY
@@ -55,6 +59,7 @@ static std::string generate_log_filename(const char *base)
    strcpy(tmp, "unknown");
  else
    strftime(tmp, sizeof(tmp), "%Y-%m-%d-%H-%M-%S", &tm);
+  tmp[sizeof(tmp) - 1] = 0;
  filename += "-";
  filename += tmp;
  return filename;
@@ -94,7 +99,7 @@ static const char *get_default_categories(int level)
      categories = "*:WARNING,net:FATAL,net.p2p:FATAL,net.cn:FATAL,global:INFO,verify:FATAL,stacktrace:INFO,logging:INFO,msgwriter:INFO";
      break;
    case 1:
-      categories = "*:WARNING,global:INFO,stacktrace:INFO,logging:INFO,msgwriter:INFO";
+      categories = "*:INFO,global:INFO,stacktrace:INFO,logging:INFO,msgwriter:INFO";
      break;
    case 2:
      categories = "*:DEBUG";
@@ -111,7 +116,7 @@ static const char *get_default_categories(int level)
  return categories;
 }

-void mlog_configure(const std::string &filename_base, bool console)
+void mlog_configure(const std::string &filename_base, bool console, const std::size_t max_log_file_size)
 {
  el::Configurations c;
  c.setGlobally(el::ConfigurationType::Filename, filename_base);
@@ -121,7 +126,7 @@ void mlog_configure(const std::string &filename_base, bool console)
    log_format = MLOG_BASE_FORMAT;
  c.setGlobally(el::ConfigurationType::Format, log_format);
  c.setGlobally(el::ConfigurationType::ToStandardOutput, console ? "true" : "false");
-  c.setGlobally(el::ConfigurationType::MaxLogFileSize, "104850000"); // 100 MB - 7600 bytes
+  c.setGlobally(el::ConfigurationType::MaxLogFileSize, std::to_string(max_log_file_size));
  el::Loggers::setDefaultConfigurations(c, true);

  el::Loggers::addFlag(el::LoggingFlag::HierarchicalLogging);
@@ -144,16 +149,52 @@ void mlog_configure(const std::string &filename_base, bool console)

 void mlog_set_categories(const char *categories)
 {
-  el::Loggers::setCategories(categories);
-  MLOG_LOG("New log categories: " << categories);
+  std::string new_categories;
+  if (*categories)
+  {
+    if (*categories == '+')
+    {
+      ++categories;
+      new_categories = mlog_get_categories();
+      if (*categories)
+      {
+        if (!new_categories.empty())
+          new_categories += ",";
+        new_categories += categories;
+      }
+    }
+    else if (*categories == '-')
+    {
+      ++categories;
+      new_categories = mlog_get_categories();
+      std::vector<std::string> single_categories;
+      boost::split(single_categories, categories, boost::is_any_of(","), boost::token_compress_on);
+      for (const std::string &s: single_categories)
+      {
+        size_t pos = new_categories.find(s);
+        if (pos != std::string::npos)
+          new_categories = new_categories.erase(pos, s.size());
+      }
+    }
+    else
+    {
+      new_categories = categories;
+    }
+  }
+  el::Loggers::setCategories(new_categories.c_str(), true);
+  MLOG_LOG("New log categories: " << el::Loggers::getCategories());
+}
+
+std::string mlog_get_categories()
+{
+  return el::Loggers::getCategories();
 }

 // maps epee style log level to new logging system
 void mlog_set_log_level(int level)
 {
  const char *categories = get_default_categories(level);
-  el::Loggers::setCategories(categories);
-  MLOG_LOG("New log categories: " << categories);
+  mlog_set_categories(categories);
 }

 void mlog_set_log(const char *log)
@@ -161,7 +202,12 @@ void mlog_set_log(const char *log)
  long level;
  char *ptr = NULL;

-  level = strtoll(log, &ptr, 10);
+  if (!*log)
+  {
+    mlog_set_categories(log);
+    return;
+  }
+  level = strtol(log, &ptr, 10);
  if (ptr && *ptr)
  {
    // we can have a default level, eg, 2,foo:ERROR
--- a/contrib/epee/src/net_utils_base.cpp
+++ b/contrib/epee/src/net_utils_base.cpp
@@ -0,0 +1,90 @@
+
+#include "net/net_utils_base.h"
+#include "string_tools.h"
+
+#include <cstring>
+#include <typeindex>
+#include "net/local_ip.h"
+
+namespace epee { namespace net_utils
+{
+	const uint8_t ipv4_network_address::ID;
+
+	bool ipv4_network_address::equal(const ipv4_network_address& other) const noexcept
+	{ return is_same_host(other) && port() == other.port(); }
+
+	bool ipv4_network_address::less(const ipv4_network_address& other) const noexcept
+	{ return is_same_host(other) ? port() < other.port() : ip() < other.ip(); }
+
+	std::string ipv4_network_address::str() const
+	{ return string_tools::get_ip_string_from_int32(ip()) + ":" + std::to_string(port()); }
+
+	std::string ipv4_network_address::host_str() const { return string_tools::get_ip_string_from_int32(ip()); }
+	bool ipv4_network_address::is_loopback() const { return net_utils::is_ip_loopback(ip()); }
+	bool ipv4_network_address::is_local() const { return net_utils::is_ip_local(ip()); }
+
+
+	bool network_address::equal(const network_address& other) const
+	{
+		// clang typeid workaround
+		network_address::interface const* const self_ = self.get();
+		network_address::interface const* const other_self = other.self.get();
+		if (self_ == other_self) return true;
+		if (!self_ || !other_self) return false;
+		if (typeid(*self_) != typeid(*other_self)) return false;
+		return self_->equal(*other_self);
+	}
+
+	bool network_address::less(const network_address& other) const
+	{
+		// clang typeid workaround
+		network_address::interface const* const self_ = self.get();
+		network_address::interface const* const other_self = other.self.get();
+		if (self_ == other_self) return false;
+		if (!self_ || !other_self) return self == nullptr;
+		if (typeid(*self_) != typeid(*other_self))
+			return self_->get_type_id() < other_self->get_type_id();
+		return self_->less(*other_self);
+	}
+
+	bool network_address::is_same_host(const network_address& other) const
+	{
+		// clang typeid workaround
+		network_address::interface const* const self_ = self.get();
+		network_address::interface const* const other_self = other.self.get();
+		if (self_ == other_self) return true;
+		if (!self_ || !other_self) return false;
+		if (typeid(*self_) != typeid(*other_self)) return false;
+		return self_->is_same_host(*other_self);
+	}
+
+	bool create_network_address(network_address &address, const std::string &string, uint16_t default_port)
+	{
+		uint32_t ip;
+		uint16_t port;
+		if (epee::string_tools::parse_peer_from_string(ip, port, string))
+		{
+			if (default_port && !port)
+				port = default_port;
+			address = ipv4_network_address{ip, port};
+			return true;
+		}
+		return false;
+	}
+
+  std::string print_connection_context(const connection_context_base& ctx)
+  {
+    std::stringstream ss;
+    ss << ctx.m_remote_address.str() << " " << epee::string_tools::get_str_from_guid_a(ctx.m_connection_id) << (ctx.m_is_income ? " INC":" OUT");
+    return ss.str();
+  }
+
+  std::string print_connection_context_short(const connection_context_base& ctx)
+  {
+    std::stringstream ss;
+    ss << ctx.m_remote_address.str() << (ctx.m_is_income ? " INC":" OUT");
+    return ss.str();
+  }
+
+}}
+
--- a/contrib/epee/src/network_throttle-detail.cpp
+++ b/contrib/epee/src/network_throttle-detail.cpp
@@ -2,7 +2,7 @@
 /// @author rfree (current maintainer in monero.cc project)
 /// @brief implementaion for throttling of connection (count and rate-limit speed etc)

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -74,7 +74,7 @@
 #include "net/abstract_tcp_server2.h"

 // TODO:
-#include "network_throttle-detail.hpp"
+#include "net/network_throttle-detail.hpp"

 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.throttle"
@@ -160,17 +160,11 @@ void network_throttle::set_target_speed( network_speed_kbps target )
 {
    m_target_speed = target * 1024;
 	MINFO("Setting LIMIT: " << target << " kbps");
-	set_real_target_speed(target);
-}
-
-void network_throttle::set_real_target_speed( network_speed_kbps real_target )
-{
-	m_real_target_speed = real_target * 1024;
 }

 network_speed_kbps network_throttle::get_target_speed()
 {
-	return m_real_target_speed / 1024;
+	return m_target_speed / 1024;
 }
 			
 void network_throttle::tick()
@@ -237,8 +231,10 @@ network_time_seconds network_throttle::get_sleep_time_after_tick(size_t packet_s
 }

 void network_throttle::logger_handle_net(const std::string &filename, double time, size_t size) {
-    boost::mutex mutex;
-    mutex.lock(); {
+    static boost::mutex mutex;
+
+    boost::lock_guard<boost::mutex> lock(mutex);
+    {
        std::fstream file;
        file.open(filename.c_str(), std::ios::app | std::ios::out );
        file.precision(6);
@@ -246,7 +242,7 @@ void network_throttle::logger_handle_net(const std::string &filename, double tim
            _warn("Can't open file " << filename);
        file << static_cast<int>(time) << " " << static_cast<double>(size/1024) << "\n";
        file.close();
-    }  mutex.unlock();
+    }
 }

 // fine tune this to decide about sending speed:
--- a/contrib/epee/src/network_throttle.cpp
+++ b/contrib/epee/src/network_throttle.cpp
@@ -26,7 +26,7 @@ Throttling work by:

 */

-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2014-2018, The Monero Project
 // 
 // All rights reserved.
 // 
@@ -54,7 +54,7 @@ Throttling work by:
 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-#include "network_throttle-detail.hpp"
+#include "net/network_throttle-detail.hpp"

 namespace epee
 {
@@ -71,9 +71,6 @@ boost::mutex network_throttle_manager::m_lock_get_global_throttle_in;
 boost::mutex network_throttle_manager::m_lock_get_global_throttle_inreq;
 boost::mutex network_throttle_manager::m_lock_get_global_throttle_out;

-int network_throttle_manager::xxx;
-
-
 // ================================================================================================
 // methods:
 i_network_throttle & network_throttle_manager::get_global_throttle_in() { 
--- a/contrib/epee/src/readline_buffer.cpp
+++ b/contrib/epee/src/readline_buffer.cpp
@@ -1,21 +1,17 @@
 #include "readline_buffer.h"
 #include <readline/readline.h>
 #include <readline/history.h>
-#include <sys/select.h>
 #include <unistd.h>
-#include <mutex>
-#include <condition_variable>
+#include <iostream>
 #include <boost/thread.hpp>
 #include <boost/algorithm/string.hpp>

-static int process_input();
 static void install_line_handler();
 static void remove_line_handler();

-static std::string last_line;
-static std::string last_prompt;
-static std::mutex line_mutex, sync_mutex, process_mutex;
-static std::condition_variable have_line;
+static boost::mutex sync_mutex;
+static rdln::linestatus line_stat;
+static char *the_line;

 namespace
 {
@@ -55,7 +51,6 @@ rdln::readline_buffer::readline_buffer()

 void rdln::readline_buffer::start()
 {
-  std::unique_lock<std::mutex> lock(process_mutex);
  if(m_cout_buf != NULL)
    return;
  m_cout_buf = std::cout.rdbuf();
@@ -65,9 +60,6 @@ void rdln::readline_buffer::start()

 void rdln::readline_buffer::stop()
 {
-  std::unique_lock<std::mutex> lock_process(process_mutex);
-  std::unique_lock<std::mutex> lock_sync(sync_mutex);
-  have_line.notify_all();
  if(m_cout_buf == NULL)
    return;
  std::cout.rdbuf(m_cout_buf);
@@ -75,20 +67,26 @@ void rdln::readline_buffer::stop()
  remove_line_handler();
 }

-void rdln::readline_buffer::get_line(std::string& line) const
+rdln::linestatus rdln::readline_buffer::get_line(std::string& line) const
 {
-  std::unique_lock<std::mutex> lock(line_mutex);
-  have_line.wait(lock);
-  line = last_line;
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
+  line_stat = rdln::partial;
+  rl_callback_read_char();
+  if (line_stat == rdln::full)
+  {
+    line = the_line;
+    free(the_line);
+    the_line = NULL;
+  }
+  return line_stat;
 }

 void rdln::readline_buffer::set_prompt(const std::string& prompt)
 {
-  last_prompt = prompt;
  if(m_cout_buf == NULL)
    return;
-  std::lock_guard<std::mutex> lock(sync_mutex);
-  rl_set_prompt(last_prompt.c_str());
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
+  rl_set_prompt(prompt.c_str());
  rl_redisplay();
 }

@@ -104,128 +102,80 @@ const std::vector<std::string>& rdln::readline_buffer::get_completions()
  return completion_commands();
 }

-int rdln::readline_buffer::process()
-{
-  process_mutex.lock();
-  if(m_cout_buf == NULL)
-  {
-    process_mutex.unlock();
-    boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
-    return 0;
-  }
-  int count = process_input();
-  process_mutex.unlock();
-  boost::this_thread::sleep_for(boost::chrono::milliseconds( 1 ));
-  return count;
-}
-
 int rdln::readline_buffer::sync()
 {
-  std::lock_guard<std::mutex> lock(sync_mutex);
-  char* saved_line;
-  int saved_point;
-  
-  saved_point = rl_point;
-  saved_line = rl_copy_text(0, rl_end);
-  
-  rl_set_prompt("");
-  rl_replace_line("", 0);
-  rl_redisplay();
-  
+  boost::lock_guard<boost::mutex> lock(sync_mutex);
+#if RL_READLINE_VERSION < 0x0700
+  char lbuf[2] = {0,0};
+  char *line = NULL;
+  int end = 0, point = 0;
+#endif
+
+  if (rl_end || *rl_prompt)
+  {
+#if RL_READLINE_VERSION >= 0x0700
+    rl_clear_visible_line();
+#else
+    line = rl_line_buffer;
+    end = rl_end;
+    point = rl_point;
+    rl_line_buffer = lbuf;
+    rl_end = 0;
+    rl_point = 0;
+    rl_save_prompt();
+    rl_redisplay();
+#endif
+  }
+
  do
  {
    m_cout_buf->sputc( this->sgetc() );
  }
  while ( this->snextc() != EOF );
-  
-  rl_set_prompt(last_prompt.c_str());
-  rl_replace_line(saved_line, 0);
-  rl_point = saved_point;
-  rl_redisplay();
-  free(saved_line);
-  
-  return 0;
-}

-static int process_input()
-{
-  int count;
-  struct timeval t;
-  fd_set fds;
-  
-  t.tv_sec = 0;
-  t.tv_usec = 1000;
-  
-  FD_ZERO(&fds);
-  FD_SET(STDIN_FILENO, &fds);
-  count = select(STDIN_FILENO + 1, &fds, NULL, NULL, &t);
-  if (count < 1)
+#if RL_READLINE_VERSION < 0x0700
+  if (end || *rl_prompt)
  {
-    return count;
+    rl_restore_prompt();
+    rl_line_buffer = line;
+    rl_end = end;
+    rl_point = point;
  }
-  rl_callback_read_char();
-  return count;
+#endif
+  rl_on_new_line();
+  rl_redisplay();
+
+  return 0;
 }

 static void handle_line(char* line)
 {
-  free(line);
+  bool exit = false;
+  if (line)
+  {
+    line_stat = rdln::full;
+    the_line = line;
+    std::string test_line = line;
+    boost::trim_right(test_line);
+    if(!test_line.empty())
+    {
+      add_history(test_line.c_str());
+      history_set_pos(history_length);
+      if (test_line == "exit" || test_line == "q")
+        exit = true;
+    }
+  } else
+  /* EOF */
+  {
+    line_stat = rdln::empty;
+    exit = true;
+  }
  rl_done = 1;
+  if (exit)
+    rl_set_prompt("");
  return;
 }

-static int handle_enter(int x, int y)
-{
-  std::lock_guard<std::mutex> lock(sync_mutex);
-  char* line = NULL;
-
-  line = rl_copy_text(0, rl_end);
-  std::string test_line = line;
-  free(line);
-  boost::trim_right(test_line);
-
-  rl_crlf();
-  rl_on_new_line();
-
-  if(test_line.empty())
-  {
-    last_line = "";
-    rl_set_prompt(last_prompt.c_str());
-    rl_replace_line("", 1);
-    rl_redisplay();
-    have_line.notify_one();
-    return 0;
-  }
-
-  rl_set_prompt("");
-  rl_replace_line("", 1);
-  rl_redisplay();
-  
-  if (!test_line.empty())
-  {
-    last_line = test_line;
-    add_history(test_line.c_str());
-    history_set_pos(history_length);
-  }
-
-  if(last_line != "exit" && last_line != "q")
-  {
-    rl_set_prompt(last_prompt.c_str());
-    rl_replace_line("", 1);
-    rl_redisplay();
-  }
-
-  have_line.notify_one();
-  return 0;
-}
-
-static int startup_hook()
-{
-  rl_bind_key(RETURN, handle_enter);
-  rl_bind_key(NEWLINE, handle_enter);
-  return 0;
-}
-
 static char* completion_matches(const char* text, int state)
 {
  static size_t list_index;
@@ -258,7 +208,6 @@ static char** attempted_completion(const char* text, int start, int end)

 static void install_line_handler()
 {
-  rl_startup_hook = startup_hook;
  rl_attempted_completion_function = attempted_completion;
  rl_callback_handler_install("", handle_line);
  stifle_history(500);
@@ -269,8 +218,6 @@ static void remove_line_handler()
  rl_replace_line("", 0);
  rl_set_prompt("");
  rl_redisplay();
-  rl_unbind_key(RETURN);
-  rl_unbind_key(NEWLINE);
  rl_callback_handler_remove();
 }

--- a/contrib/epee/src/string_tools.cpp
+++ b/contrib/epee/src/string_tools.cpp
@@ -26,6 +26,8 @@

 #include "string_tools.h"

+#include <ctype.h>
+
 #ifdef _WIN32
 # include <winsock2.h>
 #else
@@ -56,6 +58,16 @@ namespace string_tools

    return true;
  }
+  //----------------------------------------------------------------------------
+  bool validate_hex(uint64_t length, const std::string& str)
+  {
+    if (str.size() != length)
+      return false;
+    for (char c: str)
+      if (!isxdigit(c))
+        return false;
+    return true;
+  }
 }
 }

--- a/contrib/epee/src/wipeable_string.cpp
+++ b/contrib/epee/src/wipeable_string.cpp
@@ -0,0 +1,146 @@
+// Copyright (c) 2017-2018, The Monero Project
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <string.h>
+#include "memwipe.h"
+#include "misc_log_ex.h"
+#include "wipeable_string.h"
+
+namespace epee
+{
+
+wipeable_string::wipeable_string(const wipeable_string &other):
+  buffer(other.buffer)
+{
+}
+
+wipeable_string::wipeable_string(wipeable_string &&other)
+{
+  if (&other == this)
+    return;
+  buffer = std::move(other.buffer);
+}
+
+wipeable_string::wipeable_string(const std::string &other)
+{
+  grow(other.size());
+  memcpy(buffer.data(), other.c_str(), size());
+}
+
+wipeable_string::wipeable_string(std::string &&other)
+{
+  grow(other.size());
+  memcpy(buffer.data(), other.c_str(), size());
+  if (!other.empty())
+  {
+    memwipe(&other[0], other.size()); // we're kinda left with this again aren't we
+    other = std::string();
+  }
+}
+
+wipeable_string::wipeable_string(const char *s)
+{
+  grow(strlen(s));
+  memcpy(buffer.data(), s, size());
+}
+
+wipeable_string::~wipeable_string()
+{
+  wipe();
+}
+
+void wipeable_string::wipe()
+{
+  if (!buffer.empty())
+    memwipe(buffer.data(), buffer.size() * sizeof(char));
+}
+
+void wipeable_string::grow(size_t sz, size_t reserved)
+{
+  if (reserved < sz)
+    reserved = sz;
+  if (reserved <= buffer.capacity())
+  {
+    if (sz < buffer.size())
+      memwipe(buffer.data() + sz, buffer.size() - sz);
+    buffer.resize(sz);
+    return;
+  }
+  size_t old_sz = buffer.size();
+  std::unique_ptr<char[]> tmp{new char[old_sz]};
+  memcpy(tmp.get(), buffer.data(), old_sz * sizeof(char));
+  if (old_sz > 0)
+    memwipe(buffer.data(), old_sz * sizeof(char));
+  buffer.reserve(reserved);
+  buffer.resize(sz);
+  memcpy(buffer.data(), tmp.get(), old_sz * sizeof(char));
+  if (old_sz > 0)
+    memwipe(tmp.get(), old_sz * sizeof(char));
+}
+
+void wipeable_string::push_back(char c)
+{
+  grow(size() + 1);
+  buffer.back() = c;
+}
+
+void wipeable_string::pop_back()
+{
+  resize(size() - 1);
+}
+
+void wipeable_string::resize(size_t sz)
+{
+  grow(sz);
+}
+
+void wipeable_string::reserve(size_t sz)
+{
+  grow(size(), sz);
+}
+
+void wipeable_string::clear()
+{
+  resize(0);
+}
+
+wipeable_string &wipeable_string::operator=(wipeable_string &&other)
+{
+  if (&other != this)
+    buffer = std::move(other.buffer);
+  return *this;
+}
+
+wipeable_string &wipeable_string::operator=(const wipeable_string &other)
+{
+  if (&other != this)
+    buffer = other.buffer;
+  return *this;
+}
+
+}
--- a/contrib/epee/tests/src/net/test_net.h
+++ b/contrib/epee/tests/src/net/test_net.h
@@ -155,7 +155,7 @@ namespace tests

    bool init(const std::string& bind_port = "", const std::string& bind_ip = "0.0.0.0")
    {
-      m_net_server.get_config_object().m_pcommands_handler = this;
+      m_net_server.get_config_object().set_handler(this);
      m_net_server.get_config_object().m_invoke_timeout = 1000;
      LOG_PRINT_L0("Binding on " << bind_ip << ":" << bind_port);
      return m_net_server.init_server(bind_port, bind_ip);
@@ -261,7 +261,7 @@ namespace tests
    boost::thread th1( boost::bind(&test_levin_server::run, &srv1));
    boost::thread th2( boost::bind(&test_levin_server::run, &srv2));

-    LOG_PRINT_L0("Initalized servers, waiting for worker threads started...");
+    LOG_PRINT_L0("Initialized servers, waiting for worker threads started...");
    misc_utils::sleep_no_w(1000);  


--- a/contrib/fuzz_testing/fuzz.sh
+++ b/contrib/fuzz_testing/fuzz.sh
@@ -10,12 +10,20 @@ fi
 type="$1"
 if test -z "$type"
 then
-  echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction"
+  echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin"
  exit 1
 fi
 case "$type" in
-  block|transaction|signature|cold-outputs|cold-transaction) ;;
-  *) echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction"; exit 1 ;;
+  block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin) ;;
+  *) echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin"; exit 1 ;;
 esac

-afl-fuzz -i tests/data/fuzz/$type -m 150 -t 250 -o fuzz-out/$type build/fuzz/tests/fuzz/${type}_fuzz_tests
+if test -d "fuzz-out/$type"
+then
+  dir="-"
+else
+  dir="tests/data/fuzz/$type"
+fi
+
+mkdir -p fuzz-out
+afl-fuzz -i "$dir" -m none -t 250 -o fuzz-out/$type build/fuzz/tests/fuzz/${type}_fuzz_tests @@
--- a/contrib/rlwrap/monerocommands_bitmonerod.txt
+++ b/contrib/rlwrap/monerocommands_bitmonerod.txt
@@ -32,4 +32,5 @@ status
 stop_daemon
 stop_mining
 stop_save_graph
+sync_info
 unban
--- a/contrib/snap/snapcraft.yaml
+++ b/contrib/snap/snapcraft.yaml
@@ -1,5 +1,5 @@
 name: monero
-version: 0.10.2-1
+version: 0.11.1.0-1
 summary: "Monero: the secure, private, untraceable cryptocurrency https://getmonero.org"
 description: |
    Monero is a private, secure, untraceable, decentralised digital currency.
@@ -35,7 +35,6 @@ parts:
        plugin: cmake
        configflags:
            - -DBDB_STATIC=1
-            - -DUPNP_STATIC=1
            - -DBoost_USE_STATIC_LIBS=1
            - -DBoost_USE_STATIC_RUNTIME=1
            - -DARCH=default
@@ -46,11 +45,15 @@ parts:
            - libunbound-dev
            - libevent-dev
            - libboost-all-dev
+            - libzmqpp-dev
+            - libzmq3-dev
+            - libsodium-dev
            - libdb-dev
            - libunwind-dev
            - libminiupnpc-dev
            - libldns-dev
            - libexpat1-dev
+            - libreadline6-dev
            - bison
            - doxygen
            - graphviz
--- a/external/CMakeLists.txt
+++ b/external/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -34,42 +34,21 @@
 # We always compile if we are building statically to reduce static dependency issues...
 # ...except for FreeBSD, because FreeBSD is a special case that doesn't play well with
 # others.
-if(NOT IOS)
-    find_package(Miniupnpc QUIET)
+
+find_package(Miniupnpc REQUIRED)
+
+message(STATUS "Using in-tree miniupnpc")
+
+add_subdirectory(miniupnp/miniupnpc)
+
+set_property(TARGET libminiupnpc-static PROPERTY FOLDER "external")
+if(MSVC)
+  set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -wd4244 -wd4267")
+elseif(NOT MSVC)
+  set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-undef -Wno-unused-result -Wno-unused-value")
 endif()

-# If we have the correct shared version and we're not building static, use it
-if(STATIC OR IOS)
- set(USE_SHARED_MINIUPNPC false)
-elseif(MINIUPNP_FOUND AND MINIUPNPC_VERSION_1_7_OR_HIGHER)
- set(USE_SHARED_MINIUPNPC true)
-endif()
-
-if(USE_SHARED_MINIUPNPC)
-  message(STATUS "Using shared miniupnpc found at ${MINIUPNP_INCLUDE_DIR}")
-
-  set(UPNP_STATIC false PARENT_SCOPE)
-  set(UPNP_INCLUDE ${MINIUPNP_INCLUDE_DIR} PARENT_SCOPE)
-  set(UPNP_LIBRARIES ${MINIUPNP_LIBRARY} PARENT_SCOPE)
-else()
-  if(STATIC)
-    message(STATUS "Using miniupnpc from local source tree for static build")
-  else()
-    message(STATUS "Using miniupnpc from local source tree (/external/miniupnpc)")
-  endif()
-
-  add_subdirectory(miniupnpc)
-
-  set_property(TARGET libminiupnpc-static PROPERTY FOLDER "external")
-  if(MSVC)
-    set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -wd4244 -wd4267")
-  elseif(NOT MSVC)
-    set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-undef -Wno-unused-result -Wno-unused-value")
-  endif()
-
-  set(UPNP_STATIC true PARENT_SCOPE)
-  set(UPNP_LIBRARIES "libminiupnpc-static" PARENT_SCOPE)
-endif()
+set(UPNP_LIBRARIES "libminiupnpc-static" PARENT_SCOPE)

 find_package(Unbound)

--- a/external/boost/archive/portable_binary_oarchive.hpp
+++ b/external/boost/archive/portable_binary_oarchive.hpp
@@ -41,19 +41,24 @@ class portable_binary_oarchive_exception :
    public boost::archive::archive_exception
 {
 public:
-    typedef enum {
+    enum exception_code {
        invalid_flags 
-    } exception_code;
-    portable_binary_oarchive_exception(exception_code c = invalid_flags )
+    } m_exception_code ;
+    portable_binary_oarchive_exception(exception_code c = invalid_flags ) :
+        boost::archive::archive_exception(boost::archive::archive_exception::other_exception),
+        m_exception_code(c)
    {}
    virtual const char *what( ) const throw( )
    {
        const char *msg = "programmer error";
-        switch(code){
+        switch(m_exception_code){
        case invalid_flags:
            msg = "cannot be both big and little endian";
+            break;
        default:
-            boost::archive::archive_exception::what();
+            msg = boost::archive::archive_exception::what();
+            assert(false);
+            break;
        }
        return msg;
    }
--- a/external/db_drivers/CMakeLists.txt
+++ b/external/db_drivers/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
--- a/external/db_drivers/liblmdb/CMakeLists.txt
+++ b/external/db_drivers/liblmdb/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -46,11 +46,20 @@ add_library(lmdb
 target_link_libraries(lmdb
  PRIVATE
    ${CMAKE_THREAD_LIBS_INIT})
-if(WIN32)
-  target_link_libraries(lmdb
-    -lntdll)
-endif()
 if(${ARCH_WIDTH} EQUAL 32)
  target_compile_definitions(lmdb
    PUBLIC -DMDB_VL32)
 endif()
+
+# GUI/libwallet install target
+if (BUILD_GUI_DEPS)
+    if(IOS)
+        set(lib_folder lib-${ARCH})
+    else()
+        set(lib_folder lib)
+    endif()
+    install(TARGETS lmdb
+        ARCHIVE DESTINATION ${lib_folder}
+        LIBRARY DESTINATION ${lib_folder})
+endif()
+set_property(TARGET lmdb APPEND PROPERTY COMPILE_FLAGS "-fPIC")
--- a/external/db_drivers/liblmdb/Makefile
+++ b/external/db_drivers/liblmdb/Makefile
@@ -24,8 +24,8 @@ W	= -W -Wall -Wno-unused-parameter -Wbad-function-cast -Wuninitialized
 THREADS = -pthread
 OPT = -O2 -g
 CFLAGS	= $(THREADS) $(OPT) $(W) $(XCFLAGS)
-LDLIBS	= # -lntdll # Windows needs ntdll
-SOLIBS	= # -lntdll
+LDLIBS	= 
+SOLIBS	= 
 prefix	= /usr/local
 exec_prefix = $(prefix)
 bindir = $(exec_prefix)/bin
@@ -38,8 +38,8 @@ mandir = $(datarootdir)/man

 IHDRS	= lmdb.h
 ILIBS	= liblmdb.a liblmdb.so
-IPROGS	= mdb_stat mdb_copy mdb_dump mdb_load
-IDOCS	= mdb_stat.1 mdb_copy.1 mdb_dump.1 mdb_load.1
+IPROGS	= mdb_stat mdb_copy mdb_dump mdb_load mdb_drop
+IDOCS	= mdb_stat.1 mdb_copy.1 mdb_dump.1 mdb_load.1 mdb_drop.1
 PROGS	= $(IPROGS) mtest mtest2 mtest3 mtest4 mtest5
 all:	$(ILIBS) $(PROGS)

@@ -71,6 +71,7 @@ mdb_stat: mdb_stat.o liblmdb.a
 mdb_copy: mdb_copy.o liblmdb.a
 mdb_dump: mdb_dump.o liblmdb.a
 mdb_load: mdb_load.o liblmdb.a
+mdb_drop: mdb_drop.o liblmdb.a
 mtest:    mtest.o    liblmdb.a
 mtest2:	mtest2.o liblmdb.a
 mtest3:	mtest3.o liblmdb.a
--- a/external/db_drivers/liblmdb/mdb.c
+++ b/external/db_drivers/liblmdb/mdb.c
@@ -47,29 +47,35 @@
 * the full size. These APIs are defined in <wdm.h> and <ntifs.h>
 * but those headers are meant for driver-level development and
 * conflict with the regular user-level headers, so we explicitly
- * declare them here. Using these APIs also means we must link to
- * ntdll.dll, which is not linked by default in user code.
+ * declare them here. We get pointers to these functions from
+ * NTDLL.DLL at runtime, to avoid buildtime dependencies on any
+ * NTDLL import libraries.
 */
-NTSTATUS WINAPI
-NtCreateSection(OUT PHANDLE sh, IN ACCESS_MASK acc,
+typedef NTSTATUS WINAPI (NtCreateSectionFunc)
+  (OUT PHANDLE sh, IN ACCESS_MASK acc,
  IN void * oa OPTIONAL,
  IN PLARGE_INTEGER ms OPTIONAL,
  IN ULONG pp, IN ULONG aa, IN HANDLE fh OPTIONAL);

+static NtCreateSectionFunc *NtCreateSection;
+
 typedef enum _SECTION_INHERIT {
 	ViewShare = 1,
 	ViewUnmap = 2
 } SECTION_INHERIT;

-NTSTATUS WINAPI
-NtMapViewOfSection(IN PHANDLE sh, IN HANDLE ph,
+typedef NTSTATUS WINAPI (NtMapViewOfSectionFunc)
+  (IN PHANDLE sh, IN HANDLE ph,
  IN OUT PVOID *addr, IN ULONG_PTR zbits,
  IN SIZE_T cs, IN OUT PLARGE_INTEGER off OPTIONAL,
  IN OUT PSIZE_T vs, IN SECTION_INHERIT ih,
  IN ULONG at, IN ULONG pp);

-NTSTATUS WINAPI
-NtClose(HANDLE h);
+static NtMapViewOfSectionFunc *NtMapViewOfSection;
+
+typedef NTSTATUS WINAPI (NtCloseFunc)(HANDLE h);
+
+static NtCloseFunc *NtClose;

 /** getpid() returns int; MinGW defines pid_t but MinGW64 typedefs it
 *  as int64 which is wrong. MSVC doesn't define it at all, so just
@@ -304,7 +310,8 @@ union semun {
 # else
 #  define MDB_USE_ROBUST	1
 /* glibc < 2.12 only provided _np API */
-#  if defined(__GLIBC__) && GLIBC_VER < 0x02000c
+#  if (defined(__GLIBC__) && GLIBC_VER < 0x02000c) || \
+	(defined(PTHREAD_MUTEX_ROBUST_NP) && !defined(PTHREAD_MUTEX_ROBUST))
 #   define PTHREAD_MUTEX_ROBUST	PTHREAD_MUTEX_ROBUST_NP
 #   define pthread_mutexattr_setrobust(attr, flag)	pthread_mutexattr_setrobust_np(attr, flag)
 #   define pthread_mutex_consistent(mutex)	pthread_mutex_consistent_np(mutex)
@@ -1634,7 +1641,11 @@ mdb_assert_fail(MDB_env *env, const char *expr_txt,
 	if (env->me_assert_func)
 		env->me_assert_func(env, buf);
 	fprintf(stderr, "%s\n", buf);
+#ifdef NDEBUG
+	_exit();
+#else
 	abort();
+#endif
 }
 #else
 # define mdb_assert0(env, expr, expr_txt) ((void) 0)
@@ -4392,6 +4403,21 @@ mdb_env_open2(MDB_env *env, int prev)
 		env->me_pidquery = MDB_PROCESS_QUERY_LIMITED_INFORMATION;
 	else
 		env->me_pidquery = PROCESS_QUERY_INFORMATION;
+	/* Grab functions we need from NTDLL */
+	if (!NtCreateSection) {
+		HMODULE h = GetModuleHandle("NTDLL.DLL");
+		if (!h)
+			return MDB_PANIC;
+		NtClose = (NtCloseFunc *)GetProcAddress(h, "NtClose");
+		if (!NtClose)
+			return MDB_PANIC;
+		NtMapViewOfSection = (NtMapViewOfSectionFunc *)GetProcAddress(h, "NtMapViewOfSection");
+		if (!NtMapViewOfSection)
+			return MDB_PANIC;
+		NtCreateSection = (NtCreateSectionFunc *)GetProcAddress(h, "NtCreateSection");
+		if (!NtCreateSection)
+			return MDB_PANIC;
+	}
 #endif /* _WIN32 */

 #ifdef BROKEN_FDATASYNC
@@ -4977,6 +5003,13 @@ mdb_env_setup_locks(MDB_env *env, char *lpath, int mode, int *excl)
 #else	/* MDB_USE_POSIX_MUTEX: */
 		pthread_mutexattr_t mattr;

+		/* Solaris needs this before initing a robust mutex.  Otherwise
+		 * it may skip the init and return EBUSY "seems someone already
+		 * inited" or EINVAL "it was inited differently".
+		 */
+		memset(env->me_txns->mti_rmutex, 0, sizeof(*env->me_txns->mti_rmutex));
+		memset(env->me_txns->mti_wmutex, 0, sizeof(*env->me_txns->mti_wmutex));
+
 		if ((rc = pthread_mutexattr_init(&mattr))
 			|| (rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED))
 #ifdef MDB_ROBUST_SUPPORTED
@@ -6288,6 +6321,10 @@ release:
 		if (rc)
 			return rc;
 	}
+#ifdef MDB_VL32
+	if (mc->mc_ovpg == mp)
+		mc->mc_ovpg = NULL;
+#endif
 	mc->mc_db->md_overflow_pages -= ovpages;
 	return 0;
 }
@@ -7194,7 +7231,7 @@ mdb_cursor_put(MDB_cursor *mc, MDB_val *key, MDB_val *data,

 	dkey.mv_size = 0;

-	if (flags == MDB_CURRENT) {
+	if (flags & MDB_CURRENT) {
 		if (!(mc->mc_flags & C_INITIALIZED))
 			return EINVAL;
 		rc = MDB_SUCCESS;
@@ -7587,7 +7624,7 @@ put_sub:
 			xdata.mv_size = 0;
 			xdata.mv_data = "";
 			leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
-			if (flags & MDB_CURRENT) {
+			if (flags == MDB_CURRENT) {
 				xflags = MDB_CURRENT|MDB_NOSPILL;
 			} else {
 				mdb_xcursor_init1(mc, leaf);
--- a/external/db_drivers/liblmdb/mdb_drop.1
+++ b/external/db_drivers/liblmdb/mdb_drop.1
@@ -0,0 +1,40 @@
+.TH MDB_DROP 1 "2017/11/19" "LMDB 0.9.70"
+.\" Copyright 2014-2017 Howard Chu, Symas Corp. All Rights Reserved.
+.\" Copying restrictions apply.  See COPYRIGHT/LICENSE.
+.SH NAME
+mdb_drop \- LMDB database delete tool
+.SH SYNOPSIS
+.B mdb_drop
+[\c
+.BR \-V ]
+[\c
+.BR \-n ]
+[\c
+.BR \-d ]
+[\c
+.BI \-s \ subdb\fR]
+.BR \ envpath
+.SH DESCRIPTION
+The
+.B mdb_drop
+utility empties or deletes a database in the specified
+environment.
+.SH OPTIONS
+.TP
+.BR \-V
+Write the library version number to the standard output, and exit.
+.TP
+.BR \-n
+Operate on an LMDB database which does not use subdirectories.
+.TP
+.BR \-d
+Delete the specified database, don't just empty it.
+.TP
+.BR \-s \ subdb
+Operate on a specific subdatabase. If no database is specified, only the main database is dropped.
+.SH DIAGNOSTICS
+Exit status is zero if no errors occur.
+Errors result in a non-zero exit status and
+a diagnostic message being written to standard error.
+.SH AUTHOR
+Howard Chu of Symas Corporation <http://www.symas.com>
--- a/external/db_drivers/liblmdb/mdb_drop.c
+++ b/external/db_drivers/liblmdb/mdb_drop.c
@@ -0,0 +1,135 @@
+/* mdb_drop.c - memory-mapped database delete tool */
+/*
+ * Copyright 2016-2017 Howard Chu, Symas Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <signal.h>
+#include "lmdb.h"
+
+static volatile sig_atomic_t gotsig;
+
+static void dumpsig( int sig )
+{
+	gotsig=1;
+}
+
+static void usage(char *prog)
+{
+	fprintf(stderr, "usage: %s [-V] [-n] [-d] [-s subdb] dbpath\n", prog);
+	exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+	int i, rc;
+	MDB_env *env;
+	MDB_txn *txn;
+	MDB_dbi dbi;
+	char *prog = argv[0];
+	char *envname;
+	char *subname = NULL;
+	int envflags = 0, delete = 0;
+
+	if (argc < 2) {
+		usage(prog);
+	}
+
+	/* -d: delete the db, don't just empty it
+	 * -s: drop the named subDB
+	 * -n: use NOSUBDIR flag on env_open
+	 * -V: print version and exit
+	 * (default) empty the main DB
+	 */
+	while ((i = getopt(argc, argv, "dns:V")) != EOF) {
+		switch(i) {
+		case 'V':
+			printf("%s\n", MDB_VERSION_STRING);
+			exit(0);
+			break;
+		case 'd':
+			delete = 1;
+			break;
+		case 'n':
+			envflags |= MDB_NOSUBDIR;
+			break;
+		case 's':
+			subname = optarg;
+			break;
+		default:
+			usage(prog);
+		}
+	}
+
+	if (optind != argc - 1)
+		usage(prog);
+
+#ifdef SIGPIPE
+	signal(SIGPIPE, dumpsig);
+#endif
+#ifdef SIGHUP
+	signal(SIGHUP, dumpsig);
+#endif
+	signal(SIGINT, dumpsig);
+	signal(SIGTERM, dumpsig);
+
+	envname = argv[optind];
+	rc = mdb_env_create(&env);
+	if (rc) {
+		fprintf(stderr, "mdb_env_create failed, error %d %s\n", rc, mdb_strerror(rc));
+		return EXIT_FAILURE;
+	}
+
+	mdb_env_set_maxdbs(env, 2);
+
+	rc = mdb_env_open(env, envname, envflags, 0664);
+	if (rc) {
+		fprintf(stderr, "mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
+		goto env_close;
+	}
+
+	rc = mdb_txn_begin(env, NULL, 0, &txn);
+	if (rc) {
+		fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
+		goto env_close;
+	}
+
+	rc = mdb_open(txn, subname, 0, &dbi);
+	if (rc) {
+		fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
+		goto txn_abort;
+	}
+
+	rc = mdb_drop(txn, dbi, delete);
+	if (rc) {
+		fprintf(stderr, "mdb_drop failed, error %d %s\n", rc, mdb_strerror(rc));
+		goto txn_abort;
+	}
+	rc = mdb_txn_commit(txn);
+	if (rc) {
+		fprintf(stderr, "mdb_txn_commit failed, error %d %s\n", rc, mdb_strerror(rc));
+		goto txn_abort;
+	}
+	txn = NULL;
+
+txn_abort:
+	if (txn)
+		mdb_txn_abort(txn);
+env_close:
+	mdb_env_close(env);
+
+	return rc ? EXIT_FAILURE : EXIT_SUCCESS;
+}
--- a/external/db_drivers/liblmdb/mdb_load.1
+++ b/external/db_drivers/liblmdb/mdb_load.1
@@ -37,6 +37,13 @@ option below.
 .BR \-V
 Write the library version number to the standard output, and exit.
 .TP
+.BR \-a
+Append all records in the order they appear in the input. The input is assumed to already be
+in correctly sorted order and no sorting or checking for redundant values will be performed.
+This option must be used to reload data that was produced by running
+.B mdb_dump
+on a database that uses custom compare functions.
+.TP
 .BR \-f \ file
 Read from the specified file instead of from the standard input.
 .TP
--- a/external/db_drivers/liblmdb/mdb_load.c
+++ b/external/db_drivers/liblmdb/mdb_load.c
@@ -37,6 +37,7 @@ static int Eof;
 static MDB_envinfo info;

 static MDB_val kbuf, dbuf;
+static MDB_val k0buf;

 #ifdef _WIN32
 #define Z	"I"
@@ -77,6 +78,7 @@ static void readhdr(void)
 {
 	char *ptr;

+	flags = 0;
 	while (fgets(dbuf.mv_data, dbuf.mv_size, stdin) != NULL) {
 		lineno++;
 		if (!strncmp(dbuf.mv_data, "VERSION=", STRLENOF("VERSION="))) {
@@ -285,10 +287,15 @@ badend:

 static void usage(void)
 {
-	fprintf(stderr, "usage: %s [-V] [-f input] [-n] [-s name] [-N] [-T] dbpath\n", prog);
+	fprintf(stderr, "usage: %s [-V] [-a] [-f input] [-n] [-s name] [-N] [-T] dbpath\n", prog);
 	exit(EXIT_FAILURE);
 }

+static int greater(const MDB_val *a, const MDB_val *b)
+{
+	return 1;
+}
+
 int main(int argc, char *argv[])
 {
 	int i, rc;
@@ -297,8 +304,9 @@ int main(int argc, char *argv[])
 	MDB_cursor *mc;
 	MDB_dbi dbi;
 	char *envname;
-	int envflags = 0, putflags = 0;
-	int dohdr = 0;
+	int envflags = MDB_NOSYNC, putflags = 0;
+	int dohdr = 0, append = 0;
+	MDB_val prevk;

 	prog = argv[0];

@@ -306,19 +314,23 @@ int main(int argc, char *argv[])
 		usage();
 	}

-	/* -f: load file instead of stdin
+	/* -a: append records in input order
+	 * -f: load file instead of stdin
 	 * -n: use NOSUBDIR flag on env_open
 	 * -s: load into named subDB
 	 * -N: use NOOVERWRITE on puts
 	 * -T: read plaintext
 	 * -V: print version and exit
 	 */
-	while ((i = getopt(argc, argv, "f:ns:NTV")) != EOF) {
+	while ((i = getopt(argc, argv, "af:ns:NTV")) != EOF) {
 		switch(i) {
 		case 'V':
 			printf("%s\n", MDB_VERSION_STRING);
 			exit(0);
 			break;
+		case 'a':
+			append = 1;
+			break;
 		case 'f':
 			if (freopen(optarg, "r", stdin) == NULL) {
 				fprintf(stderr, "%s: %s: reopen: %s\n",
@@ -377,12 +389,15 @@ int main(int argc, char *argv[])
 	}

 	kbuf.mv_size = mdb_env_get_maxkeysize(env) * 2 + 2;
-	kbuf.mv_data = malloc(kbuf.mv_size);
+	kbuf.mv_data = malloc(kbuf.mv_size * 2);
+	k0buf.mv_size = kbuf.mv_size;
+	k0buf.mv_data = (char *)kbuf.mv_data + kbuf.mv_size;
+	prevk.mv_data = k0buf.mv_data;

 	while(!Eof) {
 		MDB_val key, data;
 		int batch = 0;
-		flags = 0;
+		int appflag;

 		if (!dohdr) {
 			dohdr = 1;
@@ -400,6 +415,12 @@ int main(int argc, char *argv[])
 			fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
 			goto txn_abort;
 		}
+		prevk.mv_size = 0;
+		if (append) {
+			mdb_set_compare(txn, dbi, greater);
+			if (flags & MDB_DUPSORT)
+				mdb_set_dupsort(txn, dbi, greater);
+		}

 		rc = mdb_cursor_open(txn, dbi, &mc);
 		if (rc) {
@@ -418,7 +439,20 @@ int main(int argc, char *argv[])
 				goto txn_abort;
 			}

-			rc = mdb_cursor_put(mc, &key, &data, putflags);
+			if (append) {
+				appflag = MDB_APPEND;
+				if (flags & MDB_DUPSORT) {
+					if (prevk.mv_size == key.mv_size && !memcmp(prevk.mv_data, key.mv_data, key.mv_size))
+						appflag = MDB_CURRENT|MDB_APPENDDUP;
+					else {
+						memcpy(prevk.mv_data, key.mv_data, key.mv_size);
+						prevk.mv_size = key.mv_size;
+					}
+				}
+			} else {
+				appflag = 0;
+			}
+			rc = mdb_cursor_put(mc, &key, &data, putflags|appflag);
 			if (rc == MDB_KEYEXIST && putflags)
 				continue;
 			if (rc) {
@@ -443,6 +477,10 @@ int main(int argc, char *argv[])
 					fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
 					goto txn_abort;
 				}
+				if (appflag & MDB_APPENDDUP) {
+					MDB_val k, d;
+					mdb_cursor_get(mc, &k, &d, MDB_LAST);
+				}
 				batch = 0;
 			}
 		}
--- a/external/db_drivers/liblmdb/tooltag
+++ b/external/db_drivers/liblmdb/tooltag
@@ -4,6 +4,11 @@
 	<title>mdb_copy - environment copy tool</title>
 	<filename>mdb_copy.1</filename>
  </compound>
+  <compound kind="page">
+    <name>mdb_drop_1</name>
+	<title>mdb_drop - database delete tool</title>
+	<filename>mdb_drop.1</filename>
+  </compound>
  <compound kind="page">
    <name>mdb_dump_1</name>
 	<title>mdb_dump - environment export tool</title>
--- a/external/easylogging++/CMakeLists.txt
+++ b/external/easylogging++/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright (c) 2014-2017, The Monero Project
+# Copyright (c) 2014-2018, The Monero Project
 # 
 # All rights reserved.
 # 
@@ -51,6 +51,8 @@ if (BUILD_GUI_DEPS)
        set(lib_folder lib)
    endif()
    install(TARGETS easylogging
-        ARCHIVE DESTINATION ${lib_folder})
+        ARCHIVE DESTINATION ${lib_folder}
+        LIBRARY DESTINATION ${lib_folder})
 endif()
+set_property(TARGET easylogging APPEND PROPERTY COMPILE_FLAGS "-fPIC")

--- a/external/easylogging++/ea_config.h
+++ b/external/easylogging++/ea_config.h
@@ -2,9 +2,13 @@

 #define ELPP_THREAD_SAFE
 #define ELPP_DEFAULT_LOG_FILE ""
-#if !defined __GNUC__ || defined __MINGW32__ || defined __MINGW64__ || defined __ANDROID__
-#else
-#define ELPP_FEATURE_CRASH_LOG 1
-#endif
 #define ELPP_DISABLE_DEFAULT_CRASH_HANDLING
 #define ELPP_NO_CHECK_MACROS
+#define ELPP_WINSOCK2
+#define ELPP_NO_DEBUG_MACROS
+
+#ifdef EASYLOGGING_CC
+#if !(!defined __GNUC__ || defined __MINGW32__ || defined __MINGW64__ || defined __ANDROID__)
+#define ELPP_FEATURE_CRASH_LOG
+#endif
+#endif
--- a/external/easylogging++/easylogging++.cc
+++ b/external/easylogging++/easylogging++.cc
@@ -14,8 +14,11 @@
 //  http://muflihun.com
 //

+#define EASYLOGGING_CC
 #include "easylogging++.h"

+#include <unistd.h>
+
 #if defined(AUTO_INITIALIZE_EASYLOGGINGPP)
 INITIALIZE_EASYLOGGINGPP
 #endif
@@ -34,8 +37,12 @@ static void abort(int status, const std::string& reason) {
 #if defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG)
  // Ignore msvc critical error dialog - break instead (on debug mode)
  _asm int 3
+#else
+#ifdef NDEBUG
+  ::_exit(1);
 #else
  ::abort();
+#endif
 #endif  // defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG)
 }

@@ -1015,8 +1022,9 @@ const std::string OS::getBashOutput(const char* command) {
  char hBuff[4096];
  if (fgets(hBuff, sizeof(hBuff), proc) != nullptr) {
    pclose(proc);
-    if (hBuff[strlen(hBuff) - 1] == '\n') {
-      hBuff[strlen(hBuff) - 1] = '\0';
+    const size_t len = strlen(hBuff);
+    if (len > 0 && hBuff[len - 1] == '\n') {
+      hBuff[len- 1] = '\0';
    }
    return std::string(hBuff);
  }
@@ -1961,8 +1969,13 @@ void VRegistry::setCategories(const char* categories, bool clear) {
    m_categories.push_back(std::make_pair(ss.str(), level));
  };

-  if (clear)
+  if (clear) {
    m_categories.clear();
+    m_categoriesString.clear();
+  }
+  if (!m_categoriesString.empty())
+    m_categoriesString += ",";
+  m_categoriesString += categories;
  if (!categories)
    return;

@@ -2001,6 +2014,11 @@ void VRegistry::setCategories(const char* categories, bool clear) {
  }
 }

+std::string VRegistry::getCategories() {
+  base::threading::ScopedLock scopedLock(lock());
+  return m_categoriesString;
+}
+
 // Log levels are sorted in a weird way...
 static int priority(Level level) {
  if (level == Level::Fatal) return 0;
@@ -3073,6 +3091,10 @@ void Loggers::setCategories(const char* categories, bool clear) {
  ELPP->vRegistry()->setCategories(categories, clear);
 }

+std::string Loggers::getCategories() {
+  return ELPP->vRegistry()->getCategories();
+}
+
 void Loggers::clearCategories(void) {
  ELPP->vRegistry()->clearCategories();
 }
--- a/external/easylogging++/easylogging++.h
+++ b/external/easylogging++/easylogging++.h
@@ -99,6 +99,11 @@
 #else
 #  define ELPP_OS_FREEBSD 0
 #endif
+#if (defined(__OpenBSD__))
+#  define ELPP_OS_OPENBSD 1
+#else
+#  define ELPP_OS_OPENBSD 0
+#endif
 #if (defined(__sun))
 #  define ELPP_OS_SOLARIS 1
 #else
@@ -110,7 +115,7 @@
 #   define ELPP_OS_DRAGONFLY 0
 #endif
 // Unix
-#if ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_SOLARIS || ELPP_OS_DRAGONFLY) && (!ELPP_OS_WINDOWS))
+#if ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_SOLARIS || ELPP_OS_DRAGONFLY || ELPP_OS_OPENBSD) && (!ELPP_OS_WINDOWS))
 #  define ELPP_OS_UNIX 1
 #else
 #  define ELPP_OS_UNIX 0
@@ -195,19 +200,20 @@ ELPP_INTERNAL_DEBUGGING_OUT_INFO << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStre
 #  define ELPP_INTERNAL_INFO(lvl, msg)
 #endif  // (defined(ELPP_DEBUG_INFO))
 #if (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG))
-#  if (ELPP_COMPILER_GCC && !ELPP_MINGW)
+#  if (ELPP_COMPILER_GCC && !ELPP_MINGW && !ELPP_OS_OPENBSD)
 #    define ELPP_STACKTRACE 1
 #  else
-#      define ELPP_STACKTRACE 0
-#      if ELPP_COMPILER_MSVC
-#         pragma message("Stack trace not available for this compiler")
-#      else
-#         warning "Stack trace not available for this compiler";
-#      endif  // ELPP_COMPILER_MSVC
 #    define ELPP_STACKTRACE 0
+#    ifdef EASYLOGGING_CC
+#      if ELPP_COMPILER_MSVC
+#        pragma message("Stack trace not available for this compiler")
+#      else
+#        warning "Stack trace not available for this compiler";
+#      endif  // ELPP_COMPILER_MSVC
+#    endif
 #  endif  // ELPP_COMPILER_GCC
 #else
-#    define ELPP_STACKTRACE 0
+#  define ELPP_STACKTRACE 0
 #endif  // (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG))
 // Miscellaneous macros
 #define ELPP_UNUSED(x) (void)x
@@ -2488,6 +2494,8 @@ class VRegistry : base::NoCopy, public base::threading::ThreadSafe {

  void setCategories(const char* categories, bool clear = true);

+  std::string getCategories();
+
  void setModules(const char* modules);

  bool allowed(Level level, const char* category);
@@ -2518,6 +2526,7 @@ class VRegistry : base::NoCopy, public base::threading::ThreadSafe {
  base::type::EnumType* m_pFlags;
  std::map<std::string, base::type::VerboseLevel> m_modules;
  std::deque<std::pair<std::string, Level>> m_categories;
+  std::string m_categoriesString;
  std::string m_filenameCommonPrefix;
 };
 }  // namespace base
@@ -3953,6 +3962,8 @@ class Loggers : base::StaticClass {
  static void setVModules(const char* modules);
  /// @brief Sets categories as specified (on the fly)
  static void setCategories(const char* categories, bool clear = true);
+  /// @brief Gets current categories
+  static std::string getCategories();
  /// @brief Clears vmodules
  static void clearVModules(void);
  /// @brief Clears categories
--- a/external/miniupnp
+++ b/external/miniupnp
--- a/Show More
+++ b/Show More