wowletify

Reviewed-on: https://git.wownero.com/wownero/wownero/pulls/435

.github/workflows/build.yml

@@ -1,44 +1,21 @@
-name: ci/gh-actions/cli
+name: continuous-integration/gh-actions/cli
 
 on: [push, pull_request]
 
-# The below variables reduce repetitions across similar targets
-env:
-  REMOVE_BUNDLED_BOOST : rm -rf /usr/local/share/boost
-  APT_INSTALL_LINUX: 'sudo apt -y install build-essential cmake libboost-all-dev miniupnpc libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libzmq3-dev libsodium-dev libhidapi-dev libnorm-dev libusb-1.0-0-dev libpgm-dev libprotobuf-dev protobuf-compiler ccache'
-  APT_SET_CONF: |
-        echo "Acquire::Retries \"3\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-        echo "Acquire::ftp::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-
 jobs:
   build-macos:
     runs-on: macOS-latest
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
     - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v2
-      with:
-        path: /Users/runner/Library/Caches/ccache
-        key: ccache-macos-build-${{ github.sha }}
-        restore-keys: ccache-macos-build-
-    - name: install dependencies
-      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install boost hidapi zmq libpgm miniupnpc ldns expat libunwind-headers protobuf ccache
+    - name: update brew and install dependencies
+      run: brew update && brew install boost hidapi zmq libpgm miniupnpc ldns expat libunwind-headers protobuf
     - name: build
-      run: |
-        ccache --max-size=150M
-        make -j3
+      run: make -j3
 
   build-windows:
     runs-on: windows-latest
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: C:\Users\runneradmin\.ccache-temp
-      CCACHE_DIR: C:\Users\runneradmin\.ccache
     defaults:
       run:
         shell: msys2 {0}
@@ -46,128 +23,74 @@ jobs:
     - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v2
-      with:
-        path: C:\Users\runneradmin\.ccache
-        key: ccache-windows-build-${{ github.sha }}
-        restore-keys: ccache-windows-build-
-    - uses: eine/setup-msys2@v2
+    - uses: msys2/setup-msys2@v2
       with:
         update: true
-        install: mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-ccache mingw-w64-x86_64-boost mingw-w64-x86_64-openssl mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-hidapi mingw-w64-x86_64-protobuf-c mingw-w64-x86_64-libusb git
+        install: 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 mingw-w64-x86_64-hidapi mingw-w64-x86_64-protobuf-c mingw-w64-x86_64-libusb git
     - name: build
-      run: |
-        ccache --max-size=150M
-        make release-static-win64 -j2
+      run: make release-static-win64 -j2
 
   build-ubuntu:
     runs-on: ubuntu-latest
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
     - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v2
-      with:
-        path: ~/.ccache
-        key: ccache-ubuntu-build-${{ github.sha }}
-        restore-keys: ccache-ubuntu-build-
     - name: remove bundled boost
-      run: ${{env.REMOVE_BUNDLED_BOOST}}
+      run: sudo rm -rf /usr/local/share/boost
     - name: set apt conf
-      run: ${{env.APT_SET_CONF}}
+      run: |
+        echo "Acquire::Retries \"3\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::ftp::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
     - name: update apt
       run: sudo apt update
     - name: install monero dependencies
-      run: ${{env.APT_INSTALL_LINUX}}
+      run: sudo apt -y install build-essential cmake libboost-all-dev miniupnpc libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libzmq3-dev libsodium-dev libhidapi-dev libnorm-dev libusb-1.0-0-dev libpgm-dev libprotobuf-dev protobuf-compiler
     - name: build
-      run: |
-        ccache --max-size=150M
-        make -j3
+      run: make -j3
 
   libwallet-ubuntu:
     runs-on: ubuntu-latest
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
     - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - uses: actions/cache@v2
-      with:
-        path: ~/.ccache
-        key: ccache-ubuntu-libwallet-${{ github.sha }}
-        restore-keys: ccache-ubuntu-libwallet-
     - name: remove bundled boost
-      run: ${{env.REMOVE_BUNDLED_BOOST}}
+      run: sudo rm -rf /usr/local/share/boost
     - name: set apt conf
-      run: ${{env.APT_SET_CONF}}
+      run: |
+        echo "Acquire::Retries \"3\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::ftp::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
     - name: update apt
       run: sudo apt update
     - name: install monero dependencies
-      run: ${{env.APT_INSTALL_LINUX}}
+      run: sudo apt -y install build-essential cmake libboost-all-dev miniupnpc libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libzmq3-dev libsodium-dev libhidapi-dev libnorm-dev libusb-1.0-0-dev libpgm-dev libprotobuf-dev protobuf-compiler
     - name: build
-      run: |
-        ccache --max-size=150M
-        cmake -DBUILD_GUI_DEPS=ON
-        make -j3
+      run: cmake -DBUILD_GUI_DEPS=ON && make -j3
 
   test-ubuntu:
     needs: build-ubuntu
     runs-on: ubuntu-latest
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: /tmp/.ccache-temp
     steps:
     - uses: actions/checkout@v1
       with:
         submodules: recursive
-    - name: ccache
-      uses: actions/cache@v2
-      with:
-        path: ~/.ccache
-        key: test-ubuntu-ccache-${{ github.sha }}
-        restore-keys: test-ubuntu-ccache-
     - name: remove bundled boost
-      run: ${{env.REMOVE_BUNDLED_BOOST}}
+      run: sudo rm -rf /usr/local/share/boost
     - name: set apt conf
-      run: ${{env.APT_SET_CONF}}
+      run: |
+        echo "Acquire::Retries \"3\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
+        echo "Acquire::ftp::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
     - name: update apt
       run: sudo apt update
     - name: install monero dependencies
-      run: ${{env.APT_INSTALL_LINUX}}
-    - name: install Python dependencies
-      run: pip install requests psutil monotonic
+      run: sudo apt -y install build-essential cmake libboost-all-dev miniupnpc libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libzmq3-dev libsodium-dev libhidapi-dev libnorm-dev libusb-1.0-0-dev libpgm-dev libprotobuf-dev protobuf-compiler
+    - name: install requests
+      run: pip install requests
     - name: tests
       env:
         CTEST_OUTPUT_ON_FAILURE: ON
-      run: |
-        ccache --max-size=150M
-        DIR_BUILD="build/ci/release"
-        DIR_SRC="`pwd`"
-        mkdir -p "${DIR_BUILD}" && cd "${DIR_BUILD}"
-        cmake -S "${DIR_SRC}" -D ARCH="default" -D BUILD_SHARED_LIBS=ON -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=release && make -j3 && make test
-
-# ARCH="default" (not "native") ensures, that a different execution host can execute binaries compiled elsewhere.
-# BUILD_SHARED_LIBS=ON speeds up the linkage part a bit, reduces size, and is the only place where the dynamic linkage is tested.
-
-  source-archive:
-    runs-on: ubuntu-20.04
-    steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: recursive
-    - name: archive
-      run: |
-        pip install git-archive-all
-        export VERSION="monero-$(git describe)"
-        export OUTPUT="$VERSION.tar"
-        echo "OUTPUT=$OUTPUT" >> $GITHUB_ENV
-        /home/runner/.local/bin/git-archive-all --prefix "$VERSION/" --force-submodules "$OUTPUT"
-    - uses: actions/upload-artifact@v2
-      with:
-        name: ${{ env.OUTPUT }}
-        path: /home/runner/work/monero/monero/${{ env.OUTPUT }}
+      run: make release-test -j3

.github/workflows/depends.yml

@@ -1,85 +0,0 @@
-name: ci/gh-actions/depends
-
-on: [push, pull_request]
-
-jobs:
-  build-macos:
-    runs-on: ubuntu-18.04
-    env:
-      CCACHE_COMPRESS: 1
-      CCACHE_TEMPDIR: /tmp/.ccache-temp
-    strategy:
-      fail-fast: false
-      matrix:
-        toolchain:
-          - name: "RISCV 64bit"
-            host: "riscv64-linux-gnu"
-            packages: "python3 gperf g++-riscv64-linux-gnu"
-          - name: "ARM v7"
-            host: "arm-linux-gnueabihf"
-            packages: "python3 gperf g++-arm-linux-gnueabihf"
-          - name: "ARM v8"
-            host: "aarch64-linux-gnu"
-            packages: "python3 gperf g++-aarch64-linux-gnu"
-          - name: "i686 Win"
-            host: "i686-w64-mingw32"
-            packages: "python3 g++-mingw-w64-i686 qttools5-dev-tools"
-          - name: "i686 Linux"
-            host: "i686-pc-linux-gnu"
-            packages: "gperf cmake g++-multilib python3-zmq"
-          - name: "Win64"
-            host: "x86_64-w64-mingw32"
-            packages: "cmake python3 g++-mingw-w64-x86-64 qttools5-dev-tools"
-          - name: "x86_64 Linux"
-            host: "x86_64-unknown-linux-gnu"
-            packages: "gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
-          - name: "Cross-Mac"
-            host: "x86_64-apple-darwin11"
-            packages: "cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev python3-setuptools-git"
-            osx_sdk: "10.11"
-          - name: "x86_64 Freebsd"
-            host: "x86_64-unknown-freebsd"
-            packages: "clang-8 gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
-    name: ${{ matrix.toolchain.name }}
-    steps:
-    - uses: actions/checkout@v1
-      with:
-        submodules: recursive
-    - name: ccache
-      uses: actions/cache@v2
-      with:
-        path: |
-            ~/.ccache
-            contrib/depends/built
-            contrib/depends/sdk-sources
-        key: ccache-${{ matrix.toolchain.host }}-${{ github.sha }}
-        restore-keys: ccache-${{ matrix.toolchain.host }}-
-    - name: set apt conf
-      run: |
-        echo "Acquire::Retries \"3\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-        echo "Acquire::http::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-        echo "Acquire::ftp::Timeout \"120\";" | sudo tee -a /etc/apt/apt.conf.d/80-custom
-    - name: install dependencies
-      run: sudo apt update; sudo apt -y install build-essential libtool cmake autotools-dev automake pkg-config bsdmainutils curl git ca-certificates ccache ${{ matrix.toolchain.packages }}
-    - name: prepare apple-darwin11
-      if: ${{ matrix.toolchain.host == 'x86_64-apple-darwin11' }}
-      run: |
-        mkdir -p contrib/depends/SDKs contrib/depends/sdk-sources
-        if [ ! -f contrib/depends/sdk-sources/MacOSX${{ matrix.toolchain.osx_sdk }}.sdk.tar.gz ]; then curl --location --fail https://bitcoincore.org/depends-sources/sdks/MacOSX${{ matrix.toolchain.osx_sdk }}.sdk.tar.gz -o contrib/depends/sdk-sources/MacOSX${{ matrix.toolchain.osx_sdk }}.sdk.tar.gz; fi
-        if [ -f contrib/depends/sdk-sources/MacOSX${{ matrix.toolchain.osx_sdk }}.sdk.tar.gz ]; then tar -C contrib/depends/SDKs -xf contrib/depends/sdk-sources/MacOSX${{ matrix.toolchain.osx_sdk }}.sdk.tar.gz; fi
-    - name: prepare w64-mingw32
-      if: ${{ matrix.toolchain.host == 'x86_64-w64-mingw32' || matrix.toolchain.host == 'i686-w64-mingw32' }}
-      run: |
-        sudo update-alternatives --set ${{ matrix.toolchain.host }}-g++ $(which ${{ matrix.toolchain.host }}-g++-posix)
-        sudo update-alternatives --set ${{ matrix.toolchain.host }}-gcc $(which ${{ matrix.toolchain.host }}-gcc-posix)
-    - name: build
-      run: |
-        ccache --max-size=150M
-        make depends target=${{ matrix.toolchain.host }} -j2
-    - uses: actions/upload-artifact@v2
-      if: ${{ matrix.toolchain.host == 'x86_64-w64-mingw32' || matrix.toolchain.host == 'x86_64-apple-darwin11' || matrix.toolchain.host == 'x86_64-unknown-linux-gnu' }}
-      with:
-        name: ${{ matrix.toolchain.name }}
-        path: |
-          /home/runner/work/monero/monero/build/${{ matrix.toolchain.host }}/release/bin/monero-wallet-cli*
-          /home/runner/work/monero/monero/build/${{ matrix.toolchain.host }}/release/bin/monerod*

.gitignore

@@ -23,7 +23,6 @@ cscope.po.out
 external/miniupnpc/Makefile
 miniupnpcstrings.h
 version/
-ClangBuildAnalyzerSession.txt
 # Created by https://www.gitignore.io
 
 ### C++ ###

.gitmodules

@@ -4,7 +4,8 @@
 	branch = monero
 [submodule "external/miniupnp"]
 	path = external/miniupnp
-	url = https://github.com/miniupnp/miniupnp
+	url = https://github.com/monero-project/miniupnp
+	branch = monero
 [submodule "external/rapidjson"]
 	path = external/rapidjson
 	url = https://github.com/Tencent/rapidjson

.travis.yml

@@ -0,0 +1,66 @@
+sudo: required
+dist: trusty
+os: linux
+language: minimal
+cache:
+  directories:
+  - contrib/depends/built
+  - contrib/depends/sdk-sources
+  - $HOME/.ccache
+env:
+  global:
+    - MAKEJOBS=-j3
+    - CCACHE_SIZE=100M
+    - CCACHE_TEMPDIR=/tmp/.ccache-temp
+    - CCACHE_COMPRESS=1
+    - CCACHE_DIR=$HOME/.ccache
+    - BASE_OUTDIR=$TRAVIS_BUILD_DIR/out
+    - SDK_URL=https://bitcoincore.org/depends-sources/sdks
+    - DOCKER_PACKAGES="build-essential libtool cmake autotools-dev automake pkg-config bsdmainutils curl git ca-certificates ccache"
+  matrix:
+# RISCV 64bit
+    - HOST=riscv64-linux-gnu PACKAGES="python3 gperf g++-riscv64-linux-gnu"
+# ARM v7
+    - HOST=arm-linux-gnueabihf PACKAGES="python3 gperf g++-arm-linux-gnueabihf"
+# ARM v8
+    - HOST=aarch64-linux-gnu PACKAGES="python3 gperf g++-aarch64-linux-gnu"
+# i686 Win
+    - HOST=i686-w64-mingw32 DEP_OPTS="NO_QT=1" PACKAGES="python3 g++-mingw-w64-i686 qttools5-dev-tools" MAKEJOBS=-j2
+# i686 Linux
+    - HOST=i686-pc-linux-gnu PACKAGES="gperf cmake g++-multilib python3-zmq"
+# Win64
+    - HOST=x86_64-w64-mingw32 DEP_OPTS="NO_QT=1" PACKAGES="cmake python3 g++-mingw-w64-x86-64 qttools5-dev-tools"
+# x86_64 Linux
+    - HOST=x86_64-unknown-linux-gnu PACKAGES="gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
+# Cross-Mac
+    - HOST=x86_64-apple-darwin11 PACKAGES="cmake imagemagick libcap-dev librsvg2-bin libz-dev libbz2-dev libtiff-tools python-dev python3-setuptools-git" OSX_SDK=10.11
+# x86_64 Freebsd
+    - HOST=x86_64-unknown-freebsd PACKAGES="clang-8 gperf cmake python3-zmq libdbus-1-dev libharfbuzz-dev"
+
+before_install:
+    - export PATH=$(echo $PATH | tr ':' "\n" | sed '/\/opt\/python/d' | tr "\n" ":" | sed "s|::|:|g")
+install:
+    - env | grep -E '^(CCACHE_|DISPLAY|CONFIG_SHELL)' | tee /tmp/env
+    - if [[ $HOST = *-mingw32 ]]; then DOCKER_ADMIN="--cap-add SYS_ADMIN"; fi
+    - DOCKER_ID=$(docker run $DOCKER_ADMIN -idt --mount type=bind,src=$TRAVIS_BUILD_DIR,dst=$TRAVIS_BUILD_DIR --mount type=bind,src=$CCACHE_DIR,dst=$CCACHE_DIR -w $TRAVIS_BUILD_DIR --env-file /tmp/env ubuntu:18.04)
+    - DOCKER_EXEC="docker exec $DOCKER_ID"
+    - if [ -n "$DPKG_ADD_ARCH" ]; then $DOCKER_EXEC dpkg --add-architecture "$DPKG_ADD_ARCH" ; fi
+    - travis_retry $DOCKER_EXEC apt-get update
+    - travis_retry $DOCKER_EXEC apt-get install --no-install-recommends --no-upgrade -qq $PACKAGES $DOCKER_PACKAGES
+before_script:
+    - mkdir -p contrib/depends/SDKs contrib/depends/sdk-sources
+    - if [ -n "$OSX_SDK" -a ! -f contrib/depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz ]; then curl --location --fail $SDK_URL/MacOSX${OSX_SDK}.sdk.tar.gz -o contrib/depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz; fi
+    - if [ -n "$OSX_SDK" -a -f contrib/depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz ]; then tar -C contrib/depends/SDKs -xf contrib/depends/sdk-sources/MacOSX${OSX_SDK}.sdk.tar.gz; fi
+    - if [[ $HOST = *-mingw32 ]]; then $DOCKER_EXEC bash -c "update-alternatives --set $HOST-g++ \$(which $HOST-g++-posix)"; fi
+    - if [[ $HOST = *-mingw32 ]]; then $DOCKER_EXEC bash -c "update-alternatives --set $HOST-gcc \$(which $HOST-gcc-posix)"; fi
+    - if [ -z "$NO_DEPENDS" ]; then $DOCKER_EXEC bash -c "make $MAKEJOBS -C contrib/depends HOST=$HOST $DEP_OPTS"; fi
+script:
+    - git submodule init && git submodule update
+    - export TRAVIS_COMMIT_LOG=`git log --format=fuller -1`
+    - OUTDIR=$BASE_OUTDIR/$TRAVIS_PULL_REQUEST/$TRAVIS_JOB_NUMBER-$HOST
+    - if [ -z "$NO_DEPENDS" ]; then $DOCKER_EXEC ccache --max-size=$CCACHE_SIZE; fi
+    - $DOCKER_EXEC bash -c "mkdir build && cd build && cmake -DCMAKE_TOOLCHAIN_FILE=$TRAVIS_BUILD_DIR/contrib/depends/$HOST/share/toolchain.cmake .. && make $MAKEJOBS"
+    - export LD_LIBRARY_PATH=$TRAVIS_BUILD_DIR/contrib/depends/$HOST/lib
+after_script:
+    - echo $TRAVIS_COMMIT_RANGE
+    - echo $TRAVIS_COMMIT_LOG

CMakeLists.txt

@@ -43,7 +43,7 @@ if (IOS)
     INCLUDE(CmakeLists_IOS.txt)
 endif()
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 2.8.7)
 message(STATUS "CMake version ${CMAKE_VERSION}")
 
 project(monero)
@@ -54,41 +54,6 @@ if (USE_CCACHE)
 else()
 	message(STATUS "ccache deselected")
 endif()
-option (USE_COMPILATION_TIME_PROFILER "Use compilation time profiler (for CLang >= 9 only)" OFF)
-if (USE_COMPILATION_TIME_PROFILER)
-	if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-		message(FATAL_ERROR "The flag USE_COMPILATION_TIME_PROFILER is meant to be set only for CLang compiler!")
-	endif()
-	add_compile_options("-ftime-trace")
-endif()
-
-if (${CMAKE_VERSION} VERSION_GREATER "3.0.0" AND CMAKE_MAKE_PROGRAM MATCHES "ninja")
-  set(MONERO_PARALLEL_COMPILE_JOBS "" CACHE STRING "The maximum number of concurrent compilation jobs.")
-  if (MONERO_PARALLEL_COMPILE_JOBS)
-    set_property(GLOBAL APPEND PROPERTY JOB_POOLS compile_job_pool=${MONERO_PARALLEL_COMPILE_JOBS})
-    set(CMAKE_JOB_POOL_COMPILE compile_job_pool)
-  endif ()
-
-  set(MONERO_PARALLEL_LINK_JOBS "" CACHE STRING "The maximum number of concurrent link jobs.")
-  if (MONERO_PARALLEL_LINK_JOBS)
-    set_property(GLOBAL APPEND PROPERTY JOB_POOLS link_job_pool=${MONERO_PARALLEL_LINK_JOBS})
-    set(CMAKE_JOB_POOL_LINK link_job_pool)
-  endif ()
-endif ()
-  
-option (USE_CLANG_TIDY_C   "Lint the code with clang-tidy - variant C"   OFF)
-option (USE_CLANG_TIDY_CXX "Lint the code with clang-tidy - variant C++" OFF)
-if (USE_CLANG_TIDY_C AND USE_CLANG_TIDY_CXX)
-	message(FATAL_ERROR "Enabling both USE_CLANG_TIDY_C and USE_CLANG_TIDY_CXX simultaneously crashes clang-tidy.")
-endif()
-if (USE_CLANG_TIDY_C OR USE_CLANG_TIDY_CXX)
-	include(SetClangTidy)
-endif()
-if (USE_CLANG_TIDY_C)
-	monero_clang_tidy("C")
-elseif (USE_CLANG_TIDY_CXX)
-	monero_clang_tidy("CXX")
-endif()
 
 # Job pool feature requires Ninja.
 if (${CMAKE_VERSION} VERSION_GREATER "3.0.0")
@@ -121,16 +86,18 @@ function (die msg)
 endfunction ()
 
 function (add_c_flag_if_supported flag var)
-  string(REPLACE "-" "_" supported ${flag}_c)
-  check_c_compiler_flag(${flag} ${supported})
+  set(TMP "-Werror ${flag}")
+  string(REGEX REPLACE "[- ]" "_" supported ${TMP}_c)
+  check_c_compiler_flag(${TMP} ${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})
+  set(TMP "-Werror ${flag}")
+  string(REGEX REPLACE "[- ]" "_" supported ${TMP}_cxx)
+  check_cxx_compiler_flag(${TMP} ${supported})
   if(${${supported}})
     set(${var} "${${var}} ${flag}" PARENT_SCOPE)
   endif()
@@ -161,47 +128,65 @@ function (add_definition_if_library_exists library function header var)
   endif()
 endfunction()
 
-option(RELINK_TARGETS "Relink targets, when just a dependant .so changed, but not its header?" OFF)
-function (monero_set_target_no_relink target)
-  if (RELINK_TARGETS MATCHES OFF)
-    # Will not relink the target, when just its dependant .so has changed, but not it's interface
-    set_target_properties("${target}" PROPERTIES LINK_DEPENDS_NO_SHARED true)
-  endif()
+# Function to forbid undefined symbols and also verify
+# 1) Test project with all types of libraries and without undefined symbols can compile successfully
+# 2) Test project with all types of libraries and undefined symbols can not compile successfully
+function(forbid_undefined_symbols)
+  unset(TMP)
+  # https://www.unix.com/man-page/linux/1/ld, --no-undefined, Report unresolved symbol references from regular object files.
+  add_linker_flag_if_supported(-Wl,--no-undefined TMP)
+  # https://www.unix.com/man-page/osx/1/ld/, -undefined, Specifies how undefined symbols are to be treated.
+  add_linker_flag_if_supported(-Wl,-undefined,error TMP)
+  string(APPEND CMAKE_SHARED_LINKER_FLAGS ${TMP})
+  string(APPEND CMAKE_MODULE_LINKER_FLAGS ${TMP})
+  set(CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS} PARENT_SCOPE)
+  set(CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS} PARENT_SCOPE)
+  set(TEST_PROJECT "${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CMakeTmp/test_project")
+  foreach(EXPECT IN ITEMS TRUE FALSE)
+    file(REMOVE_RECURSE "${TEST_PROJECT}")
+    file(MAKE_DIRECTORY "${TEST_PROJECT}")
+    file(WRITE "${TEST_PROJECT}/CMakeLists.txt"
+      [=[
+cmake_minimum_required(VERSION 3.1)
+project(test)
+option(EXPECT_SUCCESS "" ON)
+file(WRITE "${CMAKE_SOURCE_DIR}/incorrect_source.cpp" "void undefined_symbol(); void symbol() { undefined_symbol(); }")
+if (EXPECT_SUCCESS)
+  file(APPEND "${CMAKE_SOURCE_DIR}/incorrect_source.cpp" " void undefined_symbol() {}; ")
+endif()
+add_library(l0 SHARED incorrect_source.cpp)
+add_library(l1 MODULE incorrect_source.cpp)
+add_library(l2 STATIC incorrect_source.cpp)
+add_library(l3 OBJECT incorrect_source.cpp)
+]=]
+    )
+    try_compile(SUCCESS "${TEST_PROJECT}/build" "${TEST_PROJECT}" test
+      CMAKE_FLAGS
+      "-DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS}"
+      "-DCMAKE_MODULE_LINKER_FLAGS=${CMAKE_MODULE_LINKER_FLAGS}"
+      "-DEXPECT_SUCCESS=${EXPECT}"
+    )
+    if (NOT ${SUCCESS} STREQUAL ${EXPECT})
+      message(FATAL_ERROR "Undefined symbols test failure: expect(${EXPECT}), success(${SUCCESS})")
+    endif()
+    file(REMOVE_RECURSE "${TEST_PROJECT}")
+  endforeach()
 endfunction()
+if (NOT (CMAKE_SYSTEM_NAME MATCHES "kOpenBSD.*|OpenBSD.*"))
+  forbid_undefined_symbols()
+endif()
 
-option(STRIP_TARGETS "Strip symbols from targets?" OFF)
-function (monero_set_target_strip target)
-  if (STRIP_TARGETS)
-    set_target_properties("${target}" PROPERTIES LINK_FLAGS_RELEASE -s)
-    set_target_properties("${target}" PROPERTIES LINK_FLAGS_DEBUG -s)
-    # Stripping from Debug might make sense if you're low on disk space, but want to test if debug version builds properly.
-  endif()
-endfunction()
-
-function (monero_add_minimal_executable name)
-  source_group("${name}"
-    FILES
-      ${ARGN})
-
-  add_executable("${name}"
-    ${ARGN})
-    monero_set_target_no_relink("${name}")
-    monero_set_target_strip    ("${name}")
-endfunction()
-
-# Finds all headers in a directory and its subdirs, to be able to search for them and autosave in IDEs.
-#
-# Parameters:
-# - headers_found:    Output variable, which will hold the found headers
-# - module_root_dir:  The search path for the headers. Typically it will be the module's root dir, so "${CMAKE_CURRENT_SOURCE_DIR}" or a derivative of it.
-macro (monero_find_all_headers headers_found module_root_dir)
-  file(GLOB ${headers_found}
-           "${module_root_dir}/*.h*"    # h* will include hpps as well.
-           "${module_root_dir}/**/*.h*" # Any number of subdirs will be included.
-           "${module_root_dir}/*.inl"   # .inl is typically template code and is being treated as headers (it's being included).
-           "${module_root_dir}/**/*.inl"
-)
-endmacro()
+if (MINGW)
+  function(export_all_symbols)
+    unset(TMP)
+    add_linker_flag_if_supported(-Wl,--export-all-symbols TMP)
+    string(APPEND CMAKE_SHARED_LINKER_FLAGS ${TMP})
+    string(APPEND CMAKE_MODULE_LINKER_FLAGS ${TMP})
+    set(CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS} PARENT_SCOPE)
+    set(CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS} PARENT_SCOPE)
+  endfunction()
+  export_all_symbols()
+endif()
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
@@ -495,7 +480,7 @@ 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)
+elseif (ARM AND STATIC)
   set(DEFAULT_STACK_TRACE OFF)
   set(LIBUNWIND_LIBRARIES "")
 else()
