cmake_minimum_required(VERSION 3.10.0)

message("Using CMake ${CMAKE_VERSION}")

project(veyon)

option(WITH_CORE_ONLY "Build core library only" OFF)

option(WITH_ADDONS "Build add-ons" OFF)

option(WITH_TRANSLATIONS "Build translation files" ON)

option(WITH_TESTS "Build tests and integrate runtime test extensions" OFF)

option(WITH_LTO "Build with link-time optimization" ON)

option(WITH_PCH "Reduce compile time by using precompiled headers (requires CMake >= 3.16)" ON)

option(WITH_UNITY_BUILD "Reduce compile time by using cmake unity builds (requires CMake >= 3.16)" ON)

option(WITH_ADDRESS_SANITIZER "Build with address sanitizer" OFF)

option(WITH_THREAD_SANITIZER "Build with thread sanitizer" OFF)

option(WITH_UB_SANITIZER "Build with undefined behavior sanitizer" OFF)

option(WITH_FUZZERS "Build LLVM fuzzer tests (implies WITH_TESTS=ON)" OFF)

option(WITH_BUILTIN_LIBVNC "Build with built-in LibVNCServer/Client" OFF)

set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})

if(CMAKE_BUILD_TYPE STREQUAL "Debug")

set(VEYON_DEBUG TRUE)

elseif(NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "None")

set(CMAKE_BUILD_TYPE RelWithDebInfo)

endif()

if(VEYON_DEBUG)

add_definitions(-DVEYON_DEBUG)

else()

add_definitions(-D_FORTIFY_SOURCE=2)

endif()

set(CMAKE_EXPORT_COMPILE_COMMANDS 1)

if(COMMAND CMAKE_POLICY)

cmake_policy(SET CMP0009 NEW)

cmake_policy(SET CMP0022 NEW)

cmake_policy(SET CMP0058 NEW)

cmake_policy(SET CMP0063 NEW)

cmake_policy(SET CMP0069 NEW)

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.12.0")

cmake_policy(SET CMP0075 NEW)

endif()

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14.0")

cmake_policy(SET CMP0083 NEW)

include(CheckPIESupported)

check_pie_supported(LANGUAGES CXX)

if(CMAKE_CXX_LINK_PIE_SUPPORTED)

set(CMAKE_COMPILE_OPTIONS_PIE "-fPIE")

set(CMAKE_LINK_OPTIONS_PIE "-pie;-fPIE;-fPIC")

else()

set(CMAKE_COMPILE_OPTIONS_PIE "-fPIC")

set(CMAKE_LINK_OPTIONS_PIE "-fPIC")

endif()

endif()

endif()

include(AddFileDependencies)

include(CheckCSourceCompiles)

include(CheckIncludeFiles)

include(CheckFunctionExists)

include(CheckSymbolExists)

include(CheckTypeSize)

include(GNUInstallDirs)

include(ConfigureFiles)

include(PchHelpers)

include(SetDefaultTargetProperties)

find_package(Git)

if(GIT_FOUND)

execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags

WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}

OUTPUT_STRIP_TRAILING_WHITESPACE

OUTPUT_VARIABLE VERSION_STRING)

string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${VERSION_STRING}")

string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" VERSION_MINOR "${VERSION_STRING}")

string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" VERSION_PATCH "${VERSION_STRING}")

# determine build number to use in NSIS installer and resource files

execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags

COMMAND cut -d "-" -f2

WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}

OUTPUT_STRIP_TRAILING_WHITESPACE

OUTPUT_VARIABLE VERSION_BUILD)

if(NOT VERSION_BUILD GREATER 0)

set(VERSION_BUILD 0)

endif()

# Get list of all committers from git history, ordered by number of commits.

# The CONTRIBUTORS file is used by AboutDialog. This information can be provided

# with -DCONTRIBUTORS=/path/to/CONTRIBUTORS instead. For instance, to generate

# this file for version 3.0.2, the command is:

# git shortlog -sne v3.0.2 | cut -c8-

set(CONTRIBUTORS "${CMAKE_BINARY_DIR}/CONTRIBUTORS")

if(NOT EXISTS "${CONTRIBUTORS}")

execute_process(COMMAND "${GIT_EXECUTABLE}" shortlog -s d160d147165271516589c304cb1b8f5e48f8527d..HEAD

COMMAND cut -c8-

COMMAND sort -f

OUTPUT_FILE "${CONTRIBUTORS}"

WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"

TIMEOUT 10)

endif()

endif()

# can't retrieve version information as not building from Git repository?

if(NOT VERSION_STRING)

set(VERSION_MAJOR 4)

set(VERSION_MINOR 99)

set(VERSION_PATCH 0)

