CMakeLists.txt

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