CMakeLists.txt

   1 #
   2 # Libevent CMake project
   3 #
   4 # Based on initial work by:
   5 #    Alexey Ozeritsky
   6 #
   7 # Additional changes:
   8 #   Brodie Thiesfield
   9 #   Joakim Soderberg
  10 #   Trond Norbye
  11 #   Sergei Nikulov
  12 #
  13 #   Build example:
  14 #
  15 #       cd libevent
  16 #       md build
  17 #       cd build
  18 #       cmake -G "Visual Studio 10" ..
  19 #       start libevent.sln
  20 #
  21 cmake_minimum_required(VERSION 2.8.0 FATAL_ERROR)
  22
  23 if(NOT CMAKE_BUILD_TYPE)
  24     set(CMAKE_BUILD_TYPE Release
  25         CACHE STRING "Set build type to Debug o Release (default Release)" FORCE)
  26 endif()
  27
  28 # get rid of the extra default configurations
  29 # what? why would you get id of other useful build types? - Ellzey
  30 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Limited configurations" FORCE)
  31
  32 project(libevent C)
  33
  34 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/")
  35
  36
  37 include(CheckTypeSize)
  38 include(CheckFunctionExistsEx)
  39 include(CheckFileOffsetBits)
  40 include(CheckFunctionExists)
  41 include(CheckIncludeFile)
  42 include(CheckIncludeFiles)
  43 include(CheckVariableExists)
  44 include(CheckSymbolExists)
  45 include(CheckStructHasMember)
  46 include(CheckCSourceCompiles)
  47 include(CheckPrototypeDefinition)
  48 include(CheckFunctionKeywords)
  49 include(AddCompilerFlags)
  50 include(VersionViaGit)
  51
  52 event_fuzzy_version_from_git()
  53
  54 set(EVENT_VERSION_MAJOR ${EVENT_GIT___VERSION_MAJOR})
  55 set(EVENT_VERSION_MINOR ${EVENT_GIT___VERSION_MINOR})
  56 set(EVENT_VERSION_PATCH ${EVENT_GIT___VERSION_PATCH})
  57 set(EVENT_VERSION_STAGE ${EVENT_GIT___VERSION_STAGE})
  58
  59
  60 set(EVENT_ABI_MAJOR ${EVENT_VERSION_MAJOR})
  61 set(EVENT_ABI_MINOR ${EVENT_VERSION_MINOR})
  62 set(EVENT_ABI_PATCH ${EVENT_VERSION_PATCH})
  63
  64 set(EVENT_ABI_LIBVERSION
  65     "${EVENT_ABI_MAJOR}.${EVENT_ABI_MINOR}.${EVENT_ABI_PATCH}")
  66
  67 set(EVENT_PACKAGE_VERSION
  68     "${EVENT_VERSION_MAJOR}.${EVENT_VERSION_MINOR}.${EVENT_VERSION_PATCH}")
  69
  70 set(EVENT_NUMERIC_VERSION 0x02010500)
  71
  72 # only a subset of names can be used, defaults to "beta"
  73 set(EVENT_STAGE_NAME ${EVENT_VERSION_STAGE}
  74         CACHE STRING "set the stage name (beta|alpha|release)")
  75
  76 # a list that defines what can set for EVENT_STAGE_VERSION
  77 set(EVENT__ALLOWED_STAGE_NAMES
  78     rc
  79     beta
  80     alpha
  81     release)
  82
  83 # attempt to find the EVENT__STAGE_VERSION in the allowed list
  84 # of accepted stage names, the return value is stord in
  85 # EVENT__STAGE_RET
  86
  87 list(FIND EVENT__ALLOWED_STAGE_NAMES
  88         ${EVENT_STAGE_NAME}
  89         EVENT__STAGE_RET)
  90
  91 if (EVENT__STAGE_RET EQUAL "-1")
  92         set(EVENT_STAGE_NAME beta)
  93 endif()
  94
  95 set(EVENT_VERSION
  96         "${EVENT_VERSION_MAJOR}.${EVENT_VERSION_MINOR}.${EVENT_VERSION_PATCH}-${EVENT_STAGE_NAME}")
  97
  98 option(EVENT__BUILD_SHARED_LIBRARIES
  99     "Define if libevent should be built with shared libraries instead of archives" OFF)
 100
 101 option(EVENT__DISABLE_DEBUG_MODE
 102     "Define if libevent should build without support for a debug mode" OFF)
 103
 104 option(EVENT__ENABLE_VERBOSE_DEBUG
 105     "Enables verbose debugging" OFF)
 106
 107 option(EVENT__DISABLE_MM_REPLACEMENT
 108     "Define if libevent should not allow replacing the mm functions" OFF)
 109
 110 option(EVENT__DISABLE_THREAD_SUPPORT
 111     "Define if libevent should not be compiled with thread support" OFF)
 112
 113 option(EVENT__DISABLE_OPENSSL
 114     "Define if libevent should build without support for OpenSSL encrpytion" OFF)
 115
 116 option(EVENT__DISABLE_BENCHMARK
 117     "Defines if libevent should build without the benchmark exectuables" OFF)
 118
 119 option(EVENT__DISABLE_TESTS
 120     "If tests should be compiled or not" OFF)
 121
 122 option(EVENT__DISABLE_REGRESS
 123     "Disable the regress tests" OFF)
 124
 125 option(EVENT__DISABLE_SAMPLES
 126     "Disable sample files" OFF)
 127
 128 option(EVENT__FORCE_KQUEUE_CHECK
 129     "When crosscompiling forces running a test program that verifies that Kqueue works with pipes. Note that this requires you to manually run the test program on the the cross compilation target to verify that it works. See cmake documentation for try_run for more details" OFF)
 130
 131 # TODO: Add --disable-largefile     omit support for large files
 132 option(EVENT__COVERAGE
 133 "Enable running gcov to get a test coverage report (only works with GCC/CLang). Make sure to enable -DCMAKE_BUILD_TYPE=Debug as well." OFF)
 134
 135 # Put the libaries and binaries that get built into directories at the
 136 # top of the build tree rather than in hard-to-find leaf directories.
 137 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 138 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 139 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 140
 141 if (EVENT__ENABLE_VERBOSE_DEBUG)
 142     add_definitions(-DUSE_DBUG=1)
 143 endif()
 144
 145 # Setup compiler flags for coverage.
 146 if (EVENT__COVERAGE)
 147     if ((NOT CMAKE_COMPILER_IS_GNUCC) AND (NOT ${CMAKE_CXX_COMPILER_ID} STREQAL "Clang"))
 148             message(FATAL_ERROR"Trying to compile coverage support,  but compiler is not GNU gcc! Try CC=/usr/bin/gcc CXX=/usr/bin/g++ cmake <options> ..")
 149     endif()
 150
 151     if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
 152         message(FATAL_ERROR "Coverage requires -DCMAKE_BUILD_TYPE=Debug")
 153     endif()
 154
 155     message(STATUS "Setting coverage compiler flags")
 156         add_compiler_flags(-g -O0 -fprofile-arcs -ftest-coverage)
 157 endif()
 158
 159 # GCC specific options.
 160 if (CMAKE_COMPILER_IS_GNUCC)
 161     option(EVENT__DISABLE_GCC_WARNINGS "Disable verbose warnings with GCC" OFF)
 162     option(EVENT__ENABLE_GCC_HARDENING "Enable compiler security checks" OFF)
 163     option(EVENT__ENABLE_GCC_FUNCTION_SECTIONS "Enable gcc function sections" OFF)
 164     option(EVENT__ENABLE_GCC_WARNINGS "Make all GCC warnings into errors" OFF)
 165
 166         list(APPEND __FLAGS -Wall)
 167
 168     if (EVENT__DISABLE_GCC_WARNINGS)
 169             list(APPEND __FLAGS -w)
 170     endif()
 171
 172     if (EVENT__ENABLE_GCC_HARDENING)
 173             list(APPEND __FLAGS
 174                 -fstack-protector-all
 175                 -fwrapv
 176                 -fPIE
 177                 -Wstack-protector
 178                 "--param ssp-buffer-size=1")
 179
 180                 add_definitions(-D_FORTIFY_SOURCE=2)
 181     endif()
 182
 183     if (EVENT__ENABLE_GCC_FUNCTION_SECTIONS)
 184             list(APPEND __FLAGS -ffunction-sections)
 185         # TODO: Add --gc-sections support. We need some checks for NetBSD to ensure this works.
 186     endif()
 187
 188     if (EVENT__ENABLE_GCC_WARNINGS)
 189             list(APPEND __FLAGS -Werror)
 190     endif()
 191
 192     # We need to test for at least gcc 2.95 here, because older versions don't
 193     # have -fno-strict-aliasing
 194         list(APPEND __FLAGS -fno-strict-aliasing)
 195
 196         add_compiler_flags(__FLAGS)
 197 endif()
 198
 199 if (APPLE)
 200     # Get rid of deprecated warnings for OpenSSL on OSX 10.7 and greater.
 201         add_compiler_flags(
 202             -Wno-error=deprecated-declarations
 203             -Qunused-arguments)
 204 endif()
 205
 206 # Winsock.
 207 if(WIN32)
 208     set(CMAKE_EXTRA_INCLUDE_FILES winsock2.h ws2tcpip.h)
 209     set(CMAKE_REQUIRED_LIBRARIES  ws2_32.lib)
 210     set(CMAKE_REQUIRED_DEFINITIONS -FIwinsock2.h -FIws2tcpip.h)
 211 endif()
 212
 213 # Check if _GNU_SOURCE is available.
 214 CHECK_SYMBOL_EXISTS(__GNU_LIBRARY__ "features.h" _GNU_SOURCE)
 215
 216 if (_GNU_SOURCE)
 217     add_definitions(-D_GNU_SOURCE)
 218 endif()
 219
 220 CHECK_INCLUDE_FILE(sys/types.h EVENT__HAVE_SYS_TYPES_H)
 221 if(EVENT__HAVE_SYS_TYPES_H)
 222     list(APPEND CMAKE_EXTRA_INCLUDE_FILES sys/types.h)
 223 endif()
 224
 225 CHECK_INCLUDE_FILE(sys/socket.h EVENT__HAVE_SYS_SOCKET_H)
 226 if(EVENT__HAVE_SYS_SOCKET_H)
 227     list(APPEND CMAKE_EXTRA_INCLUDE_FILES sys/socket.h)
 228 endif()
 229
 230 CHECK_INCLUDE_FILE(netinet/in.h EVENT__HAVE_NETINET_IN_H)
 231 if(EVENT__HAVE_NETINET_IN_H)
 232     list(APPEND CMAKE_EXTRA_INCLUDE_FILES netinet/in.h)
 233 endif()
 234
 235 CHECK_INCLUDE_FILE(netinet/in6.h EVENT__HAVE_NETINET_IN6_H)
 236 if(EVENT__HAVE_NETINET_IN6_H)
 237     list(APPEND CMAKE_EXTRA_INCLUDE_FILES netinet/in6.h)
 238 endif()
 239
 240 CHECK_INCLUDE_FILE(unistd.h EVENT__HAVE_UNISTD_H)
 241 CHECK_INCLUDE_FILE(netdb.h EVENT__HAVE_NETDB_H)
 242 CHECK_INCLUDE_FILE(dlfcn.h EVENT__HAVE_DLFCN_H)
 243 CHECK_INCLUDE_FILE(arpa/inet.h EVENT__HAVE_ARPA_INET_H)
 244 CHECK_INCLUDE_FILE(fcntl.h EVENT__HAVE_FCNTL_H)
 245 if(EVENT__HAVE_FCNTL_H)
 246     list(APPEND CMAKE_EXTRA_INCLUDE_FILES fcntl.h)
 247 endif()
 248 CHECK_INCLUDE_FILE(inttypes.h EVENT__HAVE_INTTYPES_H)
 249 CHECK_INCLUDE_FILE(memory.h EVENT__HAVE_MEMORY_H)
 250 CHECK_INCLUDE_FILE(poll.h EVENT__HAVE_POLL_H)
 251 CHECK_INCLUDE_FILE(port.h EVENT__HAVE_PORT_H)
 252 if(EVENT__HAVE_PORT_H)
 253     list(APPEND CMAKE_EXTRA_INCLUDE_FILES port.h)
 254 endif()
 255 CHECK_INCLUDE_FILE(signal.h EVENT__HAVE_SIGNAL_H)
 256 CHECK_INCLUDE_FILE(stdarg.h EVENT__HAVE_STDARG_H)
 257 CHECK_INCLUDE_FILE(stddef.h EVENT__HAVE_STDDEF_H)
 258 CHECK_INCLUDE_FILE(stdint.h EVENT__HAVE_STDINT_H)
 259 CHECK_INCLUDE_FILE(stdlib.h EVENT__HAVE_STDLIB_H)
 260 CHECK_INCLUDE_FILE(strings.h EVENT__HAVE_STRINGS_H)
 261 CHECK_INCLUDE_FILE(string.h EVENT__HAVE_STRING_H)
 262 CHECK_INCLUDE_FILE(sys/devpoll.h EVENT__HAVE_SYS_DEVPOLL_H)
 263 CHECK_INCLUDE_FILE(sys/epoll.h EVENT__HAVE_SYS_EPOLL_H)
 264 CHECK_INCLUDE_FILE(sys/eventfd.h EVENT__HAVE_SYS_EVENTFD_H)
 265 CHECK_INCLUDE_FILE(sys/event.h EVENT__HAVE_SYS_EVENT_H)
 266 CHECK_INCLUDE_FILE(sys/ioctl.h EVENT__HAVE_SYS_IOCTL_H)
 267 CHECK_INCLUDE_FILE(sys/mman.h EVENT__HAVE_SYS_MMAN_H)
 268 CHECK_INCLUDE_FILE(sys/param.h EVENT__HAVE_SYS_PARAM_H)
 269 CHECK_INCLUDE_FILE(sys/queue.h EVENT__HAVE_SYS_QUEUE_H)
 270 CHECK_INCLUDE_FILE(sys/select.h EVENT__HAVE_SYS_SELECT_H)
 271 CHECK_INCLUDE_FILE(sys/sendfile.h EVENT__HAVE_SYS_SENDFILE_H)
 272 CHECK_INCLUDE_FILE(sys/stat.h EVENT__HAVE_SYS_STAT_H)
 273 CHECK_INCLUDE_FILE(sys/time.h EVENT__HAVE_SYS_TIME_H)
 274 if(EVENT__HAVE_SYS_TIME_H)
 275     list(APPEND CMAKE_EXTRA_INCLUDE_FILES sys/time.h)
 276 endif()
 277 CHECK_INCLUDE_FILE(sys/uio.h EVENT__HAVE_SYS_UIO_H)
 278 CHECK_INCLUDE_FILES("sys/types.h;ifaddrs.h" EVENT__HAVE_IFADDRS_H)
 279 CHECK_INCLUDE_FILE(mach/mach_time.h EVENT__HAVE_MACH_MACH_TIME_H)
 280 CHECK_INCLUDE_FILE(netdb.h EVENT__HAVE_NETDB_H)
 281 CHECK_INCLUDE_FILE(netinet/tcp.h EVENT__HAVE_NETINET_TCP_H)
 282 CHECK_INCLUDE_FILE(sys/wait.h EVENT__HAVE_SYS_WAIT_H)
 283 CHECK_INCLUDE_FILE(sys/resource.h EVENT__HAVE_SYS_RESOURCE_H)
 284 CHECK_INCLUDE_FILE(sys/sysctl.h EVENT__HAVE_SYS_SYSCTL_H)
 285 CHECK_INCLUDE_FILE(sys/timerfd.h EVENT__HAVE_SYS_TIMERFD_H)
 286
 287
 288 CHECK_FUNCTION_EXISTS_EX(epoll_create EVENT__HAVE_EPOLL)
 289 CHECK_FUNCTION_EXISTS_EX(epoll_ctl EVENT__HAVE_EPOLL_CTL)
 290 CHECK_FUNCTION_EXISTS_EX(eventfd EVENT__HAVE_EVENTFD)
 291 CHECK_FUNCTION_EXISTS_EX(clock_gettime EVENT__HAVE_CLOCK_GETTIME)
 292 CHECK_FUNCTION_EXISTS_EX(fcntl EVENT__HAVE_FCNTL)
 293 CHECK_FUNCTION_EXISTS_EX(getaddrinfo EVENT__HAVE_GETADDRINFO)
 294 CHECK_FUNCTION_EXISTS_EX(getnameinfo EVENT__HAVE_GETNAMEINFO)
 295 CHECK_FUNCTION_EXISTS_EX(gettimeofday EVENT__HAVE_GETTIMEOFDAY)
 296 CHECK_FUNCTION_EXISTS_EX(getprotobynumber EVENT__HAVE_GETPROTOBYNUMBER)
 297 CHECK_FUNCTION_EXISTS_EX(getservbyname EVENT__HAVE_GETSERVBYNAME)
 298 CHECK_FUNCTION_EXISTS_EX(inet_ntop EVENT__HAVE_INET_NTOP)
 299 CHECK_FUNCTION_EXISTS_EX(inet_pton EVENT__HAVE_INET_PTON)
 300 CHECK_FUNCTION_EXISTS_EX(kqueue EVENT__HAVE_KQUEUE)
 301 CHECK_FUNCTION_EXISTS_EX(mmap EVENT__HAVE_MMAP)
 302 CHECK_FUNCTION_EXISTS_EX(pipe EVENT__HAVE_PIPE)
 303 CHECK_FUNCTION_EXISTS_EX(pipe2 EVENT__HAVE_PIPE2)
 304 CHECK_FUNCTION_EXISTS_EX(poll EVENT__HAVE_POLL)
 305 CHECK_FUNCTION_EXISTS_EX(port_create EVENT__HAVE_PORT_CREATE)
 306 CHECK_FUNCTION_EXISTS_EX(sendfile EVENT__HAVE_SENDFILE)
 307 CHECK_FUNCTION_EXISTS_EX(sigaction EVENT__HAVE_SIGACTION)
 308 CHECK_FUNCTION_EXISTS_EX(signal EVENT__HAVE_SIGNAL)
 309 CHECK_FUNCTION_EXISTS_EX(splice EVENT__HAVE_SPLICE)
 310 CHECK_FUNCTION_EXISTS_EX(strlcpy EVENT__HAVE_STRLCPY)
 311 CHECK_FUNCTION_EXISTS_EX(strsep EVENT__HAVE_STRSEP)
 312 CHECK_FUNCTION_EXISTS_EX(strtok_r EVENT__HAVE_STRTOK_R)
 313 CHECK_FUNCTION_EXISTS_EX(strtoll EVENT__HAVE_STRTOLL)
 314 CHECK_FUNCTION_EXISTS_EX(vasprintf EVENT__HAVE_VASPRINTF)
 315 CHECK_FUNCTION_EXISTS_EX(sysctl EVENT__HAVE_SYSCTL)
 316 CHECK_FUNCTION_EXISTS_EX(accept4 EVENT__HAVE_ACCEPT4)
 317 CHECK_FUNCTION_EXISTS_EX(arc4random EVENT__HAVE_ARC4RANDOM)
 318 CHECK_FUNCTION_EXISTS_EX(arc4random_buf EVENT__HAVE_ARC4RANDOM_BUF)
 319 CHECK_FUNCTION_EXISTS_EX(epoll_create1 EVENT__HAVE_EPOLL_CREATE1)
 320 CHECK_FUNCTION_EXISTS_EX(getegid EVENT__HAVE_GETEGID)
 321 CHECK_FUNCTION_EXISTS_EX(geteuid EVENT__HAVE_GETEUID)
 322 CHECK_FUNCTION_EXISTS_EX(getifaddrs EVENT__HAVE_GETIFADDRS)
 323 CHECK_FUNCTION_EXISTS_EX(issetugid EVENT__HAVE_ISSETUGID)
 324 CHECK_FUNCTION_EXISTS_EX(mach_absolute_time EVENT__HAVE_MACH_ABSOLUTE_TIME)
 325 CHECK_FUNCTION_EXISTS_EX(nanosleep EVENT__HAVE_NANOSLEEP)
 326 CHECK_FUNCTION_EXISTS_EX(usleep EVENT__HAVE_USLEEP)
 327 CHECK_FUNCTION_EXISTS_EX(timeradd EVENT__HAVE_TIMERADD)
 328 CHECK_FUNCTION_EXISTS_EX(timerclear EVENT__HAVE_TIMERCLEAR)
 329 CHECK_FUNCTION_EXISTS_EX(timercmp EVENT__HAVE_TIMERCMP)
 330 CHECK_FUNCTION_EXISTS_EX(timerfd_create HAVE_TIMERFD_CREATE)
 331 CHECK_FUNCTION_EXISTS_EX(timerisset EVENT__HAVE_TIMERISSET)
 332 CHECK_FUNCTION_EXISTS_EX(putenv EVENT__HAVE_PUTENV)
 333 CHECK_FUNCTION_EXISTS_EX(setenv EVENT__HAVE_SETENV)
 334 CHECK_FUNCTION_EXISTS_EX(setrlimit EVENT__HAVE_SETRLIMIT)
 335 CHECK_FUNCTION_EXISTS_EX(umask EVENT__HAVE_UMASK)
 336 CHECK_FUNCTION_EXISTS_EX(unsetenv EVENT__HAVE_UNSETENV)
 337
 338 # Get the gethostbyname_r prototype.
 339 CHECK_FUNCTION_EXISTS_EX(gethostbyname_r EVENT__HAVE_GETHOSTBYNAME_R)
 340
 341 if(EVENT__HAVE_GETHOSTBYNAME_R)
 342     CHECK_PROTOTYPE_DEFINITION(gethostbyname_r
 343         "int gethostbyname_r(const char *name, struct hostent *hp, struct hostent_data *hdata)"
 344         "0"
 345         "netdb.h"
 346         EVENT__HAVE_GETHOSTBYNAME_R_3_ARG)
 347
 348     CHECK_PROTOTYPE_DEFINITION(gethostbyname_r
 349         "struct hostent *gethostbyname_r(const char *name, struct hostent *hp, char *buf, size_t buflen, int *herr)"
 350         "NULL"
 351         "netdb.h"
 352         EVENT__HAVE_GETHOSTBYNAME_R_5_ARG)
 353
 354     CHECK_PROTOTYPE_DEFINITION(gethostbyname_r
 355         "int gethostbyname_r(const char *name, struct hostent *hp, char *buf, size_t buflen, struct hostent **result, int *herr)"
 356         "0"
 357         "netdb.h"
 358         EVENT__HAVE_GETHOSTBYNAME_R_6_ARG)
 359 endif()
 360
 361 if(HAVE_PORT_H AND HAVE_PORT_CREATE)
 362     set(EVENT__HAVE_EVENT_PORTS 1)
 363 endif()
 364
 365 if(NOT WIN32)
 366     CHECK_FUNCTION_EXISTS_EX(select EVENT__HAVE_SELECT)
 367 endif()
 368
 369 CHECK_TYPE_SIZE("uint8_t" EVENT__HAVE_UINT8_T)
 370 CHECK_TYPE_SIZE("uint16_t" EVENT__HAVE_UINT16_T)
 371 CHECK_TYPE_SIZE("uint32_t" EVENT__HAVE_UINT32_T)
 372 CHECK_TYPE_SIZE("uint64_t" EVENT__HAVE_UINT64_T)
 373 CHECK_TYPE_SIZE("short" EVENT__SIZEOF_SHORT BUILTIN_TYPES_ONLY)
 374 CHECK_TYPE_SIZE("int" EVENT__SIZEOF_INT BUILTIN_TYPES_ONLY)
 375 CHECK_TYPE_SIZE("unsigned" EVENT__SIZEOF_UNSIGNED BUILTIN_TYPES_ONLY)
 376 CHECK_TYPE_SIZE("unsigned int" EVENT__SIZEOF_UNSIGNED_INT BUILTIN_TYPES_ONLY)
 377 CHECK_TYPE_SIZE("long" EVENT__SIZEOF_LONG BUILTIN_TYPES_ONLY)
 378 CHECK_TYPE_SIZE("long long" EVENT__SIZEOF_LONG_LONG BUILTIN_TYPES_ONLY)
 379
 380 if(WIN32)
 381     # These aren't available until Windows Vista.
 382     # But you can still link them. They just won't be found when running the exe.
 383     set(EVENT__HAVE_INET_NTOP 0)
 384     set(EVENT__HAVE_INET_PTON 0)
 385 endif()
 386
 387 # Check for different inline keyword versions.
 388 check_function_keywords("inline" "__inline" "__inline__")
 389
 390 if (HAVE_INLINE)
 391     set (EVENT__inline inline)
 392 elseif (HAVE___INLINE)
 393     set(EVENT__inline __inline)
 394 elseif(HAVE___INLINE__)
 395     set(EVENT__inline __inline__)
 396 else()
 397     set(EVENT__inline)
 398 endif()
 399
 400 CHECK_SYMBOL_EXISTS(TAILQ_FOREACH sys/queue.h EVENT__HAVE_TAILQFOREACH)
 401 CHECK_SYMBOL_EXISTS(CTL_KERN sys/sysctl.h EVENT__HAVE_DECL_CTL_KERN)
 402 CHECK_SYMBOL_EXISTS(KERN_ARND sys/sysctl.h EVENT__HAVE_DECL_KERN_ARND)
 403 CHECK_SYMBOL_EXISTS(KERN_RANDOM sys/sysctl.h EVENT__HAVE_DECL_KERN_RANDOM)
 404 CHECK_SYMBOL_EXISTS(RANDOM_UUID sys/sysctl.h EVENT__HAVE_DECL_RANDOM_UUID)
 405 CHECK_SYMBOL_EXISTS(F_SETFD fcntl.h EVENT__HAVE_SETFD)
 406
 407 CHECK_TYPE_SIZE(fd_mask EVENT__HAVE_FD_MASK)
 408
 409 CHECK_TYPE_SIZE(size_t EVENT__SIZEOF_SIZEE_T)
 410 if(NOT EVENT__SIZEOF_SIZE_T)
 411   set(EVENT__size_t "unsigned")
 412   set(EVENT__SIZEOF_SIZE_T ${EVENT__SIZEOF_UNSIGNED})
 413 else()
 414     set(EVENT__size_t size_t)
 415 endif()
 416
 417 CHECK_TYPE_SIZE("off_t" EVENT__SIZEOF_OFF_T LANGUAGE C)
 418
 419
 420 # XXX we should functionalize these size and type sets. --elley
 421
 422 # Winssck.
 423 set(SSIZE_TMAP_ssize_t "ssize_t")
 424 set(SSIZE_TMAP_SSIZE_T "SSIZE_T")
 425
 426 CHECK_TYPE_SIZE("ssize_t" EVENT__SIZEOF_SSIZE_T LANGUAGE C)
 427 CHECK_TYPE_SIZE("SSIZE_T" EVENT__SIZEOF_SSIZE_T LANGUAGE C)
 428
 429 if (DEFINED EVENT__SIZEOF_SSIZE_T)
 430         if (DEFINED SSIZE_TMAP_ssize_t)
 431                 set(EVENT__ssize_t "ssize_t")
 432         elseif (DEFINED SSIZE_TMAP_SSIZE_T)
 433                 set(EVENT__ssize_t "SSIZE_T")
 434         else()
 435                 set(EVENT__ssize_t "int")
 436                 set(EVENT__SIZEOF_SSIZE_T ${EVENT__SIZEOF_INT})
 437         endif()
 438 endif()
 439
 440
 441 CHECK_TYPE_SIZE(socklen_t EVENT__SIZEOF_SOCKLEN_T)
 442 if(NOT EVENT__SIZEOF_SOCKLEN_T)
 443   set(EVENT__socklen_t "unsigned int")
 444   set(EVENT__SIZEOF_SOCKLEN_T ${EVENT__SIZEOF_UNSIGNED_INT})
 445 else()
 446     set(EVENT__socklen_t "socklen_t")
 447 endif()
 448
 449 CHECK_TYPE_SIZE(pid_t EVENT__SIZEOF_PID_T)
 450 if(NOT EVENT__SIZEOF_PID_T)
 451   set(EVENT__pid_t "int")
 452   set(EVENT__SIZEOF_PID_T ${EVENT__SIZEOF_INT})
 453 else()
 454         set(EVENT__pid_t "pid_t")
 455         set(EVENT__SIZEOF_PID_T EVENT__SIZEOF_PID_T)
 456 endif()
 457
 458 if (NOT EVENT__DISABLE_THREAD_SUPPORT)
 459     CHECK_TYPE_SIZE(pthread_t EVENT__SIZEOF_PTHREAD_T)
 460 endif()
 461
 462 if(EVENT__HAVE_CLOCK_GETTIME)
 463   set(EVENT__DNS_USE_CPU_CLOCK_FOR_ID 1)
 464 endif()
 465
 466 # we're just getting lazy now.
 467 CHECK_TYPE_SIZE("uintptr_t" EVENT__HAVE_UINTPTR_T)
 468 CHECK_TYPE_SIZE("void *" EVENT__SIZEOF_VOID_P)
 469
 470 # Tests file offset bits.
 471 # TODO: Add AIX test for if -D_LARGE_FILES is needed.
 472
 473 # XXX: Why is this here? we don't even use it. Well, we don't even use it
 474 #      on top of that, why is it set in the config.h?! IT_MAKES_NO_SENSE
 475 #      I'm commenting it out for now.
 476 #      - ellzey
 477
 478 #CHECK_FILE_OFFSET_BITS()
 479 #set(EVENT___FILE_OFFSET_BITS _FILE_OFFSET_BITS)
 480
 481 # Verify kqueue works with pipes.
 482 if (EVENT__HAVE_KQUEUE)
 483     if (CMAKE_CROSSCOMPILING AND NOT EVENT__FORCE_KQUEUE_CHECK)
 484         message(WARNING "Cannot check if kqueue works with pipes when crosscompiling, use EVENT__FORCE_KQUEUE_CHECK to be sure (this requires manually running a test program on the cross compilation target)")
 485         set(EVENT__HAVE_WORKING_KQUEUE 1)
 486     else()
 487         message(STATUS "Checking if kqueue works with pipes...")
 488         include(CheckWorkingKqueue)
 489     endif()
 490 endif()
 491
 492 CHECK_SYMBOL_EXISTS(_MINIX "stdio.h" EVENT___MINIX)
 493 CHECK_SYMBOL_EXISTS(_POSIX_1_SOURCE "stdio.h" EVENT___POSIX_1_SOURCE)
 494 CHECK_SYMBOL_EXISTS(_POSIX_SOURCE "stdio.h" EVENT___POSIX_SOURCE)
 495
 496 if(EVENT__HAVE_NETDB_H)
 497     list(APPEND CMAKE_EXTRA_INCLUDE_FILES netdb.h)
 498     CHECK_TYPE_SIZE("struct addrinfo" EVENT__HAVE_STRUCT_ADDRINFO)
 499 elseif(WIN32)
 500     list(APPEND CMAKE_EXTRA_INCLUDE_FILES ws2tcpip.h)
 501     CHECK_TYPE_SIZE("struct addrinfo" EVENT__HAVE_STRUCT_ADDRINFO)
 502 endif()
 503
 504 # Check for sockaddr structure sizes.
 505 set(SOCKADDR_HEADERS)
 506 if (WIN32)
 507     set(CMAKE_REQUIRED_DEFINITIONS "-DWIN32_LEAN_AND_MEAN")
 508     if (_MSC_VER LESS 1300)
 509         set(SOCKADDR_HEADERS winsock.h)
 510     else()
 511         set(SOCKADDR_HEADERS winsock2.h ws2tcpip.h)
 512     endif()
 513 else()
 514     if (EVENT__HAVE_NETINET_IN_H)
 515         set(SOCKADDR_HEADERS ${SOCKADDR_HEADERS} netinet/in.h)
 516     endif()
 517
 518     if (EVENT__HAVE_NETINET_IN6_H)
 519         set(SOCKADDR_HEADERS ${SOCKADDR_HEADERS} netinet/in6.h)
 520     endif()
 521
 522     if (EVENT__HAVE_SYS_SOCKET_H)
 523         set(SOCKADDR_HEADERS ${SOCKADDR_HEADERS} sys/socket.h)
 524     endif()
 525
 526     if (EVENT__HAVE_NETDB_H)
 527         set(SOCKADDR_HEADERS ${SOCKADDR_HEADERS} netdb.h)
 528     endif()
 529 endif()
 530
 531 CHECK_TYPE_SIZE("struct in6_addr" EVENT__HAVE_STRUCT_IN6_ADDR)
 532 if(EVENT__HAVE_STRUCT_IN6_ADDR)
 533     CHECK_STRUCT_HAS_MEMBER("struct in6_addr"
 534             s6_addr16 "${SOCKADDR_HEADERS}"
 535             EVENT__HAVE_STRUCT_IN6_ADDR_S6_ADDR16)
 536
 537     CHECK_STRUCT_HAS_MEMBER("struct in6_addr"
 538             s6_addr32 "${SOCKADDR_HEADERS}"
 539             EVENT__HAVE_STRUCT_IN6_ADDR_S6_ADDR32)
 540 endif()
 541
 542 CHECK_TYPE_SIZE("sa_family_t" EVENT__HAVE_SA_FAMILY_T)
 543 CHECK_TYPE_SIZE("struct sockaddr_in6" EVENT__HAVE_STRUCT_SOCKADDR_IN6)
 544
 545 if(EVENT__HAVE_STRUCT_SOCKADDR_IN6)
 546     CHECK_STRUCT_HAS_MEMBER("struct sockaddr_in6"
 547             sin6_len "${SOCKADDR_HEADERS}"
 548             EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN)
 549
 550     CHECK_STRUCT_HAS_MEMBER("struct sockaddr_in6"
 551             sin_len "${SOCKADDR_HEADERS}"
 552             EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN)
 553 endif()
 554
 555 CHECK_TYPE_SIZE("struct sockaddr_storage" EVENT__HAVE_STRUCT_SOCKADDR_STORAGE)
 556 if(EVENT__HAVE_STRUCT_SOCKADDR_STORAGE)
 557     CHECK_STRUCT_HAS_MEMBER("struct sockaddr_storage"
 558             ss_family "${SOCKADDR_HEADERS}"
 559             EVENT__HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY)
 560
 561     CHECK_STRUCT_HAS_MEMBER("struct sockaddr_storage"
 562             __ss_family "${SOCKADDR_HEADERS}" EVENT__HAVE_STRUCT_SOCKADDR_STORAGE___SS_FAMILY)
 563 endif()
 564
 565 # Group the source files.
 566 set(HDR_PRIVATE
 567     bufferevent-internal.h
 568     changelist-internal.h
 569     defer-internal.h
 570     epolltable-internal.h
 571     evbuffer-internal.h
 572     event-internal.h
 573     evmap-internal.h
 574     evrpc-internal.h
 575     evsignal-internal.h
 576     evthread-internal.h
 577     ht-internal.h
 578     http-internal.h
 579     iocp-internal.h
 580     ipv6-internal.h
 581     log-internal.h
 582     minheap-internal.h
 583     mm-internal.h
 584     ratelim-internal.h
 585     strlcpy-internal.h
 586     util-internal.h
 587     evconfig-private.h
 588     compat/sys/queue.h)
 589
 590 set(HDR_COMPAT
 591     include/evdns.h
 592     include/evrpc.h
 593     include/event.h
 594     include/evhttp.h
 595     include/evutil.h)
 596
 597 set(HDR_PUBLIC
 598     include/event2/buffer.h
 599     include/event2/bufferevent.h
 600     include/event2/bufferevent_compat.h
 601     include/event2/bufferevent_struct.h
 602     include/event2/buffer_compat.h
 603     include/event2/dns.h
 604     include/event2/dns_compat.h
 605     include/event2/dns_struct.h
 606     include/event2/event.h
 607     include/event2/event_compat.h
 608     include/event2/event_struct.h
 609     include/event2/http.h
 610     include/event2/http_compat.h
 611     include/event2/http_struct.h
 612     include/event2/keyvalq_struct.h
 613     include/event2/listener.h
 614     include/event2/rpc.h
 615     include/event2/rpc_compat.h
 616     include/event2/rpc_struct.h
 617     include/event2/tag.h
 618     include/event2/tag_compat.h
 619     include/event2/thread.h
 620     include/event2/util.h
 621     include/event2/visibility.h
 622     ${PROJECT_BINARY_DIR}/include/event2/event-config.h)
 623
 624 set(SRC_CORE
 625     buffer.c
 626     bufferevent.c
 627     bufferevent_filter.c
 628     bufferevent_pair.c
 629     bufferevent_ratelim.c
 630     bufferevent_sock.c
 631     event.c
 632     evmap.c
 633     evthread.c
 634     evutil.c
 635     evutil_rand.c
 636     evutil_time.c
 637     listener.c
 638     log.c
 639     signal.c
 640     strlcpy.c)
 641
 642 if(EVENT__HAVE_SELECT)
 643     list(APPEND SRC_CORE select.c)
 644 endif()
 645
 646 if(EVENT__HAVE_POLL)
 647     list(APPEND SRC_CORE poll.c)
 648 endif()
 649
 650 if(EVENT__HAVE_KQUEUE)
 651     list(APPEND SRC_CORE kqueue.c)
 652 endif()
 653
 654 if(EVENT__HAVE_DEVPOLL)
 655     list(APPEND SRC_CORE devpoll.c)
 656 endif()
 657
 658 if(EVENT__HAVE_EPOLL)
 659     list(APPEND SRC_CORE epoll_sub.c epoll.c)
 660 endif()
 661
 662 if(EVENT__HAVE_EVENT_PORTS)
 663     list(APPEND SRC_CORE evport.c)
 664 endif()
 665
 666 if (NOT EVENT__DISABLE_OPENSSL)
 667     find_package(OpenSSL REQUIRED)
 668
 669     set(EVENT__HAVE_OPENSSL 1)
 670
 671     message(STATUS "OpenSSL include: ${OPENSSL_INCLUDE_DIR}")
 672     message(STATUS "OpenSSL lib: ${OPENSSL_LIBRARIES}")
 673
 674     include_directories(${OPENSSL_INCLUDE_DIR})
 675
 676     list(APPEND SRC_CORE bufferevent_openssl.c)
 677     list(APPEND HDR_PUBLIC include/event2/bufferevent_ssl.h)
 678     list(APPEND LIB_APPS ${OPENSSL_LIBRARIES})
 679 endif()
 680
 681 if (NOT EVENT__DISABLE_THREAD_SUPPORT)
 682     if (WIN32)
 683         list(APPEND SRC_CORE evthread_win32.c)
 684     else()
 685         find_package(Threads REQUIRED)
 686         if (NOT CMAKE_USE_PTHREADS_INIT)
 687             message(FATAL_ERROR
 688                             "Failed to find Pthreads, set EVENT__DISABLE_THREAD_SUPPORT to disable")
 689         endif()
 690
 691         set(EVENT__HAVE_PTHREADS 1)
 692         list(APPEND SRC_CORE evthread_pthread.c)
 693         list(APPEND LIB_APPS ${CMAKE_THREAD_LIBS_INIT})
 694     endif()
 695 endif()
 696
 697 if (NOT EVENT__DISABLE_TESTS)
 698     # Zlib is only used for testing.
 699     find_package(ZLIB)
 700
 701     if (ZLIB_LIBRARY)
 702         include_directories(${ZLIB_INCLUDE_DIRS})
 703
 704         set(EVENT__HAVE_ZLIB 1)
 705         set(EVENT__HAVE_ZLIB_H)
 706         list(APPEND LIB_APPS ${ZLIB_LIBRARIES})
 707     endif()
 708 endif()
 709
 710 set(SRC_EXTRA
 711     event_tagging.c
 712     http.c
 713     evdns.c
 714     evrpc.c)
 715
 716 add_definitions(-DHAVE_CONFIG_H)
 717
 718 # We use BEFORE here so we don't accidentally look in system directories
 719 # first for some previous versions of the headers that are installed.
 720 include_directories(BEFORE ${PROJECT_SOURCE_DIR}
 721     ${PROJECT_SOURCE_DIR}/compat
 722     ${PROJECT_SOURCE_DIR}/include)
 723
 724 if(WIN32)
 725     list(APPEND SRC_CORE
 726         buffer_iocp.c
 727         bufferevent_async.c
 728         event_iocp.c
 729         evthread_win32.c
 730         win32select.c)
 731
 732     list(APPEND HDR_PRIVATE WIN32-Code/getopt.h)
 733
 734     set(EVENT__DNS_USE_FTIME_FOR_ID 1)
 735     set(LIB_PLATFORM ws2_32)
 736     add_definitions(
 737             -D_CRT_SECURE_NO_WARNINGS
 738             -D_CRT_NONSTDC_NO_DEPRECATE)
 739
 740     include_directories(./WIN32-Code)
 741 endif()
 742
 743 if (UNIX)
 744     list(APPEND LIB_PLATFORM m)
 745 endif()
 746
 747 source_group("Headers Private"  FILES ${HDR_PRIVATE})
 748 source_group("Header Compat"    FILES ${HDR_COMPAT})
 749 source_group("Headers Public"   FILES ${HDR_PUBLIC})
 750 source_group("Source Core"      FILES ${SRC_CORE})
 751 source_group("Source Extra"     FILES ${SRC_EXTRA})
 752
 753 # Generate the configure headers.
 754 # (Place them in the build dir so we don't polute the source tree with generated files).
 755 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include)
 756
 757 if (EVENT__BUILD_SHARED_LIBRARIES)
 758   set(EVENT__LIBRARY_TYPE SHARED)
 759
 760   if ((CMAKE_COMPILER_IS_GNUCC) OR (${CMAKE_C_COMPILER_ID} STREQUAL "Clang"))
 761         add_compiler_flags(-fvisibility=hidden)
 762   elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "SunPro")
 763     add_compiler_flags(-xldscope=hidden)
 764   endif()
 765
 766   set(EVENT__NEED_DLLIMPORT 1)
 767 else (EVENT__BUILD_SHARED_LIBRARIES)
 768   set(EVENT__LIBRARY_TYPE STATIC)
 769 endif (EVENT__BUILD_SHARED_LIBRARIES)
 770
 771 configure_file(
 772     ${CMAKE_CURRENT_SOURCE_DIR}/event-config.h.cmake
 773     ${CMAKE_CURRENT_BINARY_DIR}/include/event2/event-config.h
 774         NEWLINE_STYLE UNIX)
 775
 776 configure_file(
 777     ${CMAKE_CURRENT_SOURCE_DIR}/evconfig-private.h.cmake
 778     ${CMAKE_CURRENT_BINARY_DIR}/include/evconfig-private.h)
 779
 780 #
 781 # Create the libraries.
 782 #
 783
 784 # TODO: Add dynamic versions of the libraries as well.
 785 add_library(event_core ${EVENT__LIBRARY_TYPE}
 786     ${HDR_PRIVATE}
 787     ${HDR_COMPAT}
 788     ${HDR_PUBLIC}
 789     ${SRC_CORE})
 790
 791 add_library(event_extra ${EVENT__LIBRARY_TYPE}
 792     ${HDR_PRIVATE}
 793     ${HDR_COMPAT}
 794     ${HDR_PUBLIC}
 795     ${SRC_CORE}
 796     ${SRC_EXTRA})
 797
 798 # library exists for historical reasons; it contains the contents of
 799 # both libevent_core and libevent_extra. You shouldn’t use it; it may
 800 # go away in a future version of Libevent.
 801 add_library(event ${EVENT__LIBRARY_TYPE}
 802     ${HDR_PRIVATE}
 803     ${HDR_COMPAT}
 804     ${HDR_PUBLIC}
 805     ${SRC_CORE}
 806     ${SRC_EXTRA})
 807
 808 if (EVENT__BUILD_SHARED_LIBRARIES)
 809     # Prepare static library to be linked to tests that need hidden symbols
 810     add_library(event_extra_static STATIC
 811         ${HDR_PRIVATE}
 812         ${HDR_COMPAT}
 813         ${HDR_PUBLIC}
 814         ${SRC_CORE}
 815         ${SRC_EXTRA})
 816
 817     set(EVENT_EXTRA_FOR_TEST event_extra_static)
 818
 819    target_link_libraries(event_core ${OPENSSL_LIBRARIES}
 820                                     ${CMAKE_THREAD_LIBS_INIT}
 821                                     ${LIB_PLATFORM})
 822
 823    target_link_libraries(event ${OPENSSL_LIBRARIES}
 824                                ${CMAKE_THREAD_LIBS_INIT}
 825                                ${LIB_PLATFORM})
 826
 827    target_link_libraries(event_extra ${OPENSSL_LIBRARIES}
 828                                       ${CMAKE_THREAD_LIBS_INIT}
 829                                       ${LIB_PLATFORM})
 830
 831   set_target_properties(event
 832         PROPERTIES SOVERSION
 833             ${EVENT_ABI_LIBVERSION})
 834
 835   set_target_properties(event_core
 836         PROPERTIES SOVERSION
 837             ${EVENT_ABI_LIBVERSION})
 838
 839   set_target_properties(event_extra
 840         PROPERTIES SOVERSION
 841             ${EVENT_ABI_LIBVERSION})
 842
 843 else (EVENT__BUILD_SHARED_LIBRARIES)
 844     set(EVENT_EXTRA_FOR_TEST event_extra)
 845 endif (EVENT__BUILD_SHARED_LIBRARIES)
 846
 847 #
 848 # Samples.
 849 #
 850
 851 if (NOT EVENT__DISABLE_SAMPLES)
 852     set(SAMPLES
 853         dns-example
 854         event-read-fifo
 855         hello-world
 856         signal-test
 857         http-server
 858         http-connect
 859         time-test)
 860
 861     if (NOT EVENT__DISABLE_OPENSSL AND OPENSSL_LIBRARIES)
 862         set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES})
 863         CHECK_FUNCTION_EXISTS_EX(ERR_remove_thread_state EVENT__HAVE_ERR_REMOVE_THREAD_STATE)
 864         set(CMAKE_REQUIRED_LIBRARIES "")
 865
 866         # Special sample with more than one file.
 867         add_executable(https-client
 868             sample/https-client.c
 869             sample/openssl_hostname_validation.c
 870             sample/hostcheck.c)
 871
 872         target_link_libraries(https-client
 873                     event_extra
 874                     ${LIB_APPS}
 875                     ${LIB_PLATFORM})
 876
 877         add_dependencies(https-client event_extra)
 878
 879         # Requires OpenSSL.
 880         list(APPEND SAMPLES le-proxy)
 881     endif()
 882
 883     foreach(SAMPLE ${SAMPLES})
 884         add_executable(${SAMPLE}
 885                     sample/${SAMPLE}.c)
 886
 887         target_link_libraries(${SAMPLE}
 888                     event_extra
 889                     ${LIB_APPS}
 890                     ${LIB_PLATFORM})
 891
 892         add_dependencies(${SAMPLE} event_extra)
 893     endforeach()
 894 endif()
 895
 896 if (NOT EVENT__DISABLE_BENCHMARK)
 897     foreach (BENCHMARK bench bench_cascade bench_http bench_httpclient)
 898         set(BENCH_SRC test/${BENCHMARK}.c)
 899
 900         if (WIN32)
 901             list(APPEND BENCH_SRC
 902                             WIN32-Code/getopt.c
 903                             WIN32-Code/getopt_long.c)
 904         endif()
 905
 906         add_executable(${BENCHMARK} ${BENCH_SRC})
 907
 908         target_link_libraries(${BENCHMARK}
 909                     event_extra
 910                     ${LIB_PLATFORM})
 911
 912         add_dependencies(${BENCHMARK} event_extra)
 913     endforeach()
 914 endif()
 915
 916 if (NOT EVENT__DISABLE_TESTS)
 917     #
 918     # Generate Regress tests.
 919     #
 920     if (NOT EVENT__DISABLE_REGRESS)
 921
 922         # (We require python to generate the regress tests)
 923         find_package(PythonInterp)
 924
 925         if (PYTHONINTERP_FOUND AND PYTHON_VERSION_STRING VERSION_LESS "3.0.0")
 926             set(__FOUND_USABLE_PYTHON 1)
 927         endif()
 928
 929         if (__FOUND_USABLE_PYTHON)
 930             message(STATUS "Generating regress tests...")
 931
 932             add_definitions(-DTINYTEST_LOCAL)
 933
 934             add_custom_command(
 935                 OUTPUT
 936                     ${CMAKE_CURRENT_SOURCE_DIR}/test/regress.gen.c
 937                     ${CMAKE_CURRENT_SOURCE_DIR}/test/regress.gen.h
 938                 DEPENDS
 939                     event_rpcgen.py
 940                     test/regress.rpc
 941                 COMMAND ${PYTHON_EXECUTABLE} ../event_rpcgen.py regress.rpc
 942                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
 943
 944             list(APPEND SRC_REGRESS
 945                 test/regress.c
 946                 test/regress.gen.c
 947                 test/regress.gen.h
 948                 test/regress_buffer.c
 949                 test/regress_bufferevent.c
 950                 test/regress_dns.c
 951                 test/regress_et.c
 952                 test/regress_finalize.c
 953                 test/regress_http.c
 954                 test/regress_listener.c
 955                 test/regress_main.c
 956                 test/regress_minheap.c
 957                 test/regress_rpc.c
 958                 test/regress_testutils.c
 959                 test/regress_testutils.h
 960                 test/regress_util.c
 961                 test/tinytest.c
 962                 ${SRC_CORE}
 963                 ${SRC_EXTRA})
 964
 965             if (WIN32)
 966                 list(APPEND SRC_REGRESS test/regress_iocp.c)
 967                 list(APPEND SRC_REGRESS test/regress_thread.c)
 968             endif()
 969
 970             if (CMAKE_USE_PTHREADS_INIT)
 971                 list(APPEND SRC_REGRESS test/regress_thread.c)
 972             endif()
 973
 974             if (ZLIB_LIBRARY)
 975                 list(APPEND SRC_REGRESS test/regress_zlib.c)
 976             endif()
 977
 978             if (OPENSSL_LIBRARIES)
 979                 list(APPEND SRC_REGRESS test/regress_ssl.c)
 980             endif()
 981
 982             add_executable(regress ${SRC_REGRESS})
 983
 984             # While building the test suite we don't want the visibility
 985             # header trying to "dllimport" the symbols on windows (it
 986             # generates a ton of warnings due to different link
 987             # attributes for all of the symbols)
 988             SET_TARGET_PROPERTIES(regress
 989                             PROPERTIES COMPILE_DEFINITIONS
 990               "EVENT_BUILDING_REGRESS_TEST=1")
 991
 992             target_link_libraries(regress
 993                             ${LIB_APPS}
 994                             ${LIB_PLATFORM})
 995         else()
 996             message(WARNING "No suitable Python interpreter found, cannot generate regress tests!")
 997         endif()
 998     endif()
 999
1000     #
1001     # Test programs.
1002     #
1003         # all of these, including the cmakelists.txt should be moved
1004         # into the dirctory 'tests' first.
1005         #
1006         # doing this, we can remove all the DISABLE_TESTS stuff, and simply
1007         # do something like:
1008         #
1009         # add_custom_targets(tests)
1010         # add_executable(... EXCLUDE_FROM_ALL ...c)
1011         # add_dependencis(tests testa testb testc)
1012         # add_test(....)
1013         #
1014         # then you can just run 'make tests' instead of them all
1015         # auto-compile|running
1016         # - ellzey
1017     set(TESTPROGS   test-changelist
1018                     test-eof
1019                     test-fdleak
1020                     test-init
1021                     test-time
1022                     test-weof)
1023
1024     set(ALL_TESTPROGS
1025             ${TESTPROGS}
1026             test-dumpevents
1027             test-ratelim)
1028
1029     # Create test program executables.
1030     foreach (TESTPROG ${ALL_TESTPROGS})
1031         add_executable(${TESTPROG}
1032                     test/${TESTPROG}.c)
1033
1034         target_link_libraries(${TESTPROG}
1035                     ${EVENT_EXTRA_FOR_TEST}
1036                     ${LIB_PLATFORM})
1037
1038         add_dependencies(${TESTPROG}
1039                     ${EVENT_EXTRA_FOR_TEST})
1040     endforeach()
1041
1042     #
1043     # We run all tests with the different backends turned on one at a time.
1044     #
1045
1046     # Add event backends based on system introspection result.
1047     set(BACKENDS "")
1048
1049     if (EVENT__HAVE_EPOLL)
1050         list(APPEND BACKENDS EPOLL)
1051     endif()
1052
1053     if (EVENT__HAVE_SELECT)
1054         list(APPEND BACKENDS SELECT)
1055     endif()
1056
1057     if (EVENT__HAVE_POLL)
1058         list(APPEND BACKENDS POLL)
1059     endif()
1060
1061     if (EVENT__HAVE_KQUEUE)
1062         list(APPEND BACKENDS KQUEUE)
1063     endif()
1064
1065     if (EVENT__HAVE_EVENT_PORTS)
1066         list(APPEND BACKENDS EVPORT)
1067     endif()
1068
1069     if (EVENT__HAVE_DEVPOLL)
1070         list(APPEND BACKENDS DEVPOLL)
1071     endif()
1072
1073     if (WIN32)
1074         list(APPEND BACKENDS WIN32)
1075     endif()
1076
1077
1078     # Default environment variables turns off all event systems,
1079     # then we enable each one, one at a time when creating the tests.
1080     set(DEFAULT_TEST_ENV_VARS "EVENT_SHOW_METHOD=1;")
1081     foreach(BACKEND ${BACKENDS})
1082         set(BACKEND_ENV_VAR "EVENT_NO${BACKEND}=1")
1083         list(APPEND DEFAULT_TEST_ENV_VARS "${BACKEND_ENV_VAR}")
1084     endforeach()
1085
1086     # Macro that creates the ctest test for a backend.
1087     macro(add_backend_test BACKEND_TEST_NAME ENV_VARS)
1088         set(TEST_NAMES "")
1089
1090         foreach (TESTPROG ${TESTPROGS})
1091             set(TEST_NAME ${TESTPROG}__${BACKEND_TEST_NAME})
1092
1093             add_test(${TEST_NAME}
1094                             ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTPROG})
1095
1096             list(APPEND TEST_NAMES ${TEST_NAME})
1097
1098             set_tests_properties(${TEST_NAME}
1099                             PROPERTIES ENVIRONMENT "${ENV_VARS}")
1100         endforeach()
1101
1102         # Dump events test.
1103         if (__FOUND_USABLE_PYTHON)
1104             set(TEST_NAME test-dumpevents__${BACKEND_TEST_NAME})
1105
1106             add_test(${TEST_NAME}
1107                             ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test-dumpevents |
1108                             ${PYTHON_EXECUTABLE}
1109                             ${CMAKE_CURRENT_SOURCE_DIR}/test/check-dumpevents.py)
1110
1111             set_tests_properties(${TEST_NAME}
1112                             PROPERTIES ENVIRONMENT "${ENV_VARS}")
1113         else()
1114             message(WARNING "test-dumpevents will be run without output check since python was not found!")
1115             set(TEST_NAME test-dumpevents__${BACKEND_TEST_NAME}_no_check)
1116
1117             add_test(${TEST_NAME}
1118                             ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test-dumpevents)
1119
1120             set_tests_properties(${TEST_NAME}
1121                             PROPERTIES ENVIRONMENT "${ENV_VARS}")
1122         endif()
1123
1124         # Regress tests.
1125         if (NOT EVENT__DISABLE_REGRESS AND __FOUND_USABLE_PYTHON)
1126             set(TEST_NAME regress__${BACKEND_TEST_NAME})
1127
1128             add_test(${TEST_NAME}
1129                             ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/regress)
1130
1131             set_tests_properties(${TEST_NAME}
1132                             PROPERTIES ENVIRONMENT "${ENV_VARS}")
1133
1134             add_test(${TEST_NAME}_debug
1135                             ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/regress)
1136
1137             set_tests_properties(${TEST_NAME}_debug
1138                             PROPERTIES ENVIRONMENT "${ENV_VARS};EVENT_DEBUG_MODE=1")
1139         endif()
1140     endmacro()
1141
1142     # Add the tests for each backend.
1143     foreach(BACKEND ${BACKENDS})
1144         # Enable this backend only.
1145         set(BACKEND_ENV_VARS ${DEFAULT_TEST_ENV_VARS})
1146         list(REMOVE_ITEM BACKEND_ENV_VARS EVENT_NO${BACKEND}=1)
1147
1148         # Epoll has some extra settings.
1149         if (${BACKEND} STREQUAL "EPOLL")
1150             add_backend_test(timerfd_${BACKEND}
1151                             "${BACKEND_ENV_VARS};EVENT_PRECISE_TIMER=1")
1152
1153             add_backend_test(changelist_${BACKEND}
1154                             "${BACKEND_ENV_VARS};EVENT_EPOLL_USE_CHANGELIST=yes")
1155
1156             add_backend_test(timerfd_changelist_${BACKEND}
1157                             "${BACKEND_ENV_VARS};EVENT_EPOLL_USE_CHANGELIST=yes;EVENT_PRECISE_TIMER=1")
1158         else()
1159             add_backend_test(${BACKEND} "${BACKEND_ENV_VARS}")
1160         endif()
1161     endforeach()
1162
1163     #
1164     # Rate limiter tests.
1165     #
1166
1167     # Group limits, no connection limit.
1168         set(RL_BIN  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test-ratelim)
1169
1170     add_test(test-ratelim__group_lim
1171                 ${RL_BIN}
1172                 -g 30000
1173                 -n 30
1174                 -t 100
1175                 --check-grouplimit 1000
1176                 --check-stddev 100)
1177
1178     # Connection limit, no group limit.
1179     add_test(test-ratelim__con_lim
1180                 ${RL_BIN}
1181                 -c 1000
1182                 -n 30
1183                 -t 100
1184                 --check-connlimit 50
1185                 --check-stddev 50)
1186
1187     # Connection limit and group limit.
1188     add_test(test-ratelim__group_con_lim
1189                 ${RL_BIN}
1190                 -c 1000
1191                 -g 30000
1192                 -n 30
1193                 -t 100
1194                 --check-grouplimit 1000
1195                 --check-connlimit 50
1196                 --check-stddev 50)
1197
1198     # Connection limit and group limit with independent drain.
1199     add_test(test-ratelim__group_con_lim_drain
1200                 ${RL_BIN}
1201                 -c 1000
1202                 -g 35000
1203                 -n 30
1204                 -t 100
1205                 -G 500
1206                 --check-grouplimit 1000
1207                 --check-connlimit 50
1208                 --check-stddev 50)
1209
1210     # Add a "make verify" target, same as for autoconf.
1211     # (Important! This will unset all EVENT_NO* environment variables.
1212     #  If they are set in the shell the tests are running using simply "ctest" or "make test" will fail)
1213     if (WIN32)
1214         # Windows doesn't have "unset". But you can use "set VAR=" instead.
1215         # We need to guard against the possibility taht EVENT_NOWIN32 is set, and all test failing
1216         # since no event backend being available.
1217         file(TO_NATIVE_PATH ${CMAKE_CTEST_COMMAND} WINDOWS_CTEST_COMMAND)
1218
1219         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tmp/verify_tests.bat
1220             "
1221             set EVENT_NOWIN32=
1222             \"${WINDOWS_CTEST_COMMAND}\"
1223             ")
1224
1225         message(STATUS "${WINDOWS_CTEST_COMMAND}")
1226
1227         file(COPY ${CMAKE_CURRENT_BINARY_DIR}/tmp/verify_tests.bat
1228             DESTINATION
1229                             ${CMAKE_CURRENT_BINARY_DIR}
1230             FILE_PERMISSIONS
1231                             OWNER_READ
1232                             OWNER_WRITE
1233                             OWNER_EXECUTE
1234                             GROUP_READ
1235                             GROUP_EXECUTE
1236                             WORLD_READ WORLD_EXECUTE)
1237
1238         file(TO_NATIVE_PATH
1239                     "${CMAKE_CURRENT_BINARY_DIR}/verify_tests.bat" VERIFY_PATH)
1240
1241         add_custom_target(verify COMMAND "${VERIFY_PATH}"
1242                         DEPENDS event ${ALL_TESTPROGS})
1243     else()
1244         # On some platforms doing exec(unset) as CMake does won't work, so make sure
1245         # we run the unset command in a shell instead.
1246         # First we write the script contents.
1247         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tmp/verify_tests.sh
1248             "
1249             #!/bin/bash
1250             unset EVENT_NOEPOLL; unset EVENT_NOPOLL; unset EVENT_NOSELECT; unset EVENT_NOWIN32; unset EVENT_NOEVPORT; unset EVENT_NOKQUEUE; unset EVENT_NODEVPOLL
1251             ${CMAKE_CTEST_COMMAND}
1252             ")
1253
1254         # Then we copy the file (this allows us to set execute permission on it)
1255         file(COPY ${CMAKE_CURRENT_BINARY_DIR}/tmp/verify_tests.sh
1256             DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
1257             FILE_PERMISSIONS
1258                             OWNER_READ
1259                             OWNER_WRITE
1260                             OWNER_EXECUTE
1261                             GROUP_READ
1262                             GROUP_EXECUTE
1263                             WORLD_READ
1264                             WORLD_EXECUTE)
1265
1266         # Create the target that runs the script.
1267         add_custom_target(verify
1268                     COMMAND
1269                         ${CMAKE_CURRENT_BINARY_DIR}/verify_tests.sh
1270           DEPENDS
1271                         event
1272                         ${ALL_TESTPROGS})
1273     endif()
1274
1275     if (NOT EVENT__DISABLE_REGRESS AND __FOUND_USABLE_PYTHON)
1276         add_dependencies(verify regress)
1277     endif()
1278
1279     if (EVENT__COVERAGE)
1280         include(CodeCoverage)
1281
1282         setup_target_for_coverage(
1283             verify_coverage # Coverage target name "make verify_coverage"
1284             make            # Test runner.
1285             coverage        # Output directory.
1286             verify)         # Arguments passed to test runner. "make verify"
1287     endif()
1288
1289     enable_testing()
1290
1291     include(CTest)
1292 endif()
1293
1294 #
1295 # Installation preparation.
1296 #
1297
1298 # Allow the user to override installation directories.
1299 set(EVENT_INSTALL_LIB_DIR       lib CACHE PATH "Installation directory for libraries")
1300 set(EVENT_INSTALL_BIN_DIR       bin CACHE PATH "Installation directory for executables")
1301 set(EVENT_INSTALL_INCLUDE_DIR   include CACHE PATH "Installation directory for header files")
1302
1303 if(WIN32 AND NOT CYGWIN)
1304   set(DEF_INSTALL_CMAKE_DIR cmake)
1305 else()
1306   set(DEF_INSTALL_CMAKE_DIR lib/cmake/libevent)
1307 endif()
1308
1309 set(EVENT_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
1310
1311 # Make sure the paths are absolute.
1312 foreach(p LIB BIN INCLUDE CMAKE)
1313     set(var EVENT_INSTALL_${p}_DIR)
1314     if(NOT IS_ABSOLUTE "${${var}}")
1315         set(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
1316     endif()
1317 endforeach()
1318
1319 # Export targets (This is used for other CMake projects to easily find the libraries and include files).
1320 export(TARGETS event event_extra event_core
1321         FILE "${PROJECT_BINARY_DIR}/LibeventTargets.cmake")
1322 export(PACKAGE libevent)
1323
1324 # Generate the config file for the build-tree.
1325 set(EVENT__INCLUDE_DIRS
1326     "${PROJECT_SOURCE_DIR}/include"
1327     "${PROJECT_BINARY_DIR}/include")
1328
1329 set(LIBEVENT_INCLUDE_DIRS
1330     ${EVENT__INCLUDE_DIRS}
1331     CACHE PATH "Libevent include directories")
1332
1333 configure_file(${PROJECT_SOURCE_DIR}/cmake/LibeventConfigBuildTree.cmake.in
1334                 ${PROJECT_BINARY_DIR}/LibeventConfig.cmake
1335                 @ONLY)
1336
1337 # Generate the config file for the installation tree.
1338 file(RELATIVE_PATH
1339     REL_INCLUDE_DIR
1340     "${EVENT_INSTALL_CMAKE_DIR}"
1341     "${EVENT_INSTALL_INCLUDE_DIR}") # Calculate the relative directory from the Cmake dir.
1342
1343 # Note the EVENT_CMAKE_DIR is defined in LibeventConfig.cmake.in,
1344 # we escape it here so it's evaluated when it is included instead
1345 # so that the include dirs are givenrelative to where the
1346 # config file is located.
1347 set(EVENT__INCLUDE_DIRS
1348     "\${EVENT_CMAKE_DIR}/${REL_INCLUDE_DIR}")
1349
1350 configure_file(${PROJECT_SOURCE_DIR}/cmake/LibeventConfig.cmake.in
1351                 ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/LibeventConfig.cmake
1352                 @ONLY)
1353
1354 # Generate version info for both build-tree and install-tree.
1355 configure_file(${PROJECT_SOURCE_DIR}/cmake/LibeventConfigVersion.cmake.in
1356                 ${PROJECT_BINARY_DIR}/LibeventConfigVersion.cmake
1357                 @ONLY)
1358
1359 # Define the public headers.
1360 set_target_properties(event event_core event_extra
1361     PROPERTIES PUBLIC_HEADER "${HDR_PUBLIC}")
1362
1363 #
1364 # Install targets.
1365 #
1366 install(TARGETS event event_core event_extra
1367         EXPORT LibeventTargets
1368         RUNTIME DESTINATION "${EVENT_INSTALL_BIN_DIR}" COMPONENT bin
1369         LIBRARY DESTINATION "${EVENT_INSTALL_LIB_DIR}" COMPONENT lib
1370         ARCHIVE DESTINATION "${EVENT_INSTALL_LIB_DIR}" COMPONENT lib
1371         PUBLIC_HEADER DESTINATION "${EVENT_INSTALL_INCLUDE_DIR}/event2" COMPONENT dev)
1372
1373 # Install compat headers
1374 install(FILES ${HDR_COMPAT}
1375     DESTINATION
1376             "${EVENT_INSTALL_INCLUDE_DIR}"
1377     COMPONENT dev)
1378
1379 # Install the configs.
1380 install(FILES
1381     ${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/LibeventConfig.cmake
1382     ${PROJECT_BINARY_DIR}/LibeventConfigVersion.cmake
1383     DESTINATION
1384             "${EVENT_INSTALL_CMAKE_DIR}"
1385         COMPONENT dev)
1386
1387 # Install exports for the install-tree.
1388 install(EXPORT LibeventTargets
1389         DESTINATION
1390                     "${EVENT_INSTALL_CMAKE_DIR}"
1391                 COMPONENT dev)
1392
1393 set(LIBEVENT_LIBRARIES
1394         event
1395         event_core
1396         event_extra
1397         CACHE STRING "Libevent libraries")
1398
1399 message("")
1400 message("        ---( Libevent " ${EVENT_VERSION} " )---")
1401 message("")
1402 message(STATUS "Available event backends: ${BACKENDS}")
1403 message(STATUS "CMAKE_BINARY_DIR:         " ${CMAKE_BINARY_DIR})
1404 message(STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR})
1405 message(STATUS "CMAKE_SOURCE_DIR:         " ${CMAKE_SOURCE_DIR})
1406 message(STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR})
1407 message(STATUS "PROJECT_BINARY_DIR:       " ${PROJECT_BINARY_DIR})
1408 message(STATUS "PROJECT_SOURCE_DIR:       " ${PROJECT_SOURCE_DIR})
1409 message(STATUS "CMAKE_MODULE_PATH:        " ${CMAKE_MODULE_PATH})
1410 message(STATUS "CMAKE_COMMAND:            " ${CMAKE_COMMAND})
1411 message(STATUS "CMAKE_ROOT:               " ${CMAKE_ROOT} )
1412 message(STATUS "CMAKE_SYSTEM:             " ${CMAKE_SYSTEM} )
1413 message(STATUS "CMAKE_SYSTEM_NAME:        " ${CMAKE_SYSTEM_NAME} )
1414 message(STATUS "CMAKE_SYSTEM_VERSION:     " ${CMAKE_SYSTEM_VERSION} )
1415 message(STATUS "CMAKE_SYSTEM_PROCESSOR:   " ${CMAKE_SYSTEM_PROCESSOR} )
1416 message(STATUS "CMAKE_SKIP_RPATH:         " ${CMAKE_SKIP_RPATH} )
1417 message(STATUS "CMAKE_VERBOSE_MAKEFILE:   " ${CMAKE_VERBOSE_MAKEFILE} )
1418 message(STATUS "CMAKE_C_FLAGS:            " ${CMAKE_C_FLAGS} )
1419 message(STATUS "CMAKE_BUILD_TYPE:         " ${CMAKE_BUILD_TYPE} )
1420 message(STATUS "CMAKE_C_COMPILER:         " ${CMAKE_C_COMPILER} )
1421 message(STATUS "CMAKE_AR:                 " ${CMAKE_AR} )
1422 message(STATUS "CMAKE_RANLIB:             " ${CMAKE_RANLIB} )
1423 message("")
1424