set(VERSION_BUILD 0)

set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")

else()

# remove leading character from tag name

string(REPLACE "v" "" VERSION_STRING "${VERSION_STRING}")

endif()

# set up basic platform variables

if(WIN32)

set(VEYON_BUILD_WINDOWS 1)

if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")

set(VEYON_BUILD_WIN64 1)

set(VEYON_WINDOWS_ARCH "win64")

else()

set(VEYON_BUILD_WIN32 1)

set(VEYON_WINDOWS_ARCH "win32")

endif()

add_definitions(-DUNICODE -D_UNICODE)

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-attributes")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-attributes")

endif()

if(APPLE)

set(VEYON_BUILD_APPLE 1)

endif()

if(UNIX AND NOT ANDROID)

set(VEYON_BUILD_LINUX 1)

endif()

if(ANDROID)

set(VEYON_BUILD_ANDROID 1)

endif()

# set up library and plugin path variables

if(VEYON_BUILD_ANDROID)

set(CMAKE_INSTALL_PREFIX "/")

set(VEYON_LIB_DIR "lib")

set(VEYON_INSTALL_PLUGIN_DIR "${VEYON_LIB_DIR}/veyon")

set(VEYON_INSTALL_DATA_DIR "${CMAKE_INSTALL_DATADIR}/veyon")

set(VEYON_PLUGIN_DIR "")

set(VEYON_TRANSLATIONS_DIR "/translations")

else()

if(CMAKE_INSTALL_LIBDIR)

set(VEYON_LIB_DIR "${CMAKE_INSTALL_LIBDIR}/veyon" CACHE INTERNAL "Veyon library directory")

else()

set(VEYON_LIB_DIR lib/veyon CACHE INTERNAL "Veyon library directory")

endif()

set(VEYON_INSTALL_PLUGIN_DIR "${VEYON_LIB_DIR}")

set(VEYON_INSTALL_DATA_DIR "${CMAKE_INSTALL_DATADIR}/veyon")

if(WIN32)

set(VEYON_PLUGIN_DIR "plugins")

set(VEYON_TRANSLATIONS_DIR "translations")

else()

set(VEYON_PLUGIN_DIR "../${VEYON_LIB_DIR}")

set(VEYON_TRANSLATIONS_DIR "../share/veyon/translations")

endif()

endif()

# find required Qt modules

option(WITH_QT6 "Build for Qt 6" OFF)

if(WITH_QT6)

set(QT_MAJOR_VERSION 6)

find_package(Qt6 COMPONENTS

Core

Core5Compat

Concurrent

Gui

Widgets

Network

Quick

QuickControls2

REQUIRED)

if(WITH_TRANSLATIONS)

find_package(Qt6 COMPONENTS LinguistTools REQUIRED)

endif()

if(VEYON_BUILD_ANDROID)

find_package(Qt6 COMPONENTS AndroidExtras REQUIRED)

endif()

else()

set(QT_MAJOR_VERSION 5)

find_package(Qt5Core REQUIRED)

find_package(Qt5Concurrent REQUIRED)

find_package(Qt5Gui REQUIRED)

find_package(Qt5Widgets REQUIRED)

find_package(Qt5Network REQUIRED)

find_package(Qt5Quick REQUIRED)

find_package(Qt5QuickControls2 REQUIRED)

if(WITH_TRANSLATIONS)

find_package(Qt5LinguistTools REQUIRED)

endif()

if(VEYON_BUILD_ANDROID)

find_package(Qt5AndroidExtras REQUIRED)

endif()

endif()

# find required libraries

find_package(Qca-qt${QT_MAJOR_VERSION} REQUIRED)

find_package(OpenSSL REQUIRED)

# find Linux-specific packages

if(VEYON_BUILD_LINUX)

include(XdgInstall)

endif()

if(${CMAKE_VERSION} VERSION_LESS "3.16.0")

set(WITH_PCH OFF)

set(WITH_UNITY_BUILD OFF)

elseif(WITH_UNITY_BUILD)

set(CMAKE_UNITY_BUILD ON)

endif()

if(VEYON_BUILD_WIN32)

set(WITH_LTO OFF)

endif()

if(WITH_LTO)

include(ProcessorCount)

ProcessorCount(CPU_COUNT)

set(GCC_LTO_FLAGS "-flto=${CPU_COUNT} -fno-fat-lto-objects")

endif()

if(WITH_FUZZERS)

set(WITH_TESTS ON)

endif()

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-strong ${CFLAGS}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong -fno-exceptions ${CXXFLAGS}")

if(WITH_TESTS)

enable_testing(TRUE)

if(WITH_QT6)

find_package(Qt6 COMPONENTS Test REQUIRED)

else()

