source: nscp/CMakeLists.txt @ 2018659

cmake_minimum_required(VERSION 2.6)

include(build.cmake)
        
PROJECT(NSCP)

SET(VERSION_SERIES 0)
SET(VERSION_MAJOR 4)
SET(VERSION_MINOR 0)

IF(NOT SHARED_LIBS)
  IF(WIN32)
    OPTION(SHARED_LIBS "Compile shared libraries" OFF)
  ELSE(WIN32)
    OPTION(SHARED_LIBS "Compile shared libraries" ON)
  ENDIF(WIN32)
ENDIF(NOT SHARED_LIBS)

IF(NOT SHARED_LIBS)
  SET(NSCP_STATIC true)
ENDIF(NOT SHARED_LIBS)

IF(NOT MULTI_THREADED)
  OPTION(MULTI_THREADED "Build multi-threaded httpd deamon (if possible)" ON)
ENDIF(NOT MULTI_THREADED)

SET(NSCP_INCLUDE_PATH "${NSCP_SOURCE_DIR}/include" CACHE PATH "directory containing NSCP specific includes")
SET(PBUF_INCLUDE_PATH "${NSCP_SOURCE_DIR}/proto" CACHE PATH "directory containing NSCP specific protocol buffer files")
INCLUDE_DIRECTORIES(${NSCP_INCLUDE_PATH})
INCLUDE_DIRECTORIES(${PBUF_INCLUDE_PATH})

SET(BOOST_LIBRARYDIR ${BOOST_LIBRARYDIR} CACHE PATH "")
SET(BOOST_INCLUDEDIR ${BOOST_INCLUDEDIR} CACHE PATH "")
SET(BOOST_LIB_SUFFIX ${BOOST_LIB_SUFFIX} CACHE STRING "Look for Boost libraries ending with this")

IF(WIN32)
  SET(LIB_INSTALL_DIR "lib" CACHE STRING "Default path for libraries within ${CMAKE_INSTALL_PREFIX}")
  SET(RUNDIR "c:/nscp" CACHE PATH "Not really used in WIN32")


  #SET(BOOST_VERSION "1_34_1" CACHE STRING "Use boost version in BOOST_DIR")
  #OPTION(BOOST_DYNAMIC "Link to boost DLLs (OFF means static link)" OFF)

ELSE(WIN32)
  SET(USERLIB_ROOT /usr CACHE PATH "Other installation prefix for dependent libraries")
  SET(LIB_INSTALL_DIR "lib" CACHE STRING "Default path for libraries within ${CMAKE_INSTALL_PREFIX}")
  SET(RUNDIR "/usr/wt/run" CACHE PATH "Default path for wt session management (only used by FCGI connector; not relative to CMAKE_INSTALL_PREFIX)")
  SET(CONFIGURATION /etc/nscp/boot.ini CACHE PATH "Path to the boot configuration file")
  SET(MAIN_CONFIGURATION /etc/nscp/nscp.xml CACHE PATH "Path for the client configurtion file")
  SET(DEPLOYROOT /usr/bin CACHE PATH "Path to deploy examples into)")
ENDIF(WIN32)

SET(OPENSSL_INCLUDE_DIR ${OPENSSL_INCLUDE_DIR} CACHE PATH "Look for OPENSSL headers here")
SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} CACHE PATH "Look for libraries here")

FIND_PACKAGE(OpenSSL)
if(OPENSSL_FOUND)
        if(WIN32)
                FIND_LIBRARY(LIB_EAY_DEBUG NAMES libeay32MDd libeay32)
                FIND_LIBRARY(LIB_EAY_RELEASE NAMES libeay32MD libeay32)
      IF(LIB_EAY_DEBUG AND LIB_EAY_RELEASE)
         SET(OPENSSL_LIBRARIES ${OPENSSL_LIBRARIES} optimized ${LIB_EAY_RELEASE} debug ${LIB_EAY_DEBUG})
      ELSE(LIB_EAY_DEBUG AND LIB_EAY_RELEASE)
                SET(OPENSSL_FOUND FALSE)
         SET(OPENSSL_LIBRARIES NOTFOUND)
         MESSAGE(STATUS "Could not find the debug and release version of openssl")
      ENDIF(LIB_EAY_DEBUG AND LIB_EAY_RELEASE)
        endif(WIN32)
