Utilities/cmlibarchive/CMakeLists.txt

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