oxen-io
/
oxen-core
mirror of https://github.com/oxen-io/oxen-core.git
2
1
Fork 0
Code Issues Projects Releases Wiki Activity

cmake modernization 

The archaic (i.e. decade old) cmake usage here really got in the way of
trying to properly use newer libraries (like lokimq), so this undertakes
overhauling it considerably to make it much more sane (and significantly
reduce the size).

I left more of the architecture-specific bits in the top-level
CMakeLists.txt intact; most of the efforts here are about properly
loading dependencies, specifying dependencies and avoiding a whole pile
of cmake antipatterns.

This bumps the required cmake version to 3.5, which is what xenial comes
with.

- extensive use of interface libraries to include libraries,
definitions, and include paths

- use Boost::whatever instead of ${Boost_WHATEVER_LIBRARY}.  The
interface targets are (again) much better as they also give you any
needed include or linking flags without needing to worry about them.

- don't list header files when building things.  This has *never* been
correct cmake usage (cmake has always known how to wallet_rpc_headers
the headers that .cpp files include to know about build changes).

- remove the loki_add_library monstrosity; it breaks target names and
makes compiling less efficient because the author couldn't figure out
how to link things together.

- make loki_add_executable take the output filename, and set the output
path to bin/ and install to bin because *every single usage* of
loki_add_executable was immediately followed by setting the output
filename and setting the output path to bin/ and installing to bin.

- move a bunch of crap that is only used in one particular
src/whatever/CMakeLists.txt into that particular CMakeLists.txt instead
of the top level CMakeLists.txt (or src/CMakeLists.txt).

- Remove a bunch of redundant dependencies; most of them look like they
were just copy-and-pasted in, and many more aren't needed (since they
are implied by the PUBLIC linking of other dependencies).

- Removed `die` since it just does a FATAL_ERROR, but adds color (which
is useless since CMake already makes FATAL_ERRORs perfectly visible).

- Change the way LOKI_DAEMON_AND_WALLET_ONLY works to just change the
make targets to daemon and simplewallet rather than changing the build
process (this should make it faster, too, since there are various other
things that will be excluded).
This commit is contained in:
Jason Rhinelander 2020-03-02 23:57:08 -04:00
parent 997ef13551
commit 5b97ff6e9c
52 changed files with 606 additions and 1783 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -77,7 +77,7 @@ script:
# The wallet code is too bloated to be compiled at -j2 with only 4GB ram, so do the huge ones
# at -j1 and the rest at -j2.
#
make -j1 obj_rpc obj_wallet # core_rpc_server.cpp and wallet2.cpp are hogs
make -j1 rpc wallet # core_rpc_server.cpp and wallet2.cpp are hogs
make -j2 daemon device_trezor # covers most things
make -j1 wallet_rpc_server # another hog, which depends on much of the above
make -j2 # everything else

301
CMakeLists.txt
View File

@ -40,24 +40,11 @@ if (IOS)
INCLUDE(CmakeLists_IOS.txt)
endif()
cmake_minimum_required(VERSION 2.8.7)
cmake_minimum_required(VERSION 3.5)
message(STATUS "CMake version ${CMAKE_VERSION}")
project(loki)
function (die msg)
if (NOT WIN32)
string(ASCII 27 Esc)
set(ColourReset "${Esc}[m")
set(BoldRed "${Esc}[1;31m")
else ()
set(ColourReset "")
set(BoldRed "")
endif ()
message(FATAL_ERROR "${BoldRed}${msg}${ColourReset}")
endfunction ()
function (add_c_flag_if_supported flag var)
string(REPLACE "-" "_" supported ${flag}_c)
check_c_compiler_flag(${flag} ${supported})
@ -174,6 +161,10 @@ else()
set(OPT_FLAGS_RELEASE "-Ofast")
endif()
set(CMAKE_C_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}")
# BUILD_TAG is used to select the build type to check for a new version
if(BUILD_TAG)
message(STATUS "Building build tag ${BUILD_TAG}")
@ -205,18 +196,8 @@ if(NOT MANUAL_SUBMODULES)
endif()
endif()
set(CMAKE_C_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG ${OPT_FLAGS_RELEASE}")
# set this to 0 if per-block checkpoint needs to be disabled
set(PER_BLOCK_CHECKPOINT 1)
if(PER_BLOCK_CHECKPOINT)
add_definitions("-DPER_BLOCK_CHECKPOINT")
set(Blocks "blocks")
else()
set(Blocks "")
endif()
option(PER_BLOCK_CHECKPOINT "Enables per-block checkpointing" ON)
list(INSERT CMAKE_MODULE_PATH 0
"${CMAKE_SOURCE_DIR}/cmake")
@ -294,7 +275,7 @@ endif()
# elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSDI.*")
# set(BSDI TRUE)
include_directories(external/rapidjson/include external/easylogging++ src contrib/epee/include external/cppzmq external)
include_directories(external/rapidjson/include src contrib/epee/include external/cppzmq external)
if(APPLE)
include_directories(SYSTEM /usr/include/malloc)
@ -367,95 +348,15 @@ else()
message(STATUS "Could not find DATABASE in env (not required unless you want to change database type from default: ${DATABASE})")
endif()
set(BERKELEY_DB_OVERRIDE 0)
if (DEFINED ENV{BERKELEY_DB})
set(BERKELEY_DB_OVERRIDE 1)
set(BERKELEY_DB $ENV{BERKELEY_DB})
elseif()
set(BERKELEY_DB 0)
endif()
if (DATABASE STREQUAL "lmdb")
message(STATUS "Using LMDB as default DB type")
set(BLOCKCHAIN_DB DB_LMDB)
add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"")
elseif (DATABASE STREQUAL "berkeleydb")
find_package(BerkeleyDB)
if(NOT BERKELEY_DB)
die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
else()
message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}")
if(BERKELEY_DB_LIBRARIES)
message(STATUS "Found BerkeleyDB shared library")
set(BDB_STATIC false CACHE BOOL "BDB Static flag")
set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path")
set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name")
set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs")
set(BERKELEY_DB 1)
else()
die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
endif()
endif()
message(STATUS "Using Berkeley DB as default DB type")
add_definitions("-DDEFAULT_DB_TYPE=\"berkeley\"")
set(BLOCKCHAIN_DB "lmdb")
else()
die("Invalid database type: ${DATABASE}")
message(FATAL_ERROR "Invalid database type: ${DATABASE}")
endif()
if(BERKELEY_DB)
add_definitions("-DBERKELEY_DB")
endif()
add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
# Can't install hook in static build on OSX, because OSX linker does not support --wrap
# On ARM, having libunwind package (with .so's only) installed breaks static link.
# When possible, avoid stack tracing using libunwind in favor of using easylogging++.
if (APPLE)
set(DEFAULT_STACK_TRACE OFF)
set(LIBUNWIND_LIBRARIES "")
elseif (DEPENDS AND NOT LINUX)
set(DEFAULT_STACK_TRACE OFF)
set(LIBUNWIND_LIBRARIES "")
elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT MINGW)
set(DEFAULT_STACK_TRACE ON)
set(STACK_TRACE_LIB "easylogging++") # for diag output only
set(LIBUNWIND_LIBRARIES "")
elseif (ARM AND STATIC)
set(DEFAULT_STACK_TRACE OFF)
set(LIBUNWIND_LIBRARIES "")
else()
find_package(Libunwind)
if(LIBUNWIND_FOUND)
set(DEFAULT_STACK_TRACE ON)
set(STACK_TRACE_LIB "libunwind") # for diag output only
else()
set(DEFAULT_STACK_TRACE OFF)
set(LIBUNWIND_LIBRARIES "")
endif()
endif()
option(STACK_TRACE "Install a hook that dumps stack on exception" ${DEFAULT_STACK_TRACE})
if(STACK_TRACE)
message(STATUS "Stack trace on exception enabled (using ${STACK_TRACE_LIB})")
else()
message(STATUS "Stack trace on exception disabled")
endif()
if (UNIX AND NOT APPLE)
# Note that at the time of this writing the -Wstrict-prototypes flag added below will make this fail
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads)
add_c_flag_if_supported(-pthread CMAKE_C_FLAGS)
add_cxx_flag_if_supported(-pthread CMAKE_CXX_FLAGS)
endif()
# Handle OpenSSL, used for sha256sum on binary updates and light wallet ssl http
if (CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads")
endif ()
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads)
if (APPLE AND NOT IOS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=x86-64 -fvisibility=default -std=c++14")
@ -469,21 +370,11 @@ endif()
find_package(OpenSSL REQUIRED)
message(STATUS "Using OpenSSL include dir at ${OPENSSL_INCLUDE_DIR}")
include_directories(${OPENSSL_INCLUDE_DIR})
if(STATIC AND NOT IOS)
if(UNIX)
set(OPENSSL_LIBRARIES "${OPENSSL_LIBRARIES};${CMAKE_DL_LIBS};${CMAKE_THREAD_LIBS_INIT}")
endif()
endif()
find_package(HIDAPI)
add_definition_if_library_exists(c memset_s "string.h" HAVE_MEMSET_S)
add_definition_if_library_exists(c explicit_bzero "strings.h" HAVE_EXPLICIT_BZERO)
add_definition_if_function_found(strptime HAVE_STRPTIME)
add_definitions(-DAUTO_INITIALIZE_EASYLOGGINGPP)
# 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
@ -494,41 +385,15 @@ ExternalProject_Add(generate_translations_header
STAMP_DIR ${LRELEASE_PATH}
CMAKE_ARGS -DLRELEASE_PATH=${LRELEASE_PATH}
INSTALL_COMMAND cmake -E echo "")
include_directories("${CMAKE_CURRENT_BINARY_DIR}/translations")
if(POLICY CMP0079)
cmake_policy(SET CMP0079 NEW)
endif()
add_library(libunbound INTERFACE)
add_library(miniupnpc INTERFACE)
add_subdirectory(external)
# Final setup for libunbound
include_directories(${UNBOUND_INCLUDE_DIRS})
link_directories(${UNBOUND_LIBRARY_DIRS})
include_directories(${MINIUPNPC_INCLUDE_DIRS})
link_directories(${MINIUPNPC_LIBRARY_DIRS})
# Final setup for easylogging++
include_directories(${EASYLOGGING_INCLUDE})
link_directories(${EASYLOGGING_LIBRARY_DIRS})
# Final setup for liblmdb
include_directories(${LMDB_INCLUDE})
# Final setup for Berkeley DB
if (BERKELEY_DB)
include_directories(${BDB_INCLUDE})
endif()
# Final setup for libunwind
include_directories(${LIBUNWIND_INCLUDE})
link_directories(${LIBUNWIND_LIBRARY_DIRS})
# Final setup for hid
if (HIDAPI_FOUND)
message(STATUS "Using HIDAPI include dir at ${HIDAPI_INCLUDE_DIR}")
add_definitions(-DHAVE_HIDAPI)
include_directories(${HIDAPI_INCLUDE_DIR})
link_directories(${LIBHIDAPI_LIBRARY_DIRS})
else (HIDAPI_FOUND)
message(STATUS "Could not find HIDAPI")
endif()
target_compile_definitions(easylogging PRIVATE AUTO_INITIALIZE_EASYLOGGINGPP)
# Trezor support check
include(CheckTrezor)
@ -578,36 +443,6 @@ else()
endif()
endif()
option(NO_AES "Explicitly disable AES support" ${NO_AES})
if(NO_AES)
message(STATUS "AES support explicitly disabled")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNO_AES")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNO_AES")
elseif(NOT ARM AND NOT PPC64LE AND NOT PPC64 AND NOT PPC AND NOT S390X)
message(STATUS "AES support enabled")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
elseif(PPC64LE OR PPC64 OR PPC)
message(STATUS "AES support not available on POWER")
elseif(S390X)
message(STATUS "AES support not available on s390x")
elseif(ARM6)
message(STATUS "AES support not available on ARMv6")
elseif(ARM7)
message(STATUS "AES support not available on ARMv7")
elseif(ARM8)
CHECK_CXX_ACCEPTS_FLAG("-march=${ARCH}+crypto" ARCH_PLUS_CRYPTO)
if(ARCH_PLUS_CRYPTO)
message(STATUS "Crypto extensions enabled for ARMv8")
set(ARCH_FLAG "-march=${ARCH}+crypto")
else()
message(STATUS "Crypto extensions unavailable on your ARMv8 device")
endif()
else()
message(STATUS "AES support disabled")
endif()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH_FLAG}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARCH_FLAG}")
@ -913,11 +748,12 @@ if(STATIC)
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON)
endif()
set(Boost_USE_MULTITHREADED TRUE) # Needed for macOS, at least, and won't hurt elsewhere
find_package(Boost 1.58 QUIET REQUIRED COMPONENTS system filesystem thread date_time chrono regex serialization program_options locale)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${OLD_LIB_SUFFIXES})
if(NOT Boost_FOUND)
die("Could not find Boost libraries, please make sure you have installed Boost or libboost-all-dev (>=1.58) or the equivalent")
message(FATAL_ERROR "Could not find Boost libraries, please make sure you have installed Boost or libboost-all-dev (>=1.58) or the equivalent")
elseif(Boost_FOUND)
message(STATUS "Found Boost Version: ${Boost_VERSION}")
if (Boost_VERSION VERSION_LESS 10 AND Boost_VERSION VERSION_LESS 1.62.0 AND NOT (OPENSSL_VERSION VERSION_LESS 1.1))
@ -933,58 +769,62 @@ elseif(Boost_FOUND)
endif()
endif()
include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
# Interface target for random extra system libraries that we need to link everything against
add_library(extra INTERFACE)
target_link_libraries(extra INTERFACE ${CMAKE_DL_LIBS})
target_link_libraries(extra INTERFACE Boost::boost)
target_link_libraries(extra INTERFACE Threads::Threads)
# Interface target for ICU libs (if needed)
add_library(icu INTERFACE)
if(MINGW)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wa,-mbig-obj")
set(EXTRA_LIBRARIES mswsock;ws2_32;iphlpapi;crypt32;bcrypt)
target_link_libraries(extra INTERFACE mswsock ws2_32 iphlpapi crypt32 bcrypt)
target_link_libraries(icu INTERFACE icuio icuuc icutu iconv)
if(DEPENDS)
set(ICU_LIBRARIES icuio icui18n icuuc icudata icutu iconv)
target_link_libraries(icu INTERFACE icui18n icudata)
else()
set(ICU_LIBRARIES icuio icuin icuuc icudt icutu iconv)
target_link_libraries(icu INTERFACE icuin icudt)
endif()
elseif(APPLE OR OPENBSD OR ANDROID)
set(EXTRA_LIBRARIES "")
elseif(FREEBSD)
set(EXTRA_LIBRARIES execinfo)
target_link_libraries(extra INTERFACE execinfo)
elseif(DRAGONFLY)
find_library(COMPAT compat)
set(EXTRA_LIBRARIES execinfo ${COMPAT})
target_link_libraries(extra INTERFACE ${COMPAT})
elseif(CMAKE_SYSTEM_NAME MATCHES "(SunOS|Solaris)")
set(EXTRA_LIBRARIES socket nsl resolv)
elseif(NOT MSVC AND NOT DEPENDS)
target_link_libraries(extra INTERFACE socket nsl resolv)
elseif(APPLE)
if(DEPENDS)
target_link_libraries(extra INTERFACE "-framework Foundation" "-framework IOKit" "-framework AppKit" "-framework IOKit")
else()
find_library(COREFOUNDATION CoreFoundation)
find_library(IOKIT IOKit)
target_link_libraries(extra INTERFACE ${IOKIT} ${COREFOUNDATION})
endif()
elseif(NOT (MSVC OR DEPENDS OR APPLE OR OPENBSD OR ANDROID))
find_library(RT rt)
set(EXTRA_LIBRARIES ${RT})
target_link_libraries(extra INTERFACE rt)
endif()
list(APPEND EXTRA_LIBRARIES ${CMAKE_DL_LIBS})
if (HIDAPI_FOUND OR LibUSB_COMPILE_TEST_PASSED)
if (APPLE)
if(DEPENDS)
list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework IOKit")
else()
find_library(COREFOUNDATION CoreFoundation)
find_library(IOKIT IOKit)
list(APPEND EXTRA_LIBRARIES ${IOKIT})
list(APPEND EXTRA_LIBRARIES ${COREFOUNDATION})
endif()
endif()
if (WIN32)
list(APPEND EXTRA_LIBRARIES setupapi)
endif()
if (WIN32)
target_link_libraries(extra INTERFACE setupapi)
endif()
add_library(readline INTERFACE)
if (BUILD_INTEGRATION)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D LOKI_ENABLE_INTEGRATION_TEST_HOOKS")
target_compile_definitions(extra INTERFACE LOKI_ENABLE_INTEGRATION_TEST_HOOKS)
else()
option(USE_READLINE "Build with GNU readline support." ON)
if(USE_READLINE AND NOT DEPENDS)
find_package(Readline)
if(READLINE_FOUND AND GNU_READLINE_FOUND)
add_definitions(-DHAVE_READLINE)
include_directories(${Readline_INCLUDE_DIR})
message(STATUS "Found readline library at: ${Readline_ROOT_DIR}")
set(EPEE_READLINE epee_readline)
target_link_libraries(readline INTERFACE ${GNU_READLINE_LIBRARY} epee_readline)
target_include_directories(readline INTERFACE ${Readline_INCLUDE_DIR})
target_compile_definitions(readline INTERFACE HAVE_READLINE)
message(STATUS "Found readline library at: ${GNU_READLINE_LIBRARY}")
else()
message(STATUS "Could not find GNU readline library so building without readline support")
endif()
@ -992,21 +832,19 @@ else()
find_path(Readline_INCLUDE_PATH readline/readline.h)
find_library(Readline_LIBRARY readline)
find_library(Terminfo_LIBRARY tinfo)
set(Readline_LIBRARY "${Readline_LIBRARY};${Terminfo_LIBRARY}")
set(GNU_READLINE_LIBRARY ${Readline_LIBRARY})
add_definitions(-DHAVE_READLINE)
set(EPEE_READLINE epee_readline)
target_link_libraries(readline INTERFACE ${Readline_LIBRARY} ${Terminfo_LIBRARY})
target_include_directories(readline INTERFACE ${Readline_INCLUDE_PATH})
target_compile_definitions(readline INTERFACE HAVE_READLINE)
endif()
endif()
if(ANDROID)
set(ATOMIC libatomic.a)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=user-defined-warnings")
target_compile_options(extra INTERFACE "-Wno-error=user-defined-warnings")
endif()
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})
target_link_libraries(extra INTERFACE ${ATOMIC})
endif()
endif()
@ -1019,17 +857,26 @@ if(NOT ZMQ_LIBRARIES) # may be already set (such as by contrib/depends toolchain
find_package(PkgConfig REQUIRED)
pkg_check_modules(ZMQ REQUIRED libzmq)
endif()
add_library(sodium INTERFACE)
if(NOT SODIUM_LIBRARIES)
find_package(PkgConfig REQUIRED)
pkg_check_modules(SODIUM REQUIRED libsodium)
endif()
find_library(sodium_link_libs NAMES ${SODIUM_LIBRARIES} PATHS ${SODIUM_LIBRARY_DIRS})
target_link_libraries(sodium INTERFACE ${sodium_link_libs})
target_include_directories(sodium INTERFACE ${SODIUM_INCLUDE_DIRS})
add_library(sqlite3 INTERFACE)
if (NOT SQLITE3_LIBRARIES)
find_package(PkgConfig REQUIRED)
pkg_check_modules(SQLITE3 REQUIRED sqlite3)
endif()
include_directories(${ZMQ_INCLUDE_DIRS} ${SODIUM_INCLUDE_DIRS} ${SQLITE3_INCLUDE_DIRS})
link_directories(${ZMQ_LIBRARY_DIRS} ${SODIUM_LIBRARY_DIRS} ${SQLITE3_LIBRARY_DIRS})
find_library(sqlite3_link_libs NAMES ${SQLITE3_LIBRARIES} PATHS ${SQLITE3_LIBRARY_DIRS})
message(STATUS "sqlite3: ${SQLITE3_LIBRARIES} ${sqlite3_link_libs}")
target_link_libraries(sqlite3 INTERFACE ${sqlite3_link_libs})
target_include_directories(sqlite3 INTERFACE ${SQLITE3_INCLUDE_DIRS})
add_subdirectory(contrib)
add_subdirectory(src)
@ -1067,5 +914,3 @@ option(BUILD_GUI_DEPS "Build GUI dependencies." OFF)
# on libunbound shipped with their distribution instead
option(INSTALL_VENDORED_LIBUNBOUND "Install libunbound binary built from source vendored with this repo." OFF)
CHECK_C_COMPILER_FLAG(-std=c11 HAVE_C11)

