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