CMakeLists.txt

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