2
Makefile
View File

@ -181,6 +181,6 @@ tags:
# Debug Target for Developers: Only build daemon and wallet
developer-daemon-and-wallet:
mkdir -p $(builddir)/debug
cd $(builddir)/debug && cmake -D CMAKE_BUILD_TYPE=Debug -D BUILD_TESTS=OFF -D WARNINGS_AS_ERRORS=ON -D LOKI_DAEMON_AND_WALLET_ONLY=ON $(topdir) && $(MAKE)
cd $(builddir)/debug && cmake -D CMAKE_BUILD_TYPE=Debug -D BUILD_TESTS=OFF -D WARNINGS_AS_ERRORS=ON $(topdir) && $(MAKE) daemon simplewallet
.PHONY: all cmake-debug debug debug-test debug-all cmake-release release release-test release-all clean tags developer_daemon_and_wallet

27
contrib/epee/src/CMakeLists.txt
View File

@ -29,8 +29,15 @@
add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp net_helper.cpp net_utils_base.cpp string_tools.cpp wipeable_string.cpp memwipe.c
connection_basic.cpp network_throttle.cpp network_throttle-detail.cpp mlocker.cpp buffer.cpp net_ssl.cpp)
if (USE_READLINE AND (GNU_READLINE_FOUND OR DEPENDS AND NOT MINGW))
if (USE_READLINE AND (GNU_READLINE_FOUND OR (DEPENDS AND NOT MINGW)))
add_library(epee_readline STATIC readline_buffer.cpp)
target_link_libraries(epee_readline
PUBLIC
easylogging
readline
)
else()
add_library(epee_readline INTERFACE)
endif()
if(HAVE_C11)
@ -55,17 +62,9 @@ endif()
target_link_libraries(epee
PUBLIC
easylogging
${Boost_CHRONO_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
PRIVATE
${OPENSSL_LIBRARIES}
${EXTRA_LIBRARIES})
if (USE_READLINE AND (GNU_READLINE_FOUND OR DEPENDS AND NOT MINGW))
target_link_libraries(epee_readline
PUBLIC
easylogging
PRIVATE
${GNU_READLINE_LIBRARY})
endif()
Boost::filesystem
Boost::thread
OpenSSL::SSL
OpenSSL::Crypto
extra)

1
contrib/epee/src/network_throttle-detail.cpp
View File

@ -44,7 +44,6 @@
#include "net/net_utils_base.h"
#include "misc_log_ex.h"
#include <boost/chrono.hpp>
#include "misc_language.h"
#include "pragma_comp_defs.h"
#include <sstream>

40
external/CMakeLists.txt vendored
View File

