generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-12 18:40:27 +01:00
Code Issues Projects Releases Wiki Activity
5264d49eab
libzmq/CMakeLists.txt

1089 lines
35 KiB
CMake
Raw Normal View History

First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# CMake build script for ZeroMQ
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cmake_minimum_required (VERSION 2.8.12)
project (ZeroMQ)
cmake: Use project specific source directory instead of top level source tree Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:28:38 +02:00
list (INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_SOURCE_DIR}")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=gnu++11" COMPILER_SUPPORTS_CXX11)
if(COMPILER_SUPPORTS_CXX11)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
endif()
include(CheckCCompilerFlag)
CHECK_C_COMPILER_FLAG("-std=gnu11" COMPILER_SUPPORTS_C11)
if(COMPILER_SUPPORTS_C11)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu11")
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
endif()
Problem: pkgconfig file does not support static link Solution: add dependencies, if necessary, to the .private Libs and Requires field of the pkgconfig file at build time. This way pkg-config --static --libs libzmq will correctly print dependencies if they were used to build the static libzmq.a library.
2016-09-27 19:39:07 +02:00
# Will be used to add flags to pkg-config useful when apps want to statically link
set (pkg_config_libs_private "")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (WITH_OPENPGM "Build with support for OpenPGM" OFF)
option (WITH_VMCI "Build with support for VMware VMCI socket" OFF)
if (APPLE)
Make OS Xframwork build optional
2017-01-27 19:30:18 +01:00
option (ZMQ_BUILD_FRAMEWORK "Build as OS X framework" OFF)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
# Select curve encryption library, defaults to tweetnacl
# To use libsodium instead, use --with-libsodium (must be installed)
# To disable curve, use --disable-curve
option (WITH_LIBSODIUM "Use libsodium instead of built-in tweetnacl" OFF)
option (ENABLE_CURVE "Enable CURVE security" ON)
if (NOT ENABLE_CURVE)
message (STATUS "CURVE security is disabled")
Problem: typo in CMakeLists.txt, can't use sodium Solution: check for WITH_LIBSODIUM configure option instead of WITH_SODIUM
2016-02-11 21:40:34 +01:00
elseif (WITH_LIBSODIUM)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_package (Sodium)
if (SODIUM_FOUND)
message (STATUS "Using libsodium for CURVE security")
include_directories (${SODIUM_INCLUDE_DIRS})
# On Solaris, libsodium depends on libssp
Problem: typo in CMakeLists "matches" keyword Solution: must be upper case
2016-02-11 21:41:18 +01:00
if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ssp)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: HAVE_LIBSODIUM macro is inconsistent Solution: use ZMQ_USE_LIBSODIUM to match ZMQ_USE_TWEETNACL
2016-03-12 15:25:41 +01:00
set (ZMQ_USE_LIBSODIUM 1)
Problem: tweetnacl sources are a mess - they have no copyright / license statement - they are in some randomish directory structure - they are a mix of postable and non-portable files - they do not conform to conditional compile environment Overall, it makes it rather more work than needed, in build scripts. Solution: clean up tweetnacl sauce. - merged code into single tweetnacl.c and .h - standard copyright header, DJB to AUTHORS - moved into src/ along with all other source files - all system and conditional compilation hidden in these files - thus, they can be compiled and packaged in all cases - ZMQ_USE_TWEETNACL is set when we're using built-in tweetnacl - HAVE_LIBSODIUM is set when we're using external libsodium
2016-02-11 18:06:07 +01:00
set (ZMQ_HAVE_CURVE 1)
Problem: pkg-config Requires.private is broken Solution: use only Libs.private to avoid breaking application builds. Even though Requires.private are supposed to be parsed only if pkg-config is called with --static, the --cflags parameter is enough to trigger the parsing, causing build failures for applications that do not (and should not) depend on libzmq's dependencies.
2016-09-28 00:08:40 +02:00
set (pkg_config_libs_private "${pkg_config_libs_private} -lsodium")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
else ()
message (FATAL_ERROR
"libsodium is not installed. Install it, then run CMake again")
endif ()
else ()
message (STATUS "Using tweetnacl for CURVE security")
Problem: tweetnacl sources are a mess - they have no copyright / license statement - they are in some randomish directory structure - they are a mix of postable and non-portable files - they do not conform to conditional compile environment Overall, it makes it rather more work than needed, in build scripts. Solution: clean up tweetnacl sauce. - merged code into single tweetnacl.c and .h - standard copyright header, DJB to AUTHORS - moved into src/ along with all other source files - all system and conditional compilation hidden in these files - thus, they can be compiled and packaged in all cases - ZMQ_USE_TWEETNACL is set when we're using built-in tweetnacl - HAVE_LIBSODIUM is set when we're using external libsodium
2016-02-11 18:06:07 +01:00
list (APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/tweetnacl.c)
set (ZMQ_USE_TWEETNACL 1)
set (ZMQ_HAVE_CURVE 1)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: no support for DRAFT API in build systems Solution: add support for --enable-drafts/ENABLE_DRAFTS=ON in Autools and CMake.
2016-05-02 20:44:35 +02:00
set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
if (EXISTS "${SOURCE_DIR}/.git")
OPTION (ENABLE_DRAFTS "Build and install draft classes and methods" ON)
else ()
OPTION (ENABLE_DRAFTS "Build and install draft classes and methods" OFF)
endif ()
IF (ENABLE_DRAFTS)
ADD_DEFINITIONS (-DZMQ_BUILD_DRAFT_API)
set (pkg_config_defines "-DZMQ_BUILD_DRAFT_API=1")
ELSE (ENABLE_DRAFTS)
set (pkg_config_defines "")
ENDIF (ENABLE_DRAFTS)
Problem: No CMake option to set ZMQ_ACT_MILITANT Solution: Add CMake option called WITH_MILITANT so that it aligns with the Autotools build infrastructure; enabling this option defines ZMQ_ACT_MILITANT, which enables assertions should malformed requests make their way into zmq_setsockopt(3) or zmq_getsockopt(3).
2016-05-06 21:50:56 +02:00
option (WITH_MILITANT "Enable militant assertions" OFF)
if (WITH_MILITANT)
add_definitions(-DZMQ_ACT_MILITANT)
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (POLLER "" CACHE STRING "Choose polling system. valid values are
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
kqueue, epoll, devpoll, pollset, poll or select [default=autodetect]")
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (CheckFunctionExists)
include (CheckTypeSize)
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/event.h)
check_function_exists (kqueue HAVE_KQUEUE)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_KQUEUE)
set (POLLER "kqueue")
Remove duplicate poller decision making The decision about the poller mechanism to use (select, poll, ...) was done twice: once by the build system and once by the code in poller.hpp. As the build-system can actually detect the mechanisms available, prefer that result to the hard coded defaults in poller.hpp. At the same time, remove the duplicate detection of select() vs. poll()-variant from proxy.cpp, signaler.cpp and zmq.cpp. This patch has not been tested on many build platforms: especially the cmake build needs testing / patching. For the other builds, hard code the result as these these are all Windows platforms.
2014-02-17 14:08:11 +01:00
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/epoll.h)
check_function_exists (epoll_create HAVE_EPOLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_EPOLL)
set (POLLER "epoll")
Problem: epoll leaks socket on fork+exec Solution: if available, use epoll_create1 with EPOLL_CLOEXEC flag to make the process close the socket on fork+exec
2016-12-26 18:01:36 +01:00
check_function_exists (epoll_create1 HAVE_EPOLL_CLOEXEC)
if (HAVE_EPOLL_CLOEXEC)
set (ZMQ_USE_EPOLL_CLOEXEC 1)
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
endif ()
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/devpoll.h)
check_type_size ("struct pollfd" DEVPOLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_DEVPOLL)
set (POLLER "devpoll")
endif ()
endif ()
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/pollset.h)
check_function_exists (pollset_create HAVE_POLLSET)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_POLLSET)
set (POLLER "pollset")
endif()
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES poll.h)
check_function_exists (poll HAVE_POLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_POLL)
set (POLLER "poll")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (POLLER STREQUAL "")
if (WIN32)
set (CMAKE_REQUIRED_INCLUDES winsock2.h)
set (HAVE_SELECT 1)
else ()
set (CMAKE_REQUIRED_INCLUDES sys/select.h)
check_function_exists (select HAVE_SELECT)
set (CMAKE_REQUIRED_INCLUDES)
endif ()
if (HAVE_SELECT)
set (POLLER "select")
else ()
message (FATAL_ERROR
"Could not autodetect polling method")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (POLLER STREQUAL "kqueue"
OR POLLER STREQUAL "epoll"
OR POLLER STREQUAL "devpoll"
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
OR POLLER STREQUAL "pollset"
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
OR POLLER STREQUAL "poll"
OR POLLER STREQUAL "select")
message (STATUS "Detected ${POLLER} polling method")
string (TOUPPER ${POLLER} UPPER_POLLER)
set (ZMQ_USE_${UPPER_POLLER} 1)
else ()
message (FATAL_ERROR "Invalid polling method")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (ZMQ_CMAKE_MODULES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/Modules)
list (APPEND CMAKE_MODULE_PATH ${ZMQ_CMAKE_MODULES_DIR})
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (TestZMQVersion)
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
if (NOT CMAKE_CROSSCOMPILING)
include (ZMQSourceRunChecks)
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (CheckIncludeFiles)
include (CheckLibraryExists)
include (CheckCCompilerFlag)
include (CheckCXXCompilerFlag)
include (CheckCSourceCompiles)
include (CheckCSourceRuns)
include (CMakeDependentOption)
include (CheckCXXSymbolExists)
replace check_library and check_include with find_file and find_library
2015-02-06 16:42:23 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
check_include_files (ifaddrs.h ZMQ_HAVE_IFADDRS)
check_include_files (windows.h ZMQ_HAVE_WINDOWS)
Problem: CMake evaluation fails with Mingw-w64 Solution: we can use 'CMAKE_SYSTEM_VERSION' instead of '${CMAKE_SYSTEM_VERSION}' for the 'if' clauses. CMake fails to evaluate condition when CMAKE_SYSTEM_VERSION is empty, which can happen with a default installation of Mingw-w64 in Linux.
2017-06-14 15:55:29 +02:00
if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore" AND CMAKE_SYSTEM_VERSION STREQUAL "10.0")
Problem: no windows UWP support * add define for windows/UWP * prevent issue with COM references * gettickcount not available on uwp * add compiler definitions * add convenitnece cmake file * brute force uwp compilation * fix compiler version * cosmetics
2017-04-04 10:50:33 +02:00
SET(ZMQ_HAVE_WINDOWS_UWP ON)
ADD_DEFINITIONS(-D_WIN32_WINNT=_WIN32_WINNT_WIN10)
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
check_include_files (sys/uio.h ZMQ_HAVE_UIO)
check_include_files (sys/eventfd.h ZMQ_HAVE_EVENTFD)
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
if (ZMQ_HAVE_EVENTFD AND NOT CMAKE_CROSSCOMPILING)
Problem: eventfd leaks socket on fork+exec Solution: if available, use eventfd with EFD_CLOEXEC flag to make the process close the socket on fork+exec
2016-12-26 18:18:00 +01:00
zmq_check_efd_cloexec ()
endif ()
replace check_library and check_include with find_file and find_library
2015-02-06 16:42:23 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
check_library_exists (ws2_32 fopen "" HAVE_WS2_32) # TODO: Why doesn't something logical like WSAStartup work?
check_library_exists (ws2 fopen "" HAVE_WS2)
check_library_exists (rpcrt4 fopen "" HAVE_RPCRT4) # UuidCreateSequential
check_library_exists (iphlpapi fopen "" HAVE_IPHLAPI) # GetAdaptersAddresses
Enable building IPC filtering with cmake.
2013-12-06 19:55:44 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
check_cxx_symbol_exists (SO_PEERCRED sys/socket.h ZMQ_HAVE_SO_PEERCRED)
check_cxx_symbol_exists (LOCAL_PEERCRED sys/socket.h ZMQ_HAVE_LOCAL_PEERCRED)
Fix cmake not linking librt to perf-tools
2013-01-23 20:31:02 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_library (RT_LIBRARY rt)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_package (Threads)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WIN32 AND NOT CYGWIN)
if (NOT HAVE_WS2_32 AND NOT HAVE_WS2)
message (FATAL_ERROR "Cannot link to ws2_32 or ws2")
endif ()
if (NOT HAVE_RPCRT4)
message (FATAL_ERROR "Cannot link to rpcrt4")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT HAVE_IPHLAPI)
message (FATAL_ERROR "Cannot link to iphlapi")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_REQUIRED_LIBRARIES rt)
check_function_exists (clock_gettime HAVE_CLOCK_GETTIME)
set (CMAKE_REQUIRED_LIBRARIES)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_REQUIRED_INCLUDES unistd.h)
check_function_exists (fork HAVE_FORK)
set (CMAKE_REQUIRED_INCLUDES)
fix test_fork * was problem on debian/wheezy
2014-03-17 21:09:10 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_REQUIRED_INCLUDES sys/time.h)
check_function_exists (gethrtime HAVE_GETHRTIME)
set (CMAKE_REQUIRED_INCLUDES)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: mkdtemp not available on all platforms Solution: check for availability in autoconf and cmake, and if not available fall back to random file name rather than random directory.
2016-04-10 23:45:35 +02:00
set (CMAKE_REQUIRED_INCLUDES stdlib.h)
check_function_exists (mkdtemp HAVE_MKDTEMP)
set (CMAKE_REQUIRED_INCLUDES)
Problem: accept4 not available on all platforms Solution: check for availability in CMake and autoconf before using it
2017-11-17 19:40:53 +01:00
set (CMAKE_REQUIRED_INCLUDES sys/socket.h)
check_function_exists (accept4 HAVE_ACCEPT4)
set (CMAKE_REQUIRED_INCLUDES)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_REENTRANT -D_THREAD_SAFE)
Problem: gyp does not build tests Solution: it's a lot of work to define the tests in project.gyp so I did this using gsl to generate the JSON, from a small XML list of the test cases. To keep this, and the hundreds of .mk files, away from the root directory, I've moved the gyp files into builds/gyp, where you would run them. It all seems to work now. Next up, OS/X and Windows :)
2016-02-12 11:31:38 +01:00
add_definitions (-DZMQ_CUSTOM_PLATFORM_HPP)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (ENABLE_EVENTFD "Enable/disable eventfd" ZMQ_HAVE_EVENTFD)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
macro (zmq_check_cxx_flag_prepend flag)
check_cxx_compiler_flag ("${flag}" HAVE_FLAG_${flag})
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (HAVE_FLAG_${flag})
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
endif ()
endmacro ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
zmq_check_cxx_flag_prepend ("/W3")
CMAKE_VS_PLATFORM_TOOLSET may not be set. E.g. for nmake.
2015-12-18 15:50:41 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC_IDE)
set (MSVC_TOOLSET "-${CMAKE_VS_PLATFORM_TOOLSET}")
else ()
set (MSVC_TOOLSET "")
endif ()
else ()
zmq_check_cxx_flag_prepend ("-Wall")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
zmq_check_cxx_flag_prepend ("-Wextra")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# TODO: why is -Wno-long-long defined differently than in configure.ac?
zmq_check_cxx_flag_prepend ("-Wno-long-long")
zmq_check_cxx_flag_prepend ("-Wno-uninitialized")
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (LIBZMQ_PEDANTIC "" ON)
option (LIBZMQ_WERROR "" OFF)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (LIBZMQ_PEDANTIC)
zmq_check_cxx_flag_prepend ("-pedantic")
Fix unused argument warnings
2013-01-01 09:26:31 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CXX_COMPILER_ID} MATCHES "Intel")
zmq_check_cxx_flag_prepend ("-strict-ansi")
endif ()
Fix unused argument warnings
2013-01-01 09:26:31 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
zmq_check_cxx_flag_prepend ("-compat=5")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (LIBZMQ_WERROR)
zmq_check_cxx_flag_prepend ("-Werror")
zmq_check_cxx_flag_prepend ("-errwarn=%all")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^sparc")
zmq_check_cxx_flag_prepend ("-mcpu=v9")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
zmq_check_cxx_flag_prepend ("-features=zla")
endif ()
Fix cmake build with sun studio
2013-01-01 11:22:05 +01:00
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SYSTEM_NAME MATCHES "SunOS" OR CMAKE_SYSTEM_NAME MATCHES "NetBSD")
message (STATUS "Checking whether atomic operations can be used")
check_c_source_compiles (
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
"
#include <atomic.h>
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
int main ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
{
uint32_t value;
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
atomic_cas_32 (&value, 0, 0);
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
return 0;
}
"
HAVE_ATOMIC_H)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT HAVE_ATOMIC_H)
set (ZMQ_FORCE_MUTEXES 1)
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
#-----------------------------------------------------------------------------
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
if (NOT CMAKE_CROSSCOMPILING)
zmq_check_sock_cloexec ()
Problem: tweetnacl leaks file descriptor on fork+exec Solution: open with O_CLOEXEC if available or set FD_CLOEXEC if not
2017-07-28 00:29:33 +02:00
zmq_check_o_cloexec ()
Add socket option BINDTODEVICE Linux now supports Virtual Routing and Forwarding (VRF) as per: https://www.kernel.org/doc/Documentation/networking/vrf.txt In order for an application to bind or connect to a socket with an address in a VRF, they need to first bind the socket to the VRF device: setsockopt(sd, SOL_SOCKET, SO_BINDTODEVICE, dev, strlen(dev)+1); Note "dev" is the VRF device, eg. VRF "blue", rather than an interface enslaved to the VRF. Add a new socket option, ZMQ_BINDTODEVICE, to bind a socket to a device. In general, if a socket is bound to a device, eg. an interface, only packets received from that particular device are processed by the socket. If device is a VRF device, then subsequent binds/connects to that socket use addresses in the VRF routing table.
2017-07-28 15:35:09 +02:00
zmq_check_so_bindtodevice ()
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
zmq_check_so_keepalive ()
zmq_check_tcp_keepcnt ()
zmq_check_tcp_keepidle ()
zmq_check_tcp_keepintvl ()
zmq_check_tcp_keepalive ()
zmq_check_tcp_tipc ()
zmq_check_pthread_setname ()
Background threads enhancements (#2778) * Background thread scheduling - add ZMQ_THREAD_AFFINITY ctx option; set all thread scheduling options from the context of the secondary thread instead of using the main process thread context! - change ZMQ_THREAD_PRIORITY to support setting NICE of the background thread when using SCHED_OTHER
2017-10-16 13:29:03 +02:00
zmq_check_pthread_setaffinity ()
Problem: reading from /dev/urandom is clunky Solution: if available use the getrandom function as it doesn't require any synchronization, state or cleanup
2017-07-27 22:37:12 +02:00
zmq_check_getrandom ()
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if ( CMAKE_SYSTEM_NAME MATCHES "Linux"
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
OR CMAKE_SYSTEM_NAME MATCHES "GNU/kFreeBSD"
OR CMAKE_SYSTEM_NAME MATCHES "GNU/Hurd"
OR CYGWIN)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_GNU_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
add_definitions (-D__BSD_VISIBLE)
elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
add_definitions (-D_NETBSD_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
add_definitions (-D_OPENBSD_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "SunOS")
add_definitions (-D_PTHREADS)
elseif (CMAKE_SYSTEM_NAME MATCHES "HP-UX")
add_definitions (-D_POSIX_C_SOURCE=200112L)
zmq_check_cxx_flag_prepend (-Ae)
elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
add_definitions (-D_DARWIN_C_SOURCE)
endif ()
set (CMAKE_PYTHON_VERSION 2.7 2.6 2.5 2.4)
find_package (PythonInterp)
find_package (AsciiDoc)
cmake_dependent_option (WITH_DOC "Build Reference Guide documentation (requires DocBook)" ON
Problem: Broken documentation build Solution: The CMAKE module PythonInterp sets the variable PYTHONINTERP_FOUND and not PYTHON_FOUND if it finds a python interpreter.
2016-08-28 12:57:28 +02:00
"PYTHONINTERP_FOUND;ASCIIDOC_FOUND" OFF)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
if (WITH_OPENPGM)
# set (OPENPGM_ROOT "" CACHE PATH "Location of OpenPGM")
set (OPENPGM_VERSION_MAJOR 5)
set (OPENPGM_VERSION_MINOR 2)
set (OPENPGM_VERSION_MICRO 122)
if (CMAKE_CL_64)
find_path (OPENPGM_ROOT include/pgm/pgm.h
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
PATHS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
NO_DEFAULT_PATH
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
)
message (STATUS "OpenPGM x64 detected - ${OPENPGM_ROOT}")
else ()
find_path (OPENPGM_ROOT include/pgm/pgm.h
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
PATHS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
NO_DEFAULT_PATH
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
)
message (STATUS "OpenPGM x86 detected - ${OPENPGM_ROOT}")
endif (CMAKE_CL_64)
set (OPENPGM_INCLUDE_DIRS ${OPENPGM_ROOT}/include)
set (OPENPGM_LIBRARY_DIRS ${OPENPGM_ROOT}/lib)
set (OPENPGM_LIBRARIES
CMAKE_VS_PLATFORM_TOOLSET may not be set. E.g. for nmake.
2015-12-18 15:50:41 +01:00
optimized libpgm${MSVC_TOOLSET}-mt-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib
debug libpgm${MSVC_TOOLSET}-mt-gd-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
else ()
if (WITH_OPENPGM)
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
# message (FATAL_ERROR "WITH_OPENPGM not implemented")
if (NOT OPENPGM_PKGCONFIG_NAME)
SET (OPENPGM_PKGCONFIG_NAME "openpgm-5.2")
endif(NOT OPENPGM_PKGCONFIG_NAME)
SET (OPENPGM_PKGCONFIG_NAME ${OPENPGM_PKGCONFIG_NAME} CACHE STRING
"Name pkg-config shall use to find openpgm libraries and include paths"
FORCE )
find_package(PkgConfig)
pkg_check_modules (OPENPGM ${OPENPGM_PKGCONFIG_NAME})
if (OPENPGM_FOUND)
message (STATUS ${OPENPGM_PKGCONFIG_NAME}" found")
else ()
message (FATAL_ERROR
${OPENPGM_PKGCONFIG_NAME}" not found. openpgm is searchd via `pkg-config ${OPENPGM_PKGCONFIG_NAME}`. Consider providing a valid OPENPGM_PKGCONFIG_NAME")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# DSO symbol visibility for openpgm
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (HAVE_FLAG_VISIBILITY_HIDDEN)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
elseif (HAVE_FLAG_LDSCOPE_HIDDEN)
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# force off-tree build
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
message (FATAL_ERROR "CMake generation is not allowed within the source directory!
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Remove the CMakeCache.txt file and try again from another folder, e.g.:
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
rm CMakeCache.txt
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
mkdir cmake-make
cd cmake-make
cmake ..
")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# default to Release build
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-Set signaler_port to 0 which allows the OS to find a free port, rather than crashing if 5905 is in use (https://github.com/zeromq/libzmq/issues/1542) -Added config.hpp to the source list so it shows up in generated projects -Remove CMAKE_BUILD_TYPE setting for generators that don't use it
2015-08-21 05:45:59 +02:00
# CMAKE_BUILD_TYPE is not used for multi-configuration generators like Visual Studio/XCode
# which instead use CMAKE_CONFIGURATION_TYPES
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_BUILD_TYPE Release CACHE STRING
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
FORCE)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/bin)
set (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/lib)
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# platform specifics
mutualize win32 flags
2015-03-11 10:10:23 +01:00
if (WIN32)
Problem: socket limit is still 4K on Windows Solution: fix in CMakeLists.txt (already fixed in builds/msvc)
2016-02-12 16:30:55 +01:00
# Socket limit is 16K (can be raised arbitrarily)
add_definitions (-DFD_SETSIZE=16384)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_CRT_SECURE_NO_WARNINGS)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
mutualize win32 flags
2015-03-11 10:10:23 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# Parallel make.
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# Optimization flags.
# http://msdn.microsoft.com/en-us/magazine/cc301698.aspx
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GL")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG")
set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LTCG")
set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LTCG")
endif ()
endif ()
Enable parallel make and LTO by default.
2012-10-12 20:18:04 +02:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# source files
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (cxx-sources
Windows cmake build fixed
2017-01-06 10:52:20 +01:00
precompiled.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
address.cpp
fix jenkins build
2015-02-02 15:42:50 +01:00
client.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
clock.cpp
ctx.cpp
Problem: code duplication between curve_client_t and curve_server_t decode and encode Solution: extracted common base class curve_mechanism_base_t
2017-08-18 11:34:22 +02:00
curve_mechanism_base.cpp
Implement ZMTP/3.0 CURVE handshake
2013-06-18 23:38:24 +02:00
curve_client.cpp
curve_server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
dealer.cpp
devpoll.cpp
Added dgram.cpp to CMakeLists.txt sources
2016-05-13 04:06:45 +02:00
dgram.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
dist.cpp
epoll.cpp
err.cpp
fq.cpp
io_object.cpp
io_thread.cpp
ip.cpp
ipc_address.cpp
ipc_connecter.cpp
ipc_listener.cpp
kqueue.cpp
lb.cpp
mailbox.cpp
thread safety - supporting windows
2015-02-12 15:56:14 +01:00
mailbox_safe.cpp
Port tests to windows and add to cmake build.
2013-08-17 14:43:45 +02:00
mechanism.cpp
Problem: code duplication between curve_client_t and curve_server_t decode and encode Solution: extracted common base class curve_mechanism_base_t
2017-08-18 11:34:22 +02:00
mechanism_base.cpp
add metadata
2014-05-01 21:35:53 +02:00
metadata.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
msg.cpp
mtrie.cpp
object.cpp
options.cpp
own.cpp
Port tests to windows and add to cmake build.
2013-08-17 14:43:45 +02:00
null_mechanism.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
pair.cpp
pgm_receiver.cpp
pgm_sender.cpp
pgm_socket.cpp
pipe.cpp
Update cmake for split of plain_mechanism
2014-05-12 09:51:13 +02:00
plain_client.cpp
plain_server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
poll.cpp
poller_base.cpp
replace tabs with space
2016-09-21 05:28:32 +02:00
pollset.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
proxy.cpp
pub.cpp
pull.cpp
push.cpp
random.cpp
raw_encoder.cpp
raw_decoder.cpp
reaper.cpp
rep.cpp
req.cpp
router.cpp
select.cpp
fix jenkins build
2015-02-02 15:42:50 +01:00
server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
session_base.cpp
signaler.cpp
socket_base.cpp
Fix windows build
2014-06-23 14:10:43 +02:00
socks.cpp
socks_connecter.cpp
Fix cmake build Fix build on windows, uint isn't a standard type, unsigned int is.
2013-07-01 12:52:39 +02:00
stream.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
stream_engine.cpp
sub.cpp
tcp.cpp
tcp_address.cpp
tcp_connecter.cpp
tcp_listener.cpp
thread.cpp
trie.cpp
v1_decoder.cpp
v1_encoder.cpp
Updated CMake building to work after encoder/decoder changes.
2013-03-13 20:10:00 +01:00
v2_decoder.cpp
v2_encoder.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
xpub.cpp
xsub.cpp
zmq.cpp
"zero-copy" raw_decoder A memcpy is eliminated when receiving data on a ZMQ_STREAM socket. Instead of receiving into a static buffer and then copying the data into the buffer malloced in msg_t::init_size, the raw_decoder allocates the memory for together with the reference-counter and creates a msg_t object on top of that memory. This saves the memcpy operation. For small messages, data is still copied and the receive buffer is reused.
2015-06-14 19:00:52 +02:00
zmq_utils.cpp
-Set signaler_port to 0 which allows the OS to find a free port, rather than crashing if 5905 is in use (https://github.com/zeromq/libzmq/issues/1542) -Added config.hpp to the source list so it shows up in generated projects -Remove CMAKE_BUILD_TYPE setting for generators that don't use it
2015-08-21 05:45:59 +02:00
decoder_allocators.cpp
port zpoller to libzmq as zmq_poller
2015-10-18 20:07:23 +02:00
socket_poller.cpp
add timers API to libzmq
2015-12-18 11:12:18 +01:00
timers.cpp
radio-dish pattern
2016-01-27 17:19:14 +01:00
config.hpp
radio.cpp
make udp support for radio-dish
2016-01-29 20:17:11 +01:00
dish.cpp
udp_engine.cpp
Scatter-Gather socket types
2016-04-21 12:23:44 +02:00
udp_address.cpp
scatter.cpp
Problem: ZAP client code is duplicated in all mechanisms Solution: created a zap_client_t class, extracted first function send_zap_request from curve_server_t
2017-08-16 10:03:11 +02:00
gather.cpp
zap_client.cpp)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (rc-sources version.rc)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MINGW)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
# Generate the right type when using -m32 or -m64
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
macro (set_rc_arch rc_target)
set (CMAKE_RC_COMPILER_INIT windres)
enable_language (RC)
set (CMAKE_RC_COMPILE_OBJECT
Fix issue #969
2014-04-13 15:25:22 +02:00
"<CMAKE_RC_COMPILER> <FLAGS> -O coff --target=${rc_target} <DEFINES> -i <SOURCE> -o <OBJECT>")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endmacro ()
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT CMAKE_SYSTEM_PROCESSOR)
set (CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if ( CMAKE_SYSTEM_PROCESSOR MATCHES "i386"
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i486"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i586"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686"
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
# This also happens on x86_64 systems...what a worthless variable
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64")
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SIZEOF_VOID_P EQUAL 8)
set_rc_arch ("pe-x86-64")
else ()
set_rc_arch ("pe-i386")
endif ()
endif ()
endif ()
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Deprecate zmq_utils.h instead of removing it, which breaks downstream builds.
2016-02-18 10:27:21 +01:00
set (public_headers include/zmq.h
include/zmq_utils.h)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (readme-docs AUTHORS
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
COPYING
COPYING.LESSER
README file moved to GitHub format and extension, drop from packaging and default to NEWS file for popup.
2013-07-14 19:26:55 +02:00
NEWS)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# optional modules
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_OPENPGM)
add_definitions (-DZMQ_HAVE_OPENPGM)
include_directories (${OPENPGM_INCLUDE_DIRS})
link_directories (${OPENPGM_LIBRARY_DIRS})
set (OPTIONAL_LIBRARIES ${OPENPGM_LIBRARIES})
endif (WITH_OPENPGM)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_VMCI)
add_definitions (-DZMQ_HAVE_VMCI)
include_directories (${VMCI_INCLUDE_DIRS})
list (APPEND cxx-sources vmci_address.cpp vmci_connecter.cpp vmci_listener.cpp vmci.cpp)
endif (WITH_VMCI)
Add the VMCI transport. VMCI transport allows fast communication between the Host and a virtual machine, between virtual machines on the same host, and within a virtual machine (like IPC). It requires VMware to be installed on the host and Guest Additions to be installed on a guest.
2015-12-07 13:19:45 +01:00
Problem: CMake does not check for TIPC support Solution: add macro in ZMQSourceRunChecks.cmake and optionally include the TIPC sources if the support is available. More importantly, only run the TIPC tests if the support is there.
2016-04-21 12:33:20 +02:00
if (ZMQ_HAVE_TIPC)
add_definitions (-DZMQ_HAVE_TIPC)
Problem: ZMQ_HAVE_TIPC option for CMake is broken Solution: Fix it - there was a typo in the source list variable; it should be 'cpp-sources' and not 'cpp-source'.
2016-05-04 17:12:27 +02:00
list (APPEND cxx-sources tipc_address.cpp tipc_connecter.cpp tipc_listener.cpp)
Problem: CMake does not check for TIPC support Solution: add macro in ZMQSourceRunChecks.cmake and optionally include the TIPC sources if the support is available. More importantly, only run the TIPC tests if the support is there.
2016-04-21 12:33:20 +02:00
endif (ZMQ_HAVE_TIPC)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# source generators
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
foreach (source ${cxx-sources})
list (APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/${source})
endforeach ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
foreach (source ${rc-sources})
list (APPEND sources ${CMAKE_CURRENT_BINARY_DIR}/${source})
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/src/${source}.in ${CMAKE_CURRENT_BINARY_DIR}/${source})
endforeach ()
tweetnacl integration
2014-05-01 21:24:20 +02:00
Problem: cmake fails with #error None of the ZMQ_USE_* macros defined This happens if you first configure with autotools, and then run cmake. The problem is that the compiler finds the old src/platform.hpp before looking for the one generated by CMake. Further, there are a set of macros that configure passes via the command line, yet CMake passes via platform.hpp. (HAVE_xxx for pollers, at least.) This means you can't do a CMake build using the autotools platform.hpp. Solution: remove any src/platform.hpp when running cmake. This is a workaround. I'll fix the inconsistent macros separately.
2016-02-11 13:38:02 +01:00
# Delete any src/platform.hpp left by configure
file (REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/src/platform.hpp)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/platform.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
list (APPEND sources ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
Fix NSIS installer errors, MinGW build. The CPack NSIS installer was in a state where it would always give a useless error. I think it was using stuff intended for running cpack separately from cmake.
2013-01-01 08:25:15 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/src/libzmq.pc.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc @ONLY)
set (zmq-pkgconfig ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ZMQ_BUILD_FRAMEWORK)
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc DESTINATION lib/pkgconfig)
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
if (CMAKE_CL_64)
set (nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template64.in)
else ()
set (nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template32.in)
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_custom_command (
Fix random 3 space tabs
2013-01-01 12:53:56 +01:00
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
COMMAND ${CMAKE_COMMAND}
ARGS -E
copy
${nsis-template}
${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
DEPENDS ${nsis-template})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc)
file (GLOB docs RELATIVE ${CMAKE_CURRENT_BINARY_DIR}/ "${CMAKE_CURRENT_SOURCE_DIR}/doc/*.txt")
set (html-docs)
foreach (txt ${docs})
Problem: Documentation still has .txt suffix Solution: The regular expression replacement expected a non-existing space at the beginning of the input files.
2016-08-28 13:00:09 +02:00
string (REGEX REPLACE ".*/(.*)\\.txt" "\\1.html" html ${txt})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (src ${txt})
set (dst doc/${html})
if (WITH_DOC)
Fix WITH_DOC
2017-04-28 09:06:45 +02:00
add_custom_command (
OUTPUT ${dst}
COMMAND ${ASCIIDOC_EXECUTABLE}
-d manpage
-b xhtml11
-f ${CMAKE_CURRENT_SOURCE_DIR}/doc/asciidoc.conf
-azmq_version=${ZMQ_VERSION}
-o ${dst}
${src}
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${src}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating ${html}")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
list (APPEND html-docs ${CMAKE_CURRENT_BINARY_DIR}/${dst})
endif ()
endforeach ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_FRAMEWORK)
add_custom_command (
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
TARGET libzmq
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory "${CMAKE_LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION}/MacOS"
COMMENT "Perf tools")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
if (MSVC)
# default for all sources is to use precompiled headers
foreach(source ${sources})
Fix precompiled
2017-05-17 18:50:01 +02:00
if (NOT ${source} STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp")
set_source_files_properties(${source}
PROPERTIES
COMPILE_FLAGS "/Yuprecompiled.hpp"
OBJECT_DEPENDS precompiled.hpp
)
endif()
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
endforeach()
# create precompiled header
set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp
PROPERTIES
COMPILE_FLAGS "/Ycprecompiled.hpp"
Fix precompiled
2017-05-17 18:50:01 +02:00
OBJECT_OUTPUTS precompiled.hpp
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
)
# C and C++ can not use the same precompiled header
set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/tweetnacl.c
PROPERTIES
COMPILE_FLAGS "/Y-"
)
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# output
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
option(BUILD_SHARED "Whether or not to build the shared object" ON)
option(BUILD_STATIC "Whether or not to build the static archive" ON)
list(APPEND target_outputs "")
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
list(APPEND target_outputs "libzmq")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
if (BUILD_STATIC)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
list(APPEND target_outputs "libzmq-static")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
Suppress linker warning 4221 for MSVC Some #define switches cause the body of entire files to be omitted. This causes a linker warning on Visual Studio 2017, for example warning LNK4221: This object file does not define any previously undefined public symbols, so it will not be used by any link operation that consumes this library Since this is warning us about something that shouldn't be earth-shattering news, we add a linker flag to suppress this warning on MSVC builds.
2017-05-20 20:22:29 +02:00
# Suppress linker warnings caused by #ifdef omission
# of file content.
set( CMAKE_STATIC_LINKER_FLAGS /ignore:4221 )
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
add_library (libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs} ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in)
target_link_libraries (libzmq ${OPTIONAL_LIBRARIES})
set_target_properties (libzmq PROPERTIES
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
PUBLIC_HEADER "${public_headers}"
RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
RELWITHDEBINFO_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin"
COMPILE_DEFINITIONS "DLL_EXPORT"
OUTPUT_NAME "libzmq")
endif()
if (BUILD_STATIC)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
add_library (libzmq-static STATIC ${sources})
set_target_properties (libzmq-static PROPERTIES
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
PUBLIC_HEADER "${public_headers}"
RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
RELWITHDEBINFO_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-sgd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
COMPILE_FLAGS "/DZMQ_STATIC"
OUTPUT_NAME "libzmq")
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
else ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
add_library (libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig})
Problem: CMake on Linux does not link libzmq with optional libs Solution: add missing target_link_libraries Fixes #2701
2017-08-19 13:26:36 +02:00
target_link_libraries (libzmq ${OPTIONAL_LIBRARIES})
Problem: CMake build uses library version as the ABI version Solution: set SOVERSION in CMakeLists to match the SONAME generated by libtool so that there is no mismatch between the output of the *NIX build systems. Before: $ ls -l total 2696 lrwxrwxrwx 1 luca luca 15 Dec 1 22:36 libzmq.so -> libzmq.so.4.2.0 lrwxrwxrwx 1 luca luca 15 Dec 1 22:36 libzmq.so.4.2.0 -> libzmq.so.4.2.1 -rwxr-xr-x 1 luca luca 906168 Dec 1 22:36 libzmq.so.4.2.1 $ readelf -d libzmq.so.4.2.1 | grep SONAME 0x000000000000000e (SONAME) Library soname: [libzmq.so.4.2.0] After: $ ls -l total 2700 lrwxrwxrwx 1 luca luca 15 Dec 1 22:31 libzmq.so -> libzmq.so.5.1.0 -rwxr-xr-x 1 luca luca 906168 Dec 1 22:31 libzmq.so.4.2.1 lrwxrwxrwx 1 luca luca 15 Dec 1 22:31 libzmq.so.5.1.0 -> libzmq.so.4.2.1 $ readelf -d libzmq.so.4.2.1 | grep SONAME 0x000000000000000e (SONAME) Library soname: [libzmq.so.5.1.0]
2016-12-01 23:33:43 +01:00
# NOTE: the SOVERSION MUST be the same as the one generated by libtool!
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq PROPERTIES
set soversion without ZMQ_BUILD_FRAMEWORK
2015-03-11 10:15:40 +01:00
COMPILE_DEFINITIONS "DLL_EXPORT"
PUBLIC_HEADER "${public_headers}"
VERSION ${ZMQ_VERSION}
Problem: 4.2.2 is out, version(s) are out of date Solution: bump changelog, ABI revision, library and packaging version
2017-02-18 18:56:55 +01:00
SOVERSION "5.1.3"
Fix windows compilation
2017-04-05 18:46:48 +02:00
OUTPUT_NAME "zmq"
PREFIX "lib")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_FRAMEWORK)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER "org.zeromq.libzmq"
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${ZMQ_VERSION}
set soversion without ZMQ_BUILD_FRAMEWORK
2015-03-11 10:15:40 +01:00
MACOSX_FRAMEWORK_BUNDLE_VERSION ${ZMQ_VERSION})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${html-docs} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION doc)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${readme-docs} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION etc)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${zmq-pkgconfig} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION lib/pkgconfig)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
if (BUILD_STATIC)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
add_library (libzmq-static STATIC ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig})
set_target_properties (libzmq-static PROPERTIES
Add static compilation on CMake
2014-07-02 21:51:34 +02:00
PUBLIC_HEADER "${public_headers}"
do not mix DLL_EXPORT & ZMQ_STATIC definitions
2015-03-11 10:03:21 +01:00
COMPILE_DEFINITIONS "ZMQ_STATIC"
Fix windows compilation
2017-04-05 18:46:48 +02:00
OUTPUT_NAME "zmq"
PREFIX "lib")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
foreach (target ${target_outputs})
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
target_include_directories (${target}
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
$<INSTALL_INTERFACE:include>
)
endforeach()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ${CMAKE_THREAD_LIBS_INIT})
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (SODIUM_FOUND)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ${SODIUM_LIBRARIES})
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
if (HAVE_WS2_32)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ws2_32)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
elseif (HAVE_WS2)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ws2)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (HAVE_RPCRT4)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq rpcrt4)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
add linking to librt under cmake build - fixes missing symbol The libzmq library itself uses clock_gettime and should link w/ -lrt on linux. Caught this issue on on Ubuntu 12.04 LTS.
2014-02-24 20:07:28 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (HAVE_IPHLAPI)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq iphlpapi)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (RT_LIBRARY)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ${RT_LIBRARY})
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Make CMake option for perf-tools This allow disable making perf-tools in Release build type Signed-off-by: Anton Sergeev <Anton.Sergeev@elecard.ru>
2015-05-06 17:25:26 +02:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
set (perf-tools local_lat
remote_lat
local_thr
remote_thr
inproc_lat
inproc_thr)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug") # Why?
option (WITH_PERF_TOOL "Build with perf-tools" ON)
else ()
option (WITH_PERF_TOOL "Build with perf-tools" OFF)
endif ()
Fix cmake not linking librt to perf-tools
2013-01-23 20:31:02 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (WITH_PERF_TOOL)
foreach (perf-tool ${perf-tools})
add_executable (${perf-tool} perf/${perf-tool}.cpp)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (${perf-tool} libzmq ${OPTIONAL_LIBRARIES})
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (RT_LIBRARY)
target_link_libraries (${perf-tool} ${RT_LIBRARY})
endif ()
if (ZMQ_BUILD_FRAMEWORK)
# Copy perf-tools binaries into Framework
add_custom_command (
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
TARGET libzmq ${perf-tool}
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy "$<TARGET_FILE:${perf-tool}>" "${LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION_STRING}/MacOS/${perf-tool}"
VERBATIM
COMMENT "Perf tools")
else ()
install (TARGETS ${perf-tool}
RUNTIME DESTINATION bin
COMPONENT PerfTools)
endif ()
endforeach ()
endif ()
elseif (WITH_PERF_TOOL)
message(FATAL_ERROR "Shared library disabled - perf-tools unavailable.")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Added ZMQ_BUILD_TESTS to CMakeLists.txt to allow turning off tests. Useful when building ZMQ as a git submodule.
2014-02-07 17:50:45 +01:00
#-----------------------------------------------------------------------------
# tests
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (ZMQ_BUILD_TESTS ON CACHE BOOL "Build the tests for ZeroMQ")
Added ZMQ_BUILD_TESTS to CMakeLists.txt to allow turning off tests. Useful when building ZMQ as a git submodule.
2014-02-07 17:50:45 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_TESTS)
enable_testing () # Enable testing only works in root scope
ADD_SUBDIRECTORY (tests)
endif ()
Add support for extending ZAP request address with IPC peer credentials. Another take on LIBZMQ-568 to allow filtering IPC connections, this time using ZAP. This change is backward compatible. If the ZMQ_ZAP_IPC_CREDS option is set, the user, group, and process IDs of the peer process are appended to the address (separated by colons) of a ZAP request; otherwise, nothing changes. See LIBZMQ-568 and zmq_setsockopt documentation for more information.
2013-12-06 23:28:44 +01:00
Bring along CMake patchset from zeromq3-x for adding minor version to Windows labeling.
2012-11-09 14:48:59 +01:00
#-----------------------------------------------------------------------------
# installer
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
cmake install config file
2017-01-06 22:41:29 +01:00
include(GNUInstallDirs)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
install (TARGETS ${target_outputs}
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
EXPORT ${PROJECT_NAME}-targets
cmake install config file
2017-01-06 22:41:29 +01:00
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
COMPONENT SDK)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
install (TARGETS ${target_outputs}
cmake install config file
2017-01-06 22:41:29 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
COMPONENT SDK)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT CMAKE_PDB_OUTPUT_DIRECTORY)
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/bin/libzmq${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}.pdb DESTINATION lib
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
COMPONENT SDK)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
elseif (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
install (TARGETS libzmq
cmake install config file
2017-01-06 22:41:29 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
COMPONENT Runtime)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
else ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
install (TARGETS ${target_outputs}
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
EXPORT ${PROJECT_NAME}-targets
cmake install config file
2017-01-06 22:41:29 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
FRAMEWORK DESTINATION "Library/Frameworks"
cmake install config file
2017-01-06 22:41:29 +01:00
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# install (FILES ${public_headers}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# DESTINATION include
# COMPONENT SDK)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
#if (NOT ZMQ_BUILD_FRAMEWORK)
# file (GLOB private_headers "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
# install (FILES ${sources} ${private_headers} DESTINATION src/zmq
do not install sources
2015-03-11 09:50:39 +01:00
# COMPONENT SourceCode)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
#endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
foreach (readme ${readme-docs})
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/${readme} ${CMAKE_CURRENT_BINARY_DIR}/${readme}.txt)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ZMQ_BUILD_FRAMEWORK)
CPack option and .txt files installation dir
2017-01-06 14:29:56 +01:00
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${readme}.txt DESTINATION share/zmq)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
endforeach ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_DOC)
if (NOT ZMQ_BUILD_FRAMEWORK)
install (FILES ${html-docs} DESTINATION doc/zmq COMPONENT RefGuide)
endif ()
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
cmake install config file
2017-01-06 22:41:29 +01:00
include(CMakePackageConfigHelpers)
# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
set(ZEROMQ_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for ZeroMQConfig.cmake")
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
if (NOT CMAKE_VERSION VERSION_LESS 3.0)
export(EXPORT ${PROJECT_NAME}-targets
FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake")
endif()
cmake install config file
2017-01-06 22:41:29 +01:00
configure_package_config_file(${PROJECT_NAME}Config.cmake.in
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION ${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH}
COMPATIBILITY AnyNewerVersion)
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
install(EXPORT ${PROJECT_NAME}-targets
FILE ${PROJECT_NAME}Targets.cmake
DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
cmake install config file
2017-01-06 22:41:29 +01:00
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
CPack option and .txt files installation dir
2017-01-06 14:29:56 +01:00
option(ENABLE_CPACK "Enables cpack rules" ON)
if (MSVC AND ENABLE_CPACK)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (InstallRequiredSystemLibraries)
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_CL_64)
set (arch_name "x64")
else ()
set (arch_name "x86")
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CPACK_NSIS_DISPLAY_NAME "ZeroMQ ${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH} (${arch_name})")
set (CPACK_PACKAGE_FILE_NAME "ZeroMQ-${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH}-${arch_name}")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# TODO: I think this part was intended to be used when running cpack
# separately from cmake but I don't know how that works.
#
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# macro (add_crt_version version)
# set (rel_dir "${CMAKE_CURRENT_BINARY_DIR}/build/${arch_name}/${version};ZeroMQ;ALL;/")
# set (debug_dir "${CMAKE_CURRENT_BINARY_DIR}/debug/${arch_name}/${version};ZeroMQ;ALL;/")
# if (EXISTS ${rel_dir})
# list (APPEND CPACK_INSTALL_CMAKE_PROJECTS ${rel_dir})
# endif ()
# if (EXISTS ${debug_dir})
# list (APPEND CPACK_INSTALL_CMAKE_PROJECTS ${rel_dir})
# endmacro ()
# endmacro ()
# add_crt_version (v110)
# add_crt_version (v100)
# add_crt_version (v90)
set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_BINARY_DIR}")
set (CPACK_GENERATOR "NSIS")
set (CPACK_PACKAGE_NAME "ZeroMQ")
set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "ZeroMQ lightweight messaging kernel")
set (CPACK_PACKAGE_VENDOR "Miru")
set (CPACK_NSIS_CONTACT "Steven McCoy <Steven.McCoy@miru.hk>")
set (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_BINARY_DIR}\\\\COPYING.txt")
# set (CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_BINARY_DIR}\\\\README.txt")
# set (CPACK_RESOURCE_FILE_WELCOME "${CMAKE_CURRENT_BINARY_DIR}\\\\WELCOME.txt")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# There is a bug in NSI that does not handle full unix paths properly. Make
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# sure there is at least one set of four (4) backslashes.
set (CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\installer.ico")
set (CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\installer.ico")
set (CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\branding.bmp")
set (CPACK_NSIS_COMPRESSOR "/SOLID lzma")
set (CPACK_PACKAGE_VERSION ${ZMQ_VERSION})
set (CPACK_PACKAGE_VERSION_MAJOR ${ZMQ_VERSION_MAJOR})
set (CPACK_PACKAGE_VERSION_MINOR ${ZMQ_VERSION_MINOR})
set (CPACK_PACKAGE_VERSION_PATCH ${ZMQ_VERSION_PATCH})
# set (CPACK_PACKAGE_INSTALL_DIRECTORY "ZMQ Install Directory")
# set (CPACK_TEMPORARY_DIRECTORY "ZMQ Temporary CPack Directory")
include (CPack)
cpack_add_component_group (Development
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ software development kit"
EXPANDED)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (PerfTools
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ performance tools"
INSTALL_TYPES FullInstall DevInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (SourceCode
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ source code"
DISABLED
INSTALL_TYPES FullInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (SDK
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ headers and libraries"
INSTALL_TYPES FullInstall DevInstall
GROUP Development)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_DOC)
cpack_add_component (RefGuide
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ reference guide"
INSTALL_TYPES FullInstall DevInstall
GROUP Development)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
cpack_add_component (Runtime
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ runtime files"
REQUIRED
INSTALL_TYPES FullInstall DevInstall MinInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (FullInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Full install, including source code")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (DevInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Developer install, headers and libraries")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (MinInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Minimal install, runtime only")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# Export this for library to help build this as a sub-project
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (ZEROMQ_LIBRARY libzmq CACHE STRING "ZeroMQ library")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# Workaround for MSVS10 to avoid the Dialog Hell
# FIXME: This could be removed with future version of CMake.
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC_VERSION EQUAL 1600)
set (ZMQ_SLN_FILENAME "${CMAKE_CURRENT_BINARY_DIR}/ZeroMQ.sln")
if (EXISTS "${ZMQ_SLN_FILENAME}")
file (APPEND "${ZMQ_SLN_FILENAME}" "\n# This should be regenerated!\n")
endif ()
endif ()
Reference in New Issue Copy Permalink