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