@ -43,24 +43,24 @@ if(NOT STATIC)
endif()
if(MINIUPNPC_FOUND)
find_library(miniupnpc_link_libs NAMES ${MINIUPNPC_LIBRARIES} PATHS ${MINIUPNPC_LIBRARY_DIRS})
message(STATUS "Found miniupnpc")
set(MINIUPNPC_LIBRARIES "${MINIUPNPC_LIBRARIES}" PARENT_SCOPE)
set(MINIUPNPC_INCLUDE_DIRS "${MINIUPNPC_INCLUDE_DIRS}" PARENT_SCOPE)
set(MINIUPNPC_LIBRARY_DIRS "${MINIUPNPC_LIBRARY_DIRS}" PARENT_SCOPE)
message(STATUS "${MINIUPNPC_LIBRARIES} ${miniupnpc_link_libs}")
target_link_libraries(miniupnpc INTERFACE ${miniupnpc_link_libs})
target_include_directories(miniupnpc INTERFACE ${MINIUPNPC_INCLUDE_DIRS})
else()
message(STATUS "Using in-tree miniupnpc")
add_subdirectory(miniupnp/miniupnpc)
set_property(TARGET libminiupnpc-static PROPERTY FOLDER "external")
if(MSVC)
set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -wd4244 -wd4267")
elseif(NOT MSVC)
set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-undef -Wno-unused-result -Wno-unused-value")
target_compile_options(libminiupnpc-static PRIVATE -wd4244 -wd4267)
else()
target_compile_options(libminiupnpc-static PRIVATE -Wno-undef -Wno-unused-result -Wno-unused-value)
endif()
if(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
set_property(TARGET libminiupnpc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -D_NETBSD_SOURCE")
target_compile_definitions(libminiupnpc-static PRIVATE _NETBSD_SOURCE)
endif()
set(MINIUPNPC_LIBRARIES "libminiupnpc-static" PARENT_SCOPE)
target_link_libraries(miniupnpc INTERFACE libminiupnpc-static)
endif()
@ -72,22 +72,18 @@ if(NOT UNBOUND_FOUND)
# static OpenSSL libraries set up there after with target_link_libraries.
message(STATUS "Using in-tree unbound")
add_subdirectory(unbound)
set(UNBOUND_STATIC true PARENT_SCOPE)
set(UNBOUND_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/unbound/libunbound" PARENT_SCOPE)
set(UNBOUND_LIBRARIES "unbound" PARENT_SCOPE)
set(UNBOUND_LIBRARY_DIRS "${LIBEVENT2_LIBDIR}" PARENT_SCOPE)
target_link_libraries(libunbound INTERFACE unbound)
target_include_directories(libunbound INTERFACE unbound/libunbound)
else()
message(STATUS "Found libunbound include (unbound.h) in ${UNBOUND_INCLUDE_DIRS}")
if(UNBOUND_LIBRARIES)
message(STATUS "Found libunbound shared library")
set(UNBOUND_STATIC false PARENT_SCOPE)
set(UNBOUND_INCLUDE_DIRS ${UNBOUND_INCLUDE_DIRS} PARENT_SCOPE)
set(UNBOUND_LIBRARIES ${UNBOUND_LIBRARIES} PARENT_SCOPE)
set(UNBOUND_LIBRARY_DIRS "${UNBOUND_LIBRARY_DIRS}" PARENT_SCOPE)
else()
die("Found libunbound includes, but could not find libunbound library. Please make sure you have installed libunbound or libunbound-dev or the equivalent")
if(NOT UNBOUND_LIBRARIES)
message(FATAL_ERROR "Found libunbound includes, but could not find libunbound library. Please make sure you have installed libunbound or libunbound-dev or the equivalent")
endif()
find_library(unbound_link_libs NAMES ${UNBOUND_LIBRARIES} PATHS ${UNBOUND_LIBRARY_DIRS})
message(STATUS "${UNBOUND_LIBRARIES} ${unbound_link_libs}")
target_link_libraries(libunbound INTERFACE ${unbound_link_libs})
target_include_directories(libunbound INTERFACE ${UNBOUND_INCLUDE_DIRS})
endif()
add_subdirectory(db_drivers)

38
external/db_drivers/liblmdb/CMakeLists.txt vendored
View File

@ -26,30 +26,23 @@
# 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.
if(FREEBSD)
add_definitions(-DMDB_DSYNC=O_SYNC)
endif()
if(ANDROID)
add_definitions("-DANDROID=1")
endif()
set (lmdb_sources
mdb.c
midl.c)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
add_library(lmdb
${lmdb_sources})
target_link_libraries(lmdb
PRIVATE
${CMAKE_THREAD_LIBS_INIT})
if(${ARCH_WIDTH} EQUAL 32)
target_compile_definitions(lmdb
PUBLIC -DMDB_VL32)
mdb.c
midl.c)
if(FREEBSD)
target_compile_definitions(lmdb PRIVATE MDB_DSYNC=O_SYNC)
endif()
if(ANDROID)
target_compile_definitions(lmdb PRIVATE ANDROID=1)
endif()
if(${ARCH_WIDTH} EQUAL 32)
target_compile_definitions(lmdb PUBLIC MDB_VL32)
endif()
target_include_directories(lmdb PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
target_link_libraries(lmdb PRIVATE Threads::Threads)
set_property(TARGET lmdb PROPERTY POSITION_INDEPENDENT_CODE ON)
# GUI/libwallet install target
if (BUILD_GUI_DEPS)
@ -62,4 +55,3 @@ if (BUILD_GUI_DEPS)
ARCHIVE DESTINATION ${lib_folder}
LIBRARY DESTINATION ${lib_folder})
endif()
set_property(TARGET lmdb APPEND PROPERTY COMPILE_FLAGS "-fPIC")

26
external/easylogging++/CMakeLists.txt vendored
View File

@ -26,32 +26,32 @@
# 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 2.8.7)
cmake_minimum_required(VERSION 3.5)
project(easylogging CXX)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(flags "-fPIC")
find_package(Threads)
find_package(Backtrace)
add_library(easylogging
easylogging++.cc)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
include_directories("${CMAKE_CURRENT_BINARY_DIR}")
set_property(TARGET easylogging PROPERTY POSITION_INDEPENDENT_CODE ON)
set_property(TARGET easylogging PROPERTY CXX_STANDARD 11)
set_property(TARGET easylogging PROPERTY CXX_STANDARD_REQUIRED ON)
find_package(Threads)
find_package(Backtrace)
target_include_directories(easylogging PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
target_link_libraries(easylogging
PRIVATE
${CMAKE_THREAD_LIBS_INIT}
Threads::Threads
${Backtrace_LIBRARIES})
# GUI/libwallet install target
if (BUILD_GUI_DEPS)
if(IOS)
set(lib_folder lib-${ARCH})
set(flags "${flags} -fno-stack-check")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-stack-check")
target_compile_options(easylogging PUBLIC -fno-stack-check)
else()
set(lib_folder lib)
endif()
@ -59,5 +59,3 @@ if (BUILD_GUI_DEPS)
ARCHIVE DESTINATION ${lib_folder}
LIBRARY DESTINATION ${lib_folder})
endif()
set_property(TARGET easylogging APPEND PROPERTY COMPILE_FLAGS "${flags}")

2
external/randomx vendored

@ -1 +1 @@
Subproject commit eeb3559c368b7fd26446c280d657955a93caa92f
Subproject commit aacf457e37cf4538a6c3abc9f016e2dcf7621b8d

77
src/CMakeLists.txt
View File

@ -29,34 +29,14 @@
#
# Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
if (WIN32 OR STATIC)
add_definitions(-DSTATICLIB)
# miniupnp changed their static define
add_definitions(-DMINIUPNP_STATICLIB)
endif ()
# warnings are cleared only for GCC on Linux
if (NOT (MINGW OR APPLE OR FREEBSD OR OPENBSD OR DRAGONFLY))
add_compile_options("${WARNINGS_AS_ERRORS_FLAG}") # applies only to targets that follow
endif()
function (loki_private_headers group)
source_group("${group}\\Private"
FILES
${ARGN})
endfunction ()
function (loki_install_headers subdir)
install(
FILES ${ARGN}
DESTINATION "include/${subdir}"
COMPONENT development)
endfunction ()
function (enable_stack_trace target)
if(STACK_TRACE)
set_property(TARGET ${target}
APPEND PROPERTY COMPILE_DEFINITIONS "STACK_TRACE")
target_compile_definitions("${target}" PRIVATE STACK_TRACE)
if (STATIC)
set_property(TARGET "${target}"
APPEND PROPERTY LINK_FLAGS "-Wl,--wrap=__cxa_throw")
@ -64,50 +44,19 @@ function (enable_stack_trace target)
endif()
endfunction()
function (loki_add_executable name)
source_group("${name}"
FILES
${ARGN})
add_executable("${name}"
${ARGN})
target_link_libraries("${name}"
PRIVATE
${EXTRA_LIBRARIES})
set_property(TARGET "${name}"
PROPERTY
FOLDER "prog")
set_property(TARGET "${name}"
PROPERTY
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
enable_stack_trace("${name}")
endfunction ()
function (loki_add_library name)
loki_add_library_with_deps(NAME "${name}" SOURCES ${ARGN})
endfunction()
function (loki_add_library_with_deps)
cmake_parse_arguments(LOKI_ADD_LIBRARY "" "NAME" "DEPENDS;SOURCES" ${ARGN})
source_group("${LOKI_ADD_LIBRARY_NAME}" FILES ${LOKI_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_${LOKI_ADD_LIBRARY_NAME})
add_library(${objlib} OBJECT ${LOKI_ADD_LIBRARY_SOURCES})
add_library("${LOKI_ADD_LIBRARY_NAME}" $<TARGET_OBJECTS:${objlib}>)
if (LOKI_ADD_LIBRARY_DEPENDS)
add_dependencies(${objlib} ${LOKI_ADD_LIBRARY_DEPENDS})
endif()
set_property(TARGET "${LOKI_ADD_LIBRARY_NAME}" PROPERTY FOLDER "libs")
target_compile_definitions(${objlib}
PRIVATE $<TARGET_PROPERTY:${LOKI_ADD_LIBRARY_NAME},INTERFACE_COMPILE_DEFINITIONS>)
function (loki_add_executable target binary)
add_executable("${target}" ${ARGN})
target_link_libraries("${target}" PRIVATE extra)
enable_stack_trace("${target}")
set_target_properties("${target}" PROPERTIES
OUTPUT_NAME "${binary}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
install(TARGETS "${target}" DESTINATION bin)
endfunction ()
include(Version)
loki_add_library(version SOURCES ${CMAKE_BINARY_DIR}/version.cpp DEPENDS genversion)
add_library(version ${CMAKE_BINARY_DIR}/version.cpp)
add_dependencies(version genversion)
add_subdirectory(common)
add_subdirectory(crypto)
@ -124,7 +73,7 @@ add_subdirectory(cryptonote_protocol)
add_subdirectory(quorumnet)
if(NOT IOS)
if (NOT LOKI_DAEMON_AND_WALLET_ONLY AND NOT BUILD_INTEGRATION)
if (NOT BUILD_INTEGRATION)
add_subdirectory(gen_multisig)
add_subdirectory(blockchain_utilities)
endif()
@ -138,7 +87,7 @@ if(NOT IOS)
endif()
if(CMAKE_BUILD_TYPE STREQUAL Debug)
if (NOT LOKI_DAEMON_AND_WALLET_ONLY AND NOT BUILD_INTEGRATION)
if (NOT BUILD_INTEGRATION)
add_subdirectory(debug_utilities)
endif()
endif()

50
src/blockchain_db/CMakeLists.txt
View File

@ -27,47 +27,21 @@
# 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(blockchain_db_sources
add_library(blockchain_db
blockchain_db.cpp
lmdb/db_lmdb.cpp
)
if (BERKELEY_DB)
set(blockchain_db_sources
${blockchain_db_sources}
berkeleydb/db_bdb.cpp
)
endif()
set(blockchain_db_headers)
set(blockchain_db_private_headers
blockchain_db.h
lmdb/db_lmdb.h
)
if (BERKELEY_DB)
set(blockchain_db_private_headers
${blockchain_db_private_headers}
berkeleydb/db_bdb.h
)
endif()
loki_private_headers(blockchain_db
${crypto_private_headers})
loki_add_library(blockchain_db
${blockchain_db_sources}
${blockchain_db_headers}
${blockchain_db_private_headers})
target_link_libraries(blockchain_db
PUBLIC
common
cncrypto
ringct
${LMDB_LIBRARY}
${BDB_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
PRIVATE
${EXTRA_LIBRARIES})
common
ringct
lmdb
Boost::filesystem
Boost::thread
extra)
target_compile_definitions(blockchain_db PRIVATE
"DEFAULT_DB_TYPE=\"${BLOCKCHAIN_DB}\""
"BLOCKCHAIN_DB=${BLOCKCHAIN_DB}"
)

320
src/blockchain_utilities/CMakeLists.txt
View File

@ -27,309 +27,81 @@
# 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(blockchain_import_sources
add_library(blockchain_tools_common_libs INTERFACE)
target_link_libraries(blockchain_tools_common_libs INTERFACE
cryptonote_core
blockchain_db
version
Boost::filesystem
Boost::program_options
extra)
loki_add_executable(blockchain_import "loki-blockchain-import"
blockchain_import.cpp
bootstrap_file.cpp
blocksdat_file.cpp
)
set(blockchain_import_private_headers
bootstrap_file.h
blocksdat_file.h
bootstrap_serialization.h
)
target_link_libraries(blockchain_import PRIVATE blockchain_tools_common_libs)
loki_private_headers(blockchain_import
${blockchain_import_private_headers})
if(ARCH_WIDTH)
target_compile_definitions(blockchain_import PRIVATE ARCH_WIDTH=${ARCH_WIDTH})
endif()
set(blockchain_export_sources
loki_add_executable(blockchain_export "loki-blockchain-export"
blockchain_export.cpp
bootstrap_file.cpp
blocksdat_file.cpp
)
set(blockchain_export_private_headers
bootstrap_file.h
blocksdat_file.h
bootstrap_serialization.h
)
loki_private_headers(blockchain_export
${blockchain_export_private_headers})
target_link_libraries(blockchain_export PRIVATE blockchain_tools_common_libs)
set(blockchain_blackball_sources
loki_add_executable(blockchain_blackball "loki-blockchain-mark-spent-outputs"
blockchain_blackball.cpp
)
set(blockchain_blackball_private_headers
bootstrap_file.h
blocksdat_file.h
bootstrap_serialization.h
)
loki_private_headers(blockchain_blackball
${blockchain_blackball_private_headers})
set(blockchain_usage_sources
blockchain_usage.cpp
)
set(blockchain_usage_private_headers)
loki_private_headers(blockchain_usage
${blockchain_usage_private_headers})
set(blockchain_prune_known_spent_data_sources
blockchain_prune_known_spent_data.cpp
)
set(blockchain_prune_known_spent_data_private_headers)
loki_private_headers(blockchain_prune_known_spent_data
${blockchain_prune_known_spent_data_private_headers})
set(blockchain_prune_sources
blockchain_prune.cpp
)
set(blockchain_prune_private_headers)
loki_private_headers(blockchain_prune
${blockchain_prune_private_headers})
set(blockchain_ancestry_sources
blockchain_ancestry.cpp
)
set(blockchain_ancestry_private_headers)
loki_private_headers(blockchain_ancestry
${blockchain_ancestry_private_headers})
set(blockchain_depth_sources
blockchain_depth.cpp
)
set(blockchain_depth_private_headers)
loki_private_headers(blockchain_depth
${blockchain_depth_private_headers})
set(blockchain_stats_sources
blockchain_stats.cpp
)
set(blockchain_stats_private_headers)
loki_private_headers(blockchain_stats
${blockchain_stats_private_headers})
loki_add_executable(blockchain_import
${blockchain_import_sources}
${blockchain_import_private_headers})
target_link_libraries(blockchain_import
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES}
${Blocks})
if(ARCH_WIDTH)
target_compile_definitions(blockchain_import
PUBLIC -DARCH_WIDTH=${ARCH_WIDTH})
endif()
set_property(TARGET blockchain_import
PROPERTY
OUTPUT_NAME "loki-blockchain-import")
install(TARGETS blockchain_import DESTINATION bin)
loki_add_executable(blockchain_export
${blockchain_export_sources}
${blockchain_export_private_headers})
target_link_libraries(blockchain_export
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET blockchain_export
PROPERTY
OUTPUT_NAME "loki-blockchain-export")
install(TARGETS blockchain_export DESTINATION bin)
loki_add_executable(blockchain_blackball
${blockchain_blackball_sources}
${blockchain_blackball_private_headers})
target_link_libraries(blockchain_blackball
PRIVATE
wallet
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET blockchain_blackball
PROPERTY
OUTPUT_NAME "loki-blockchain-mark-spent-outputs")
install(TARGETS blockchain_blackball DESTINATION bin)
blockchain_tools_common_libs
wallet)
loki_add_executable(blockchain_usage
${blockchain_usage_sources}
${blockchain_usage_private_headers})
loki_add_executable(blockchain_usage "loki-blockchain-usage"
blockchain_usage.cpp
)
target_link_libraries(blockchain_usage PRIVATE blockchain_tools_common_libs)
target_link_libraries(blockchain_usage
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
loki_add_executable(blockchain_ancestry "loki-blockchain-ancestry"
blockchain_ancestry.cpp
)
target_link_libraries(blockchain_ancestry PRIVATE blockchain_tools_common_libs)
set_property(TARGET blockchain_usage
PROPERTY
OUTPUT_NAME "loki-blockchain-usage")
install(TARGETS blockchain_usage DESTINATION bin)
loki_add_executable(blockchain_depth "loki-blockchain-depth"
blockchain_depth.cpp
)
target_link_libraries(blockchain_depth PRIVATE blockchain_tools_common_libs)
loki_add_executable(blockchain_ancestry
${blockchain_ancestry_sources}
${blockchain_ancestry_private_headers})
target_link_libraries(blockchain_ancestry
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET blockchain_ancestry
PROPERTY
OUTPUT_NAME "loki-blockchain-ancestry")
install(TARGETS blockchain_ancestry DESTINATION bin)
loki_add_executable(blockchain_depth
${blockchain_depth_sources}
${blockchain_depth_private_headers})
target_link_libraries(blockchain_depth
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET blockchain_depth
PROPERTY
OUTPUT_NAME "loki-blockchain-depth")
install(TARGETS blockchain_depth DESTINATION bin)
loki_add_executable(blockchain_stats
${blockchain_stats_sources}
${blockchain_stats_private_headers})
target_link_libraries(blockchain_stats
PRIVATE
cryptonote_core
blockchain_db
version
epee
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET blockchain_stats
PROPERTY
OUTPUT_NAME "loki-blockchain-stats")
install(TARGETS blockchain_stats DESTINATION bin)
loki_add_executable(blockchain_stats "loki-blockchain-stats"
blockchain_stats.cpp
)
target_link_libraries(blockchain_stats PRIVATE blockchain_tools_common_libs)
# TODO(loki): Blockchain pruning not supported in Loki yet
# loki_add_executable(blockchain_prune_known_spent_data
# ${blockchain_prune_known_spent_data_sources}
# ${blockchain_prune_known_spent_data_private_headers})
# loki_add_executable(blockchain_prune_known_spent_data "loki-blockchain-prune-known-spent-data"
# blockchain_prune_known_spent_data.cpp
# )
#
# target_link_libraries(blockchain_prune_known_spent_data
# PRIVATE
# cryptonote_core
# blockchain_db
# p2p
# version
# epee
# ${Boost_FILESYSTEM_LIBRARY}
# ${Boost_SYSTEM_LIBRARY}
# ${Boost_THREAD_LIBRARY}
# ${CMAKE_THREAD_LIBS_INIT}
# ${EXTRA_LIBRARIES})
# blockchain_tools_common_libs
# p2p)
#
# set_property(TARGET blockchain_prune_known_spent_data
# PROPERTY
# OUTPUT_NAME "loki-blockchain-prune-known-spent-data")
# install(TARGETS blockchain_prune_known_spent_data DESTINATION bin)
#
# loki_add_executable(blockchain_prune
# ${blockchain_prune_sources}
# ${blockchain_prune_private_headers})
#
# set_property(TARGET blockchain_prune
# PROPERTY
# OUTPUT_NAME "loki-blockchain-prune")
# install(TARGETS blockchain_prune DESTINATION bin)
# loki_add_executable(blockchain_prune "loki-blockchain-prune"
# blockchain_prune.cpp
# )
#
# target_link_libraries(blockchain_prune
# PRIVATE
# cryptonote_core
# blockchain_db
# p2p
# version
# epee
# ${Boost_FILESYSTEM_LIBRARY}
# ${Boost_SYSTEM_LIBRARY}
# ${Boost_THREAD_LIBRARY}
# ${CMAKE_THREAD_LIBS_INIT}
# ${EXTRA_LIBRARIES})
# blockchain_tools_common_libs
# p2p)

5
src/blocks/CMakeLists.txt
View File

@ -26,11 +26,10 @@
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
set(GENERATED_SOURCES "")
add_library(blocks STATIC blocks.cpp)
foreach(BLOB_NAME checkpoints testnet_blocks stagenet_blocks)
set(OUTPUT_C_SOURCE "generated_${BLOB_NAME}.c")
list(APPEND GENERATED_SOURCES ${OUTPUT_C_SOURCE})
set(INPUT_DAT_FILE "${BLOB_NAME}.dat")
add_custom_command(
OUTPUT ${OUTPUT_C_SOURCE}
@ -43,6 +42,6 @@ foreach(BLOB_NAME checkpoints testnet_blocks stagenet_blocks)
echo "'};'" >> ${OUTPUT_C_SOURCE} &&
echo "'const\tsize_t\t${BLOB_NAME}_len\t=\tsizeof(${BLOB_NAME});'" >> ${OUTPUT_C_SOURCE}
)
target_sources(blocks PRIVATE ${OUTPUT_C_SOURCE})
endforeach()
add_library(blocks STATIC blocks.cpp ${GENERATED_SOURCES})

42
src/checkpoints/CMakeLists.txt
View File

@ -27,39 +27,15 @@
# 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.
if(APPLE)
if(DEPENDS)
list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework ApplicationServices -framework AppKit -framework IOKit")
else()
find_library(IOKIT_LIBRARY IOKit)
mark_as_advanced(IOKIT_LIBRARY)
list(APPEND EXTRA_LIBRARIES ${IOKIT_LIBRARY})
endif()
endif()
add_library(checkpoints
checkpoints.cpp
)
set(checkpoints_sources
checkpoints.cpp)
set(checkpoints_headers)
set(checkpoints_private_headers
checkpoints.h)
loki_private_headers(checkpoints
${checkpoints_private_headers})
loki_add_library(checkpoints
${checkpoints_sources}
${checkpoints_headers}
${checkpoints_private_headers})
target_link_libraries(checkpoints
PUBLIC
common
cncrypto
${Boost_DATE_TIME_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
PRIVATE
${EXTRA_LIBRARIES})
common
Boost::date_time
Boost::program_options
Boost::serialization
Boost::filesystem
extra)

95
src/common/CMakeLists.txt
View File

@ -27,9 +27,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_directories(SYSTEM ${OPENSSL_INCLUDE_DIR})
set(common_sources
add_library(common
base32z.cpp
base58.cpp
command_line.cpp
@ -55,72 +53,47 @@ set(common_sources
combinator.cpp)
if (STACK_TRACE)
list(APPEND common_sources stack_trace.cpp)
target_sources(common PRIVATE stack_trace.cpp)
if(WIN32 OR STATIC)
target_compile_definitions(common PRIVATE STATICLIB)
endif()
endif()
if (BACKCOMPAT)
list(APPEND common_sources compat/glibc_compat.cpp)
target_sources(common PRIVATE compat/glibc_compat.cpp)
endif()
set(common_headers)
add_dependencies(common generate_translations_header)
set(common_private_headers
apply_permutation.h
base32z.h
base58.h
boost_serialization_helper.h
command_line.h
common_fwd.h
dns_utils.h
download.h
error.h
expect.h
loki.h
http_connection.h
loki_integration_test_hooks.h
notify.h
osrb.h
pruning.h
random.h
rpc_client.h
scoped_message_writer.h
unordered_containers_boost_serialization.h
util.h
varint.h
i18n.h
password.h
perf_timer.h
rules.h
spawn.h
stack_trace.h
threadpool.h
updates.h
aligned.h
timings.h
combinator.h)
loki_private_headers(common
${common_private_headers})
loki_add_library(common
${common_sources}
${common_headers}
${common_private_headers}
DEPENDS generate_translations_header)
target_link_libraries(common
PUBLIC
cncrypto
${UNBOUND_LIBRARIES}
${LIBUNWIND_LIBRARIES}
${Boost_DATE_TIME_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_CHRONO_LIBRARY}
PRIVATE
${OPENSSL_LIBRARIES}
${EPEE_READLINE}
${EXTRA_LIBRARIES})
libunbound
Boost::regex
OpenSSL::SSL
OpenSSL::Crypto
epee_readline
extra)
#monero_install_headers(common
# ${common_headers})
target_include_directories(common PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/../../translations")
option(STACK_TRACE "Install a hook that dumps stack on exception" OFF)
if(STACK_TRACE)
# Can't install hook in static build on OSX, because OSX linker does not support --wrap
# On ARM, having libunwind package (with .so's only) installed breaks static link.
# When possible, avoid stack tracing using libunwind in favor of using easylogging++.
if (APPLE)
elseif (DEPENDS AND NOT LINUX)
elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT MINGW)
target_link_libraries(common PRIVATE easylogging) # for diag output only
elseif (ARM AND STATIC)
else()
find_package(Libunwind)
if(LIBUNWIND_FOUND)
target_link_libraries(common PRIVATE ${LIBUNWIND_LIBRARIES})
target_include_directories(common PRIVATE ${LIBUNWIND_INCLUDE_DIR})
endif()
endif()
endif()

61
src/crypto/CMakeLists.txt
View File

@ -27,7 +27,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.
set(crypto_sources
add_library(cncrypto
aesb.c
blake256.c
chacha.c
@ -53,53 +53,42 @@ set(crypto_sources
rx-slow-hash.c
tree-hash.c)
include_directories(${RANDOMX_INCLUDE})
set(crypto_headers)
set(crypto_private_headers
blake256.h
chacha.h
crypto-ops.h
crypto.h
generic-ops.h
groestl.h
groestl_tables.h
hash-ops.h
hash.h
hmac-keccak.h
initializer.h
jh.h
keccak.h
oaes_config.h
oaes_lib.h
random.h
skein.h
skein_port.h
cn_heavy_hash.hpp)
loki_private_headers(cncrypto
${crypto_private_headers})
loki_add_library(cncrypto
${crypto_sources}
${crypto_headers}
${crypto_private_headers})
target_link_libraries(cncrypto
PUBLIC
epee
randomx
${Boost_SYSTEM_LIBRARY}
${SODIUM_LIBRARIES}
Boost::system
Boost::thread
sodium
PRIVATE
${EXTRA_LIBRARIES})
extra)
# Because of the way Qt works on android with JNI, the code does not live in the main android thread
# So this code runs with a 1 MB default stack size.
# This will force the use of the heap for the allocation of the scratchpad
if (ANDROID OR IOS)
if( BUILD_GUI_DEPS )
add_definitions(-DFORCE_USE_HEAP=1)
target_compile_definitions(cncrypto PUBLIC FORCE_USE_HEAP=1)
endif()
endif()
option(NO_AES "Explicitly disable AES support" ${NO_AES})
if(NO_AES)
message(STATUS "AES support explicitly disabled")
target_compile_definitions(common PRIVATE NO_AES)
elseif(NOT ARM AND NOT PPC64LE AND NOT PPC64 AND NOT PPC AND NOT S390X)
message(STATUS "AES support enabled")
target_compile_options(common PRIVATE "-maes")
elseif(PPC64LE OR PPC64 OR PPC)
message(STATUS "AES support not available on POWER")
elseif(S390X)
message(STATUS "AES support not available on s390x")
elseif(ARM6)
message(STATUS "AES support not available on ARMv6")
elseif(ARM7)
message(STATUS "AES support not available on ARMv7")
else()
message(STATUS "AES support disabled")
endif()

50
src/cryptonote_basic/CMakeLists.txt
View File

@ -27,56 +27,20 @@
# 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.
if(APPLE)
if(DEPENDS)
list(APPEND EXTRA_LIBRARIES "-framework Foundation -framework ApplicationServices -framework AppKit -framework IOKit")
else()
find_library(IOKIT_LIBRARY IOKit)
mark_as_advanced(IOKIT_LIBRARY)
list(APPEND EXTRA_LIBRARIES ${IOKIT_LIBRARY})
endif()
endif()
set(cryptonote_basic_sources
add_library(cryptonote_basic
account.cpp
cryptonote_basic_impl.cpp
cryptonote_format_utils.cpp
difficulty.cpp
hardfork.cpp)
set(cryptonote_basic_headers)
set(cryptonote_basic_private_headers
account.h
account_boost_serialization.h
connection_context.h
cryptonote_basic.h
cryptonote_basic_impl.h
cryptonote_boost_serialization.h
cryptonote_format_utils.h
cryptonote_stat_info.h
difficulty.h
hardfork.h
tx_extra.h
verification_context.h)
loki_private_headers(cryptonote_basic
${cryptonote_basic_private_headers})
loki_add_library(cryptonote_basic
${cryptonote_basic_sources}
${cryptonote_basic_headers}
${cryptonote_basic_private_headers})
target_link_libraries(cryptonote_basic
PUBLIC
PRIVATE
common
cncrypto
checkpoints
device
${Boost_DATE_TIME_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
PRIVATE
${EXTRA_LIBRARIES})
Boost::date_time
Boost::program_options
Boost::serialization
Boost::filesystem
extra)

58
src/cryptonote_core/CMakeLists.txt
View File

@ -27,13 +27,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.
pkg_check_modules(SYSTEMD libsystemd)
if(SYSTEMD_FOUND)
add_definitions(-DENABLE_SYSTEMD)
endif()
set(cryptonote_core_sources
add_library(cryptonote_core
blockchain.cpp
cryptonote_core.cpp
service_node_rules.cpp
@ -48,45 +42,29 @@ set(cryptonote_core_sources
miner.cpp
cryptonote_tx_utils.cpp)
set(cryptonote_core_headers)
set(cryptonote_core_private_headers
blockchain.h
service_node_rules.h
service_node_list.h
service_node_quorum_cop.h
service_node_swarm.h
loki_name_system.h
cryptonote_core.h
service_node_voting.h
tx_blink.h
tx_pool.h
tx_sanity_check.h
miner.h
cryptonote_tx_utils.h)
loki_private_headers(cryptonote_core
${cryptonote_core_private_headers})
loki_add_library(cryptonote_core
${cryptonote_core_sources}
${cryptonote_core_headers}
${cryptonote_core_private_headers})
target_link_libraries(cryptonote_core
PUBLIC
version
common
cncrypto
blockchain_db
multisig
ringct
device
${Boost_DATE_TIME_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
PRIVATE
sqlite3
${SYSTEMD_LIBRARIES}
${EXTRA_LIBRARIES})
PRIVATE
Boost::program_options
Boost::chrono
extra)
pkg_check_modules(SYSTEMD libsystemd)
if(SYSTEMD_FOUND)
target_compile_definitions(cryptonote_core PRIVATE ENABLE_SYSTEMD)
target_link_libraries(cryptonote_core PRIVATE ${SYSTEMD_LIBRARIES})
endif()
if(PER_BLOCK_CHECKPOINT)
target_compile_definitions(cryptonote_core PUBLIC PER_BLOCK_CHECKPOINT)
target_link_libraries(cryptonote_core PUBLIC blocks)
endif()

27
src/cryptonote_protocol/CMakeLists.txt
View File

@ -26,10 +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.
cmake_minimum_required (VERSION 2.6)
project (loki CXX)
set(cryptonote_protocol_sources
add_library(cryptonote_protocol
block_queue.cpp
cryptonote_protocol_handler.inl
quorumnet.cpp
@ -37,25 +34,11 @@ set(cryptonote_protocol_sources
p2p_net_node_instantiation.cpp
)
set(cryptonote_protocol_headers)
set(cryptonote_protocol_private_headers
block_queue.h
cryptonote_protocol_defs.h
cryptonote_protocol_handler_common.h
cryptonote_protocol_handler.h
quorumnet.h
)
loki_private_headers(cryptonote_protocol
${cryptonote_protocol_private_headers})
loki_add_library(cryptonote_protocol
${cryptonote_protocol_sources}
${cryptonote_protocol_headers}
${cryptonote_protocol_private_headers})
target_link_libraries(cryptonote_protocol
PUBLIC
p2p
quorumnet
PRIVATE
${EXTRA_LIBRARIES})
quorumnet
miniupnpc
easylogging
extra)

60
src/daemon/CMakeLists.txt
View File

@ -27,73 +27,29 @@
# 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(daemon_sources
loki_add_executable(daemon "lokid"
command_parser_executor.cpp
command_server.cpp
daemon.cpp
executor.cpp
main.cpp
rpc_command_executor.cpp
)
set(daemon_headers)
set(daemon_private_headers
command_parser_executor.h
command_server.h
core.h
daemon.h
executor.h
p2p.h
protocol.h
rpc.h
rpc_command_executor.h
# cryptonote_protocol
../cryptonote_protocol/cryptonote_protocol_defs.h
../cryptonote_protocol/cryptonote_protocol_handler.h
../cryptonote_protocol/cryptonote_protocol_handler.inl
../cryptonote_protocol/cryptonote_protocol_handler_common.h
# p2p
../p2p/net_node.h
../p2p/net_node_common.h
../p2p/net_peerlist.h
../p2p/net_peerlist_boost_serialization.h
../p2p/p2p_protocol_defs.h
../p2p/stdafx.h)
loki_private_headers(daemon
${daemon_private_headers})
loki_add_executable(daemon
${daemon_sources}
${daemon_headers}
${daemon_private_headers})
)
target_link_libraries(daemon
PRIVATE
rpc
blockchain_db
cryptonote_core
cncrypto
common
p2p
cryptonote_protocol
daemonizer
serialization
daemon_rpc_server
${EPEE_READLINE}
epee_readline
version
${Boost_CHRONO_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
Boost::chrono
Boost::filesystem
Boost::program_options
Boost::system
${ZMQ_LIBRARIES}
${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES}
${Blocks})
set_property(TARGET daemon
PROPERTY
OUTPUT_NAME "lokid")
install(TARGETS daemon DESTINATION bin)
extra)

36
src/daemonizer/CMakeLists.txt
View File

@ -28,48 +28,26 @@
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
if(MSVC OR MINGW)
set(daemonizer_sources
add_library(daemonizer
windows_service.cpp
windows_daemonizer.inl
)
else()
set(daemonizer_sources
add_library(daemonizer
posix_fork.cpp
posix_daemonizer.inl
)
endif()
set(daemonizer_headers
)
if(MSVC OR MINGW)
set(daemonizer_private_headers
daemonizer.h
windows_service.h
windows_service_runner.h
)
else()
set(daemonizer_private_headers
daemonizer.h
posix_fork.h
)
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
add_definitions(-DDEBUG_TMPDIR_LOG=1)
target_compile_definitions(daemonizer PRIVATE DEBUG_TMPDIR_LOG)
endif()
loki_private_headers(daemonizer
${daemonizer_private_headers})
loki_add_library(daemonizer
${daemonizer_sources}
${daemonizer_headers}
${daemonizer_private_headers})
target_link_libraries(daemonizer
PUBLIC
common
${Boost_CHRONO_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
Boost::chrono
Boost::filesystem
Boost::program_options
PRIVATE
${EXTRA_LIBRARIES})
extra)

41
src/debug_utilities/CMakeLists.txt
View File

@ -27,46 +27,23 @@
# 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(cn_deserialize_sources
loki_add_executable(cn_deserialize "loki-utils-deserialize"
cn_deserialize.cpp
)
loki_add_executable(cn_deserialize
${cn_deserialize_sources}
${cn_deserialize_private_headers})
target_link_libraries(cn_deserialize
LINK_PRIVATE
cryptonote_core
blockchain_db
device
ringct
PRIVATE
Boost::program_options
p2p
epee
${CMAKE_THREAD_LIBS_INIT})
extra)
set_property(TARGET cn_deserialize
PROPERTY
OUTPUT_NAME "loki-utils-deserialize")
set(object_sizes_sources
loki_add_executable(object_sizes "loki-utils-object-sizes"
object_sizes.cpp
)
loki_add_executable(object_sizes
${object_sizes_sources}
${object_sizes_private_headers})
target_link_libraries(object_sizes
LINK_PRIVATE
cryptonote_core
blockchain_db
PRIVATE
lmdb
p2p
epee
${CMAKE_THREAD_LIBS_INIT})
set_property(TARGET object_sizes
PROPERTY
OUTPUT_NAME "loki-utils-object-sizes")
extra
)

64
src/device/CMakeLists.txt
View File

@ -27,55 +27,33 @@
# 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(device_sources
add_library(device
device.cpp
device_default.cpp
log.cpp
)
if(HIDAPI_FOUND)
set(device_sources
${device_sources}
target_link_libraries(device
PUBLIC
cncrypto
ringct_basic
OpenSSL::Crypto
Boost::serialization
PRIVATE
version
extra)
find_package(HIDAPI)
if (HIDAPI_FOUND)
message(STATUS "Using HIDAPI ${HIDAPI_LIBRARIES} (includes at ${HIDAPI_INCLUDE_DIR})")
target_sources(device PRIVATE
device_ledger.cpp
device_io_hid.cpp
)
target_compile_definitions(device PUBLIC HAVE_HIDAPI)
target_include_directories(device PRIVATE ${HIDAPI_INCLUDE_DIR})
target_link_libraries(device PRIVATE ${HIDAPI_LIBRARIES})
else (HIDAPI_FOUND)
message(STATUS "Could not find HIDAPI")
endif()
set(device_headers
device.hpp
device_io.hpp
device_default.hpp
device_cold.hpp
log.hpp
)
if(HIDAPI_FOUND)
set(device_headers
${device_headers}
device_ledger.hpp
device_io_hid.hpp
)
endif()
set(device_private_headers)
loki_private_headers(device
${device_private_headers})
loki_add_library(device
${device_sources}
${device_headers}
${device_private_headers})
target_link_libraries(device
PUBLIC
${HIDAPI_LIBRARIES}
cncrypto
ringct_basic
${OPENSSL_CRYPTO_LIBRARIES}
${Boost_SERIALIZATION_LIBRARY}
PRIVATE
version
${Blocks}
${EXTRA_LIBRARIES})

68
src/device_trezor/CMakeLists.txt
View File

@ -26,78 +26,44 @@
# 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(TREZOR_PROTOB_H
trezor/messages/messages.pb.h
trezor/messages/messages-common.pb.h
trezor/messages/messages-management.pb.h
trezor/messages/messages-monero.pb.h
)
# Protobuf and LibUSB processed by CheckTrezor
if(DEVICE_TREZOR_READY)
message(STATUS "Trezor support enabled")
set(TREZOR_PROTOB_CPP
trezor/messages/messages.pb.cc
trezor/messages/messages-common.pb.cc
trezor/messages/messages-management.pb.cc
trezor/messages/messages-monero.pb.cc
)
set(trezor_headers
trezor/exceptions.hpp
trezor/messages_map.hpp
trezor/protocol.hpp
trezor/transport.hpp
device_trezor_base.hpp
device_trezor.hpp
trezor.hpp
${TREZOR_PROTOB_H}
)
set(trezor_sources
add_library(device_trezor
trezor/messages_map.cpp
trezor/protocol.cpp
trezor/transport.cpp
device_trezor_base.cpp
device_trezor.cpp
${TREZOR_PROTOB_CPP}
)
trezor/messages/messages.pb.cc
trezor/messages/messages-common.pb.cc
trezor/messages/messages-management.pb.cc
trezor/messages/messages-monero.pb.cc
)
set(trezor_private_headers)
# Protobuf and LibUSB processed by CheckTrezor
if(DEVICE_TREZOR_READY)
message(STATUS "Trezor support enabled")
if(USE_DEVICE_TREZOR_DEBUG)
list(APPEND trezor_headers trezor/debug_link.hpp trezor/messages/messages-debug.pb.h)
list(APPEND trezor_sources trezor/debug_link.cpp trezor/messages/messages-debug.pb.cc)
target_sources(device_trezor PRIVATE trezor/debug_link.cpp trezor/messages/messages-debug.pb.cc)
message(STATUS "Trezor debugging enabled")
endif()
loki_private_headers(device_trezor
${device_private_headers})
loki_add_library(device_trezor
${trezor_sources}
${trezor_headers}
${trezor_private_headers})
target_link_libraries(device_trezor
PUBLIC
PRIVATE
device
cncrypto
ringct_basic
cryptonote_core
common
${SODIUM_LIBRARIES}
${Boost_CHRONO_LIBRARY}
sodium
Boost::chrono
Boost::regex
${Protobuf_LIBRARY}
${TREZOR_LIBUSB_LIBRARIES}
PRIVATE
${EXTRA_LIBRARIES})
extra)
else()
message(STATUS "Trezor support disabled")
loki_private_headers(device_trezor)
loki_add_library(device_trezor device_trezor.cpp)
target_link_libraries(device_trezor PUBLIC cncrypto)
add_library(device_trezor device_trezor.cpp)
target_link_libraries(device_trezor PRIVATE cncrypto)
endif()

29
src/gen_multisig/CMakeLists.txt
View File

@ -27,29 +27,18 @@
# 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(gen_multisig_sources
gen_multisig.cpp)
loki_add_executable(gen_multisig "loki-gen-trusted-multisig"
gen_multisig.cpp
)
loki_add_executable(gen_multisig
${gen_multisig_sources})
target_link_libraries(gen_multisig
PRIVATE
wallet
cryptonote_core
cncrypto
common
epee
${EPEE_READLINE}
${Boost_CHRONO_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES})
add_dependencies(gen_multisig
version)
set_property(TARGET gen_multisig
PROPERTY
OUTPUT_NAME "loki-gen-trusted-multisig")
install(TARGETS gen_multisig DESTINATION bin)
epee_readline
Boost::chrono
Boost::program_options
Boost::filesystem
version
extra)

10
src/lmdb/CMakeLists.txt
View File

@ -26,8 +26,10 @@
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
set(lmdb_sources database.cpp error.cpp table.cpp value_stream.cpp)
set(lmdb_headers database.h error.h key_stream.h table.h transaction.h util.h value_stream.h)
add_library(lmdb_lib
database.cpp
error.cpp
table.cpp
value_stream.cpp)
loki_add_library(lmdb_lib ${lmdb_sources} ${lmdb_headers})
target_link_libraries(lmdb_lib common ${LMDB_LIBRARY})
target_link_libraries(lmdb_lib PRIVATE common lmdb)

34
src/mnemonics/CMakeLists.txt
View File

@ -27,39 +27,11 @@
# 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(mnemonics_sources
add_library(mnemonics
electrum-words.cpp)
set(mnemonics_headers)
set(mnemonics_private_headers
electrum-words.h
chinese_simplified.h
english.h
dutch.h
french.h
german.h
italian.h
japanese.h
language_base.h
english_old.h
portuguese.h
russian.h
singleton.h
spanish.h
esperanto.h
lojban.h)
loki_private_headers(mnemonics
${mnemonics_private_headers})
loki_add_library(mnemonics
${mnemonics_sources}
${mnemonics_headers}
${mnemonics_private_headers})
target_link_libraries(mnemonics
PUBLIC
PRIVATE
epee
easylogging
${Boost_SYSTEM_LIBRARY}
PRIVATE
${EXTRA_LIBRARIES})
extra)

21
src/multisig/CMakeLists.txt
View File

@ -27,27 +27,12 @@
# 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(multisig_sources
add_library(multisig
multisig.cpp)
set(multisig_headers)
set(multisig_private_headers
multisig.h)
loki_private_headers(multisig
${multisig_private_headers})
loki_add_library(multisig
${multisig_sources}
${multisig_headers}
${multisig_private_headers})
target_link_libraries(multisig
PUBLIC
PRIVATE
ringct
cryptonote_basic
common
cncrypto
PRIVATE
${EXTRA_LIBRARIES})
extra)

19
src/net/CMakeLists.txt
View File

@ -26,9 +26,16 @@
# 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(net_sources error.cpp i2p_address.cpp parse.cpp socks.cpp socks_connect.cpp tor_address.cpp)
set(net_headers error.h i2p_address.h parse.h socks.h socks_connect.h tor_address.h)
loki_add_library(net ${net_sources} ${net_headers})
target_link_libraries(net common epee ${Boost_ASIO_LIBRARY})
add_library(net
error.cpp
i2p_address.cpp
parse.cpp
socks.cpp
socks_connect.cpp
tor_address.cpp
)
target_link_libraries(net PRIVATE
common
epee
extra
)

40
src/p2p/CMakeLists.txt
View File

@ -27,43 +27,21 @@
# 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 2.6)
project (loki CXX)
set(p2p_sources
add_library(p2p
net_node.cpp
net_node.inl
net_peerlist.cpp
)
set(p2p_headers)
set(p2p_private_headers
net_node_common.h
net_node.h
net_peerlist_boost_serialization.h
net_peerlist.h
p2p_protocol_defs.h
stdafx.h
)
loki_private_headers(p2p
${p2p_private_headers})
loki_add_library(p2p
${p2p_sources}
${p2p_headers}
${p2p_private_headers})
target_link_libraries(p2p
PUBLIC
version
cryptonote_core
net
${MINIUPNPC_LIBRARIES}
${Boost_CHRONO_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
PRIVATE
${EXTRA_LIBRARIES})
version
net
miniupnpc
Boost::chrono
Boost::program_options
Boost::filesystem
Boost::serialization
extra)

21
src/quorumnet/CMakeLists.txt
View File

@ -26,23 +26,8 @@
# 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(quorumnet_sources
add_library(quorumnet
sn_network.cpp
bt_serialize.cpp)
set(quorumnet_headers
)
set(quorumnet_private_headers
sn_network.h
bt_serialize.h
common.h
conn_matrix.h)
loki_private_headers(quorumnet
${quorumnet_private_headers})
loki_add_library(quorumnet
${quorumnet_sources}
${quorumnet_headers}
${quorumnet_private_headers})
bt_serialize.cpp
)
target_link_libraries(quorumnet PRIVATE ${ZMQ_LIBRARIES})

42
src/ringct/CMakeLists.txt
View File

@ -27,54 +27,30 @@
# 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(ringct_basic_sources
add_library(ringct_basic
rctOps.cpp
rctTypes.cpp
rctCryptoOps.c
multiexp.cc
bulletproofs.cc)
set(ringct_basic_private_headers
rctOps.h
rctTypes.h
multiexp.h
bulletproofs.h)
loki_private_headers(ringct_basic
${crypto_private_headers})
loki_add_library(ringct_basic
${ringct_basic_sources}
${ringct_basic_private_headers})
target_link_libraries(ringct_basic
PUBLIC
common
cncrypto
PRIVATE
${OPENSSL_LIBRARIES}
${EXTRA_LIBRARIES})
OpenSSL::SSL
OpenSSL::Crypto
extra)
set(ringct_sources
add_library(ringct
rctSigs.cpp
)
set(ringct_headers)
set(ringct_private_headers
rctSigs.h
)
loki_private_headers(ringct
${crypto_private_headers})
loki_add_library(ringct
${ringct_sources}
${ringct_headers}
${ringct_private_headers})
)
target_link_libraries(ringct
PUBLIC
common
cncrypto
cryptonote_basic
device
PRIVATE
${OPENSSL_LIBRARIES}
${EXTRA_LIBRARIES})
OpenSSL::SSL
OpenSSL::Crypto
extra)

105
src/rpc/CMakeLists.txt
View File

@ -27,117 +27,60 @@
# 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(rpc_base_sources
rpc_args.cpp)
add_library(rpc_base
rpc_args.cpp
)
set(rpc_sources
add_library(rpc
core_rpc_server.cpp
rpc_handler.cpp)
rpc_handler.cpp
)
set(daemon_messages_sources
add_library(daemon_messages
message.cpp
daemon_messages.cpp)
daemon_messages.cpp
)
set(daemon_rpc_server_sources
add_library(daemon_rpc_server
daemon_handler.cpp
zmq_server.cpp)
set(rpc_base_headers
rpc_args.h)
set(rpc_headers
rpc_handler.cpp)
set(daemon_rpc_server_headers)
set(rpc_daemon_private_headers
core_rpc_server.h
core_rpc_server_commands_defs.h
core_rpc_server_error_codes.h)
set(daemon_messages_private_headers
message.h
daemon_messages.h)
set(daemon_rpc_server_private_headers
message.h
daemon_messages.h
daemon_handler.h
zmq_server.h)
loki_private_headers(rpc
${rpc_private_headers})
loki_private_headers(daemon_rpc_server
${daemon_rpc_server_private_headers})
loki_add_library(rpc_base
${rpc_base_sources}
${rpc_base_headers}
${rpc_base_private_headers})
loki_add_library(rpc
${rpc_sources}
${rpc_headers}
${rpc_private_headers})
loki_add_library(daemon_messages
${daemon_messages_sources}
${daemon_messages_headers}
${daemon_messages_private_headers})
loki_add_library(daemon_rpc_server
${daemon_rpc_server_sources}
${daemon_rpc_server_headers}
${daemon_rpc_server_private_headers})
zmq_server.cpp
)
target_link_libraries(rpc_base
PUBLIC
common
epee
${Boost_REGEX_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
Boost::thread
Boost::program_options
OpenSSL::SSL
PRIVATE
${EXTRA_LIBRARIES})
extra)
target_link_libraries(rpc
PUBLIC
rpc_base
common
cryptonote_core
cryptonote_protocol
net
version
${Boost_REGEX_LIBRARY}
${Boost_THREAD_LIBRARY}
Boost::regex
PRIVATE
${EXTRA_LIBRARIES})
extra)
target_link_libraries(daemon_messages
LINK_PRIVATE
PRIVATE
cryptonote_core
cryptonote_protocol
version
serialization
${EXTRA_LIBRARIES})
extra)
target_link_libraries(daemon_rpc_server
LINK_PRIVATE
PRIVATE
rpc
cryptonote_core
cryptonote_protocol
version
daemon_messages
serialization
${Boost_CHRONO_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
Boost::chrono
Boost::thread
${ZMQ_LIBRARIES}
${EXTRA_LIBRARIES})
extra)

30
src/serialization/CMakeLists.txt
View File

@ -27,29 +27,15 @@
# 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(serialization_sources
json_object.cpp)
set(serialization_headers)
set(serialization_private_headers
json_object.h)
loki_private_headers(serialization
${serialization_private_headers})
loki_add_library(serialization
${serialization_sources}
${serialization_headers}
${serialization_private_headers})
add_library(serialization
json_object.cpp
)
target_link_libraries(serialization
LINK_PRIVATE
PRIVATE
cryptonote_core
cryptonote_protocol
${Boost_CHRONO_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${EXTRA_LIBRARIES})
add_dependencies(serialization
version)
Boost::chrono
Boost::thread
version
extra)

43
src/simplewallet/CMakeLists.txt
View File

@ -27,41 +27,22 @@
# 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(simplewallet_sources
simplewallet.cpp)
set(simplewallet_headers)
set(simplewallet_private_headers
simplewallet.h)
loki_private_headers(simplewallet
${simplewallet_private_headers})
loki_add_executable(simplewallet
${simplewallet_sources}
${simplewallet_headers}
${simplewallet_private_headers})
loki_add_executable(simplewallet "loki-wallet-cli"
simplewallet.cpp
)
target_link_libraries(simplewallet
PRIVATE
wallet
daemonizer
rpc_base
cryptonote_core
cncrypto
common
mnemonics
${EPEE_READLINE}
version
${Boost_CHRONO_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_LOCALE_LIBRARY}
${ICU_LIBRARIES}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${GNU_READLINE_LIBRARY}
${EXTRA_LIBRARIES})
set_property(TARGET simplewallet
PROPERTY
OUTPUT_NAME "loki-wallet-cli")
install(TARGETS simplewallet DESTINATION bin)
epee_readline
Boost::chrono
Boost::program_options
Boost::filesystem
Boost::locale
Boost::regex
icu
Boost::thread
extra)