find_package(Qt5Test REQUIRED)

endif()

else()

set(CMAKE_C_VISIBILITY_PRESET hidden)

set(CMAKE_CXX_VISIBILITY_PRESET hidden)

set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)

endif()

add_definitions(

-DQT_DEPRECATED_WARNINGS

-DQT_DISABLE_DEPRECATED_BEFORE=0x050e00

-DQT_NO_CAST_FROM_ASCII

-DQT_NO_CAST_TO_ASCII

-DQT_NO_CAST_FROM_BYTEARRAY

-DQT_NO_KEYWORDS

-DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT

-DQT_USE_QSTRINGBUILDER

-DQT_STRICT_ITERATORS

)

file(GLOB_RECURSE IN_FILES RELATIVE ${CMAKE_SOURCE_DIR} "veyonconfig.h.in" "*.rc.in" "*.desktop.in" "*.policy.in" "*.service.in" "*.manifest.in" "*.nsi.in")

configure_files(${IN_FILES})

set(CMAKE_AUTOMOC TRUE)

set(CMAKE_AUTOUIC TRUE)

set(CMAKE_AUTORCC TRUE)

set(3rdparty_DIR ${CMAKE_SOURCE_DIR}/3rdparty)

set(ultravnc_DIR ${3rdparty_DIR}/ultravnc)

set(libvncserver_DIR ${3rdparty_DIR}/libvncserver)

set(x11vnc_DIR ${3rdparty_DIR}/x11vnc)

set(libfakekey_DIR ${3rdparty_DIR}/libfakekey)

set(qthttpserver_DIR ${3rdparty_DIR}/qthttpserver)

set(CMAKE_SKIP_BUILD_RPATH FALSE)

set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)

set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${VEYON_LIB_DIR}")

set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)

if(VEYON_BUILD_ANDROID)

include(AndroidDeployQt)

set(_CMAKE_ANDROID_DIR "${CMAKE_SOURCE_DIR}/android")

set(ANDROID_INSTALL_DIR "${CMAKE_BINARY_DIR}/install")

set(ANDROID_EXTRA_PLUGINS ${ANDROID_INSTALL_DIR}/${VEYON_LIB_DIR}/veyon/ ${QT_DIR}/lib/qca-qt5/crypto ${ANDROID_INSTALL_DIR}/jar)

set(ANDROID_EXTRA_LIBS)

list(APPEND ANDROID_EXTRA_LIBS "${ANDROID_SYSROOT_GENERIC}/libc++_shared.so")

list(APPEND ANDROID_EXTRA_LIBS "${QT_DIR}/lib/libldap.so"

"${QT_DIR}/lib/liblber.so"

"${QT_DIR}/lib/libsasl2.so")

add_custom_target(prepare-apk

COMMAND rm -rf ${ANDROID_INSTALL_DIR}

COMMAND cd ${CMAKE_BINARY_DIR}/core && make DESTDIR=${ANDROID_INSTALL_DIR} install

COMMAND cd ${CMAKE_BINARY_DIR}/plugins && make DESTDIR=${ANDROID_INSTALL_DIR} install

)

endif()

include(cmake/CPackDefinitions.cmake)

# make sub-directories

add_subdirectory(core)

if(NOT WITH_CORE_ONLY)

add_subdirectory(server)

add_subdirectory(service)

add_subdirectory(master)

add_subdirectory(configurator)

add_subdirectory(cli)

add_subdirectory(worker)

add_subdirectory(plugins)

add_subdirectory(tests)

add_subdirectory(translations)

endif()

if(WITH_ADDONS)

add_subdirectory(addons)

endif()

#

# add Windows installer related targets

#

if(WIN32)

include(WindowsInstaller)

endif()

#

# package generation

#

include(CPack)

#

# display configuration information

#

message("\n"

"Veyon build summary\n"

"--------------------\n"

"* Version : ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_BUILD} (${VERSION_STRING})\n"

"* Install prefix : ${CMAKE_INSTALL_PREFIX}\n"

"* Library directory : ${CMAKE_INSTALL_PREFIX}/${VEYON_LIB_DIR}\n"

"* Plugin directory : ${CMAKE_INSTALL_PREFIX}/${VEYON_INSTALL_PLUGIN_DIR}\n"

"* Build type : ${CMAKE_BUILD_TYPE}\n"

"* Build platform : ${CMAKE_SYSTEM_PROCESSOR}\n"

"* Compile flags : ${CMAKE_C_FLAGS} (CXX: ${CMAKE_CXX_FLAGS})\n"

"* Link-time optimization : ${WITH_LTO}\n"

"* Use precompiled headers : ${WITH_PCH}\n"

"* Use unity build : ${WITH_UNITY_BUILD}\n"

)