CMakeLists.txt 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495
  1. # Determines what CMake APIs we can rely on
  2. cmake_minimum_required (VERSION 2.8.11)
  3. if (${CMAKE_VERSION} VERSION_GREATER 3.2.2)
  4. cmake_policy(VERSION 3.2.2)
  5. endif()
  6. if (${CMAKE_VERSION} VERSION_GREATER 3.1 OR
  7. ${CMAKE_VERSION} VERSION_EQUAL 3.1)
  8. cmake_policy(SET CMP0054 NEW)
  9. endif()
  10. # Do not allow in source builds
  11. set(CMAKE_DISABLE_SOURCE_CHANGES ON)
  12. set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
  13. # Make sure we can import out CMake functions
  14. list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
  15. # Load in the needed CMake modules
  16. include(CheckIncludeFiles)
  17. include(CheckCCompilerFlag)
  18. include(CheckCXXCompilerFlag)
  19. include(AddCCompilerFlag)
  20. include(AddCXXCompilerFlag)
  21. include(DetermineTargetArchitecture)
  22. include(CMakeDependentOption)
  23. # Set up the project
  24. project (civetweb)
  25. set(CIVETWEB_VERSION "1.10.0" CACHE STRING "The version of the civetweb library")
  26. string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CIVETWEB_VERSION_MATCH "${CIVETWEB_VERSION}")
  27. if ("${CIVETWEB_VERSION_MATCH}" STREQUAL "")
  28. message(FATAL_ERROR "Must specify a semantic version: major.minor.patch")
  29. endif()
  30. set(CIVETWEB_VERSION_MAJOR "${CMAKE_MATCH_1}")
  31. set(CIVETWEB_VERSION_MINOR "${CMAKE_MATCH_2}")
  32. set(CIVETWEB_VERSION_PATCH "${CMAKE_MATCH_3}")
  33. determine_target_architecture(CIVETWEB_ARCHITECTURE)
  34. # Detect the platform reliably
  35. if(NOT MACOSX AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
  36. SET(DARWIN YES)
  37. elseif(NOT BSD AND ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
  38. SET(FREEBSD YES)
  39. elseif(NOT LINUX AND ${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  40. SET(LINUX YES)
  41. endif()
  42. # C++ wrappers
  43. option(CIVETWEB_ENABLE_THIRD_PARTY_OUTPUT "Shows the output of third party dependency processing" OFF)
  44. # Thread Stack Size
  45. set(CIVETWEB_THREAD_STACK_SIZE 102400 CACHE STRING
  46. "The stack size in bytes for each thread created")
  47. set_property(CACHE CIVETWEB_THREAD_STACK_SIZE PROPERTY VALUE ${CIVETWEB_THREAD_STACK_SIZE})
  48. message(STATUS "Thread Stack Size - ${CIVETWEB_THREAD_STACK_SIZE}")
  49. # Serve no files from the web server
  50. option(CIVETWEB_SERVE_NO_FILES "Configures the server to serve no static files" OFF)
  51. message(STATUS "Serve no static files - ${CIVETWEB_SERVE_NO_FILES}")
  52. # Serve no files from the web server
  53. option(CIVETWEB_DISABLE_CGI "Disables CGI, so theserver will not execute CGI scripts" OFF)
  54. message(STATUS "Disable CGI support - ${CIVETWEB_DISABLE_CGI}")
  55. # Disable caching
  56. option(CIVETWEB_DISABLE_CACHING "Disables caching, so that no timegm is used." OFF)
  57. message(STATUS "Disable caching support - ${CIVETWEB_DISABLE_CACHING}")
  58. # C++ wrappers
  59. option(CIVETWEB_ENABLE_CXX "Enables the C++ wrapper library" OFF)
  60. message(STATUS "C++ wrappers - ${CIVETWEB_ENABLE_CXX}")
  61. # IP Version 6
  62. option(CIVETWEB_ENABLE_IPV6 "Enables the IP version 6 support" OFF)
  63. message(STATUS "IP Version 6 - ${CIVETWEB_ENABLE_IPV6}")
  64. # Websocket support
  65. option(CIVETWEB_ENABLE_WEBSOCKETS "Enable websockets connections" OFF)
  66. message(STATUS "Websockets support - ${CIVETWEB_ENABLE_WEBSOCKETS}")
  67. # Server statistics support
  68. option(CIVETWEB_ENABLE_SERVER_STATS "Enable server statistics" OFF)
  69. message(STATUS "Server statistics support - ${CIVETWEB_ENABLE_SERVER_STATS}")
  70. # Memory debugging
  71. option(CIVETWEB_ENABLE_MEMORY_DEBUGGING "Enable the memory debugging features" OFF)
  72. message(STATUS "Memory Debugging - ${CIVETWEB_ENABLE_MEMORY_DEBUGGING}")
  73. # ASAN in debug mode (-fsanitize=address, etc)
  74. option(CIVETWEB_ENABLE_ASAN "Enable ASAN in debug mode" ON)
  75. message(STATUS "ASAN in debug mode - ${CIVETWEB_ENABLE_ASAN}")
  76. # ARCH flag
  77. option(CIVETWEB_ARCH "Force 32/64 bit architecture" OFF)
  78. message(STATUS "Force x32 / x64 architecture - ${CIVETWEB_ARCH}")
  79. # LUA CGI support
  80. option(CIVETWEB_ENABLE_LUA "Enable Lua CGIs" OFF)
  81. message(STATUS "Lua CGI support - ${CIVETWEB_ENABLE_LUA}")
  82. # Enable installing CivetWeb executables
  83. option(CIVETWEB_INSTALL_EXECUTABLE "Enable installing CivetWeb executable" ON)
  84. mark_as_advanced(FORCE CIVETWEB_INSTALL_EXECUTABLE) # Advanced users can disable
  85. message(STATUS "Executable installation - ${CIVETWEB_INSTALL_EXECUTABLE}")
  86. # Allow builds to complete with warnings (do not set -Werror)
  87. if (LINUX)
  88. # CivetWeb Linux support is stable: Builds must be free from warnings.
  89. option(CIVETWEB_ALLOW_WARNINGS "Do not stop build if there are warnings" OFF)
  90. else()
  91. # CivetWeb Linux support for other systems is in a setup phase.
  92. option(CIVETWEB_ALLOW_WARNINGS "Do not stop build if there are warnings" ON)
  93. endif()
  94. message(STATUS "Build if there are warnings - ${CIVETWEB_ALLOW_WARNINGS}")
  95. # Link to the shared LUA library
  96. cmake_dependent_option(
  97. CIVETWEB_ENABLE_LUA_SHARED "Link to the shared LUA system library" OFF
  98. CIVETWEB_ENABLE_LUA OFF)
  99. if (CIVETWEB_ENABLE_LUA)
  100. message(STATUS "Linking shared Lua library - ${CIVETWEB_ENABLE_LUA_SHARED}")
  101. endif()
  102. # Lua Third Party Settings
  103. if (CIVETWEB_ENABLE_LUA)
  104. if (NOT CIVETWEB_ENABLE_LUA_SHARED)
  105. # Lua Version
  106. set(CIVETWEB_LUA_VERSION 5.2.4 CACHE STRING
  107. "The version of Lua to build and include statically")
  108. set_property(CACHE CIVETWEB_LUA_VERSION PROPERTY VALUE ${CIVETWEB_LUA_VERSION})
  109. message(STATUS "Lua Version - ${CIVETWEB_LUA_VERSION}")
  110. mark_as_advanced(CIVETWEB_LUA_VERSION)
  111. # Lua Verification Hash
  112. set(CIVETWEB_LUA_MD5_HASH 913fdb32207046b273fdb17aad70be13 CACHE STRING
  113. "The hash of Lua archive to be downloaded")
  114. set_property(CACHE CIVETWEB_LUA_MD5_HASH PROPERTY VALUE ${CIVETWEB_LUA_MD5_HASH})
  115. mark_as_advanced(CIVETWEB_LUA_MD5_HASH)
  116. endif()
  117. # Lua Filesystem Version
  118. set(CIVETWEB_LUA_FILESYSTEM_VERSION 1.6.3 CACHE STRING
  119. "The version of Lua Filesystem to build and include statically")
  120. set_property(CACHE CIVETWEB_LUA_FILESYSTEM_VERSION PROPERTY VALUE ${CIVETWEB_LUA_FILESYSTEM_VERSION})
  121. message(STATUS "Lua Filesystem Version - ${CIVETWEB_LUA_FILESYSTEM_VERSION}")
  122. mark_as_advanced(CIVETWEB_LUA_FILESYSTEM_VERSION)
  123. # Lua Filesystem Verification Hash
  124. set(CIVETWEB_LUA_FILESYSTEM_MD5_HASH d0552c7e5a082f5bb2865af63fb9dc95 CACHE STRING
  125. "The hash of Lua Filesystem archive to be downloaded")
  126. set_property(CACHE CIVETWEB_LUA_FILESYSTEM_MD5_HASH PROPERTY VALUE ${CIVETWEB_LUA_FILESYSTEM_MD5_HASH})
  127. mark_as_advanced(CIVETWEB_LUA_FILESYSTEM_MD5_HASH)
  128. # Lua SQLite Version
  129. set(CIVETWEB_LUA_SQLITE_VERSION 0.9.3 CACHE STRING
  130. "The version of Lua SQLite to build and include statically")
  131. set_property(CACHE CIVETWEB_LUA_SQLITE_VERSION PROPERTY VALUE ${CIVETWEB_LUA_SQLITE_VERSION})
  132. message(STATUS "Lua SQLite Version - ${CIVETWEB_LUA_SQLITE_VERSION}")
  133. mark_as_advanced(CIVETWEB_LUA_SQLITE_VERSION)
  134. # Lua SQLite Verification Hash
  135. set(CIVETWEB_LUA_SQLITE_MD5_HASH 43234ae08197dfce6da02482ed14ec92 CACHE STRING
  136. "The hash of Lua SQLite archive to be downloaded")
  137. set_property(CACHE CIVETWEB_LUA_SQLITE_MD5_HASH PROPERTY VALUE ${CIVETWEB_LUA_SQLITE_MD5_HASH})
  138. mark_as_advanced(CIVETWEB_LUA_SQLITE_MD5_HASH)
  139. # Lua XML Version
  140. set(CIVETWEB_LUA_XML_VERSION 1.8.0 CACHE STRING
  141. "The version of Lua XML to build and include statically")
  142. set_property(CACHE CIVETWEB_LUA_XML_VERSION PROPERTY VALUE ${CIVETWEB_LUA_XML_VERSION})
  143. message(STATUS "Lua XML Version - ${CIVETWEB_LUA_XML_VERSION}")
  144. mark_as_advanced(CIVETWEB_LUA_XML_VERSION)
  145. # Lua XML Verification Hash
  146. set(CIVETWEB_LUA_XML_MD5_HASH 25e4c276c5d8716af1de0c7853aec2b4 CACHE STRING
  147. "The hash of Lua XML archive to be downloaded")
  148. set_property(CACHE CIVETWEB_LUA_XML_MD5_HASH PROPERTY VALUE ${CIVETWEB_LUA_XML_MD5_HASH})
  149. mark_as_advanced(CIVETWEB_LUA_XML_MD5_HASH)
  150. # SQLite Version
  151. set(CIVETWEB_SQLITE_VERSION 3.8.9 CACHE STRING
  152. "The version of SQLite to build and include statically")
  153. set_property(CACHE CIVETWEB_SQLITE_VERSION PROPERTY VALUE ${CIVETWEB_SQLITE_VERSION})
  154. message(STATUS "SQLite Version - ${CIVETWEB_SQLITE_VERSION}")
  155. mark_as_advanced(CIVETWEB_SQLITE_VERSION)
  156. # SQLite Verification Hash
  157. set(CIVETWEB_SQLITE_MD5_HASH 02e9c3a6daa8b8587cf6bef828c2e33f CACHE STRING
  158. "The hash of SQLite archive to be downloaded")
  159. set_property(CACHE CIVETWEB_SQLITE_MD5_HASH PROPERTY VALUE ${CIVETWEB_SQLITE_MD5_HASH})
  160. mark_as_advanced(CIVETWEB_SQLITE_MD5_HASH)
  161. endif()
  162. # Duktape CGI support
  163. option(CIVETWEB_ENABLE_DUKTAPE "Enable Duktape CGIs" OFF)
  164. message(STATUS "Duktape CGI support - ${CIVETWEB_ENABLE_DUKTAPE}")
  165. # SSL support
  166. option(CIVETWEB_ENABLE_SSL "Enables the secure socket layer" ON)
  167. message(STATUS "SSL support - ${CIVETWEB_ENABLE_SSL}")
  168. # OpenSSL 1.1 API
  169. option(CIVETWEB_SSL_OPENSSL_API_1_1 "Use the OpenSSL 1.1 API" OFF)
  170. message(STATUS "Compile for OpenSSL 1.1 API - ${CIVETWEB_SSL_OPENSSL_API_1_1}")
  171. # Dynamically load or link the SSL libraries
  172. cmake_dependent_option(
  173. CIVETWEB_ENABLE_SSL_DYNAMIC_LOADING "Dynamically loads the SSL library rather than linking it" ON
  174. CIVETWEB_ENABLE_SSL OFF)
  175. if (CIVETWEB_ENABLE_SSL)
  176. message(STATUS "Dynamically load SSL libraries - ${CIVETWEB_ENABLE_SSL_DYNAMIC_LOADING}")
  177. endif()
  178. # Third Party Download location
  179. set(CIVETWEB_THIRD_PARTY_DIR "${CMAKE_BINARY_DIR}/third_party" CACHE STRING
  180. "The location that third party code is downloaded, built and installed")
  181. set_property(CACHE CIVETWEB_THIRD_PARTY_DIR PROPERTY VALUE ${CIVETWEB_THIRD_PARTY_DIR})
  182. # Unix systems can define the dynamic library names to load
  183. if (CIVETWEB_ENABLE_SSL_DYNAMIC_LOADING AND NOT DARWIN AND UNIX)
  184. # SSL library name
  185. set(CIVETWEB_SSL_SSL_LIB "libssl.so" CACHE STRING
  186. "The name of the SSL library to load")
  187. set_property(CACHE CIVETWEB_SSL_SSL_LIB PROPERTY VALUE ${CIVETWEB_SSL_SSL_LIB})
  188. message(STATUS "SSL Library Name - ${CIVETWEB_SSL_SSL_LIB}")
  189. # Crytography library name
  190. set(CIVETWEB_SSL_CRYPTO_LIB "libcrypto.so" CACHE STRING
  191. "The name of the SSL Cryptography library to load")
  192. set_property(CACHE CIVETWEB_SSL_CRYPTO_LIB PROPERTY VALUE ${CIVETWEB_SSL_CRYPTO_LIB})
  193. message(STATUS "SSL Cryptography Library Name - ${CIVETWEB_SSL_CRYPTO_LIB}")
  194. endif()
  195. # Allow warnings in 3rd party components
  196. if (CIVETWEB_ENABLE_LUA OR CIVETWEB_ENABLE_DUKTAPE)
  197. SET(CIVETWEB_ALLOW_WARNINGS YES)
  198. endif()
  199. # The C and C++ standards to use
  200. set(CIVETWEB_C_STANDARD auto CACHE STRING
  201. "The C standard to use; auto determines the latest supported by the compiler")
  202. set_property(CACHE CIVETWEB_C_STANDARD PROPERTY STRINGS auto c11 c99 c89)
  203. set(CIVETWEB_CXX_STANDARD auto CACHE STRING
  204. "The C++ standard to use; auto determines the latest supported by the compiler")
  205. set_property(CACHE CIVETWEB_CXX_STANDARD PROPERTY STRINGS auto c++14 c++11 c++98)
  206. # Configure the linker
  207. if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
  208. find_program(GCC_AR gcc-ar)
  209. if (GCC_AR)
  210. set(CMAKE_AR ${GCC_AR})
  211. endif()
  212. find_program(GCC_RANLIB gcc-ranlib)
  213. if (GCC_RANLIB)
  214. set(CMAKE_RANLIB ${GCC_RANLIB})
  215. endif()
  216. endif()
  217. # Configure the C compiler
  218. message(STATUS "Configuring C Compiler")
  219. if ("${CIVETWEB_C_STANDARD}" STREQUAL "auto")
  220. add_c_compiler_flag(-std=c11)
  221. if (NOT HAVE_C_FLAG_STD_C11)
  222. add_c_compiler_flag(-std=c99)
  223. if (NOT HAVE_C_FLAG_STD_C99)
  224. add_c_compiler_flag(-std=c89)
  225. endif()
  226. endif()
  227. else()
  228. add_c_compiler_flag(-std=${CIVETWEB_C_STANDARD})
  229. endif()
  230. add_c_compiler_flag(-Wall)
  231. add_c_compiler_flag(-Wextra)
  232. add_c_compiler_flag(-Wshadow)
  233. add_c_compiler_flag(-Wconversion)
  234. add_c_compiler_flag(-Wmissing-prototypes)
  235. add_c_compiler_flag(-Weverything)
  236. add_c_compiler_flag(/W4)
  237. add_c_compiler_flag(-Wno-padded)
  238. add_c_compiler_flag(/Wd4820) # padding
  239. add_c_compiler_flag(-Wno-unused-macros)
  240. add_c_compiler_flag(-Wno-format-nonliteral)
  241. add_c_compiler_flag(-Wno-date-time)
  242. add_c_compiler_flag(-Wparentheses)
  243. if (MINGW)
  244. add_c_compiler_flag(-Wno-format)
  245. endif()
  246. if (NOT CIVETWEB_ALLOW_WARNINGS)
  247. add_c_compiler_flag(-Werror)
  248. endif()
  249. add_c_compiler_flag(/WX)
  250. add_c_compiler_flag(-pedantic-errors)
  251. add_c_compiler_flag(-fvisibility=hidden)
  252. add_c_compiler_flag(-fstack-protector-strong RELEASE)
  253. add_c_compiler_flag(-flto RELEASE)
  254. if (${CIVETWEB_ENABLE_ASAN})
  255. add_c_compiler_flag(-fsanitize=undefined DEBUG)
  256. add_c_compiler_flag(-fsanitize=address DEBUG)
  257. if (HAVE_C_FLAG_FSANITIZE_ADDRESS)
  258. add_c_compiler_flag(-static-asan DEBUG)
  259. endif()
  260. endif()
  261. add_c_compiler_flag(-fstack-protector-all DEBUG)
  262. if (MINGW)
  263. add_c_compiler_flag(-mwindows)
  264. endif()
  265. # Coverage build type
  266. set(CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_DEBUG}" CACHE STRING
  267. "Flags used by the C compiler during coverage builds."
  268. FORCE)
  269. set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
  270. "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
  271. "Flags used for linking binaries during coverage builds."
  272. FORCE)
  273. set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
  274. "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
  275. "Flags used by the shared libraries linker during coverage builds."
  276. FORCE)
  277. mark_as_advanced(
  278. CMAKE_CXX_FLAGS_COVERAGE
  279. CMAKE_C_FLAGS_COVERAGE
  280. CMAKE_EXE_LINKER_FLAGS_COVERAGE
  281. CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
  282. set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
  283. "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage."
  284. FORCE)
  285. add_c_compiler_flag(--coverage COVERAGE)
  286. # Configure the C++ compiler
  287. if (CIVETWEB_ENABLE_CXX)
  288. message(STATUS "Configuring C++ Compiler")
  289. if ("${CIVETWEB_CXX_STANDARD}" STREQUAL "auto")
  290. add_cxx_compiler_flag(-std=c++14)
  291. if (NOT HAVE_CXX_FLAG_STD_CXX14)
  292. add_cxx_compiler_flag(-std=c++11)
  293. if (NOT HAVE_CXX_FLAG_STD_CXX11)
  294. add_cxx_compiler_flag(-std=c++98)
  295. endif()
  296. endif()
  297. else()
  298. add_cxx_compiler_flag(-std=${CIVETWEB_CXX_STANDARD})
  299. endif()
  300. add_cxx_compiler_flag(-Wall)
  301. add_cxx_compiler_flag(-Wextra)
  302. add_cxx_compiler_flag(-Wshadow)
  303. add_cxx_compiler_flag(-Wmissing-prototypes)
  304. add_cxx_compiler_flag(-Weverything)
  305. add_cxx_compiler_flag(/W4)
  306. add_cxx_compiler_flag(-Wno-padded)
  307. add_cxx_compiler_flag(/Wd4820) # padding
  308. add_cxx_compiler_flag(-Wno-unused-macros)
  309. add_cxx_compiler_flag(-Wno-format-nonliteral)
  310. if (MINGW)
  311. add_cxx_compiler_flag(-Wno-format)
  312. endif()
  313. if (NOT CIVETWEB_ALLOW_WARNINGS)
  314. add_cxx_compiler_flag(-Werror)
  315. endif()
  316. add_cxx_compiler_flag(/WX)
  317. add_cxx_compiler_flag(-pedantic-errors)
  318. add_cxx_compiler_flag(-fvisibility=hidden)
  319. add_cxx_compiler_flag(-fstack-protector-strong RELEASE)
  320. add_cxx_compiler_flag(-flto RELEASE)
  321. if (${CIVETWEB_ENABLE_ASAN})
  322. add_cxx_compiler_flag(-fsanitize=undefined DEBUG)
  323. add_cxx_compiler_flag(-fsanitize=address DEBUG)
  324. if (HAVE_CXX_FLAG_FSANITIZE_ADDRESS)
  325. add_cxx_compiler_flag(-static-asan DEBUG)
  326. endif()
  327. endif()
  328. add_cxx_compiler_flag(-fstack-protector-all DEBUG)
  329. if (MINGW)
  330. add_cxx_compiler_flag(-mwindows)
  331. endif()
  332. set(CMAKE_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING
  333. "Flags used by the C++ compiler during coverage builds."
  334. FORCE)
  335. add_cxx_compiler_flag(--coverage COVERAGE)
  336. endif()
  337. # Set up the definitions
  338. if (${CMAKE_BUILD_TYPE} MATCHES "[Dd]ebug")
  339. add_definitions(-DDEBUG)
  340. endif()
  341. if (CIVETWEB_ENABLE_IPV6)
  342. add_definitions(-DUSE_IPV6)
  343. endif()
  344. if (CIVETWEB_ENABLE_WEBSOCKETS)
  345. add_definitions(-DUSE_WEBSOCKET)
  346. endif()
  347. if (CIVETWEB_ENABLE_SERVER_STATS)
  348. add_definitions(-DUSE_SERVER_STATS)
  349. endif()
  350. if (CIVETWEB_SERVE_NO_FILES)
  351. add_definitions(-DNO_FILES)
  352. endif()
  353. if (CIVETWEB_DISABLE_CGI)
  354. add_definitions(-DNO_CGI)
  355. endif()
  356. if (CIVETWEB_DISABLE_CACHING)
  357. add_definitions(-DNO_CACHING)
  358. endif()
  359. if (CIVETWEB_ENABLE_LUA)
  360. add_definitions(-DUSE_LUA)
  361. endif()
  362. if (CIVETWEB_ENABLE_DUKTAPE)
  363. add_definitions(-DUSE_DUKTAPE)
  364. endif()
  365. if (CIVETWEB_ENABLE_MEMORY_DEBUGGING)
  366. add_definitions(-DMEMORY_DEBUGGING)
  367. endif()
  368. if (NOT CIVETWEB_ENABLE_SSL)
  369. add_definitions(-DNO_SSL)
  370. elseif (NOT CIVETWEB_ENABLE_SSL_DYNAMIC_LOADING)
  371. add_definitions(-DNO_SSL_DL)
  372. else()
  373. if(CIVETWEB_SSL_SSL_LIB)
  374. add_definitions(-DSSL_LIB="${CIVETWEB_SSL_SSL_LIB}")
  375. endif()
  376. if(CIVETWEB_SSL_CRYPTO_LIB)
  377. add_definitions(-DCRYPTO_LIB="${CIVETWEB_SSL_CRYPTO_LIB}")
  378. endif()
  379. endif()
  380. if(CIVETWEB_SSL_OPENSSL_API_1_1)
  381. add_definitions(-DOPENSSL_API_1_1)
  382. endif()
  383. add_definitions(-DUSE_STACK_SIZE=${CIVETWEB_THREAD_STACK_SIZE})
  384. # Set 32 or 64 bit environment
  385. if (${CMAKE_ARCH} MATCHES "[Xx]86")
  386. add_c_compiler_flag(-m32)
  387. endif()
  388. if (${CMAKE_ARCH} MATCHES "[Xx]64")
  389. add_c_compiler_flag(-m64)
  390. endif()
  391. # TODO: add support for -march
  392. # Build the targets
  393. add_subdirectory(src)
  394. # Enable the testing of the library/executable
  395. include(CTest)
  396. if (BUILD_TESTING)
  397. # Check unit testing framework Version
  398. set(CIVETWEB_CHECK_VERSION 0.11.0 CACHE STRING
  399. "The version of Check unit testing framework to build and include statically")
  400. set_property(CACHE CIVETWEB_CHECK_VERSION PROPERTY VALUE ${CIVETWEB_CHECK_VERSION})
  401. message(STATUS "Check Unit Testing Framework Version - ${CIVETWEB_CHECK_VERSION}")
  402. mark_as_advanced(CIVETWEB_CHECK_VERSION)
  403. # Check unit testing framework Verification Hash
  404. # Hash for Check 0.10.0: 67a34c40b5bc888737f4e5ae82e9939f
  405. # Hash for Check 0.11.0: 1b14ee307dca8e954a8219c34484d7c4
  406. set(CIVETWEB_CHECK_MD5_HASH 1b14ee307dca8e954a8219c34484d7c4 CACHE STRING
  407. "The hash of Check unit testing framework archive to be downloaded")
  408. set_property(CACHE CIVETWEB_CHECK_MD5_HASH PROPERTY VALUE ${CIVETWEB_CHECK_MD5_HASH})
  409. mark_as_advanced(CIVETWEB_CHECK_MD5_HASH)
  410. # Build the testing
  411. add_subdirectory(test)
  412. endif()
  413. # Set up CPack
  414. include(InstallRequiredSystemLibraries)
  415. set(CPACK_PACKAGE_VENDOR "civetweb Contributors")
  416. set(CPACK_PACKAGE_CONTACT "civetweb@github.com")
  417. set(CPACK_PACKAGE_VERSION_MAJOR "${CIVETWEB_VERSION_MAJOR}")
  418. set(CPACK_PACKAGE_VERSION_MINOR "${CIVETWEB_VERSION_MINOR}")
  419. set(CPACK_PACKAGE_VERSION_PATCH "${CIVETWEB_VERSION_PATCH}")
  420. set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "A HTTP library and server")
  421. set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
  422. set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")
  423. set(CPACK_STRIP_FILES TRUE)
  424. set(CPACK_PACKAGE_DEPENDS "openssl")
  425. if (CIVETWEB_ENABLE_LUA_SHARED)
  426. set(CPACK_PACKAGE_DEPENDS "lua, ${CPACK_PACKAGE_DEPENDS}")
  427. endif()
  428. # RPM Packaging
  429. set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
  430. set(CPACK_RPM_PACKAGE_LICENSE "MIT")
  431. set(CPACK_RPM_PACKAGE_ARCHITECTURE "${CIVETWEB_ARCHITECTURE}")
  432. set(CPACK_RPM_PACKAGE_REQUIRES "${CPACK_PACKAGE_DEPENDS}")
  433. # Debian Packaging
  434. set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "${CIVETWEB_ARCHITECTURE}")
  435. set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://github.com/civetweb/civetweb")
  436. set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_PACKAGE_DEPENDS}")
  437. # WiX Packaging
  438. # TODO: www.cmake.org/cmake/help/v3.0/module/CPackWIX.html
  439. # Finalize CPack settings
  440. include(CPack)