@@ -531,7 +516,7 @@ if (CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
 endif ()
 
 if (APPLE AND NOT IOS)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=default -std=c++11")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=x86-64 -fvisibility=default -std=c++11")
   if (NOT OPENSSL_ROOT_DIR)
       EXECUTE_PROCESS(COMMAND brew --prefix openssl
         OUTPUT_VARIABLE OPENSSL_ROOT_DIR
@@ -549,6 +534,10 @@ if(STATIC AND NOT IOS)
   endif()
 endif()
 
+if (WIN32)
+  list(APPEND OPENSSL_LIBRARIES ws2_32 crypt32)
+endif()
+
 find_package(HIDAPI)
 
 add_definition_if_library_exists(c memset_s "string.h" HAVE_MEMSET_S)
@@ -560,44 +549,6 @@ add_definitions(-DAUTO_INITIALIZE_EASYLOGGINGPP)
 set(MONERO_GENERATED_HEADERS_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated_include")
 include_directories(${MONERO_GENERATED_HEADERS_DIR})
 
-option(COVERAGE "Enable profiling for test coverage report" OFF)
-if(COVERAGE)
-    message(STATUS "Building with profiling for test coverage report")
-endif()
-macro (monero_enable_coverage)
-  if(COVERAGE)
-    foreach(COV_FLAG -fprofile-arcs -ftest-coverage --coverage)
-      set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   ${COV_FLAG}")
-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COV_FLAG}")
-    endforeach()
-  endif()
-endmacro()
-
-function (monero_add_library name)
-    monero_add_library_with_deps(NAME "${name}" SOURCES ${ARGN})
-endfunction()
-
-function (monero_add_library_with_deps)
-  cmake_parse_arguments(MONERO_ADD_LIBRARY "" "NAME" "DEPENDS;SOURCES" ${ARGN})
-  source_group("${MONERO_ADD_LIBRARY_NAME}" FILES ${MONERO_ADD_LIBRARY_SOURCES})
-
-  # Define a ("virtual") object library and an actual library that links those
-  # objects together. The virtual libraries can be arbitrarily combined to link
-  # any subset of objects into one library archive. This is used for releasing
-  # libwallet, which combines multiple components.
-  set(objlib obj_${MONERO_ADD_LIBRARY_NAME})
-  add_library(${objlib} OBJECT ${MONERO_ADD_LIBRARY_SOURCES})
-  add_library("${MONERO_ADD_LIBRARY_NAME}" $<TARGET_OBJECTS:${objlib}>)
-  monero_set_target_no_relink("${MONERO_ADD_LIBRARY_NAME}")
-  monero_set_target_strip    ("${MONERO_ADD_LIBRARY_NAME}")
-  if (MONERO_ADD_LIBRARY_DEPENDS)
-    add_dependencies(${objlib} ${MONERO_ADD_LIBRARY_DEPENDS})
-  endif()
-  set_property(TARGET "${MONERO_ADD_LIBRARY_NAME}" PROPERTY FOLDER "libs")
-  target_compile_definitions(${objlib}
-    PRIVATE $<TARGET_PROPERTY:${MONERO_ADD_LIBRARY_NAME},INTERFACE_COMPILE_DEFINITIONS>)
-endfunction ()
-
 # Generate header for embedded translations
 # Generate header for embedded translations, use target toolchain if depends, otherwise use the
 # lrelease and lupdate binaries from the host
@@ -607,7 +558,7 @@ ExternalProject_Add(generate_translations_header
   BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/translations"
   STAMP_DIR ${LRELEASE_PATH}
   CMAKE_ARGS -DLRELEASE_PATH=${LRELEASE_PATH}
-  INSTALL_COMMAND ${CMAKE_COMMAND} -E echo "")
+  INSTALL_COMMAND cmake -E echo "")
 include_directories("${CMAKE_CURRENT_BINARY_DIR}/translations")
 add_subdirectory(external)
 
@@ -725,8 +676,8 @@ else()
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH_FLAG}")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARCH_FLAG}")
 
-  set(WARNINGS "-Wall -Wextra -Wpointer-arith -Wundef -Wvla -Wwrite-strings -Wno-error=extra -Wno-error=deprecated-declarations -Wno-unused-parameter -Wno-error=unused-variable -Wno-error=undef -Wno-error=uninitialized")
-  if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+  set(WARNINGS "-Wall -Wextra -Wpointer-arith -Wundef -Wvla -Wwrite-strings -Wno-error=extra -Wno-error=deprecated-declarations -Wno-unused-parameter -Wno-unused-variable -Wno-error=unused-variable -Wno-error=undef -Wno-error=uninitialized")
+  if(CMAKE_C_COMPILER_ID STREQUAL "Clang")
     if(ARM)
       set(WARNINGS "${WARNINGS} -Wno-error=inline-asm")
     endif()
@@ -761,7 +712,13 @@ else()
     set(STATIC_ASSERT_CPP_FLAG "-Dstatic_assert=_Static_assert")
   endif()
 
-  monero_enable_coverage()
+  option(COVERAGE "Enable profiling for test coverage report" 0)
+
+  if(COVERAGE)
+    message(STATUS "Building with profiling for test coverage report")
+    set(COVERAGE_FLAGS "-fprofile-arcs -ftest-coverage --coverage")
+  endif()
+
   # 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.
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-strict-aliasing")
@@ -804,16 +761,10 @@ else()
   endif()
 
   # linker
-  if (NOT SANITIZE AND NOT OSSFUZZ AND NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND (CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1 OR NOT STATIC))))
+  if (NOT SANITIZE AND NOT OSSFUZZ AND NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1)))
     # PIE executables randomly crash at startup with ASAN
     # Windows binaries die on startup with PIE when compiled with GCC <9.x
-    # Windows dynamically-linked binaries die on startup with PIE regardless of GCC version
-    if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-      # Clang does not support -pie flag
-      add_linker_flag_if_supported("-Wl,-pie" LD_SECURITY_FLAGS)
-    else()
-      add_linker_flag_if_supported("-pie" LD_SECURITY_FLAGS)
-    endif()
+    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)
@@ -839,19 +790,12 @@ else()
     add_linker_flag_if_supported(-Wl,--high-entropy-va LD_SECURITY_FLAGS)
   endif()
 
-  # Warnings, that when ignored are so severe, that they can segfault or even UB any application.
-  # Treat them as errors.
-  add_c_flag_if_supported(  -Werror=switch      C_SECURITY_FLAGS)
-  add_cxx_flag_if_supported(-Werror=switch      CXX_SECURITY_FLAGS)
-  add_c_flag_if_supported(  -Werror=return-type C_SECURITY_FLAGS)
-  add_cxx_flag_if_supported(-Werror=return-type CXX_SECURITY_FLAGS)
-
   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}")
 
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_FLAG} ${WARNINGS} ${C_WARNINGS} ${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} ${PIC_FLAG} ${CXX_SECURITY_FLAGS}")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -D_GNU_SOURCE ${MINGW_FLAG} ${STATIC_ASSERT_FLAG} ${WARNINGS} ${C_WARNINGS} ${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} ${COVERAGE_FLAGS} ${PIC_FLAG} ${CXX_SECURITY_FLAGS}")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LD_SECURITY_FLAGS} ${LD_BACKCOMPAT_FLAGS}")
 
   # With GCC 6.1.1 the compiled binary malfunctions due to aliasing. Until that
@@ -969,7 +913,7 @@ else()
   endif()
   set(USE_LTO ${USE_LTO_DEFAULT} CACHE BOOL "Use Link-Time Optimization (Release mode only)")
 
-  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     # There is a clang bug that does not allow to compile code that uses AES-NI intrinsics if -flto is enabled, so explicitly disable
     set(USE_LTO false)
   endif()
@@ -1116,7 +1060,7 @@ if(ANDROID)
   set(ATOMIC libatomic.a)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=user-defined-warnings")
 endif()
-if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS AND NOT FREEBSD)
+if(CMAKE_C_COMPILER_ID STREQUAL "Clang" AND ARCH_WIDTH EQUAL "32" AND NOT IOS AND NOT FREEBSD)
   find_library(ATOMIC atomic)
   if (ATOMIC_FOUND)
     list(APPEND EXTRA_LIBRARIES ${ATOMIC})

Dockerfile

@@ -55,8 +55,8 @@ RUN set -ex \
 ENV BOOST_ROOT /usr/local/boost_${BOOST_VERSION}
 
 # OpenSSL
-ARG OPENSSL_VERSION=1.1.1i
-ARG OPENSSL_HASH=e8be6a35fe41d10603c3cc635e93289ed00bf34b79671a3a4de64fcee00d5242
+ARG OPENSSL_VERSION=1.1.1g
+ARG OPENSSL_HASH=ddb04774f1e32f0c49751e21b67216ac87852ceb056b75209af2443400636d46
 RUN set -ex \
     && curl -s -O https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz \
     && echo "${OPENSSL_HASH}  openssl-${OPENSSL_VERSION}.tar.gz" | sha256sum -c \

Doxyfile

@@ -68,7 +68,7 @@ OUTPUT_DIRECTORY       = doc
 # performance problems for the file system.
 # The default value is: NO.
 
-CREATE_SUBDIRS         = YES
+CREATE_SUBDIRS         = NO
 
 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
 # characters to appear in the names of generated files. If set to NO, non-ASCII
@@ -754,7 +754,7 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = .
+INPUT                  = src
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -1552,7 +1552,7 @@ EXTRA_SEARCH_MAPPINGS  =
 # If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
 # The default value is: YES.
 
-GENERATE_LATEX         = NO
+GENERATE_LATEX         = YES
 
 # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of

LEVIN_PROTOCOL.md

@@ -10,7 +10,7 @@ extensibility.
 One of the goals of this document is to clearly indicate what is being sent
 "on the wire" to identify metadata that could de-anonymize users over I2P/Tor.
 These issues will be addressed as they are found. See `ANONMITY_NETWORKS.md` in
-the `docs` folder for any outstanding issues.
+the top-level folder for any outstanding issues.
 
 > This document does not currently list all data being sent by the monero
 > protocol, that portion is a work-in-progress. Please take the time to do it

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2021, The Monero Project
+Copyright (c) 2014-2020, The Monero Project
 
 All rights reserved.
 

README.md

@@ -1,6 +1,6 @@
 # ~~Mo~~Wownero -  Such privacy! Many coins! Wow! 🐕
 
-Copyright (c) 2014-2021 The Monero Project.   
+Copyright (c) 2014-2023 The Monero Project.   
 Portions Copyright (c) 2012-2013 The Cryptonote developers.
 
 ## Resources