109
src/wallet/CMakeLists.txt
View File

@ -27,11 +27,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 (${PROJECT_SOURCE_DIR}/cmake/libutils.cmake)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(wallet_sources
add_library(wallet
wallet2.cpp
wallet_args.cpp
ringdb.cpp
@ -40,83 +36,60 @@ set(wallet_sources
message_transporter.cpp
)
set(wallet_private_headers
wallet2.h
wallet_args.h
wallet_errors.h
wallet_rpc_server.h
wallet_rpc_server_commands_defs.h
wallet_rpc_server_error_codes.h
ringdb.h
node_rpc_proxy.h
message_store.h
message_transporter.h)
loki_private_headers(wallet
${wallet_private_headers})
loki_add_library(wallet
${wallet_sources}
${wallet_private_headers})
target_link_libraries(wallet
PUBLIC
multisig
common
cryptonote_core
mnemonics
device_trezor
net
${LMDB_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_REGEX_LIBRARY}
lmdb
Boost::chrono
Boost::serialization
Boost::filesystem
Boost::thread
PRIVATE
${EXTRA_LIBRARIES})
extra)
if (NOT LOKI_DAEMON_AND_WALLET_ONLY)
set(wallet_rpc_sources
wallet_rpc_server.cpp)
loki_add_executable(wallet_rpc_server "loki-wallet-rpc"
wallet_rpc_server.cpp
)
set(wallet_rpc_headers)
target_link_libraries(wallet_rpc_server
PRIVATE
wallet
rpc_base
daemonizer
epee_readline
Boost::program_options
Boost::regex
extra)
set(wallet_rpc_private_headers
wallet_rpc_server.h)
loki_private_headers(wallet_rpc_server
${wallet_rpc_private_headers})
loki_add_executable(wallet_rpc_server
${wallet_rpc_sources}
${wallet_rpc_headers}
${wallet_rpc_private_headers})
function(combine_archives output_archive)
set(mri_file ${CMAKE_CURRENT_BINARY_DIR}/${output_archive}.mri)
set(FULL_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}/lib${output_archive}.a)
set(mri_content "create ${FULL_OUTPUT_PATH}\n")
FOREACH(in_archive ${ARGN})
string(APPEND mri_content "addlib $<TARGET_FILE:${in_archive}>\n")
ENDFOREACH()
string(APPEND mri_content "save\nend\n")
file(GENERATE OUTPUT ${mri_file} CONTENT "${mri_content}")
target_link_libraries(wallet_rpc_server
PRIVATE
wallet
rpc_base
cryptonote_core
cncrypto
common
version
daemonizer
${EPEE_READLINE}
${Boost_CHRONO_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set_property(TARGET wallet_rpc_server
PROPERTY
OUTPUT_NAME "loki-wallet-rpc")
install(TARGETS wallet_rpc_server DESTINATION bin)
endif()
set(output_archive_dummy_file ${CMAKE_CURRENT_BINARY_DIR}/${output_archive}.dummy.cpp)
add_custom_command(OUTPUT ${output_archive_dummy_file}
COMMAND touch ${output_archive_dummy_file}
DEPENDS ${ARGN})
add_library(${output_archive} STATIC ${output_archive_dummy_file})
add_custom_command(TARGET ${output_archive}
POST_BUILD
COMMAND ar -M < ${mri_file})
endfunction(combine_archives)
# build and install libwallet_merged only if we building for GUI
if (BUILD_GUI_DEPS)
set(libs_to_merge
if (BUILD_GUI_DEPS AND STATIC)
combine_archives(wallet_merged
wallet_api
wallet
multisig
@ -133,10 +106,6 @@ if (BUILD_GUI_DEPS)
net
device_trezor)
foreach(lib ${libs_to_merge})
list(APPEND objlibs $<TARGET_OBJECTS:obj_${lib}>) # matches naming convention in src/CMakeLists.txt
endforeach()
add_library(wallet_merged STATIC ${objlibs})
if(IOS)
set(lib_folder lib-${ARCH})
else()

44
src/wallet/api/CMakeLists.txt
View File

@ -27,11 +27,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 (${PROJECT_SOURCE_DIR}/cmake/libutils.cmake)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(wallet_api_sources
add_library(wallet_api
wallet.cpp
wallet_manager.cpp
transaction_info.cpp
@ -43,45 +39,21 @@ set(wallet_api_sources
subaddress_account.cpp
unsigned_transaction.cpp)
set(wallet_api_headers
wallet2_api.h)
set(wallet_api_private_headers
wallet.h
wallet_manager.h
transaction_info.h
transaction_history.h
pending_transaction.h
common_defines.h
address_book.h
subaddress.h
subaddress_account.h
unsigned_transaction.h)
loki_private_headers(wallet_api
${wallet_api_private_headers})
loki_add_library(wallet_api
${wallet_api_sources}
${wallet_api_headers}
${wallet_api_private_headers})
target_link_libraries(wallet_api
PUBLIC
wallet
common
cryptonote_core
mnemonics
${LMDB_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_REGEX_LIBRARY}
lmdb
Boost::chrono
Boost::serialization
Boost::filesystem
Boost::thread
Boost::regex
PRIVATE
${EXTRA_LIBRARIES})
extra)
set_property(TARGET wallet_api PROPERTY EXCLUDE_FROM_ALL TRUE)
set_property(TARGET obj_wallet_api PROPERTY EXCLUDE_FROM_ALL TRUE)
if(IOS)
set(lib_folder lib-${ARCH})

17
tests/CMakeLists.txt
View File

@ -32,12 +32,6 @@
set(folder "tests")
set(TEST_DATA_DIR "${CMAKE_CURRENT_LIST_DIR}/data")
if (WIN32 AND STATIC)
add_definitions(-DSTATICLIB)
# miniupnp changed their static define
add_definitions(-DMINIUPNP_STATICLIB)
endif ()
find_package(GTest)
if (GTest_FOUND)
@ -93,7 +87,8 @@ add_subdirectory(hash)
add_subdirectory(net_load_tests)
add_subdirectory(network_tests)
if (BUILD_GUI_DEPS)
add_subdirectory(libwallet_api_tests)
# Currently failed to compile
# add_subdirectory(libwallet_api_tests)
endif()
if (TREZOR_DEBUG)
@ -102,14 +97,8 @@ endif()
# add_subdirectory(daemon_tests)
set(hash_targets_sources
hash-target.cpp)
set(hash_targets_headers)
add_executable(hash-target-tests
${hash_targets_sources}
${hash_targets_headers})
hash-target.cpp)
target_link_libraries(hash-target-tests
PRIVATE
cryptonote_core)

10
tests/block_weight/CMakeLists.txt
View File

@ -26,19 +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(block_weight_sources
block_weight.cpp)
set(block_weight_headers)
add_executable(block_weight
${block_weight_sources}
${block_weight_headers})
block_weight.cpp)
target_link_libraries(block_weight
PRIVATE
cryptonote_core
blockchain_db
${EXTRA_LIBRARIES})
extra)
add_test(
NAME block_weight

16
tests/core_proxy/CMakeLists.txt
View File

@ -26,24 +26,20 @@
# 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(core_proxy_sources
core_proxy.cpp)
set(core_proxy_headers
core_proxy.h)
add_executable(core_proxy
${core_proxy_sources}
${core_proxy_headers})
core_proxy.cpp)
target_link_libraries(core_proxy
PRIVATE
cryptonote_core
cryptonote_protocol
p2p
net
version
epee
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::regex
Boost::program_options
miniupnpc
extra)
set_property(TARGET core_proxy
PROPERTY
FOLDER "tests")