endif(OPENSSL_FOUND)

if(OPENSSL_FOUND)
        message(STATUS, "Found openssl: ${OPENSSL_LIBRARIES}")
        SET(NSCP_GLOBAL_DEFINES ${NSCP_GLOBAL_DEFINES} -DUSE_SSL)
else(OPENSSL_FOUND)
        message(STATUS, "openssl NOT found (no ssl support)")
endif(OPENSSL_FOUND)

FIND_PACKAGE(Boost COMPONENTS system filesystem thread REQUIRED)

if(Boost_FOUND)
        message(STATUS, "Found boost in: ${Boost_INCLUDE_DIRS}")
else(Boost_FOUND)
        message(FATAL_ERROR, "boost NOT fround: ${Boost_ERROR_REASON}")
endif(Boost_FOUND)

INCLUDE(cmake/NSCPPBuffer.cmake)

if(PROTOBUF_FOUND)
        message(STATUS, "Found proto in: ${PROTOBUF_LIBRARY}")
        INCLUDE_DIRECTORIES(${PROTOBUF_INCLUDE_DIR})
        #LINK_DIRECTORIES(${BOOST_LIB_DIRS})
else(PROTOBUF_FOUND)
        message(FATAL_ERROR, "Protocol buffers NOT found (${PROTOBUF_LIBRARYDIR}, )")
endif(PROTOBUF_FOUND)


#INCLUDE(cmake/WtFindAsio.txt)
#INCLUDE(cmake/WtFindSsl.txt)
#INCLUDE(cmake/FindICU.cmake)


#IF(NOT WIN32)
#       FIND_PACKAGE(ICU REQUIRED)
#       IF(NOT ICU_FOUND)
#               MESSAGE(FATAL_ERROR "ICU package not found..")
#       ELSE(NOT ICU_FOUND)
#               ADD_DEFINITIONS( -DSI_CONVERT_ICU )
#       ENDIF(NOT ICU_FOUND)
#ENDIF(NOT WIN32)

IF(NOT WIN32)
        FIND_PACKAGE(Threads REQUIRED)
        IF (NOT CMAKE_USE_PTHREADS_INIT)
          message(FATAL_ERROR "Could not find POSIX threads")
        ELSE (NOT CMAKE_USE_PTHREADS_INIT)
          #add_definitions(-D_REENTRANT)
        ENDIF (NOT CMAKE_USE_PTHREADS_INIT)
        FIND_PACKAGE(Threads REQUIRED)
ENDIF(NOT WIN32)


SET(NSCP_GLOBAL_DEFINES ${NSCP_GLOBAL_DEFINES} -DUNICODE -D_UNICODE -D_WIN32_WINNT=0x0400)

IF(CMAKE_HOST_UNIX)
        SET(UNIX_FLAVOUR LINUX CACHE STRING "Choose your unix flavour UNIX, AIX, HPUX" FORCE)
        IF(UNIX_FLAVOUR STREQUAL LINUX)
                SET(NSCP_GLOBAL_DEFINES ${NSCP_GLOBAL_DEFINES} -DLINUX)
        ENDIF(UNIX_FLAVOUR STREQUAL LINUX)
        
        SET(EXTRA_LIBS ${EXTRA_LIBS} ${CMAKE_DL_LIBS})
ENDIF()