@@ -16,19 +16,21 @@ Portions Copyright (c) 2012-2013 The Cryptonote developers.
 - Discord: [discord.gg/ykZyAzJhDK](https://discord.com/invite/ykZyAzJhDK)
 - Telegram: [t.me/wownero](https://t.me/wownero)
 - Wowlet Desktop Wallet: [git.wownero.com/wowlet/wowlet](https://git.wownero.com/wowlet/wowlet/releases)
-- WOW Stash Web Wallet: [wowstash.app](https://wowstash.app)
+- Stack Wallet iOS & Android Mobile Wallet: [stackwallet.com](https://stackwallet.com)
+- Wonerujo Android Mobile Wallet: [google store](https://play.google.com/store/apps/details?id=com.m2049r.wowwallet)
 - Public Node Status: [monero.fail](https://monero.fail/?crypto=wownero)
-- Map of Nodes: [wownero.fyi](https://wownero.fyi)
 - Wownero Memes: [suchwow.xyz](https://suchwow.xyz/posts/top)
-- XMR/WOW Swap: [nero Swap](https://neroswap.com)
-- Mining Pools: [miningpoolstats.stream](https://miningpoolstats.stream/wownero)
 - Market Info: [coinmarketcap.com](https://coinmarketcap.com/currencies/wownero), [coingecko.com](https://www.coingecko.com/en/coins/wownero/usd)
 
+## Exchanges
+
+- [AltQuick](https://altquick.com/market/Wownero)
+- [Majestic Bank](https://majesticbank.sc)
+- [TradeOgre](https://tradeogre.com/exchange/BTC-WOW)
+
 ### Blockchain Explorers
+
 - https://explore.wownero.com
-- http://wow5eqtzqvsg5jctqzg5g7uk3u62sfqiacj5x6lo4by7bvnj6jkvubyd.onion
-- https://wownero.club
-- https://explorer.wownero.fyi
 
 ## Introduction
 
@@ -39,11 +41,11 @@ Wownero is a privacy-centric memecoin that was fairly launched on April 1, 2018
 Wownero is a 100% community-sponsored endeavor. Supporting services are also graciously provided by sponsors:
 
 [<img src="https://git.wownero.com/wownero/meta/raw/branch/master/images/macstadium.png"
-      alt="MacStadium"
-      height="100">](https://www.macstadium.com)
+alt="MacStadium"
+height="100">](https://www.macstadium.com)
 [<img src="https://git.wownero.com/wownero/meta/raw/branch/master/images/jetbrains.png"
-      alt="JetBrains"
-      height="100">](https://www.jetbrains.com)
+alt="JetBrains"
+height="100">](https://www.jetbrains.com)
 
 Developers are volunteers doing this mostly for shits and giggles. If you would like to support our shenanigans and stimulant addictions, please consider donating to [WFS proposals](https://funding.wownero.com/proposals) or the dev slush fund.
 
@@ -67,31 +69,32 @@ Wownero is hosted by Open Collective Europe, a Brussels-based non-profit that ho
 
 ## Release staging and Contributing
 
-**Anyone is welcome to contribute to Wownero's codebase!** 
+**Anyone is welcome to contribute to Wownero's codebase!**
 
 If you have a fix or code change, feel free to submit it as a pull request. Ahead of a scheduled software upgrade, a development branch will be created with the new release version tag. Pull requests that address bugs should be made to Master. Pull requests that require review and testing (generally, optimizations and new features) should be made to the development branch. All pull requests will be considered safe until the US dollar valuation of 1 Wownero equals $1000. After this valuation has been reached, more research will be needed to introduce experimental cryptography and/or code into the codebase.
 
-Things to Do, Work in Progress, and Help Wanted tasks are tracked in the [Meta](https://git.wownero.com/wownero/meta/issues) repo. 
+Things to Do, Work in Progress, and Help Wanted tasks are tracked in the [Meta](https://git.wownero.com/wownero/meta/issues) repo.
 
-Join `#wownero-dev` on IRC OFTC to participate in development conversation.
+Join `#wownero` on IRC OFTC to participate in development conversation.
 
-## Scheduled software upgrades
+## Scheduled software/network upgrades
 
 Wownero uses a fixed-schedule software upgrade (hard fork) mechanism to implement new features. This means that users of Wownero (end users and service providers) should run current versions and upgrade their software on a regular schedule. 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 Wownero software version. Below is the historical schedule and the projected schedule for the next upgrade.
-Dates are provided in the format YYYY-MM-DD. 
+Dates are provided in the format YYYY-MM-DD.
 
 | Software upgrade block height | Date       | Release Name | Minimum Wownero version | Recommended Wownero version | Details                                                                            |  
-| ------------------------------ | -----------| ----------------- | ---------------------- | -------------------------- | ---------------------------------------------------------------------------------- |
-| 1                              | 2018-04-01 | Awesome Akita                | v0.1.0.0               | v0.1.0.0                  | Cryptonight variant 1, ringsize >= 8, sorted inputs
-| 69,69                           | 2018-04-24 | Busty Brazzers                | v0.2.0.0               | v0.2.0.0                  | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
-| 53,666                          | 2018-10-06 | Cool Cage                | v0.3.0.0               | v0.3.1.3                  | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
-| 63,469                          | 2018-11-11 | Dank Doge               | v0.4.0.0               | v0.4.0.0                  | LWMA v4
-| 81,769                          | 2019-02-19 | Erotic EggplantEmoji    | v0.5.0.0               | v0.5.0.2                  | Cryptonight/wow, LWMA v1 with N=144, Updated Bulletproofs, Fee Per Byte, Auto-churn
-| 114,969                          | 2019-06-14 | F For Fappening    | v0.6.1.0               | v0.6.1.2                  | RandomWOW, new block weight algorithm, slightly more efficient RingCT format
-| 160,777                          | 2019-11-20 | Gaping Goatse    | v0.7.0.0               | v0.7.1.0                  | Only allow >= 2 outputs, change to the block median used to calculate penalty, rct sigs in coinbase forbidden, 4 unlock time as protocol rule
-| -                         | 2020-06-28 | Hallucinogenic Hypnotoad  | v0.8.0.0               | v0.8.0.2                  | Dandelion++ support
-| 253,999                         | 2020-10-09 | Illiterate Illuminati  | v0.9.0.0               | v0.9.3.3                  | Dynamic coinbase unlock (up to 1 mo.), Deterministic unlock times, Enforce maximum coinbase amount, show_qr_code wallet command, CLSAG
-| 331,170                         | 2021-07-04 | Junkie Jeff  | v0.10.0.0               |  v0.10.0.1                  | Bulletproofs+, Miner Block Header Signing, Vote by Block, Change coinbase unlock time to 1 day, Reset difficulty and switch back to Monero's difficulty algorithm
+|-------------------------------|------------| ----------------- |-------------------------|-----------------------------| ---------------------------------------------------------------------------------- |
+| 1                             | 2018-04-01 | Awesome Akita                | v0.1.0.0                | v0.1.0.0                    | Cryptonight variant 1, ringsize >= 8, sorted inputs
+| 69,69                         | 2018-04-24 | Busty Brazzers                | v0.2.0.0                | v0.2.0.0                    | Bulletproofs, LWMA difficulty algorithm, ringsize >= 10, reduce unlock to 4
+| 53,666                        | 2018-10-06 | Cool Cage                | v0.3.0.0                | v0.3.1.3                    | Cryptonight variant 2, LWMA v2, ringsize = 22, MMS
+| 63,469                        | 2018-11-11 | Dank Doge               | v0.4.0.0                | v0.4.0.0                    | LWMA v4
+| 81,769                        | 2019-02-19 | Erotic EggplantEmoji    | v0.5.0.0                | v0.5.0.2                    | Cryptonight/wow, LWMA v1 with N=144, Updated Bulletproofs, Fee Per Byte, Auto-churn
+| 114,969                       | 2019-06-14 | F For Fappening    | v0.6.1.0                | v0.6.1.2                    | RandomWOW, new block weight algorithm, slightly more efficient RingCT format
+| 160,777                       | 2019-11-20 | Gaping Goatse    | v0.7.0.0                | v0.7.1.0                    | Only allow >= 2 outputs, change to the block median used to calculate penalty, rct sigs in coinbase forbidden, 4 unlock time as protocol rule
+| -                             | 2020-06-28 | Hallucinogenic Hypnotoad  | v0.8.0.0                | v0.8.0.2                    | Dandelion++ support
+| 253,999                       | 2020-10-09 | Illiterate Illuminati  | v0.9.0.0                | v0.9.3.3                    | Dynamic coinbase unlock (up to 1 mo.), Deterministic unlock times, Enforce maximum coinbase amount, show_qr_code wallet command, CLSAG
+| 331,170                       | 2021-07-04 | Junkie Jeff  | v0.10.0.0               | v0.10.2.0                   | Bulletproofs+, Miner Block Header Signing, Vote by Block, Change coinbase unlock time to 1 day, Reset difficulty and switch back to Monero's difficulty algorithm
+| XXX,XXX                       | 2023-XX-XX | Kunty Karen  | v0.11.0.0               | v0.11.0.0                   | View tags, fee changes, adjusted dynamic block weight algorithm, multisig security fixes, RPC broadcast node donation sub-address 
 
 X's indicate that these details have not been determined as of commit date.
 
@@ -117,13 +120,6 @@ Packages are available for
 
         nix-shell -p wownero
 
-* Ubuntu 18.04/Ubuntu 16.04/Debian 9/Debian 8 (amd64)
-
-        sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 8BC34ABB48E565F0
-        sudo add-apt-repository "deb http://ppa.wownero.com/ bionic main"
-        sudo apt-get update
-        sudo apt-get install wownero
-
 Packaging for your favorite distribution would be a welcome contribution!
 
 **DISCLAIMER: These packages are not part of this repository, and as such, do not go through the same review process to ensure their trustworthiness and security.**
@@ -170,10 +166,10 @@ To run in background:
 
 To run as a systemd service, copy
 [wownerod.service](utils/systemd/wownerod.service) to `/etc/systemd/system/` and
-[wownerod.conf](utils/conf/wownerod.conf) to `/etc/`. The [example
+[wownerod.conf](wownerod.conf) to `/etc/`. The [example
 service](utils/systemd/wownerod.service) assumes that the user `wownero` exists
 and its home is the data directory specified in the [example
-config](utils/conf/wownerod.conf).
+config](wownerod.conf).
 
 Once node is synced to network, run the CLI wallet by entering:
 
@@ -183,26 +179,37 @@ Type `help` in CLI wallet to see standard commands (for advanced options, type `
 
 ## Tor Anonymity Network
 
-* Install [Tor Browser](https://www.torproject.org/download/)
-* Open `torrc` file in a text editor ([installation directory]/Browser/TorBrowser/Data/Tor/torrc) and add hidden service information as follows:
+### Ubuntu
 
+* `sudo apt-get update && sudo apt-get install tor -y`
+* `sudo nano /etc/tor/torrc`
+
+add the following:
 ```
-HiddenServiceDir [installation directory]/Browser/TorBrowser/Data/Tor/wow_node
+HiddenServiceDir /var/lib/tor/wownero/
+HiddenServicePort 34569 127.0.0.1:34569
+HiddenServicePort 34566 127.0.0.1:34566
 HiddenServiceVersion 3
-HiddenServicePort 44568 127.0.0.1:44568
 ```
-* Save `torrc` file and restart Tor Browser (keep open)
-* Change directory to the `wow_node` folder, open `hostname` file, and copy your node's ".onion" address
-* Start wownerod with the following parameters:
+save and close nano
+
+* `sudo /etc/init.d/tor restart && sudo systemctl enable tor`
+* copy [wownerod.conf](https://git.wownero.com/wownero/wownero/raw/branch/master/wownerod.conf) file and save it in same directory as `wownerod`.
+* start wownerod like this:
 
 ```
-./wownerod --tx-proxy tor,127.0.0.1:9150,10 --add-peer hdps3qwnusz64r7odvynmae6myc2uyvrsc2emap6636qeuzll72eouid.onion:44568 --anonymous-inbound YOUR_NODE_ADDRESS.onion:44568,127.0.0.1:44568,25
+./wownerod --config-file=wownerod.conf
 ```
 
+* `sudo cat /var/lib/tor/wownero/hostname`
+  copy your onion address and share node with others [here](https://monero.fail/?crypto=wownero) and [here](https://forum.wownero.com/t/wownero-tor-onion-sites/623)
+
+To share your node over p2p, uncomment first line of wownerod.conf and add your onion address.
+
+More information on running Tor and i2p nodes is available [here](https://forum.wownero.com/t/how-to-setup-a-full-node-with-tor-i2p/588)
+
 ### Access remote Tor node from CLI wallet
 
 ```
-./wownero-wallet-cli --proxy 127.0.0.1:9150 --daemon-address wow7dhbgiljnkspkzpjyy66auegbrye2ptfv4gucgbhireg5rrjza5ad.onion:34568
-```
-
-Use port `9050` instead of `9150` if you installed Tor as a standalone daemon. For more information, check out [ANONYMITY_NETWORKS](https://git.wownero.com/wownero/wownero/src/branch/master/ANONYMITY_NETWORKS.md).
+./wownero-wallet-cli --proxy 127.0.0.1:9050 --daemon-address iy6ry6uudpzvbd72zsipepukp6nsazjdu72n52vg3isfnxqn342flzad.onion:34568
+```

cmake/CheckLinkerFlag.cmake

@@ -15,7 +15,6 @@ macro(CHECK_LINKER_FLAG flag VARIABLE)
       ${_cle_source}
       COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${flag}
       CMAKE_FLAGS
-      "-DCMAKE_EXE_LINKER_FLAGS=${flag}"
       OUTPUT_VARIABLE OUTPUT)
     unset(_cle_source)
     set(CMAKE_C_FLAGS ${saved_CMAKE_C_FLAGS})

cmake/FindCcache.cmake

@@ -44,13 +44,13 @@ if (CCACHE_FOUND)
 	# Try to compile a test program with ccache, in order to verify if it really works. (needed on exotic setups)
 	set(TEST_PROJECT "${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CMakeTmp")
 	file(WRITE "${TEST_PROJECT}/CMakeLists.txt" [=[
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.1)
 project(test)
 option (CCACHE "")
 file(WRITE "${CMAKE_SOURCE_DIR}/test.cpp" "int main() { return 0; }")
 set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE}")
 set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK    "${CCACHE}")
-add_executable(test test.cpp)
+add_executable(main test.cpp)
 ]=])
 	try_compile(RET "${TEST_PROJECT}/build" "${TEST_PROJECT}" "test" CMAKE_FLAGS -DCCACHE="${CCACHE_FOUND}")
 	unset(TEST_PROJECT)

cmake/SetClangTidy.cmake

@@ -1,72 +0,0 @@
-# Copyright (c) 2014-2020, 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.
-
-# https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_CLANG_TIDY.html
-# This module sets the following variables:
-# CMAKE_C_CLANG_TIDY
-# CMAKE_CXX_CLANG_TIDY
-# when clang-tidy is found in PATH. Afterwards, the code is being linted by the tool.
-# The checks to be enabled can be manipulated with the variable MONERO_CLANG_TIDY_CHECKS
-
-macro (monero_clang_tidy LANGUAGE)
-	set(TOOL_NAME "clang-tidy")
-	set(MONERO_CLANG_TIDY_MIN_VERSION "3.6")
-	if(${CMAKE_VERSION} VERSION_LESS "${MONERO_CLANG_TIDY_MIN_VERSION}")
-		message(FATAL_ERROR "Sorry, ${TOOL_NAME} is available for CMake from version ${MONERO_CLANG_TIDY_MIN_VERSION}")
-	else()
-		message(STATUS "Trying to enable ${TOOL_NAME}")
-		find_program(MONERO_CLANG_BIN ${TOOL_NAME})
-		if(NOT MONERO_CLANG_BIN)
-			message(FATAL_ERROR "${TOOL_NAME} not found! Try running: sudo apt install ${TOOL_NAME}")
-		else()
-			message(STATUS "Found ${MONERO_CLANG_BIN}")
-			set(MONERO_CLANG_TIDY_CHECKS
-			    -header-filter=.; 	# By default the headers are excluded. This line enables them.
-			    -checks=*; 		# Currently enabling all checks
-			    # An example of selectively enabling checks:
-			    #-checks=bugprone-*,cppcoreguidelines-avoid-goto # Have to be in one line :(
-			)
-			# Current list of checks is avaibale under:
-			# https://clang.llvm.org/extra/clang-tidy/
-			if (${LANGUAGE} STREQUAL "C")
-				set(CMAKE_C_CLANG_TIDY
-					${MONERO_CLANG_BIN}; # Mind the semicolon
-					${MONERO_CLANG_TIDY_CHECKS}
-				)
-			elseif (${LANGUAGE} STREQUAL "CXX")
-				set(CMAKE_CXX_CLANG_TIDY
-					${MONERO_CLANG_BIN}; # Mind the semicolon
-					${MONERO_CLANG_TIDY_CHECKS}
-				)
-			else()
-				message(FATAL_ERROR "${TOOL_NAME}: Unsupported language: ${LANGUAGE}")
-			endif()
-		endif()
-	endif()
-endmacro()
-

contrib/CMakeLists.txt

@@ -26,6 +26,5 @@
 # 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.
 
-monero_enable_coverage()
 add_subdirectory(epee)
 

contrib/brew/Brewfile

@@ -27,7 +27,6 @@ brew "miniupnpc"
 brew "readline"
 brew "ldns"
 brew "expat"
-brew "ccache"
 brew "doxygen"
 brew "graphviz"
 brew "libunwind-headers"

contrib/depends/Makefile

@@ -3,15 +3,15 @@
 SOURCES_PATH ?= $(BASEDIR)/sources
 BASE_CACHE ?= $(BASEDIR)/built
 SDK_PATH ?= $(BASEDIR)/SDKs
-FALLBACK_DOWNLOAD_PATH ?= https://bitcoincore.org/depends-sources
+FALLBACK_DOWNLOAD_PATH ?= https://downloads.getmonero.org/depends-sources
 
 BUILD = $(shell ./config.guess)
 HOST ?= $(BUILD)
 PATCHES_PATH = $(BASEDIR)/patches
 BASEDIR = $(CURDIR)
 HASH_LENGTH:=11
-DOWNLOAD_CONNECT_TIMEOUT:=30
-DOWNLOAD_RETRIES:=5
+DOWNLOAD_CONNECT_TIMEOUT:=10
+DOWNLOAD_RETRIES:=3
 HOST_ID_SALT ?= salt
 BUILD_ID_SALT ?= salt
 

contrib/depends/funcs.mk

@@ -32,7 +32,7 @@ endef
 define fetch_file
     ( test -f $$($(1)_source_dir)/$(4) || \
     ( $(call fetch_file_inner,$(1),$(2),$(3),$(4),$(5)) || \
-      $(call fetch_file_inner,$(1),$(FALLBACK_DOWNLOAD_PATH),$(3),$(4),$(5))))
+      $(call fetch_file_inner,$(1),$(FALLBACK_DOWNLOAD_PATH),$(4),$(4),$(5))))
 endef
 
 define int_get_build_recipe_hash

contrib/depends/packages/eudev.mk

@@ -1,7 +1,8 @@
 package=eudev
 $(package)_version=v3.2.6
 $(package)_download_path=https://github.com/gentoo/eudev/archive/
-$(package)_file_name=$($(package)_version).tar.gz
+$(package)_download_file=$($(package)_version).tar.gz
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=a96ecb8637667897b8bd4dee4c22c7c5f08b327be45186e912ce6bc768385852
 
 define $(package)_set_vars

contrib/depends/packages/gtest.mk

@@ -1,7 +1,8 @@
 package=gtest
 $(package)_version=1.8.1
 $(package)_download_path=https://github.com/google/googletest/archive/
-$(package)_file_name=release-$($(package)_version).tar.gz
+$(package)_download_file=release-$($(package)_version).tar.gz
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=9bf1fe5182a604b4135edc1a425ae356c9ad15e9b23f9f12a02e80184c3a249c
 $(package)_cxxflags=-std=c++11
 $(package)_cxxflags_linux=-fPIC

contrib/depends/packages/native_cctools.mk

@@ -1,7 +1,8 @@
 package=native_cctools
 $(package)_version=807d6fd1be5d2224872e381870c0a75387fe05e6
 $(package)_download_path=https://github.com/theuni/cctools-port/archive
-$(package)_file_name=$($(package)_version).tar.gz
+$(package)_download_file=$($(package)_version).tar.gz
+$(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=a09c9ba4684670a0375e42d9d67e7f12c1f62581a27f28f7c825d6d7032ccc6a
 $(package)_build_subdir=cctools
 $(package)_clang_version=3.7.1

contrib/epee/demo/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 2.8)
 set(Boost_USE_MULTITHREADED ON)
 #set(Boost_DEBUG 1) 
 find_package(Boost COMPONENTS system filesystem thread date_time chrono regex )

contrib/epee/include/byte_slice.h

@@ -112,7 +112,7 @@ namespace epee
     explicit byte_slice(std::string&& buffer);
 
     //! Convert `stream` into a slice with zero allocations.
-    explicit byte_slice(byte_stream&& stream, bool shrink = true);
+    explicit byte_slice(byte_stream&& stream) noexcept;
 
     byte_slice(byte_slice&& source) noexcept;
     ~byte_slice() noexcept = default;

contrib/epee/include/byte_stream.h

@@ -58,6 +58,7 @@ namespace epee
     byte_buffer buffer_;        //! Beginning of buffer
     std::uint8_t* next_write_;  //! Current write position
     const std::uint8_t* end_;   //! End of buffer
+    std::size_t increase_size_; //! Minimum buffer size increase
 
     //! \post `requested <= available()`
     void overflow(const std::size_t requested);
@@ -74,17 +75,29 @@ namespace epee
     using char_type = std::uint8_t;
     using Ch = char_type;
 
+    //! \return Default minimum size increase on buffer overflow
+    static constexpr std::size_t default_increase() noexcept { return 4096; }
+
     //! Increase internal buffer by at least `byte_stream_increase` bytes.
     byte_stream() noexcept
+      : byte_stream(default_increase())
+    {}
+
+    //! Increase internal buffer by at least `increase` bytes.
+    explicit byte_stream(const std::size_t increase) noexcept
       : buffer_(nullptr),
         next_write_(nullptr),
-        end_(nullptr)
+        end_(nullptr),
+        increase_size_(increase)
     {}
 
     byte_stream(byte_stream&& rhs) noexcept;
     ~byte_stream() noexcept = default;
     byte_stream& operator=(byte_stream&& rhs) noexcept;
 
+    //! \return The minimum increase size on buffer overflow
+    std::size_t increase_size() const noexcept { return increase_size_; }
+
     const std::uint8_t* data() const noexcept { return buffer_.get(); }
     std::uint8_t* tellp() const noexcept { return next_write_; }
     std::size_t available() const noexcept { return end_ - next_write_; }

contrib/epee/include/file_io_utils.h

@@ -24,23 +24,211 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+
 #ifndef _FILE_IO_UTILS_H_
 #define _FILE_IO_UTILS_H_
 
-#include <string>
-#include <ctime>
+#include <fstream>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#ifdef WIN32
+#include <windows.h>
+#include "string_tools.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
 {
 namespace file_io_utils
 {
-    bool is_file_exist(const std::string& path);
-    bool save_string_to_file(const std::string& path_to_file, const std::string& str);
-    bool get_file_time(const std::string& path_to_file, time_t& ft);
-    bool set_file_time(const std::string& path_to_file, const time_t& ft);
-    bool load_file_to_string(const std::string& path_to_file, std::string& target_str, size_t max_size = 1000000000);
-    bool append_string_to_file(const std::string& path_to_file, const std::string& str);
-    bool get_file_size(const std::string& path_to_file, uint64_t &size);
+	inline 
+		bool is_file_exist(const std::string& path)
+	{
+		boost::filesystem::path p(path);
+		return boost::filesystem::exists(p);
+	}
+
+	inline
+		bool save_string_to_file(const std::string& path_to_file, const std::string& str)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
+			fstream << str;
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+#endif
+	}
+
+	inline
+	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);
+		if(!ec)
+			return true;
+		else
+			return false;
+	}
+
+	inline
+		bool set_file_time(const std::string& path_to_file, const time_t& ft)
+	{
+		boost::system::error_code ec;
+		boost::filesystem::last_write_time(boost::filesystem::path(path_to_file), ft, ec);
+		if(!ec)
+			return true;
+		else
+			return false;
+	}
+
+
+	inline
+		bool load_file_to_string(const std::string& path_to_file, std::string& target_str, size_t max_size = 1000000000)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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) || (uint64_t)file_size > (uint64_t)max_size) {
+                    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;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::in | std::ios::ate);
+
+			std::ifstream::pos_type file_size = fstream.tellg();
+			
+			if((uint64_t)file_size > (uint64_t)max_size) // ensure a large domain for comparison, and negative -> too large
+				return false;//don't go crazy
+			size_t file_size_t = static_cast<size_t>(file_size);
+
+			target_str.resize(file_size_t);
+
+			fstream.seekg (0, std::ios::beg);
+			fstream.read((char*)target_str.data(), target_str.size());
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			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;
+			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+			fstream.open(path_to_file.c_str(), std::ios_base::binary | std::ios_base::out | std::ios_base::app);
+			fstream << str;
+			fstream.close();
+			return true;
+		}
+
+		catch(...)
+		{
+			return false;
+		}
+	}
+
+	inline
+		bool get_file_size(const std::string& path_to_file, uint64_t &size)
+	{
+#ifdef WIN32
+                std::wstring wide_path;
+                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
+                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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
+	}
+
 }
 }
 

contrib/epee/include/memwipe.h

@@ -32,7 +32,6 @@
 
 #ifdef __cplusplus
 #include <array>
-#include <cstddef>
 
 extern "C" {
 #endif

contrib/epee/include/misc_language.h

@@ -28,11 +28,9 @@
 
 #pragma once
 
-#include <boost/utility/value_init.hpp>
-#include <boost/shared_ptr.hpp>
 #include <limits>
-#include <functional>
-#include <vector>
+#include <boost/thread.hpp>
+#include <boost/utility/value_init.hpp>
 namespace epee
 {
 #define STD_TRY_BEGIN() try {
@@ -97,7 +95,16 @@ namespace misc_utils
       return memcmp(&_Left, &_Right, sizeof(_Left)) < 0;
   }
 	
-	bool sleep_no_w(long ms );
+
+	inline
+	bool sleep_no_w(long ms )
+	{
+		boost::this_thread::sleep( 
+			boost::get_system_time() + 
+			boost::posix_time::milliseconds( std::max<long>(ms,0) ) );
+		
+		return true;
+	}
 
   template <typename T>
   T get_mid(const T &a, const T &b)

contrib/epee/include/misc_log_ex.h

@@ -41,7 +41,7 @@
 #define MAX_LOG_FILES 50
 
 #define MCLOG_TYPE(level, cat, color, type, x) do { \
-    if (el::Loggers::allowed(level, cat)) { \
+    if (ELPP->vRegistry()->allowed(level, cat)) { \
       el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
     } \
   } while (0)
@@ -89,7 +89,7 @@
 
 #define IFLOG(level, cat, color, type, init, x) \
   do { \
-    if (el::Loggers::allowed(level, cat)) { \
+    if (ELPP->vRegistry()->allowed(level, cat)) { \
       init; \
       el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
     } \

contrib/epee/include/misc_os_dependent.h

@@ -47,7 +47,7 @@
 #endif
 
 #include <iostream>
-#include <ctime>
+#include <boost/lexical_cast.hpp>
 
 #pragma once 
 namespace epee
@@ -115,7 +115,15 @@ namespace misc_utils
 
 	}
 
-	std::string get_thread_string_id();
+
+	inline std::string get_thread_string_id()
+	{
+#if defined(_WIN32)
+		return boost::lexical_cast<std::string>(GetCurrentThreadId());
+#elif defined(__GNUC__)  
+		return boost::lexical_cast<std::string>(pthread_self());
+#endif
+	}
 
 	inline bool get_gmt_time(time_t t, struct tm &tm)
 	{

contrib/epee/include/net/abstract_http_client.h

@@ -70,7 +70,7 @@ namespace http
     virtual bool connect(std::chrono::milliseconds timeout) = 0;
     virtual bool disconnect() = 0;
     virtual bool is_connected(bool *ssl = NULL) = 0;
-    virtual bool invoke(const boost::string_ref uri, const boost::string_ref method, const boost::string_ref body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
+    virtual bool invoke(const boost::string_ref uri, const boost::string_ref method, const std::string& body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
     virtual bool invoke_get(const boost::string_ref uri, std::chrono::milliseconds timeout, const std::string& body = std::string(), const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
     virtual bool invoke_post(const boost::string_ref uri, const std::string& body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) = 0;
     virtual uint64_t get_bytes_sent() const = 0;

contrib/epee/include/net/abstract_tcp_server2.h

@@ -265,12 +265,6 @@ namespace net_utils
     template<class t_callback>
     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", epee::net_utils::ssl_support_t ssl_support = epee::net_utils::ssl_support_t::e_ssl_support_autodetect);
 
-    boost::asio::ssl::context& get_ssl_context() noexcept
-    {
-      assert(m_state != nullptr);
-      return m_state->ssl_context;
-    }
-
     typename t_protocol_handler::config_type& get_config_object()
     {
       assert(m_state != nullptr); // always set in constructor

contrib/epee/include/net/abstract_tcp_server2.inl

@@ -40,9 +40,8 @@
 #include <boost/date_time/posix_time/posix_time.hpp> // TODO
 #include <boost/thread/condition_variable.hpp> // TODO
 #include <boost/make_shared.hpp>
-#include <boost/thread.hpp>
 #include "warnings.h"
-#include "string_tools_lexical.h"
+#include "string_tools.h"
 #include "misc_language.h"
 #include "net/local_ip.h"
 #include "pragma_comp_defs.h"
@@ -561,7 +560,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 			{ // LOCK: chunking
     		epee::critical_region_t<decltype(m_chunking_lock)> send_guard(m_chunking_lock); // *** critical *** 
 
-				MDEBUG("do_send() will SPLIT into small chunks, from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
+				MDEBUG("do_send() will SPLIT into small chunks, from packet="<<message_size<<" B for ptr="<<message_data);
 				// 01234567890 
 				// ^^^^        (pos=0, len=4)     ;   pos:=pos+len, pos=4
 				//     ^^^^    (pos=4, len=4)     ;   pos:=pos+len, pos=8
@@ -574,14 +573,14 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 				while (!message.empty()) {
 					byte_slice chunk = message.take_slice(chunksize_good);
 
-					MDEBUG("chunk_start="<<(void*)chunk.data()<<" ptr="<<(const void*)message_data<<" pos="<<(chunk.data() - message_data));
+					MDEBUG("chunk_start="<<(void*)chunk.data()<<" ptr="<<message_data<<" pos="<<(chunk.data() - message_data));
 					MDEBUG("part of " << message.size() << ": pos="<<(chunk.data() - message_data) << " len="<<chunk.size());
 
 					bool ok = do_send_chunk(std::move(chunk)); // <====== ***
 
 					all_ok = all_ok && ok;
 					if (!all_ok) {
-						MDEBUG("do_send() DONE ***FAILED*** from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
+						MDEBUG("do_send() DONE ***FAILED*** from packet="<<message_size<<" B for ptr="<<message_data);
 						MDEBUG("do_send() SEND was aborted in middle of big package - this is mostly harmless "
 							<< " (e.g. peer closed connection) but if it causes trouble tell us at #monero-dev. " << message_size);
 						return false; // partial failure in sending
@@ -589,7 +588,7 @@ PRAGMA_WARNING_DISABLE_VS(4355)
 					// (in catch block, or uniq pointer) delete buf;
 				} // each chunk
 
-				MDEBUG("do_send() DONE SPLIT from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
+				MDEBUG("do_send() DONE SPLIT from packet="<<message_size<<" B for ptr="<<message_data);
 
                 MDEBUG("do_send() m_connection_type = " << m_connection_type);
 

contrib/epee/include/net/http_base.h

@@ -27,13 +27,14 @@
 
 
 #pragma once
-#include "memwipe.h"
-
+#include <boost/lexical_cast.hpp>
+#include <boost/regex.hpp>
 #include <boost/utility/string_ref.hpp>
-
 #include <string>
 #include <utility>
-#include <list>
+
+#include "memwipe.h"
+#include "string_tools.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.http"
@@ -65,9 +66,34 @@ namespace net_utils
 
 		typedef std::list<std::pair<std::string, std::string> > fields_list;
 
-		std::string get_value_from_fields_list(const std::string& param_name, const net_utils::http::fields_list& fields);
+		inline
+		std::string get_value_from_fields_list(const std::string& param_name, const net_utils::http::fields_list& fields)
+		{
+			fields_list::const_iterator it = fields.begin();
+			for(; it != fields.end(); it++)
+				if(!string_tools::compare_no_case(param_name, it->first))
+					break;
 
-		std::string get_value_from_uri_line(const std::string& param_name, const std::string& uri);
+			if(it==fields.end())
+				return std::string();
+
+			return it->second;
+		}
+
+
+		inline
+			std::string get_value_from_uri_line(const std::string& param_name, const std::string& uri)
+		{
+			std::string buff = "([\\?|&])";
+			buff += param_name + "=([^&]*)";
+			boost::regex match_param(buff.c_str(), boost::regex::icase | boost::regex::normal);
+			boost::smatch	result;
+			if(boost::regex_search(uri, result, match_param, boost::match_default) && result[0].matched) 
+			{
+				return result[2];
+			}
+			return std::string();
+		}
 
 		static inline void add_field(std::string& out, const boost::string_ref name, const boost::string_ref value)
 		{

contrib/epee/include/net/http_client.h

@@ -30,6 +30,7 @@
 #include <ctype.h>
 #include <boost/shared_ptr.hpp>
 #include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/utility/string_ref.hpp>
 //#include <mbstring.h>
@@ -45,7 +46,6 @@
 #endif 
 
 #include "string_tools.h"
-#include "string_tools_lexical.h"
 #include "reg_exp_definer.h"
 #include "abstract_http_client.h"
 #include "http_base.h" 
@@ -233,7 +233,7 @@ namespace net_utils
 			}
 
 			//---------------------------------------------------------------------------
-			inline bool invoke(const boost::string_ref uri, const boost::string_ref method, const boost::string_ref body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) override
+			inline bool invoke(const boost::string_ref uri, const boost::string_ref method, const std::string& body, std::chrono::milliseconds timeout, const http_response_info** ppresponse_info = NULL, const fields_list& additional_params = fields_list()) override
 			{
 				CRITICAL_REGION_LOCAL(m_lock);
 				if(!is_connected())

contrib/epee/include/net/http_server_handlers_map2.h

@@ -74,13 +74,7 @@
       uint64_t ticks = misc_utils::get_tick_count(); \
       boost::value_initialized<command_type::request> req; \
       bool parse_res = epee::serialization::load_t_from_json(static_cast<command_type::request&>(req), query_info.m_body); \
-      if (!parse_res) \
-      { \
-         MERROR("Failed to parse json: \r\n" << query_info.m_body); \
-         response_info.m_response_code = 400; \
-         response_info.m_response_comment = "Bad request"; \
-         return true; \
-      } \
+      CHECK_AND_ASSERT_MES(parse_res, false, "Failed to parse json: \r\n" << query_info.m_body); \
       uint64_t ticks1 = epee::misc_utils::get_tick_count(); \
       boost::value_initialized<command_type::response> resp;\
       MINFO(m_conn_context << "calling " << s_pattern); \
@@ -110,13 +104,7 @@
       uint64_t ticks = misc_utils::get_tick_count(); \
       boost::value_initialized<command_type::request> req; \
       bool parse_res = epee::serialization::load_t_from_binary(static_cast<command_type::request&>(req), epee::strspan<uint8_t>(query_info.m_body)); \
-      if (!parse_res) \
-      { \
-         MERROR("Failed to parse bin body data, body size=" << query_info.m_body.size()); \
-         response_info.m_response_code = 400; \
-         response_info.m_response_comment = "Bad request"; \
-         return true; \
-      } \
+      CHECK_AND_ASSERT_MES(parse_res, false, "Failed to parse bin body data, body size=" << query_info.m_body.size()); \
       uint64_t ticks1 = misc_utils::get_tick_count(); \
       boost::value_initialized<command_type::response> resp;\
       MINFO(m_conn_context << "calling " << s_pattern); \
@@ -130,10 +118,8 @@
         return true; \
       } \
       uint64_t ticks2 = misc_utils::get_tick_count(); \
-      epee::byte_slice buffer; \
-      epee::serialization::store_t_to_binary(static_cast<command_type::response&>(resp), buffer, 64 * 1024); \
+      epee::serialization::store_t_to_binary(static_cast<command_type::response&>(resp), response_info.m_body); \
       uint64_t ticks3 = epee::misc_utils::get_tick_count(); \
-      response_info.m_body.assign(reinterpret_cast<const char*>(buffer.data()), buffer.size()); \
       response_info.m_mime_tipe = " application/octet-stream"; \
       response_info.m_header_info.m_content_type = " application/octet-stream"; \
       MDEBUG( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \

contrib/epee/include/net/levin_base.h

@@ -31,7 +31,7 @@
 
 #include <cstdint>
 
-#include "byte_stream.h"
+#include "byte_slice.h"
 #include "net_utils_base.h"
 #include "span.h"
 
@@ -39,7 +39,6 @@
 
 namespace epee
 {
-class byte_slice;
 namespace levin
 {
 #pragma pack(push)
@@ -84,12 +83,11 @@ namespace levin
 
 #define LEVIN_PROTOCOL_VER_0         0
 #define LEVIN_PROTOCOL_VER_1         1
-
  
   template<class t_connection_context = net_utils::connection_context_base>
   struct levin_commands_handler
   {
-    virtual int invoke(int command, const epee::span<const uint8_t> in_buff, byte_stream& buff_out, t_connection_context& context)=0;
+    virtual int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, t_connection_context& context)=0;
     virtual int notify(int command, const epee::span<const uint8_t> in_buff, t_connection_context& context)=0;
     virtual void callback(t_connection_context& context){};
 
@@ -127,41 +125,12 @@ namespace levin
     }
   }
 
-  //! Provides space for levin (p2p) header, so that payload can be sent without copy
-  class message_writer
-  {
-    byte_slice finalize(uint32_t command, uint32_t flags, uint32_t return_code, bool expect_response);
-  public:
-    using header = bucket_head2;
-
-    explicit message_writer(std::size_t reserve = 8192);
-
-    message_writer(const message_writer&) = delete;
-    message_writer(message_writer&&) = default;
-    ~message_writer() = default;
-    message_writer& operator=(const message_writer&) = delete;
-    message_writer& operator=(message_writer&&) = default;
-
-    //! \return Size of payload (excludes header size).
-    std::size_t payload_size() const noexcept
-    {
-      return buffer.size() < sizeof(header) ? 0 : buffer.size() - sizeof(header);
-    }
-
-    byte_slice finalize_invoke(uint32_t command) { return finalize(command, LEVIN_PACKET_REQUEST, 0, true); }
-    byte_slice finalize_notify(uint32_t command) { return finalize(command, LEVIN_PACKET_REQUEST, 0, false); }
-    byte_slice finalize_response(uint32_t command, uint32_t return_code)
-    {
-      return finalize(command, LEVIN_PACKET_RESPONSE, return_code, false);
-    }
-
-    //! Has space for levin header until a finalize method is used
-    byte_stream buffer;
-  };
-
   //! \return Intialized levin header.
   bucket_head2 make_header(uint32_t command, uint64_t msg_size, uint32_t flags, bool expect_response) noexcept;
 
+  //! \return A levin notification message.
+  byte_slice make_notify(int command, epee::span<const std::uint8_t> payload);
+
   /*! Generate a dummy levin message.
 
       \param noise_bytes Total size of the returned `byte_slice`.
@@ -171,11 +140,12 @@ namespace levin
 
   /*! Generate 1+ levin messages that are identical to the noise message size.
 
-   \param noise_size Each levin message will be identical to this value.
+   \param noise Each levin message will be identical to the size of this
+      message. The bytes from this message will be used for padding.
    \return `nullptr` if `noise.size()` is less than the levin header size.
       Otherwise, a levin notification message OR 2+ levin fragment messages.
       Each message is `noise.size()` in length. */
-  byte_slice make_fragmented_notify(const std::size_t noise_size, int command, message_writer message);
+  byte_slice make_fragmented_notify(const byte_slice& noise, int command, epee::span<const std::uint8_t> payload);
 }
 }
 

contrib/epee/include/net/levin_protocol_handler_async.h

@@ -51,21 +51,6 @@
 #define MIN_BYTES_WANTED	512
 #endif
 
-template<typename context_t>
-void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, const char* category)
-{
-  MCINFO("net.p2p.traffic", context << bytes << " bytes " << (sent ? "sent" : "received") << (error ? "/corrupt" : "")
-      << " for category " << category << " initiated by " << (initiator ? "us" : "peer"));
-}
-
-template<typename context_t>
-void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, int command)
-{
-  char buf[32];
-  snprintf(buf, sizeof(buf),  "command-%u", command);
-  on_levin_traffic(context, initiator, sent, error, bytes, buf);
-}
-
 namespace epee
 {
 namespace levin
@@ -103,10 +88,11 @@ public:
   uint64_t m_max_packet_size;
   uint64_t m_invoke_timeout;
 
-  int invoke(int command, message_writer in_msg, std::string& buff_out, boost::uuids::uuid connection_id);
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, boost::uuids::uuid connection_id);
   template<class callback_t>
-  int invoke_async(int command, message_writer in_msg, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED);
+  int invoke_async(int command, const epee::span<const uint8_t> in_buff, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED);
 
+  int notify(int command, const epee::span<const uint8_t> in_buff, boost::uuids::uuid connection_id);
   int send(epee::byte_slice message, const boost::uuids::uuid& connection_id);
   bool close(boost::uuids::uuid connection_id);
   bool update_connection_context(const t_connection_context& contxt);
@@ -136,17 +122,12 @@ class async_protocol_handler
 {
   std::string m_fragment_buffer;
 
-  bool send_message(byte_slice message)
+  bool send_message(uint32_t command, epee::span<const uint8_t> in_buff, uint32_t flags, bool expect_response)
   {
-    if (message.size() < sizeof(message_writer::header))
+    const bucket_head2 head = make_header(command, in_buff.size(), flags, expect_response);
+    if(!m_pservice_endpoint->do_send(byte_slice{as_byte_span(head), in_buff}))
       return false;
 
-    message_writer::header head;
-    std::memcpy(std::addressof(head), message.data(), sizeof(head));
-    if(!m_pservice_endpoint->do_send(std::move(message)))
-      return false;
-
-    on_levin_traffic(m_connection_context, true, true, false, head.m_cb, head.m_command);
     MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << head.m_cb
         << ", flags" << head.m_flags
         << ", r?=" << head.m_have_to_return_data
@@ -165,6 +146,7 @@ public:
     stream_state_body
   };
 
+  std::atomic<bool> m_deletion_initiated;
   std::atomic<bool> m_protocol_released;
   volatile uint32_t m_invoke_buf_ready;
 
@@ -315,6 +297,7 @@ public:
             m_state(stream_state_head)
   {
     m_close_called = 0;
+    m_deletion_initiated = false;
     m_protocol_released = false;
     m_wait_count = 0;
     m_oponent_protocol_ver = 0;
@@ -327,6 +310,7 @@ public:
     try
     {
 
+    m_deletion_initiated = true;
     if(m_connection_initialized)
     {
       m_config.del_connection(this);
@@ -542,17 +526,27 @@ public:
           {
             if(m_current_head.m_have_to_return_data)
             {
-              levin::message_writer return_message{32 * 1024};
+              std::string return_buff;
               const uint32_t return_code = m_config.m_pcommands_handler->invoke(
-                m_current_head.m_command, buff_to_invoke, return_message.buffer, m_connection_context
+                m_current_head.m_command, buff_to_invoke, return_buff, m_connection_context
               );
 
               // peer_id remains unset if dropped
               if (m_current_head.m_command == m_connection_context.handshake_command() && m_connection_context.handshake_complete())
                 m_max_packet_size = m_config.m_max_packet_size;
 
-              if(!send_message(return_message.finalize_response(m_current_head.m_command, return_code)))
+              bucket_head2 head = make_header(m_current_head.m_command, return_buff.size(), LEVIN_PACKET_RESPONSE, false);
+              head.m_return_code = SWAP32LE(return_code);
+              return_buff.insert(0, reinterpret_cast<const char*>(&head), sizeof(head));
+
+              if(!m_pservice_endpoint->do_send(byte_slice{std::move(return_buff)}))
                 return false;
+
+              MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << head.m_cb
+                << ", flags" << head.m_flags
+                << ", r?=" << head.m_have_to_return_data
+                <<", cmd = " << head.m_command
+                << ", ver=" << head.m_protocol_version);
             }
             else
               m_config.m_pcommands_handler->notify(m_current_head.m_command, buff_to_invoke, m_connection_context);
@@ -629,7 +623,7 @@ public:
   }
 
   template<class callback_t>
-  bool async_invoke(int command, message_writer in_msg, const callback_t &cb, size_t timeout = LEVIN_DEFAULT_TIMEOUT_PRECONFIGURED)
+  bool async_invoke(int command, const epee::span<const uint8_t> 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));
@@ -640,15 +634,27 @@ public:
     int err_code = LEVIN_OK;
     do
     {
+      if(m_deletion_initiated)
+      {
+        err_code = LEVIN_ERROR_CONNECTION_DESTROYED;
+        break;
+      }
+
       CRITICAL_REGION_LOCAL(m_call_lock);
 
+      if(m_deletion_initiated)
+      {
+        err_code = LEVIN_ERROR_CONNECTION_DESTROYED;
+        break;
+      }
+
       boost::interprocess::ipcdetail::atomic_write32(&m_invoke_buf_ready, 0);
       CRITICAL_REGION_BEGIN(m_invoke_response_handlers_lock);
 
       if (command == m_connection_context.handshake_command())
         m_max_packet_size = m_config.m_max_packet_size;
 
-      if(!send_message(in_msg.finalize_invoke(command)))
+      if(!send_message(command, in_buff, LEVIN_PACKET_REQUEST, true))
       {
         LOG_ERROR_CC(m_connection_context, "Failed to do_send");
         err_code = LEVIN_ERROR_CONNECTION;
@@ -674,19 +680,25 @@ public:
     return true;
   }
 
-  int invoke(int command, message_writer in_msg, std::string& buff_out)
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out)
   {
     misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
                                       boost::bind(&async_protocol_handler::finish_outer_call, this));
 
+    if(m_deletion_initiated)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
     CRITICAL_REGION_LOCAL(m_call_lock);
 
+    if(m_deletion_initiated)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
     boost::interprocess::ipcdetail::atomic_write32(&m_invoke_buf_ready, 0);
 
     if (command == m_connection_context.handshake_command())
       m_max_packet_size = m_config.m_max_packet_size;
 
-    if (!send_message(in_msg.finalize_invoke(command)))
+    if (!send_message(command, in_buff, LEVIN_PACKET_REQUEST, true))
     {
       LOG_ERROR_CC(m_connection_context, "Failed to send request");
       return LEVIN_ERROR_CONNECTION;
@@ -695,7 +707,7 @@ public:
     uint64_t ticks_start = misc_utils::get_tick_count();
     size_t prev_size = 0;
 
-    while(!boost::interprocess::ipcdetail::atomic_read32(&m_invoke_buf_ready) && !m_protocol_released)
+    while(!boost::interprocess::ipcdetail::atomic_read32(&m_invoke_buf_ready) && !m_deletion_initiated && !m_protocol_released)
     {
       if(m_cache_in_buffer.size() - prev_size >= MIN_BYTES_WANTED)
       {
@@ -712,7 +724,7 @@ public:
         return LEVIN_ERROR_CONNECTION_DESTROYED;
     }
 
-    if(m_protocol_released)
+    if(m_deletion_initiated || m_protocol_released)
       return LEVIN_ERROR_CONNECTION_DESTROYED;
 
     CRITICAL_REGION_BEGIN(m_local_inv_buff_lock);
@@ -723,9 +735,31 @@ public:
     return m_invoke_result_code;
   }
 
-  /*! Sends `message` without adding a levin header. The message must have been
-      created with `make_noise_notify`, `make_fragmented_notify`, or
-      `message_writer::finalize_notify`. See additional instructions for
+  int notify(int command, const epee::span<const uint8_t> in_buff)
+  {
+    misc_utils::auto_scope_leave_caller scope_exit_handler = misc_utils::create_scope_leave_handler(
+                          boost::bind(&async_protocol_handler::finish_outer_call, this));
+
+    if(m_deletion_initiated)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
+    CRITICAL_REGION_LOCAL(m_call_lock);
+
+    if(m_deletion_initiated)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
+    if (!send_message(command, in_buff, LEVIN_PACKET_REQUEST, false))
+    {
+      LOG_ERROR_CC(m_connection_context, "Failed to send notify message");
+      return -1;
+    }
+
+    return 1;
+  }
+
+  /*! Sends `message` without adding a levin header. The message must have
+      been created with `make_notify`, `make_noise_notify` or
+      `make_fragmented_notify`. See additional instructions for
       `make_fragmented_notify`.
 
       \return 1 on success */
@@ -735,11 +769,17 @@ public:
       boost::bind(&async_protocol_handler::finish_outer_call, this)
     );
 
-    if (!send_message(std::move(message)))
+    if(m_deletion_initiated)
+      return LEVIN_ERROR_CONNECTION_DESTROYED;
+
+    const std::size_t length = message.size();
+    if (!m_pservice_endpoint->do_send(std::move(message)))
     {
       LOG_ERROR_CC(m_connection_context, "Failed to send message, dropping it");
       return -1;
     }
+
+    MDEBUG(m_connection_context << "LEVIN_PACKET_SENT. [len=" << (length - sizeof(bucket_head2)) << ", r?=0]");
     return 1;
   }
   //------------------------------------------------------------------------------------------
@@ -829,19 +869,19 @@ int async_protocol_handler_config<t_connection_context>::find_and_lock_connectio
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context>
-int async_protocol_handler_config<t_connection_context>::invoke(int command, message_writer in_msg, std::string& buff_out, boost::uuids::uuid connection_id)
+int async_protocol_handler_config<t_connection_context>::invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, boost::uuids::uuid connection_id)
 {
   async_protocol_handler<t_connection_context>* aph;
   int r = find_and_lock_connection(connection_id, aph);
-  return LEVIN_OK == r ? aph->invoke(command, std::move(in_msg), buff_out) : r;
+  return LEVIN_OK == r ? aph->invoke(command, in_buff, buff_out) : r;
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
-int async_protocol_handler_config<t_connection_context>::invoke_async(int command, message_writer in_msg, boost::uuids::uuid connection_id, const callback_t &cb, size_t timeout)
+int async_protocol_handler_config<t_connection_context>::invoke_async(int command, const epee::span<const uint8_t> 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);
-  return LEVIN_OK == r ? aph->async_invoke(command, std::move(in_msg), cb, timeout) : r;
+  return LEVIN_OK == r ? aph->async_invoke(command, in_buff, cb, timeout) : r;
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context> template<class callback_t>
@@ -920,6 +960,14 @@ void async_protocol_handler_config<t_connection_context>::set_handler(levin_comm
 }
 //------------------------------------------------------------------------------------------
 template<class t_connection_context>
+int async_protocol_handler_config<t_connection_context>::notify(int command, const epee::span<const uint8_t> in_buff, boost::uuids::uuid connection_id)
+{
+  async_protocol_handler<t_connection_context>* aph;
+  int r = find_and_lock_connection(connection_id, aph);
+  return LEVIN_OK == r ? aph->notify(command, in_buff) : r;
+}
+//------------------------------------------------------------------------------------------
+template<class t_connection_context>
 int async_protocol_handler_config<t_connection_context>::send(byte_slice message, const boost::uuids::uuid& connection_id)
 {
   async_protocol_handler<t_connection_context>* aph;

contrib/epee/include/net/net_helper.h

@@ -44,7 +44,6 @@
 #include <boost/lambda/lambda.hpp>
 #include <boost/interprocess/detail/atomic.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/utility/string_ref.hpp>
 #include <functional>
 #include "net/net_utils_base.h"
 #include "net/net_ssl.h"
@@ -281,7 +280,7 @@ namespace net_utils
 
 
 		inline 
-		bool send(const boost::string_ref buff, std::chrono::milliseconds timeout)
+		bool send(const std::string& buff, std::chrono::milliseconds timeout)
 		{
 
 			try
@@ -299,7 +298,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.
-				async_write(buff.data(), buff.size(), ec);
+				async_write(buff.c_str(), buff.size(), ec);
 
 				// Block until the asynchronous operation has completed.
 				while (ec == boost::asio::error::would_block)

contrib/epee/include/net/net_parse_helpers.h

@@ -24,9 +24,12 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
-#pragma once 
 
+
+
+#pragma once 
 #include "http_base.h"
+#include "reg_exp_definer.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"
@@ -35,8 +38,173 @@ namespace epee
 {
 namespace net_utils
 {
-    bool parse_uri(const std::string uri, http::uri_content& content);
-    bool parse_url_ipv6(const std::string url_str, http::url_content& content);
-    bool parse_url(const std::string url_str, http::url_content& content);
+
+  inline bool parse_uri_query(const std::string& query, std::list<std::pair<std::string, std::string> >& params)
+  { 
+    enum state
+    {
+      st_param_name, 
+      st_param_val
+    };
+    state st = st_param_name;
+    std::string::const_iterator start_it = query.begin();
+    std::pair<std::string, std::string> e;
+    for(std::string::const_iterator it = query.begin(); it != query.end(); it++)
+    {
+      switch(st)
+      {
+      case st_param_name:
+        if(*it == '=')
+        {
+          e.first.assign(start_it, it);
+          start_it = it;++start_it;
+          st = st_param_val;
+        }
+        break;
+      case st_param_val:
+        if(*it == '&')
+        {
+          e.second.assign(start_it, it);
+          start_it = it;++start_it;
+          params.push_back(e);
+          e.first.clear();e.second.clear();
+          st = st_param_name;
+        }
+        break;
+      default:
+        LOG_ERROR("Unknown state " << (int)st);
+        return false;
+      }
+    }
+    if(st == st_param_name)
+    {
+      if(start_it != query.end())
+      {
+        e.first.assign(start_it, query.end());
+        params.push_back(e);
+      }
+    }else
+    {
+      if(start_it != query.end())
+        e.second.assign(start_it, query.end());
+
+      if(e.first.size())
+        params.push_back(e);
+    }
+    return true;
+  }
+  
+  inline
+    bool parse_uri(const std::string uri, http::uri_content& content)
+  {
+
+    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
+    content.m_query_params.clear();
+    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))
+    {
+      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
+      content.m_path = uri;
+      return true;
+    }
+    if(result[1].matched)
+    {
+      content.m_path = result[1];
+    }
+    if(result[3].matched)
+    {
+      content.m_query = result[3];
+    }
+    if(result[5].matched)
+    {
+      content.m_fragment = result[5];
+    }
+    if(content.m_query.size())
+    {
+      parse_uri_query(content.m_query, content.m_query_params);
+    }
+    return true;
+  }
+
+  inline
+    bool parse_url_ipv6(const std::string url_str, http::url_content& content)
+  {
+    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^((.*?)://)?(\\[(.*)\\](:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
+    //                                     12         3   4      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))
+    {
+      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
+      //content.m_path = uri;
+      return false;
+    }
+    if(result[2].matched)
+    {
+      content.schema = result[2];
+    }
+    if(result[4].matched)
+    {
+      content.host = result[4];
+    }
+    else  // if host not matched, matching should be considered failed
+    {
+      return false;
+    }
+    if(result[6].matched)
+    {
+      content.port = boost::lexical_cast<uint64_t>(result[6]);
+    }
+    if(result[7].matched)
+    {
+      content.uri = result[7];
+      return parse_uri(result[7], content.m_uri_content);
+    }
+
+    return true;
+  }
+
+  inline
+    bool parse_url(const std::string url_str, http::url_content& content)
+  {
+
+    if (parse_url_ipv6(url_str, content)) return true;
+
+    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
+    //STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
+    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^((.*?)://)?(([^/:]*)(:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
+    //                                     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))
+    {
+      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
+      //content.m_path = uri;
+      return true;
+    }
+    if(result[2].matched)
+    {
+      content.schema = result[2];
+    }
+    if(result[4].matched)
+    {
+      content.host = result[4];
+    }
+    if(result[6].matched)
+    {
+      content.port = boost::lexical_cast<uint64_t>(result[6]);
+    }
+    if(result[7].matched)
+    {
+      content.uri = result[7];
+      return parse_uri(result[7], content.m_uri_content);
+    }
+    
+    return true;
+  }
+
 }
 }

contrib/epee/include/net/net_ssl.h

@@ -36,7 +36,6 @@
 #include <boost/utility/string_ref.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/ssl.hpp>
-#include <boost/filesystem/path.hpp>
 #include <boost/system/error_code.hpp>
 
 #define SSL_FINGERPRINT_SIZE 32
@@ -145,9 +144,6 @@ namespace net_utils
 
 	bool create_ec_ssl_certificate(EVP_PKEY *&pkey, X509 *&cert);
 	bool create_rsa_ssl_certificate(EVP_PKEY *&pkey, X509 *&cert);
-
-  //! Store private key for `ssl` at `base + ".key"` unencrypted and certificate for `ssl` at `base + ".crt"`.
-  boost::system::error_code store_ssl_keys(boost::asio::ssl::context& ssl, const boost::filesystem::path& base);
 }
 }
 

contrib/epee/include/net/net_utils_base.h

@@ -236,6 +236,7 @@ namespace net_utils
 			virtual address_type get_type_id() const = 0;
 			virtual zone get_zone() const = 0;
 			virtual bool is_blockable() const = 0;
+			virtual std::uint16_t port() const = 0;
 		};
 
 		template<typename T>
@@ -266,6 +267,7 @@ namespace net_utils
 			virtual address_type get_type_id() const override { return value.get_type_id(); }
 			virtual zone get_zone() const override { return value.get_zone(); }
 			virtual bool is_blockable() const override { return value.is_blockable(); }
+			virtual std::uint16_t port() const override { return value.port(); }
 		};
 
 		std::shared_ptr<interface> self;
@@ -312,6 +314,7 @@ namespace net_utils
 		address_type get_type_id() const { return self ? self->get_type_id() : address_type::invalid; }
 		zone get_zone() const { return self ? self->get_zone() : zone::invalid; }
 		bool is_blockable() const { return self ? self->is_blockable() : false; }
+		std::uint16_t port() const { return self ? self->port() : 0; }
 		template<typename Type> const Type &as() const { return as_mutable<const Type>(); }
 
 		BEGIN_KV_SERIALIZE_MAP()

contrib/epee/include/reg_exp_definer.h

@@ -29,7 +29,6 @@
 #define _REG_EXP_DEFINER_H_
 
 #include <boost/interprocess/detail/atomic.hpp>
-#include <boost/regex.hpp>
 #include "syncobj.h"
 
 namespace epee

contrib/epee/include/serialization/keyvalue_serialization.h

@@ -73,8 +73,7 @@ public: \
   template<bool is_store, class t_storage> \
   bool serialize_map(t_storage& stg, typename t_storage::hsection hparent_section) \
   { \
-    decltype(*this) &this_ref = *this; \
-    (void) this_ref; // Suppress unused var warnings. Sometimes this var is used, sometimes not.
+    decltype(*this) &this_ref = *this;
 
 #define KV_SERIALIZE_N(varialble, val_name) \
   epee::serialization::selector<is_store>::serialize(this_ref.varialble, stg, hparent_section, val_name);

contrib/epee/include/span.h

@@ -31,6 +31,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
+#include <string>
 #include <type_traits>
 
 namespace epee
@@ -166,11 +167,10 @@ namespace epee
   }
 
   //! make a span from a std::string
-  template<typename T, typename U>
-  span<const T> strspan(const U&s) noexcept
+  template<typename T>
+  span<const T> strspan(const std::string &s) noexcept
   {
-    static_assert(std::is_same<typename U::value_type, char>(), "unexpected source type");
-    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected destination type");
+    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected type");
     return {reinterpret_cast<const T*>(s.data()), s.size()};
   }
 }

contrib/epee/include/storages/http_abstract_invoke.h

@@ -29,7 +29,6 @@
 #include <boost/utility/string_ref.hpp>
 #include <chrono>
 #include <string>
-#include "byte_slice.h"
 #include "portable_storage_template_helper.h"
 #include "net/http_base.h"
 #include "net/http_server_handlers_map2.h"
@@ -75,12 +74,12 @@ namespace epee
     template<class t_request, class t_response, class t_transport>
     bool invoke_http_bin(const boost::string_ref uri, const t_request& out_struct, t_response& result_struct, t_transport& transport, std::chrono::milliseconds timeout = std::chrono::seconds(15), const boost::string_ref method = "POST")
     {
-      byte_slice req_param;
-      if(!serialization::store_t_to_binary(out_struct, req_param, 16 * 1024))
+      std::string req_param;
+      if(!serialization::store_t_to_binary(out_struct, req_param))
         return false;
 
       const http::http_response_info* pri = NULL;
-      if(!transport.invoke(uri, method, boost::string_ref{reinterpret_cast<const char*>(req_param.data()), req_param.size()}, timeout, std::addressof(pri)))
+      if(!transport.invoke(uri, method, req_param, timeout, std::addressof(pri)))
       {
         LOG_PRINT_L1("Failed to invoke http request to  " << uri);
         return false;

contrib/epee/include/storages/levin_abstract_invoke2.h

@@ -27,24 +27,29 @@
 #pragma once
 
 #include "portable_storage_template_helper.h"
-#include <boost/utility/string_ref.hpp>
 #include <boost/utility/value_init.hpp>
 #include <functional>
-#include "byte_slice.h"
 #include "span.h"
 #include "net/levin_base.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net"
 
-template<typename context_t>
-void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, const char *category);
-
-template<typename context_t>
-void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, int command);
-
 namespace
 {
+  template<typename context_t>
+  void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, const char *category)
+  {
+    MCINFO("net.p2p.traffic", context << bytes << " bytes " << (sent ? "sent" : "received") << (error ? "/corrupt" : "")
+        << " for category " << category << " initiated by " << (initiator ? "us" : "peer"));
+  }
+  template<typename context_t>
+  void on_levin_traffic(const context_t &context, bool initiator, bool sent, bool error, size_t bytes, int command)
+  {
+    char buf[32];
+    snprintf(buf, sizeof(buf),  "command-%u", command);
+    return on_levin_traffic(context, initiator, sent, error, bytes, buf);
+  }
   static const constexpr epee::serialization::portable_storage::limits_t default_levin_limits = {
     8192, // objects
     16384, // fields
@@ -110,11 +115,11 @@ namespace epee
       const boost::uuids::uuid &conn_id = context.m_connection_id;
       typename serialization::portable_storage stg;
       out_struct.store(stg);
-      levin::message_writer to_send{16 * 1024};
-      std::string buff_to_recv;
-      stg.store_to_binary(to_send.buffer);
+      std::string buff_to_send, buff_to_recv;
+      stg.store_to_binary(buff_to_send);
 
-      int res = transport.invoke(command, std::move(to_send), buff_to_recv, conn_id);
+      on_levin_traffic(context, true, true, false, buff_to_send.size(), command);
+      int res = transport.invoke(command, buff_to_send, buff_to_recv, conn_id);
       if( res <=0 )
       {
         LOG_PRINT_L1("Failed to invoke command " << command << " return code " << res);
@@ -137,9 +142,10 @@ namespace epee
       const boost::uuids::uuid &conn_id = context.m_connection_id;
       typename serialization::portable_storage stg;
       const_cast<t_arg&>(out_struct).store(stg);//TODO: add true const support to searilzation
-      levin::message_writer to_send{16 * 1024};
-      stg.store_to_binary(to_send.buffer);
-      int res = transport.invoke_async(command, std::move(to_send), conn_id, [cb, command](int code, const epee::span<const uint8_t> buff, typename t_transport::connection_context& context)->bool
+      std::string buff_to_send;
+      stg.store_to_binary(buff_to_send);
+      on_levin_traffic(context, true, true, false, buff_to_send.size(), command);
+      int res = transport.invoke_async(command, epee::strspan<uint8_t>(buff_to_send), conn_id, [cb, command](int code, const epee::span<const uint8_t> buff, typename t_transport::connection_context& context)->bool 
       {
         t_result result_struct = AUTO_VAL_INIT(result_struct);
         if( code <=0 )
@@ -183,10 +189,11 @@ namespace epee
       const boost::uuids::uuid &conn_id = context.m_connection_id;
       serialization::portable_storage stg;
       out_struct.store(stg);
-      levin::message_writer to_send;
-      stg.store_to_binary(to_send.buffer);
+      std::string buff_to_send;
+      stg.store_to_binary(buff_to_send);
 
-      int res = transport.send(to_send.finalize_notify(command), conn_id);
+      on_levin_traffic(context, true, true, false, buff_to_send.size(), command);
+      int res = transport.notify(command, epee::strspan<uint8_t>(buff_to_send), conn_id);
       if(res <=0 )
       {
         MERROR("Failed to notify command " << command << " return code " << res);
@@ -197,7 +204,7 @@ namespace epee
     //----------------------------------------------------------------------------------------------------
     //----------------------------------------------------------------------------------------------------
     template<class t_owner, class t_in_type, class t_out_type, class t_context, class callback_t>
-    int buff_to_t_adapter(int command, const epee::span<const uint8_t> in_buff, byte_stream& buff_out, callback_t cb, t_context& context )
+    int buff_to_t_adapter(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, callback_t cb, t_context& context )
     {
       serialization::portable_storage strg;
       if(!strg.load_from_binary(in_buff, &default_levin_limits))
@@ -225,6 +232,7 @@ namespace epee
         LOG_ERROR("Failed to store_to_binary in command" << command);
         return -1;
       }
+      on_levin_traffic(context, false, true, false, buff_out.size(), command);
 
       return res;
     }
@@ -251,7 +259,7 @@ namespace epee
     }
 
 #define CHAIN_LEVIN_INVOKE_MAP2(context_type) \
-  int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, context_type& context) \
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, context_type& context) \
   { \
   bool handled = false; \
   return handle_invoke_map(false, command, in_buff, buff_out, context, handled); \
@@ -260,13 +268,13 @@ namespace epee
 #define CHAIN_LEVIN_NOTIFY_MAP2(context_type) \
   int notify(int command, const epee::span<const uint8_t> in_buff, context_type& context) \
   { \
-    bool handled = false; epee::byte_stream fake_str; \
-    return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
+  bool handled = false; std::string fake_str;\
+  return handle_invoke_map(true, command, in_buff, fake_str, context, handled); \
   } 
 
 
 #define CHAIN_LEVIN_INVOKE_MAP() \
-  int invoke(int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, epee::net_utils::connection_context_base& context) \
+  int invoke(int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, epee::net_utils::connection_context_base& context) \
   { \
   bool handled = false; \
   return handle_invoke_map(false, command, in_buff, buff_out, context, handled); \
@@ -286,7 +294,7 @@ namespace epee
   } 
 
 #define BEGIN_INVOKE_MAP2(owner_type) \
-  template <class t_context> int handle_invoke_map(bool is_notify, int command, const epee::span<const uint8_t> in_buff, epee::byte_stream& buff_out, t_context& context, bool& handled) \
+  template <class t_context> int handle_invoke_map(bool is_notify, int command, const epee::span<const uint8_t> in_buff, std::string& buff_out, t_context& context, bool& handled) \
   { \
   try { \
   typedef owner_type internal_owner_type_name;

contrib/epee/include/storages/parserse_base_utils.h

@@ -28,8 +28,13 @@
 
 #pragma once 
 
-#include <boost/utility/string_ref_fwd.hpp>
-#include <string>
+#include <algorithm>
+#include <boost/utility/string_ref.hpp>
+
+#include "misc_log_ex.h"
+
+#undef MONERO_DEFAULT_LOG_CATEGORY
+#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
 
 namespace epee 
 {
@@ -92,7 +97,46 @@ namespace misc_utils
       return lut[(uint8_t)c] & 1;
     }
 
-    std::string transform_to_escape_sequence(const std::string& src);
+    inline std::string transform_to_escape_sequence(const std::string& src)
+    {
+      static const char escaped[] = "\b\f\n\r\t\v\"\\/";
+      std::string::const_iterator it = std::find_first_of(src.begin(), src.end(), escaped, escaped + sizeof(escaped));
+      if (it == src.end())
+        return src;
+
+      std::string res;
+      res.reserve(2 * src.size());
+      res.assign(src.begin(), it);
+      for(; it!=src.end(); ++it)
+      {
+        switch(*it)
+        {
+        case '\b':  //Backspace (ascii code 08)
+          res+="\\b"; break;
+        case '\f':  //Form feed (ascii code 0C)
+          res+="\\f"; break;
+        case '\n':  //New line
+          res+="\\n"; break;
+        case '\r':  //Carriage return
+          res+="\\r"; break;
+        case '\t':  //Tab
+          res+="\\t"; break;
+        case '\v':  //Vertical tab
+          res+="\\v"; break;
+        //case '\'':  //Apostrophe or single quote
+        //  res+="\\'"; break;
+        case '"':  //Double quote
+          res+="\\\""; break;
+        case '\\':  //Backslash caracter
+          res+="\\\\"; break;
+        case '/':  //Backslash caracter
+          res+="\\/"; break;
+        default:
+          res.push_back(*it);
+        }
+      }
+      return res;
+    }
     /*
       
       \b  Backspace (ascii code 08)
@@ -106,7 +150,98 @@ namespace misc_utils
       \\  Backslash character
 
       */
-      void match_string2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val);
+      inline void match_string2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
+      {
+        bool escape_mode = false;
+        std::string::const_iterator it = star_end_string;
+        ++it;
+        std::string::const_iterator fi = it;
+        while (fi != buf_end && ((lut[(uint8_t)*fi] & 32)) == 0)
+          ++fi;
+        val.assign(it, fi);
+        it = fi;
+        for(;it != buf_end;it++)
+        {
+          if(escape_mode/*prev_ch == '\\'*/)
+          {
+            switch(*it)
+            {
+            case 'b':  //Backspace (ascii code 08)
+              val.push_back(0x08);break;
+            case 'f':  //Form feed (ascii code 0C)
+              val.push_back(0x0C);break;
+            case 'n':  //New line
+              val.push_back('\n');break;
+            case 'r':  //Carriage return
+              val.push_back('\r');break;
+            case 't':  //Tab
+              val.push_back('\t');break;
+            case 'v':  //Vertical tab
+              val.push_back('\v');break;
+            case '\'':  //Apostrophe or single quote
+              val.push_back('\'');break;
+            case '"':  //Double quote
+              val.push_back('"');break;
+            case '\\':  //Backslash character
+              val.push_back('\\');break;
+            case '/':  //Slash character
+              val.push_back('/');break;
+            case 'u':  //Unicode code point
+              if (buf_end - it < 4)
+              {
+                ASSERT_MES_AND_THROW("Invalid Unicode escape sequence");
+              }
+              else
+              {
+                uint32_t dst = 0;
+                for (int i = 0; i < 4; ++i)
+                {
+                  const unsigned char tmp = isx[(unsigned char)*++it];
+                  CHECK_AND_ASSERT_THROW_MES(tmp != 0xff, "Bad Unicode encoding");
+                  dst = dst << 4 | tmp;
+                }
+                // encode as UTF-8
+                if (dst <= 0x7f)
+                {
+                  val.push_back(dst);
+                }
+                else if (dst <= 0x7ff)
+                {
+                  val.push_back(0xc0 | (dst >> 6));
+                  val.push_back(0x80 | (dst & 0x3f));
+                }
+                else if (dst <= 0xffff)
+                {
+                  val.push_back(0xe0 | (dst >> 12));
+                  val.push_back(0x80 | ((dst >> 6) & 0x3f));
+                  val.push_back(0x80 | (dst & 0x3f));
+                }
+                else
+                {
+                  ASSERT_MES_AND_THROW("Unicode code point is out or range");
+                }
+              }
+              break;
+            default:
+              val.push_back(*it);
+              LOG_PRINT_L0("Unknown escape sequence :\"\\" << *it << "\"");
+            }
+            escape_mode = false;
+          }else if(*it == '"')
+          {
+            star_end_string = it;
+            return;
+          }else if(*it == '\\')
+          {
+            escape_mode = true;
+          }          
+          else
+          {
+            val.push_back(*it); 
+          }
+        }
+        ASSERT_MES_AND_THROW("Failed to match string in json entry: " << std::string(star_end_string, buf_end));
+      }
       inline bool match_string(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
       {
         try
@@ -120,7 +255,42 @@ namespace misc_utils
           return false;
         }
       }
-      void match_number2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val, bool& is_float_val, bool& is_signed_val);
+      inline void match_number2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val, bool& is_float_val, bool& is_signed_val)
+      {
+        val.clear();
+        uint8_t float_flag = 0;
+        is_signed_val = false;
+        size_t chars = 0;
+        std::string::const_iterator it = star_end_string;
+        if (it != buf_end && *it == '-')
+        {
+          is_signed_val = true;
+          ++chars;
+          ++it;
+        }
+        for(;it != buf_end;it++)
+        {
+          const uint8_t flags = lut[(uint8_t)*it];
+          if (flags & 16)
+          {
+            float_flag |= flags;
+            ++chars;
+          }
+          else
+          {
+            val = boost::string_ref(&*star_end_string, chars);
+            if(val.size())
+            {
+              star_end_string = --it;
+              is_float_val = !!(float_flag & 2);
+              return;
+            }
+            else 
+              ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
+          }
+        }
+        ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
+      }
       inline bool match_number(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
       {
         try
@@ -134,7 +304,25 @@ namespace misc_utils
           return false;
         }
       }
-      void match_word2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val);
+      inline void match_word2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
+      {
+        val.clear();
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if (!(lut[(uint8_t)*it] & 4))
+          {
+            val = boost::string_ref(&*star_end_string, std::distance(star_end_string, it));
+            if(val.size())
+            {
+              star_end_string = --it;
+              return;
+            }else 
+              ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
+          }
+        }
+        ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
+      }
       inline bool match_word(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
       {
         try
@@ -147,8 +335,44 @@ namespace misc_utils
           return false;
         }
       }
-      bool match_word_with_extrasymb(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val);
-      bool match_word_til_equal_mark(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string::const_iterator& word_end);
+      inline bool match_word_with_extrasymb(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
+      {
+        val.clear();
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if(!isalnum(*it) && *it != '-' && *it != '_')
+          {
+            val.assign(star_end_string, it);
+            if(val.size())
+            {
+              star_end_string = --it;
+              return true;
+            }else 
+              return false;
+          }
+        }
+        return false;
+      }
+      inline bool match_word_til_equal_mark(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string::const_iterator& word_end)
+      {
+        word_end = star_end_string;
+
+        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
+        {
+          if(isspace(*it))
+          {
+
+            continue;
+          }else if( *it == '=' )
+          {            
+            star_end_string = it;
+            word_end = it;
+            return true;
+          }
+        }
+        return false;
+      }
   }
 }
 }

contrib/epee/include/storages/portable_storage.h

@@ -24,19 +24,26 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+
+
 #pragma once 
 
+#include <type_traits>
+
+#include "misc_language.h"
 #include "portable_storage_base.h"
+#include "portable_storage_to_bin.h"
+#include "portable_storage_from_bin.h"
+#include "portable_storage_to_json.h"
+#include "portable_storage_from_json.h"
 #include "portable_storage_val_converters.h"
-#include "misc_log_ex.h"
 #include "span.h"
+#include "int-util.h"
 
 #include <boost/mpl/contains.hpp>
 
 namespace epee
 {
-  class byte_slice;
-  class byte_stream;
   namespace serialization
   {
     /************************************************************************/
@@ -85,14 +92,9 @@ namespace epee
       bool        delete_entry(const std::string& pentry_name, hsection hparent_section = nullptr);
 
       //-------------------------------------------------------------------------------
-      bool		store_to_binary(byte_slice& target, std::size_t initial_buffer_size = 8192);
-      bool		store_to_binary(byte_stream& ss);
-      bool		load_from_binary(const epee::span<const uint8_t> target, const limits_t *limits = nullptr);
-      bool		load_from_binary(const std::string& target, const limits_t *limits = nullptr)
-      {
-        return load_from_binary(epee::strspan<uint8_t>(target), limits);
-      }
-
+      bool		store_to_binary(binarybuffer& target);
+      bool		load_from_binary(const epee::span<const uint8_t> target, const limits_t *limits = NULL);
+      bool		load_from_binary(const std::string& target, const limits_t *limits = NULL) { return load_from_binary(epee::strspan<uint8_t>(target), limits); }
       template<class trace_policy>
       bool		  dump_as_xml(std::string& targetObj, const std::string& root_name = "");
       bool		  dump_as_json(std::string& targetObj, size_t indent = 0, bool insert_newlines = true);
@@ -117,13 +119,101 @@ namespace epee
       };
 #pragma pack(pop)
     };
-    
+    inline
+    bool portable_storage::dump_as_json(std::string& buff, size_t indent, bool insert_newlines)
+    {
+      TRY_ENTRY();
+      std::stringstream ss;
+      epee::serialization::dump_as_json(ss, m_root, indent, insert_newlines);
+      buff = ss.str();
+      return true;
+      CATCH_ENTRY("portable_storage::dump_as_json", false)
+    }
+    inline
+    bool portable_storage::load_from_json(const std::string& source)
+    {
+      TRY_ENTRY();
+      return json::load_from_json(source, *this);
+      CATCH_ENTRY("portable_storage::load_from_json", false)
+    }
+
     template<class trace_policy>
     bool portable_storage::dump_as_xml(std::string& targetObj, const std::string& root_name)
     {
       return false;//TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
-    }    
+    }
 
+    inline
+    bool portable_storage::store_to_binary(binarybuffer& target)
+    {
+      TRY_ENTRY();
+      std::stringstream ss;
+      storage_block_header sbh = AUTO_VAL_INIT(sbh);
+      sbh.m_signature_a = SWAP32LE(PORTABLE_STORAGE_SIGNATUREA);
+      sbh.m_signature_b = SWAP32LE(PORTABLE_STORAGE_SIGNATUREB);
+      sbh.m_ver = PORTABLE_STORAGE_FORMAT_VER;
+      ss.write((const char*)&sbh, sizeof(storage_block_header));
+      pack_entry_to_buff(ss, m_root);
+      target = ss.str();
+      return true;
+      CATCH_ENTRY("portable_storage::store_to_binary", false)
+    }
+    inline
+    bool portable_storage::load_from_binary(const epee::span<const uint8_t> source, const limits_t *limits)
+    {
+      m_root.m_entries.clear();
+      if(source.size() < sizeof(storage_block_header))
+      {
+        LOG_ERROR("portable_storage: wrong binary format, packet size = " << source.size() << " less than expected sizeof(storage_block_header)=" << sizeof(storage_block_header));
+        return false;
+      }
+      storage_block_header* pbuff = (storage_block_header*)source.data();
+      if(pbuff->m_signature_a != SWAP32LE(PORTABLE_STORAGE_SIGNATUREA) ||
+        pbuff->m_signature_b != SWAP32LE(PORTABLE_STORAGE_SIGNATUREB)
+        )
+      {
+        LOG_ERROR("portable_storage: wrong binary format - signature mismatch");
+        return false;
+      }
+      if(pbuff->m_ver != PORTABLE_STORAGE_FORMAT_VER)
+      {
+        LOG_ERROR("portable_storage: wrong binary format - unknown format ver = " << pbuff->m_ver);
+        return false;
+      }
+      TRY_ENTRY();
+      throwable_buffer_reader buf_reader(source.data()+sizeof(storage_block_header), source.size()-sizeof(storage_block_header));
+      if (limits)
+        buf_reader.set_limits(limits->n_objects, limits->n_fields, limits->n_strings);
+      buf_reader.read(m_root);
+      return true;//TODO:
+      CATCH_ENTRY("portable_storage::load_from_binary", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    hsection portable_storage::open_section(const std::string& section_name,  hsection hparent_section, bool create_if_notexist)
+    {
+      TRY_ENTRY();
+      hparent_section = hparent_section ? hparent_section:&m_root;
+      storage_entry* pentry = find_storage_entry(section_name, hparent_section);
+      if(!pentry)
+      {
+        if(!create_if_notexist)
+          return nullptr;
+        return insert_new_section(section_name, hparent_section);
+      }
+      CHECK_AND_ASSERT(pentry , nullptr);
+      //check that section_entry we find is real "CSSection"
+      if(pentry->type() != typeid(section))
+      {
+        if(create_if_notexist)
+          *pentry = storage_entry(section());//replace
+        else
+          return nullptr;
+      }
+      return &boost::get<section>(*pentry);
+      CATCH_ENTRY("portable_storage::open_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
     template<class to_type>
     struct get_value_visitor: boost::static_visitor<void>
     {
@@ -149,6 +239,20 @@ namespace epee
       //CATCH_ENTRY("portable_storage::template<>get_value", false);
     }
     //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::get_value(const std::string& value_name, storage_entry& val, hsection hparent_section)
+    {
+      //TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
+      if(!pentry)
+        return false;
+
+      val = *pentry;
+      return true;
+      //CATCH_ENTRY("portable_storage::template<>get_value", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
     template<class t_value>
     bool portable_storage::set_value(const std::string& value_name, t_value&& v, hsection hparent_section)
     {
@@ -170,6 +274,19 @@ namespace epee
       CATCH_ENTRY("portable_storage::template<>set_value", false);
     }
     //---------------------------------------------------------------------------------------------------------------
+    inline
+    storage_entry* portable_storage::find_storage_entry(const std::string& pentry_name, hsection psection)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(psection, nullptr);
+      auto it = psection->m_entries.find(pentry_name);
+      if(it == psection->m_entries.end())
+        return nullptr;
+
+      return &it->second;
+      CATCH_ENTRY("portable_storage::find_storage_entry", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
     template<class entry_type>
     storage_entry* portable_storage::insert_new_entry_get_storage_entry(const std::string& pentry_name, hsection psection, entry_type&& entry)
     {
@@ -182,6 +299,16 @@ namespace epee
       CATCH_ENTRY("portable_storage::insert_new_entry_get_storage_entry", nullptr);
     }
     //---------------------------------------------------------------------------------------------------------------
+    inline
+    hsection portable_storage::insert_new_section(const std::string& pentry_name, hsection psection)
+    {
+      TRY_ENTRY();
+      storage_entry* pse = insert_new_entry_get_storage_entry(pentry_name, psection, section());
+      if(!pse) return nullptr;
+      return &boost::get<section>(*pse);
+      CATCH_ENTRY("portable_storage::insert_new_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
     template<class to_type>
     struct get_first_value_visitor: boost::static_visitor<bool>
     {
@@ -235,6 +362,7 @@ namespace epee
       }
     };
 
+
     template<class t_value>
     bool portable_storage::get_next_value(harray hval_array, t_value& target)
     {
@@ -292,5 +420,83 @@ namespace epee
       return true;
       CATCH_ENTRY("portable_storage::insert_next_value", false);
     }
+    //---------------------------------------------------------------------------------------------------------------
+    //sections
+    inline
+    harray portable_storage::get_first_section(const std::string& sec_name, hsection& h_child_section, hsection hparent_section)
+    {
+      TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
+      if(!pentry)
+        return nullptr;
+      if(pentry->type() != typeid(array_entry))
+        return nullptr;
+      array_entry& ar_entry = boost::get<array_entry>(*pentry);
+      if(ar_entry.type() != typeid(array_entry_t<section>))
+        return nullptr;
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
+      section* psec = sec_array.get_first_val();
+      if(!psec)
+        return nullptr;
+      h_child_section = psec;
+      return &ar_entry;
+      CATCH_ENTRY("portable_storage::get_first_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::get_next_section(harray hsec_array, hsection& h_child_section)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(hsec_array, false);
+      if(hsec_array->type() != typeid(array_entry_t<section>))
+        return false;
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
+      h_child_section = sec_array.get_next_val();
+      if(!h_child_section)
+        return false;
+      return true;
+      CATCH_ENTRY("portable_storage::get_next_section", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    harray portable_storage::insert_first_section(const std::string& sec_name, hsection& hinserted_childsection, hsection hparent_section)
+    {
+      TRY_ENTRY();
+      if(!hparent_section) hparent_section = &m_root;
+      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
+      if(!pentry)
+      {
+        pentry = insert_new_entry_get_storage_entry(sec_name, hparent_section, array_entry(array_entry_t<section>()));
+        if(!pentry)
+          return nullptr;
+      }
+      if(pentry->type() != typeid(array_entry))
+        *pentry = storage_entry(array_entry(array_entry_t<section>()));
+
+      array_entry& ar_entry = boost::get<array_entry>(*pentry);
+      if(ar_entry.type() != typeid(array_entry_t<section>))
+        ar_entry = array_entry(array_entry_t<section>());
+
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
+      hinserted_childsection = &sec_array.insert_first_val(section());
+      return &ar_entry;
+      CATCH_ENTRY("portable_storage::insert_first_section", nullptr);
+    }
+    //---------------------------------------------------------------------------------------------------------------
+    inline
+    bool portable_storage::insert_next_section(harray hsec_array, hsection& hinserted_childsection)
+    {
+      TRY_ENTRY();
+      CHECK_AND_ASSERT(hsec_array, false);
+      CHECK_AND_ASSERT_MES(hsec_array->type() == typeid(array_entry_t<section>), 
+        false, "unexpected type(not 'section') in insert_next_section, type: " << hsec_array->type().name());
+
+      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
+      hinserted_childsection = &sec_array.insert_next_value(section());
+      return true;
+      CATCH_ENTRY("portable_storage::insert_next_section", false);
+    }
+    //---------------------------------------------------------------------------------------------------------------
   }
 }

contrib/epee/include/storages/portable_storage_base.h

@@ -29,10 +29,10 @@
 #pragma once 
 
 #include <boost/variant.hpp>
+#include <boost/any.hpp>
 #include <string>
 #include <vector>
 #include <deque>
-#include <map>
 
 #define PORTABLE_STORAGE_SIGNATUREA 0x01011101
 #define PORTABLE_STORAGE_SIGNATUREB 0x01020101 // bender's nightmare 

contrib/epee/include/storages/portable_storage_from_bin.h

@@ -29,7 +29,6 @@
 #pragma once 
 
 #include "misc_language.h"
-#include "misc_log_ex.h"
 #include "portable_storage_base.h"
 #include "portable_storage_bin_utils.h"
 

contrib/epee/include/storages/portable_storage_from_json.h

@@ -26,7 +26,6 @@
 
 #pragma once
 #include <boost/lexical_cast.hpp>
-#include <boost/utility/string_ref.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include "parserse_base_utils.h"
 #include "file_io_utils.h"

contrib/epee/include/storages/portable_storage_template_helper.h

@@ -28,16 +28,12 @@
 
 #include <string>
 
-#include "byte_slice.h"
-#include "parserse_base_utils.h" /// TODO: (mj-xmr) This will be reduced in an another PR
+#include "parserse_base_utils.h"
 #include "portable_storage.h"
 #include "file_io_utils.h"
-#include "span.h"
 
 namespace epee
 {
-  class byte_stream;
-
   namespace serialization
   {
     //-----------------------------------------------------------------------------------------------------------
@@ -115,28 +111,19 @@ namespace epee
     }
     //-----------------------------------------------------------------------------------------------------------
     template<class t_struct>
-    bool store_t_to_binary(t_struct& str_in, byte_slice& binary_buff, size_t initial_buffer_size = 8192)
-    {
-      portable_storage ps;
-      str_in.store(ps);
-      return ps.store_to_binary(binary_buff, initial_buffer_size);
-    }
-    //-----------------------------------------------------------------------------------------------------------
-    template<class t_struct>
-    byte_slice store_t_to_binary(t_struct& str_in, size_t initial_buffer_size = 8192)
-    {
-      byte_slice binary_buff;
-      store_t_to_binary(str_in, binary_buff, initial_buffer_size);
-      return binary_buff;
-    }
-    //-----------------------------------------------------------------------------------------------------------
-    template<class t_struct>
-    bool store_t_to_binary(t_struct& str_in, byte_stream& binary_buff)
+    bool store_t_to_binary(t_struct& str_in, std::string& binary_buff, size_t indent = 0)
     {
       portable_storage ps;
       str_in.store(ps);
       return ps.store_to_binary(binary_buff);
     }
-
+    //-----------------------------------------------------------------------------------------------------------
+    template<class t_struct>
+    std::string store_t_to_binary(t_struct& str_in, size_t indent = 0)
+    {
+      std::string binary_buff;
+      store_t_to_binary(str_in, binary_buff, indent);
+      return binary_buff;
+    }
   }
 }

contrib/epee/include/storages/portable_storage_to_bin.h

@@ -32,7 +32,6 @@
 #include "misc_language.h"
 #include "portable_storage_base.h"
 #include "portable_storage_bin_utils.h"
-#include "misc_log_ex.h"
 
 namespace epee
 {

contrib/epee/include/storages/portable_storage_val_converters.h

@@ -28,17 +28,12 @@
 
 #pragma once
 
+#include <time.h>
 #include <boost/regex.hpp>
 
 #include "misc_language.h"
 #include "portable_storage_base.h"
-#include "parserse_base_utils.h"
 #include "warnings.h"
-#include "misc_log_ex.h"
-
-#include <boost/lexical_cast.hpp>
-#include <typeinfo>
-#include <iomanip>
 
 namespace epee
 {

contrib/epee/include/string_tools.h

@@ -24,16 +24,33 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // 
 
+
+
 #ifndef _STRING_TOOLS_H_
 #define _STRING_TOOLS_H_
 
-#include "hex.h"
-#include "mlocker.h"
+// Previously pulled in by ASIO, further cleanup still required ...
+#ifdef _WIN32
+# include <winsock2.h>
+# include <windows.h>
+#endif
 
-#include <boost/utility/string_ref.hpp>
-#include <sstream>
+#include <string.h>
+#include <locale>
+#include <cstdlib>
 #include <string>
-#include <cstdint>
+#include <type_traits>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/utility/string_ref.hpp>
+#include "misc_log_ex.h"
+#include "storages/parserse_base_utils.h"
+#include "hex.h"
+#include "memwipe.h"
+#include "mlocker.h"
+#include "span.h"
+#include "warnings.h"
+
 
 #ifndef OUT
 	#define OUT
@@ -57,28 +74,182 @@ namespace string_tools
   {
     return from_hex::to_string(res, s);
   }
-  
-  std::string get_ip_string_from_int32(uint32_t ip);
-  bool get_ip_int32_from_string(uint32_t& ip, const std::string& ip_str);
-  bool parse_peer_from_string(uint32_t& ip, uint16_t& port, const std::string& addres);
-  std::string num_to_string_fast(int64_t val);
-	
-  bool compare_no_case(const std::string& str1, const std::string& str2);
-  std::string& get_current_module_name();
-  std::string& get_current_module_folder();
-#ifdef _WIN32
-   std::string get_current_module_path();
-#endif
-  bool set_module_name_and_folder(const std::string& path_to_process_);
-  bool trim_left(std::string& str);
-  bool trim_right(std::string& str);
   //----------------------------------------------------------------------------
-  inline std::string& trim(std::string& str)
+PUSH_WARNINGS
+DISABLE_GCC_WARNING(maybe-uninitialized)
+  template<class XType>
+  inline bool get_xtype_from_string(OUT XType& val, const std::string& str_id)
   {
-    trim_left(str);
-    trim_right(str);
-    return str;
+    if (std::is_integral<XType>::value && !std::numeric_limits<XType>::is_signed && !std::is_same<XType, bool>::value)
+    {
+      for (char c : str_id)
+      {
+        if (!epee::misc_utils::parse::isdigit(c))
+          return false;
+      }
+    }
+
+    try
+    {
+      val = boost::lexical_cast<XType>(str_id);
+      return true;
+    }
+    catch(const std::exception& /*e*/)
+    {
+      //const char* pmsg = e.what();
+      return false;
+    }
+    catch(...)
+    {
+      return false;
+    }
+
+    return true;
   }
+POP_WARNINGS
+	//----------------------------------------------------------------------------
+	template<class XType>
+	inline bool xtype_to_string(const  XType& val, std::string& str)
+	{
+		try
+		{
+			str = boost::lexical_cast<std::string>(val);
+		}
+		catch(...)
+		{
+			return false;
+		}
+
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	std::string get_ip_string_from_int32(uint32_t ip);
+	//----------------------------------------------------------------------------
+	bool get_ip_int32_from_string(uint32_t& ip, const std::string& ip_str);
+  //----------------------------------------------------------------------------
+  inline bool parse_peer_from_string(uint32_t& ip, uint16_t& port, const std::string& addres)
+  {
+    //parse ip and address
+    std::string::size_type p = addres.find(':');
+    std::string ip_str, port_str;
+    if(p == std::string::npos)
+    {
+      port = 0;
+      ip_str = addres;
+    }
+    else
+    {
+      ip_str = addres.substr(0, p);
+      port_str = addres.substr(p+1, addres.size());
+    }
+
+    if(!get_ip_int32_from_string(ip, ip_str))
+    {
+      return false;
+    }
+
+    if(p != std::string::npos && !get_xtype_from_string(port, port_str))
+    {
+      return false;
+    }
+    return true;
+  }
+
+	inline std::string num_to_string_fast(int64_t val)
+	{
+		/*
+		char  buff[30] = {0};
+		i64toa_s(val, buff, sizeof(buff)-1, 10);
+		return buff;*/
+		return boost::lexical_cast<std::string>(val);
+	}
+	//----------------------------------------------------------------------------
+	template<typename T>
+	inline std::string to_string_hex(const T &val)
+	{
+		static_assert(std::is_arithmetic<T>::value, "only arithmetic types");
+		std::stringstream ss;
+		ss << std::hex << val;
+		std::string s;
+		ss >> s;
+		return s;
+	}
+	//----------------------------------------------------------------------------
+	
+	inline bool compare_no_case(const std::string& str1, const std::string& str2)
+	{
+		
+		return !boost::iequals(str1, str2);
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& get_current_module_name()
+	{
+		static std::string module_name;
+		return module_name;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& get_current_module_folder()
+	{	
+		static std::string module_folder;
+		return module_folder;
+	}
+  //----------------------------------------------------------------------------
+#ifdef _WIN32
+  inline std::string get_current_module_path()
+  {
+    char pname [5000] = {0};
+    GetModuleFileNameA( NULL, pname, sizeof(pname));
+    pname[sizeof(pname)-1] = 0; //be happy ;)
+    return pname;
+  }
+#endif
+	//----------------------------------------------------------------------------
+	inline bool set_module_name_and_folder(const std::string& path_to_process_)
+	{
+    std::string path_to_process = path_to_process_;
+#ifdef _WIN32
+    path_to_process = get_current_module_path();
+#endif 
+		std::string::size_type a = path_to_process.rfind( '\\' );
+		if(a == std::string::npos )
+		{
+			a = path_to_process.rfind( '/' );
+		}
+		if ( a != std::string::npos )
+		{	
+			get_current_module_name() = path_to_process.substr(a+1, path_to_process.size());
+			get_current_module_folder() = path_to_process.substr(0, a);
+			return true;
+		}else
+			return false;
+
+	}
+
+	//----------------------------------------------------------------------------
+	inline bool trim_left(std::string& str)
+	{
+		for(std::string::iterator it = str.begin(); it!= str.end() && isspace(static_cast<unsigned char>(*it));)
+			str.erase(str.begin());
+			
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	inline bool trim_right(std::string& str)
+	{
+
+		for(std::string::reverse_iterator it = str.rbegin(); it!= str.rend() && isspace(static_cast<unsigned char>(*it));)
+			str.erase( --((it++).base()));
+
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& trim(std::string& str)
+	{
+
+		trim_left(str);
+		trim_right(str);
+		return str;
+	}
   //----------------------------------------------------------------------------
   inline std::string trim(const std::string& str_)
   {
@@ -87,8 +258,18 @@ namespace string_tools
     trim_right(str);
     return str;
   }
-  std::string pad_string(std::string s, size_t n, char c = ' ', bool prepend = false);
-  
+  //----------------------------------------------------------------------------
+  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)
@@ -115,25 +296,64 @@ namespace string_tools
   {
     return hex_to_pod(hex_str, unwrap(s));
   }
-  	//----------------------------------------------------------------------------
-	template<typename T>
-	inline std::string to_string_hex(const T &val)
-	{
-		static_assert(std::is_arithmetic<T>::value, "only arithmetic types");
-		std::stringstream ss;
-		ss << std::hex << val;
-		std::string s;
-		ss >> s;
-		return s;
-	}
-  
+  //----------------------------------------------------------------------------
   bool validate_hex(uint64_t length, const std::string& str);
-  std::string get_extension(const std::string& str);
-  std::string cut_off_extension(const std::string& str);
-  
+  //----------------------------------------------------------------------------
+	inline std::string get_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return res;
+		
+		res = str.substr(pos+1, str.size()-pos);
+		return res;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string cut_off_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return str;
+
+		res = str.substr(0, pos);
+		return res;
+	}
+  //----------------------------------------------------------------------------
 #ifdef _WIN32
-   std::wstring utf8_to_utf16(const std::string& str);
-   std::string utf16_to_utf8(const std::wstring& wstr);
+  inline std::wstring utf8_to_utf16(const std::string& str)
+  {
+    if (str.empty())
+      return {};
+    int wstr_size = MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), NULL, 0);
+    if (wstr_size == 0)
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    std::wstring wstr(wstr_size, wchar_t{});
+    if (!MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), &wstr[0], wstr_size))
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    return wstr;
+  }
+  inline std::string utf16_to_utf8(const std::wstring& wstr)
+  {
+    if (wstr.empty())
+      return {};
+    int str_size = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), NULL, 0, NULL, NULL);
+    if (str_size == 0)
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    std::string str(str_size, char{});
+    if (!WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), &str[0], str_size, NULL, NULL))
+    {
+      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
+    }
+    return str;
+  }
 #endif
 }
 }

contrib/epee/include/string_tools_lexical.h

@@ -1,91 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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.
-// 
-
-#ifndef _STRING_TOOLS_LEXICAL_H_
-#define _STRING_TOOLS_LEXICAL_H_
-
-#include "warnings.h"
-#include "storages/parserse_base_utils.h"
-#include <boost/lexical_cast.hpp> // A heavy header, that was extracted from the rest
-
-#ifndef OUT
-	#define OUT
-#endif
-
-namespace epee
-{
-namespace string_tools
-{
-PUSH_WARNINGS
-DISABLE_GCC_WARNING(maybe-uninitialized)
-    template<class XType>
-    inline bool get_xtype_from_string(OUT XType& val, const std::string& str_id)
-    {
-        if (std::is_integral<XType>::value && !std::numeric_limits<XType>::is_signed && !std::is_same<XType, bool>::value)
-        {
-            for (char c : str_id)
-            {
-                if (!epee::misc_utils::parse::isdigit(c))
-                    return false;
-            }
-        }
-
-        try
-        {
-            val = boost::lexical_cast<XType>(str_id);
-            return true;
-        }
-        catch(const std::exception& /*e*/)
-        {
-            //const char* pmsg = e.what();
-            return false;
-        }
-        catch(...)
-        {
-            return false;
-        }
-
-        return true;
-    }
-POP_WARNINGS
-
-    template<class XType>
-    inline bool xtype_to_string(const  XType& val, std::string& str)
-    {
-        try
-        {
-            str = boost::lexical_cast<std::string>(val);
-        }
-        catch(...)
-        {
-            return false;
-        }
-
-        return true;
-    }
-}
-}
-#endif //_STRING_TOOLS_LEXICAL_H_

contrib/epee/include/tiny_ini.h

@@ -28,6 +28,8 @@
 #ifndef _TINY_INI_H_
 #define _TINY_INI_H_
 
+#include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
 #include "string_tools.h"
 
 namespace epee
@@ -35,8 +37,20 @@ namespace epee
 namespace tiny_ini
 {
 
-	bool get_param_value(const std::string& param_name, const std::string& ini_entry, std::string& res);
-	inline std::string get_param_value(const std::string& param_name, const std::string& ini_entry)
+	inline 
+		bool get_param_value(const std::string& param_name, const std::string& ini_entry, std::string& res)
+	{
+		std::string expr_str = std::string() + "^("+ param_name +") *=(.*?)$";
+		const boost::regex match_ini_entry( expr_str, boost::regex::icase | boost::regex::normal); 
+		boost::smatch result;	
+		if(!boost::regex_search(ini_entry, result, match_ini_entry, boost::match_default))
+			return false;
+		res = result[2];
+		string_tools::trim(res);
+		return true;
+	}
+	inline 
+		std::string get_param_value(const std::string& param_name, const std::string& ini_entry)
 	{
 		std::string buff;
 		get_param_value(param_name, ini_entry, buff);

contrib/epee/src/CMakeLists.txt

@@ -26,25 +26,13 @@
 # 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.
 
-set(EPEE_INCLUDE_DIR_BASE "${CMAKE_CURRENT_SOURCE_DIR}/../include")
 
-# Add headers to the file list, to be able to search for them and autosave in IDEs.
-monero_find_all_headers(EPEE_HEADERS_PUBLIC "${EPEE_INCLUDE_DIR_BASE}")
-
-monero_add_library(epee byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_client.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp parserse_base_utils.cpp
+add_library(epee byte_slice.cpp byte_stream.cpp hex.cpp abstract_http_client.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp
     wipeable_string.cpp levin_base.cpp memwipe.c connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp mlocker.cpp buffer.cpp net_ssl.cpp
-    int-util.cpp portable_storage.cpp
-    misc_language.cpp
-    misc_os_dependent.cpp
-    file_io_utils.cpp
-    net_parse_helpers.cpp
-    http_base.cpp
-    tiny_ini.cpp
-    ${EPEE_HEADERS_PUBLIC}
-    )
+    int-util.cpp)
 
 if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
-  monero_add_library(epee_readline readline_buffer.cpp)
+  add_library(epee_readline STATIC readline_buffer.cpp)
 endif()
 
 if(HAVE_C11)
@@ -73,6 +61,7 @@ target_link_libraries(epee
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_THREAD_LIBRARY}
     ${Boost_REGEX_LIBRARY}
+    ${Boost_SYSTEM_LIBRARY}
     ${OPENSSL_LIBRARIES}
   PRIVATE
     ${EXTRA_LIBRARIES})
@@ -81,6 +70,7 @@ if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
   target_link_libraries(epee_readline
     PUBLIC
       easylogging
+      ${Boost_SYSTEM_LIBRARY}
     PRIVATE
     ${GNU_READLINE_LIBRARY})
 endif()

contrib/epee/src/abstract_http_client.cpp

@@ -1,7 +1,6 @@
 #include "net/abstract_http_client.h"
 #include "net/http_base.h"
 #include "net/net_parse_helpers.h"
-#include "misc_log_ex.h"
 
 #undef MONERO_DEFAULT_LOG_CATEGORY
 #define MONERO_DEFAULT_LOG_CATEGORY "net.http"

contrib/epee/src/buffer.cpp

@@ -26,6 +26,7 @@
 // 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 <limits>
 #include <string.h>
 #include "net/buffer.h"
 

contrib/epee/src/byte_slice.cpp

@@ -36,11 +36,6 @@
 #include "byte_slice.h"
 #include "byte_stream.h"
 
-namespace
-{
-  const std::size_t page_size = 4096;
-}
-
 namespace epee
 {
   struct byte_slice_data
@@ -151,7 +146,7 @@ namespace epee
     : byte_slice()
   {
     std::size_t space_needed = 0;
-    for (const auto& source : sources)
+    for (const auto source : sources)
       space_needed += source.size();
 
     if (space_needed)
@@ -160,7 +155,7 @@ namespace epee
       span<std::uint8_t> out{reinterpret_cast<std::uint8_t*>(storage.get() + 1), space_needed};
       portion_ = {out.data(), out.size()};
 
-      for (const auto& source : sources)
+      for (const auto source : sources)
       {
         std::memcpy(out.data(), source.data(), source.size());
         if (out.remove_prefix(source.size()) < source.size())
@@ -178,27 +173,16 @@ namespace epee
     : byte_slice(adapt_buffer{}, std::move(buffer))
   {}
 
-  byte_slice::byte_slice(byte_stream&& stream, const bool shrink)
+  byte_slice::byte_slice(byte_stream&& stream) noexcept
     : storage_(nullptr), portion_(stream.data(), stream.size())
   {
-    if (portion_.size())
+    if (stream.size())
     {
-      byte_buffer buf;
-      if (shrink && page_size <= stream.available())
-      {
-          buf = byte_buffer_resize(stream.take_buffer(), portion_.size());
-          if (!buf)
-            throw std::bad_alloc{};
-          portion_ = {buf.get(), portion_.size()};
-      }
-      else // no need to shrink buffer
-        buf = stream.take_buffer();
-
-      std::uint8_t* const data = buf.release() - sizeof(raw_byte_slice);
+      std::uint8_t* const data = stream.take_buffer().release() - sizeof(raw_byte_slice);
       new (data) raw_byte_slice{};
       storage_.reset(reinterpret_cast<raw_byte_slice*>(data));
     }
-    else // empty stream
+    else
       portion_ = nullptr;
   }
 

contrib/epee/src/byte_stream.cpp

@@ -34,11 +34,6 @@
 
 #include <iostream>
 
-namespace
-{
-  constexpr const std::size_t minimum_increase = 4096;
-}
-
 namespace epee
 {
   void byte_stream::overflow(const std::size_t requested)
@@ -51,7 +46,7 @@ namespace epee
 
     const std::size_t len = size();
     const std::size_t cap = capacity();
-    const std::size_t increase = std::max(std::max(need, cap), minimum_increase);
+    const std::size_t increase = std::max(need, increase_size());
 
     next_write_ = nullptr;
     end_ = nullptr;
@@ -67,7 +62,8 @@ namespace epee
   byte_stream::byte_stream(byte_stream&& rhs) noexcept
     : buffer_(std::move(rhs.buffer_)),
       next_write_(rhs.next_write_),
-      end_(rhs.end_)
+      end_(rhs.end_),
+      increase_size_(rhs.increase_size_)
   {
     rhs.next_write_ = nullptr;
     rhs.end_ = nullptr;
@@ -80,6 +76,7 @@ namespace epee
       buffer_ = std::move(rhs.buffer_);
       next_write_ = rhs.next_write_;
       end_ = rhs.end_;
+      increase_size_ = rhs.increase_size_;
       rhs.next_write_ = nullptr;
       rhs.end_ = nullptr;
     }

contrib/epee/src/file_io_utils.cpp

@@ -1,231 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "file_io_utils.h"
-
-#include <fstream>
-#include <boost/filesystem/path.hpp>
-#include <boost/filesystem/operations.hpp>
-#ifdef WIN32
-#include <windows.h>
-#include "string_tools.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
-{
-namespace file_io_utils
-{
- 
-	bool is_file_exist(const std::string& path)
-	{
-		boost::filesystem::path p(path);
-		return boost::filesystem::exists(p);
-	}
-
-
-	bool save_string_to_file(const std::string& path_to_file, const std::string& str)
-	{
-#ifdef WIN32
-                std::wstring wide_path;
-                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
-                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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;
-			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
-			fstream << str;
-			fstream.close();
-			return true;
-		}
-
-		catch(...)
-		{
-			return false;
-		}
-#endif
-	}
-
-
-	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);
-		if(!ec)
-			return true;
-		else
-			return false;
-	}
-
-
-	bool set_file_time(const std::string& path_to_file, const time_t& ft)
-	{
-		boost::system::error_code ec;
-		boost::filesystem::last_write_time(boost::filesystem::path(path_to_file), ft, ec);
-		if(!ec)
-			return true;
-		else
-			return false;
-	}
-
-
-
-	bool load_file_to_string(const std::string& path_to_file, std::string& target_str, size_t max_size)
-	{
-#ifdef WIN32
-                std::wstring wide_path;
-                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
-                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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) || (uint64_t)file_size > (uint64_t)max_size) {
-                    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;
-			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::in | std::ios::ate);
-
-			std::ifstream::pos_type file_size = fstream.tellg();
-			
-			if((uint64_t)file_size > (uint64_t)max_size) // ensure a large domain for comparison, and negative -> too large
-				return false;//don't go crazy
-			size_t file_size_t = static_cast<size_t>(file_size);
-
-			target_str.resize(file_size_t);
-
-			fstream.seekg (0, std::ios::beg);
-			fstream.read((char*)target_str.data(), target_str.size());
-			fstream.close();
-			return true;
-		}
-
-		catch(...)
-		{
-			return false;
-		}
-#endif
-	}
-
-
-	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;
-			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-			fstream.open(path_to_file.c_str(), std::ios_base::binary | std::ios_base::out | std::ios_base::app);
-			fstream << str;
-			fstream.close();
-			return true;
-		}
-
-		catch(...)
-		{
-			return false;
-		}
-	}
-
-
-	bool get_file_size(const std::string& path_to_file, uint64_t &size)
-	{
-#ifdef WIN32
-                std::wstring wide_path;
-                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
-                HANDLE file_handle = CreateFileW(wide_path.c_str(), 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
-	}
-
-}
-}

contrib/epee/src/http_base.cpp

@@ -1,71 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "net/http_base.h"
-#include "memwipe.h"
-#include "string_tools.h"
-
-#include <boost/regex.hpp>
-#include <string>
-#include <utility>
-
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "net.http"
-
-namespace epee
-{
-namespace net_utils
-{
-namespace http
-{
-    std::string get_value_from_fields_list(const std::string& param_name, const net_utils::http::fields_list& fields)
-    {
-        fields_list::const_iterator it = fields.begin();
-        for(; it != fields.end(); it++)
-            if(!string_tools::compare_no_case(param_name, it->first))
-                break;
-
-        if(it==fields.end())
-            return std::string();
-
-        return it->second;
-    }
-
-    std::string get_value_from_uri_line(const std::string& param_name, const std::string& uri)
-    {
-        std::string buff = "([\\?|&])";
-        buff += param_name + "=([^&]*)";
-        boost::regex match_param(buff.c_str(), boost::regex::icase | boost::regex::normal);
-        boost::smatch	result;
-        if(boost::regex_search(uri, result, match_param, boost::match_default) && result[0].matched) 
-        {
-            return result[2];
-        }
-        return std::string();
-    }
-}
-}
-}

contrib/epee/src/levin_base.cpp

@@ -34,25 +34,6 @@ namespace epee
 {
 namespace levin
 {
-  message_writer::message_writer(const std::size_t reserve)
-    : buffer()
-  {
-    buffer.reserve(reserve);
-    buffer.put_n(0, sizeof(header));
-  }
-
-  byte_slice message_writer::finalize(const uint32_t command, const uint32_t flags, const uint32_t return_code, const bool expect_response)
-  {
-    if (buffer.size() < sizeof(header))
-      throw std::runtime_error{"levin_writer::finalize already called"};
-
-    header head = make_header(command, payload_size(), flags, expect_response);
-    head.m_return_code = SWAP32LE(return_code);
-
-    std::memcpy(buffer.tellp() - buffer.size(), std::addressof(head), sizeof(head));
-    return byte_slice{std::move(buffer)};
-  }
-
   bucket_head2 make_header(uint32_t command, uint64_t msg_size, uint32_t flags, bool expect_response) noexcept
   {
     bucket_head2 head = {0};
@@ -66,6 +47,12 @@ namespace levin
     return head;
   }
 
+  byte_slice make_notify(int command, epee::span<const std::uint8_t> payload)
+  {
+    const bucket_head2 head = make_header(command, payload.size(), LEVIN_PACKET_REQUEST, false);
+    return byte_slice{epee::as_byte_span(head), payload};
+  }
+
   byte_slice make_noise_notify(const std::size_t noise_bytes)
   {
     static constexpr const std::uint32_t flags =
@@ -81,40 +68,46 @@ namespace levin
     return byte_slice{std::move(buffer)};
   }
 
-  byte_slice make_fragmented_notify(const std::size_t noise_size, const int command, message_writer message)
+  byte_slice make_fragmented_notify(const byte_slice& noise_message, int command, epee::span<const std::uint8_t> payload)
   {
+    const size_t noise_size = noise_message.size();
     if (noise_size < sizeof(bucket_head2) * 2)
       return nullptr;
 
-    if (message.buffer.size() <= noise_size)
+    if (payload.size() <= noise_size - sizeof(bucket_head2))
     {
       /* The entire message can be sent at once, and the levin binary parser
          will ignore extra bytes. So just pad with zeroes and otherwise send
          a "normal", not fragmented message. */
+      const size_t padding = noise_size - sizeof(bucket_head2) - payload.size();
+      const span<const uint8_t> padding_bytes{noise_message.end() - padding, padding};
 
-      message.buffer.put_n(0, noise_size - message.buffer.size());
-      return message.finalize_notify(command);
+      const bucket_head2 head = make_header(command, noise_size - sizeof(bucket_head2), LEVIN_PACKET_REQUEST, false);
+      return byte_slice{as_byte_span(head), payload, padding_bytes};
     }
 
     // fragment message
-    const byte_slice payload_bytes = message.finalize_notify(command);
-    span<const std::uint8_t> payload = to_span(payload_bytes);
-
     const size_t payload_space = noise_size - sizeof(bucket_head2);
     const size_t expected_fragments = ((payload.size() - 2) / payload_space) + 1;
 
-    byte_stream buffer{};
-    buffer.reserve(expected_fragments * noise_size);
+    std::string buffer{};
+    buffer.reserve((expected_fragments + 1) * noise_size); // +1 here overselects for internal bucket_head2 value
 
-    bucket_head2 head = make_header(0, payload_space, LEVIN_PACKET_BEGIN, false);
-    buffer.write(as_byte_span(head));
+    bucket_head2 head = make_header(0, noise_size - sizeof(bucket_head2), LEVIN_PACKET_BEGIN, false);
+    buffer.append(reinterpret_cast<const char*>(&head), sizeof(head));
 
-    // internal levin header is in payload already
+    head.m_command = command;
+    head.m_flags = LEVIN_PACKET_REQUEST;
+    head.m_cb = payload.size();
+    buffer.append(reinterpret_cast<const char*>(&head), sizeof(head));
 
-    size_t copy_size = payload.remove_prefix(payload_space);
-    buffer.write(payload.data() - copy_size, copy_size);
+    size_t copy_size = payload.remove_prefix(payload_space - sizeof(bucket_head2));
+    buffer.append(reinterpret_cast<const char*>(payload.data()) - copy_size, copy_size);
 
+    head.m_command = 0;
     head.m_flags = 0;
+    head.m_cb = noise_size - sizeof(bucket_head2);
+
     while (!payload.empty())
     {
       copy_size = payload.remove_prefix(payload_space);
@@ -122,12 +115,12 @@ namespace levin
       if (payload.empty())
         head.m_flags = LEVIN_PACKET_END;
 
-      buffer.write(as_byte_span(head));
-      buffer.write(payload.data() - copy_size, copy_size);
+      buffer.append(reinterpret_cast<const char*>(&head), sizeof(head));
+      buffer.append(reinterpret_cast<const char*>(payload.data()) - copy_size, copy_size);
     }
 
     const size_t padding = noise_size - copy_size - sizeof(bucket_head2);
-    buffer.put_n(0, padding);
+    buffer.append(reinterpret_cast<const char*>(noise_message.end()) - padding, padding);
 
     return byte_slice{std::move(buffer)};
   }

contrib/epee/src/misc_language.cpp

@@ -1,44 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "misc_language.h"
-
-#include <boost/thread.hpp>
-
-namespace epee
-{
-namespace misc_utils
-{
-	bool sleep_no_w(long ms )
-	{
-		boost::this_thread::sleep( 
-			boost::get_system_time() + 
-			boost::posix_time::milliseconds( std::max<long>(ms,0) ) );
-		
-		return true;
-	}
-}
-}

contrib/epee/src/misc_os_dependent.cpp

@@ -1,44 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "misc_os_dependent.h"
-#include <boost/lexical_cast.hpp>
-
-namespace epee
-{
-namespace misc_utils
-{
-    // TODO: (vtnerd) This function is weird since boost::this_thread::get_id() exists but returns a different value.    
-	std::string get_thread_string_id()
-	{
-#if defined(_WIN32)
-		return boost::lexical_cast<std::string>(GetCurrentThreadId());
-#elif defined(__GNUC__)  
-		return boost::lexical_cast<std::string>(pthread_self());
-#endif
-	}
-}
-}

contrib/epee/src/net_parse_helpers.cpp

@@ -1,206 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "net/net_parse_helpers.h"
-#include "net/http_base.h"
-#include "misc_log_ex.h"
-#include "reg_exp_definer.h"
-#include <boost/lexical_cast.hpp>
-
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "net"
-
-namespace epee
-{
-namespace net_utils
-{
-
-  static bool parse_uri_query(const std::string& query, std::list<std::pair<std::string, std::string> >& params)
-  { 
-    enum state
-    {
-      st_param_name, 
-      st_param_val
-    };
-    state st = st_param_name;
-    std::string::const_iterator start_it = query.begin();
-    std::pair<std::string, std::string> e;
-    for(std::string::const_iterator it = query.begin(); it != query.end(); it++)
-    {
-      switch(st)
-      {
-      case st_param_name:
-        if(*it == '=')
-        {
-          e.first.assign(start_it, it);
-          start_it = it;++start_it;
-          st = st_param_val;
-        }
-        break;
-      case st_param_val:
-        if(*it == '&')
-        {
-          e.second.assign(start_it, it);
-          start_it = it;++start_it;
-          params.push_back(e);
-          e.first.clear();e.second.clear();
-          st = st_param_name;
-        }
-        break;
-      default:
-        LOG_ERROR("Unknown state " << (int)st);
-        return false;
-      }
-    }
-    if(st == st_param_name)
-    {
-      if(start_it != query.end())
-      {
-        e.first.assign(start_it, query.end());
-        params.push_back(e);
-      }
-    }else
-    {
-      if(start_it != query.end())
-        e.second.assign(start_it, query.end());
-
-      if(e.first.size())
-        params.push_back(e);
-    }
-    return true;
-  }
-  
-  bool parse_uri(const std::string uri, http::uri_content& content)
-  {
-
-    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
-    content.m_query_params.clear();
-    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))
-    {
-      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
-      content.m_path = uri;
-      return true;
-    }
-    if(result[1].matched)
-    {
-      content.m_path = result[1];
-    }
-    if(result[3].matched)
-    {
-      content.m_query = result[3];
-    }
-    if(result[5].matched)
-    {
-      content.m_fragment = result[5];
-    }
-    if(content.m_query.size())
-    {
-      parse_uri_query(content.m_query, content.m_query_params);
-    }
-    return true;
-  }
-
-  bool parse_url_ipv6(const std::string url_str, http::url_content& content)
-  {
-    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^(([^:]*?)://)?(\\[(.*)\\](:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
-    //                                     12            3   4      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))
-    {
-      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
-      //content.m_path = uri;
-      return false;
-    }
-    if(result[2].matched)
-    {
-      content.schema = result[2];
-    }
-    if(result[4].matched)
-    {
-      content.host = result[4];
-    }
-    else  // if host not matched, matching should be considered failed
-    {
-      return false;
-    }
-    if(result[6].matched)
-    {
-      content.port = boost::lexical_cast<uint64_t>(result[6]);
-    }
-    if(result[7].matched)
-    {
-      content.uri = result[7];
-      return parse_uri(result[7], content.m_uri_content);
-    }
-
-    return true;
-  }
-
-  bool parse_url(const std::string url_str, http::url_content& content)
-  {
-
-    if (parse_url_ipv6(url_str, content)) return true;
-
-    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
-    //STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
-    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^(([^:]*?)://)?(([^/:]*)(:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
-    //                                     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))
-    {
-      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
-      //content.m_path = uri;
-      return true;
-    }
-    if(result[2].matched)
-    {
-      content.schema = result[2];
-    }
-    if(result[4].matched)
-    {
-      content.host = result[4];
-    }
-    if(result[6].matched)
-    {
-      content.port = boost::lexical_cast<uint64_t>(result[6]);
-    }
-    if(result[7].matched)
-    {
-      content.uri = result[7];
-      return parse_uri(result[7], content.m_uri_content);
-    }
-    
-    return true;
-  }
-
-}
-}

contrib/epee/src/net_ssl.cpp

@@ -29,8 +29,6 @@
 #include <string.h>
 #include <thread>
 #include <boost/asio/ssl.hpp>
-#include <boost/cerrno.hpp>
-#include <boost/filesystem/operations.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <openssl/ssl.h>
 #include <openssl/pem.h>
@@ -569,51 +567,6 @@ bool ssl_support_from_string(ssl_support_t &ssl, boost::string_ref s)
   return true;
 }
 
-boost::system::error_code store_ssl_keys(boost::asio::ssl::context& ssl, const boost::filesystem::path& base)
-{
-  EVP_PKEY* ssl_key = nullptr;
-  X509* ssl_cert = nullptr;
-  const auto ctx = ssl.native_handle();
-  CHECK_AND_ASSERT_MES(ctx, boost::system::error_code(EINVAL, boost::system::system_category()), "Context is null");
-  CHECK_AND_ASSERT_MES(base.has_filename(), boost::system::error_code(EINVAL, boost::system::system_category()), "Need filename");
-  if (!(ssl_key = SSL_CTX_get0_privatekey(ctx)) || !(ssl_cert = SSL_CTX_get0_certificate(ctx)))
-    return {EINVAL, boost::system::system_category()};
-
-  using file_closer = int(std::FILE*);
-  boost::system::error_code error{};
-  std::unique_ptr<std::FILE, file_closer*> file{nullptr, std::fclose};
-
-  // write key file unencrypted
-  {
-    const boost::filesystem::path key_file{base.string() + ".key"};
-    file.reset(std::fopen(key_file.string().c_str(), "wb"));
-    if (!file)
-      return {errno, boost::system::system_category()};
-    boost::filesystem::permissions(key_file, boost::filesystem::owner_read, error);
-    if (error)
-      return error;
-    if (!PEM_write_PrivateKey(file.get(), ssl_key, nullptr, nullptr, 0, nullptr, nullptr))
-      return boost::asio::error::ssl_errors(ERR_get_error());
-    if (std::fclose(file.release()) != 0)
-      return {errno, boost::system::system_category()};
-  }
-
-  // write certificate file in standard SSL X.509 unencrypted
-  const boost::filesystem::path cert_file{base.string() + ".crt"};
-  file.reset(std::fopen(cert_file.string().c_str(), "wb"));
-  if (!file)
-    return {errno, boost::system::system_category()};
-  const auto cert_perms = (boost::filesystem::owner_read | boost::filesystem::group_read | boost::filesystem::others_read);
-  boost::filesystem::permissions(cert_file, cert_perms, error);
-  if (error)
-    return error;
-  if (!PEM_write_X509(file.get(), ssl_cert))
-    return boost::asio::error::ssl_errors(ERR_get_error());
-  if (std::fclose(file.release()) != 0)
-    return {errno, boost::system::system_category()};
-  return error;
-}
-
 } // namespace
 } // namespace
 

contrib/epee/src/parserse_base_utils.cpp

@@ -1,282 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "storages/parserse_base_utils.h"
-
-#include "misc_log_ex.h"
-#include <boost/utility/string_ref.hpp>
-#include <algorithm>
-
-#undef MONERO_DEFAULT_LOG_CATEGORY
-#define MONERO_DEFAULT_LOG_CATEGORY "serialization"
-
-namespace epee 
-{
-namespace misc_utils
-{
-  namespace parse
-  {
-    std::string transform_to_escape_sequence(const std::string& src)
-    {
-      static const char escaped[] = "\b\f\n\r\t\v\"\\/";
-      std::string::const_iterator it = std::find_first_of(src.begin(), src.end(), escaped, escaped + sizeof(escaped));
-      if (it == src.end())
-        return src;
-
-      std::string res;
-      res.reserve(2 * src.size());
-      res.assign(src.begin(), it);
-      for(; it!=src.end(); ++it)
-      {
-        switch(*it)
-        {
-        case '\b':  //Backspace (ascii code 08)
-          res+="\\b"; break;
-        case '\f':  //Form feed (ascii code 0C)
-          res+="\\f"; break;
-        case '\n':  //New line
-          res+="\\n"; break;
-        case '\r':  //Carriage return
-          res+="\\r"; break;
-        case '\t':  //Tab
-          res+="\\t"; break;
-        case '\v':  //Vertical tab
-          res+="\\v"; break;
-        //case '\'':  //Apostrophe or single quote
-        //  res+="\\'"; break;
-        case '"':  //Double quote
-          res+="\\\""; break;
-        case '\\':  //Backslash caracter
-          res+="\\\\"; break;
-        case '/':  //Backslash caracter
-          res+="\\/"; break;
-        default:
-          res.push_back(*it);
-        }
-      }
-      return res;
-    }
-    /*
-      
-      \b  Backspace (ascii code 08)
-      \f  Form feed (ascii code 0C)
-      \n  New line
-      \r  Carriage return
-      \t  Tab
-      \v  Vertical tab
-      \'  Apostrophe or single quote
-      \"  Double quote
-      \\  Backslash character
-
-      */
-      void match_string2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
-      {
-        bool escape_mode = false;
-        std::string::const_iterator it = star_end_string;
-        ++it;
-        std::string::const_iterator fi = it;
-        while (fi != buf_end && ((lut[(uint8_t)*fi] & 32)) == 0)
-          ++fi;
-        val.assign(it, fi);
-        it = fi;
-        for(;it != buf_end;it++)
-        {
-          if(escape_mode/*prev_ch == '\\'*/)
-          {
-            switch(*it)
-            {
-            case 'b':  //Backspace (ascii code 08)
-              val.push_back(0x08);break;
-            case 'f':  //Form feed (ascii code 0C)
-              val.push_back(0x0C);break;
-            case 'n':  //New line
-              val.push_back('\n');break;
-            case 'r':  //Carriage return
-              val.push_back('\r');break;
-            case 't':  //Tab
-              val.push_back('\t');break;
-            case 'v':  //Vertical tab
-              val.push_back('\v');break;
-            case '\'':  //Apostrophe or single quote
-              val.push_back('\'');break;
-            case '"':  //Double quote
-              val.push_back('"');break;
-            case '\\':  //Backslash character
-              val.push_back('\\');break;
-            case '/':  //Slash character
-              val.push_back('/');break;
-            case 'u':  //Unicode code point
-              if (buf_end - it < 4)
-              {
-                ASSERT_MES_AND_THROW("Invalid Unicode escape sequence");
-              }
-              else
-              {
-                uint32_t dst = 0;
-                for (int i = 0; i < 4; ++i)
-                {
-                  const unsigned char tmp = isx[(unsigned char)*++it];
-                  CHECK_AND_ASSERT_THROW_MES(tmp != 0xff, "Bad Unicode encoding");
-                  dst = dst << 4 | tmp;
-                }
-                // encode as UTF-8
-                if (dst <= 0x7f)
-                {
-                  val.push_back(dst);
-                }
-                else if (dst <= 0x7ff)
-                {
-                  val.push_back(0xc0 | (dst >> 6));
-                  val.push_back(0x80 | (dst & 0x3f));
-                }
-                else if (dst <= 0xffff)
-                {
-                  val.push_back(0xe0 | (dst >> 12));
-                  val.push_back(0x80 | ((dst >> 6) & 0x3f));
-                  val.push_back(0x80 | (dst & 0x3f));
-                }
-                else
-                {
-                  ASSERT_MES_AND_THROW("Unicode code point is out or range");
-                }
-              }
-              break;
-            default:
-              val.push_back(*it);
-              LOG_PRINT_L0("Unknown escape sequence :\"\\" << *it << "\"");
-            }
-            escape_mode = false;
-          }else if(*it == '"')
-          {
-            star_end_string = it;
-            return;
-          }else if(*it == '\\')
-          {
-            escape_mode = true;
-          }          
-          else
-          {
-            val.push_back(*it); 
-          }
-        }
-        ASSERT_MES_AND_THROW("Failed to match string in json entry: " << std::string(star_end_string, buf_end));
-      }
-      void match_number2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val, bool& is_float_val, bool& is_signed_val)
-      {
-        val.clear();
-        uint8_t float_flag = 0;
-        is_signed_val = false;
-        size_t chars = 0;
-        std::string::const_iterator it = star_end_string;
-        if (it != buf_end && *it == '-')
-        {
-          is_signed_val = true;
-          ++chars;
-          ++it;
-        }
-        for(;it != buf_end;it++)
-        {
-          const uint8_t flags = lut[(uint8_t)*it];
-          if (flags & 16)
-          {
-            float_flag |= flags;
-            ++chars;
-          }
-          else
-          {
-            val = boost::string_ref(&*star_end_string, chars);
-            if(val.size())
-            {
-              star_end_string = --it;
-              is_float_val = !!(float_flag & 2);
-              return;
-            }
-            else 
-              ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
-          }
-        }
-        ASSERT_MES_AND_THROW("wrong number in json entry: " << std::string(star_end_string, buf_end));
-      }
-      void match_word2(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, boost::string_ref& val)
-      {
-        val.clear();
-
-        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
-        {
-          if (!(lut[(uint8_t)*it] & 4))
-          {
-            val = boost::string_ref(&*star_end_string, std::distance(star_end_string, it));
-            if(val.size())
-            {
-              star_end_string = --it;
-              return;
-            }else 
-              ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
-          }
-        }
-        ASSERT_MES_AND_THROW("failed to match word number in json entry: " << std::string(star_end_string, buf_end));
-      }
-      bool match_word_with_extrasymb(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string& val)
-      {
-        val.clear();
-
-        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
-        {
-          if(!isalnum(*it) && *it != '-' && *it != '_')
-          {
-            val.assign(star_end_string, it);
-            if(val.size())
-            {
-              star_end_string = --it;
-              return true;
-            }else 
-              return false;
-          }
-        }
-        return false;
-      }
-      bool match_word_til_equal_mark(std::string::const_iterator& star_end_string, std::string::const_iterator buf_end, std::string::const_iterator& word_end)
-      {
-        word_end = star_end_string;
-
-        for(std::string::const_iterator it = star_end_string;it != buf_end;it++)
-        {
-          if(isspace(*it))
-          {
-
-            continue;
-          }else if( *it == '=' )
-          {            
-            star_end_string = it;
-            word_end = it;
-            return true;
-          }
-        }
-        return false;
-      }
-  }
-}
-}

contrib/epee/src/portable_storage.cpp

@@ -1,247 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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 "byte_slice.h"
-#include "byte_stream.h"
-#include "misc_log_ex.h"
-#include "span.h"
-#include "storages/portable_storage.h"
-#include "storages/portable_storage_to_json.h"
-#include "storages/portable_storage_from_json.h"
-#include "storages/portable_storage_to_bin.h"
-#include "storages/portable_storage_from_bin.h"
-
-#include <boost/utility/string_ref.hpp>
-
-#include <string>
-#include <sstream>
-
-namespace epee
-{
-namespace serialization
-{
-  bool portable_storage::store_to_binary(byte_slice& target, const std::size_t initial_buffer_size)
-  {
-    TRY_ENTRY();
-    byte_stream ss;
-    ss.reserve(initial_buffer_size);
-    store_to_binary(ss);
-    target = epee::byte_slice{std::move(ss)};
-    return true;
-    CATCH_ENTRY("portable_storage::store_to_binary", false);
-  }
-
-  bool portable_storage::store_to_binary(byte_stream& ss)
-  {
-    TRY_ENTRY();
-    storage_block_header sbh{};
-    sbh.m_signature_a = SWAP32LE(PORTABLE_STORAGE_SIGNATUREA);
-    sbh.m_signature_b = SWAP32LE(PORTABLE_STORAGE_SIGNATUREB);
-    sbh.m_ver = PORTABLE_STORAGE_FORMAT_VER;
-    ss.write(epee::as_byte_span(sbh));
-    pack_entry_to_buff(ss, m_root);
-    return true;
-    CATCH_ENTRY("portable_storage::store_to_binary", false);
-  }
-
-    bool portable_storage::dump_as_json(std::string& buff, size_t indent, bool insert_newlines)
-    {
-      TRY_ENTRY();
-      std::stringstream ss;
-      epee::serialization::dump_as_json(ss, m_root, indent, insert_newlines);
-      buff = ss.str();
-      return true;
-      CATCH_ENTRY("portable_storage::dump_as_json", false)
-    }
-
-    bool portable_storage::load_from_json(const std::string& source)
-    {
-      TRY_ENTRY();
-      return json::load_from_json(source, *this);
-      CATCH_ENTRY("portable_storage::load_from_json", false)
-    }
-
-    bool portable_storage::load_from_binary(const epee::span<const uint8_t> source, const limits_t *limits)
-    {
-      m_root.m_entries.clear();
-      if(source.size() < sizeof(storage_block_header))
-      {
-        LOG_ERROR("portable_storage: wrong binary format, packet size = " << source.size() << " less than expected sizeof(storage_block_header)=" << sizeof(storage_block_header));
-        return false;
-      }
-      storage_block_header* pbuff = (storage_block_header*)source.data();
-      if(pbuff->m_signature_a != SWAP32LE(PORTABLE_STORAGE_SIGNATUREA) ||
-        pbuff->m_signature_b != SWAP32LE(PORTABLE_STORAGE_SIGNATUREB)
-        )
-      {
-        LOG_ERROR("portable_storage: wrong binary format - signature mismatch");
-        return false;
-      }
-      if(pbuff->m_ver != PORTABLE_STORAGE_FORMAT_VER)
-      {
-        LOG_ERROR("portable_storage: wrong binary format - unknown format ver = " << pbuff->m_ver);
-        return false;
-      }
-      TRY_ENTRY();
-      throwable_buffer_reader buf_reader(source.data()+sizeof(storage_block_header), source.size()-sizeof(storage_block_header));
-      if (limits)
-        buf_reader.set_limits(limits->n_objects, limits->n_fields, limits->n_strings);
-      buf_reader.read(m_root);
-      return true;//TODO:
-      CATCH_ENTRY("portable_storage::load_from_binary", false);
-    }
-    
-    hsection portable_storage::open_section(const std::string& section_name,  hsection hparent_section, bool create_if_notexist)
-    {
-      TRY_ENTRY();
-      hparent_section = hparent_section ? hparent_section:&m_root;
-      storage_entry* pentry = find_storage_entry(section_name, hparent_section);
-      if(!pentry)
-      {
-        if(!create_if_notexist)
-          return nullptr;
-        return insert_new_section(section_name, hparent_section);
-      }
-      CHECK_AND_ASSERT(pentry , nullptr);
-      //check that section_entry we find is real "CSSection"
-      if(pentry->type() != typeid(section))
-      {
-        if(create_if_notexist)
-          *pentry = storage_entry(section());//replace
-        else
-          return nullptr;
-      }
-      return &boost::get<section>(*pentry);
-      CATCH_ENTRY("portable_storage::open_section", nullptr);
-    }
-    
-    bool portable_storage::get_value(const std::string& value_name, storage_entry& val, hsection hparent_section)
-    {
-      //TRY_ENTRY();
-      if(!hparent_section) hparent_section = &m_root;
-      storage_entry* pentry = find_storage_entry(value_name, hparent_section);
-      if(!pentry)
-        return false;
-
-      val = *pentry;
-      return true;
-      //CATCH_ENTRY("portable_storage::template<>get_value", false);
-    }
-    
-    storage_entry* portable_storage::find_storage_entry(const std::string& pentry_name, hsection psection)
-    {
-      TRY_ENTRY();
-      CHECK_AND_ASSERT(psection, nullptr);
-      auto it = psection->m_entries.find(pentry_name);
-      if(it == psection->m_entries.end())
-        return nullptr;
-
-      return &it->second;
-      CATCH_ENTRY("portable_storage::find_storage_entry", nullptr);
-    }
-    
-    hsection portable_storage::insert_new_section(const std::string& pentry_name, hsection psection)
-    {
-      TRY_ENTRY();
-      storage_entry* pse = insert_new_entry_get_storage_entry(pentry_name, psection, section());
-      if(!pse) return nullptr;
-      return &boost::get<section>(*pse);
-      CATCH_ENTRY("portable_storage::insert_new_section", nullptr);
-    }
-    
-    harray portable_storage::get_first_section(const std::string& sec_name, hsection& h_child_section, hsection hparent_section)
-    {
-      TRY_ENTRY();
-      if(!hparent_section) hparent_section = &m_root;
-      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
-      if(!pentry)
-        return nullptr;
-      if(pentry->type() != typeid(array_entry))
-        return nullptr;
-      array_entry& ar_entry = boost::get<array_entry>(*pentry);
-      if(ar_entry.type() != typeid(array_entry_t<section>))
-        return nullptr;
-      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
-      section* psec = sec_array.get_first_val();
-      if(!psec)
-        return nullptr;
-      h_child_section = psec;
-      return &ar_entry;
-      CATCH_ENTRY("portable_storage::get_first_section", nullptr);
-    }
-    
-    bool portable_storage::get_next_section(harray hsec_array, hsection& h_child_section)
-    {
-      TRY_ENTRY();
-      CHECK_AND_ASSERT(hsec_array, false);
-      if(hsec_array->type() != typeid(array_entry_t<section>))
-        return false;
-      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
-      h_child_section = sec_array.get_next_val();
-      if(!h_child_section)
-        return false;
-      return true;
-      CATCH_ENTRY("portable_storage::get_next_section", false);
-    }
-    
-    harray portable_storage::insert_first_section(const std::string& sec_name, hsection& hinserted_childsection, hsection hparent_section)
-    {
-      TRY_ENTRY();
-      if(!hparent_section) hparent_section = &m_root;
-      storage_entry* pentry = find_storage_entry(sec_name, hparent_section);
-      if(!pentry)
-      {
-        pentry = insert_new_entry_get_storage_entry(sec_name, hparent_section, array_entry(array_entry_t<section>()));
-        if(!pentry)
-          return nullptr;
-      }
-      if(pentry->type() != typeid(array_entry))
-        *pentry = storage_entry(array_entry(array_entry_t<section>()));
-
-      array_entry& ar_entry = boost::get<array_entry>(*pentry);
-      if(ar_entry.type() != typeid(array_entry_t<section>))
-        ar_entry = array_entry(array_entry_t<section>());
-
-      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(ar_entry);
-      hinserted_childsection = &sec_array.insert_first_val(section());
-      return &ar_entry;
-      CATCH_ENTRY("portable_storage::insert_first_section", nullptr);
-    }
-    
-    bool portable_storage::insert_next_section(harray hsec_array, hsection& hinserted_childsection)
-    {
-      TRY_ENTRY();
-      CHECK_AND_ASSERT(hsec_array, false);
-      CHECK_AND_ASSERT_MES(hsec_array->type() == typeid(array_entry_t<section>), 
-        false, "unexpected type(not 'section') in insert_next_section, type: " << hsec_array->type().name());
-
-      array_entry_t<section>& sec_array = boost::get<array_entry_t<section>>(*hsec_array);
-      hinserted_childsection = &sec_array.insert_next_value(section());
-      return true;
-      CATCH_ENTRY("portable_storage::insert_next_section", false);
-    }
-}
-}

contrib/epee/src/readline_buffer.cpp

@@ -6,7 +6,6 @@
 #include <boost/thread/lock_guard.hpp>
 #include <boost/algorithm/string.hpp>
 
-static bool same_as_last_line(const std::string&);
 static void install_line_handler();
 static void remove_line_handler();
 
@@ -176,11 +175,8 @@ static void handle_line(char* line)
     boost::trim_right(test_line);
     if(!test_line.empty())
     {
-      if (!same_as_last_line(test_line))
-      {
-        add_history(test_line.c_str());
-        history_set_pos(history_length);
-      }
+      add_history(test_line.c_str());
+      history_set_pos(history_length);
       if (test_line == "exit" || test_line == "q")
         exit = true;
     }
@@ -196,16 +192,6 @@ static void handle_line(char* line)
   return;
 }
 
-// same_as_last_line returns true, if the last line in the history is
-// equal to test_line.
-static bool same_as_last_line(const std::string& test_line)
-{
-  // Note that state->offset == state->length, when a new line was entered.
-  HISTORY_STATE* state = history_get_history_state();
-  return state->length > 0
-    && test_line.compare(state->entries[state->length-1]->line) == 0;
-}
-
 static char* completion_matches(const char* text, int state)
 {
   static size_t list_index;

contrib/epee/src/string_tools.cpp

@@ -25,29 +25,6 @@
 //
 
 #include "string_tools.h"
-#include "string_tools_lexical.h"
-
-
-// Previously pulled in by ASIO, further cleanup still required ...
-#ifdef _WIN32
-# include <winsock2.h>
-# include <windows.h>
-#endif
-
-#include <locale>
-#include <cstdlib>
-#include <string>
-#include <type_traits>
-#include <boost/lexical_cast.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/utility/string_ref.hpp>
-#include "misc_log_ex.h"
-#include "storages/parserse_base_utils.h"
-#include "hex.h"
-#include "memwipe.h"
-#include "mlocker.h"
-#include "span.h"
-#include "warnings.h"
 
 #include <ctype.h>
 
@@ -91,180 +68,6 @@ namespace string_tools
         return false;
     return true;
   }
-  //----------------------------------------------------------------------------
-  bool parse_peer_from_string(uint32_t& ip, uint16_t& port, const std::string& addres)
-  {
-    //parse ip and address
-    std::string::size_type p = addres.find(':');
-    std::string ip_str, port_str;
-    if(p == std::string::npos)
-    {
-      port = 0;
-      ip_str = addres;
-    }
-    else
-    {
-      ip_str = addres.substr(0, p);
-      port_str = addres.substr(p+1, addres.size());
-    }
-
-    if(!get_ip_int32_from_string(ip, ip_str))
-    {
-      return false;
-    }
-
-    if(p != std::string::npos && !get_xtype_from_string(port, port_str))
-    {
-      return false;
-    }
-    return true;
-  }
-  
-  std::string num_to_string_fast(int64_t val)
-  {
-    /*
-    char  buff[30] = {0};
-    i64toa_s(val, buff, sizeof(buff)-1, 10);
-    return buff;*/
-    return boost::lexical_cast<std::string>(val);
-  }
-	
-	
-    bool compare_no_case(const std::string& str1, const std::string& str2)
-	{
-		
-		return !boost::iequals(str1, str2);
-	}
-	//----------------------------------------------------------------------------
-	 std::string& get_current_module_name()
-	{
-		static std::string module_name;
-		return module_name;
-	}
-	//----------------------------------------------------------------------------
-	 std::string& get_current_module_folder()
-	{	
-		static std::string module_folder;
-		return module_folder;
-	}
-	
-#ifdef _WIN32
-  std::string get_current_module_path()
-  {
-    char pname [5000] = {0};
-    GetModuleFileNameA( NULL, pname, sizeof(pname));
-    pname[sizeof(pname)-1] = 0; //be happy ;)
-    return pname;
-  }
-#endif
-	
-    bool set_module_name_and_folder(const std::string& path_to_process_)
-	{
-    std::string path_to_process = path_to_process_;
-#ifdef _WIN32
-    path_to_process = get_current_module_path();
-#endif 
-		std::string::size_type a = path_to_process.rfind( '\\' );
-		if(a == std::string::npos )
-		{
-			a = path_to_process.rfind( '/' );
-		}
-		if ( a != std::string::npos )
-		{	
-			get_current_module_name() = path_to_process.substr(a+1, path_to_process.size());
-			get_current_module_folder() = path_to_process.substr(0, a);
-			return true;
-		}else
-			return false;
-
-	}
-
-	//----------------------------------------------------------------------------
-	bool trim_left(std::string& str)
-	{
-		for(std::string::iterator it = str.begin(); it!= str.end() && isspace(static_cast<unsigned char>(*it));)
-			str.erase(str.begin());
-			
-		return true;
-	}
-	//----------------------------------------------------------------------------
-	bool trim_right(std::string& str)
-	{
-
-		for(std::string::reverse_iterator it = str.rbegin(); it!= str.rend() && isspace(static_cast<unsigned char>(*it));)
-			str.erase( --((it++).base()));
-
-		return true;
-	}
-  //----------------------------------------------------------------------------
-  std::string pad_string(std::string s, size_t n, char c, bool prepend)
-  {
-    if (s.size() < n)
-    {
-      if (prepend)
-        s = std::string(n - s.size(), c) + s;
-      else
-        s.append(n - s.size(), c);
-    }
-    return s;
-  }
-  
-    std::string get_extension(const std::string& str)
-	{
-		std::string res;
-		std::string::size_type pos = str.rfind('.');
-		if(std::string::npos == pos)
-			return res;
-		
-		res = str.substr(pos+1, str.size()-pos);
-		return res;
-	}
-	//----------------------------------------------------------------------------
-	std::string cut_off_extension(const std::string& str)
-	{
-		std::string res;
-		std::string::size_type pos = str.rfind('.');
-		if(std::string::npos == pos)
-			return str;
-
-		res = str.substr(0, pos);
-		return res;
-	}
-  //----------------------------------------------------------------------------
-#ifdef _WIN32
-  std::wstring utf8_to_utf16(const std::string& str)
-  {
-    if (str.empty())
-      return {};
-    int wstr_size = MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), NULL, 0);
-    if (wstr_size == 0)
-    {
-      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
-    }
-    std::wstring wstr(wstr_size, wchar_t{});
-    if (!MultiByteToWideChar(CP_UTF8, 0, &str[0], str.size(), &wstr[0], wstr_size))
-    {
-      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
-    }
-    return wstr;
-  }
-  std::string utf16_to_utf8(const std::wstring& wstr)
-  {
-    if (wstr.empty())
-      return {};
-    int str_size = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), NULL, 0, NULL, NULL);
-    if (str_size == 0)
-    {
-      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
-    }
-    std::string str(str_size, char{});
-    if (!WideCharToMultiByte(CP_UTF8, 0, &wstr[0], wstr.size(), &str[0], str_size, NULL, NULL))
-    {
-      throw std::runtime_error(std::error_code(GetLastError(), std::system_category()).message());
-    }
-    return str;
-  }
-#endif
 }
 }
 

contrib/epee/src/tiny_ini.cpp

@@ -1,46 +0,0 @@
-// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
-// All rights reserved.
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * 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.
-// * Neither the name of the Andrey N. Sabelnikov 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 OWNER  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_tools.h"
-#include <boost/regex.hpp>
-
-namespace epee
-{
-namespace tiny_ini
-{
-    bool get_param_value(const std::string& param_name, const std::string& ini_entry, std::string& res)
-	{
-		std::string expr_str = std::string() + "^("+ param_name +") *=(.*?)$";
-		const boost::regex match_ini_entry( expr_str, boost::regex::icase | boost::regex::normal); 
-		boost::smatch result;	
-		if(!boost::regex_search(ini_entry, result, match_ini_entry, boost::match_default))
-			return false;
-		res = result[2];
-		string_tools::trim(res);
-		return true;
-	}
-}
-}

contrib/epee/src/wipeable_string.cpp

@@ -27,6 +27,7 @@
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/optional/optional.hpp>
+#include <limits>
 #include <string.h>
 #include "memwipe.h"
 #include "misc_log_ex.h"

contrib/epee/tests/src/CMakeLists.txt

@@ -1,5 +1,5 @@
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 2.8)
 
 set(Boost_USE_MULTITHREADED ON)
 

contrib/fuzz_testing/fuzz.sh

@@ -14,8 +14,8 @@ then
   exit 1
 fi
 case "$type" in
-  block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin|bulletproof|utf8) ;;
-  *) echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin|bulletproof|utf8"; exit 1 ;;
+  block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin|bulletproof) ;;
+  *) echo "usage: $0 block|transaction|signature|cold-outputs|cold-transaction|load-from-binary|load-from-json|base58|parse-url|http-client|levin|bulletproof"; exit 1 ;;
 esac
 
 if test -d "fuzz-out/$type"