30
tests/core_tests/CMakeLists.txt
View File

@ -26,7 +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.
set(core_tests_sources
add_executable(core_tests
# block_reward.cpp
block_validation.cpp
chain_split_1.cpp
@ -46,28 +46,6 @@ set(core_tests_sources
bulletproofs.cpp
wallet_tools.cpp)
set(core_tests_headers
# block_reward.h
block_validation.h
chain_split_1.h
chain_switch_1.h
chaingen.h
chaingen_tests_list.h
double_spend.h
integer_overflow.h
multisig.h
ring_signature_1.h
loki_tests.h
transaction_tests.h
tx_validation.h
v2_tests.h
rct.h
bulletproofs.h
wallet_tools.h)
add_executable(core_tests
${core_tests_sources}
${core_tests_headers})
target_link_libraries(core_tests
PRIVATE
sqlite3
@ -78,8 +56,10 @@ target_link_libraries(core_tests
epee
device
wallet
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::program_options
Boost::regex
miniupnpc
extra)
enable_stack_trace(core_tests)
set_property(TARGET core_tests
PROPERTY

12
tests/crypto/CMakeLists.txt
View File

@ -26,7 +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.
set(crypto_sources
add_executable(cncrypto-tests
crypto-ops-data.c
crypto-ops.c
crypto.cpp
@ -34,17 +34,11 @@ set(crypto_sources
main.cpp
random.c)
set(crypto_headers
crypto-tests.h)
add_executable(cncrypto-tests
${crypto_sources}
${crypto_headers})
target_link_libraries(cncrypto-tests
PRIVATE
common
${Boost_SYSTEM_LIBRARY}
${EXTRA_LIBRARIES})
Boost::system
extra)
set_property(TARGET cncrypto-tests
PROPERTY
FOLDER "tests")

8
tests/daemon_tests/CMakeLists.txt
View File

@ -26,14 +26,8 @@
# 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(transfers_sources
transfers.cpp)
set(transfers_headers)
add_executable(transfers
${transfers_sources}
${transfers_headers})
transfers.cpp)
target_link_libraries(transfers
PRIVATE
useragent

10
tests/difficulty/CMakeLists.txt
View File

@ -26,18 +26,12 @@
# 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(difficulty_sources
difficulty.cpp)
set(difficulty_headers)
add_executable(difficulty-tests
${difficulty_sources}
${difficulty_headers})
difficulty.cpp)
target_link_libraries(difficulty-tests
PRIVATE
cryptonote_core
${EXTRA_LIBRARIES})
extra)
set_property(TARGET difficulty-tests
PROPERTY
FOLDER "tests")

18
tests/functional_tests/CMakeLists.txt
View File

@ -26,29 +26,19 @@
# 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(functional_tests_sources
add_executable(functional_tests
main.cpp
transactions_flow_test.cpp
transactions_generation_from_blockchain.cpp)
set(functional_tests_headers
transactions_flow_test.h
transactions_generation_from_blockchain.h)
add_executable(functional_tests
${functional_tests_sources}
${functional_tests_headers})
target_link_libraries(functional_tests
PRIVATE
cryptonote_core
wallet
common
cncrypto
epee
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::regex
Boost::program_options
extra)
execute_process(COMMAND ${PYTHON_EXECUTABLE} "-c" "import requests; print('OK')" OUTPUT_VARIABLE REQUESTS_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE)
if (REQUESTS_OUTPUT STREQUAL "OK")

74
tests/fuzz/CMakeLists.txt
View File

@ -33,8 +33,7 @@ target_link_libraries(block_fuzz_tests
p2p
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET block_fuzz_tests
PROPERTY
FOLDER "tests")
@ -46,8 +45,7 @@ target_link_libraries(transaction_fuzz_tests
p2p
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET transaction_fuzz_tests
PROPERTY
FOLDER "tests")
@ -60,8 +58,7 @@ target_link_libraries(signature_fuzz_tests
p2p
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET signature_fuzz_tests
PROPERTY
FOLDER "tests")
@ -74,8 +71,7 @@ target_link_libraries(cold-outputs_fuzz_tests
p2p
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET cold-outputs_fuzz_tests
PROPERTY
FOLDER "tests")
@ -88,8 +84,7 @@ target_link_libraries(cold-transaction_fuzz_tests
p2p
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET cold-transaction_fuzz_tests
PROPERTY
FOLDER "tests")
@ -99,9 +94,8 @@ target_link_libraries(load-from-binary_fuzz_tests
PRIVATE
common
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::program_options
extra)
set_property(TARGET load-from-binary_fuzz_tests
PROPERTY
FOLDER "tests")
@ -111,9 +105,8 @@ target_link_libraries(load-from-json_fuzz_tests
PRIVATE
common
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::program_options
extra)
set_property(TARGET load-from-json_fuzz_tests
PROPERTY
FOLDER "tests")
@ -123,9 +116,8 @@ target_link_libraries(base58_fuzz_tests
PRIVATE
common
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::program_options
extra)
set_property(TARGET base58_fuzz_tests
PROPERTY
FOLDER "tests")
@ -134,11 +126,10 @@ add_executable(parse-url_fuzz_tests parse_url.cpp fuzzer.cpp)
target_link_libraries(parse-url_fuzz_tests
PRIVATE
epee
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::regex
Boost::program_options
Boost::system
extra)
set_property(TARGET parse-url_fuzz_tests
PROPERTY
FOLDER "tests")
@ -147,13 +138,12 @@ add_executable(http-client_fuzz_tests http-client.cpp fuzzer.cpp)
target_link_libraries(http-client_fuzz_tests
PRIVATE
epee
${Boost_THREAD_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::thread
Boost::chrono
Boost::regex
Boost::program_options
Boost::system
extra)
set_property(TARGET http-client_fuzz_tests
PROPERTY
FOLDER "tests")
@ -163,12 +153,11 @@ target_link_libraries(levin_fuzz_tests
PRIVATE
common
epee
${Boost_THREAD_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::thread
Boost::chrono
Boost::regex
Boost::program_options
extra)
set_property(TARGET levin_fuzz_tests
PROPERTY
FOLDER "tests")
@ -178,12 +167,11 @@ target_link_libraries(bulletproof_fuzz_tests
PRIVATE
common
epee
${Boost_THREAD_LIBRARY}
${Boost_CHRONO_LIBRARY}
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::thread
Boost::chrono
Boost::regex
Boost::program_options
extra)
set_property(TARGET bulletproof_fuzz_tests
PROPERTY
FOLDER "tests")

11
tests/hash/CMakeLists.txt
View File

@ -26,20 +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(hash_sources
main.cpp)
set(hash_headers)
add_executable(hash-tests
${hash_sources}
${hash_headers})
main.cpp)
target_link_libraries(hash-tests
PRIVATE
cryptonote_core
common
cncrypto
${EXTRA_LIBRARIES})
extra)
set_property(TARGET hash-tests
PROPERTY
FOLDER "tests")

25
tests/libwallet_api_tests/CMakeLists.txt
View File

@ -26,16 +26,8 @@
# 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(libwallet_api_tests_sources
main.cpp
)
set(libwallet_api_tests_headers
)
add_executable(libwallet_api_tests
${libwallet_api_tests_sources}
${libwallet_api_tests_headers})
main.cpp)
target_link_libraries(libwallet_api_tests
PUBLIC
@ -45,16 +37,13 @@ target_link_libraries(libwallet_api_tests
wallet
version
epee
${Boost_CHRONO_LIBRARY}
${Boost_SERIALIZATION_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_THREAD_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_LOCALE_LIBRARY}
${ICU_LIBRARIES}
Boost::chrono
Boost::serialization
Boost::filesystem
Boost::locale
icu
${GTEST_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET libwallet_api_tests
PROPERTY

38
tests/net_load_tests/CMakeLists.txt
View File

@ -26,48 +26,32 @@
# 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(clt_sources
clt.cpp)
set(clt_headers
net_load_tests.h)
add_executable(net_load_tests_clt
${clt_sources}
${clt_headers})
clt.cpp)
target_link_libraries(net_load_tests_clt
PRIVATE
p2p
cryptonote_core
epee
${GTEST_LIBRARIES}
${Boost_CHRONO_LIBRARY}
${Boost_DATE_TIME_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${Boost_THREAD_LIBARRY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
set(srv_sources
srv.cpp)
set(srv_headers
net_load_tests.h)
Boost::chrono
Boost::date_time
Boost::thread
Boost::regex
extra)
add_executable(net_load_tests_srv
${srv_sources}
${srv_headers})
srv.cpp)
target_link_libraries(net_load_tests_srv
PRIVATE
p2p
cryptonote_core
epee
${GTEST_LIBRARIES}
${Boost_CHRONO_LIBRARY}
${Boost_DATE_TIME_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::chrono
Boost::date_time
Boost::regex
extra)
set_property(TARGET net_load_tests_clt net_load_tests_srv
PROPERTY

39
tests/performance_tests/CMakeLists.txt
View File

@ -26,47 +26,18 @@
# 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(performance_tests_sources
main.cpp)
set(performance_tests_headers
check_tx_signature.h
cn_slow_hash.h
construct_tx.h
derive_public_key.h
derive_secret_key.h
ge_frombytes_vartime.h
generate_key_derivation.h
generate_key_image.h
generate_key_image_helper.h
generate_keypair.h
signature.h
is_out_to_acc.h
subaddress_expand.h
range_proof.h
bulletproof.h
crypto_ops.h
sc_reduce32.h
sc_check.h
multiexp.h
multi_tx_test_base.h
performance_tests.h
performance_utils.h
single_tx_test_base.h)
add_executable(performance_tests
${performance_tests_sources}
${performance_tests_headers})
main.cpp)
target_link_libraries(performance_tests
PRIVATE
wallet
cryptonote_core
common
cncrypto
epee
${Boost_CHRONO_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
Boost::chrono
Boost::program_options
Boost::regex
extra)
set_property(TARGET performance_tests
PROPERTY
FOLDER "tests")

23
tests/trezor/CMakeLists.txt
View File

@ -26,24 +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(trezor_tests_sources
add_executable(trezor_tests
tools.cpp
daemon.cpp
trezor_tests.cpp
../core_tests/chaingen.cpp
../core_tests/wallet_tools.cpp)
set(trezor_tests_headers
tools.h
daemon.h
trezor_tests.h
../core_tests/chaingen.h
../core_tests/wallet_tools.h)
add_executable(trezor_tests
${trezor_tests_sources}
${trezor_tests_headers})
target_link_libraries(trezor_tests
PRIVATE
multisig
@ -58,13 +47,11 @@ target_link_libraries(trezor_tests
rpc
cryptonote_protocol
daemon_rpc_server
${Boost_CHRONO_LIBRARY}
${Boost_FILESYSTEM_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SYSTEM_LIBRARY}
Boost::chrono
Boost::filesystem
Boost::program_options
${ZMQ_LIB}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
enable_stack_trace(trezor_tests)
set_property(TARGET trezor_tests

18
tests/unit_tests/CMakeLists.txt
View File

@ -26,7 +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.
set(unit_tests_sources
add_executable(unit_tests
account.cpp
apply_permutation.cpp
address_from_url.cpp
@ -94,12 +94,6 @@ set(unit_tests_sources
is_hdd.cpp
aligned.cpp)
set(unit_tests_headers
unit_tests_utils.h)
add_executable(unit_tests
${unit_tests_sources}
${unit_tests_headers})
target_link_libraries(unit_tests
PRIVATE
ringct
@ -113,11 +107,11 @@ target_link_libraries(unit_tests
wallet
p2p
version
${Boost_CHRONO_LIBRARY}
${Boost_THREAD_LIBRARY}
Boost::chrono
Boost::thread
miniupnpc
${GTEST_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
extra)
set_property(TARGET unit_tests
PROPERTY
FOLDER "tests")
@ -138,5 +132,5 @@ add_test(
COMMAND unit_tests --data-dir "${TEST_DATA_DIR}")
add_executable(test_notifier test_notifier.cpp)
target_link_libraries(test_notifier ${EXTRA_LIBRARIES})
target_link_libraries(test_notifier extra)
set_property(TARGET test_notifier PROPERTY FOLDER "tests")