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