1# 2CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR) 3if(POLICY CMP0074) 4 cmake_policy(SET CMP0074 NEW) #3.12.0 `find_package()`` uses ``<PackageName>_ROOT`` variables. 5endif() 6# 7PROJECT(libarchive C) 8# 9SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake") 10if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) 11 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${libarchive_BINARY_DIR}/bin) 12endif() 13# 14# Set the Build type for make based generators. 15# You can choose following types: 16# Debug : Debug build 17# Release : Release build 18# RelWithDebInfo : Release build with Debug Info 19# MinSizeRel : Release Min Size build 20IF(NOT CMAKE_BUILD_TYPE) 21 SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build Type" FORCE) 22ENDIF(NOT CMAKE_BUILD_TYPE) 23# Set a value type to properly display CMAKE_BUILD_TYPE on GUI if the 24# value type is "UNINITIALIZED". 25GET_PROPERTY(cached_type CACHE CMAKE_BUILD_TYPE PROPERTY TYPE) 26IF("${cached_type}" STREQUAL "UNINITIALIZED") 27 SET(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "Build Type" FORCE) 28ENDIF("${cached_type}" STREQUAL "UNINITIALIZED") 29# Check the Build Type. 30IF(NOT "${CMAKE_BUILD_TYPE}" 31 MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$") 32 MESSAGE(FATAL_ERROR 33 "Unknown keyword for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}\n" 34 "Acceptable keywords: Debug,Release,RelWithDebInfo,MinSizeRel") 35ENDIF(NOT "${CMAKE_BUILD_TYPE}" 36 MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$") 37 38# On MacOS, prefer MacPorts libraries to system libraries. 39# I haven't come up with a compelling argument for this to be conditional. 40list(APPEND CMAKE_PREFIX_PATH /opt/local) 41# Enable @rpath in the install name. 42# detail in "cmake --help-policy CMP0042" 43SET(CMAKE_MACOSX_RPATH ON) 44 45# 46# Version - read from 'version' file. 47# 48FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/build/version _version) 49STRING(REGEX REPLACE 50 "^([0-9])[0-9][0-9][0-9][0-9][0-9][0-9][a-z]*$" "\\1" _major ${_version}) 51STRING(REGEX REPLACE 52 "^[0-9]([0-9][0-9][0-9])[0-9][0-9][0-9][a-z]*$" "\\1" _minor ${_version}) 53STRING(REGEX REPLACE 54 "^[0-9][0-9][0-9][0-9]([0-9][0-9][0-9])[a-z]*$" "\\1" _revision ${_version}) 55STRING(REGEX REPLACE 56 "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9]([a-z]*)$" "\\1" _quality ${_version}) 57SET(_version_number ${_major}${_minor}${_revision}) 58STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_minor ${_minor}) 59STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_revision ${_revision}) 60# 61SET(VERSION "${_major}.${_trimmed_minor}.${_trimmed_revision}${_quality}") 62SET(BSDCPIO_VERSION_STRING "${VERSION}") 63SET(BSDTAR_VERSION_STRING "${VERSION}") 64SET(BSDCAT_VERSION_STRING "${VERSION}") 65SET(LIBARCHIVE_VERSION_NUMBER "${_version_number}") 66SET(LIBARCHIVE_VERSION_STRING "${VERSION}") 67 68# INTERFACE_VERSION increments with every release 69# libarchive 2.7 == interface version 9 = 2 + 7 70# libarchive 2.8 == interface version 10 = 2 + 8 71# libarchive 2.9 == interface version 11 = 2 + 9 72# libarchive 3.0 == interface version 12 73# libarchive 3.1 == interface version 13 74math(EXPR INTERFACE_VERSION "13 + ${_minor}") 75 76# Set SOVERSION == Interface version 77# ?? Should there be more here ?? 78SET(SOVERSION "${INTERFACE_VERSION}") 79 80# Enable CMAKE_PUSH_CHECK_STATE() and CMAKE_POP_CHECK_STATE() macros 81# saving and restoring the state of the variables. 82INCLUDE(CMakePushCheckState) 83 84# Initialize the state of the variables. This initialization is not 85# necessary but this shows you what value the variables initially have. 86SET(CMAKE_REQUIRED_DEFINITIONS) 87SET(CMAKE_REQUIRED_INCLUDES) 88SET(CMAKE_REQUIRED_LIBRARIES) 89SET(CMAKE_REQUIRED_FLAGS) 90if (CMAKE_BUILD_TYPE STREQUAL "Debug") 91 OPTION(ENABLE_WERROR "Treat warnings as errors - default is ON for Debug, OFF otherwise." ON) 92else () 93 OPTION(ENABLE_WERROR "Treat warnings as errors - default is ON for Debug, OFF otherwise." OFF) 94endif () 95 96# Especially for early development, we want to be a little 97# aggressive about diagnosing build problems; this can get 98# relaxed somewhat in final shipping versions. 99IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$") 100 SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security") 101 ################################################################# 102 # Set compile flags for all build types. 103 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security") 104 if (ENABLE_WERROR) 105 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") 106 endif () 107 ################################################################# 108 # Set compile flags for debug build. 109 # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug" 110 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra") 111 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused") 112 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow") 113 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes") 114 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual") 115ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$") 116IF (CMAKE_C_COMPILER_ID MATCHES "^Clang$") 117 SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security") 118 ################################################################# 119 # Set compile flags for all build types. 120 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security") 121 if (ENABLE_WERROR) 122 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") 123 endif () 124 ################################################################# 125 # Set compile flags for debug build. 126 # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug" 127 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g") 128 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra") 129 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused") 130 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow") 131 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes") 132 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual") 133ENDIF (CMAKE_C_COMPILER_ID MATCHES "^Clang$") 134IF (CMAKE_C_COMPILER_ID MATCHES "^XL$") 135 SET(CMAKE_C_COMPILER "xlc_r") 136 SET(CMAKE_REQUIRED_FLAGS "-qflag=e:e -qformat=sec") 137 ################################################################# 138 # Set compile flags for all build types. 139 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -qflag=e:e -qformat=sec") 140 if (ENABLE_WERROR) 141 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -qhalt=w") 142 endif () 143 ################################################################# 144 # Set compile flags for debug build. 145 # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug" 146 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g") 147 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qflag=w:w") 148 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qinfo=pro:use") 149ENDIF(CMAKE_C_COMPILER_ID MATCHES "^XL$") 150IF (MSVC) 151 if (ENABLE_WERROR) 152 # /WX option is the same as gcc's -Werror option. 153 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX") 154 endif () 155 ################################################################# 156 # Set compile flags for debug build. 157 # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug" 158 # Enable level 4 C4062: The enumerate has no associated handler in a switch 159 # statement and there is no default that can catch it. 160 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14062") 161 # Enable level 4 C4254: A larger bit field was assigned to a smaller bit 162 # field. 163 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14254") 164 # Enable level 4 C4295: An array was initialized but the last character in 165 # the array is not a null; accessing the array may 166 # produce unexpected results. 167 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14295") 168 # Enable level 4 C4296: An unsigned variable was used in a comparison 169 # operation with zero. 170 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14296") 171 # Enable level 4 C4389: An operation involved signed and unsigned variables. 172 # This could result in a loss of data. 173 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14389") 174 # Enable level 4 C4505: The given function is local and not referenced in 175 # the body of the module; therefore, the function is 176 # dead code. 177 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14505") 178 # Enable level 4 C4514: The optimizer removed an inline function that is not 179 # called. 180 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14514") 181 # Enable level 4 C4702: Unreachable code. 182 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14702") 183 # Enable level 4 C4706: The test value in a conditional expression was the 184 # result of an assignment. 185 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /w14706") 186 # /Oi option enables built-in functions. 187 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Oi") 188 ################################################################# 189 # Set compile flags for release build. 190 SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Oi") 191ENDIF (MSVC) 192 193# Enable CTest/CDash support 194include(CTest) 195 196OPTION(ENABLE_MBEDTLS "Enable use of mbed TLS" OFF) 197OPTION(ENABLE_NETTLE "Enable use of Nettle" OFF) 198OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON) 199OPTION(ENABLE_LIBB2 "Enable the use of the system LIBB2 library if found" ON) 200OPTION(ENABLE_LZ4 "Enable the use of the system LZ4 library if found" ON) 201OPTION(ENABLE_LZO "Enable the use of the system LZO library if found" OFF) 202OPTION(ENABLE_LZMA "Enable the use of the system LZMA library if found" ON) 203OPTION(ENABLE_ZSTD "Enable the use of the system zstd library if found" ON) 204 205OPTION(ENABLE_ZLIB "Enable the use of the system ZLIB library if found" ON) 206OPTION(ENABLE_BZip2 "Enable the use of the system BZip2 library if found" ON) 207OPTION(ENABLE_LIBXML2 "Enable the use of the system libxml2 library if found" ON) 208OPTION(ENABLE_EXPAT "Enable the use of the system EXPAT library if found" ON) 209OPTION(ENABLE_PCREPOSIX "Enable the use of the system PCREPOSIX library if found" ON) 210OPTION(ENABLE_LibGCC "Enable the use of the system LibGCC library if found" ON) 211# CNG is used for encrypt/decrypt Zip archives on Windows. 212OPTION(ENABLE_CNG "Enable the use of CNG(Crypto Next Generation)" ON) 213 214OPTION(ENABLE_TAR "Enable tar building" ON) 215OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" FALSE) 216OPTION(ENABLE_CPIO "Enable cpio building" ON) 217OPTION(ENABLE_CPIO_SHARED "Enable dynamic build of cpio" FALSE) 218OPTION(ENABLE_CAT "Enable cat building" ON) 219OPTION(ENABLE_CAT_SHARED "Enable dynamic build of cat" FALSE) 220OPTION(ENABLE_XATTR "Enable extended attribute support" ON) 221OPTION(ENABLE_ACL "Enable ACL support" ON) 222OPTION(ENABLE_ICONV "Enable iconv support" ON) 223OPTION(ENABLE_TEST "Enable unit and regression tests" ON) 224OPTION(ENABLE_COVERAGE "Enable code coverage (GCC only, automatically sets ENABLE_TEST to ON)" FALSE) 225OPTION(ENABLE_INSTALL "Enable installing of libraries" ON) 226 227SET(POSIX_REGEX_LIB "AUTO" CACHE STRING "Choose what library should provide POSIX regular expression support") 228SET(ENABLE_SAFESEH "AUTO" CACHE STRING "Enable use of /SAFESEH linker flag (MSVC only)") 229SET(WINDOWS_VERSION "WIN7" CACHE STRING "Set Windows version to use (Windows only)") 230 231IF(ENABLE_COVERAGE) 232 include(LibarchiveCodeCoverage) 233ENDIF(ENABLE_COVERAGE) 234 235IF(ENABLE_TEST) 236 ENABLE_TESTING() 237ENDIF(ENABLE_TEST) 238 239IF(WIN32) 240 IF(WINDOWS_VERSION STREQUAL "WIN8") 241 SET(NTDDI_VERSION 0x06020000) 242 SET(_WIN32_WINNT 0x0602) 243 SET(WINVER 0x0602) 244 ELSEIF(WINDOWS_VERSION STREQUAL "WIN7") 245 SET(NTDDI_VERSION 0x06010000) 246 SET(_WIN32_WINNT 0x0601) 247 SET(WINVER 0x0601) 248 ELSEIF(WINDOWS_VERSION STREQUAL "WS08") 249 SET(NTDDI_VERSION 0x06000100) 250 SET(_WIN32_WINNT 0x0600) 251 SET(WINVER 0x0600) 252 ELSEIF(WINDOWS_VERSION STREQUAL "VISTA") 253 SET(NTDDI_VERSION 0x06000000) 254 SET(_WIN32_WINNT 0x0600) 255 SET(WINVER 0x0600) 256 ELSEIF(WINDOWS_VERSION STREQUAL "WS03") 257 SET(NTDDI_VERSION 0x05020000) 258 SET(_WIN32_WINNT 0x0502) 259 SET(WINVER 0x0502) 260 ELSEIF(WINDOWS_VERSION STREQUAL "WINXP") 261 SET(NTDDI_VERSION 0x05010000) 262 SET(_WIN32_WINNT 0x0501) 263 SET(WINVER 0x0501) 264 ELSE(WINDOWS_VERSION STREQUAL "WIN8") 265 # Default to Windows Server 2003 API if we don't recognize the specifier 266 SET(NTDDI_VERSION 0x05020000) 267 SET(_WIN32_WINNT 0x0502) 268 SET(WINVER 0x0502) 269 ENDIF(WINDOWS_VERSION STREQUAL "WIN8") 270ENDIF(WIN32) 271 272IF(MSVC) 273 IF(ENABLE_SAFESEH STREQUAL "YES") 274 SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH") 275 SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH") 276 SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH") 277 SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH") 278 ELSEIF(ENABLE_SAFESEH STREQUAL "NO") 279 SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO") 280 SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO") 281 SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO") 282 SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH:NO") 283 ENDIF(ENABLE_SAFESEH STREQUAL "YES") 284ENDIF(MSVC) 285 286IF("${CMAKE_C_PLATFORM_ID}" MATCHES "^(HP-UX)$") 287 ADD_DEFINITIONS(-D_XOPEN_SOURCE=500) # Ask wchar.h for mbstate_t 288ENDIF() 289 290IF(MINGW) 291 ADD_DEFINITIONS(-D__USE_MINGW_ANSI_STDIO) 292ENDIF() 293 294# 295INCLUDE(CheckCSourceCompiles) 296INCLUDE(CheckCSourceRuns) 297INCLUDE(CheckFileOffsetBits) 298INCLUDE(CheckFuncs) 299INCLUDE(CheckHeaderDirent) 300INCLUDE(CheckIncludeFile) 301INCLUDE(CheckIncludeFiles) 302INCLUDE(CheckLibraryExists) 303INCLUDE(CheckStructHasMember) 304INCLUDE(CheckSymbolExists) 305INCLUDE(CheckTypeExists) 306INCLUDE(CheckTypeSize) 307 308# 309# Generate list.h 310# 311MACRO (GENERATE_LIST_H _listfile _cmlist __list_sources) 312 SET(_argv ${ARGV}) 313 # Remove _listfile and _cmlist from _argv 314 LIST(REMOVE_AT _argv 0 1) 315 IF (NOT EXISTS "${_listfile}" OR 316 ${_cmlist} IS_NEWER_THAN "${_listfile}") 317 318 MESSAGE(STATUS "Generating ${_listfile}") 319 FILE(WRITE ${_listfile} "") 320 FOREACH (testfile ${_argv}) 321 IF (testfile MATCHES "^test_[^/]+[.]c$") 322 FILE(STRINGS ${testfile} testvar REGEX "^DEFINE_TEST") 323 FOREACH (deftest ${testvar}) 324 FILE(APPEND ${_listfile} "${deftest}\n") 325 ENDFOREACH (deftest) 326 ENDIF (testfile MATCHES "^test_[^/]+[.]c$") 327 ENDFOREACH (testfile) 328 329 ENDIF (NOT EXISTS "${_listfile}" OR 330 ${_cmlist} IS_NEWER_THAN "${_listfile}") 331ENDMACRO (GENERATE_LIST_H) 332# 333# Generate installation rules for man pages. 334# 335MACRO (INSTALL_MAN __mans) 336 FOREACH (_man ${ARGV}) 337 STRING(REGEX REPLACE "^.+[.]([1-9])" "\\1" _mansect ${_man}) 338 INSTALL(FILES ${_man} DESTINATION "share/man/man${_mansect}") 339 ENDFOREACH (_man) 340ENDMACRO (INSTALL_MAN __mans) 341# 342# Find out what macro is needed to use libraries on Windows. 343# 344MACRO (TRY_MACRO_FOR_LIBRARY INCLUDES LIBRARIES 345 TRY_TYPE SAMPLE_SOURCE MACRO_LIST) 346 IF(WIN32 AND NOT CYGWIN) 347 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 348 SET(CMAKE_REQUIRED_INCLUDES ${INCLUDES}) 349 SET(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES}) 350 FOREACH(VAR ${MACRO_LIST}) 351 # Clear ${VAR} from CACHE If the libraries which ${VAR} was 352 # checked with are changed. 353 SET(VAR_WITH_LIB "${VAR}_WITH_LIB") 354 GET_PROPERTY(PREV_VAR_WITH_LIB VARIABLE PROPERTY ${VAR_WITH_LIB}) 355 IF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}") 356 UNSET(${VAR} CACHE) 357 ENDIF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}") 358 # Check if the library can be used with the macro. 359 IF("${TRY_TYPE}" MATCHES "COMPILES") 360 CHECK_C_SOURCE_COMPILES("${SAMPLE_SOURCE}" ${VAR}) 361 ELSEIF("${TRY_TYPE}" MATCHES "RUNS") 362 CHECK_C_SOURCE_RUNS("${SAMPLE_SOURCE}" ${VAR}) 363 ELSE("${TRY_TYPE}" MATCHES "COMPILES") 364 MESSAGE(FATAL_ERROR "UNKNOWN KEYWORD \"${TRY_TYPE}\" FOR TRY_TYPE") 365 ENDIF("${TRY_TYPE}" MATCHES "COMPILES") 366 # Save the libraries which ${VAR} is checked with. 367 SET(${VAR_WITH_LIB} "${LIBRARIES}" CACHE INTERNAL 368 "Macro ${VAR} is checked with") 369 ENDFOREACH(VAR) 370 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 371 ENDIF(WIN32 AND NOT CYGWIN) 372ENDMACRO (TRY_MACRO_FOR_LIBRARY) 373# 374# Check compress/decompress libraries 375# 376IF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN) 377 # GnuWin32 is only for Win32, not Win64. 378 SET(__GNUWIN32PATH "C:/Program Files/GnuWin32") 379ENDIF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN) 380IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}") 381 # You have to add a path available DLL file into PATH environment variable. 382 # Maybe DLL path is "C:/Program Files/GnuWin32/bin". 383 # The zlib and the bzip2 Setup program have installed programs and DLLs into 384 # "C:/Program Files/GnuWin32" by default. 385 # This is convenience setting for Windows. 386 SET(CMAKE_PREFIX_PATH ${__GNUWIN32PATH} $(CMAKE_PREFIX_PATH)) 387 # 388 # If you didn't use Setup program or installed into nonstandard path, 389 # cmake cannot find out your zlib or bzip2 libraries and include files, 390 # you should execute cmake with -DCMAKE_PREFIX_PATH option. 391 # e.g. 392 # cmake -DCMAKE_PREFIX_PATH=<your-GnuWin32-path> <path-to-source> 393 # 394 # If compiling error occurred in zconf.h, You may need patch to zconf.h. 395 #--- zconf.h.orig 2005-07-21 00:40:26.000000000 396 #+++ zconf.h 2009-01-19 11:39:10.093750000 397 #@@ -286,7 +286,7 @@ 398 # 399 # #if 1 /* HAVE_UNISTD_H -- this line is updated by ./configure */ 400 # # include <sys/types.h> /* for off_t */ 401 #-# include <unistd.h> /* for SEEK_* and off_t */ 402 #+# include <stdio.h> /* for SEEK_* and off_t */ 403 # # ifdef VMS 404 # # include <unixio.h> /* for off_t */ 405 # # endif 406ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}") 407 408SET(ADDITIONAL_LIBS "") 409# 410# Find ZLIB 411# 412IF(ENABLE_ZLIB) 413 FIND_PACKAGE(ZLIB) 414ELSE() 415 SET(ZLIB_FOUND FALSE) # Override cached value 416ENDIF() 417IF(ZLIB_FOUND) 418 SET(HAVE_LIBZ 1) 419 SET(HAVE_ZLIB_H 1) 420 INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) 421 LIST(APPEND ADDITIONAL_LIBS ${ZLIB_LIBRARIES}) 422 IF(WIN32 AND NOT CYGWIN) 423 # 424 # Test if ZLIB_WINAPI macro is needed to use. 425 # 426 TRY_MACRO_FOR_LIBRARY( 427 "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}" 428 RUNS 429 "#include <zlib.h>\nint main() {uLong f = zlibCompileFlags(); return (f&(1U<<10))?0:-1; }" 430 ZLIB_WINAPI) 431 IF(ZLIB_WINAPI) 432 ADD_DEFINITIONS(-DZLIB_WINAPI) 433 ELSE(ZLIB_WINAPI) 434 # Test if a macro is needed for the library. 435 TRY_MACRO_FOR_LIBRARY( 436 "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}" 437 COMPILES 438 "#include <zlib.h>\nint main() {return zlibVersion()?1:0; }" 439 "ZLIB_DLL;WITHOUT_ZLIB_DLL") 440 IF(ZLIB_DLL) 441 ADD_DEFINITIONS(-DZLIB_DLL) 442 ENDIF(ZLIB_DLL) 443 ENDIF(ZLIB_WINAPI) 444 ENDIF(WIN32 AND NOT CYGWIN) 445ENDIF(ZLIB_FOUND) 446MARK_AS_ADVANCED(CLEAR ZLIB_INCLUDE_DIR) 447MARK_AS_ADVANCED(CLEAR ZLIB_LIBRARY) 448# 449# Find BZip2 450# 451IF(ENABLE_BZip2) 452 FIND_PACKAGE(BZip2) 453ELSE() 454 SET(BZIP2_FOUND FALSE) # Override cached value 455ENDIF() 456IF(BZIP2_FOUND) 457 SET(HAVE_LIBBZ2 1) 458 SET(HAVE_BZLIB_H 1) 459 INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR}) 460 LIST(APPEND ADDITIONAL_LIBS ${BZIP2_LIBRARIES}) 461 # Test if a macro is needed for the library. 462 TRY_MACRO_FOR_LIBRARY( 463 "${BZIP2_INCLUDE_DIR}" "${BZIP2_LIBRARIES}" 464 COMPILES 465 "#include <bzlib.h>\nint main() {return BZ2_bzlibVersion()?1:0; }" 466 "USE_BZIP2_DLL;USE_BZIP2_STATIC") 467 IF(USE_BZIP2_DLL) 468 ADD_DEFINITIONS(-DUSE_BZIP2_DLL) 469 ELSEIF(USE_BZIP2_STATIC) 470 ADD_DEFINITIONS(-DUSE_BZIP2_STATIC) 471 ENDIF(USE_BZIP2_DLL) 472ENDIF(BZIP2_FOUND) 473MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR) 474MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARIES) 475 476 477# 478# Find LZMA 479# 480IF(ENABLE_LZMA) 481 FIND_PACKAGE(LibLZMA) 482ELSE() 483 SET(LIBLZMA_FOUND FALSE) # Override cached value 484ENDIF() 485 486IF(LIBLZMA_FOUND) 487 SET(HAVE_LIBLZMA 1) 488 SET(HAVE_LZMA_H 1) 489 CMAKE_PUSH_CHECK_STATE() 490 SET(CMAKE_REQUIRED_INCLUDES ${LIBLZMA_INCLUDE_DIR}) 491 SET(CMAKE_REQUIRED_LIBRARIES ${LIBLZMA_LIBRARIES}) 492 INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIRS}) 493 LIST(APPEND ADDITIONAL_LIBS ${LIBLZMA_LIBRARIES}) 494 # Test if a macro is needed for the library. 495 TRY_MACRO_FOR_LIBRARY( 496 "${LIBLZMA_INCLUDE_DIRS}" "${LIBLZMA_LIBRARIES}" 497 COMPILES 498 "#include <lzma.h>\nint main() {return (int)lzma_version_number(); }" 499 "WITHOUT_LZMA_API_STATIC;LZMA_API_STATIC") 500 IF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC) 501 ADD_DEFINITIONS(-DLZMA_API_STATIC) 502 ENDIF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC) 503 CMAKE_POP_CHECK_STATE() 504ELSE(LIBLZMA_FOUND) 505# LZMA not found and will not be used. 506ENDIF(LIBLZMA_FOUND) 507MARK_AS_ADVANCED(CLEAR LIBLZMA_INCLUDE_DIR) 508MARK_AS_ADVANCED(CLEAR LIBLZMA_LIBRARY) 509 510# 511# Find LZO2 512# 513IF(ENABLE_LZO) 514 IF (LZO2_INCLUDE_DIR) 515 # Already in cache, be silent 516 SET(LZO2_FIND_QUIETLY TRUE) 517 ENDIF (LZO2_INCLUDE_DIR) 518 519 FIND_PATH(LZO2_INCLUDE_DIR lzo/lzoconf.h) 520 FIND_LIBRARY(LZO2_LIBRARY NAMES lzo2 liblzo2) 521 INCLUDE(FindPackageHandleStandardArgs) 522 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZO2 DEFAULT_MSG LZO2_LIBRARY LZO2_INCLUDE_DIR) 523ELSE(ENABLE_LZO) 524 SET(LZO2_FOUND FALSE) # Override cached value 525ENDIF(ENABLE_LZO) 526IF(LZO2_FOUND) 527 SET(HAVE_LIBLZO2 1) 528 SET(HAVE_LZO_LZOCONF_H 1) 529 SET(HAVE_LZO_LZO1X_H 1) 530 INCLUDE_DIRECTORIES(${LZO2_INCLUDE_DIR}) 531 LIST(APPEND ADDITIONAL_LIBS ${LZO2_LIBRARY}) 532 # 533 # TODO: test for static library. 534 # 535ENDIF(LZO2_FOUND) 536MARK_AS_ADVANCED(CLEAR LZO2_INCLUDE_DIR) 537MARK_AS_ADVANCED(CLEAR LZO2_LIBRARY) 538# 539# Find libb2 540# 541IF(ENABLE_LIBB2) 542 IF (LIBB2_INCLUDE_DIR) 543 # Already in cache, be silent 544 SET(LIBB2_FIND_QUIETLY TRUE) 545 ENDIF (LIBB2_INCLUDE_DIR) 546 547 FIND_PATH(LIBB2_INCLUDE_DIR blake2.h) 548 FIND_LIBRARY(LIBB2_LIBRARY NAMES b2 libb2) 549 INCLUDE(FindPackageHandleStandardArgs) 550 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBB2 DEFAULT_MSG LIBB2_LIBRARY LIBB2_INCLUDE_DIR) 551ELSE(ENABLE_LIBB2) 552 SET(LIBB2_FOUND FALSE) # Override cached value 553ENDIF(ENABLE_LIBB2) 554IF(LIBB2_FOUND) 555 SET(HAVE_LIBB2 1) 556 SET(HAVE_BLAKE2_H 1) 557 SET(ARCHIVE_BLAKE2 FALSE) 558 LIST(APPEND ADDITIONAL_LIBS ${LIBB2_LIBRARY}) 559 CMAKE_PUSH_CHECK_STATE() 560 SET(CMAKE_REQUIRED_LIBRARIES ${LIBB2_LIBRARY}) 561 SET(CMAKE_REQUIRED_INCLUDES ${LIBB2_INCLUDE_DIR}) 562 CHECK_FUNCTION_EXISTS(blake2sp_init HAVE_LIBB2) 563 CMAKE_POP_CHECK_STATE() 564ELSE(LIBB2_FOUND) 565 SET(ARCHIVE_BLAKE2 TRUE) 566ENDIF(LIBB2_FOUND) 567# 568# Find LZ4 569# 570IF(ENABLE_LZ4) 571 IF (LZ4_INCLUDE_DIR) 572 # Already in cache, be silent 573 SET(LZ4_FIND_QUIETLY TRUE) 574 ENDIF (LZ4_INCLUDE_DIR) 575 576 FIND_PATH(LZ4_INCLUDE_DIR lz4.h) 577 FIND_LIBRARY(LZ4_LIBRARY NAMES lz4 liblz4) 578 INCLUDE(FindPackageHandleStandardArgs) 579 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZ4 DEFAULT_MSG LZ4_LIBRARY LZ4_INCLUDE_DIR) 580ELSE(ENABLE_LZ4) 581 SET(LZ4_FOUND FALSE) # Override cached value 582ENDIF(ENABLE_LZ4) 583IF(LZ4_FOUND) 584 SET(HAVE_LIBLZ4 1) 585 SET(HAVE_LZ4_H 1) 586 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 587 SET(CMAKE_REQUIRED_INCLUDES ${LZ4_INCLUDE_DIR}) 588 CHECK_INCLUDE_FILES("lz4hc.h" HAVE_LZ4HC_H) 589 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 590 INCLUDE_DIRECTORIES(${LZ4_INCLUDE_DIR}) 591 LIST(APPEND ADDITIONAL_LIBS ${LZ4_LIBRARY}) 592 # 593 # TODO: test for static library. 594 # 595ENDIF(LZ4_FOUND) 596MARK_AS_ADVANCED(CLEAR LZ4_INCLUDE_DIR) 597MARK_AS_ADVANCED(CLEAR LZ4_LIBRARY) 598# 599# Find Zstd 600# 601IF(ENABLE_ZSTD) 602 IF (ZSTD_INCLUDE_DIR) 603 # Already in cache, be silent 604 SET(ZSTD_FIND_QUIETLY TRUE) 605 ENDIF (ZSTD_INCLUDE_DIR) 606 607 FIND_PATH(ZSTD_INCLUDE_DIR zstd.h) 608 FIND_LIBRARY(ZSTD_LIBRARY NAMES zstd libzstd) 609 INCLUDE(FindPackageHandleStandardArgs) 610 FIND_PACKAGE_HANDLE_STANDARD_ARGS(ZSTD DEFAULT_MSG ZSTD_LIBRARY ZSTD_INCLUDE_DIR) 611ELSE(ENABLE_ZSTD) 612 SET(ZSTD_FOUND FALSE) # Override cached value 613ENDIF(ENABLE_ZSTD) 614IF(ZSTD_FOUND) 615 SET(HAVE_ZSTD_H 1) 616 INCLUDE_DIRECTORIES(${ZSTD_INCLUDE_DIR}) 617 LIST(APPEND ADDITIONAL_LIBS ${ZSTD_LIBRARY}) 618 CMAKE_PUSH_CHECK_STATE() 619 SET(CMAKE_REQUIRED_LIBRARIES ${ZSTD_LIBRARY}) 620 SET(CMAKE_REQUIRED_INCLUDES ${ZSTD_INCLUDE_DIR}) 621 CHECK_FUNCTION_EXISTS(ZSTD_compressStream HAVE_LIBZSTD) 622 # 623 # TODO: test for static library. 624 # 625 CMAKE_POP_CHECK_STATE() 626ENDIF(ZSTD_FOUND) 627MARK_AS_ADVANCED(CLEAR ZSTD_INCLUDE_DIR) 628MARK_AS_ADVANCED(CLEAR ZSTD_LIBRARY) 629 630 631# 632# Check headers 633# 634CHECK_HEADER_DIRENT() 635 636SET(INCLUDES "") 637MACRO (LA_CHECK_INCLUDE_FILE header var) 638 CHECK_INCLUDE_FILES("${INCLUDES};${header}" ${var}) 639 IF (${var}) 640 SET(INCLUDES ${INCLUDES} ${header}) 641 ENDIF (${var}) 642ENDMACRO (LA_CHECK_INCLUDE_FILE) 643 644# Some FreeBSD headers assume sys/types.h was already included. 645LA_CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H) 646 647# Alphabetize the rest unless there's a compelling reason 648LA_CHECK_INCLUDE_FILE("acl/libacl.h" HAVE_ACL_LIBACL_H) 649LA_CHECK_INCLUDE_FILE("attr/xattr.h" HAVE_ATTR_XATTR_H) 650LA_CHECK_INCLUDE_FILE("ctype.h" HAVE_CTYPE_H) 651LA_CHECK_INCLUDE_FILE("copyfile.h" HAVE_COPYFILE_H) 652LA_CHECK_INCLUDE_FILE("direct.h" HAVE_DIRECT_H) 653LA_CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H) 654LA_CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H) 655LA_CHECK_INCLUDE_FILE("ext2fs/ext2_fs.h" HAVE_EXT2FS_EXT2_FS_H) 656 657CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h> 658#include <ext2fs/ext2_fs.h> 659int main(void) { return EXT2_IOC_GETFLAGS; }" HAVE_WORKING_EXT2_IOC_GETFLAGS) 660 661LA_CHECK_INCLUDE_FILE("fcntl.h" HAVE_FCNTL_H) 662LA_CHECK_INCLUDE_FILE("grp.h" HAVE_GRP_H) 663LA_CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H) 664LA_CHECK_INCLUDE_FILE("io.h" HAVE_IO_H) 665LA_CHECK_INCLUDE_FILE("langinfo.h" HAVE_LANGINFO_H) 666LA_CHECK_INCLUDE_FILE("limits.h" HAVE_LIMITS_H) 667LA_CHECK_INCLUDE_FILE("linux/types.h" HAVE_LINUX_TYPES_H) 668LA_CHECK_INCLUDE_FILE("linux/fiemap.h" HAVE_LINUX_FIEMAP_H) 669LA_CHECK_INCLUDE_FILE("linux/fs.h" HAVE_LINUX_FS_H) 670 671CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h> 672#include <linux/fs.h> 673int main(void) { return FS_IOC_GETFLAGS; }" HAVE_WORKING_FS_IOC_GETFLAGS) 674 675LA_CHECK_INCLUDE_FILE("linux/magic.h" HAVE_LINUX_MAGIC_H) 676LA_CHECK_INCLUDE_FILE("locale.h" HAVE_LOCALE_H) 677LA_CHECK_INCLUDE_FILE("membership.h" HAVE_MEMBERSHIP_H) 678LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H) 679LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H) 680LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H) 681LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H) 682LA_CHECK_INCLUDE_FILE("pthread.h" HAVE_PTHREAD_H) 683LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H) 684LA_CHECK_INCLUDE_FILE("readpassphrase.h" HAVE_READPASSPHRASE_H) 685LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H) 686LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H) 687LA_CHECK_INCLUDE_FILE("spawn.h" HAVE_SPAWN_H) 688LA_CHECK_INCLUDE_FILE("stdarg.h" HAVE_STDARG_H) 689LA_CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H) 690LA_CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H) 691LA_CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H) 692LA_CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H) 693LA_CHECK_INCLUDE_FILE("sys/acl.h" HAVE_SYS_ACL_H) 694LA_CHECK_INCLUDE_FILE("sys/cdefs.h" HAVE_SYS_CDEFS_H) 695LA_CHECK_INCLUDE_FILE("sys/extattr.h" HAVE_SYS_EXTATTR_H) 696LA_CHECK_INCLUDE_FILE("sys/ioctl.h" HAVE_SYS_IOCTL_H) 697LA_CHECK_INCLUDE_FILE("sys/mkdev.h" HAVE_SYS_MKDEV_H) 698LA_CHECK_INCLUDE_FILE("sys/mount.h" HAVE_SYS_MOUNT_H) 699LA_CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H) 700LA_CHECK_INCLUDE_FILE("sys/poll.h" HAVE_SYS_POLL_H) 701LA_CHECK_INCLUDE_FILE("sys/richacl.h" HAVE_SYS_RICHACL_H) 702LA_CHECK_INCLUDE_FILE("sys/select.h" HAVE_SYS_SELECT_H) 703LA_CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H) 704LA_CHECK_INCLUDE_FILE("sys/statfs.h" HAVE_SYS_STATFS_H) 705LA_CHECK_INCLUDE_FILE("sys/statvfs.h" HAVE_SYS_STATVFS_H) 706LA_CHECK_INCLUDE_FILE("sys/sysmacros.h" HAVE_SYS_SYSMACROS_H) 707LA_CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H) 708LA_CHECK_INCLUDE_FILE("sys/utime.h" HAVE_SYS_UTIME_H) 709LA_CHECK_INCLUDE_FILE("sys/utsname.h" HAVE_SYS_UTSNAME_H) 710LA_CHECK_INCLUDE_FILE("sys/vfs.h" HAVE_SYS_VFS_H) 711LA_CHECK_INCLUDE_FILE("sys/wait.h" HAVE_SYS_WAIT_H) 712LA_CHECK_INCLUDE_FILE("sys/xattr.h" HAVE_SYS_XATTR_H) 713LA_CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H) 714LA_CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H) 715LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H) 716LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H) 717LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H) 718LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H) 719IF(ENABLE_CNG) 720 LA_CHECK_INCLUDE_FILE("Bcrypt.h" HAVE_BCRYPT_H) 721 IF(HAVE_BCRYPT_H) 722 LIST(APPEND ADDITIONAL_LIBS "Bcrypt") 723 ENDIF(HAVE_BCRYPT_H) 724ELSE(ENABLE_CNG) 725 UNSET(HAVE_BCRYPT_H CACHE) 726ENDIF(ENABLE_CNG) 727# Following files need windows.h, so we should test it after windows.h test. 728LA_CHECK_INCLUDE_FILE("wincrypt.h" HAVE_WINCRYPT_H) 729LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H) 730 731# 732# Check whether use of __EXTENSIONS__ is safe. 733# We need some macro such as _GNU_SOURCE to use extension functions. 734# 735SET(_INCLUDE_FILES) 736FOREACH (it ${_HEADER}) 737 SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") 738ENDFOREACH (it) 739 740CHECK_C_SOURCE_COMPILES( 741 "#define __EXTENSIONS__ 1 742 ${_INCLUDE_FILES} 743 int main() { return 0;}" 744 SAFE_TO_DEFINE_EXTENSIONS) 745 746# 747# Find mbed TLS 748# 749IF(ENABLE_MBEDTLS) 750 FIND_PACKAGE(MbedTLS) 751 IF(MBEDTLS_FOUND) 752 SET(HAVE_LIBMBEDCRYPTO 1) 753 LIST(APPEND ADDITIONAL_LIBS ${MBEDCRYPTO_LIBRARY}) 754 INCLUDE_DIRECTORIES(${MBEDTLS_INCLUDE_DIRS}) 755 756 LIST(APPEND CMAKE_REQUIRED_INCLUDES ${MBEDTLS_INCLUDE_DIRS}) 757 LA_CHECK_INCLUDE_FILE("mbedtls/aes.h" HAVE_MBEDTLS_AES_H) 758 LA_CHECK_INCLUDE_FILE("mbedtls/md.h" HAVE_MBEDTLS_MD_H) 759 LA_CHECK_INCLUDE_FILE("mbedtls/pkcs5.h" HAVE_MBEDTLS_PKCS5_H) 760 761 ENDIF(MBEDTLS_FOUND) 762 MARK_AS_ADVANCED(CLEAR MBEDTLS_INCLUDE_DIRS) 763 MARK_AS_ADVANCED(CLEAR MBEDCRYPTO_LIBRARY) 764ENDIF(ENABLE_MBEDTLS) 765 766# 767# Find Nettle 768# 769IF(ENABLE_NETTLE) 770 FIND_PACKAGE(Nettle) 771 IF(NETTLE_FOUND) 772 SET(HAVE_LIBNETTLE 1) 773 LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARIES}) 774 INCLUDE_DIRECTORIES(${NETTLE_INCLUDE_DIR}) 775 776 LIST(APPEND CMAKE_REQUIRED_INCLUDES ${NETTLE_INCLUDE_DIR}) 777 LA_CHECK_INCLUDE_FILE("nettle/aes.h" HAVE_NETTLE_AES_H) 778 LA_CHECK_INCLUDE_FILE("nettle/hmac.h" HAVE_NETTLE_HMAC_H) 779 LA_CHECK_INCLUDE_FILE("nettle/md5.h" HAVE_NETTLE_MD5_H) 780 LA_CHECK_INCLUDE_FILE("nettle/pbkdf2.h" HAVE_NETTLE_PBKDF2_H) 781 LA_CHECK_INCLUDE_FILE("nettle/ripemd160.h" HAVE_NETTLE_RIPEMD160_H) 782 LA_CHECK_INCLUDE_FILE("nettle/sha.h" HAVE_NETTLE_SHA_H) 783 784 ENDIF(NETTLE_FOUND) 785 MARK_AS_ADVANCED(CLEAR NETTLE_INCLUDE_DIR) 786 MARK_AS_ADVANCED(CLEAR NETTLE_LIBRARIES) 787ENDIF(ENABLE_NETTLE) 788 789# 790# Find OpenSSL 791# (Except on Mac, where OpenSSL is deprecated.) 792# 793IF(ENABLE_OPENSSL AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin") 794 FIND_PACKAGE(OpenSSL) 795 IF(OPENSSL_FOUND) 796 SET(HAVE_LIBCRYPTO 1) 797 INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR}) 798 LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_CRYPTO_LIBRARY}) 799 ENDIF(OPENSSL_FOUND) 800ELSE() 801 SET(OPENSSL_FOUND FALSE) # Override cached value 802ENDIF() 803 804# FreeBSD libmd 805IF(NOT OPENSSL_FOUND) 806 CHECK_LIBRARY_EXISTS(md "MD5Init" "" LIBMD_FOUND) 807 IF(LIBMD_FOUND) 808 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 809 SET(CMAKE_REQUIRED_LIBRARIES "md") 810 FIND_LIBRARY(LIBMD_LIBRARY NAMES md) 811 LIST(APPEND ADDITIONAL_LIBS ${LIBMD_LIBRARY}) 812 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 813 ENDIF(LIBMD_FOUND) 814ENDIF(NOT OPENSSL_FOUND) 815 816# 817# How to prove that CRYPTO functions, which have several names on various 818# platforms, just see if archive_digest.c can compile and link against 819# required libraries. 820# 821MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION) 822 FOREACH(ALGORITHM ${ALGORITHMS}) 823 IF(NOT ARCHIVE_CRYPTO_${ALGORITHM}) 824 STRING(TOLOWER "${ALGORITHM}" lower_algorithm) 825 STRING(TOUPPER "${ALGORITHM}" algorithm) 826 IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND) 827 SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE) 828 ELSEIF("${IMPLEMENTATION}" MATCHES "^MBEDTLS$" AND NOT MBEDTLS_FOUND) 829 SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE) 830 ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NOT NETTLE_FOUND) 831 SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE) 832 ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND) 833 834 IF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 835 # Probe the local implementation for whether this 836 # crypto implementation is available on this platform. 837 SET(TRY_CRYPTO_REQUIRED_INCLUDES 838 "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive;${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp") 839 SET(TRY_CRYPTO_REQUIRED_LIBS) 840 IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) 841 SET(TRY_CRYPTO_REQUIRED_INCLUDES 842 "${TRY_CRYPTO_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}") 843 SET(TRY_CRYPTO_REQUIRED_LIBS 844 "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}") 845 ELSEIF("${IMPLEMENTATION}" MATCHES "^MBEDTLS$" AND MBEDTLS_FOUND) 846 SET(TRY_CRYPTO_REQUIRED_INCLUDES 847 "${TRY_CRYPTO_REQUIRED_INCLUDES};${MBEDTLS_INCLUDE_DIRS}") 848 SET(TRY_CRYPTO_REQUIRED_LIBS 849 "-DLINK_LIBRARIES:STRING=${MBEDCRYPTO_LIBRARY}") 850 ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NETTLE_FOUND) 851 SET(TRY_CRYPTO_REQUIRED_INCLUDES 852 "${TRY_CRYPTO_REQUIRED_INCLUDES};${NETTLE_INCLUDE_DIR}") 853 SET(TRY_CRYPTO_REQUIRED_LIBS 854 "-DLINK_LIBRARIES:STRING=${NETTLE_LIBRARY}") 855 ELSEIF("${IMPLEMENTATION}" MATCHES "^LIBMD$" AND LIBMD_FOUND) 856 SET(TRY_CRYPTO_REQUIRED_LIBS 857 "-DLINK_LIBRARIES:STRING=${LIBMD_LIBRARY}") 858 ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) 859 860 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in 861 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h) 862 FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h" 863 CONFDEFS_H) 864 FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_digest.c" 865 ARCHIVE_CRYPTO_C) 866 867 SET(SOURCE "${CONFDEFS_H} 868 869#define ARCHIVE_${algorithm}_COMPILE_TEST 870#define ARCHIVE_CRYPTO_${algorithm}_${IMPLEMENTATION} 871#define PLATFORM_CONFIG_H \"check_crypto_md.h\" 872 873${ARCHIVE_CRYPTO_C} 874 875int 876main(int argc, char **argv) 877{ 878 archive_${lower_algorithm}_ctx ctx; 879 archive_${lower_algorithm}_init(&ctx); 880 archive_${lower_algorithm}_update(&ctx, *argv, argc); 881 archive_${lower_algorithm}_final(&ctx, NULL); 882 return 0; 883} 884") 885 886 FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.h" "") 887 FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c" "${SOURCE}") 888 MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}") 889 890 TRY_COMPILE(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} 891 ${CMAKE_BINARY_DIR} 892 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c 893 CMAKE_FLAGS 894 "${TRY_CRYPTO_REQUIRED_LIBS}" 895 "${TRY_CRYPTO_REQUIRED_INCLUDES}" 896 OUTPUT_VARIABLE OUTPUT) 897 898 # Inform user whether or not we found it; if not, log why we didn't. 899 IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 900 MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- found") 901 SET(ARCHIVE_CRYPTO_${ALGORITHM} 1) 902 ELSE (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 903 MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- not found") 904 FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 905 "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} failed with the following output:\n" 906 "${OUTPUT}\n" 907 "Source file was:\n${SOURCE}\n") 908 ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 909 ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 910 911 # Add appropriate libs/includes depending on whether the implementation 912 # was found on this platform. 913 IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 914 IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) 915 INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR}) 916 LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_LIBRARIES}) 917 LIST(REMOVE_DUPLICATES ADDITIONAL_LIBS) 918 ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) 919 ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}) 920 ENDIF(NOT ARCHIVE_CRYPTO_${ALGORITHM}) 921 ENDFOREACH(ALGORITHM ${ALGORITHMS}) 922ENDMACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION) 923 924# 925# CRYPTO functions on Windows is defined at archive_windows.c, thus we do not 926# need the test what the functions can be mapped to archive_{crypto name}_init, 927# archive_{crypto name}_update and archive_{crypto name}_final. 928# The functions on Windows use CALG_{crypto name} macro to create a crypt object 929# and then we need to know what CALG_{crypto name} macros is available to show 930# ARCHIVE_CRYPTO_{crypto name}_WIN macros because Windows 2000 and earlier version 931# of Windows XP do not support SHA256, SHA384 and SHA512. 932# 933MACRO(CHECK_CRYPTO_WIN CRYPTO_LIST) 934 IF(WIN32 AND NOT CYGWIN) 935 FOREACH(CRYPTO ${CRYPTO_LIST}) 936 IF(NOT ARCHIVE_CRYPTO_${CRYPTO}) 937 IF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN) 938 STRING(TOUPPER "${CRYPTO}" crypto) 939 SET(ALGID "") 940 IF ("${CRYPTO}" MATCHES "^MD5$") 941 SET(ALGID "CALG_MD5") 942 ENDIF ("${CRYPTO}" MATCHES "^MD5$") 943 IF ("${CRYPTO}" MATCHES "^SHA1$") 944 SET(ALGID "CALG_SHA1") 945 ENDIF ("${CRYPTO}" MATCHES "^SHA1$") 946 IF ("${CRYPTO}" MATCHES "^SHA256$") 947 SET(ALGID "CALG_SHA_256") 948 ENDIF ("${CRYPTO}" MATCHES "^SHA256$") 949 IF ("${CRYPTO}" MATCHES "^SHA384$") 950 SET(ALGID "CALG_SHA_384") 951 ENDIF ("${CRYPTO}" MATCHES "^SHA384$") 952 IF ("${CRYPTO}" MATCHES "^SHA512$") 953 SET(ALGID "CALG_SHA_512") 954 ENDIF ("${CRYPTO}" MATCHES "^SHA512$") 955 956 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in 957 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h) 958 FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h" 959 CONFDEFS_H) 960 961 SET(SOURCE "${CONFDEFS_H} 962 963#define ${crypto}_COMPILE_TEST 964#include <windows.h> 965#include <wincrypt.h> 966 967int 968main(int argc, char **argv) 969{ 970 return ${ALGID}; 971} 972") 973 SET(SOURCE_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_win.c") 974 975 FILE(WRITE "${SOURCE_FILE}" "${SOURCE}") 976 MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN") 977 978 TRY_COMPILE(ARCHIVE_CRYPTO_${CRYPTO}_WIN 979 ${CMAKE_BINARY_DIR} 980 ${SOURCE_FILE} 981 CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive" 982 OUTPUT_VARIABLE OUTPUT) 983 984 IF (ARCHIVE_CRYPTO_${CRYPTO}_WIN) 985 MESSAGE(STATUS 986 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- found") 987 SET(ARCHIVE_CRYPTO_${CRYPTO} 1) 988 ELSE (ARCHIVE_CRYPTO_${CRYPTO}_WIN) 989 MESSAGE(STATUS 990 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- not found") 991 FILE(APPEND 992 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 993 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN failed with the following output:\n" 994 "${OUTPUT}\n" 995 "Source file was:\n${SOURCE}\n") 996 ENDIF (ARCHIVE_CRYPTO_${CRYPTO}_WIN) 997 998 ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN) 999 ENDIF(NOT ARCHIVE_CRYPTO_${CRYPTO}) 1000 ENDFOREACH(CRYPTO) 1001 ENDIF(WIN32 AND NOT CYGWIN) 1002ENDMACRO(CHECK_CRYPTO_WIN CRYPTO_LIST) 1003 1004# 1005# Find iconv 1006# POSIX defines the second arg as const char ** 1007# and requires it to be in libc. But we can accept 1008# a non-const argument here and can support iconv() 1009# being in libiconv. 1010# 1011MACRO(CHECK_ICONV LIB TRY_ICONV_CONST) 1012 IF(NOT HAVE_ICONV) 1013 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1014 IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR 1015 CMAKE_C_COMPILER_ID MATCHES "^Clang$") 1016 # 1017 # During checking iconv proto type, we should use -Werror to avoid the 1018 # success of iconv detection with a warning which success is a miss 1019 # detection. So this needs for all build mode(even it's a release mode). 1020 # 1021 SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror") 1022 ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR 1023 CMAKE_C_COMPILER_ID MATCHES "^Clang$") 1024 IF (CMAKE_C_COMPILER_ID MATCHES "^XL$") 1025 SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -qhalt=w -qflag=w:w") 1026 ENDIF (CMAKE_C_COMPILER_ID MATCHES "^XL$") 1027 IF (MSVC) 1028 # NOTE: /WX option is the same as gcc's -Werror option. 1029 SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} /WX") 1030 ENDIF (MSVC) 1031 # 1032 CHECK_C_SOURCE_COMPILES( 1033 "#include <stdlib.h> 1034 #include <iconv.h> 1035 int main() { 1036 ${TRY_ICONV_CONST} char *ccp; 1037 iconv_t cd = iconv_open(\"\", \"\"); 1038 iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0); 1039 iconv_close(cd); 1040 return 0; 1041 }" 1042 HAVE_ICONV_${LIB}_${TRY_ICONV_CONST}) 1043 IF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST}) 1044 SET(HAVE_ICONV true) 1045 SET(ICONV_CONST ${TRY_ICONV_CONST}) 1046 ENDIF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST}) 1047 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1048 ENDIF(NOT HAVE_ICONV) 1049ENDMACRO(CHECK_ICONV TRY_ICONV_CONST) 1050 1051IF(ENABLE_ICONV) 1052 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1053 FIND_PATH(ICONV_INCLUDE_DIR iconv.h) 1054 IF(ICONV_INCLUDE_DIR) 1055 #SET(INCLUDES ${INCLUDES} "iconv.h") 1056 SET(HAVE_ICONV_H 1) 1057 INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR}) 1058 SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) 1059 CHECK_ICONV("libc" "const") 1060 CHECK_ICONV("libc" "") 1061 1062 # If iconv isn't in libc and we have a libiconv, try that. 1063 FIND_LIBRARY(LIBICONV_PATH NAMES iconv libiconv) 1064 IF(NOT HAVE_ICONV AND LIBICONV_PATH) 1065 LIST(APPEND CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH}) 1066 # Test if a macro is needed for the library. 1067 TRY_MACRO_FOR_LIBRARY( 1068 "${ICONV_INCLUDE_DIR}" "${LIBICONV_PATH}" 1069 COMPILES 1070 "#include <iconv.h>\nint main() {return iconv_close((iconv_t)0);}" 1071 "WITHOUT_LIBICONV_STATIC;LIBICONV_STATIC") 1072 IF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC) 1073 ADD_DEFINITIONS(-DLIBICONV_STATIC) 1074 ENDIF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC) 1075 # 1076 # Set up CMAKE_REQUIRED_* for CHECK_ICONV 1077 # 1078 SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) 1079 SET(CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH}) 1080 IF(LIBICONV_STATIC) 1081 # LIBICONV_STATIC is necessary for the success of CHECK_ICONV 1082 # on Windows. 1083 SET(CMAKE_REQUIRED_DEFINITIONS "-DLIBICONV_STATIC") 1084 ELSE(LIBICONV_STATIC) 1085 SET(CMAKE_REQUIRED_DEFINITIONS) 1086 ENDIF(LIBICONV_STATIC) 1087 CHECK_ICONV("libiconv" "const") 1088 CHECK_ICONV("libiconv" "") 1089 IF (HAVE_ICONV) 1090 LIST(APPEND ADDITIONAL_LIBS ${LIBICONV_PATH}) 1091 ENDIF(HAVE_ICONV) 1092 ENDIF(NOT HAVE_ICONV AND LIBICONV_PATH) 1093 ENDIF(ICONV_INCLUDE_DIR) 1094 # 1095 # Find locale_charset() for libiconv. 1096 # 1097 IF(LIBICONV_PATH) 1098 SET(CMAKE_REQUIRED_DEFINITIONS) 1099 SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) 1100 SET(CMAKE_REQUIRED_LIBRARIES) 1101 CHECK_INCLUDE_FILES("localcharset.h" HAVE_LOCALCHARSET_H) 1102 FIND_LIBRARY(LIBCHARSET_PATH NAMES charset libcharset) 1103 IF(LIBCHARSET_PATH) 1104 SET(CMAKE_REQUIRED_LIBRARIES ${LIBCHARSET_PATH}) 1105 IF(WIN32 AND NOT CYGWIN) 1106 # Test if a macro is needed for the library. 1107 TRY_MACRO_FOR_LIBRARY( 1108 "${ICONV_INCLUDE_DIR}" "${LIBCHARSET_PATH}" 1109 COMPILES 1110 "#include <localcharset.h>\nint main() {return locale_charset()?1:0;}" 1111 "WITHOUT_LIBCHARSET_STATIC;LIBCHARSET_STATIC") 1112 IF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC) 1113 ADD_DEFINITIONS(-DLIBCHARSET_STATIC) 1114 ENDIF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC) 1115 IF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC) 1116 SET(HAVE_LOCALE_CHARSET ON CACHE INTERNAL 1117 "Have function locale_charset") 1118 ENDIF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC) 1119 ELSE(WIN32 AND NOT CYGWIN) 1120 CHECK_FUNCTION_EXISTS_GLIBC(locale_charset HAVE_LOCALE_CHARSET) 1121 ENDIF(WIN32 AND NOT CYGWIN) 1122 IF(HAVE_LOCALE_CHARSET) 1123 LIST(APPEND ADDITIONAL_LIBS ${LIBCHARSET_PATH}) 1124 ENDIF(HAVE_LOCALE_CHARSET) 1125 ENDIF(LIBCHARSET_PATH) 1126 ENDIF(LIBICONV_PATH) 1127 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1128ELSE(ENABLE_ICONV) 1129 # Make sure ICONV variables are not in CACHE after ENABLE_ICONV disabled 1130 # (once enabled). 1131 UNSET(HAVE_LOCALE_CHARSET CACHE) 1132 UNSET(HAVE_ICONV CACHE) 1133 UNSET(HAVE_ICONV_libc_ CACHE) 1134 UNSET(HAVE_ICONV_libc_const CACHE) 1135 UNSET(HAVE_ICONV_libiconv_ CACHE) 1136 UNSET(HAVE_ICONV_libiconv_const CACHE) 1137 UNSET(ICONV_INCLUDE_DIR CACHE) 1138 UNSET(LIBICONV_PATH CACHE) 1139 UNSET(LIBICONV_DLL CACHE) 1140 UNSET(LIBICONV_STATIC CACHE) 1141 UNSET(LIBCHARSET_DLL CACHE) 1142 UNSET(LIBCHARSET_STATIC CACHE) 1143ENDIF(ENABLE_ICONV) 1144 1145# 1146# Find Libxml2 1147# 1148IF(ENABLE_LIBXML2) 1149 FIND_PACKAGE(LibXml2) 1150ELSE() 1151 SET(LIBXML2_FOUND FALSE) 1152ENDIF() 1153IF(LIBXML2_FOUND) 1154 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1155 INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR}) 1156 LIST(APPEND ADDITIONAL_LIBS ${LIBXML2_LIBRARIES}) 1157 SET(HAVE_LIBXML2 1) 1158 # libxml2's include files use iconv.h 1159 SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR}) 1160 CHECK_INCLUDE_FILES("libxml/xmlreader.h" HAVE_LIBXML_XMLREADER_H) 1161 CHECK_INCLUDE_FILES("libxml/xmlwriter.h" HAVE_LIBXML_XMLWRITER_H) 1162 # Test if a macro is needed for the library. 1163 TRY_MACRO_FOR_LIBRARY( 1164 "${ICONV_INCLUDE_DIR};${LIBXML2_INCLUDE_DIR}" 1165 "ws2_32.lib;${ZLIB_LIBRARIES};${LIBICONV_PATH};${LIBXML2_LIBRARIES}" 1166 COMPILES 1167 "#include <stddef.h>\n#include <libxml/xmlreader.h>\nint main() {return xmlTextReaderRead((xmlTextReaderPtr)(void *)0);}" 1168 "WITHOUT_LIBXML_STATIC;LIBXML_STATIC") 1169 IF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC) 1170 ADD_DEFINITIONS(-DLIBXML_STATIC) 1171 ENDIF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC) 1172 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1173ELSE(LIBXML2_FOUND) 1174 # 1175 # Find Expat 1176 # 1177 IF(ENABLE_EXPAT) 1178 FIND_PACKAGE(EXPAT) 1179 ELSE() 1180 SET(EXPAT_FOUND FALSE) 1181 ENDIF() 1182 IF(EXPAT_FOUND) 1183 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1184 INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR}) 1185 LIST(APPEND ADDITIONAL_LIBS ${EXPAT_LIBRARIES}) 1186 SET(HAVE_LIBEXPAT 1) 1187 LA_CHECK_INCLUDE_FILE("expat.h" HAVE_EXPAT_H) 1188 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1189 ENDIF(EXPAT_FOUND) 1190ENDIF(LIBXML2_FOUND) 1191MARK_AS_ADVANCED(CLEAR LIBXML2_INCLUDE_DIR) 1192MARK_AS_ADVANCED(CLEAR LIBXML2_LIBRARIES) 1193 1194# 1195# POSIX Regular Expression support 1196# 1197IF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$") 1198 # 1199 # If PCREPOSIX is not found or not requested, try using regex 1200 # from libc or libregex 1201 # 1202 FIND_PATH(REGEX_INCLUDE_DIR regex.h) 1203 IF(REGEX_INCLUDE_DIR) 1204 CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBC) 1205 # 1206 # If libc does not provide regex, find libregex. 1207 # 1208 IF(NOT HAVE_REGCOMP_LIBC) 1209 CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1210 FIND_LIBRARY(REGEX_LIBRARY regex) 1211 IF(REGEX_LIBRARY) 1212 SET(CMAKE_REQUIRED_LIBRARIES ${REGEX_LIBRARY}) 1213 CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBREGEX) 1214 IF(HAVE_REGCOMP_LIBREGEX) 1215 LIST(APPEND ADDITIONAL_LIBS ${REGEX_LIBRARY}) 1216 # 1217 # If regex.h is not found, retry looking for regex.h at 1218 # REGEX_INCLUDE_DIR 1219 # 1220 IF(NOT HAVE_REGEX_H) 1221 UNSET(HAVE_REGEX_H CACHE) 1222 INCLUDE_DIRECTORIES(${REGEX_INCLUDE_DIR}) 1223 SET(CMAKE_REQUIRED_INCLUDES ${REGEX_INCLUDE_DIR}) 1224 LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H) 1225 ENDIF(NOT HAVE_REGEX_H) 1226 # Test if a macro is needed for the library. 1227 TRY_MACRO_FOR_LIBRARY( 1228 "${REGEX_INCLUDE_DIR}" "${REGEX_LIBRARY}" 1229 COMPILES 1230 "#include <stddef.h>\n#include <regex.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}" 1231 "USE_REGEX_DLL;USE_REGEX_STATIC") 1232 IF(USE_REGEX_DLL) 1233 ADD_DEFINITIONS(-DUSE_REGEX_DLL) 1234 ELSEIF(USE_REGEX_STATIC) 1235 ADD_DEFINITIONS(-DUSE_REGEX_STATIC) 1236 ENDIF(USE_REGEX_DLL) 1237 ENDIF(HAVE_REGCOMP_LIBREGEX) 1238 ENDIF(REGEX_LIBRARY) 1239 CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1240 ENDIF(NOT HAVE_REGCOMP_LIBC) 1241 ENDIF(REGEX_INCLUDE_DIR) 1242 IF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX) 1243 SET(FOUND_POSIX_REGEX_LIB 1) 1244 ENDIF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX) 1245ENDIF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$") 1246 1247IF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$") 1248 # 1249 # If requested, try finding library for PCREPOSIX 1250 # 1251 IF(ENABLE_LibGCC) 1252 FIND_PACKAGE(LibGCC) 1253 ELSE() 1254 SET(LIBGCC_FOUND FALSE) # Override cached value 1255 ENDIF() 1256 IF(ENABLE_PCREPOSIX) 1257 FIND_PACKAGE(PCREPOSIX) 1258 ELSE() 1259 SET(PCREPOSIX_FOUND FALSE) # Override cached value 1260 ENDIF() 1261 IF(PCREPOSIX_FOUND) 1262 INCLUDE_DIRECTORIES(${PCRE_INCLUDE_DIR}) 1263 LIST(APPEND ADDITIONAL_LIBS ${PCREPOSIX_LIBRARIES}) 1264 # Test if a macro is needed for the library. 1265 TRY_MACRO_FOR_LIBRARY( 1266 "${PCRE_INCLUDE_DIR}" "${PCREPOSIX_LIBRARIES}" 1267 COMPILES 1268 "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}" 1269 "WITHOUT_PCRE_STATIC;PCRE_STATIC") 1270 IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1271 ADD_DEFINITIONS(-DPCRE_STATIC) 1272 ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND PCRE_FOUND) 1273 # Determine if pcre static libraries are to be used. 1274 LIST(APPEND ADDITIONAL_LIBS ${PCRE_LIBRARIES}) 1275 SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES}) 1276 MESSAGE(STATUS "trying again with -lpcre included") 1277 TRY_MACRO_FOR_LIBRARY( 1278 "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}" 1279 COMPILES 1280 "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}" 1281 "WITHOUT_PCRE_STATIC;PCRE_STATIC") 1282 IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1283 ADD_DEFINITIONS(-DPCRE_STATIC) 1284 ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND MSVC AND LIBGCC_FOUND) 1285 # When doing a Visual Studio build using pcre static libraries 1286 # built using the mingw toolchain, -lgcc is needed to resolve 1287 # ___chkstk_ms. 1288 MESSAGE(STATUS "Visual Studio build detected, trying again with -lgcc included") 1289 LIST(APPEND ADDITIONAL_LIBS ${LIBGCC_LIBRARIES}) 1290 SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES} ${LIBGCC_LIBRARIES}) 1291 TRY_MACRO_FOR_LIBRARY( 1292 "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}" 1293 COMPILES 1294 "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}" 1295 "WITHOUT_PCRE_STATIC;PCRE_STATIC") 1296 IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1297 ADD_DEFINITIONS(-DPCRE_STATIC) 1298 ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1299 ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1300 ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC) 1301 ENDIF(PCREPOSIX_FOUND) 1302 MARK_AS_ADVANCED(CLEAR PCRE_INCLUDE_DIR) 1303 MARK_AS_ADVANCED(CLEAR PCREPOSIX_LIBRARIES) 1304 MARK_AS_ADVANCED(CLEAR PCRE_LIBRARIES) 1305 MARK_AS_ADVANCED(CLEAR LIBGCC_LIBRARIES) 1306ENDIF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$") 1307 1308# 1309# Check functions 1310# 1311CMAKE_PUSH_CHECK_STATE() # Save the state of the variables 1312IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR 1313 CMAKE_C_COMPILER_ID MATCHES "^Clang$") 1314 # 1315 # During checking functions, we should use -fno-builtin to avoid the 1316 # failure of function detection which failure is an error "conflicting 1317 # types for built-in function" caused by using -Werror option. 1318 # 1319 SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-builtin") 1320ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR 1321 CMAKE_C_COMPILER_ID MATCHES "^Clang$") 1322CHECK_SYMBOL_EXISTS(_CrtSetReportMode "crtdbg.h" HAVE__CrtSetReportMode) 1323CHECK_FUNCTION_EXISTS_GLIBC(arc4random_buf HAVE_ARC4RANDOM_BUF) 1324CHECK_FUNCTION_EXISTS_GLIBC(chflags HAVE_CHFLAGS) 1325CHECK_FUNCTION_EXISTS_GLIBC(chown HAVE_CHOWN) 1326CHECK_FUNCTION_EXISTS_GLIBC(chroot HAVE_CHROOT) 1327CHECK_FUNCTION_EXISTS_GLIBC(ctime_r HAVE_CTIME_R) 1328CHECK_FUNCTION_EXISTS_GLIBC(fchdir HAVE_FCHDIR) 1329CHECK_FUNCTION_EXISTS_GLIBC(fchflags HAVE_FCHFLAGS) 1330CHECK_FUNCTION_EXISTS_GLIBC(fchmod HAVE_FCHMOD) 1331CHECK_FUNCTION_EXISTS_GLIBC(fchown HAVE_FCHOWN) 1332CHECK_FUNCTION_EXISTS_GLIBC(fcntl HAVE_FCNTL) 1333CHECK_FUNCTION_EXISTS_GLIBC(fdopendir HAVE_FDOPENDIR) 1334CHECK_FUNCTION_EXISTS_GLIBC(fork HAVE_FORK) 1335CHECK_FUNCTION_EXISTS_GLIBC(fstat HAVE_FSTAT) 1336CHECK_FUNCTION_EXISTS_GLIBC(fstatat HAVE_FSTATAT) 1337CHECK_FUNCTION_EXISTS_GLIBC(fstatfs HAVE_FSTATFS) 1338CHECK_FUNCTION_EXISTS_GLIBC(fstatvfs HAVE_FSTATVFS) 1339CHECK_FUNCTION_EXISTS_GLIBC(ftruncate HAVE_FTRUNCATE) 1340CHECK_FUNCTION_EXISTS_GLIBC(futimens HAVE_FUTIMENS) 1341CHECK_FUNCTION_EXISTS_GLIBC(futimes HAVE_FUTIMES) 1342CHECK_FUNCTION_EXISTS_GLIBC(futimesat HAVE_FUTIMESAT) 1343CHECK_FUNCTION_EXISTS_GLIBC(geteuid HAVE_GETEUID) 1344CHECK_FUNCTION_EXISTS_GLIBC(getgrgid_r HAVE_GETGRGID_R) 1345CHECK_FUNCTION_EXISTS_GLIBC(getgrnam_r HAVE_GETGRNAM_R) 1346CHECK_FUNCTION_EXISTS_GLIBC(getpwnam_r HAVE_GETPWNAM_R) 1347CHECK_FUNCTION_EXISTS_GLIBC(getpwuid_r HAVE_GETPWUID_R) 1348CHECK_FUNCTION_EXISTS_GLIBC(getpid HAVE_GETPID) 1349CHECK_FUNCTION_EXISTS_GLIBC(getvfsbyname HAVE_GETVFSBYNAME) 1350CHECK_FUNCTION_EXISTS_GLIBC(gmtime_r HAVE_GMTIME_R) 1351CHECK_FUNCTION_EXISTS_GLIBC(lchflags HAVE_LCHFLAGS) 1352CHECK_FUNCTION_EXISTS_GLIBC(lchmod HAVE_LCHMOD) 1353CHECK_FUNCTION_EXISTS_GLIBC(lchown HAVE_LCHOWN) 1354CHECK_FUNCTION_EXISTS_GLIBC(link HAVE_LINK) 1355CHECK_FUNCTION_EXISTS_GLIBC(linkat HAVE_LINKAT) 1356CHECK_FUNCTION_EXISTS_GLIBC(localtime_r HAVE_LOCALTIME_R) 1357CHECK_FUNCTION_EXISTS_GLIBC(lstat HAVE_LSTAT) 1358CHECK_FUNCTION_EXISTS_GLIBC(lutimes HAVE_LUTIMES) 1359CHECK_FUNCTION_EXISTS_GLIBC(mbrtowc HAVE_MBRTOWC) 1360CHECK_FUNCTION_EXISTS_GLIBC(memmove HAVE_MEMMOVE) 1361CHECK_FUNCTION_EXISTS_GLIBC(mkdir HAVE_MKDIR) 1362CHECK_FUNCTION_EXISTS_GLIBC(mkfifo HAVE_MKFIFO) 1363CHECK_FUNCTION_EXISTS_GLIBC(mknod HAVE_MKNOD) 1364CHECK_FUNCTION_EXISTS_GLIBC(mkstemp HAVE_MKSTEMP) 1365CHECK_FUNCTION_EXISTS_GLIBC(nl_langinfo HAVE_NL_LANGINFO) 1366CHECK_FUNCTION_EXISTS_GLIBC(openat HAVE_OPENAT) 1367CHECK_FUNCTION_EXISTS_GLIBC(pipe HAVE_PIPE) 1368CHECK_FUNCTION_EXISTS_GLIBC(poll HAVE_POLL) 1369CHECK_FUNCTION_EXISTS_GLIBC(posix_spawnp HAVE_POSIX_SPAWNP) 1370CHECK_FUNCTION_EXISTS_GLIBC(readlink HAVE_READLINK) 1371CHECK_FUNCTION_EXISTS_GLIBC(readpassphrase HAVE_READPASSPHRASE) 1372CHECK_FUNCTION_EXISTS_GLIBC(select HAVE_SELECT) 1373CHECK_FUNCTION_EXISTS_GLIBC(setenv HAVE_SETENV) 1374CHECK_FUNCTION_EXISTS_GLIBC(setlocale HAVE_SETLOCALE) 1375CHECK_FUNCTION_EXISTS_GLIBC(sigaction HAVE_SIGACTION) 1376CHECK_FUNCTION_EXISTS_GLIBC(statfs HAVE_STATFS) 1377CHECK_FUNCTION_EXISTS_GLIBC(statvfs HAVE_STATVFS) 1378CHECK_FUNCTION_EXISTS_GLIBC(strchr HAVE_STRCHR) 1379CHECK_FUNCTION_EXISTS_GLIBC(strdup HAVE_STRDUP) 1380CHECK_FUNCTION_EXISTS_GLIBC(strerror HAVE_STRERROR) 1381CHECK_FUNCTION_EXISTS_GLIBC(strncpy_s HAVE_STRNCPY_S) 1382CHECK_FUNCTION_EXISTS_GLIBC(strnlen HAVE_STRNLEN) 1383CHECK_FUNCTION_EXISTS_GLIBC(strrchr HAVE_STRRCHR) 1384CHECK_FUNCTION_EXISTS_GLIBC(symlink HAVE_SYMLINK) 1385CHECK_FUNCTION_EXISTS_GLIBC(timegm HAVE_TIMEGM) 1386CHECK_FUNCTION_EXISTS_GLIBC(tzset HAVE_TZSET) 1387CHECK_FUNCTION_EXISTS_GLIBC(unlinkat HAVE_UNLINKAT) 1388CHECK_FUNCTION_EXISTS_GLIBC(unsetenv HAVE_UNSETENV) 1389CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIME) 1390CHECK_FUNCTION_EXISTS_GLIBC(utimes HAVE_UTIMES) 1391CHECK_FUNCTION_EXISTS_GLIBC(utimensat HAVE_UTIMENSAT) 1392CHECK_FUNCTION_EXISTS_GLIBC(vfork HAVE_VFORK) 1393CHECK_FUNCTION_EXISTS_GLIBC(wcrtomb HAVE_WCRTOMB) 1394CHECK_FUNCTION_EXISTS_GLIBC(wcscmp HAVE_WCSCMP) 1395CHECK_FUNCTION_EXISTS_GLIBC(wcscpy HAVE_WCSCPY) 1396CHECK_FUNCTION_EXISTS_GLIBC(wcslen HAVE_WCSLEN) 1397CHECK_FUNCTION_EXISTS_GLIBC(wctomb HAVE_WCTOMB) 1398CHECK_FUNCTION_EXISTS_GLIBC(_ctime64_s HAVE__CTIME64_S) 1399CHECK_FUNCTION_EXISTS_GLIBC(_fseeki64 HAVE__FSEEKI64) 1400CHECK_FUNCTION_EXISTS_GLIBC(_get_timezone HAVE__GET_TIMEZONE) 1401CHECK_FUNCTION_EXISTS_GLIBC(_gmtime64_s HAVE__GMTIME64_S) 1402CHECK_FUNCTION_EXISTS_GLIBC(_localtime64_s HAVE__LOCALTIME64_S) 1403CHECK_FUNCTION_EXISTS_GLIBC(_mkgmtime64 HAVE__MKGMTIME64) 1404 1405SET(CMAKE_REQUIRED_LIBRARIES "") 1406CHECK_FUNCTION_EXISTS(cygwin_conv_path HAVE_CYGWIN_CONV_PATH) 1407CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO) 1408CHECK_FUNCTION_EXISTS(strerror_r HAVE_STRERROR_R) 1409CHECK_FUNCTION_EXISTS(strftime HAVE_STRFTIME) 1410CHECK_FUNCTION_EXISTS(vprintf HAVE_VPRINTF) 1411CHECK_FUNCTION_EXISTS(wmemcmp HAVE_WMEMCMP) 1412CHECK_FUNCTION_EXISTS(wmemcpy HAVE_WMEMCPY) 1413CHECK_FUNCTION_EXISTS(wmemmove HAVE_WMEMMOVE) 1414 1415CMAKE_POP_CHECK_STATE() # Restore the state of the variables 1416 1417CHECK_C_SOURCE_COMPILES( 1418 "#include <sys/types.h>\n#include <sys/mount.h>\nint main(void) { struct vfsconf v; return sizeof(v);}" 1419 HAVE_STRUCT_VFSCONF) 1420 1421CHECK_C_SOURCE_COMPILES( 1422 "#include <sys/types.h>\n#include <sys/mount.h>\nint main(void) { struct xvfsconf v; return sizeof(v);}" 1423 HAVE_STRUCT_XVFSCONF) 1424 1425CHECK_C_SOURCE_COMPILES( 1426 "#include <sys/types.h>\n#include <sys/mount.h>\nint main(void) { struct statfs s; return sizeof(s);}" 1427 HAVE_STRUCT_STATFS) 1428 1429# Make sure we have the POSIX version of readdir_r, not the 1430# older 2-argument version. 1431CHECK_C_SOURCE_COMPILES( 1432 "#include <dirent.h>\nint main() {DIR *d = opendir(\".\"); struct dirent e,*r; return readdir_r(d,&e,&r);}" 1433 HAVE_READDIR_R) 1434 1435# dirfd can be either a function or a macro. 1436CHECK_C_SOURCE_COMPILES( 1437 "#include <dirent.h>\nint main() {DIR *d = opendir(\".\"); return dirfd(d);}" 1438 HAVE_DIRFD) 1439 1440# Only detect readlinkat() if we also have AT_FDCWD in unistd.h. 1441# NOTE: linux requires fcntl.h for AT_FDCWD. 1442CHECK_C_SOURCE_COMPILES( 1443 "#include <fcntl.h>\n#include <unistd.h>\nint main() {char buf[10]; return readlinkat(AT_FDCWD, \"\", buf, 0);}" 1444 HAVE_READLINKAT) 1445 1446 1447# To verify major(), we need to both include the header 1448# of interest and verify that the result can be linked. 1449# CHECK_FUNCTION_EXISTS doesn't accept a header argument, 1450# CHECK_SYMBOL_EXISTS doesn't test linkage. 1451CHECK_C_SOURCE_COMPILES( 1452 "#include <sys/mkdev.h>\nint main() { return major(256); }" 1453 MAJOR_IN_MKDEV) 1454CHECK_C_SOURCE_COMPILES( 1455 "#include <sys/sysmacros.h>\nint main() { return major(256); }" 1456 MAJOR_IN_SYSMACROS) 1457 1458IF(ENABLE_LZMA) 1459CHECK_C_SOURCE_COMPILES( 1460 "#include <lzma.h>\n#if LZMA_VERSION < 50020000\n#error unsupported\n#endif\nint main(void){lzma_stream_encoder_mt(0, 0); return 0;}" 1461 HAVE_LZMA_STREAM_ENCODER_MT) 1462ELSE() 1463 SET(HAVE_LZMA_STREAM_ENCODER_MT 0) 1464ENDIF(ENABLE_LZMA) 1465 1466IF(HAVE_STRERROR_R) 1467 SET(HAVE_DECL_STRERROR_R 1) 1468ENDIF(HAVE_STRERROR_R) 1469 1470# 1471# Check defines 1472# 1473SET(headers "limits.h") 1474IF(HAVE_STDINT_H) 1475 LIST(APPEND headers "stdint.h") 1476ENDIF(HAVE_STDINT_H) 1477IF(HAVE_INTTYPES_H) 1478 LIST(APPEND headers "inttypes.h") 1479ENDIF(HAVE_INTTYPES_H) 1480CHECK_SYMBOL_EXISTS(EFTYPE "errno.h" HAVE_EFTYPE) 1481CHECK_SYMBOL_EXISTS(EILSEQ "errno.h" HAVE_EILSEQ) 1482CHECK_SYMBOL_EXISTS(D_MD_ORDER "langinfo.h" HAVE_D_MD_ORDER) 1483CHECK_SYMBOL_EXISTS(INT32_MAX "${headers}" HAVE_DECL_INT32_MAX) 1484CHECK_SYMBOL_EXISTS(INT32_MIN "${headers}" HAVE_DECL_INT32_MIN) 1485CHECK_SYMBOL_EXISTS(INT64_MAX "${headers}" HAVE_DECL_INT64_MAX) 1486CHECK_SYMBOL_EXISTS(INT64_MIN "${headers}" HAVE_DECL_INT64_MIN) 1487CHECK_SYMBOL_EXISTS(INTMAX_MAX "${headers}" HAVE_DECL_INTMAX_MAX) 1488CHECK_SYMBOL_EXISTS(INTMAX_MIN "${headers}" HAVE_DECL_INTMAX_MIN) 1489CHECK_SYMBOL_EXISTS(UINT32_MAX "${headers}" HAVE_DECL_UINT32_MAX) 1490CHECK_SYMBOL_EXISTS(UINT64_MAX "${headers}" HAVE_DECL_UINT64_MAX) 1491CHECK_SYMBOL_EXISTS(UINTMAX_MAX "${headers}" HAVE_DECL_UINTMAX_MAX) 1492CHECK_SYMBOL_EXISTS(SIZE_MAX "${headers}" HAVE_DECL_SIZE_MAX) 1493CHECK_SYMBOL_EXISTS(SSIZE_MAX "limits.h" HAVE_DECL_SSIZE_MAX) 1494 1495# 1496# Check struct members 1497# 1498# Check for tm_gmtoff in struct tm 1499CHECK_STRUCT_HAS_MEMBER("struct tm" tm_gmtoff 1500 "time.h" HAVE_STRUCT_TM_TM_GMTOFF) 1501CHECK_STRUCT_HAS_MEMBER("struct tm" __tm_gmtoff 1502 "time.h" HAVE_STRUCT_TM___TM_GMTOFF) 1503 1504IF(HAVE_STRUCT_STATFS) 1505# Check for f_namemax in struct statfs 1506CHECK_STRUCT_HAS_MEMBER("struct statfs" f_namemax 1507 "sys/param.h;sys/mount.h" HAVE_STRUCT_STATFS_F_NAMEMAX) 1508# Check for f_iosize in struct statfs 1509CHECK_STRUCT_HAS_MEMBER("struct statfs" f_iosize 1510 "sys/param.h;sys/mount.h" HAVE_STRUCT_STATFS_F_IOSIZE) 1511ENDIF(HAVE_STRUCT_STATFS) 1512 1513# Check for birthtime in struct stat 1514CHECK_STRUCT_HAS_MEMBER("struct stat" st_birthtime 1515 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIME) 1516 1517# Check for high-resolution timestamps in struct stat 1518CHECK_STRUCT_HAS_MEMBER("struct stat" st_birthtimespec.tv_nsec 1519 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC) 1520CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtimespec.tv_nsec 1521 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC) 1522CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtim.tv_nsec 1523 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC) 1524CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtime_n 1525 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_N) 1526CHECK_STRUCT_HAS_MEMBER("struct stat" st_umtime 1527 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_UMTIME) 1528CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtime_usec 1529 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_USEC) 1530# Check for block size support in struct stat 1531CHECK_STRUCT_HAS_MEMBER("struct stat" st_blksize 1532 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BLKSIZE) 1533# Check for st_flags in struct stat (BSD fflags) 1534CHECK_STRUCT_HAS_MEMBER("struct stat" st_flags 1535 "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_FLAGS) 1536 1537IF(HAVE_SYS_STATVFS_H) 1538 CHECK_STRUCT_HAS_MEMBER("struct statvfs" f_iosize 1539 "sys/types.h;sys/statvfs.h" HAVE_STRUCT_STATVFS_F_IOSIZE) 1540ENDIF() 1541 1542# 1543# 1544CHECK_STRUCT_HAS_MEMBER("struct tm" tm_sec 1545 "sys/types.h;sys/time.h;time.h" TIME_WITH_SYS_TIME) 1546 1547# 1548# Check for integer types 1549# 1550# 1551CHECK_TYPE_SIZE("short" SIZE_OF_SHORT) 1552CHECK_TYPE_SIZE("int" SIZE_OF_INT) 1553CHECK_TYPE_SIZE("long" SIZE_OF_LONG) 1554CHECK_TYPE_SIZE("long long" SIZE_OF_LONG_LONG) 1555 1556CHECK_TYPE_SIZE("unsigned short" SIZE_OF_UNSIGNED_SHORT) 1557CHECK_TYPE_SIZE("unsigned" SIZE_OF_UNSIGNED) 1558CHECK_TYPE_SIZE("unsigned long" SIZE_OF_UNSIGNED_LONG) 1559CHECK_TYPE_SIZE("unsigned long long" SIZE_OF_UNSIGNED_LONG_LONG) 1560 1561CHECK_TYPE_SIZE("__int64" __INT64) 1562CHECK_TYPE_SIZE("unsigned __int64" UNSIGNED___INT64) 1563 1564CHECK_TYPE_SIZE(int16_t INT16_T) 1565CHECK_TYPE_SIZE(int32_t INT32_T) 1566CHECK_TYPE_SIZE(int64_t INT64_T) 1567CHECK_TYPE_SIZE(intmax_t INTMAX_T) 1568CHECK_TYPE_SIZE(uint8_t UINT8_T) 1569CHECK_TYPE_SIZE(uint16_t UINT16_T) 1570CHECK_TYPE_SIZE(uint32_t UINT32_T) 1571CHECK_TYPE_SIZE(uint64_t UINT64_T) 1572CHECK_TYPE_SIZE(uintmax_t UINTMAX_T) 1573 1574CHECK_TYPE_SIZE(dev_t DEV_T) 1575IF(NOT HAVE_DEV_T) 1576 IF(MSVC) 1577 SET(dev_t "unsigned int") 1578 ENDIF(MSVC) 1579ENDIF(NOT HAVE_DEV_T) 1580# 1581CHECK_TYPE_SIZE(gid_t GID_T) 1582IF(NOT HAVE_GID_T) 1583 IF(WIN32) 1584 SET(gid_t "short") 1585 ELSE(WIN32) 1586 SET(gid_t "unsigned int") 1587 ENDIF(WIN32) 1588ENDIF(NOT HAVE_GID_T) 1589# 1590CHECK_TYPE_SIZE(id_t ID_T) 1591IF(NOT HAVE_ID_T) 1592 IF(WIN32) 1593 SET(id_t "short") 1594 ELSE(WIN32) 1595 SET(id_t "unsigned int") 1596 ENDIF(WIN32) 1597ENDIF(NOT HAVE_ID_T) 1598# 1599CHECK_TYPE_SIZE(mode_t MODE_T) 1600IF(NOT HAVE_MODE_T) 1601 IF(WIN32) 1602 SET(mode_t "unsigned short") 1603 ELSE(WIN32) 1604 SET(mode_t "int") 1605 ENDIF(WIN32) 1606ENDIF(NOT HAVE_MODE_T) 1607# 1608CHECK_TYPE_SIZE(off_t OFF_T) 1609IF(NOT HAVE_OFF_T) 1610 SET(off_t "__int64") 1611ENDIF(NOT HAVE_OFF_T) 1612# 1613CHECK_TYPE_SIZE(size_t SIZE_T) 1614IF(NOT HAVE_SIZE_T) 1615 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1616 SET(size_t "uint64_t") 1617 ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1618 SET(size_t "uint32_t") 1619 ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1620ENDIF(NOT HAVE_SIZE_T) 1621# 1622CHECK_TYPE_SIZE(ssize_t SSIZE_T) 1623IF(NOT HAVE_SSIZE_T) 1624 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1625 SET(ssize_t "int64_t") 1626 ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1627 SET(ssize_t "long") 1628 ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1629ENDIF(NOT HAVE_SSIZE_T) 1630# 1631CHECK_TYPE_SIZE(uid_t UID_T) 1632IF(NOT HAVE_UID_T) 1633 IF(WIN32) 1634 SET(uid_t "short") 1635 ELSE(WIN32) 1636 SET(uid_t "unsigned int") 1637 ENDIF(WIN32) 1638ENDIF(NOT HAVE_UID_T) 1639# 1640CHECK_TYPE_SIZE(pid_t PID_T) 1641IF(NOT HAVE_PID_T) 1642 IF(WIN32) 1643 SET(pid_t "int") 1644 ELSE(WIN32) 1645 MESSAGE(FATAL_ERROR "pid_t doesn't exist on this platform?") 1646 ENDIF(WIN32) 1647ENDIF(NOT HAVE_PID_T) 1648# 1649CHECK_TYPE_SIZE(intptr_t INTPTR_T) 1650IF(NOT HAVE_INTPTR_T) 1651 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1652 SET(intptr_t "int64_t") 1653 ELSE() 1654 SET(intptr_t "int32_t") 1655 ENDIF() 1656ENDIF(NOT HAVE_INTPTR_T) 1657# 1658CHECK_TYPE_SIZE(uintptr_t UINTPTR_T) 1659IF(NOT HAVE_UINTPTR_T) 1660 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) 1661 SET(uintptr_t "uint64_t") 1662 ELSE() 1663 SET(uintptr_t "uint32_t") 1664 ENDIF() 1665ENDIF(NOT HAVE_UINTPTR_T) 1666# 1667CHECK_TYPE_SIZE(wchar_t SIZEOF_WCHAR_T) 1668IF(HAVE_SIZEOF_WCHAR_T) 1669 SET(HAVE_WCHAR_T 1) 1670ENDIF(HAVE_SIZEOF_WCHAR_T) 1671# 1672# Check if _FILE_OFFSET_BITS macro needed for large files 1673# 1674CHECK_FILE_OFFSET_BITS() 1675 1676# 1677# Check for Extended Attribute libraries, headers, and functions 1678# 1679IF(ENABLE_XATTR) 1680 CHECK_LIBRARY_EXISTS(attr "setxattr" "" HAVE_LIBATTR) 1681 IF(HAVE_LIBATTR) 1682 SET(CMAKE_REQUIRED_LIBRARIES "attr") 1683 ELSE() 1684 CHECK_LIBRARY_EXISTS(gnu "setxattr" "" HAVE_LIBATTR_GNU) 1685 IF(HAVE_LIBATTR_GNU) 1686 SET(CMAKE_REQUIRED_LIBRARIES "gnu") 1687 ENDIF() 1688 ENDIF(HAVE_LIBATTR) 1689 CHECK_SYMBOL_EXISTS(EXTATTR_NAMESPACE_USER "sys/types.h;sys/extattr.h" HAVE_DECL_EXTATTR_NAMESPACE_USER) 1690 CHECK_SYMBOL_EXISTS(XATTR_NOFOLLOW "sys/xattr.h" HAVE_DECL_XATTR_NOFOLLOW) 1691 IF(HAVE_SYS_XATTR_H AND HAVE_DECL_XATTR_NOFOLLOW) 1692 CHECK_FUNCTION_EXISTS(fgetxattr HAVE_FGETXATTR) 1693 CHECK_FUNCTION_EXISTS(flistxattr HAVE_FLISTXATTR) 1694 CHECK_FUNCTION_EXISTS(fsetxattr HAVE_FSETXATTR) 1695 CHECK_FUNCTION_EXISTS(getxattr HAVE_GETXATTR) 1696 CHECK_FUNCTION_EXISTS(listxattr HAVE_LISTXATTR) 1697 CHECK_FUNCTION_EXISTS(setxattr HAVE_SETXATTR) 1698 IF(HAVE_FGETXATTR AND 1699 HAVE_FLISTXATTR AND 1700 HAVE_FSETXATTR AND 1701 HAVE_GETXATTR AND 1702 HAVE_LISTXATTR AND 1703 HAVE_SETXATTR) 1704 SET(ARCHIVE_XATTR_DARWIN TRUE) 1705 ENDIF() 1706 ELSEIF(HAVE_SYS_EXTATTR_H AND HAVE_DECL_EXTATTR_NAMESPACE_USER) 1707 # FreeBSD xattr support 1708 CHECK_FUNCTION_EXISTS(extattr_get_fd HAVE_EXTATTR_GET_FD) 1709 CHECK_FUNCTION_EXISTS(extattr_get_file HAVE_EXTATTR_GET_FILE) 1710 CHECK_FUNCTION_EXISTS(extattr_get_link HAVE_EXTATTR_GET_LINK) 1711 CHECK_FUNCTION_EXISTS(extattr_list_fd HAVE_EXTATTR_LIST_FD) 1712 CHECK_FUNCTION_EXISTS(extattr_list_file HAVE_EXTATTR_LIST_FILE) 1713 CHECK_FUNCTION_EXISTS(extattr_list_link HAVE_EXTATTR_LIST_LINK) 1714 CHECK_FUNCTION_EXISTS(extattr_set_fd HAVE_EXTATTR_SET_FD) 1715 CHECK_FUNCTION_EXISTS(extattr_set_link HAVE_EXTATTR_SET_LINK) 1716 IF(HAVE_EXTATTR_GET_FD AND 1717 HAVE_EXTATTR_GET_FILE AND 1718 HAVE_EXTATTR_GET_LINK AND 1719 HAVE_EXTATTR_LIST_FD AND 1720 HAVE_EXTATTR_LIST_FILE AND 1721 HAVE_EXTATTR_LIST_LINK AND 1722 HAVE_EXTATTR_SET_FD AND 1723 HAVE_EXTATTR_SET_LINK) 1724 SET(ARCHIVE_XATTR_FREEBSD TRUE) 1725 ENDIF() 1726 ELSEIF(HAVE_SYS_XATTR_H OR HAVE_ATTR_XATTR_H) 1727 # Linux xattr support 1728 CHECK_FUNCTION_EXISTS_GLIBC(fgetxattr HAVE_FGETXATTR) 1729 CHECK_FUNCTION_EXISTS_GLIBC(flistxattr HAVE_FLISTXATTR) 1730 CHECK_FUNCTION_EXISTS_GLIBC(fsetxattr HAVE_FSETXATTR) 1731 CHECK_FUNCTION_EXISTS_GLIBC(getxattr HAVE_GETXATTR) 1732 CHECK_FUNCTION_EXISTS_GLIBC(lgetxattr HAVE_LGETXATTR) 1733 CHECK_FUNCTION_EXISTS_GLIBC(listxattr HAVE_LISTXATTR) 1734 CHECK_FUNCTION_EXISTS_GLIBC(llistxattr HAVE_LLISTXATTR) 1735 CHECK_FUNCTION_EXISTS_GLIBC(lsetxattr HAVE_LSETXATTR) 1736 IF(HAVE_FGETXATTR AND 1737 HAVE_FLISTXATTR AND 1738 HAVE_FSETXATTR AND 1739 HAVE_GETXATTR AND 1740 HAVE_LGETXATTR AND 1741 HAVE_LISTXATTR AND 1742 HAVE_LLISTXATTR AND 1743 HAVE_LSETXATTR) 1744 SET(ARCHIVE_XATTR_LINUX TRUE) 1745 ENDIF() 1746 ELSEIF(HAVE_SYS_EA_H) 1747 # AIX xattr support 1748 CHECK_FUNCTION_EXISTS(fgetea HAVE_FGETEA) 1749 CHECK_FUNCTION_EXISTS(flistea HAVE_FLISTEA) 1750 CHECK_FUNCTION_EXISTS(fsetea HAVE_FSETEA) 1751 CHECK_FUNCTION_EXISTS(getea HAVE_GETEA) 1752 CHECK_FUNCTION_EXISTS(lgetea HAVE_LGETEA) 1753 CHECK_FUNCTION_EXISTS(listea HAVE_LISTEA) 1754 CHECK_FUNCTION_EXISTS(llistea HAVE_LLISTEA) 1755 CHECK_FUNCTION_EXISTS(lsetea HAVE_LSETEA) 1756 IF(HAVE_FGETEA AND 1757 HAVE_FLISTEA AND 1758 HAVE_FSETEA AND 1759 HAVE_GETEA AND 1760 HAVE_LGETEA AND 1761 HAVE_LISTEA AND 1762 HAVE_LLISTEA AND 1763 HAVE_LSETEA) 1764 SET(ARCHIVE_XATTR_AIX TRUE) 1765 ENDIF() 1766 ENDIF() 1767 1768 IF(ARCHIVE_XATTR_DARWIN) 1769 MESSAGE(STATUS "Extended attributes support: Darwin") 1770 ELSEIF(ARCHIVE_XATTR_FREEBSD) 1771 MESSAGE(STATUS "Extended attributes support: FreeBSD") 1772 ELSEIF(ARCHIVE_XATTR_LINUX) 1773 MESSAGE(STATUS "Extended attributes support: Linux") 1774 ELSEIF(ARCHIVE_XATTR_AIX) 1775 MESSAGE(STATUS "Extended attributes support: AIX") 1776 ELSE() 1777 MESSAGE(STATUS "Extended attributes support: none") 1778 ENDIF() 1779ELSE(ENABLE_XATTR) 1780 SET(ARCHIVE_XATTR_DARWIN FALSE) 1781 SET(ARCHIVE_XATTR_FREEBSD FALSE) 1782 SET(ARCHIVE_XATTR_LINUX FALSE) 1783 SET(ARCHIVE_XATTR_AIX FALSE) 1784ENDIF(ENABLE_XATTR) 1785 1786# 1787# Check for ACL libraries, headers, and functions 1788# 1789# The ACL support in libarchive is written against the POSIX1e draft, 1790# which was never officially approved and varies quite a bit across 1791# platforms. Worse, some systems have completely non-POSIX acl functions, 1792# which makes the following checks rather more complex than I would like. 1793# 1794IF(ENABLE_ACL) 1795 # Solaris and derivates ACLs 1796 CHECK_FUNCTION_EXISTS(acl HAVE_ACL) 1797 CHECK_FUNCTION_EXISTS(facl HAVE_FACL) 1798 1799 # Libacl 1800 CHECK_LIBRARY_EXISTS(acl "acl_get_file" "" HAVE_LIBACL) 1801 IF(HAVE_LIBACL) 1802 SET(CMAKE_REQUIRED_LIBRARIES "acl") 1803 FIND_LIBRARY(ACL_LIBRARY NAMES acl) 1804 LIST(APPEND ADDITIONAL_LIBS ${ACL_LIBRARY}) 1805 ENDIF(HAVE_LIBACL) 1806 1807 CHECK_TYPE_EXISTS(acl_t "sys/types.h;sys/acl.h" HAVE_ACL_T) 1808 CHECK_TYPE_EXISTS(acl_entry_t "sys/types.h;sys/acl.h" HAVE_ACL_ENTRY_T) 1809 CHECK_TYPE_EXISTS(acl_permset_t "sys/types.h;sys/acl.h" HAVE_ACL_PERMSET_T) 1810 CHECK_TYPE_EXISTS(acl_tag_t "sys/types.h;sys/acl.h" HAVE_ACL_TAG_T) 1811 1812 IF(HAVE_ACL AND HAVE_FACL) 1813 CHECK_TYPE_EXISTS(aclent_t "sys/acl.h" HAVE_ACLENT_T) 1814 IF(HAVE_ACLENT_T) 1815 CHECK_SYMBOL_EXISTS(GETACL "sys/acl.h" HAVE_DECL_GETACL) 1816 CHECK_SYMBOL_EXISTS(GETACLCNT "sys/acl.h" HAVE_DECL_GETACLCNT) 1817 CHECK_SYMBOL_EXISTS(SETACL "sys/acl.h" HAVE_DECL_SETACL) 1818 IF(HAVE_DECL_GETACL AND 1819 HAVE_DECL_GETACLCNT AND 1820 HAVE_DECL_SETACL) 1821 SET(ARCHIVE_ACL_SUNOS TRUE) 1822 ENDIF() 1823 CHECK_TYPE_EXISTS(ace_t "sys/acl.h" HAVE_ACE_T) 1824 IF(HAVE_ACE_T) 1825 CHECK_SYMBOL_EXISTS(ACE_GETACL "sys/acl.h" HAVE_DECL_ACE_GETACL) 1826 CHECK_SYMBOL_EXISTS(ACE_GETACLCNT "sys/acl.h" HAVE_DECL_ACE_GETACLCNT) 1827 CHECK_SYMBOL_EXISTS(ACE_SETACL "sys/acl.h" HAVE_DECL_ACE_SETACL) 1828 IF(HAVE_DECL_ACE_GETACL AND 1829 HAVE_DECL_ACE_GETACLCNT AND 1830 HAVE_DECL_ACE_SETACL) 1831 SET(ARCHIVE_ACL_SUNOS_NFS4 TRUE) 1832 ENDIF() 1833 ENDIF(HAVE_ACE_T) 1834 ENDIF(HAVE_ACLENT_T) 1835 ENDIF(HAVE_ACL AND HAVE_FACL) 1836 1837 IF(HAVE_ACL_T AND HAVE_ACL_ENTRY_T AND HAVE_ACL_PERMSET_T AND HAVE_ACL_TAG_T) 1838 CHECK_FUNCTION_EXISTS_GLIBC(acl_add_perm HAVE_ACL_ADD_PERM) 1839 CHECK_FUNCTION_EXISTS_GLIBC(acl_clear_perms HAVE_ACL_CLEAR_PERMS) 1840 CHECK_FUNCTION_EXISTS_GLIBC(acl_create_entry HAVE_ACL_CREATE_ENTRY) 1841 CHECK_FUNCTION_EXISTS_GLIBC(acl_delete_def_file HAVE_ACL_DELETE_DEF_FILE) 1842 CHECK_FUNCTION_EXISTS_GLIBC(acl_free HAVE_ACL_FREE) 1843 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_entry HAVE_ACL_GET_ENTRY) 1844 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_fd HAVE_ACL_GET_FD) 1845 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_file HAVE_ACL_GET_FILE) 1846 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_permset HAVE_ACL_GET_PERMSET) 1847 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_qualifier HAVE_ACL_GET_QUALIFIER) 1848 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_tag_type HAVE_ACL_GET_TAG_TYPE) 1849 CHECK_FUNCTION_EXISTS_GLIBC(acl_init HAVE_ACL_INIT) 1850 CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd HAVE_ACL_SET_FD) 1851 CHECK_FUNCTION_EXISTS_GLIBC(acl_set_file HAVE_ACL_SET_FILE) 1852 CHECK_FUNCTION_EXISTS_GLIBC(acl_set_qualifier HAVE_ACL_SET_QUALIFIER) 1853 CHECK_FUNCTION_EXISTS_GLIBC(acl_set_tag_type HAVE_ACL_SET_TAG_TYPE) 1854 IF(HAVE_ACL_ADD_PERM AND 1855 HAVE_ACL_CLEAR_PERMS AND 1856 HAVE_ACL_CREATE_ENTRY AND 1857 HAVE_ACL_DELETE_DEF_FILE AND 1858 HAVE_ACL_FREE AND 1859 HAVE_ACL_GET_ENTRY AND 1860 HAVE_ACL_GET_FD AND 1861 HAVE_ACL_GET_FILE AND 1862 HAVE_ACL_GET_PERMSET AND 1863 HAVE_ACL_GET_QUALIFIER AND 1864 HAVE_ACL_GET_TAG_TYPE AND 1865 HAVE_ACL_INIT AND 1866 HAVE_ACL_SET_FD AND 1867 HAVE_ACL_SET_FILE AND 1868 HAVE_ACL_SET_QUALIFIER AND 1869 HAVE_ACL_SET_TAG_TYPE) 1870 SET(HAVE_POSIX_ACL_FUNCS 1) 1871 ENDIF() 1872 1873 CHECK_FUNCTION_EXISTS_GLIBC(acl_get_perm HAVE_ACL_GET_PERM) 1874 1875 IF(HAVE_POSIX_ACL_FUNCS AND HAVE_ACL_LIBACL_H AND HAVE_LIBACL AND 1876 HAVE_ACL_GET_PERM) 1877 SET(ARCHIVE_ACL_LIBACL TRUE) 1878 ELSE() 1879 CHECK_FUNCTION_EXISTS(acl_add_flag_np HAVE_ACL_ADD_FLAG_NP) 1880 CHECK_FUNCTION_EXISTS(acl_clear_flags_np HAVE_ACL_CLEAR_FLAGS_NP) 1881 CHECK_FUNCTION_EXISTS(acl_get_brand_np HAVE_ACL_GET_BRAND_NP) 1882 CHECK_FUNCTION_EXISTS(acl_get_entry_type_np HAVE_ACL_GET_ENTRY_TYPE_NP) 1883 CHECK_FUNCTION_EXISTS(acl_get_flag_np HAVE_ACL_GET_FLAG_NP) 1884 CHECK_FUNCTION_EXISTS(acl_get_flagset_np HAVE_ACL_GET_FLAGSET_NP) 1885 CHECK_FUNCTION_EXISTS(acl_get_fd_np HAVE_ACL_GET_FD_NP) 1886 CHECK_FUNCTION_EXISTS(acl_get_link_np HAVE_ACL_GET_LINK_NP) 1887 CHECK_FUNCTION_EXISTS(acl_get_perm_np HAVE_ACL_GET_PERM_NP) 1888 CHECK_FUNCTION_EXISTS(acl_is_trivial_np HAVE_ACL_IS_TRIVIAL_NP) 1889 CHECK_FUNCTION_EXISTS(acl_set_entry_type_np HAVE_ACL_SET_ENTRY_TYPE_NP) 1890 CHECK_FUNCTION_EXISTS(acl_set_fd_np HAVE_ACL_SET_FD_NP) 1891 CHECK_FUNCTION_EXISTS(acl_set_link_np HAVE_ACL_SET_LINK_NP) 1892 CHECK_FUNCTION_EXISTS(mbr_gid_to_uuid HAVE_MBR_GID_TO_UUID) 1893 CHECK_FUNCTION_EXISTS(mbr_uid_to_uuid HAVE_MBR_UID_TO_UUID) 1894 CHECK_FUNCTION_EXISTS(mbr_uuid_to_id HAVE_MBR_UUID_TO_ID) 1895 1896 CHECK_C_SOURCE_COMPILES("#include <sys/types.h> 1897#include <sys/acl.h> 1898int main(void) { return ACL_TYPE_EXTENDED; }" HAVE_DECL_ACL_TYPE_EXTENDED) 1899 CHECK_C_SOURCE_COMPILES("#include <sys/types.h> 1900#include <sys/acl.h> 1901int main(void) { return ACL_SYNCHRONIZE; }" HAVE_DECL_ACL_SYNCHRONIZE) 1902 CHECK_SYMBOL_EXISTS(ACL_TYPE_NFS4 "sys/acl.h" HAVE_DECL_ACL_TYPE_NFS4) 1903 CHECK_SYMBOL_EXISTS(ACL_USER "sys/acl.h" HAVE_DECL_ACL_USER) 1904 1905 IF(HAVE_POSIX_ACL_FUNCS AND 1906 HAVE_ACL_GET_FD_NP AND 1907 HAVE_ACL_GET_PERM_NP AND 1908 NOT HAVE_ACL_GET_PERM AND 1909 HAVE_ACL_SET_FD_NP) 1910 IF(HAVE_DECL_ACL_USER) 1911 SET(ARCHIVE_ACL_FREEBSD TRUE) 1912 IF(HAVE_DECL_ACL_TYPE_NFS4 AND 1913 HAVE_ACL_ADD_FLAG_NP AND 1914 HAVE_ACL_CLEAR_FLAGS_NP AND 1915 HAVE_ACL_GET_BRAND_NP AND 1916 HAVE_ACL_GET_ENTRY_TYPE_NP AND 1917 HAVE_ACL_GET_FLAGSET_NP AND 1918 HAVE_ACL_SET_ENTRY_TYPE_NP) 1919 SET(ARCHIVE_ACL_FREEBSD_NFS4 TRUE) 1920 ENDIF() 1921 ELSEIF(HAVE_DECL_ACL_TYPE_EXTENDED AND 1922 HAVE_MEMBERSHIP_H AND 1923 HAVE_ACL_ADD_FLAG_NP AND 1924 HAVE_ACL_CLEAR_FLAGS_NP AND 1925 HAVE_ACL_GET_FLAGSET_NP AND 1926 HAVE_ACL_GET_LINK_NP AND 1927 HAVE_ACL_SET_LINK_NP AND 1928 HAVE_MBR_UID_TO_UUID AND 1929 HAVE_MBR_GID_TO_UUID AND 1930 HAVE_MBR_UUID_TO_ID) 1931 SET(ARCHIVE_ACL_DARWIN TRUE) 1932 ENDIF() 1933 ENDIF() 1934 ENDIF() 1935 ENDIF(HAVE_ACL_T AND HAVE_ACL_ENTRY_T AND HAVE_ACL_PERMSET_T AND 1936 HAVE_ACL_TAG_T) 1937 1938 # Richacl 1939 CHECK_LIBRARY_EXISTS(richacl "richacl_get_file" "" HAVE_LIBRICHACL) 1940 IF(HAVE_LIBRICHACL) 1941 SET(CMAKE_REQUIRED_LIBRARIES "richacl") 1942 FIND_LIBRARY(RICHACL_LIBRARY NAMES richacl) 1943 LIST(APPEND ADDITIONAL_LIBS ${RICHACL_LIBRARY}) 1944 ENDIF(HAVE_LIBRICHACL) 1945 1946 CHECK_STRUCT_HAS_MEMBER("struct richace" e_type "sys/richacl.h" 1947 HAVE_STRUCT_RICHACE) 1948 CHECK_STRUCT_HAS_MEMBER("struct richacl" a_flags "sys/richacl.h" 1949 HAVE_STRUCT_RICHACL) 1950 1951 IF(HAVE_LIBRICHACL AND HAVE_STRUCT_RICHACL AND HAVE_STRUCT_RICHACE) 1952 CHECK_FUNCTION_EXISTS_GLIBC(richacl_alloc HAVE_RICHACL_ALLOC) 1953 CHECK_FUNCTION_EXISTS_GLIBC(richacl_equiv_mode HAVE_RICHACL_EQUIV_MODE) 1954 CHECK_FUNCTION_EXISTS_GLIBC(richacl_free HAVE_RICHACL_FREE) 1955 CHECK_FUNCTION_EXISTS_GLIBC(richacl_get_fd HAVE_RICHACL_GET_FD) 1956 CHECK_FUNCTION_EXISTS_GLIBC(richacl_get_file HAVE_RICHACL_GET_FILE) 1957 CHECK_FUNCTION_EXISTS_GLIBC(richacl_set_fd HAVE_RICHACL_SET_FD) 1958 CHECK_FUNCTION_EXISTS_GLIBC(richacl_set_file HAVE_RICHACL_SET_FILE) 1959 IF(HAVE_RICHACL_ALLOC AND 1960 HAVE_RICHACL_EQUIV_MODE AND 1961 HAVE_RICHACL_FREE AND 1962 HAVE_RICHACL_GET_FD AND 1963 HAVE_RICHACL_GET_FILE AND 1964 HAVE_RICHACL_SET_FD AND 1965 HAVE_RICHACL_SET_FILE) 1966 SET(ARCHIVE_ACL_LIBRICHACL TRUE) 1967 ENDIF() 1968 ENDIF(HAVE_LIBRICHACL AND HAVE_STRUCT_RICHACL AND HAVE_STRUCT_RICHACE) 1969 1970 IF(ARCHIVE_ACL_DARWIN) 1971 MESSAGE(STATUS "ACL support: Darwin (limited NFSv4)") 1972 ELSEIF(ARCHIVE_ACL_FREEBSD_NFS4) 1973 MESSAGE(STATUS "ACL support: FreeBSD (POSIX.1e and NFSv4)") 1974 ELSEIF(ARCHIVE_ACL_FREEBSD) 1975 MESSAGE(STATUS "ACL support: FreeBSD (POSIX.1e)") 1976 ELSEIF(ARCHIVE_ACL_LIBACL OR ARCHIVE_ACL_LIBRICHACL) 1977 IF(ARCHIVE_ACL_LIBACL AND ARCHIVE_ACL_LIBRICHACL) 1978 MESSAGE(STATUS "ACL support: libacl (POSIX.1e) + librichacl (NFSv4)") 1979 ELSEIF(ARCHIVE_ACL_LIBRICHACL) 1980 MESSAGE(STATUS "ACL support: librichacl (NFSv4)") 1981 ELSE() 1982 MESSAGE(STATUS "ACL support: libacl (POSIX.1e)") 1983 ENDIF() 1984 ELSEIF(ARCHIVE_ACL_SUNOS_NFS4) 1985 MESSAGE(STATUS "ACL support: Solaris (POSIX.1e and NFSv4)") 1986 ELSEIF(ARCHIVE_ACL_SUNOS) 1987 MESSAGE(STATUS "ACL support: Solaris (POSIX.1e)") 1988 ELSE() 1989 MESSAGE(STATUS "ACL support: none") 1990 ENDIF() 1991 1992ELSE(ENABLE_ACL) 1993 # If someone runs cmake, then disables ACL support, we need 1994 # to forcibly override the cached values for these. 1995 SET(ARCHIVE_ACL_DARWIN FALSE) 1996 SET(ARCHIVE_ACL_FREEBSD FALSE) 1997 SET(ARCHIVE_ACL_FREEBSD_NFS4 FALSE) 1998 SET(ARCHIVE_ACL_LIBACL FALSE) 1999 SET(ARCHIVE_ACL_SUNOS FALSE) 2000 SET(ARCHIVE_ACL_SUNOS_NFS4 FALSE) 2001ENDIF(ENABLE_ACL) 2002 2003# 2004# Check MD5/RMD160/SHA support 2005# NOTE: Crypto checks must be run last before generating config.h 2006# 2007CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" LIBC) 2008CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC2) 2009CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC3) 2010CHECK_CRYPTO("MD5;SHA1;SHA256;SHA384;SHA512" LIBSYSTEM) 2011CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" MBEDTLS) 2012CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" NETTLE) 2013CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" OPENSSL) 2014 2015# Libmd has to be probed after OpenSSL. 2016CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA512" LIBMD) 2017 2018CHECK_CRYPTO_WIN("MD5;SHA1;SHA256;SHA384;SHA512") 2019 2020# Generate "config.h" from "build/cmake/config.h.in" 2021CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in 2022 ${CMAKE_CURRENT_BINARY_DIR}/config.h) 2023INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR}) 2024ADD_DEFINITIONS(-DHAVE_CONFIG_H) 2025 2026# Handle generation of the libarchive.pc file for pkg-config 2027INCLUDE(CreatePkgConfigFile) 2028 2029# 2030# Register installation of PDF documents. 2031# 2032IF(WIN32 AND NOT CYGWIN) 2033 # 2034 # On Windows platform, It's better that we install PDF documents 2035 # on one's computer. 2036 # These PDF documents are available in the release package. 2037 # 2038 IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf) 2039 INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf 2040 DESTINATION share/man 2041 FILES_MATCHING PATTERN "*.pdf" 2042 ) 2043 ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf) 2044ENDIF(WIN32 AND NOT CYGWIN) 2045# 2046# 2047# 2048INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/libarchive) 2049# 2050IF(MSVC) 2051 ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE) 2052ENDIF(MSVC) 2053 2054IF(APPLE) 2055 # CC_MD5_Init() functions are deprecated on macOS 10.15, but we want to use them 2056 ADD_DEFINITIONS(-Wno-deprecated-declarations) 2057ENDIF(APPLE) 2058 2059IF(ENABLE_TEST) 2060 ADD_CUSTOM_TARGET(run_all_tests) 2061ENDIF(ENABLE_TEST) 2062 2063add_subdirectory(libarchive) 2064add_subdirectory(cat) 2065add_subdirectory(tar) 2066add_subdirectory(cpio) 2067