mirror of https://github.com/Cisco-Talos/clamav
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
865 lines
27 KiB
865 lines
27 KiB
# Copyright (C) 2019-2020 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
|
|
|
|
cmake_minimum_required( VERSION 3.12...3.13 )
|
|
set(CMAKE_C_STANDARD 90)
|
|
set(CMAKE_C_STANDARD_REQUIRED ON)
|
|
set(CMAKE_CXX_STANDARD 11)
|
|
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
|
|
|
# Change this on a release:
|
|
# During active development: set(VERSION_SUFFIX "-devel-${TODAY}")
|
|
# For beta: set(VERSION_SUFFIX "-beta")
|
|
# For release candidate: set(VERSION_SUFFIX "-rc")
|
|
# For release: set(VERSION_SUFFIX "")
|
|
string(TIMESTAMP TODAY "%Y%m%d")
|
|
set(VERSION_SUFFIX "-devel-${TODAY}")
|
|
|
|
project( ClamAV
|
|
VERSION "0.103.0"
|
|
DESCRIPTION "ClamAV open source email, web, and end-point anti-virus toolkit." )
|
|
|
|
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
|
|
include(Version)
|
|
|
|
set(PACKAGE_NAME "${PROJECT_NAME}")
|
|
set(PACKAGE_VERSION "${PROJECT_VERSION}")
|
|
set(PACKAGE_STRING "${PROJECT_NAME} ${PROJECT_VERSION}${VERSION_SUFFIX}")
|
|
set(PACKAGE_BUGREPORT "https://bugzilla.clamav.net/")
|
|
set(PACKAGE_URL "https://www.clamav.net/")
|
|
HexVersion(PACKAGE_VERSION_NUM ${PROJECT_VERSION_MAJOR} ${PROJECT_VERSION_MINOR} ${PROJECT_VERSION_PATCH})
|
|
|
|
# libtool library versioning rules: http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
|
|
set(LIBCLAMAV_CURRENT 9)
|
|
set(LIBCLAMAV_REVISION 5)
|
|
set(LIBCLAMAV_AGE 0)
|
|
|
|
math(EXPR LIBCLAMAV_SOVERSION "${LIBCLAMAV_CURRENT} - ${LIBCLAMAV_AGE}")
|
|
set(LIBCLAMAV_VERSION "${LIBCLAMAV_SOVERSION}.${LIBCLAMAV_AGE}.${LIBCLAMAV_REVISION}")
|
|
HexVersion(LIBCLAMAV_VERSION_NUM ${LIBCLAMAV_CURRENT} ${LIBCLAMAV_REVISION} ${LIBCLAMAV_AGE})
|
|
|
|
set(LIBFRESHCLAM_CURRENT 2)
|
|
set(LIBFRESHCLAM_REVISION 1)
|
|
set(LIBFRESHCLAM_AGE 0)
|
|
|
|
math(EXPR LIBFRESHCLAM_SOVERSION "${LIBFRESHCLAM_CURRENT} - ${LIBFRESHCLAM_AGE}")
|
|
set(LIBFRESHCLAM_VERSION "${LIBFRESHCLAM_SOVERSION}.${LIBFRESHCLAM_AGE}.${LIBFRESHCLAM_REVISION}")
|
|
HexVersion(LIBFRESHCLAM_VERSION_NUM ${LIBFRESHCLAM_CURRENT} ${LIBFRESHCLAM_REVISION} ${LIBFRESHCLAM_AGE})
|
|
|
|
# Git optionally used to add commit info into build to differentiate in bug reports.
|
|
find_package(Git)
|
|
if(Git_FOUND)
|
|
# Store git description into variable
|
|
execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --always
|
|
OUTPUT_VARIABLE REPO_VERSION)
|
|
if("${REPO_VERSION}" MATCHES "")
|
|
unset(REPO_VERSION)
|
|
else()
|
|
string(STRIP ${REPO_VERSION} REPO_VERSION)
|
|
endif()
|
|
endif()
|
|
|
|
# Enable use of pkg-config to find depenencies.
|
|
find_package(PkgConfig QUIET)
|
|
|
|
#
|
|
# Find Build Tools
|
|
#
|
|
|
|
# Bison, Flex required to build Yara module for libclamav.
|
|
find_package(BISON REQUIRED)
|
|
find_package(FLEX REQUIRED)
|
|
if(MAINTAINER_MODE)
|
|
find_package(GPERF REQUIRED)
|
|
endif()
|
|
|
|
#
|
|
# Load Build Options
|
|
#
|
|
|
|
# CMake Option default values:
|
|
set(ENABLE_APP_DEFAULT ON)
|
|
set(ENABLE_MILTER_DEFAULT OFF)
|
|
set(ENABLE_CLAMONACC_DEFAULT ON)
|
|
set(ENABLE_EXAMPLES_DEFAULT OFF)
|
|
if(WIN32)
|
|
set(ENABLE_DOCS_DEFAULT OFF)
|
|
else()
|
|
set(ENABLE_DOCS_DEFAULT ON)
|
|
endif()
|
|
set(ENABLE_DOXYGEN_DEFAULT OFF)
|
|
set(ENABLE_UNRAR_DEFAULT ON)
|
|
set(ENABLE_SYSTEMD_DEFAULT ON)
|
|
|
|
# See CMakeOptions.cmake for additional options.
|
|
include(CMakeOptions.cmake)
|
|
|
|
if(ENABLE_LIBCLAMAV_ONLY AND (ENABLE_APP OR ENABLE_EXAMPLES))
|
|
# Remember when disabled options are disabled for later diagnostics.
|
|
set(ENABLE_LIB_ONLY_DISABLED_OTHERS 1)
|
|
else()
|
|
set(ENABLE_LIB_ONLY_DISABLED_OTHERS 0)
|
|
endif()
|
|
if(ENABLE_LIBCLAMAV_ONLY)
|
|
set(ENABLE_APP OFF)
|
|
set(ENABLE_EXAMPLES OFF)
|
|
endif()
|
|
|
|
#
|
|
# Set RPATH for custom install prefixes
|
|
#
|
|
if(APPLE)
|
|
set(CMAKE_MACOSX_RPATH 1)
|
|
endif()
|
|
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
|
|
|
|
#
|
|
# Define LINUX because CMake only defines UNIX
|
|
#
|
|
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
|
|
set(LINUX 1)
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCXX)
|
|
# For O_LARGEFILE, O_CLOEXEC, O_DIRECTORY, O_NOFOLLOW, etc flags on older systems
|
|
# (pre POSIX.1-2008: glibc 2.11 and earlier). #4042
|
|
set(_GNU_SOURCE 1)
|
|
endif()
|
|
endif()
|
|
|
|
#
|
|
# Set FreeBSD include path to include /usr/local/include
|
|
#
|
|
if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
|
|
include_directories(/usr/local/include)
|
|
endif()
|
|
|
|
#
|
|
# Use the `lib` prefix on Windows, to match previous ClamAV build
|
|
#
|
|
if(WIN32)
|
|
set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
|
|
set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
|
|
endif()
|
|
|
|
#
|
|
# Find Library Dependencies
|
|
#
|
|
if (WIN32)
|
|
find_package(PThreadW32)
|
|
set(HAVE_PTHREAD_H 1)
|
|
set(_REENTRANT 1)
|
|
set(CL_THREAD_SAFE 1)
|
|
else()
|
|
set(CMAKE_THREAD_PREFER_PTHREAD 1)
|
|
find_package(Threads)
|
|
if(Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
|
|
set(HAVE_PTHREAD_H 1)
|
|
set(_REENTRANT 1)
|
|
set(CL_THREAD_SAFE 1)
|
|
endif()
|
|
endif()
|
|
|
|
# libclamav efficacy dependencies
|
|
find_package(OpenSSL REQUIRED)
|
|
if(OPENSSL_FOUND)
|
|
set(HAVE_LIBSSL 1)
|
|
endif()
|
|
|
|
find_package(ZLIB REQUIRED)
|
|
if(ZLIB_FOUND)
|
|
set(HAVE_ZLIB_H 1)
|
|
set(HAVE_LIBZ 1)
|
|
endif()
|
|
|
|
find_package(BZip2 REQUIRED)
|
|
if(BZIP2_FOUND)
|
|
set(HAVE_BZLIB_H 1)
|
|
endif()
|
|
|
|
find_package(LibXml2 REQUIRED)
|
|
if(LibXml2_FOUND)
|
|
set(HAVE_LIBXML2 1)
|
|
endif()
|
|
|
|
find_package(PCRE2 REQUIRED)
|
|
if(PCRE2_FOUND)
|
|
set(HAVE_PCRE 1)
|
|
set(USING_PCRE2 1)
|
|
endif()
|
|
|
|
# libclamav feature dependencies
|
|
if(NOT WIN32)
|
|
find_package(Iconv REQUIRED)
|
|
# Set variable required by libclamav to use iconv
|
|
set(HAVE_ICONV 1)
|
|
endif()
|
|
|
|
if(ENABLE_JSON_SHARED)
|
|
set(JSONC_USE_STATIC OFF)
|
|
else()
|
|
set(JSONC_USE_STATIC ON)
|
|
endif()
|
|
find_package(JSONC REQUIRED)
|
|
# Set variable required by libclamav to use libjson-c
|
|
set(HAVE_JSON 1)
|
|
|
|
if(BYTECODE_RUNTIME STREQUAL "llvm")
|
|
find_package(LLVM REQUIRED)
|
|
if(LLVM_FOUND)
|
|
# Set variable required by libclamav to use llvm instead of interpreter
|
|
set(LLVM_VERSION ${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR})
|
|
endif()
|
|
endif()
|
|
|
|
# libfreshclam & app dependencies
|
|
if(NOT ENABLE_LIBCLAMAV_ONLY)
|
|
find_package(CURL REQUIRED)
|
|
|
|
if(APPLE)
|
|
find_library(APPLE_CORE_FOUNDATION CoreFoundation)
|
|
if (NOT APPLE_CORE_FOUNDATION)
|
|
message(FATAL_ERROR "Apple CoreFoundation framework not found")
|
|
endif()
|
|
find_library(APPLE_SECURITY Security)
|
|
if (NOT APPLE_SECURITY)
|
|
message(FATAL_ERROR "Apple Security framework not found")
|
|
endif()
|
|
endif()
|
|
|
|
if(ENABLE_APP)
|
|
find_package(CURSES REQUIRED)
|
|
|
|
if(NOT WIN32 AND ENABLE_MILTER)
|
|
find_package(Milter REQUIRED)
|
|
endif()
|
|
|
|
if(LINUX AND ENABLE_SYSTEMD)
|
|
find_package(SYSTEMD)
|
|
if(SYSTEMD_FOUND)
|
|
set(HAVE_SYSTEMD 1)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
|
|
# Do not disable assertions based on CMAKE_BUILD_TYPE.
|
|
foreach(_build_type "Release" "MinSizeRel" "RelWithDebInfo")
|
|
foreach(_lang C CXX)
|
|
string(TOUPPER "CMAKE_${_lang}_FLAGS_${_build_type}" _var)
|
|
string(REGEX REPLACE "(^|)[/-]D *NDEBUG($|)" " " ${_var} "${${_var}}")
|
|
endforeach()
|
|
endforeach()
|
|
|
|
# Disable optimizations if OPTIMIZE=OFF
|
|
if(NOT OPTIMIZE)
|
|
# Get rid of any previous optimization flag settings...
|
|
string(REGEX REPLACE "(\-O[011123456789])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
|
string(REGEX REPLACE "(\-O[011123456789])" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
|
|
|
|
# ...And substitute our own.
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0")
|
|
endif()
|
|
|
|
# Support the latest c++ standard available.
|
|
include(ExtractValidFlags)
|
|
foreach(_cxx1x_flag -std=c++14 -std=c++11)
|
|
extract_valid_cxx_flags(_cxx1x_flag_supported ${_cxx1x_flag})
|
|
if(_cxx1x_flag_supported)
|
|
set(CXX1XCXXFLAGS ${_cxx1x_flag})
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
|
|
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
|
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the build type" FORCE)
|
|
|
|
# Include "None" as option to disable any additional (optimization) flags,
|
|
# relying on just CMAKE_C_FLAGS and CMAKE_CXX_FLAGS (which are empty by
|
|
# default). These strings are presented in cmake-gui.
|
|
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
|
|
"None" "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
|
|
endif()
|
|
|
|
include(GNUInstallDirs)
|
|
|
|
# For test scripts and documentation
|
|
find_package(Python3)
|
|
|
|
# Always use '-fPIC'/'-fPIE' option.
|
|
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
|
|
|
# Checks for header files.
|
|
include(CheckIncludeFile)
|
|
check_include_file("arpa/inet.h" HAVE_ARPA_INET_H)
|
|
check_include_file("fcntl.h" HAVE_FCNTL_H)
|
|
check_include_file("grp.h" HAVE_GRP_H)
|
|
check_include_file("limits.h" HAVE_LIMITS_H)
|
|
check_include_file("malloc.h" HAVE_MALLOC_H)
|
|
check_include_file("netdb.h" HAVE_NETDB_H)
|
|
check_include_file("netinet/in.h" HAVE_NETINET_IN_H)
|
|
check_include_file("poll.h" HAVE_POLL_H)
|
|
check_include_file("pwd.h" HAVE_PWD_H)
|
|
check_include_file("stdbool.h" HAVE_STDBOOL_H)
|
|
check_include_file("stdlib.h" HAVE_STDLIB_H)
|
|
check_include_file("string.h" HAVE_STRING_H)
|
|
check_include_file("strings.h" HAVE_STRINGS_H)
|
|
check_include_file("sys/cdefs.h" HAVE_SYS_CDEFS_H)
|
|
check_include_file("sys/dl.h" HAVE_SYS_DL_H)
|
|
check_include_file("sys/fileio.h" HAVE_SYS_FILIO_H)
|
|
check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
|
|
check_include_file("sys/param.h" HAVE_SYS_PARAM_H)
|
|
check_include_file("sys/queue.h" HAVE_SYS_QUEUE_H)
|
|
check_include_file("sys/select.h" HAVE_SYS_SELECT_H)
|
|
check_include_file("sys/socket.h" HAVE_SYS_SOCKET_H)
|
|
check_include_file("sys/stat.h" HAVE_SYS_STAT_H)
|
|
check_include_file("sys/time.h" HAVE_SYS_TIME_H)
|
|
check_include_file("sys/times.h" HAVE_SYS_TIMES_H)
|
|
check_include_file("sys/uio.h" HAVE_SYS_UIO_H)
|
|
check_include_file("syslog.h" USE_SYSLOG)
|
|
check_include_file("termios.h" HAVE_TERMIOS_H)
|
|
check_include_file("time.h" HAVE_TIME_H)
|
|
check_include_file("unistd.h" HAVE_UNISTD_H)
|
|
check_include_file("sys/fanotify.h" HAVE_SYS_FANOTIFY_H)
|
|
|
|
if(WIN32)
|
|
set(HAVE_RESOLV_H 1)
|
|
set(HAVE_DIRENT_H 1)
|
|
set(HAVE_DLFCN_H 1)
|
|
else()
|
|
if(APPLE)
|
|
set(BIND_8_COMPAT 1)
|
|
endif()
|
|
check_include_file("resolv.h" HAVE_RESOLV_H) # Disabled, beacuse libfreshclam/dns.c is broken.
|
|
check_include_file("dirent.h" HAVE_DIRENT_H)
|
|
check_include_file("dlfcn.h" HAVE_DLFCN_H)
|
|
endif()
|
|
|
|
# int-types variants
|
|
check_include_file("inttypes.h" HAVE_INTTYPES_H)
|
|
check_include_file("sys/inttypes.h" HAVE_SYS_INTTYPES_H)
|
|
check_include_file("sys/int_types.h" HAVE_SYS_INT_TYPES_H)
|
|
check_include_file("stdint.h" HAVE_STDINT_H)
|
|
|
|
include(CheckTypeSize)
|
|
# Checks for typedefs, structures, and compiler characteristics.
|
|
# AC_TYPE_SIZE_T
|
|
check_type_size("ssize_t" SIZEOF_SSIZE_T)
|
|
if(SIZEOF_SSIZE_T STREQUAL "")
|
|
# ssize_t is a signed type in POSIX storing at least -1.
|
|
# Set it to "int" to match the behavior of AC_TYPE_SSIZE_T (autotools).
|
|
set(ssize_t int)
|
|
endif()
|
|
check_type_size("off_t" SIZEOF_OFF_T)
|
|
if(SIZEOF_OFF_T STREQUAL "")
|
|
# off_t is a signed type in POSIX no narrower than int.
|
|
# Set it to "long int" to match the behavior of AC_TYPE_OFF_T (autotools).
|
|
set(off_t long int)
|
|
endif()
|
|
|
|
check_type_size("int" SIZEOF_INT)
|
|
check_type_size("short" SIZEOF_SHORT)
|
|
check_type_size("long" SIZEOF_LONG)
|
|
check_type_size("long long" SIZEOF_LONG_LONG)
|
|
|
|
#
|
|
# Variables for clamav-types.h.in
|
|
#
|
|
if(HAVE_SYS_INT_TYPES_H)
|
|
set(INT_TYPES_HEADER "#include <sys/int_types.h>")
|
|
elseif(HAVE_INTTYPES_H)
|
|
set(INT_TYPES_HEADER "#include <inttypes.h>")
|
|
elseif(HAVE_STDINT_H)
|
|
set(INT_TYPES_HEADER "#include <stdint.h>")
|
|
elseif(WIN32 AND MSVC)
|
|
# Windows / Visual C++ (not Cygwin), stdint.h should exist.
|
|
set(INT_TYPES_HEADER "#include <stdint.h>")
|
|
else()
|
|
# No int types header available. We'll define the types manually.
|
|
set(INT8_DEF "typedef signed char int8_t;")
|
|
set(UINT8_DEF "typedef unsigned char uint8_t;")
|
|
|
|
if(SIZEOF_INT EQUAL 2)
|
|
set(INT16_DEF "typedef signed int int16_t;")
|
|
set(UINT16_DEF "typedef unsigned int uint16_t;")
|
|
elif(SIZEOF_SHORT EQUAL 2)
|
|
set(INT16_DEF "typedef signed short int16_t;")
|
|
set(UINT16_DEF "typedef unsigned short uint16_t;")
|
|
endif()
|
|
|
|
if(SIZEOF_INT EQUAL 4)
|
|
set(INT32_DEF "typedef signed int int32_t;")
|
|
set(UINT32_DEF "typedef unsigned int uint32_t;")
|
|
elif(SIZEOF_LONG EQUAL 4)
|
|
set(INT32_DEF "typedef signed long int32_t;")
|
|
set(UINT32_DEF "typedef unsigned long uint32_t;")
|
|
endif()
|
|
|
|
if(SIZEOF_LONG EQUAL 8)
|
|
set(INT64_DEF "typedef signed long int64_t;")
|
|
set(UINT64_DEF "typedef unsigned long uint64_t;")
|
|
elif(SIZEOF_LONG_LONG EQUAL 8)
|
|
set(INT64_DEF "typedef signed long long int64_t;")
|
|
set(UINT64_DEF "typedef unsigned long long uint64_t;")
|
|
endif()
|
|
endif()
|
|
|
|
# Check for restrict keyword
|
|
#TODO: Move this to a .cmake file
|
|
foreach( ac_kw __restrict __restrict__ _Restrict restrict )
|
|
check_c_source_compiles(
|
|
"
|
|
typedef int * int_ptr;
|
|
int foo (int_ptr ${ac_kw} ip) {
|
|
return ip[0];
|
|
}
|
|
int main() {
|
|
int s[1];
|
|
int * ${ac_kw} t = s;
|
|
t[0] = 0;
|
|
return foo(t);
|
|
}
|
|
"
|
|
HAVE_RESTRICT )
|
|
|
|
if( HAVE_RESTRICT )
|
|
set( ac_cv_c_restrict ${ac_kw} )
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
if( HAVE_RESTRICT )
|
|
set( restrict ${ac_cv_c_restrict} )
|
|
endif()
|
|
|
|
# Define inline macro as needed.
|
|
include(TestInline)
|
|
# Determine if _FILE_OFFSET_BITS 64 needs to be set to handle large files.
|
|
include(CheckFileOffsetBits)
|
|
# Determine how to pack structs on this platform.
|
|
include(CheckStructPacking)
|
|
# Check for signed right shift implementation.
|
|
include(CheckSignedRightShift)
|
|
# Check if systtem fts implementation available
|
|
include(CheckFTS)
|
|
# Check if uname(2) follows POSIX standard.
|
|
include(CheckUnamePosix)
|
|
# Check support for file descriptor passing
|
|
include(CheckFDPassing)
|
|
|
|
# Check if big-endian
|
|
include(TestBigEndian)
|
|
TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
|
|
|
|
include(CheckStructHasMember)
|
|
check_struct_has_member("struct tm" tm_gmtoff time.h HAVE_STRUCT_TM_TM_GMTOFF)
|
|
|
|
# Check size of pointer to decide we need 8 bytes alignment adjustment.
|
|
check_type_size("int *" SIZEOF_INT_P)
|
|
check_type_size("time_t" SIZEOF_TIME_T)
|
|
|
|
# Checks for library functions.
|
|
include(CheckSymbolExists)
|
|
check_symbol_exists(_Exit "stdlib.h" HAVE__EXIT)
|
|
check_symbol_exists(accept4 "sys/types.h" HAVE_ACCEPT4)
|
|
check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
|
|
check_symbol_exists(stat64 "sys/stat.h" HAVE_STAT64)
|
|
check_symbol_exists(strcasestr "string.h" HAVE_STRCASESTR)
|
|
check_symbol_exists(strerror_r "string.h" HAVE_STRERROR_R)
|
|
check_symbol_exists(strlcat "string.h" HAVE_STRLCAT)
|
|
check_symbol_exists(strlcpy "string.h" HAVE_STRLCPY)
|
|
check_symbol_exists(strndup "string.h" HAVE_STRNDUP)
|
|
check_symbol_exists(strnlen "string.h" HAVE_STRNLEN)
|
|
check_symbol_exists(strnstr "string.h" HAVE_STRNSTR)
|
|
check_symbol_exists(sysctlbyname "sysctl.h" HAVE_SYSCTLBYNAME)
|
|
check_symbol_exists(timegm "time.h" HAVE_TIMEGM)
|
|
check_symbol_exists(vsnprintf "stdio.h" HAVE_VSNPRINTF)
|
|
|
|
if(WIN32)
|
|
#set(HAVE_FSEEKO 1)
|
|
set(HAVE_GETADDRINFO 1)
|
|
set(HAVE_GETPAGESIZE 1)
|
|
set(HAVE_MKSTEMP 1)
|
|
set(HAVE_POLL 1)
|
|
else()
|
|
check_symbol_exists(fseeko "stdio.h" HAVE_FSEEKO)
|
|
check_symbol_exists(getaddrinfo "netdb.h" HAVE_GETADDRINFO)
|
|
check_symbol_exists(getpagesize "unistd.h" HAVE_GETPAGESIZE)
|
|
check_symbol_exists(mkstemp "unistd.h" HAVE_MKSTEMP)
|
|
check_symbol_exists(poll "poll.h" HAVE_POLL)
|
|
check_symbol_exists(setgroups "unistd.h" HAVE_SETGROUPS)
|
|
check_symbol_exists(setsid "unistd.h" HAVE_SETSID)
|
|
endif()
|
|
|
|
include(CheckSymbolExists)
|
|
# XXX does this correctly detect initgroups (un)availability on cygwin?
|
|
check_symbol_exists(initgroups grp.h HAVE_INITGROUPS)
|
|
if(NOT HAVE_INITGROUPS AND HAVE_UNISTD_H)
|
|
# FreeBSD declares initgroups() in unistd.h
|
|
check_symbol_exists(initgroups unistd.h HAVE_INITGROUPS2)
|
|
if(HAVE_INITGROUPS2)
|
|
set(HAVE_INITGROUPS 1)
|
|
endif()
|
|
endif()
|
|
|
|
set(WARNCFLAGS)
|
|
set(WARNCXXFLAGS)
|
|
if(CMAKE_C_COMPILER_ID MATCHES "MSVC")
|
|
if(ENABLE_WERROR)
|
|
set(WARNCFLAGS /WX)
|
|
set(WARNCXXFLAGS /WX)
|
|
endif()
|
|
else()
|
|
if(ENABLE_WERROR)
|
|
extract_valid_c_flags(WARNCFLAGS -Werror)
|
|
extract_valid_c_flags(WARNCXXFLAGS -Werror)
|
|
endif()
|
|
|
|
# For C compiler
|
|
extract_valid_c_flags(WARNCFLAGS
|
|
-Wall -Wextra
|
|
-Wformat-security
|
|
)
|
|
if(ENABLE_ALL_THE_WARNINGS)
|
|
extract_valid_c_flags(WARNCFLAGS
|
|
-Waddress
|
|
-Wattributes
|
|
-Wclobbered
|
|
-Wconversion
|
|
-Wdeclaration-after-statement
|
|
-Wdiv-by-zero
|
|
-Wempty-body
|
|
-Wendif-labels
|
|
-Wfloat-equal
|
|
-Wformat-nonliteral
|
|
-Winline
|
|
-Wmissing-declarations
|
|
-Wmissing-field-initializers
|
|
-Wmissing-noreturn
|
|
-Wmissing-prototypes
|
|
-Wnested-externs
|
|
#-Wno-format-nonliteral # May be required to pass format string as "const char*.
|
|
-Wpointer-arith
|
|
-Wpragmas
|
|
-Wredundant-decls
|
|
-Wshadow
|
|
-Wunreachable-code
|
|
-Wunused-parameter
|
|
-Wvla
|
|
-Wwrite-strings
|
|
-Wstrict-prototypes
|
|
-Wundef
|
|
-Wcast-align
|
|
-Wextended-offsetof # May be missing from GCC
|
|
-Wheader-guard # Only work with Clang for the moment
|
|
-Wlanguage-extension-token # May be missing from GCC
|
|
-Wmissing-variable-declarations # May be missing from GCC
|
|
#-Wpadded # Not used because we cannot change public structs
|
|
-Wshorten-64-to-32 # May be missing from GCC
|
|
-Wsign-conversion
|
|
#-Wswitch-enum # Not used because this basically disallows default case
|
|
-Wunreachable-code-break # May be missing from GCC
|
|
-Wunused-macros
|
|
)
|
|
endif()
|
|
|
|
# For C++ compiler
|
|
extract_valid_cxx_flags(WARNCXXFLAGS
|
|
-Wall
|
|
-Wformat-security
|
|
)
|
|
endif()
|
|
|
|
# autotools-compatible names
|
|
# Sphinx expects relative paths in the .rst files. Use the fact that the files
|
|
# below are all one directory level deep.
|
|
file(RELATIVE_PATH top_srcdir "${CMAKE_CURRENT_BINARY_DIR}/dir" "${CMAKE_CURRENT_SOURCE_DIR}")
|
|
file(RELATIVE_PATH top_builddir "${CMAKE_CURRENT_BINARY_DIR}/dir" "${CMAKE_CURRENT_BINARY_DIR}")
|
|
set(abs_top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
|
|
set(abs_top_builddir "${CMAKE_CURRENT_BINARY_DIR}")
|
|
# libclamav.pc (pkg-config file)
|
|
set(prefix "${CMAKE_INSTALL_PREFIX}")
|
|
set(exec_prefix "${CMAKE_INSTALL_PREFIX}")
|
|
set(bindir "${CMAKE_INSTALL_FULL_BINDIR}")
|
|
set(sbindir "${CMAKE_INSTALL_FULL_SBINDIR}")
|
|
set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}")
|
|
set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
|
|
set(VERSION "${PACKAGE_VERSION}")
|
|
|
|
# DBDIR for systemd service.in files
|
|
set(DBDIR "${DATABASE_DIRECTORY}")
|
|
|
|
if(ENABLE_DEBUG)
|
|
set(CL_DEBUG 1)
|
|
endif()
|
|
if(ENABLE_EXPERIMENTAL)
|
|
set(CL_EXPERIMENTAL 1)
|
|
endif()
|
|
if(ENABLE_STRN_INTERNAL)
|
|
set(HAVE_STRNI 1)
|
|
endif()
|
|
if(ENABLE_FRESHCLAM_DNS_FIX)
|
|
set(FRESHCLAM_DNS_FIX 1)
|
|
endif()
|
|
if(ENABLE_FRESHCLAM_NO_CACHE)
|
|
set(FRESHCLAM_NO_CACHE 1)
|
|
endif()
|
|
|
|
set(SCANBUFF 131072) # scan buffer size
|
|
set(FILEBUFF 8192) # file i/o buffer size
|
|
|
|
if(APPLE)
|
|
set(C_DARWIN 1)
|
|
endif()
|
|
|
|
include(config)
|
|
if(WIN32)
|
|
set(USE_MPOOL 1)
|
|
endif()
|
|
|
|
add_definitions(-DHAVE_CONFIG_H)
|
|
configure_file(clamav-config.h.cmake.in clamav-config.h)
|
|
configure_file(target.h.cmake.in target.h)
|
|
configure_file(platform.h.in platform.h)
|
|
configure_file(clamav-version.h.in clamav-version.h)
|
|
configure_file(clamav-types.h.in clamav-types.h)
|
|
|
|
if(WIN32)
|
|
#
|
|
# Windows-specific config stuff
|
|
#
|
|
|
|
# Windows resource file
|
|
set(CLAMAV_RES "")
|
|
configure_file(
|
|
win32/res/common.rc.in
|
|
${CMAKE_BINARY_DIR}/version.rc
|
|
@ONLY)
|
|
else()
|
|
#
|
|
# POSIX-specific config stuff
|
|
#
|
|
|
|
# Don't confuse clamav-config.in with clamav-config.h.in or clamav-config.h.cmake.in
|
|
configure_file(clamav-config.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/clamav-config
|
|
@ONLY)
|
|
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/clamav-config"
|
|
DESTINATION "${CMAKE_INSTALL_BINDIR}"
|
|
PERMISSIONS
|
|
OWNER_READ OWNER_WRITE OWNER_EXECUTE
|
|
GROUP_READ GROUP_EXECUTE
|
|
WORLD_READ WORLD_EXECUTE)
|
|
|
|
# pkg-config
|
|
configure_file(
|
|
libclamav.pc.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/libclamav.pc
|
|
@ONLY)
|
|
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libclamav.pc"
|
|
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
|
|
endif()
|
|
|
|
#
|
|
# ClamAV Build targets!
|
|
#
|
|
|
|
# Build targets for libraries.
|
|
if(ENABLE_UNRAR)
|
|
# Only build libclamunrar if enabled.
|
|
# We still define the libclamunrar_iface's interface regardless,
|
|
# so that libclamav will have unrar_iface.h in the include path.
|
|
add_subdirectory( libclamunrar )
|
|
endif()
|
|
add_subdirectory( libclamunrar_iface )
|
|
|
|
if(NOT ENABLE_EXTERNAL_MSPACK)
|
|
add_subdirectory(libclammspack)
|
|
else()
|
|
find_package(MSPack)
|
|
endif()
|
|
|
|
if(WIN32)
|
|
add_subdirectory( win32/compat )
|
|
endif()
|
|
|
|
add_subdirectory( libclamav )
|
|
|
|
if(NOT LIBCLAMAV_ONLY)
|
|
add_subdirectory( shared )
|
|
|
|
add_subdirectory( libfreshclam )
|
|
|
|
if(ENABLE_APP)
|
|
# Build targets for primary applications.
|
|
add_subdirectory( clamconf )
|
|
|
|
add_subdirectory( clamd )
|
|
|
|
add_subdirectory( clamdscan )
|
|
|
|
if(LINUX AND ENABLE_CLAMONACC)
|
|
add_subdirectory( clamonacc )
|
|
endif()
|
|
|
|
if(NOT WIN32 AND ENABLE_MILTER)
|
|
add_subdirectory( clamav-milter )
|
|
endif()
|
|
|
|
add_subdirectory( clamscan )
|
|
|
|
add_subdirectory( sigtool )
|
|
|
|
add_subdirectory( clambc )
|
|
|
|
add_subdirectory( clamsubmit )
|
|
|
|
add_subdirectory( freshclam )
|
|
|
|
add_subdirectory( clamdtop )
|
|
|
|
if(WIN32)
|
|
add_subdirectory( win32/conf_examples )
|
|
else()
|
|
add_subdirectory( etc )
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(ENABLE_EXAMPLES)
|
|
add_subdirectory( examples )
|
|
endif()
|
|
|
|
if(ENABLE_DOCS)
|
|
add_subdirectory( docs )
|
|
endif()
|
|
|
|
if(ENABLE_FUZZ)
|
|
add_subdirectory( fuzz )
|
|
endif()
|
|
|
|
#
|
|
# The Summary Info.
|
|
#
|
|
include(ColourMessage)
|
|
string(TOUPPER "${CMAKE_BUILD_TYPE}" _build_type)
|
|
message(STATUS "${Y}Configuration Options Summary${e} --
|
|
${c} Package Version: ${e}${PACKAGE_STRING}
|
|
${c} libclamav version: ${e}${LIBCLAMAV_CURRENT}:${LIBCLAMAV_REVISION}:${LIBCLAMAV_AGE}
|
|
${c} libfreshclam version: ${e}${LIBFRESHCLAM_CURRENT}:${LIBFRESHCLAM_REVISION}:${LIBFRESHCLAM_AGE}
|
|
${c} Install prefix: ${e}${CMAKE_INSTALL_PREFIX}
|
|
${c} Target system: ${e}${CMAKE_SYSTEM}
|
|
${c} Compiler: ${e}
|
|
${b} Build type: ${e}${CMAKE_BUILD_TYPE}
|
|
${b} C compiler: ${e}${CMAKE_C_COMPILER}
|
|
${b} CFLAGS: ${e}${CMAKE_C_FLAGS_${_build_type}} ${CMAKE_C_FLAGS}
|
|
${b} WARNCFLAGS: ${e}${WARNCFLAGS}
|
|
${c} Build Options: ${e}
|
|
${b} Build apps: ${e}${ENABLE_APP}
|
|
${b} Shared library: ${e}${ENABLE_SHARED_LIB}
|
|
${b} Static library: ${e}${ENABLE_STATIC_LIB}
|
|
${b} Enable UnRAR: ${e}${ENABLE_UNRAR}
|
|
${b} Examples: ${e}${ENABLE_EXAMPLES}
|
|
${b} Build man pages: ${e}${ENABLE_DOCS}
|
|
${b} Build doxygen HTML: ${e}${ENABLE_DOXYGEN}")
|
|
if(NOT WIN32)
|
|
message("\
|
|
${c} Build Extras: ${e}")
|
|
message("\
|
|
${b} Build milter: ${e}${ENABLE_MILTER} (toggle with -DENABLE_MILTER=ON/OFF)")
|
|
if(LINUX)
|
|
message("\
|
|
${b} Build clamonacc: ${e}${ENABLE_CLAMONACC} (toggle with -DENABLE_CLAMONACC=ON/OFF)")
|
|
endif()
|
|
endif()
|
|
|
|
if(LLVM_FOUND)
|
|
message(STATUS "${C}Engine Options${e} --
|
|
${b} Bytecode Runtime: ${e}
|
|
${_} ${BYTECODE_RUNTIME} ${e}${LLVM_INCLUDE_DIRS}
|
|
${_} ${e}${LLVM_LDFLAGS} ${LLVM_LIBRARIES}
|
|
${_} ${e}${LLVM_LIBRARY_DIRS}")
|
|
else()
|
|
message(STATUS "${C}Engine Options${e} --
|
|
${b} Bytecode Runtime: ${e}
|
|
${_} ${BYTECODE_RUNTIME} ${e}")
|
|
endif()
|
|
|
|
message(STATUS "${C}libclamav Dependencies${e} --
|
|
${b} Compression support:${e}
|
|
${_} bzip2 ${e}${BZIP2_INCLUDE_DIRS}
|
|
${_} ${e}${BZIP2_LIBRARIES}
|
|
${_} zlib ${e}${ZLIB_INCLUDE_DIRS}
|
|
${_} ${e}${ZLIB_LIBRARIES}
|
|
${b} XML support: ${e}
|
|
${_} libxml2 ${e}${LIBXML2_INCLUDE_DIRS}
|
|
${_} ${e}${LIBXML2_LIBRARIES}
|
|
${b} RegEx support: ${e}
|
|
${_} libpcre2 ${e}${PCRE2_INCLUDE_DIRS}
|
|
${_} ${e}${PCRE2_LIBRARIES}
|
|
${b} Crypto support: ${e}
|
|
${_} openssl ${e}${OPENSSL_INCLUDE_DIR}
|
|
${_} ${e}${OPENSSL_LIBRARIES}
|
|
${b} JSON support: ${e}
|
|
${_} json-c ${e}${JSONC_INCLUDE_DIRS}
|
|
${_} ${e}${JSONC_LIBRARIES}
|
|
${b} Threading support: ${e}")
|
|
if (WIN32)
|
|
message("\
|
|
${_} pthread-win32 ${e}${PThreadW32_INCLUDE_DIRS}
|
|
${_} ${e}${PThreadW32_LIBRARIES}")
|
|
elseif(Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
|
|
message("\
|
|
${_} pthread ${e}")
|
|
else()
|
|
message("\
|
|
${o} no ${e}")
|
|
endif()
|
|
|
|
message(STATUS "${C}libfreshclam Extra Dependencies${e} --
|
|
${b} HTTP support: ${e}
|
|
${_} curl ${e}${CURL_INCLUDE_DIRS}
|
|
${_} ${e}${CURL_LIBRARIES}")
|
|
|
|
if(HAVE_LIBNCURSES)
|
|
message(STATUS "${C}Application Extra Dependencies${e} --
|
|
${b} GUI support: ${e}
|
|
${_} ncurses ${e}${CURSES_INCLUDE_DIRS}
|
|
${_} ${e}${CURSES_LIBRARIES}")
|
|
elseif(HAVE_LIBPDCURSES)
|
|
message(STATUS "${C}Application Extra Dependencies${e} --
|
|
${b} GUI support: ${e}
|
|
${_} pdcurses ${e}${CURSES_INCLUDE_DIRS}
|
|
${_} ${e}${CURSES_LIBRARIES}")
|
|
endif()
|
|
|
|
if(LINUX)
|
|
if(SYSTEMD_PROGRAM_FOUND)
|
|
message("\
|
|
${b} systemd: ${e}
|
|
${_} unit directory ${e}${SYSTEMD_UNIT_DIR}
|
|
${b} systemd ctl support: ${e}")
|
|
if(SYSTEMD_FOUND)
|
|
message("\
|
|
${_} libsystemd ${e}${SYSTEMD_INCLUDE_DIRS}
|
|
${_} ${e}${SYSTEMD_LIBRARIES}")
|
|
else()
|
|
message("\
|
|
${_} libsystemd ${e}not found")
|
|
endif()
|
|
else()
|
|
message("\
|
|
${b} systemd: ${e}not found")
|
|
endif()
|
|
endif()
|
|
|
|
if(ENABLE_MILTER)
|
|
message("\
|
|
${b} Milter Support: ${e}
|
|
${_} libmilter ${e}${Milter_INCLUDE_DIRS}
|
|
${_} ${e}${Milter_LIBRARIES}")
|
|
endif()
|
|
message("")
|
|
|
|
if(NOT JSONC_USE_STATIC)
|
|
message(STATUS "${g}Warning:${e} libjson-c is known to share symbol names with other JSON libraries which may result in crashes for applications that use libclamav. Consider providing a static json-c library that was compiled with: CFLAGS=\"-fPIC\". Default build settings for json-c 0.15+ should also work. Use the `-DENABLE_JSON_SHARED=OFF` option to prefer detection of the static library, or use -DJSONC_INCLUDE_DIR and -DJSONC_LIBRARY to specify the static JSON library.")
|
|
endif()
|
|
|