CMakeLists.txt

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