# Boost is used nearly everywhere, so we can put these here
INCLUDE_DIRECTORIES(${BOOST_INCLUDE_DIRS})
LINK_DIRECTORIES(${BOOST_LIB_DIRS})
IF(WIN32)
  IF(BOOST_DYNAMIC)
    ADD_DEFINITIONS(-DBOOST_ALL_DYN_LINK)
  ENDIF(BOOST_DYNAMIC)
  set (EXTRA_LIBS ${EXTRA_LIBS} Userenv ole32)
ENDIF(WIN32)

IF(NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
      FORCE)
ENDIF(NOT CMAKE_BUILD_TYPE)


SET(NSCP_DEF_PLUGIN_CPP
        ${NSCP_INCLUDE_PATH}/NSCHelper.cpp
        ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp
        ${NSCP_INCLUDE_PATH}/simpleini/ConvertUTF.c
        ${NSCP_INCLUDE_PATH}/b64/b64.c
        ${PBUF_INCLUDE_PATH}/plugin.pb.cc
        ${NSCP_INCLUDE_PATH}/utils.cpp
        )

SET(NSCP_DEF_PLUGIN_HPP
                ${PBUF_INCLUDE_PATH}/plugin.pb.h
                ${NSCP_INCLUDE_PATH}/NSCHelper.h
                ${NSCP_INCLUDE_PATH}/strEx.h
                ${NSCP_INCLUDE_PATH}/config.h
                ${NSCP_INCLUDE_PATH}/utils.h
                ${NSCP_INCLUDE_PATH}/NSCAPI.h
                ${NSCP_INCLUDE_PATH}/NSCHelper.h
                ${NSCP_INCLUDE_PATH}/nsc_module_wrapper.hpp
        )

SET(NSCP_DEF_PLUGIN_LIB
                ${Boost_LIBRARIES}
                ${CMAKE_THREAD_LIBS_INIT}
                ${EXTRA_LIBS}
                ${PROTOBUF_LIBRARY}
        )


# Compile time constants & make sure our build finds it
CONFIGURE_FILE(
  ${NSCP_INCLUDE_PATH}/config.h.in
  ${NSCP_INCLUDE_PATH}/config.h
)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
INCLUDE_DIRECTORIES(${NSCP_LOCAL_INCLUDE_PATH})
INSTALL_FILES(/include FILES ${WCONFIG_H_PATH})

add_definitions(-DUNICODE -D_UNICODE)

include_directories("${PROJECT_BINARY_DIR}")

MESSAGE(STATUS "Build path: ${PROJECT_BINARY_DIR}")
ADD_SUBDIRECTORY("service")

SET(ALL_MODULE_NAMES)
FILE(GLOB ALL_MODULES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "modules/*/CMakeLists.txt")
foreach(CURRENT_MODULE ${ALL_MODULES})
        get_filename_component(CURRENT_MODULE_PATH ${CURRENT_MODULE} PATH)
        get_filename_component(CURRENT_MODULE_NAME ${CURRENT_MODULE_PATH} NAME)
        message(STATUS "Adding module: ${CURRENT_MODULE_PATH} (${CURRENT_MODULE_NAME})")
        ADD_SUBDIRECTORY("${CURRENT_MODULE_PATH}")
        SET(ALL_MODULE_NAMES ${ALL_MODULE_NAMES} ${CURRENT_MODULE_NAME})
endforeach(CURRENT_MODULE ${ALL_MODULES})


SET_TARGET_PROPERTIES("nsclient++" ${ALL_MODULE_NAMES} PROPERTIES 
        RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}"
                LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/modules"
        MODULE_OUTPUT_DIRECTORY  "${PROJECT_BINARY_DIR}/modules"
        COMPILE_DEFINITIONS_DEBUG _DEBUG
)

if (MSVC_IDE)
    # hack to get around the "Debug" and "Release" directories cmake tries to add on Windows
    set_target_properties ("nsclient++" ${ALL_MODULE_NAMES} PROPERTIES PREFIX "../")
endif()