CMakeLists.txt

   1 #
   2 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.6 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 "Release" 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
  39 #
  40 # Version - read from 'version' file.
  41 #
  42 FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/build/version _version)
  43 STRING(REGEX REPLACE
  44  "^([0-9])[0-9][0-9][0-9][0-9][0-9][0-9][a-z]?$" "\\1" _major ${_version})
  45 STRING(REGEX REPLACE
  46  "^[0-9]([0-9][0-9][0-9])[0-9][0-9][0-9][a-z]?$" "\\1" _minor ${_version})
  47 STRING(REGEX REPLACE
  48  "^[0-9][0-9][0-9][0-9]([0-9][0-9][0-9])[a-z]?$" "\\1" _revision ${_version})
  49 STRING(REGEX REPLACE
  50  "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9]([a-z]?)$" "\\1" _quality ${_version})
  51 SET(_version_number ${_major}${_minor}${_revision})
  52 STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_minor ${_minor})
  53 STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_revision ${_revision})
  54 #
  55 SET(VERSION                    "${_major}.${_trimmed_minor}.${_trimmed_revision}${_quality}")
  56 SET(BSDCPIO_VERSION_STRING     "${VERSION}")
  57 SET(BSDTAR_VERSION_STRING      "${VERSION}")
  58 SET(LIBARCHIVE_VERSION_NUMBER  "${_version_number}")
  59 SET(LIBARCHIVE_VERSION_STRING  "${VERSION}")
  60
  61 # INTERFACE_VERSION increments with every release
  62 # libarchive 2.7 == interface version 9 = 2 + 7
  63 # libarchive 2.8 == interface version 10 = 2 + 8
  64 # libarchive 2.9 == interface version 11 = 2 + 9
  65 # libarchive 3.0 == interface version 12
  66 # libarchive 3.1 == interface version 13
  67 math(EXPR INTERFACE_VERSION  "13 + ${_minor}")
  68
  69 # Set SOVERSION == Interface version
  70 # ?? Should there be more here ??
  71 SET(SOVERSION "${INTERFACE_VERSION}")
  72
  73 # Enalbe CMAKE_PUSH_CHECK_STATE() and CMAKE_POP_CHECK_STATE() macros
  74 # saving and restoring the state of the variables.
  75 INCLUDE(CMakePushCheckState)
  76
  77 # Initialize the state of the variables. This initialization is not
  78 # necessary but this shows you what value the variables initially have.
  79 SET(CMAKE_REQUIRED_DEFINITIONS)
  80 SET(CMAKE_REQUIRED_INCLUDES)
  81 SET(CMAKE_REQUIRED_LIBRARIES)
  82 SET(CMAKE_REQUIRED_FLAGS)
  83
  84 # Especially for early development, we want to be a little
  85 # aggressive about diagnosing build problems; this can get
  86 # relaxed somewhat in final shipping versions.
  87 IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
  88   SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security")
  89   #################################################################
  90   # Set compile flags for all build types.
  91   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security")
  92   #################################################################
  93   # Set compile flags for debug build.
  94   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
  95   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Werror -Wextra -Wunused")
  96   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow")
  97   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes")
  98   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual")
  99 ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
 100 IF (MSVC)
 101   #################################################################
 102   # Set compile flags for debug build.
 103   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
 104   # Enable level 4 C4061: The enumerate has no associated handler in a switch
 105   #                       statement.
 106   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4061")
 107   # Enable level 4 C4254: A larger bit field was assigned to a smaller bit
 108   #                       field.
 109   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4254")
 110   # Enable level 4 C4295: An array was initialized but the last character in
 111   #                       the array is not a null; accessing the array may
 112   #                       produce unexpected results.
 113   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4295")
 114   # Enable level 4 C4296: An unsigned variable was used in a comparison
 115   #                       operation with zero.
 116   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4296")
 117   # Enable level 4 C4389: An operation involved signed and unsigned variables.
 118   #                       This could result in a loss of data.
 119   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4389")
 120   # Enable level 4 C4505: The given function is local and not referenced in
 121   #                       the body of the module; therefore, the function is
 122   #                       dead code.
 123   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4505")
 124   # Enable level 4 C4514: The optimizer removed an inline function that is not
 125   #                       called.
 126   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4514")
 127   # Enable level 4 C4702: Unreachable code.
 128   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4702")
 129   # Enable level 4 C4706: The test value in a conditional expression was the
 130   #                       result of an assignment.
 131   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4706")
 132   # /WX option is the same as gcc's -Werror option.
 133   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /WX")
 134   # /Oi option enables built-in functions.
 135   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Oi")
 136   #################################################################
 137   # Set compile flags for release build.
 138   SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Oi")
 139 ENDIF (MSVC)
 140
 141 # Enable CTest/CDash support
 142 include(CTest)
 143
 144 OPTION(ENABLE_NETTLE "Enable use of Nettle" ON)
 145 OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
 146 OPTION(ENABLE_TAR "Enable tar building" ON)
 147 OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" FALSE)
 148 OPTION(ENABLE_CPIO "Enable cpio building" ON)
 149 OPTION(ENABLE_CPIO_SHARED "Enable dynamic build of cpio" FALSE)
 150 OPTION(ENABLE_XATTR "Enable extended attribute support" ON)
 151 OPTION(ENABLE_ACL "Enable ACL support" ON)
 152 OPTION(ENABLE_ICONV "Enable iconv support" ON)
 153 OPTION(ENABLE_TEST "Enable unit and regression tests" ON)
 154 SET(POSIX_REGEX_LIB "AUTO" CACHE STRING "Choose what library should provide POSIX regular expression support")
 155 SET(ENABLE_SAFESEH "AUTO" CACHE STRING "Enable use of /SAFESEH linker flag (MSVC only)")
 156 SET(WINDOWS_VERSION "" CACHE STRING "Set Windows version to use (Windows only)")
 157
 158 IF(ENABLE_TEST)
 159         ENABLE_TESTING()
 160 ENDIF(ENABLE_TEST)
 161
 162 IF(WIN32)
 163   IF(WINDOWS_VERSION STREQUAL "WIN8")
 164     SET(WINVER 0x0602)
 165   ELSEIF(WINDOWS_VERSION STREQUAL "WIN7")
 166     SET(WINVER 0x0601)
 167   ELSEIF(WINDOWS_VERSION STREQUAL "WS08")
 168     SET(WINVER 0x0600)
 169   ELSEIF(WINDOWS_VERSION STREQUAL "VISTA")
 170     SET(WINVER 0x0600)
 171   ELSEIF(WINDOWS_VERSION STREQUAL "WS03")
 172     SET(WINVER 0x0502)
 173   ELSEIF(WINDOWS_VERSION STREQUAL "WINXP")
 174     SET(WINVER 0x0501)
 175   ELSE(WINDOWS_VERSION STREQUAL "WIN8")
 176     # The default is to use Windows 2000 API.
 177     SET(WINVER 0x0500)
 178   ENDIF(WINDOWS_VERSION STREQUAL "WIN8")
 179   SET(_WIN32_WINNT ${WINVER})
 180 ENDIF(WIN32)
 181
 182 IF(MSVC)
 183   IF(ENABLE_SAFESEH STREQUAL "YES")
 184     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH")
 185     SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH")
 186     SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH")
 187         SET(CMAKE_REQUIRED_LINKER_FLAGS "/SAFESEH")
 188   ELSEIF(ENABLE_SAFESEH STREQUAL "NO")
 189     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
 190     SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
 191     SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO")
 192         SET(CMAKE_REQUIRED_LINKER_FLAGS "/SAFESEH:NO")
 193   ENDIF(ENABLE_SAFESEH STREQUAL "YES")
 194 ENDIF(MSVC)
 195
 196 IF("${CMAKE_C_PLATFORM_ID}" MATCHES "^(HP-UX)$")
 197   ADD_DEFINITIONS(-D_XOPEN_SOURCE=500) # Ask wchar.h for mbstate_t
 198 ENDIF()
 199
 200 #
 201 INCLUDE(LibarchiveCheckCSourceCompiles)
 202 INCLUDE(LibarchiveCheckCSourceRuns)
 203 INCLUDE(CheckFileOffsetBits)
 204 INCLUDE(CheckFuncs)
 205 INCLUDE(CheckHeaderDirent)
 206 INCLUDE(CheckIncludeFile)
 207 INCLUDE(CheckIncludeFiles)
 208 INCLUDE(CheckLibraryExists)
 209 INCLUDE(CheckStructMember)
 210 INCLUDE(CheckSymbolExists)
 211 INCLUDE(CheckTypeExists)
 212 INCLUDE(CheckTypeSize)
 213
 214 #
 215 # Generate list.h
 216 #
 217 MACRO (GENERATE_LIST_H _listfile _cmlist __list_sources)
 218   SET(_argv ${ARGV})
 219   # Remove _listfile and _cmlist from _argv
 220   LIST(REMOVE_AT _argv 0 1)
 221   IF (NOT EXISTS "${_listfile}" OR
 222      ${_cmlist} IS_NEWER_THAN "${_listfile}")
 223
 224     MESSAGE(STATUS "Generating ${_listfile}")
 225     FILE(WRITE ${_listfile} "")
 226     FOREACH (testfile ${_argv})
 227       IF (testfile MATCHES "^test_[^/]+[.]c$")
 228         FILE(STRINGS ${testfile} testvar REGEX "^DEFINE_TEST")
 229         FOREACH (deftest ${testvar})
 230           FILE(APPEND ${_listfile} "${deftest}\n")
 231         ENDFOREACH (deftest)
 232       ENDIF (testfile MATCHES "^test_[^/]+[.]c$")
 233     ENDFOREACH (testfile)
 234
 235   ENDIF (NOT EXISTS "${_listfile}" OR
 236      ${_cmlist} IS_NEWER_THAN "${_listfile}")
 237 ENDMACRO (GENERATE_LIST_H)
 238 #
 239 # Generate installation rules for man pages.
 240 #
 241 MACRO (INSTALL_MAN __mans)
 242   FOREACH (_man ${ARGV})
 243     STRING(REGEX REPLACE "^.+[.]([1-9])" "\\1" _mansect ${_man})
 244     INSTALL(FILES ${_man} DESTINATION "share/man/man${_mansect}")
 245   ENDFOREACH (_man)
 246 ENDMACRO (INSTALL_MAN __mans)
 247 #
 248 # Find out what macro is needed to use libraries on Windows.
 249 #
 250 MACRO (TRY_MACRO_FOR_LIBRARY INCLUDES LIBRARIES
 251        TRY_TYPE SAMPLE_SOURCE MACRO_LIST)
 252   IF(WIN32 AND NOT CYGWIN)
 253     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 254     SET(CMAKE_REQUIRED_INCLUDES ${INCLUDES})
 255     SET(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})
 256     FOREACH(VAR ${MACRO_LIST})
 257       # Clear ${VAR} from CACHE If the libraries which ${VAR} was
 258       # checked with are changed.
 259       SET(VAR_WITH_LIB "${VAR}_WITH_LIB")
 260       GET_PROPERTY(PREV_VAR_WITH_LIB VARIABLE PROPERTY ${VAR_WITH_LIB})
 261       IF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")
 262         UNSET(${VAR} CACHE)
 263       ENDIF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")
 264       # Check if the library can be used with the macro.
 265       IF("${TRY_TYPE}" MATCHES "COMPILES")
 266         LIBARCHIVE_CHECK_C_SOURCE_COMPILES("${SAMPLE_SOURCE}" ${VAR})
 267       ELSEIF("${TRY_TYPE}" MATCHES "RUNS")
 268         LIBARCHIVE_CHECK_C_SOURCE_RUNS("${SAMPLE_SOURCE}" ${VAR})
 269       ELSE("${TRY_TYPE}" MATCHES "COMPILES")
 270         MESSAGE(FATAL_ERROR "UNKNOWN KEYWORD \"${TRY_TYPE}\" FOR TRY_TYPE")
 271       ENDIF("${TRY_TYPE}" MATCHES "COMPILES")
 272       # Save the libraries which ${VAR} is checked with.
 273       SET(${VAR_WITH_LIB} "${LIBRARIES}" CACHE INTERNAL
 274           "Macro ${VAR} is checked with")
 275     ENDFOREACH(VAR)
 276     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 277   ENDIF(WIN32 AND NOT CYGWIN)
 278 ENDMACRO (TRY_MACRO_FOR_LIBRARY)
 279 #
 280 # Check compress/decompress libraries
 281 #
 282 IF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)
 283   # GnuWin32 is only for Win32, not Win64.
 284   SET(__GNUWIN32PATH "C:/Program Files/GnuWin32")
 285 ENDIF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)
 286 IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
 287   # You have to add a path availabel DLL file into PATH environment variable.
 288   # Maybe DLL path is "C:/Program Files/GnuWin32/bin".
 289   # The zlib and the bzip2 Setup program have installed programs and DLLs into
 290   # "C:/Program Files/GnuWin32" by default.
 291   # This is convenience setting for Windows.
 292   SET(CMAKE_PREFIX_PATH ${__GNUWIN32PATH} $(CMAKE_PREFIX_PATH))
 293   #
 294   # If you didn't use Setup program or installed into nonstandard path,
 295   # cmake cannot find out your zlib or bzip2 libraries and include files,
 296   # you should execute cmake with  -DCMAKE_PREFIX_PATH option.
 297   #   e.g.
 298   #     cmake -DCMAKE_PREFIX_PATH=<your-GnuWin32-path> <path-to-source>
 299   #
 300   # If compiling error occured in zconf.h, You may need patch to zconf.h.
 301   #--- zconf.h.orig     2005-07-21 00:40:26.000000000
 302   #+++ zconf.h  2009-01-19 11:39:10.093750000
 303   #@@ -286,7 +286,7 @@
 304   #
 305   # #if 1           /* HAVE_UNISTD_H -- this line is updated by ./configure */
 306   # #  include <sys/types.h> /* for off_t */
 307   #-#  include <unistd.h>    /* for SEEK_* and off_t */
 308   #+#  include <stdio.h>    /* for SEEK_* and off_t */
 309   # #  ifdef VMS
 310   # #    include <unixio.h>   /* for off_t */
 311   # #  endif
 312 ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
 313
 314 SET(ADDITIONAL_LIBS "")
 315 #
 316 # Find ZLIB
 317 #
 318 FIND_PACKAGE(ZLIB)
 319 IF(ZLIB_FOUND)
 320   SET(HAVE_LIBZ 1)
 321   SET(HAVE_ZLIB_H 1)
 322   INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 323   LIST(APPEND ADDITIONAL_LIBS ${ZLIB_LIBRARIES})
 324   IF(WIN32 AND NOT CYGWIN)
 325     #
 326     # Test if ZLIB_WINAPI macro is needed to use.
 327     #
 328     TRY_MACRO_FOR_LIBRARY(
 329       "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"
 330       RUNS
 331       "#include <zlib.h>\nint main() {uLong f = zlibCompileFlags(); return (f&(1U<<10))?0:-1; }"
 332       ZLIB_WINAPI)
 333     IF(ZLIB_WINAPI)
 334       ADD_DEFINITIONS(-DZLIB_WINAPI)
 335     ELSE(ZLIB_WINAPI)
 336       # Test if a macro is needed for the library.
 337       TRY_MACRO_FOR_LIBRARY(
 338         "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"
 339         COMPILES
 340         "#include <zlib.h>\nint main() {return zlibVersion()?1:0; }"
 341         "ZLIB_DLL;WITHOUT_ZLIB_DLL")
 342       IF(ZLIB_DLL)
 343         ADD_DEFINITIONS(-DZLIB_DLL)
 344       ENDIF(ZLIB_DLL)
 345     ENDIF(ZLIB_WINAPI)
 346   ENDIF(WIN32 AND NOT CYGWIN)
 347 ENDIF(ZLIB_FOUND)
 348 MARK_AS_ADVANCED(CLEAR ZLIB_INCLUDE_DIR)
 349 MARK_AS_ADVANCED(CLEAR ZLIB_LIBRARY)
 350 #
 351 # Find BZip2
 352 #
 353 FIND_PACKAGE(BZip2)
 354 IF(BZIP2_FOUND)
 355   SET(HAVE_LIBBZ2 1)
 356   SET(HAVE_BZLIB_H 1)
 357   INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
 358   LIST(APPEND ADDITIONAL_LIBS ${BZIP2_LIBRARIES})
 359   # Test if a macro is needed for the library.
 360   TRY_MACRO_FOR_LIBRARY(
 361     "${BZIP2_INCLUDE_DIR}" "${BZIP2_LIBRARIES}"
 362     COMPILES
 363     "#include <bzlib.h>\nint main() {return BZ2_bzlibVersion()?1:0; }"
 364     "USE_BZIP2_DLL;USE_BZIP2_STATIC")
 365   IF(USE_BZIP2_DLL)
 366     ADD_DEFINITIONS(-DUSE_BZIP2_DLL)
 367   ELSEIF(USE_BZIP2_STATIC)
 368     ADD_DEFINITIONS(-DUSE_BZIP2_STATIC)
 369   ENDIF(USE_BZIP2_DLL)
 370 ENDIF(BZIP2_FOUND)
 371 MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR)
 372 MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARIES)
 373 #
 374 # Find LZMA
 375 #
 376 FIND_PACKAGE(LZMA)
 377 IF(LZMA_FOUND)
 378   SET(HAVE_LIBLZMA 1)
 379   SET(HAVE_LZMA_H 1)
 380   INCLUDE_DIRECTORIES(${LZMA_INCLUDE_DIR})
 381   LIST(APPEND ADDITIONAL_LIBS ${LZMA_LIBRARIES})
 382   # Test if a macro is needed for the library.
 383   TRY_MACRO_FOR_LIBRARY(
 384     "${LZMA_INCLUDE_DIR}" "${LZMA_LIBRARIES}"
 385     COMPILES
 386     "#include <lzma.h>\nint main() {return (int)lzma_version_number(); }"
 387     "WITHOUT_LZMA_API_STATIC;LZMA_API_STATIC")
 388   IF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)
 389     ADD_DEFINITIONS(-DLZMA_API_STATIC)
 390   ENDIF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)
 391 ELSEIF(LZMADEC_FOUND)
 392   SET(HAVE_LIBLZMADEC 1)
 393   SET(HAVE_LZMADEC_H 1)
 394   INCLUDE_DIRECTORIES(${LZMADEC_INCLUDE_DIR})
 395   LIST(APPEND ADDITIONAL_LIBS ${LZMADEC_LIBRARIES})
 396 ENDIF(LZMA_FOUND)
 397 #
 398 # Find LZO2
 399 #
 400 IF (LZO2_INCLUDE_DIR)
 401   # Already in cache, be silent
 402   SET(LZO2_FIND_QUIETLY TRUE)
 403 ENDIF (LZO2_INCLUDE_DIR)
 404
 405 FIND_PATH(LZO2_INCLUDE_DIR lzo/lzoconf.h)
 406 FIND_LIBRARY(LZO2_LIBRARY NAMES lzo2 liblzo2)
 407 INCLUDE(FindPackageHandleStandardArgs)
 408 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZO2 DEFAULT_MSG LZO2_LIBRARY LZO2_INCLUDE_DIR)
 409 IF(LZO2_FOUND)
 410   SET(HAVE_LIBLZO2 1)
 411   SET(HAVE_LZO_LZOCONF_H 1)
 412   SET(HAVE_LZO_LZO1X_H 1)
 413   INCLUDE_DIRECTORIES(${LZO2_INCLUDE_DIR})
 414   LIST(APPEND ADDITIONAL_LIBS ${LZO2_LIBRARY})
 415   #
 416   # TODO: test for static library.
 417   #
 418 ENDIF(LZO2_FOUND)
 419 MARK_AS_ADVANCED(CLEAR LZO2_INCLUDE_DIR)
 420 MARK_AS_ADVANCED(CLEAR LZO2_LIBRARY)
 421
 422 #
 423 # Check headers
 424 #
 425 CHECK_HEADER_DIRENT()
 426
 427 SET(INCLUDES "")
 428 MACRO (LA_CHECK_INCLUDE_FILE header var)
 429       CHECK_INCLUDE_FILES("${INCLUDES};${header}" ${var})
 430       IF (${var})
 431          SET(INCLUDES ${INCLUDES} ${header})
 432       ENDIF (${var})
 433 ENDMACRO (LA_CHECK_INCLUDE_FILE)
 434
 435 # Some FreeBSD headers assume sys/types.h was already included.
 436 LA_CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H)
 437
 438 # Alphabetize the rest unless there's a compelling reason
 439 LA_CHECK_INCLUDE_FILE("acl/libacl.h" HAVE_ACL_LIBACL_H)
 440 LA_CHECK_INCLUDE_FILE("ctype.h" HAVE_CTYPE_H)
 441 LA_CHECK_INCLUDE_FILE("copyfile.h" HAVE_COPYFILE_H)
 442 LA_CHECK_INCLUDE_FILE("direct.h" HAVE_DIRECT_H)
 443 LA_CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H)
 444 LA_CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H)
 445 LA_CHECK_INCLUDE_FILE("ext2fs/ext2_fs.h" HAVE_EXT2FS_EXT2_FS_H)
 446
 447 LIBARCHIVE_CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>
 448 #include <ext2fs/ext2_fs.h>
 449 int main(void) { return EXT2_IOC_GETFLAGS; }" HAVE_WORKING_EXT2_IOC_GETFLAGS)
 450
 451 LA_CHECK_INCLUDE_FILE("fcntl.h" HAVE_FCNTL_H)
 452 LA_CHECK_INCLUDE_FILE("grp.h" HAVE_GRP_H)
 453 LA_CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H)
 454 LA_CHECK_INCLUDE_FILE("io.h" HAVE_IO_H)
 455 LA_CHECK_INCLUDE_FILE("langinfo.h" HAVE_LANGINFO_H)
 456 LA_CHECK_INCLUDE_FILE("limits.h" HAVE_LIMITS_H)
 457 LA_CHECK_INCLUDE_FILE("linux/types.h" HAVE_LINUX_TYPES_H)
 458 LA_CHECK_INCLUDE_FILE("linux/fiemap.h" HAVE_LINUX_FIEMAP_H)
 459 LA_CHECK_INCLUDE_FILE("linux/fs.h" HAVE_LINUX_FS_H)
 460 LA_CHECK_INCLUDE_FILE("linux/magic.h" HAVE_LINUX_MAGIC_H)
 461 LA_CHECK_INCLUDE_FILE("locale.h" HAVE_LOCALE_H)
 462 LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H)
 463 LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H)
 464 LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H)
 465 LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H)
 466 LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H)
 467 LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H)
 468 LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H)
 469 LA_CHECK_INCLUDE_FILE("spawn.h" HAVE_SPAWN_H)
 470 LA_CHECK_INCLUDE_FILE("stdarg.h" HAVE_STDARG_H)
 471 LA_CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H)
 472 LA_CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H)
 473 LA_CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H)
 474 LA_CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)
 475 LA_CHECK_INCLUDE_FILE("sys/acl.h" HAVE_SYS_ACL_H)
 476 LA_CHECK_INCLUDE_FILE("sys/cdefs.h" HAVE_SYS_CDEFS_H)
 477 LA_CHECK_INCLUDE_FILE("sys/ioctl.h" HAVE_SYS_IOCTL_H)
 478 LA_CHECK_INCLUDE_FILE("sys/mkdev.h" HAVE_SYS_MKDEV_H)
 479 LA_CHECK_INCLUDE_FILE("sys/mount.h" HAVE_SYS_MOUNT_H)
 480 LA_CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H)
 481 LA_CHECK_INCLUDE_FILE("sys/poll.h" HAVE_SYS_POLL_H)
 482 LA_CHECK_INCLUDE_FILE("sys/select.h" HAVE_SYS_SELECT_H)
 483 LA_CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H)
 484 LA_CHECK_INCLUDE_FILE("sys/statfs.h" HAVE_SYS_STATFS_H)
 485 LA_CHECK_INCLUDE_FILE("sys/statvfs.h" HAVE_SYS_STATVFS_H)
 486 LA_CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H)
 487 LA_CHECK_INCLUDE_FILE("sys/utime.h" HAVE_SYS_UTIME_H)
 488 LA_CHECK_INCLUDE_FILE("sys/utsname.h" HAVE_SYS_UTSNAME_H)
 489 LA_CHECK_INCLUDE_FILE("sys/vfs.h" HAVE_SYS_VFS_H)
 490 LA_CHECK_INCLUDE_FILE("sys/wait.h" HAVE_SYS_WAIT_H)
 491 LA_CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H)
 492 LA_CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H)
 493 LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H)
 494 LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H)
 495 LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H)
 496 LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H)
 497 # Following files need windwos.h, so we should test it after windows.h test.
 498 LA_CHECK_INCLUDE_FILE("wincrypt.h" HAVE_WINCRYPT_H)
 499 LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H)
 500
 501 #
 502 # Check whether use of __EXTENSIONS__ is safe.
 503 # We need some macro such as _GNU_SOURCE to use extension functions.
 504 #
 505 SET(_INCLUDE_FILES)
 506 FOREACH (it ${_HEADER})
 507    SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n")
 508 ENDFOREACH (it)
 509
 510 LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
 511   "#define __EXTENSIONS__ 1
 512    ${_INCLUDE_FILES}
 513    int main() { return 0;}"
 514  SAFE_TO_DEFINE_EXTENSIONS)
 515
 516 #
 517 # Find Nettle
 518 #
 519 IF(ENABLE_NETTLE)
 520   FIND_PACKAGE(Nettle)
 521   IF(NETTLE_FOUND)
 522     SET(HAVE_LIBNETTLE 1)
 523     SET(HAVE_NETTLE_MD5_H 1)
 524     SET(HAVE_NETTLE_RIPEMD160_H 1)
 525     SET(HAVE_NETTLE_SHA_H 1)
 526     INCLUDE_DIRECTORIES(${NETTLE_INCLUDE_DIR})
 527     LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARIES})
 528   ENDIF(NETTLE_FOUND)
 529   MARK_AS_ADVANCED(CLEAR NETTLE_INCLUDE_DIR)
 530   MARK_AS_ADVANCED(CLEAR NETTLE_LIBRARIES)
 531 ENDIF(ENABLE_NETTLE)
 532
 533 #
 534 # Find OpenSSL
 535 # (Except on Mac, where OpenSSL is deprecated.)
 536 #
 537 IF(ENABLE_OPENSSL AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin")
 538   FIND_PACKAGE(OpenSSL)
 539 ELSE()
 540   SET(OPENSSL_FOUND FALSE) # Override cached value
 541 ENDIF()
 542
 543 # FreeBSD libmd
 544 IF(NOT OPENSSL_FOUND)
 545   CHECK_LIBRARY_EXISTS(md "MD5Init" "" LIBMD_FOUND)
 546   IF(LIBMD_FOUND)
 547     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 548     SET(CMAKE_REQUIRED_LIBRARIES "md")
 549     FIND_LIBRARY(LIBMD_LIBRARY NAMES md)
 550     LIST(APPEND ADDITIONAL_LIBS ${LIBMD_LIBRARY})
 551     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 552   ENDIF(LIBMD_FOUND)
 553 ENDIF(NOT OPENSSL_FOUND)
 554
 555 #
 556 # How to prove that CRYPTO functions, which have several names on various
 557 # platforms, just see if archive_crypto.c can compile and link against
 558 # required libraries.
 559 #
 560 MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)
 561     FOREACH(ALGORITHM ${ALGORITHMS})
 562       IF(NOT ARCHIVE_CRYPTO_${ALGORITHM})
 563       STRING(TOLOWER "${ALGORITHM}" lower_algorithm)
 564       STRING(TOUPPER "${ALGORITHM}" algorithm)
 565       IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
 566         SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)
 567       ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NOT NETTLE_FOUND)
 568         SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)
 569       ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
 570
 571       IF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 572         # Probe the local implementation for whether this
 573         # crypto implementation is available on this platform.
 574         SET(TRY_CRYPTO_REQUIRED_INCLUDES
 575           "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive;${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp")
 576         SET(TRY_CRYPTO_REQUIRED_LIBS)
 577         IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 578             SET(TRY_CRYPTO_REQUIRED_INCLUDES
 579               "${TRY_CRYPTO_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}")
 580             SET(TRY_CRYPTO_REQUIRED_LIBS
 581                 "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}")
 582         ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NETTLE_FOUND)
 583             SET(TRY_CRYPTO_REQUIRED_INCLUDES
 584               "${TRY_CRYPTO_REQUIRED_INCLUDES};${NETTLE_INCLUDE_DIR}")
 585             SET(TRY_CRYPTO_REQUIRED_LIBS
 586                 "-DLINK_LIBRARIES:STRING=${NETTLE_LIBRARY}")
 587         ELSEIF("${IMPLEMENTATION}" MATCHES "^LIBMD$" AND LIBMD_FOUND)
 588             SET(TRY_CRYPTO_REQUIRED_LIBS
 589                 "-DLINK_LIBRARIES:STRING=${LIBMD_LIBRARY}")
 590         ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 591
 592     CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
 593       ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)
 594         FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"
 595              CONFDEFS_H)
 596         FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_crypto.c"
 597              ARCHIVE_CRYPTO_C)
 598
 599         SET(SOURCE "${CONFDEFS_H}
 600
 601 #define ARCHIVE_${algorithm}_COMPILE_TEST
 602 #define ARCHIVE_CRYPTO_${algorithm}_${IMPLEMENTATION}
 603 #define PLATFORM_CONFIG_H \"check_crypto_md.h\"
 604
 605 ${ARCHIVE_CRYPTO_C}
 606
 607 int
 608 main(int argc, char **argv)
 609 {
 610   archive_${lower_algorithm}_ctx ctx;
 611   archive_${lower_algorithm}_init(&ctx);
 612   archive_${lower_algorithm}_update(&ctx, *argv, argc);
 613   archive_${lower_algorithm}_final(&ctx, NULL);
 614   return 0;
 615 }
 616 ")
 617
 618   FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.h" "")
 619         FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c" "${SOURCE}")
 620         MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}")
 621
 622     IF(CMAKE_REQUIRED_LINKER_FLAGS)
 623       SET(CHECK_CRYPTO_ADD_LINKER_FLAGS
 624         "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS} -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS} -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS}")
 625     ELSE(CMAKE_REQUIRED_LINKER_FLAGS)
 626       SET(CHECK_CRYPTO_ADD_LINKER_FLAGS)
 627     ENDIF(CMAKE_REQUIRED_LINKER_FLAGS)
 628         TRY_COMPILE(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}
 629           ${CMAKE_BINARY_DIR}
 630           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c
 631           CMAKE_FLAGS ${CHECK_CRYPTO_ADD_LINKER_FLAGS}
 632            "${TRY_CRYPTO_REQUIRED_LIBS}"
 633            "${TRY_CRYPTO_REQUIRED_INCLUDES}"
 634           OUTPUT_VARIABLE OUTPUT)
 635
 636         # Inform user whether or not we found it; if not, log why we didn't.
 637         IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 638           MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- found")
 639                   SET(ARCHIVE_CRYPTO_${ALGORITHM} 1)
 640         ELSE (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 641           MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- not found")
 642           FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 643             "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} failed with the following output:\n"
 644             "${OUTPUT}\n"
 645             "Source file was:\n${SOURCE}\n")
 646         ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 647       ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 648
 649       # Add appropriate libs/includes depending on whether the implementation
 650       # was found on this platform.
 651       IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 652         IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 653           INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
 654           LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_LIBRARIES})
 655            LIST(REMOVE_DUPLICATES ADDITIONAL_LIBS)
 656         ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 657       ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 658       ENDIF(NOT ARCHIVE_CRYPTO_${ALGORITHM})
 659     ENDFOREACH(ALGORITHM ${ALGORITHMS})
 660 ENDMACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)
 661
 662 #
 663 # CRYPTO functions on Windows is defined at archive_windows.c, thus we do not
 664 # need the test what the functions can be mapped to archive_{crypto name}_init,
 665 # archive_{crypto name}_update and archive_{crypto name}_final.
 666 # The functions on Windows use CALG_{crypto name} macro to create a crypt object
 667 # and then we need to know what CALG_{crypto name} macros is available to show
 668 # ARCHIVE_CRYPTO_{crypto name}_WIN macros because Windows 2000 and earlier version
 669 # of Windows XP do not support SHA256, SHA384 and SHA512.
 670 #
 671 MACRO(CHECK_CRYPTO_WIN CRYPTO_LIST)
 672   IF(WIN32 AND NOT CYGWIN)
 673     FOREACH(CRYPTO ${CRYPTO_LIST})
 674       IF(NOT ARCHIVE_CRYPTO_${CRYPTO})
 675       IF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 676         STRING(TOUPPER "${CRYPTO}" crypto)
 677         SET(ALGID "")
 678         IF ("${CRYPTO}" MATCHES "^MD5$")
 679             SET(ALGID "CALG_MD5")
 680         ENDIF ("${CRYPTO}" MATCHES "^MD5$")
 681         IF ("${CRYPTO}" MATCHES "^SHA1$")
 682             SET(ALGID "CALG_SHA1")
 683         ENDIF ("${CRYPTO}" MATCHES "^SHA1$")
 684         IF ("${CRYPTO}" MATCHES "^SHA256$")
 685             SET(ALGID "CALG_SHA_256")
 686         ENDIF ("${CRYPTO}" MATCHES "^SHA256$")
 687         IF ("${CRYPTO}" MATCHES "^SHA384$")
 688             SET(ALGID "CALG_SHA_384")
 689         ENDIF ("${CRYPTO}" MATCHES "^SHA384$")
 690         IF ("${CRYPTO}" MATCHES "^SHA512$")
 691             SET(ALGID "CALG_SHA_512")
 692         ENDIF ("${CRYPTO}" MATCHES "^SHA512$")
 693
 694     CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
 695       ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)
 696         FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"
 697              CONFDEFS_H)
 698
 699         SET(SOURCE "${CONFDEFS_H}
 700
 701 #define ${crypto}_COMPILE_TEST
 702 #include <windows.h>
 703 #include <wincrypt.h>
 704
 705 int
 706 main(int argc, char **argv)
 707 {
 708         return ${ALGID};
 709 }
 710 ")
 711         SET(SOURCE_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_win.c")
 712
 713         FILE(WRITE "${SOURCE_FILE}" "${SOURCE}")
 714         MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN")
 715
 716     IF(CMAKE_REQUIRED_LINKER_FLAGS)
 717       SET(CHECK_CRYPTO_WIN_ADD_LINKER_FLAGS
 718         "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS} -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS} -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_REQUIRED_LINKER_FLAGS}")
 719     ELSE(CMAKE_REQUIRED_LINKER_FLAGS)
 720       SET(CHECK_CRYPTO_WIN_ADD_LINKER_FLAGS)
 721     ENDIF(CMAKE_REQUIRED_LINKER_FLAGS)
 722         TRY_COMPILE(ARCHIVE_CRYPTO_${CRYPTO}_WIN
 723           ${CMAKE_BINARY_DIR}
 724           ${SOURCE_FILE}
 725           CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive" ${CHECK_CRYPTO_WIN_ADD_LINKER_FLAGS}
 726           OUTPUT_VARIABLE OUTPUT)
 727
 728         IF (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 729             MESSAGE(STATUS
 730                 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- found")
 731                 SET(ARCHIVE_CRYPTO_${CRYPTO} 1)
 732         ELSE (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 733             MESSAGE(STATUS
 734                  "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- not found")
 735             FILE(APPEND
 736                 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 737                 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN failed with the following output:\n"
 738                 "${OUTPUT}\n"
 739                 "Source file was:\n${SOURCE}\n")
 740         ENDIF (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 741
 742       ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 743       ENDIF(NOT ARCHIVE_CRYPTO_${CRYPTO})
 744     ENDFOREACH(CRYPTO)
 745   ENDIF(WIN32 AND NOT CYGWIN)
 746 ENDMACRO(CHECK_CRYPTO_WIN CRYPTO_LIST)
 747
 748 #
 749 # Find iconv
 750 # POSIX defines the second arg as const char **
 751 # and requires it to be in libc.  But we can accept
 752 # a non-const argument here and can support iconv()
 753 # being in libiconv.
 754 #
 755 MACRO(CHECK_ICONV LIB TRY_ICONV_CONST)
 756   IF(NOT HAVE_ICONV)
 757     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 758     IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
 759       #
 760       # During checking iconv proto type, we should use -Werror to avoid the
 761       # success of iconv detection with a warnig which success is a miss
 762       # detection. So this needs for all build mode(even it's a release mode).
 763       #
 764       SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror")
 765     ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
 766     IF (MSVC)
 767       # NOTE: /WX option is the same as gcc's -Werror option.
 768       SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} /WX")
 769     ENDIF (MSVC)
 770     #
 771     LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
 772       "#include <stdlib.h>
 773        #include <iconv.h>
 774        int main() {
 775           ${TRY_ICONV_CONST} char *ccp;
 776           iconv_t cd = iconv_open(\"\", \"\");
 777           iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0);
 778           iconv_close(cd);
 779           return 0;
 780        }"
 781      HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 782     IF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 783       SET(HAVE_ICONV true)
 784       SET(ICONV_CONST ${TRY_ICONV_CONST})
 785     ENDIF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 786     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 787   ENDIF(NOT HAVE_ICONV)
 788 ENDMACRO(CHECK_ICONV TRY_ICONV_CONST)
 789
 790 IF(ENABLE_ICONV)
 791   CMAKE_PUSH_CHECK_STATE()      # Save the state of the variables
 792   FIND_PATH(ICONV_INCLUDE_DIR iconv.h)
 793   IF(ICONV_INCLUDE_DIR)
 794     #SET(INCLUDES ${INCLUDES} "iconv.h")
 795     SET(HAVE_ICONV_H 1)
 796     INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
 797     SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 798     CHECK_ICONV("libc" "const")
 799     CHECK_ICONV("libc" "")
 800
 801     # If iconv isn't in libc and we have a libiconv, try that.
 802     FIND_LIBRARY(LIBICONV_PATH NAMES iconv libiconv)
 803     IF(NOT HAVE_ICONV AND LIBICONV_PATH)
 804       LIST(APPEND CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH})
 805       # Test if a macro is needed for the library.
 806       TRY_MACRO_FOR_LIBRARY(
 807         "${ICONV_INCLUDE_DIR}" "${LIBICONV_PATH}"
 808         COMPILES
 809         "#include <iconv.h>\nint main() {return iconv_close((iconv_t)0);}"
 810         "WITHOUT_LIBICONV_STATIC;LIBICONV_STATIC")
 811       IF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC)
 812         ADD_DEFINITIONS(-DLIBICONV_STATIC)
 813       ENDIF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC)
 814       #
 815       # Set up CMAKE_REQUIRED_* for CHECK_ICONV
 816       #
 817       SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 818       SET(CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH})
 819       IF(LIBICONV_STATIC)
 820         # LIBICONV_STATIC is necessary for the success of CHECK_ICONV
 821         # on Windows.
 822         SET(CMAKE_REQUIRED_DEFINITIONS "-DLIBICONV_STATIC")
 823       ELSE(LIBICONV_STATIC)
 824         SET(CMAKE_REQUIRED_DEFINITIONS)
 825       ENDIF(LIBICONV_STATIC)
 826       CHECK_ICONV("libiconv" "const")
 827       CHECK_ICONV("libiconv" "")
 828       IF (HAVE_ICONV)
 829         LIST(APPEND ADDITIONAL_LIBS ${LIBICONV_PATH})
 830       ENDIF(HAVE_ICONV)
 831     ENDIF(NOT HAVE_ICONV AND LIBICONV_PATH)
 832   ENDIF(ICONV_INCLUDE_DIR)
 833   #
 834   # Find locale_charset() for libiconv.
 835   #
 836   IF(LIBICONV_PATH)
 837     SET(CMAKE_REQUIRED_DEFINITIONS)
 838     SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 839     SET(CMAKE_REQUIRED_LIBRARIES)
 840     CHECK_INCLUDE_FILES("localcharset.h" HAVE_LOCALCHARSET_H)
 841     FIND_LIBRARY(LIBCHARSET_PATH NAMES charset libcharset)
 842     IF(LIBCHARSET_PATH)
 843       SET(CMAKE_REQUIRED_LIBRARIES ${LIBCHARSET_PATH})
 844       IF(WIN32 AND NOT CYGWIN)
 845         # Test if a macro is needed for the library.
 846         TRY_MACRO_FOR_LIBRARY(
 847           "${ICONV_INCLUDE_DIR}" "${LIBCHARSET_PATH}"
 848           COMPILES
 849           "#include <localcharset.h>\nint main() {return locale_charset()?1:0;}"
 850           "WITHOUT_LIBCHARSET_STATIC;LIBCHARSET_STATIC")
 851         IF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC)
 852           ADD_DEFINITIONS(-DLIBCHARSET_STATIC)
 853         ENDIF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC)
 854         IF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC)
 855           SET(HAVE_LOCALE_CHARSET ON CACHE INTERNAL
 856               "Have function locale_charset")
 857         ENDIF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC)
 858       ELSE(WIN32 AND NOT CYGWIN)
 859         CHECK_FUNCTION_EXISTS_GLIBC(locale_charset HAVE_LOCALE_CHARSET)
 860       ENDIF(WIN32 AND NOT CYGWIN)
 861       IF(HAVE_LOCALE_CHARSET)
 862         LIST(APPEND ADDITIONAL_LIBS ${LIBCHARSET_PATH})
 863       ENDIF(HAVE_LOCALE_CHARSET)
 864     ENDIF(LIBCHARSET_PATH)
 865   ENDIF(LIBICONV_PATH)
 866   CMAKE_POP_CHECK_STATE()       # Restore the state of the variables
 867 ELSE(ENABLE_ICONV)
 868   # Make sure ICONV variables are not in CACHE after ENABLE_ICONV disabled
 869   # (once enabled).
 870   UNSET(HAVE_LOCALE_CHARSET CACHE)
 871   UNSET(HAVE_ICONV CACHE)
 872   UNSET(HAVE_ICONV_libc_ CACHE)
 873   UNSET(HAVE_ICONV_libc_const CACHE)
 874   UNSET(HAVE_ICONV_libiconv_ CACHE)
 875   UNSET(HAVE_ICONV_libiconv_const CACHE)
 876   UNSET(ICONV_INCLUDE_DIR CACHE)
 877   UNSET(LIBICONV_PATH CACHE)
 878   UNSET(LIBICONV_DLL CACHE)
 879   UNSET(LIBICONV_STATIC CACHE)
 880   UNSET(LIBCHARSET_DLL CACHE)
 881   UNSET(LIBCHARSET_STATIC CACHE)
 882 ENDIF(ENABLE_ICONV)
 883
 884 #
 885 # Find Libxml2
 886 #
 887 FIND_PACKAGE(LibXml2)
 888 IF(LIBXML2_FOUND)
 889   CMAKE_PUSH_CHECK_STATE()      # Save the state of the variables
 890   INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
 891   LIST(APPEND ADDITIONAL_LIBS ${LIBXML2_LIBRARIES})
 892   SET(HAVE_LIBXML2 1)
 893   # libxml2's include files use iconv.h
 894   SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR})
 895   CHECK_INCLUDE_FILES("libxml/xmlreader.h" HAVE_LIBXML_XMLREADER_H)
 896   CHECK_INCLUDE_FILES("libxml/xmlwriter.h" HAVE_LIBXML_XMLWRITER_H)
 897   # Test if a macro is needed for the library.
 898   TRY_MACRO_FOR_LIBRARY(
 899     "${ICONV_INCLUDE_DIR};${LIBXML2_INCLUDE_DIR}"
 900     "ws2_32.lib;${ZLIB_LIBRARIES};${LIBICONV_PATH};${LIBXML2_LIBRARIES}"
 901     COMPILES
 902     "#include <stddef.h>\n#include <libxml/xmlreader.h>\nint main() {return xmlTextReaderRead((xmlTextReaderPtr)(void *)0);}"
 903     "WITHOUT_LIBXML_STATIC;LIBXML_STATIC")
 904   IF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC)
 905     ADD_DEFINITIONS(-DLIBXML_STATIC)
 906   ENDIF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC)
 907   CMAKE_POP_CHECK_STATE()       # Restore the state of the variables
 908 ELSE(LIBXML2_FOUND)
 909   #
 910   # Find Expat
 911   #
 912   FIND_PACKAGE(EXPAT)
 913   IF(EXPAT_FOUND)
 914     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 915     INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR})
 916     LIST(APPEND ADDITIONAL_LIBS ${EXPAT_LIBRARIES})
 917     SET(HAVE_LIBEXPAT 1)
 918     LA_CHECK_INCLUDE_FILE("expat.h" HAVE_EXPAT_H)
 919     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 920   ENDIF(EXPAT_FOUND)
 921 ENDIF(LIBXML2_FOUND)
 922 MARK_AS_ADVANCED(CLEAR LIBXML2_INCLUDE_DIR)
 923 MARK_AS_ADVANCED(CLEAR LIBXML2_LIBRARIES)
 924
 925 #
 926 # POSIX Regular Expression support
 927 #
 928 IF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$")
 929   #
 930   # If PCREPOSIX is not found or not requested, try using regex
 931   # from libc or libregex
 932   #
 933   FIND_PATH(REGEX_INCLUDE_DIR regex.h)
 934   IF(REGEX_INCLUDE_DIR)
 935     CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBC)
 936     #
 937     # If libc does not provide regex, find libregex.
 938     #
 939     IF(NOT HAVE_REGCOMP_LIBC)
 940       CMAKE_PUSH_CHECK_STATE()  # Save the state of the variables
 941       FIND_LIBRARY(REGEX_LIBRARY regex)
 942       IF(REGEX_LIBRARY)
 943         SET(CMAKE_REQUIRED_LIBRARIES ${REGEX_LIBRARY})
 944         CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBREGEX)
 945         IF(HAVE_REGCOMP_LIBREGEX)
 946           LIST(APPEND ADDITIONAL_LIBS ${REGEX_LIBRARY})
 947           #
 948           # If regex.h is not found, retry looking for regex.h at
 949           # REGEX_INCLUDE_DIR
 950           #
 951           IF(NOT HAVE_REGEX_H)
 952             UNSET(HAVE_REGEX_H CACHE)
 953             INCLUDE_DIRECTORIES(${REGEX_INCLUDE_DIR})
 954             SET(CMAKE_REQUIRED_INCLUDES ${REGEX_INCLUDE_DIR})
 955             LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H)
 956           ENDIF(NOT HAVE_REGEX_H)
 957           # Test if a macro is needed for the library.
 958           TRY_MACRO_FOR_LIBRARY(
 959             "${REGEX_INCLUDE_DIR}" "${REGEX_LIBRARY}"
 960             COMPILES
 961             "#include <stddef.h>\n#include <regex.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
 962             "USE_REGEX_DLL;USE_REGEX_STATIC")
 963           IF(USE_REGEX_DLL)
 964             ADD_DEFINITIONS(-DUSE_REGEX_DLL)
 965           ELSEIF(USE_REGEX_STATIC)
 966             ADD_DEFINITIONS(-DUSE_REGEX_STATIC)
 967           ENDIF(USE_REGEX_DLL)
 968         ENDIF(HAVE_REGCOMP_LIBREGEX)
 969       ENDIF(REGEX_LIBRARY)
 970       CMAKE_POP_CHECK_STATE()   # Restore the state of the variables
 971     ENDIF(NOT HAVE_REGCOMP_LIBC)
 972   ENDIF(REGEX_INCLUDE_DIR)
 973   IF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX)
 974     SET(FOUND_POSIX_REGEX_LIB 1)
 975   ENDIF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX)
 976 ENDIF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$")
 977
 978 IF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$")
 979   #
 980   # If requested, try finding library for PCREPOSIX
 981   #
 982   FIND_PACKAGE(LibGCC)
 983   FIND_PACKAGE(PCREPOSIX)
 984   IF(PCREPOSIX_FOUND)
 985     INCLUDE_DIRECTORIES(${PCRE_INCLUDE_DIR})
 986     LIST(APPEND ADDITIONAL_LIBS ${PCREPOSIX_LIBRARIES})
 987     # Test if a macro is needed for the library.
 988     TRY_MACRO_FOR_LIBRARY(
 989       "${PCRE_INCLUDE_DIR}" "${PCREPOSIX_LIBRARIES}"
 990       COMPILES
 991       "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
 992       "WITHOUT_PCRE_STATIC;PCRE_STATIC")
 993     IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
 994       ADD_DEFINITIONS(-DPCRE_STATIC)
 995         ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND PCRE_FOUND)
 996           # Determine if pcre static libraries are to be used.
 997       LIST(APPEND ADDITIONAL_LIBS ${PCRE_LIBRARIES})
 998       SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES})
 999       MESSAGE(STATUS "trying again with -lpcre included")
