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