contrib/gitian/README.md

@@ -36,10 +36,6 @@ This guide explains how to set up the environment, and how to start the builds.
 
 You need to create a new user called `gitianuser` and be logged in as that user.  The user needs `sudo` access.
 
-```bash
-sudo adduser gitianuser
-sudo usermod -aG sudo gitianuser
-```
 
 LXC
 ---
@@ -87,7 +83,7 @@ Docker
 Prepare for building with docker:
 
 ```bash
-sudo bash -c 'apt-get update && apt-get upgrade -y && apt-get install git curl docker.io'
+sudo apt-get install git make curl docker.io
 ```
 
 Consider adding `gitianuser` to the `docker` group after reading about [the security implications](https://docs.docker.com/v17.09/engine/installation/linux/linux-postinstall/):
@@ -100,12 +96,13 @@ sudo usermod -aG docker gitianuser
 Optionally add yourself to the docker group. Note that this will give docker root access to your system.
 
 ```bash
-sudo usermod -aG docker $USER
+sudo usermod -aG docker gitianuser
 ```
 
 Manual Building
 -------------------
 
+The instructions below use the automated script [gitian-build.py](gitian-build.py) which only works in Ubuntu. 
 =======
 The script automatically installs some packages with apt. If you are not running it on a debian-like system, pass `--no-apt` along with the other
 arguments to it. It calls all available .yml descriptors, which in turn pass the build configurations for different platforms to gitian.
@@ -125,23 +122,17 @@ cp monero/contrib/gitian/gitian-build.py .
 
 ### Setup the required environment
 
-Common setup part:
-
-```bash
-su - gitianuser
-
-GH_USER=YOUR_GITHUB_USER_NAME
-VERSION=v0.17.2.0
-```
-
-Where `GH_USER` is your Github user name and `VERSION` is the version tag you want to build. 
-
 Setup for LXC:
 
 ```bash
+GH_USER=fluffypony
+VERSION=v0.17.2.0
+
 ./gitian-build.py --setup $GH_USER $VERSION
 ```
 
+Where `GH_USER` is your Github user name and `VERSION` is the version tag you want to build. 
+
 Setup for docker:
 
 ```bash
@@ -154,10 +145,8 @@ fork the [gitian.sigs repository](https://github.com/monero-project/gitian.sigs)
 or pass the signed assert file back to your build machine.
 
 ```bash
-git clone https://github.com/monero-project/gitian.sigs/
-pushd gitian.sigs
-git remote add $GH_USER https://github.com/$GH_USER/gitian.sigs
-popd
+git clone git@github.com:monero-project/gitian.sigs.git
+git remote add $GH_USER git@github.com:$GH_USER/gitian.sigs.git
 ```
 
 Build the binaries
@@ -165,26 +154,13 @@ Build the binaries
 
 **Note:** if you intend to build MacOS binaries, please follow [these instructions](https://github.com/bitcoin-core/docs/blob/master/gitian-building/gitian-building-mac-os-sdk.md) to get the required SDK.
 
-Currently working MacOS solution:
-
-```bash
-curl -O https://bitcoincore.org/depends-sources/sdks/MacOSX10.11.sdk.tar.gz
-mv MacOSX10.11.sdk.tar.gz builder/inputs
-```
-
 To build the most recent tag (pass in `--docker` if using docker):
 
 ```bash
 ./gitian-build.py --detach-sign --no-commit --build $GH_USER $VERSION
 ```
 
-To speed up the build, use `-j 5 --memory 10000` as the first arguments, where `5` is the number of CPU's you allocated to the VM plus one, and 10000 is a little bit less than then the MB's of RAM you allocated. If there is memory corruption on your machine, try to tweak these values. A good rule of thumb is, that Monero currently needs about 2 GB of RAM per core. 
-
-A full example for `docker` would look like the following:
-
-```bash
-./gitian-build.py -j 5 --memory 10000 --docker --detach-sign --no-commit --build $GH_USER $VERSION
-```
+To speed up the build, use `-j 5 --memory 5000` as the first arguments, where `5` is the number of CPU's you allocated to the VM plus one, and 5000 is a little bit less than then the MB's of RAM you allocated. If there is memory corruption on your machine, try to tweak these values.
 
 If all went well, this produces a number of (uncommitted) `.assert` files in the gitian.sigs directory.
 
@@ -195,22 +171,6 @@ Take a look in the assert files and note the SHA256 checksums listed there.
 
 You should verify that the checksum that is listed matches each of the binaries you actually built.
 This may be done on Linux using the `sha256sum` command or on MacOS using `shasum --algorithm 256` for example.
-An example script to verify the checksums would be:
-
-```bash
-pushd out/${VERSION}
-
-for ASSERT in ../../sigs/${VERSION}-*/*/*.assert; do
-  if ! sha256sum --ignore-missing -c "${ASSERT}" ; then
-    echo "FAILED for ${ASSERT} ! Please inspect manually."
-  fi
-done
-
-popd
-```
-
-Don't ignore the incorrect formatting of the found assert files. These files you'll have to compare manually (currently OSX and FreeBSD).
-
 
 You can also look in the [gitian.sigs](https://github.com/monero-project/gitian.sigs/) repo and / or [getmonero.org release checksums](https://web.getmonero.org/downloads/hashes.txt) to see if others got the same checksum for the same version tag.  If there is ever a mismatch -- **STOP! Something is wrong**.  Contact others on IRC / github to figure out what is going on.
 
@@ -221,7 +181,13 @@ Signing assert files
 If you chose to do detached signing using `--detach-sign` above (recommended), you need to copy these uncommitted changes to your host machine, then sign them using your gpg key like so:
 
 ```bash
-for ASSERT in sigs/${VERSION}-*/*/*.assert; do gpg --detach-sign ${ASSERT}; done
+GH_USER=fluffypony
+VERSION=v0.17.2.0
+
+gpg --detach-sign ${VERSION}-linux/${GH_USER}/monero-linux-*-build.assert
+gpg --detach-sign ${VERSION}-win/${GH_USER}/monero-win-*-build.assert
+gpg --detach-sign ${VERSION}-osx/${GH_USER}/monero-osx-*-build.assert
+gpg --detach-sign ${VERSION}-android/${GH_USER}/monero-android-*-build.assert
 ```
 
 This will create a `.sig` file for each `.assert` file above (2 files for each platform).
@@ -234,7 +200,6 @@ Make a pull request (both the `.assert` and `.assert.sig` files) to the
 [monero-project/gitian.sigs](https://github.com/monero-project/gitian.sigs/) repository:
 
 ```bash
-cd gitian.sigs
 git checkout -b $VERSION
 # add your assert and sig files...
 git commit -S -a -m "Add $GH_USER $VERSION"

contrib/gitian/gitian-linux.yml

@@ -49,7 +49,7 @@ files: []
 script: |
 
   WRAP_DIR=$HOME/wrapped
-  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu i686-linux-gnu"
+  HOSTS="x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu"
   FAKETIME_HOST_PROGS=""
   FAKETIME_PROGS="date"
   HOST_CFLAGS="-O2 -g"

contrib/gitian/gitian-win.yml

@@ -23,12 +23,6 @@ packages:
 - "rename"
 - "cmake"
 alternatives:
--
-  package: "i686-w64-mingw32-g++"
-  path: "/usr/bin/i686-w64-mingw32-g++-posix"
--
-  package: "i686-w64-mingw32-gcc"
-  path: "/usr/bin/i686-w64-mingw32-gcc-posix"
 -
   package: "x86_64-w64-mingw32-g++"
   path: "/usr/bin/x86_64-w64-mingw32-g++-posix"
@@ -41,7 +35,7 @@ remotes:
 files: []
 script: |
   WRAP_DIR=$HOME/wrapped
-  HOSTS="i686-w64-mingw32 x86_64-w64-mingw32"
+  HOSTS="x86_64-w64-mingw32"
   FAKETIME_HOST_PROGS="windres objcopy"
   FAKETIME_PROGS="date zip"
   HOST_CFLAGS="-O2 -g"

contrib/tor/wownero-over-tor.sh

@@ -42,7 +42,9 @@ CookieAuthentication 1
 CookieAuthFile $TORDIR/control.authcookie
 CookieAuthFileGroupReadable 1
 HiddenServiceDir $TORDIR
-HiddenServicePort 38083 127.0.0.1:38083
+HiddenServicePort 34568 127.0.0.1:34568
+HiddenServicePort 34566 127.0.0.1:34566
+HiddenServiceVersion 3
 EOF
 
 echo "Starting Tor..."
@@ -67,9 +69,15 @@ fi
 echo "Starting wownerod..."
 HOSTNAME=$(cat "$HOSTNAMEFILE")
 "$monerod" \
-  --anonymous-inbound "$HOSTNAME":38083,127.0.0.1:38083,25 --tx-proxy tor,127.0.0.1:9050,10 \
-  --add-priority-node zbjkbsxc5munw3qusl7j2hpcmikhqocdf4pqhnhtpzw5nt5jrmofptid.onion:38083 \
-  --add-priority-node 2xmrnode5itf65lz.onion:38083 \
+  --anonymous-inbound "$HOSTNAME":34566,127.0.0.1:34566,25 --tx-proxy tor,127.0.0.1:9050,10 \
+  --add-priority-node v2admi6gbeprxnk6i2oscizhgy4v5ixu6iezkhj5udiwbfjjs2w7dnid.onion:34568 \
+  --add-priority-node iy6ry6uudpzvbd72zsipepukp6nsazjdu72n52vg3isfnxqn342flzad.onion:34568 \
+  --add-priority-node 7ftpbpp6rbgqi5kjmhyin46essnh3eqb3m3rhfi7r2fr33iwkeuer3yd.onion:34568 \
+  --add-priority-node j7rf2jcccizcp47y5moehguyuqdpg4lusk642sw4nayuruitqaqbc7ad.onion:34568 \
+  --add-priority-node aje53o5z5twne5q2ljw44zkahhsuhjtwaxuburxddbf7n4pfsj4rj6qd.onion:34568 \
+  --add-priority-node nepc4lxndsooj2akn7ofrj3ooqc25242obchcag6tw3f2mxrms2uuvyd.onion:34568 \
+  --add-priority-node 666l2ajxqjgj5lskvbokvworjysgvqag4oitokjuy7wz6juisul4jqad.onion:34568 \
+  --add-priority-node ty7ppqozzodz75audgvkprekiiqsovbyrkfdjwadrkbe3etyzloatxad.onion:34568 \
   --detach
 ready=0
 for i in `seq 10`

docs/COMPILING_DEBUGGING_TESTING.md

@@ -1,86 +0,0 @@
-# Compiling, debugging and testing efficiently
-
-This document describes ways of compiling, debugging and testing efficiently for various use cases.
-The intented audience are developers, who want to leverage newly added tricks to Monero via `CMake`. The document will lower the entry point for these developers.
-Before reading this document, please consult section "Build instructions" in the main README.md. 
-Some information from README.md will be repeated here, but the aim is to go beyond it.
-
-## Basic compilation
-
-Monero can be compiled via the main `Makefile`, using one of several targets listed there.
-The targets are actually presets for `CMake` calls with various options, plus `make` commands for building or in some cases `make test` for testing.
-It is possible to extract these `CMake` calls and modify them for your specific needs. For example, a minimal external cmake command to compile Monero, executed from within a newly created build directory could look like:
-
-`cmake -S "$DIR_SRC" -DCMAKE_BUILD_TYPE=Release && make`
-
-where the variable `DIR_SRC` is expected to store the path to the Monero source code.
-
-## Use cases
-
-### Test Driven Development (TDD) - shared libraries for release builds
-
-Building shared libraries spares a lot of disk space and linkage time. By default only the debug builds produce shared libraries. If you'd like to produce dynamic libraries for the release build for the same reasons as it's being done for the debug version, then you need to add the `BUILD_SHARED_LIBS=ON` flag to the `CMake` call, like the following:
-
-`cmake -S "$DIR_SRC" -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON && make`
-
-A perfect use case for the above call is following the Test Driven Development (TDD) principles. In a nutshell, you'd first write a couple of tests, which describe the (new) requirements of the class/method that you're about to write or modify. The tests will typically compile for quite a long time, so ideally write them once. After you're done with the tests, the only thing left to do is to keep modifying the implementation for as long as the tests are failing. If the implementation is contained properly within a .cpp file, then the only time cost to be paid will be compiling the single source file and generating the implementation's shared library. The test itself will not have to be touched and will pick up the new version of the implementation (via the shared library) upon the next execution of the test.
-
-### Project generation for IDEs
-
-CMake allows to generate project files for many IDEs. The list of supported project files can be obtained by writing in the console:
-
-`cmake -G`
-
-For instance, in order to generate Makefiles and project files for the Code::Blocks IDE, this part of the call would look like the following:
-
-`cmake -G "CodeBlocks - Unix Makefiles" (...)`
-
-The additional artifact of the above call is the `monero.cbp` Code::Blocks project file in the build directory.
-
-### Debugging in Code::Blocks (CB)
-
-First prepare the build directory for debugging using the following example command, assuming, that the path to the source dir is being held in the DIR_SRC variable, and using 2 cores:
-
-`cmake -S "$DIR_SRC" -G "CodeBlocks - Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTS=ON && make -j 2`
-
-After a successful build, open the `monero.cbp` with CB. From the CB's menu bar select the target, that you want debug. Assuming these are unit tests:
-
-`Build -> Select target -> Select target -> unit_tests`
-
-In order to lower the turnaround times, we will run a specific portion of code of interest, without having to go through all the time costly initialization and execution of unrelated parts. For this we'll use GTest's capabilities of test filtering. From the build directory run the following command to learn all the registered tests:
-
-`tests/unit_tests/unit_tests --gtest_list_tests`
-
-For example, if you're only interested in logging, you'd find in the list the label `logging.` and its subtests. To execute all the logging tests, you'd write in the console:
-
-`tests/unit_tests/unit_tests --gtest_filter="logging.*"`
-
-This parameter is what we need to transfer to CB, in order to reflect the same behaviour in the CB's debugger. From the main menu select:
-
-`Project -> Set program's arguments...`
-
-Then in the `Program's arguments` textbox you'd write in this case: 
-
-`--gtest_filter="logging.*"`
-
-Verify if the expected UTs are being properly executed with `F9` or select:
-
-`Build -> Build and run`
-
-If everything looks fine, then after setting some breakpoints of your choice, the target is ready for debugging in CB via:
-
-`Debug -> Start/Continue`
-
-## To be done (and merged):
-### Multihost parallel compilation
-https://github.com/monero-project/monero/pull/7160
-
-### Faster core_tests with caching
-https://github.com/monero-project/monero/pull/5821
-
-### Precompiled headers
-https://github.com/monero-project/monero/pull/7216
-
-### Unity builds
-https://github.com/monero-project/monero/pull/7217
-

docs/RELEASE_CHECKLIST.md

@@ -1,68 +0,0 @@
-- [ ] Security audit
-- [ ] Code audit
-- [ ] Ledger integration
-  - [ ] Implemented in Monero codebase (if needed)
-  - [ ] Ledger app integration coded by Ledger
-  - [ ] Ledger Monero app update available
-- [ ] Trezor integration
-  - [ ] Implemented in Monero codebase (if needed)
-  - [ ] Trezor app integration coded by Trezor
-  - [ ] Trezor firmware update available (if needed)
-- [ ] Fork height set
-  - [ ] Monero-announce mailer notice
-  - [ ] Twitter announcement
-  - [ ] Reddit announcement
-  - [ ] Getmonero.org announcement
-- [ ] Notify wallets
-  - [ ] MyMonero
-  - [ ] Coinomi
-  - [ ] Exa Wallet
-  - [ ] Wookey Wallet
-  - [ ] X Wallet
-  - [ ] Guarda
-  - [ ] ZelCore
-  - [ ] Cake Wallet
-  - [ ] Monerujo
-  - [ ] Edge Wallet
-  - [ ] Exodus
-  - [ ] XMRWallet
-- [ ] Notify exchanges
-  - [ ] https://web.getmonero.org/community/merchants/#exchanges
-- [ ] Notify 3rd party payment processors
-  - [ ] https://web.getmonero.org/community/merchants/#payment-gateways
-- [ ] Notify mining pools
-  - [ ] https://miningpoolstats.stream/monero
-- [ ] Release tagged
-  - [ ] Update src/version.cpp.in with new version AND new name (if necessary)
-  - [ ] Update Gitian YML files in contrib/gitian/ to the new version number
-  - [ ] Update README.md with new fork table entry (or at least update the Recommended Monero version)
-  - [ ] Update contrib/gitian/README.md so that the instructions reflect the current version
-  - [ ] Update src/checkpoints/checkpoints.cpp with a recent hardcoded checkpoint
-  - [ ] Update src/blocks/checkpoints.dat with ./monero-blockchain-export --output-file checkpoints.dat --block-stop <recent block height> --blocksdat
-  - [ ] Update expected_block_hashes_hash in src/cryptonote_core/blockchain.cpp with checkpoints.dat sha256 hash
-- [ ] Testnet forked
-- [ ] Testnet testing/verification
-  - [ ] Ledger
-  - [ ] Trezor
-  - [ ] Release-specific testing
-  - [ ] RPC testing/update RPC documentation
-- [ ] CLI reproducible builds validated
-- [ ] CLI released
-  - [ ] https://web.getmonero.org/downloads/ updated
-  - [ ] Update hashes.txt on website
-  - [ ] Update downloads.yml on website
-  - [ ] Update auto-update DNS records
-  - [ ] Update redirects on downloads box
-  - [ ] Update seed nodes
-- [ ] GUI released
-  - [ ] https://web.getmonero.org/downloads/ updated
-  - [ ] Update hashes.txt on website
-  - [ ] Update hashes.txt.sig on website
-  - [ ] Update downloads.yml on website
-  - [ ] Update auto-update DNS records
-  - [ ] Update redirects on downloads box
-- [ ] Release Announcements
-  - [ ] Monero-announce mailer notice
-  - [ ] Twitter announcement
-  - [ ] Reddit announcement
-  - [ ] Getmonero.org announcement

external/CMakeLists.txt

@@ -38,10 +38,8 @@
 find_package(Miniupnpc REQUIRED)
 
 message(STATUS "Using in-tree miniupnpc")
-set(UPNPC_NO_INSTALL TRUE CACHE BOOL "Disable miniupnp installation" FORCE)
 add_subdirectory(miniupnp/miniupnpc)
 set_property(TARGET libminiupnpc-static PROPERTY FOLDER "external")
-set_property(TARGET libminiupnpc-static PROPERTY POSITION_INDEPENDENT_CODE ON)
 if(MSVC)
   set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -wd4244 -wd4267")
 elseif(NOT MSVC)

external/easylogging++/CMakeLists.txt

@@ -26,22 +26,17 @@
 # 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.
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 2.8.7)
 
 project(easylogging CXX)
 
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-monero_enable_coverage()
 
 find_package(Threads)
 find_package(Backtrace)
 
-monero_find_all_headers(EASYLOGGING_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}")
-
 add_library(easylogging
-  easylogging++.cc
-  ${EASYLOGGING_HEADERS}
-  )
+  easylogging++.cc)
 
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
 include_directories("${CMAKE_CURRENT_BINARY_DIR}")

external/easylogging++/easylogging++.cc

@@ -17,7 +17,6 @@
 #define EASYLOGGING_CC
 #include "easylogging++.h"
 
-#include <atomic>
 #include <unistd.h>
 
 #if defined(AUTO_INITIALIZE_EASYLOGGINGPP)
@@ -714,8 +713,9 @@ Logger::Logger(const std::string& id, const Configurations& configurations,
 }
 
 Logger::Logger(const Logger& logger) {
+  base::utils::safeDelete(m_typedConfigurations);
   m_id = logger.m_id;
-  m_typedConfigurations = logger.m_typedConfigurations ? new base::TypedConfigurations(*logger.m_typedConfigurations) : nullptr;
+  m_typedConfigurations = logger.m_typedConfigurations;
   m_parentApplicationName = logger.m_parentApplicationName;
   m_isConfigured = logger.m_isConfigured;
   m_configurations = logger.m_configurations;
@@ -727,7 +727,7 @@ Logger& Logger::operator=(const Logger& logger) {
   if (&logger != this) {
     base::utils::safeDelete(m_typedConfigurations);
     m_id = logger.m_id;
-    m_typedConfigurations = logger.m_typedConfigurations ? new base::TypedConfigurations(*logger.m_typedConfigurations) : nullptr;
+    m_typedConfigurations = logger.m_typedConfigurations;
     m_parentApplicationName = logger.m_parentApplicationName;
     m_isConfigured = logger.m_isConfigured;
     m_configurations = logger.m_configurations;
@@ -2035,7 +2035,7 @@ void RegisteredLoggers::unsafeFlushAll(void) {
 
 // VRegistry
 
-VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) {
+VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags), m_lowest_priority(INT_MAX) {
 }
 
 /// @brief Sets verbose level. Accepted range is 0-9
@@ -2131,30 +2131,18 @@ static int priority(Level level) {
   return 7;
 }
 
-namespace
-{
-  std::atomic<int> s_lowest_priority{INT_MAX};
-}
-
-void VRegistry::clearCategories(void) {
-  const base::threading::ScopedLock scopedLock(lock());
-  m_categories.clear();
-  m_cached_allowed_categories.clear();
-  s_lowest_priority = INT_MAX;
-}
-
 void VRegistry::setCategories(const char* categories, bool clear) {
   base::threading::ScopedLock scopedLock(lock());
   auto insert = [&](std::stringstream& ss, Level level) {
     m_categories.push_back(std::make_pair(ss.str(), level));
     m_cached_allowed_categories.clear();
     int pri = priority(level);
-    if (pri > s_lowest_priority)
-      s_lowest_priority = pri;
+    if (pri > m_lowest_priority)
+      m_lowest_priority = pri;
   };
 
   if (clear) {
-    s_lowest_priority = 0;
+    m_lowest_priority = 0;
     m_categories.clear();
     m_cached_allowed_categories.clear();
     m_categoriesString.clear();
@@ -2212,9 +2200,9 @@ std::string VRegistry::getCategories() {
 }
 
 bool VRegistry::allowed(Level level, const std::string &category) {
-  return priority_allowed(priority(level), category);
-}
-bool VRegistry::priority_allowed(const int pri, const std::string &category) {
+  const int pri = priority(level);
+  if (pri > m_lowest_priority)
+    return false;
   base::threading::ScopedLock scopedLock(lock());
   const std::map<std::string, int>::const_iterator it = m_cached_allowed_categories.find(category);
   if (it != m_cached_allowed_categories.end())
@@ -2489,20 +2477,20 @@ void DefaultLogDispatchCallback::handle(const LogDispatchData* data) {
 
 
 template<typename Transform>
-static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->wint_t { return c; })
+static inline std::string utf8canonical(const std::string &s, Transform t = [](wint_t c)->wint_t { return c; })
 {
+    std::string sc = "";
     size_t avail = s.size();
     const char *ptr = s.data();
     wint_t cp = 0;
-    int rbytes = 1, bytes = -1;
+    int bytes = 1;
     char wbuf[8], *wptr;
-    size_t w_offset = 0;
     while (avail--)
     {
       if ((*ptr & 0x80) == 0)
       {
         cp = *ptr++;
-        rbytes = 1;
+        bytes = 1;
       }
       else if ((*ptr & 0xe0) == 0xc0)
       {
@@ -2511,7 +2499,7 @@ static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->win
         cp = (*ptr++ & 0x1f) << 6;
         cp |= *ptr++ & 0x3f;
         --avail;
-        rbytes = 2;
+        bytes = 2;
       }
       else if ((*ptr & 0xf0) == 0xe0)
       {
@@ -2521,7 +2509,7 @@ static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->win
         cp |= (*ptr++ & 0x3f) << 6;
         cp |= *ptr++ & 0x3f;
         avail -= 2;
-        rbytes = 3;
+        bytes = 3;
       }
       else if ((*ptr & 0xf8) == 0xf0)
       {
@@ -2532,7 +2520,7 @@ static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->win
         cp |= (*ptr++ & 0x3f) << 6;
         cp |= *ptr++ & 0x3f;
         avail -= 3;
-        rbytes = 4;
+        bytes = 4;
       }
       else
         throw std::runtime_error("Invalid UTF-8");
@@ -2549,9 +2537,6 @@ static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->win
       else
         throw std::runtime_error("Invalid code point UTF-8 transformation");
 
-      if (bytes > rbytes)
-        throw std::runtime_error("In place sanitization requires replacements to not take more space than the original code points");
-
       wptr = wbuf;
       switch (bytes)
       {
@@ -2562,17 +2547,16 @@ static inline void utf8canonical(std::string &s, Transform t = [](wint_t c)->win
         default: throw std::runtime_error("Invalid UTF-8");
       }
       *wptr = 0;
-      memcpy(&s[w_offset], wbuf, bytes);
-      w_offset += bytes;
+      sc.append(wbuf, bytes);
       cp = 0;
       bytes = 1;
     }
-    s.resize(w_offset);
+    return sc;
 }
 
 void sanitize(std::string &s)
 {
-  utf8canonical(s, [](wint_t c)->wint_t {
+  s = utf8canonical(s, [](wint_t c)->wint_t {
     if (c == 9 || c == 10 || c == 13)
       return c;
     if (c < 0x20)
@@ -3351,14 +3335,6 @@ void Helpers::logCrashReason(int sig, bool stackTraceIfAvailable, Level level, c
 
 // Loggers
 
-bool Loggers::allowed(Level level, const char* cat)
-{
-  const int pri = base::priority(level);
-  if (pri > base::s_lowest_priority)
-    return false;
-  return ELPP->vRegistry()->priority_allowed(pri, std::string{cat});
-}
-
 Logger* Loggers::getLogger(const std::string& identity, bool registerIfNotAvailable) {
   return ELPP->registeredLoggers()->get(identity, registerIfNotAvailable);
 }

external/easylogging++/easylogging++.h

@@ -412,6 +412,7 @@ ELPP_INTERNAL_DEBUGGING_OUT_INFO << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStre
 #include <sstream>
 #include <memory>
 #include <type_traits>
+#include <atomic>
 #if ELPP_THREADING_ENABLED
 #  if ELPP_USE_STD_THREADING
 #      include <mutex>
@@ -2463,7 +2464,12 @@ class VRegistry : base::NoCopy, public base::threading::ThreadSafe {
     return m_level;
   }
 
-  void clearCategories(void);
+  inline void clearCategories(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_categories.clear();
+    m_cached_allowed_categories.clear();
+    m_lowest_priority = INT_MAX;
+  }
 
   inline void clearModules(void) {
     base::threading::ScopedLock scopedLock(lock());
@@ -2476,7 +2482,6 @@ class VRegistry : base::NoCopy, public base::threading::ThreadSafe {
 
   void setModules(const char* modules);
 
-  bool priority_allowed(int priority, const std::string &category);
   bool allowed(Level level, const std::string &category);
 
   bool allowed(base::type::VerboseLevel vlevel, const char* file);
@@ -2508,6 +2513,7 @@ class VRegistry : base::NoCopy, public base::threading::ThreadSafe {
   std::map<std::string, int> m_cached_allowed_categories;
   std::string m_categoriesString;
   std::string m_filenameCommonPrefix;
+  std::atomic<int> m_lowest_priority;
 };
 }  // namespace base
 class LogMessage {
@@ -3862,8 +3868,6 @@ class Helpers : base::StaticClass {
 /// @brief Static helpers to deal with loggers and their configurations
 class Loggers : base::StaticClass {
  public:
-  /// @brief Determines whether logging will occur at this level and category
-  static bool allowed(Level leve, const char* cat);
   /// @brief Gets existing or registers new logger
   static Logger* getLogger(const std::string& identity, bool registerIfNotAvailable = true);
   /// @brief Changes default log builder for future loggers

src/CMakeLists.txt

@@ -75,9 +75,29 @@ function (monero_add_executable name)
     PROPERTY
       RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
   enable_stack_trace("${name}")
-  
-  monero_set_target_no_relink("${name}")
-  monero_set_target_strip    ("${name}")
+endfunction ()
+
+function (monero_add_library name)
+    monero_add_library_with_deps(NAME "${name}" SOURCES ${ARGN})
+endfunction()
+
+function (monero_add_library_with_deps)
+  cmake_parse_arguments(MONERO_ADD_LIBRARY "" "NAME" "DEPENDS;SOURCES" ${ARGN})
+  source_group("${MONERO_ADD_LIBRARY_NAME}" FILES ${MONERO_ADD_LIBRARY_SOURCES})
+
+  # Define a ("virtual") object library and an actual library that links those
+  # objects together. The virtual libraries can be arbitrarily combined to link
+  # any subset of objects into one library archive. This is used for releasing
+  # libwallet, which combines multiple components.
+  set(objlib obj_${MONERO_ADD_LIBRARY_NAME})
+  add_library(${objlib} OBJECT ${MONERO_ADD_LIBRARY_SOURCES})
+  add_library("${MONERO_ADD_LIBRARY_NAME}" $<TARGET_OBJECTS:${objlib}>)
+  if (MONERO_ADD_LIBRARY_DEPENDS)
+    add_dependencies(${objlib} ${MONERO_ADD_LIBRARY_DEPENDS})
+  endif()
+  set_property(TARGET "${MONERO_ADD_LIBRARY_NAME}" PROPERTY FOLDER "libs")
+  target_compile_definitions(${objlib}
+    PRIVATE $<TARGET_PROPERTY:${MONERO_ADD_LIBRARY_NAME},INTERFACE_COMPILE_DEFINITIONS>)
 endfunction ()
 
 include(Version)

src/blockchain_db/blockchain_db.cpp

@@ -216,8 +216,15 @@ void BlockchainDB::add_transaction(const crypto::hash& blk_hash, const std::pair
     }
     else
     {
-      LOG_PRINT_L1("Unsupported input type, aborting transaction addition");
-      throw std::runtime_error("Unexpected input type, aborting");
+      LOG_PRINT_L1("Unsupported input type, removing key images and aborting transaction addition");
+      for (const txin_v& tx_input : tx.vin)
+      {
+        if (tx_input.type() == typeid(txin_to_key))
+        {
+          remove_spent_key(boost::get<txin_to_key>(tx_input).k_image);
+        }
+      }
+      return;
     }
   }
 
@@ -287,7 +294,7 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
     num_rct_outs += blk.miner_tx.vout.size();
   int tx_i = 0;
   crypto::hash tx_hash = crypto::null_hash;
-  for (const std::pair<transaction, blobdata>& tx : txs)
+  for (const std::pair<transaction, blobdata_ref>& tx : txs)
   {
     tx_hash = blk.tx_hashes[tx_i];
     add_transaction(blk_hash, tx, &tx_hash);

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -897,6 +897,7 @@ uint64_t BlockchainLMDB::add_transaction_data(const crypto::hash& blk_hash, cons
     throw0(DB_ERROR(lmdb_error("Failed to add tx data to db transaction: ", result).c_str()));
 
   const cryptonote::blobdata_ref &blob = txp.second;
+  MDB_val_sized(blobval, blob);
 
   unsigned int unprunable_size = tx.unprunable_size;
   if (unprunable_size == 0)
@@ -1354,8 +1355,7 @@ void BlockchainLMDB::open(const std::string& filename, const int db_flags)
 
   m_folder = filename;
 
-  try { check_mmap_support(); }
-  catch(...) { MERROR("Failed to check for mmap support, proceeding"); }
+  check_mmap_support();
 
 #ifdef __OpenBSD__
   if ((mdb_flags & MDB_WRITEMAP) == 0) {
@@ -3001,7 +3001,7 @@ bool BlockchainLMDB::tx_exists(const crypto::hash& h) const
 
   if (! tx_found)
   {
-    LOG_PRINT_L3("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
+    LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
     return false;
   }
 
@@ -3032,7 +3032,7 @@ bool BlockchainLMDB::tx_exists(const crypto::hash& h, uint64_t& tx_id) const
   bool ret = false;
   if (get_result == MDB_NOTFOUND)
   {
-    LOG_PRINT_L3("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
+    LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
   }
   else if (get_result)
     throw0(DB_ERROR(lmdb_error("DB error attempting to fetch transaction from hash", get_result).c_str()));
@@ -3190,8 +3190,9 @@ bool BlockchainLMDB::get_blocks_from(uint64_t start_height, size_t min_block_cou
   uint64_t size = 0;
   size_t num_txes = 0;
   MDB_val_copy<uint64_t> key(start_height);
-  MDB_val v, val_tx_id;
+  MDB_val k, v, val_tx_id;
   uint64_t tx_id = ~0;
+  MDB_cursor_op op = MDB_SET;
   for (uint64_t h = start_height; h < blockchain_height && blocks.size() < max_block_count && (size < max_size || blocks.size() < min_block_count); ++h)
   {
     MDB_cursor_op op = h == start_height ? MDB_SET : MDB_NEXT;
@@ -3313,7 +3314,7 @@ bool BlockchainLMDB::get_prunable_tx_hash(const crypto::hash& tx_hash, crypto::h
   RCURSOR(txs_prunable_hash);
 
   MDB_val_set(v, tx_hash);
-  MDB_val result;
+  MDB_val result, val_tx_prunable_hash;
   auto get_result = mdb_cursor_get(m_cur_tx_indices, (MDB_val *)&zerokval, &v, MDB_GET_BOTH);
   if (get_result == 0)
   {
@@ -4310,6 +4311,7 @@ bool BlockchainLMDB::get_output_distribution(uint64_t amount, uint64_t from_heig
     return false;
   distribution.resize(db_height - from_height, 0);
 
+  bool fret = true;
   MDB_val_set(k, amount);
   MDB_val v;
   MDB_cursor_op op = MDB_SET;
@@ -5104,10 +5106,11 @@ void BlockchainLMDB::migrate_0_1()
 void BlockchainLMDB::migrate_1_2()
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
-  uint64_t i;
+  uint64_t i, z;
   int result;
   mdb_txn_safe txn(false);
-  MDB_val v;
+  MDB_val k, v;
+  char *ptr;
 
   MGINFO_YELLOW("Migrating blockchain from DB version 1 to 2 - this may take a while:");
   MINFO("updating txs_pruned and txs_prunable tables...");
@@ -5308,6 +5311,7 @@ void BlockchainLMDB::migrate_2_3()
         if (result)
           throw0(DB_ERROR(lmdb_error("Failed to open a cursor for block_info: ", result).c_str()));
         if (!i) {
+          MDB_stat db_stat;
           result = mdb_stat(txn, m_block_info, &db_stats);
           if (result)
             throw0(DB_ERROR(lmdb_error("Failed to query m_block_info: ", result).c_str()));
@@ -5439,6 +5443,7 @@ void BlockchainLMDB::migrate_3_4()
         if (result)
           throw0(DB_ERROR(lmdb_error("Failed to open a cursor for blocks: ", result).c_str()));
         if (!i) {
+          MDB_stat db_stat;
           result = mdb_stat(txn, m_block_info, &db_stats);
           if (result)
             throw0(DB_ERROR(lmdb_error("Failed to query m_block_info: ", result).c_str()));
@@ -5592,6 +5597,7 @@ void BlockchainLMDB::migrate_4_5()
         if (result)
           throw0(DB_ERROR(lmdb_error("Failed to open a cursor for block_info: ", result).c_str()));
         if (!i) {
+          MDB_stat db_stat;
           result = mdb_stat(txn, m_block_info, &db_stats);
           if (result)
             throw0(DB_ERROR(lmdb_error("Failed to query m_block_info: ", result).c_str()));

src/blockchain_utilities/blockchain-stats-readme.md

@@ -1,54 +0,0 @@
-# Monero Blockchain Stats
-
-Monero Blockchain Stats utlity exports daily statistics for the monero blockchain from creation through current state.
-
-## Usage:
-
-See also the utility's help option. `monero-blockchain-stats --help`
-
-From the command line run:
-
-`$ monero-blockchain-stats`
-
-This loads the existing blockchain and prints the results to the terminal. Default printed data includes Blocks per Day, Total Blocks,	Transactions per Day, Total Transactions, Bytes per Day and Total Bytes. The format of the output is in tab delimited csv which is printed to the console. Piping the output of the command to a csv file allows for saving the output of the utilty to a file.
-i.e. `monero-blockchain-stats > stats.csv` 
-
-### Options
-`--data-dir arg` 
-to specify location of blockchain storage
-
-`--testnet` 
-Run on testnet.
-
-`--stagenet`
-Run on stagenet.
-
-`--log-level arg`
-0-4 or categories
-
-`--block-start arg (=0)`
-start at block number
-
-`--block-stop arg (=0)`
-Stop at block number
-
-`--with-inputs`
-with input stats
-
-`--with-outputs`
-with output stats
-
-`--with-ringsize`
-with ringsize stats
-
-`--with-hours`
-with txns per hour
-
-`--with-emission`
-with coin emission
-
-`--with-fees`
-with txn fees
-
-`--with-diff`
-with difficulty

src/blockchain_utilities/blockchain_ancestry.cpp

@@ -32,7 +32,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/archive/portable_binary_iarchive.hpp>
 #include <boost/archive/portable_binary_oarchive.hpp>
-#include <boost/filesystem/path.hpp>
 #include "common/unordered_containers_boost_serialization.h"
 #include "common/command_line.h"
 #include "common/varint.h"
@@ -150,7 +149,7 @@ struct ancestry_state_t
     {
       std::unordered_map<crypto::hash, cryptonote::transaction> old_tx_cache;
       a & old_tx_cache;
-      for (const auto& i: old_tx_cache)
+      for (const auto i: old_tx_cache)
         tx_cache.insert(std::make_pair(i.first, ::tx_data_t(i.second)));
     }
     else
@@ -162,7 +161,7 @@ struct ancestry_state_t
       std::unordered_map<uint64_t, cryptonote::block> old_block_cache;
       a & old_block_cache;
       block_cache.resize(old_block_cache.size());
-      for (const auto& i: old_block_cache)
+      for (const auto i: old_block_cache)
         block_cache[i.first] = i.second;
     }
     else
@@ -576,6 +575,7 @@ int main(int argc, char* argv[])
             {
               add_ancestry(state.ancestry, txid, ancestor{amount, offset});
               // find the tx which created this output
+              bool found = false;
               crypto::hash output_txid;
               if (!get_output_txid(state, db, amount, offset, output_txid))
               {
@@ -693,6 +693,7 @@ int main(int argc, char* argv[])
             add_ancestor(ancestry, amount, offset);
 
             // find the tx which created this output
+            bool found = false;
             crypto::hash output_txid;
             if (!get_output_txid(state, db, amount, offset, output_txid))
             {

src/blockchain_utilities/blockchain_blackball.cpp

@@ -28,7 +28,6 @@
 
 #include <boost/range/adaptor/transformed.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/filesystem.hpp>
 #include "common/unordered_containers_boost_serialization.h"
 #include "common/command_line.h"
 #include "common/varint.h"
@@ -48,6 +47,9 @@ namespace po = boost::program_options;
 using namespace epee;
 using namespace cryptonote;
 
+static const char zerokey[8] = {0};
+static const MDB_val zerokval = { sizeof(zerokey), (void *)zerokey };
+
 static uint64_t records_per_sync = 200;
 static uint64_t db_flags = 0;
 static MDB_dbi dbi_relative_rings;
@@ -388,7 +390,9 @@ static bool for_all_transactions(const std::string &filename, uint64_t &start_id
     cryptonote::transaction_prefix tx;
     blobdata bd;
     bd.assign(reinterpret_cast<char*>(v.mv_data), v.mv_size);
-    binary_archive<false> ba{epee::strspan<std::uint8_t>(bd)};
+    std::stringstream ss;
+    ss << bd;
+    binary_archive<false> ba(ss);
     bool r = do_serialize(ba, tx);
     CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
 
@@ -699,6 +703,7 @@ static void get_per_amount_outputs(MDB_txn *txn, uint64_t amount, uint64_t &tota
   int dbr = mdb_cursor_open(txn, dbi_per_amount, &cur);
   CHECK_AND_ASSERT_THROW_MES(!dbr, "Failed to open cursor for per amount outputs: " + std::string(mdb_strerror(dbr)));
   MDB_val k, v;
+  mdb_size_t count = 0;
   k.mv_size = sizeof(uint64_t);
   k.mv_data = (void*)&amount;
   dbr = mdb_cursor_get(cur, &k, &v, MDB_SET);
@@ -721,6 +726,7 @@ static void inc_per_amount_outputs(MDB_txn *txn, uint64_t amount, uint64_t total
   int dbr = mdb_cursor_open(txn, dbi_per_amount, &cur);
   CHECK_AND_ASSERT_THROW_MES(!dbr, "Failed to open cursor for per amount outputs: " + std::string(mdb_strerror(dbr)));
   MDB_val k, v;
+  mdb_size_t count = 0;
   k.mv_size = sizeof(uint64_t);
   k.mv_data = (void*)&amount;
   dbr = mdb_cursor_get(cur, &k, &v, MDB_SET);
@@ -1071,6 +1077,7 @@ static std::vector<std::pair<uint64_t, uint64_t>> load_outputs(const std::string
       s[len - 1] = 0;
     if (!s[0])
       continue;
+    std::pair<uint64_t, uint64_t> output;
     uint64_t offset, num_offsets;
     if (sscanf(s, "@%" PRIu64, &amount) == 1)
     {
@@ -1262,6 +1269,8 @@ int main(int argc, char* argv[])
 
   LOG_PRINT_L0("Scanning for spent outputs...");
 
+  size_t done = 0;
+
   const uint64_t start_blackballed_outputs = get_num_spent_outputs();
 
   tools::ringdb ringdb(output_file_path.string(), epee::string_tools::pod_to_hex(get_genesis_block_hash(inputs[0])));

src/blockchain_utilities/blockchain_depth.cpp

@@ -27,7 +27,6 @@
 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/range/adaptor/transformed.hpp>
-#include <boost/filesystem/path.hpp>
 #include <boost/algorithm/string.hpp>
 #include "common/command_line.h"
 #include "common/varint.h"

src/blockchain_utilities/blockchain_import.cpp

@@ -146,7 +146,7 @@ int check_flush(cryptonote::core &core, std::vector<block_complete_entry> &block
     if (!parse_and_validate_block_from_blob(b.block, block))
     {
       MERROR("Failed to parse block: "
-          << epee::string_tools::buff_to_hex_nodelimer(b.block));
+          << epee::string_tools::pod_to_hex(get_blob_hash(b.block)));
       core.cleanup_handle_incoming_blocks();
       return 1;
     }
@@ -177,11 +177,8 @@ int check_flush(cryptonote::core &core, std::vector<block_complete_entry> &block
       core.handle_incoming_tx(tx_blob, tvc, relay_method::block, true);
       if(tvc.m_verifivation_failed)
       {
-        cryptonote::transaction transaction;
-        if (cryptonote::parse_and_validate_tx_from_blob(tx_blob.blob, transaction))
-          MERROR("Transaction verification failed, tx_id = " << cryptonote::get_transaction_hash(transaction));
-        else
-          MERROR("Transaction verification failed, transaction is unparsable");
+        MERROR("transaction verification failed, tx_id = "
+            << epee::string_tools::pod_to_hex(get_blob_hash(tx_blob.blob)));
         core.cleanup_handle_incoming_blocks();
         return 1;
       }
@@ -195,11 +192,8 @@ int check_flush(cryptonote::core &core, std::vector<block_complete_entry> &block
 
     if(bvc.m_verifivation_failed)
     {
-      cryptonote::block block;
-      if (cryptonote::parse_and_validate_block_from_blob(block_entry.block, block))
-        MERROR("Block verification failed, id = " << cryptonote::get_block_hash(block));
-      else
-        MERROR("Block verification failed, block is unparsable");
+      MERROR("Block verification failed, id = "
+          << epee::string_tools::pod_to_hex(get_blob_hash(block_entry.block)));
       core.cleanup_handle_incoming_blocks();
       return 1;
     }
@@ -233,7 +227,7 @@ int import_from_file(cryptonote::core& core, const std::string& import_file_path
     return false;
   }
 
-  uint64_t block_first;
+  uint64_t block_first, block_last;
   uint64_t start_height = 1, seek_height;
   if (opt_resume)
     start_height = core.get_blockchain_storage().get_current_blockchain_height();