1000       TRY_MACRO_FOR_LIBRARY(
1001         "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}"
1002         COMPILES
1003         "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1004         "WITHOUT_PCRE_STATIC;PCRE_STATIC")
1005       IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1006         ADD_DEFINITIONS(-DPCRE_STATIC)
1007       ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND MSVC AND LIBGCC_FOUND)
1008         # When doing a Visual Studio build using pcre static libraries
1009         # built using the mingw toolchain, -lgcc is needed to resolve
1010         # ___chkstk_ms.
1011         MESSAGE(STATUS "Visual Studio build detected, trying again with -lgcc included")
1012         LIST(APPEND ADDITIONAL_LIBS ${LIBGCC_LIBRARIES})
1013         SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES} ${LIBGCC_LIBRARIES})
1014           TRY_MACRO_FOR_LIBRARY(
1015             "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}"
1016             COMPILES
1017             "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1018             "WITHOUT_PCRE_STATIC;PCRE_STATIC")
1019           IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1020             ADD_DEFINITIONS(-DPCRE_STATIC)
1021           ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1022       ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1023     ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1024   ENDIF(PCREPOSIX_FOUND)
1025   MARK_AS_ADVANCED(CLEAR PCRE_INCLUDE_DIR)
1026   MARK_AS_ADVANCED(CLEAR PCREPOSIX_LIBRARIES)
1027   MARK_AS_ADVANCED(CLEAR PCRE_LIBRARIES)
1028   MARK_AS_ADVANCED(CLEAR LIBGCC_LIBRARIES)
1029 ENDIF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$")
1030
1031 #
1032 # Check functions
1033 #
1034 CMAKE_PUSH_CHECK_STATE()        # Save the state of the variables
1035 IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
1036   #
1037   # During checking functions, we should use -fno-builtin to avoid the
1038   # failure of function detection which failure is an error "conflicting
1039   # types for built-in function" caused by using -Werror option.
1040   #
1041   SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-builtin")
1042 ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$")
1043 CHECK_SYMBOL_EXISTS(_CrtSetReportMode "crtdbg.h" HAVE__CrtSetReportMode)
1044 CHECK_FUNCTION_EXISTS_GLIBC(chflags HAVE_CHFLAGS)
1045 CHECK_FUNCTION_EXISTS_GLIBC(chown HAVE_CHOWN)
1046 CHECK_FUNCTION_EXISTS_GLIBC(chroot HAVE_CHROOT)
1047 CHECK_FUNCTION_EXISTS_GLIBC(ctime_r HAVE_CTIME_R)
1048 CHECK_FUNCTION_EXISTS_GLIBC(dirfd HAVE_DIRFD)
1049 CHECK_FUNCTION_EXISTS_GLIBC(fchdir HAVE_FCHDIR)
1050 CHECK_FUNCTION_EXISTS_GLIBC(fchflags HAVE_FCHFLAGS)
1051 CHECK_FUNCTION_EXISTS_GLIBC(fchmod HAVE_FCHMOD)
1052 CHECK_FUNCTION_EXISTS_GLIBC(fchown HAVE_FCHOWN)
1053 CHECK_FUNCTION_EXISTS_GLIBC(fcntl HAVE_FCNTL)
1054 CHECK_FUNCTION_EXISTS_GLIBC(fdopendir HAVE_FDOPENDIR)
1055 CHECK_FUNCTION_EXISTS_GLIBC(fork HAVE_FORK)
1056 CHECK_FUNCTION_EXISTS_GLIBC(fstat HAVE_FSTAT)
1057 CHECK_FUNCTION_EXISTS_GLIBC(fstatat HAVE_FSTATAT)
1058 CHECK_FUNCTION_EXISTS_GLIBC(fstatfs HAVE_FSTATFS)
1059 CHECK_FUNCTION_EXISTS_GLIBC(fstatvfs HAVE_FSTATVFS)
1060 CHECK_FUNCTION_EXISTS_GLIBC(ftruncate HAVE_FTRUNCATE)
1061 CHECK_FUNCTION_EXISTS_GLIBC(futimens HAVE_FUTIMENS)
1062 CHECK_FUNCTION_EXISTS_GLIBC(futimes HAVE_FUTIMES)
1063 CHECK_FUNCTION_EXISTS_GLIBC(futimesat HAVE_FUTIMESAT)
1064 CHECK_FUNCTION_EXISTS_GLIBC(geteuid HAVE_GETEUID)
1065 CHECK_FUNCTION_EXISTS_GLIBC(getgrgid_r HAVE_GETGRGID_R)
1066 CHECK_FUNCTION_EXISTS_GLIBC(getgrnam_r HAVE_GETGRNAM_R)
1067 CHECK_FUNCTION_EXISTS_GLIBC(getpwnam_r HAVE_GETPWNAM_R)
1068 CHECK_FUNCTION_EXISTS_GLIBC(getpwuid_r HAVE_GETPWUID_R)
1069 CHECK_FUNCTION_EXISTS_GLIBC(getpid HAVE_GETPID)
1070 CHECK_FUNCTION_EXISTS_GLIBC(getvfsbyname HAVE_GETVFSBYNAME)
1071 CHECK_FUNCTION_EXISTS_GLIBC(gmtime_r HAVE_GMTIME_R)
1072 CHECK_FUNCTION_EXISTS_GLIBC(lchflags HAVE_LCHFLAGS)
1073 CHECK_FUNCTION_EXISTS_GLIBC(lchmod HAVE_LCHMOD)
1074 CHECK_FUNCTION_EXISTS_GLIBC(lchown HAVE_LCHOWN)
1075 CHECK_FUNCTION_EXISTS_GLIBC(link HAVE_LINK)
1076 CHECK_FUNCTION_EXISTS_GLIBC(localtime_r HAVE_LOCALTIME_R)
1077 CHECK_FUNCTION_EXISTS_GLIBC(lstat HAVE_LSTAT)
1078 CHECK_FUNCTION_EXISTS_GLIBC(lutimes HAVE_LUTIMES)
1079 CHECK_FUNCTION_EXISTS_GLIBC(mbrtowc HAVE_MBRTOWC)
1080 CHECK_FUNCTION_EXISTS_GLIBC(memmove HAVE_MEMMOVE)
1081 CHECK_FUNCTION_EXISTS_GLIBC(mkdir HAVE_MKDIR)
1082 CHECK_FUNCTION_EXISTS_GLIBC(mkfifo HAVE_MKFIFO)
1083 CHECK_FUNCTION_EXISTS_GLIBC(mknod HAVE_MKNOD)
1084 CHECK_FUNCTION_EXISTS_GLIBC(mkstemp HAVE_MKSTEMP)
1085 CHECK_FUNCTION_EXISTS_GLIBC(nl_langinfo HAVE_NL_LANGINFO)
1086 CHECK_FUNCTION_EXISTS_GLIBC(openat HAVE_OPENAT)
1087 CHECK_FUNCTION_EXISTS_GLIBC(pipe HAVE_PIPE)
1088 CHECK_FUNCTION_EXISTS_GLIBC(poll HAVE_POLL)
1089 CHECK_FUNCTION_EXISTS_GLIBC(posix_spawnp HAVE_POSIX_SPAWNP)
1090 CHECK_FUNCTION_EXISTS_GLIBC(readlink HAVE_READLINK)
1091 CHECK_FUNCTION_EXISTS_GLIBC(select HAVE_SELECT)
1092 CHECK_FUNCTION_EXISTS_GLIBC(setenv HAVE_SETENV)
1093 CHECK_FUNCTION_EXISTS_GLIBC(setlocale HAVE_SETLOCALE)
1094 CHECK_FUNCTION_EXISTS_GLIBC(sigaction HAVE_SIGACTION)
1095 CHECK_FUNCTION_EXISTS_GLIBC(statfs HAVE_STATFS)
1096 CHECK_FUNCTION_EXISTS_GLIBC(statvfs HAVE_STATVFS)
1097 CHECK_FUNCTION_EXISTS_GLIBC(strchr HAVE_STRCHR)
1098 CHECK_FUNCTION_EXISTS_GLIBC(strdup HAVE_STRDUP)
1099 CHECK_FUNCTION_EXISTS_GLIBC(strerror HAVE_STRERROR)
1100 CHECK_FUNCTION_EXISTS_GLIBC(strncpy_s HAVE_STRNCPY_S)
1101 CHECK_FUNCTION_EXISTS_GLIBC(strrchr HAVE_STRRCHR)
1102 CHECK_FUNCTION_EXISTS_GLIBC(symlink HAVE_SYMLINK)
1103 CHECK_FUNCTION_EXISTS_GLIBC(timegm HAVE_TIMEGM)
1104 CHECK_FUNCTION_EXISTS_GLIBC(tzset HAVE_TZSET)
1105 CHECK_FUNCTION_EXISTS_GLIBC(unsetenv HAVE_UNSETENV)
1106 CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIME)
1107 CHECK_FUNCTION_EXISTS_GLIBC(utimes HAVE_UTIMES)
1108 CHECK_FUNCTION_EXISTS_GLIBC(utimensat HAVE_UTIMENSAT)
1109 CHECK_FUNCTION_EXISTS_GLIBC(vfork HAVE_VFORK)
1110 CHECK_FUNCTION_EXISTS_GLIBC(wcrtomb HAVE_WCRTOMB)
1111 CHECK_FUNCTION_EXISTS_GLIBC(wcscmp HAVE_WCSCMP)
1112 CHECK_FUNCTION_EXISTS_GLIBC(wcscpy HAVE_WCSCPY)
1113 CHECK_FUNCTION_EXISTS_GLIBC(wcslen HAVE_WCSLEN)
1114 CHECK_FUNCTION_EXISTS_GLIBC(wctomb HAVE_WCTOMB)
1115 CHECK_FUNCTION_EXISTS_GLIBC(_ctime64_s HAVE__CTIME64_S)
1116 CHECK_FUNCTION_EXISTS_GLIBC(_fseeki64 HAVE__FSEEKI64)
1117 CHECK_FUNCTION_EXISTS_GLIBC(_get_timezone HAVE__GET_TIMEZONE)
1118 CHECK_FUNCTION_EXISTS_GLIBC(_localtime64_s HAVE__LOCALTIME64_S)
1119 CHECK_FUNCTION_EXISTS_GLIBC(_mkgmtime64 HAVE__MKGMTIME64)
1120
1121 SET(CMAKE_REQUIRED_LIBRARIES "")
1122 CHECK_FUNCTION_EXISTS(cygwin_conv_path HAVE_CYGWIN_CONV_PATH)
1123 CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
1124 CHECK_FUNCTION_EXISTS(strerror_r HAVE_STRERROR_R)
1125 CHECK_FUNCTION_EXISTS(strftime HAVE_STRFTIME)
1126 CHECK_FUNCTION_EXISTS(vprintf HAVE_VPRINTF)
1127 CHECK_FUNCTION_EXISTS(wmemcmp HAVE_WMEMCMP)
1128 CHECK_FUNCTION_EXISTS(wmemcpy HAVE_WMEMCPY)
1129
1130 CMAKE_POP_CHECK_STATE() # Restore the state of the variables
1131
1132 # Make sure we have the POSIX version of readdir_r, not the
1133 # older 2-argument version.
1134 LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
1135   "#include <dirent.h>\nint main() {DIR *d = opendir(\".\"); struct dirent e,*r; return readdir_r(d,&e,&r);}"
1136   HAVE_READDIR_R)
1137
1138
1139 # Only detect readlinkat() if we also have AT_FDCWD in unistd.h.
1140 # NOTE: linux requires fcntl.h for AT_FDCWD.
1141 LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
1142   "#include <fcntl.h>\n#include <unistd.h>\nint main() {char buf[10]; return readlinkat(AT_FDCWD, \"\", buf, 0);}"
1143   HAVE_READLINKAT)
1144
1145
1146 # To verify major(), we need to both include the header
1147 # of interest and verify that the result can be linked.
1148 # CHECK_FUNCTION_EXISTS doesn't accept a header argument,
1149 # CHECK_SYMBOL_EXISTS doesn't test linkage.
1150 LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
1151   "#include <sys/mkdev.h>\nint main() { return major(256); }"
1152   MAJOR_IN_MKDEV)
1153 LIBARCHIVE_CHECK_C_SOURCE_COMPILES(
1154   "#include <sys/sysmacros.h>\nint main() { return major(256); }"
1155   MAJOR_IN_SYSMACROS)
1156
1157 IF(HAVE_STRERROR_R)
1158   SET(HAVE_DECL_STRERROR_R 1)
1159 ENDIF(HAVE_STRERROR_R)
1160
1161 #
1162 # Check defines
1163 #
1164 SET(headers "limits.h")
1165 IF(HAVE_STDINT_H)
1166   LIST(APPEND headers "stdint.h")
1167 ENDIF(HAVE_STDINT_H)
1168 IF(HAVE_INTTYPES_H)
1169   LIST(APPEND headers "inttypes.h")
1170 ENDIF(HAVE_INTTYPES_H)
1171 CHECK_SYMBOL_EXISTS(EFTYPE           "errno.h"    HAVE_EFTYPE)
1172 CHECK_SYMBOL_EXISTS(EILSEQ           "errno.h"    HAVE_EILSEQ)
1173 CHECK_SYMBOL_EXISTS(D_MD_ORDER       "langinfo.h" HAVE_D_MD_ORDER)
1174 CHECK_SYMBOL_EXISTS(INT64_MAX        "${headers}" HAVE_DECL_INT64_MAX)
1175 CHECK_SYMBOL_EXISTS(INT64_MIN        "${headers}" HAVE_DECL_INT64_MIN)
1176 CHECK_SYMBOL_EXISTS(UINT32_MAX       "${headers}" HAVE_DECL_UINT32_MAX)
1177 CHECK_SYMBOL_EXISTS(UINT64_MAX       "${headers}" HAVE_DECL_UINT64_MAX)
1178 CHECK_SYMBOL_EXISTS(SIZE_MAX         "${headers}" HAVE_DECL_SIZE_MAX)
1179 CHECK_SYMBOL_EXISTS(SSIZE_MAX        "limits.h"   HAVE_DECL_SSIZE_MAX)
1180
1181 #
1182 # Check struct members
1183 #
1184 # Check for tm_gmtoff in struct tm
1185 CHECK_STRUCT_MEMBER("struct tm" tm_gmtoff
1186     "time.h" HAVE_STRUCT_TM_TM_GMTOFF)
1187 CHECK_STRUCT_MEMBER("struct tm" __tm_gmtoff
1188     "time.h" HAVE_STRUCT_TM___TM_GMTOFF)
1189
1190 # Check for f_namemax in struct statfs
1191 CHECK_STRUCT_MEMBER("struct statfs" f_namemax
1192     "sys/param.h;sys/mount.h" HAVE_STRUCT_STATFS_F_NAMEMAX)
1193
1194 # Check for birthtime in struct stat
1195 CHECK_STRUCT_MEMBER("struct stat" st_birthtime
1196     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIME)
1197
1198 # Check for high-resolution timestamps in struct stat
1199 CHECK_STRUCT_MEMBER("struct stat" st_birthtimespec.tv_nsec
1200     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
1201 CHECK_STRUCT_MEMBER("struct stat" st_mtimespec.tv_nsec
1202     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
1203 CHECK_STRUCT_MEMBER("struct stat" st_mtim.tv_nsec
1204     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
1205 CHECK_STRUCT_MEMBER("struct stat" st_mtime_n
1206     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_N)
1207 CHECK_STRUCT_MEMBER("struct stat" st_umtime
1208     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_UMTIME)
1209 CHECK_STRUCT_MEMBER("struct stat" st_mtime_usec
1210     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_USEC)
1211 # Check for block size support in struct stat
1212 CHECK_STRUCT_MEMBER("struct stat" st_blksize
1213     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BLKSIZE)
1214 # Check for st_flags in struct stat (BSD fflags)
1215 CHECK_STRUCT_MEMBER("struct stat" st_flags
1216     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_FLAGS)
1217
1218 IF(HAVE_SYS_STATVFS_H)
1219   CHECK_STRUCT_MEMBER("struct statvfs" f_iosize
1220     "sys/types.h;sys/statvfs.h" HAVE_STRUCT_STATVFS_F_IOSIZE)
1221 ENDIF()
1222
1223 #
1224 #
1225 CHECK_STRUCT_MEMBER("struct tm" tm_sec
1226     "sys/types.h;sys/time.h;time.h" TIME_WITH_SYS_TIME)
1227
1228 #
1229 # Check for integer types
1230 #
1231 #
1232 CHECK_TYPE_SIZE("short" SIZE_OF_SHORT)
1233 CHECK_TYPE_SIZE("int" SIZE_OF_INT)
1234 CHECK_TYPE_SIZE("long" SIZE_OF_LONG)
1235 CHECK_TYPE_SIZE("long long"     SIZE_OF_LONG_LONG)
1236
1237 CHECK_TYPE_SIZE("unsigned short" SIZE_OF_UNSIGNED_SHORT)
1238 CHECK_TYPE_SIZE("unsigned" SIZE_OF_UNSIGNED)
1239 CHECK_TYPE_SIZE("unsigned long" SIZE_OF_UNSIGNED_LONG)
1240 CHECK_TYPE_SIZE("unsigned long long" SIZE_OF_UNSIGNED_LONG_LONG)
1241
1242 CHECK_TYPE_SIZE("__int64" __INT64)
1243 CHECK_TYPE_SIZE("unsigned __int64" UNSIGNED___INT64)
1244
1245 CHECK_TYPE_SIZE(int16_t INT16_T)
1246 CHECK_TYPE_SIZE(int32_t INT32_T)
1247 CHECK_TYPE_SIZE(int64_t INT64_T)
1248 CHECK_TYPE_SIZE(intmax_t INTMAX_T)
1249 CHECK_TYPE_SIZE(uint8_t UINT8_T)
1250 CHECK_TYPE_SIZE(uint16_t UINT16_T)
1251 CHECK_TYPE_SIZE(uint32_t UINT32_T)
1252 CHECK_TYPE_SIZE(uint64_t UINT64_T)
1253 CHECK_TYPE_SIZE(uintmax_t UINTMAX_T)
1254
1255 CHECK_TYPE_SIZE(dev_t       DEV_T)
1256 IF(NOT HAVE_DEV_T)
1257   IF(MSVC)
1258     SET(dev_t "unsigned int")
1259   ENDIF(MSVC)
1260 ENDIF(NOT HAVE_DEV_T)
1261 #
1262 CHECK_TYPE_SIZE(gid_t       GID_T)
1263 IF(NOT HAVE_GID_T)
1264   IF(WIN32)
1265     SET(gid_t "short")
1266   ELSE(WIN32)
1267     SET(gid_t "unsigned int")
1268   ENDIF(WIN32)
1269 ENDIF(NOT HAVE_GID_T)
1270 #
1271 CHECK_TYPE_SIZE(id_t        ID_T)
1272 IF(NOT HAVE_ID_T)
1273   IF(WIN32)
1274     SET(id_t "short")
1275   ELSE(WIN32)
1276     SET(id_t "unsigned int")
1277   ENDIF(WIN32)
1278 ENDIF(NOT HAVE_ID_T)
1279 #
1280 CHECK_TYPE_SIZE(mode_t      MODE_T)
1281 IF(NOT HAVE_MODE_T)
1282   IF(WIN32)
1283     SET(mode_t "unsigned short")
1284   ELSE(WIN32)
1285     SET(mode_t "int")
1286   ENDIF(WIN32)
1287 ENDIF(NOT HAVE_MODE_T)
1288 #
1289 CHECK_TYPE_SIZE(off_t       OFF_T)
1290 IF(NOT HAVE_OFF_T)
1291   SET(off_t "__int64")
1292 ENDIF(NOT HAVE_OFF_T)
1293 #
1294 CHECK_TYPE_SIZE(size_t      SIZE_T)
1295 IF(NOT HAVE_SIZE_T)
1296   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1297     SET(size_t "uint64_t")
1298   ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1299     SET(size_t   "uint32_t")
1300   ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1301 ENDIF(NOT HAVE_SIZE_T)
1302 #
1303 CHECK_TYPE_SIZE(ssize_t     SSIZE_T)
1304 IF(NOT HAVE_SSIZE_T)
1305   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1306     SET(ssize_t "int64_t")
1307   ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1308     SET(ssize_t "long")
1309   ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1310 ENDIF(NOT HAVE_SSIZE_T)
1311 #
1312 CHECK_TYPE_SIZE(uid_t       UID_T)
1313 IF(NOT HAVE_UID_T)
1314   IF(WIN32)
1315     SET(uid_t "short")
1316   ELSE(WIN32)
1317     SET(uid_t "unsigned int")
1318   ENDIF(WIN32)
1319 ENDIF(NOT HAVE_UID_T)
1320 #
1321 CHECK_TYPE_SIZE(pid_t       PID_T)
1322 IF(NOT HAVE_PID_T)
1323   IF(WIN32)
1324     SET(pid_t "int")
1325   ELSE(WIN32)
1326     MESSAGE(FATAL_ERROR "pid_t doesn't exist on this platform?")
1327   ENDIF(WIN32)
1328 ENDIF(NOT HAVE_PID_T)
1329 #
1330 CHECK_TYPE_SIZE(intptr_t   INTPTR_T)
1331 IF(NOT HAVE_INTPTR_T)
1332   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1333     SET(intptr_t "int64_t")
1334   ELSE()
1335     SET(intptr_t "int32_t")
1336   ENDIF()
1337 ENDIF(NOT HAVE_INTPTR_T)
1338 #
1339 CHECK_TYPE_SIZE(uintptr_t   UINTPTR_T)
1340 IF(NOT HAVE_UINTPTR_T)
1341   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1342     SET(uintptr_t "uint64_t")
1343   ELSE()
1344     SET(uintptr_t "uint32_t")
1345   ENDIF()
1346 ENDIF(NOT HAVE_UINTPTR_T)
1347 #
1348 CHECK_TYPE_SIZE(wchar_t     SIZEOF_WCHAR_T)
1349 IF(HAVE_SIZEOF_WCHAR_T)
1350   SET(HAVE_WCHAR_T 1)
1351 ENDIF(HAVE_SIZEOF_WCHAR_T)
1352 #
1353 # Check if _FILE_OFFSET_BITS macro needed for large files
1354 #
1355 CHECK_FILE_OFFSET_BITS()
1356
1357 #
1358 # Check for Extended Attribute libraries, headers, and functions
1359 #
1360 IF(ENABLE_XATTR)
1361   LA_CHECK_INCLUDE_FILE(attr/xattr.h     HAVE_ATTR_XATTR_H)
1362   LA_CHECK_INCLUDE_FILE(sys/xattr.h      HAVE_SYS_XATTR_H)
1363   LA_CHECK_INCLUDE_FILE(sys/extattr.h      HAVE_SYS_EXTATTR_H)
1364   CHECK_LIBRARY_EXISTS(attr "setxattr" "" HAVE_LIBATTR)
1365   IF(HAVE_LIBATTR)
1366     SET(CMAKE_REQUIRED_LIBRARIES "attr")
1367   ENDIF(HAVE_LIBATTR)
1368   CHECK_SYMBOL_EXISTS(EXTATTR_NAMESPACE_USER "sys/types.h;sys/extattr.h" HAVE_DECL_EXTATTR_NAMESPACE_USER)
1369   CHECK_FUNCTION_EXISTS_GLIBC(extattr_get_file HAVE_EXTATTR_GET_FILE)
1370   CHECK_FUNCTION_EXISTS_GLIBC(extattr_list_file HAVE_EXTATTR_LIST_FILE)
1371   CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_fd HAVE_EXTATTR_SET_FD)
1372   CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_file HAVE_EXTATTR_SET_FILE)
1373   CHECK_FUNCTION_EXISTS_GLIBC(fgetxattr HAVE_FGETXATTR)
1374   CHECK_FUNCTION_EXISTS_GLIBC(flistxattr HAVE_FLISTXATTR)
1375   CHECK_FUNCTION_EXISTS_GLIBC(fsetxattr HAVE_FSETXATTR)
1376   CHECK_FUNCTION_EXISTS_GLIBC(getxattr HAVE_GETXATTR)
1377   CHECK_FUNCTION_EXISTS_GLIBC(lgetxattr HAVE_LGETXATTR)
1378   CHECK_FUNCTION_EXISTS_GLIBC(listxattr HAVE_LISTXATTR)
1379   CHECK_FUNCTION_EXISTS_GLIBC(llistxattr HAVE_LLISTXATTR)
1380   CHECK_FUNCTION_EXISTS_GLIBC(lsetxattr HAVE_LSETXATTR)
1381   CHECK_FUNCTION_EXISTS_GLIBC(fgetea HAVE_FGETEA)
1382   CHECK_FUNCTION_EXISTS_GLIBC(flistea HAVE_FLISTEA)
1383   CHECK_FUNCTION_EXISTS_GLIBC(fsetea HAVE_FSETEA)
1384   CHECK_FUNCTION_EXISTS_GLIBC(getea HAVE_GETEA)
1385   CHECK_FUNCTION_EXISTS_GLIBC(lgetea HAVE_LGETEA)
1386   CHECK_FUNCTION_EXISTS_GLIBC(listea HAVE_LISTEA)
1387   CHECK_FUNCTION_EXISTS_GLIBC(llistea HAVE_LLISTEA)
1388   CHECK_FUNCTION_EXISTS_GLIBC(lsetea HAVE_LSETEA)
1389 ELSE(ENABLE_XATTR)
1390   SET(HAVE_ATTR_LIB FALSE)
1391   SET(HAVE_ATTR_XATTR_H FALSE)
1392   SET(HAVE_DECL_EXTATTR_NAMESPACE_USER FALSE)
1393   SET(HAVE_EXTATTR_GET_FILE FALSE)
1394   SET(HAVE_EXTATTR_LIST_FILE FALSE)
1395   SET(HAVE_EXTATTR_SET_FD FALSE)
1396   SET(HAVE_EXTATTR_SET_FILE FALSE)
1397   SET(HAVE_FGETEA FALSE)
1398   SET(HAVE_FGETXATTR FALSE)
1399   SET(HAVE_FLISTEA FALSE)
1400   SET(HAVE_FLISTXATTR FALSE)
1401   SET(HAVE_FSETEA FALSE)
1402   SET(HAVE_FSETXATTR FALSE)
1403   SET(HAVE_GETEA FALSE)
1404   SET(HAVE_GETXATTR FALSE)
1405   SET(HAVE_LGETEA FALSE)
1406   SET(HAVE_LGETXATTR FALSE)
1407   SET(HAVE_LISTEA FALSE)
1408   SET(HAVE_LISTXATTR FALSE)
1409   SET(HAVE_LLISTEA FALSE)
1410   SET(HAVE_LLISTXATTR FALSE)
1411   SET(HAVE_LSETEA FALSE)
1412   SET(HAVE_LSETXATTR FALSE)
1413   SET(HAVE_SYS_EXTATTR_H FALSE)
1414   SET(HAVE_SYS_XATTR_H FALSE)
1415 ENDIF(ENABLE_XATTR)
1416
1417 #
1418 # Check for ACL libraries, headers, and functions
1419 #
1420 # The ACL support in libarchive is written against the POSIX1e draft,
1421 # which was never officially approved and varies quite a bit across
1422 # platforms.  Worse, some systems have completely non-POSIX acl functions,
1423 # which makes the following checks rather more complex than I would like.
1424 #
1425 IF(ENABLE_ACL)
1426   CHECK_LIBRARY_EXISTS(acl "acl_get_file" "" HAVE_LIBACL)
1427   IF(HAVE_LIBACL)
1428     SET(CMAKE_REQUIRED_LIBRARIES "acl")
1429     FIND_LIBRARY(ACL_LIBRARY NAMES acl)
1430     LIST(APPEND ADDITIONAL_LIBS ${ACL_LIBRARY})
1431   ENDIF(HAVE_LIBACL)
1432   #
1433   CHECK_FUNCTION_EXISTS_GLIBC(acl_create_entry HAVE_ACL_CREATE_ENTRY)
1434   CHECK_FUNCTION_EXISTS_GLIBC(acl_init HAVE_ACL_INIT)
1435   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd HAVE_ACL_SET_FD)
1436   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd_np HAVE_ACL_SET_FD_NP)
1437   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_file HAVE_ACL_SET_FILE)
1438   CHECK_TYPE_EXISTS(acl_permset_t "${INCLUDES}"    HAVE_ACL_PERMSET_T)
1439
1440   # The "acl_get_perm()" function was omitted from the POSIX draft.
1441   # (It's a pretty obvious oversight; otherwise, there's no way to
1442   # test for specific permissions in a permset.)  Linux uses the obvious
1443   # name, FreeBSD adds _np to mark it as "non-Posix extension."
1444   # Test for both as a double-check that we really have POSIX-style ACL support.
1445   CHECK_FUNCTION_EXISTS(acl_get_perm HAVE_ACL_GET_PERM)
1446   CHECK_FUNCTION_EXISTS(acl_get_perm_np HAVE_ACL_GET_PERM_NP)
1447   CHECK_FUNCTION_EXISTS(acl_get_link HAVE_ACL_GET_LINK)
1448   CHECK_FUNCTION_EXISTS(acl_get_link_np HAVE_ACL_GET_LINK_NP)
1449   CHECK_FUNCTION_EXISTS(acl_is_trivial_np HAVE_ACL_IS_TRIVIAL_NP)
1450   CHECK_FUNCTION_EXISTS(acl_set_link_np HAVE_ACL_SET_LINK_NP)
1451
1452   # MacOS has an acl.h that isn't POSIX.  It can be detected by
1453   # checking for ACL_USER
1454   CHECK_SYMBOL_EXISTS(ACL_USER "${INCLUDES}" HAVE_ACL_USER)
1455 ELSE(ENABLE_ACL)
1456   # If someone runs cmake, then disables ACL support, we need
1457   # to forcibly override the cached values for these.
1458   SET(HAVE_ACL_CREATE_ENTRY FALSE)
1459   SET(HAVE_ACL_GET_LINK FALSE)
1460   SET(HAVE_ACL_GET_LINK_NP FALSE)
1461   SET(HAVE_ACL_GET_PERM FALSE)
1462   SET(HAVE_ACL_GET_PERM_NP FALSE)
1463   SET(HAVE_ACL_INIT FALSE)
1464   SET(HAVE_ACL_LIB FALSE)
1465   SET(HAVE_ACL_PERMSET_T FALSE)
1466   SET(HAVE_ACL_SET_FD FALSE)
1467   SET(HAVE_ACL_SET_FD_NP FALSE)
1468   SET(HAVE_ACL_SET_FILE FALSE)
1469   SET(HAVE_ACL_USER FALSE)
1470 ENDIF(ENABLE_ACL)
1471
1472 #
1473 # Check MD5/RMD160/SHA support
1474 # NOTE: Crypto checks must be run last before generating config.h
1475 #
1476 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" LIBC)
1477 CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC2)
1478 CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC3)
1479 CHECK_CRYPTO("MD5;SHA1;SHA256;SHA384;SHA512" LIBSYSTEM)
1480 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" NETTLE)
1481 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" OPENSSL)
1482
1483 # Libmd has to be probed after OpenSSL.
1484 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA512" LIBMD)
1485
1486 CHECK_CRYPTO_WIN("MD5;SHA1;SHA256;SHA384;SHA512")
1487
1488 # Generate "config.h" from "build/cmake/config.h.in"
1489 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
1490         ${CMAKE_CURRENT_BINARY_DIR}/config.h)
1491 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
1492 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
1493
1494 #
1495 # Register installation of PDF documents.
1496 #
1497 IF(WIN32 AND NOT CYGWIN)
1498   #
1499   # On Windows platform, It's better that we install PDF documents
1500   # on one's computer.
1501   # These PDF documents are available in the release package.
1502   #
1503   IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf)
1504     INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf
1505             DESTINATION share/man
1506             FILES_MATCHING PATTERN "*.pdf"
1507     )
1508   ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf)
1509 ENDIF(WIN32 AND NOT CYGWIN)
1510 #
1511 #
1512 #
1513 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/libarchive)
1514 #
1515 IF(MSVC)
1516   ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
1517 ENDIF(MSVC)
1518
1519 IF(ENABLE_TEST)
1520   ADD_CUSTOM_TARGET(run_all_tests)
1521 ENDIF(ENABLE_TEST)
1522
1523 add_subdirectory(libarchive)
1524 add_subdirectory(tar)
1525 add_subdirectory(cpio)