cmake_minimum_required(VERSION 2.6)


if(NOT LTR_SDK_SUFFIX)
    include(cmake/ltrnames/ltrnames.cmake)
endif(NOT LTR_SDK_SUFFIX)

set(PROJECT_SRC_NAME  ltrd)
set(PROJECT ${LTR_SDK_SUFFIX}d)

project(${PROJECT} C)

set(LTRD_VERSION_MAJOR  2)
set(LTRD_VERSION_MINOR  1)
set(LTRD_VERSION_REV    5)
set(LTRD_VERSION_PATCH  0)
set(LTRD_VERSION ${LTRD_VERSION_MAJOR}.${LTRD_VERSION_MINOR}.${LTRD_VERSION_REV}.${LTRD_VERSION_PATCH})

set(LTRD_DESCR_EN "Service for control ${LTR_CRATE_NAME} Crates and modules")

set(LTRD_PROGRAMM_NAME "${PROJECT}")


option(LTRD_DAEMON_ENABLED          "Support of demonisation" OFF)
option(LTRD_STDOUT_ENABLED          "Print debug messages to stdout" OFF)
option(LTRD_SYSLOG_ENABLED          "Print debug messages to syslog" OFF)
option(LTRD_SYSTEMD_ENABLED         "Enable systemd support"        OFF)
option(LTRD_BAND_STATISTIC_ENABLED  "Enable bandwidth statistic calculation" ON)
option(LTRD_USB_ENABLED             "Enable usb support" OFF)
option(LTRD_LOGPROTO_ENABLED        "Enable log receive protocol" ON)
option(LTRD_ETH_DUMP_ENABLED        "Enable ethernet data dump on errors" OFF)

option(SETUP_UPSTART "Setup upstart configuration file" OFF)


#добавляем путь к модулям cmake в path для cmake
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")


if(NOT LTRD_FIRMWARE_DIR)
    if(UNIX)
        set(LTRD_FIRMWARE_DIR "${CMAKE_INSTALL_PREFIX}/share/ltrd/firmware")
    elseif(WIN32)
        set(LTRD_FIRMWARE_DIR ".")
    endif(UNIX)
endif(NOT LTRD_FIRMWARE_DIR)



if(CMAKE_COMPILER_IS_GNUCC)
set(WARNOPTS
    -Werror=implicit-int -Werror=implicit-function-declaration -Werror=strict-prototypes -Werror=return-type
    -Wall -Wextra
    -Wformat-security -Winit-self -Wstrict-aliasing -Wfloat-equal
    -Wundef -Wshadow -Wunsafe-loop-optimizations -Wpointer-arith -Wcast-align
    -Wwrite-strings -Wsign-compare -Waggregate-return -Winline
    -Wc++-compat -Wno-unused-parameter)

endif(CMAKE_COMPILER_IS_GNUCC )
add_definitions(${WARNOPTS})

if(MSVC)
    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS,5.01")
    #add_definitions(-D_CRT_SECURE_NO_WARNINGS)
    foreach(flag_var
            CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
            CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO)
       if(${flag_var} MATCHES "/MD")
          string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
       endif(${flag_var} MATCHES "/MD")
    endforeach(flag_var)

    #убираем флаг /INCREMENTAL, так как в MSVC с ним могут быть
    #внутренние ошибки линковщика
    foreach(flag_var
            CMAKE_SHARED_LINKER_FLAGS
            CMAKE_SHARED_LINKER_FLAGS_DEBUG
            CMAKE_SHARED_LINKER_FLAGS_RELEASE
            CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
            CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
            CMAKE_EXE_LINKER_FLAGS
            CMAKE_EXE_LINKER_FLAGS_DEBUG
            CMAKE_EXE_LINKER_FLAGS_RELEASE
            CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
            CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO)
       if(${flag_var} MATCHES "/INCREMENTAL:YES")
          string(REGEX REPLACE "/INCREMENTAL:YES" "/INCREMENTAL:NO" ${flag_var} "${${flag_var}}")
       endif(${flag_var} MATCHES "/INCREMENTAL:YES")
    endforeach(flag_var)
endif(MSVC)



include(CheckIncludeFiles)
include(CheckFunctionExists)
include(CheckLibraryExists)
include(CheckTypeSize)
include(CheckSymbolExists)


set(LTRD_COMPILE_DEFINITIONS HAVE_CONFIG_H)

if(WIN32)
    set(LTRD_COMPILE_DEFINITIONS ${LTRD_COMPILE_DEFINITIONS} UNICODE)
    set(LTRD_COMPILE_DEFINITIONS ${LTRD_COMPILE_DEFINITIONS} _UNICODE)
    set(LTRD_COMPILE_DEFINITIONS ${LTRD_COMPILE_DEFINITIONS} _CRT_SECURE_NO_WARNINGS)
    set(LTRD_COMPILE_DEFINITIONS ${LTRD_COMPILE_DEFINITIONS} _CRT_NON_CONFORMING_SWPRINTFS)
endif(WIN32)

set(SOURCES
    src/main.c
    src/ltrsrv_opt_parse.c
    src/ltrsrv_config.c
    src/ltrsrv_wait.c
    src/ltrsrv_log.c
    src/ltrsrv_crates.c
    src/ltrsrv_client.c
    src/ltrsrv_client_cmd.c
    src/ltrsrv_eth.c
    src/modules/ltr34/ltrsrv_mspec_ltr34.c
    src/modules/ltr35/ltrsrv_mspec_ltr35.c
   )

set(HEADERS
    src/ltrsrv_defs.h
    src/ltrsrv_cfg.h
    src/ltrsrv_opt_parse.h
    src/ltrsrv_log.h
    src/ltrsrv_daemon.h
    src/ltrsrv_wait.h
    src/ltr_crate_defs.h
    src/ltrsrv_crates.h
    src/ltrsrv_client.h
    src/ltrsrv_client_p.h
    src/ltrsrv_eth.h
    src/modules/ltr34/ltrsrv_mspec_ltr34.h
    src/modules/ltr35/ltrsrv_mspec_ltr35.h
  )


if(WIN32)
    configure_file(${PROJECT_SRC_NAME}.rc.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_SRC_NAME}.rc)
    set(SOURCES ${SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_SRC_NAME}.rc)
endif(WIN32)

if(LTRD_LOGPROTO_ENABLED)
    set(SOURCES ${SOURCES}
        src/ltrsrv_log_proto.c)
    set(HEADERS ${HEADERS}
        src/ltrsrv_log_proto.h)

endif(LTRD_LOGPROTO_ENABLED)


if(WIN32)
    if(LTRD_DAEMON_ENABLED)
        set(SOURCES ${SOURCES} src/ltrsrv_daemon_win.c)
    endif(LTRD_DAEMON_ENABLED)

    if(LTRD_SYSLOG_ENABLED)
        set(SOURCES ${SOURCES} "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.rc")
        set(HEADERS ${HEADERS} "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.h")

        configure_file(${PROJECT_SOURCE_DIR}/src/ltrsrv_event_msg.mc.in ${PROJECT_BINARY_DIR}/ltrsrv_event_msg.mc)

        # Цель для генерации файла ресурсов с информацией о сообщениях,
        # передаваемых в системный лог Windows
        add_custom_command(
            OUTPUT
                "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.h"
                "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.rc"
            COMMAND ${MC} -c
                -U "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.mc"
                -r "${PROJECT_BINARY_DIR}"
                -h "${PROJECT_BINARY_DIR}"
            DEPENDS
                "${PROJECT_BINARY_DIR}/ltrsrv_event_msg.mc"
        )
    endif(LTRD_SYSLOG_ENABLED)
else(WIN32)
    if(LTRD_DAEMON_ENABLED)
        set(SOURCES ${SOURCES} src/ltrsrv_daemon_linux.c)
    endif(LTRD_DAEMON_ENABLED)
endif(WIN32)

set(CONFIGS
    config.xml
    ltrd.conf)


set(LTRD_LTR010_FIRMWARE_FILENAME ltr010v3_0_5.ttf)
set(LTRD_LTR010_FIRMWARE_FILE  ${LTRD_FIRMWARE_DIR}/${LTRD_LTR010_FIRMWARE_FILENAME})


set(GETOPT_SRC_DIR lib/getopt)
include(${GETOPT_SRC_DIR}/getopt.cmake)

check_include_files("stdint.h" HAVE_STDINT)
if(NOT HAVE_STDINT)
    include_directories(src/stdint)
endif(NOT HAVE_STDINT)


if(WIN32)
    set(HAVE_INT64 YES)
    set(HAVE_UINT64 YES)
else(WIN32)
    check_type_size(int64_t           INT64)
    check_type_size(uint64_t          UINT64)
endif(WIN32)

if(WIN32)
    set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} winsock2.h Ws2ipdef.h)
elseif(UNIX)
    set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} netinet/in.h sys/socket.h)
endif(WIN32)
check_type_size("struct sockaddr_in6" SOCKADDR_IN6)
check_function_exists(initgroups HAVE_INITGROUPS)

#ищем библиотеку LibXml2
find_package(LibXml2)
if(LIBXML2_FOUND)
    set(HAVE_LIBXML2 ON)
    include_directories(${LIBXML2_INCLUDE_DIR})
    set(LIBS ${LIBS} ${LIBXML2_LIBRARIES})
    message(STATUS "libxml found: " ${LIBXML2_INCLUDE_DIR}, ${LIBXML2_LIBRARIES}, ${LIBXML2_DEFINITIONS})
endif(LIBXML2_FOUND)


if (NOT WIN32 AND LTRD_DAEMON_ENABLED)
    #смотрим, есть ли в системе libdaemon
    find_package(Libdaemon)
    set(HAVE_LIBDAEMON ${LIBDAEMON_FOUND})
    if (LIBDAEMON_FOUND)

        include_directories(${LIBDAEMON_INCLUDE_DIR})
        set(LIBS ${LIBS} ${LIBDAEMON_LIBRARIES})
        message ("libdaemon - ${LIBDAEMON_LIBRARIES}")
    endif(LIBDAEMON_FOUND)
else (NOT WIN32 AND LTRD_DAEMON_ENABLED)
    set(HAVE_LIBDAEMON OFF)
endif(NOT WIN32 AND LTRD_DAEMON_ENABLED)

#проверка наличия string.h
check_include_files("string.h" HAVE_STRING_H)
#проверка наличия strnlen
check_function_exists(strnlen HAVE_STRNLEN)
if(NOT HAVE_STRNLEN)
    set(SOURCES ${SOURCES} lib/strnlen/strnlen.c)
endif(NOT HAVE_STRNLEN)


if(NOT WIN32)
    check_type_size(socklen_t SOCKLEN_T)
    check_include_files(ifaddrs.h HAVE_IFADDRS_H)
    if(NOT HAVE_IFADDRS_H)        
        include_directories(lib/ifaddrs)
    endif(NOT HAVE_IFADDRS_H)

    check_include_files("sys/timers.h" HAVE_SYS_TIMERS_H)
    if(HAVE_SYS_TIMERS_H)
        check_symbol_exists(CLOCK_MONOTONIC "sys/timers.h" HAVE_CLOCK_MONOTONIC)
    endif(HAVE_SYS_TIMERS_H)
    if(NOT HAVE_CLOCK_MONOTONIC)
        check_symbol_exists(CLOCK_MONOTONIC "time.h" HAVE_CLOCK_MONOTONIC)
    endif(NOT HAVE_CLOCK_MONOTONIC)

endif(NOT WIN32)



if(LTRD_USB_ENABLED)
    set(HEADERS ${HEADERS} src/ltrsrv_usb.h src/ltrsrv_usb_p.h)
    set(SOURCES ${SOURCES} src/ltrsrv_usb.c)

    if(WIN32)
        # В Windows используем setupapi для нахождения устройства
        set(LIBS    ${LIBS} setupapi)
        set(SOURCES ${SOURCES} src/ltrsrv_usb_lcomp.c)
        set(LTRD_USE_WIN_DEVICEEVENT ON)
    else(WIN32)
        #ищем libusb
        find_package(LibUSB REQUIRED)
        include_directories(${LIBUSB_INCLUDE_DIR})
        set(LIBS ${LIBS} ${LIBUSB_LIBRARIES})

        set(SOURCES ${SOURCES} src/ltrsrv_usb_libusb.c)

        set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${LIBUSB_INCLUDE_DIR})
        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${LIBUSB_LIBRARIES})
        check_function_exists(libusb_error_name HAVE_LIBUSB_ERROR_NAME)
    endif(WIN32)
endif(LTRD_USB_ENABLED)

include_directories(${PROJECT_BINARY_DIR})

#Включаем файлы для таймера и inline-функций
set(LTIMER_DIR       lib/ltimer)
set(LCSPEC_DIR       lib/lcspec)

include(${LCSPEC_DIR}/lcspec.cmake)
include(${LTIMER_DIR}/ltimer.cmake)

set(SOURCES ${SOURCES} ${LTIMER_SOURCES})
set(HEADERS ${HEADERS} ${LTIMER_HEADERS})
set(LIBS    ${LIBS}    ${LTIMER_LIBS})

# Выбор размера буферов сокетов по умолчанию для работы с крейтами по ethernet,
#  с учетом того, что макс. размер в Qnx4/6 и FreeBSD ограничен
if((${CMAKE_SYSTEM_NAME} STREQUAL "QNX4") OR (${CMAKE_SYSTEM_NAME} STREQUAL "QNX"))
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_RECV_BUF_SIZE  128*1024)
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_SEND_BUF_SIZE  128*1024)
elseif(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
    message("freebsd buf size!")
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_RECV_BUF_SIZE  128*1024)
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_SEND_BUF_SIZE  128*1024)
else()
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_RECV_BUF_SIZE  4*1024*1024)
    set(LTRD_DEFAULT_ETH_CRATE_SOCK_SEND_BUF_SIZE  1024*1024)
endif()

#если размеры буфров сокетов не заданы явно при выполнении cmake, то используем размры по умолчанию
if(NOT LTRD_ETH_CRATE_SOCK_RECV_BUF_SIZE)
    set(LTRD_ETH_CRATE_SOCK_RECV_BUF_SIZE ${LTRD_DEFAULT_ETH_CRATE_SOCK_RECV_BUF_SIZE})
endif(NOT LTRD_ETH_CRATE_SOCK_RECV_BUF_SIZE)

if(NOT LTRD_ETH_CRATE_SOCK_SEND_BUF_SIZE)
    set(LTRD_ETH_CRATE_SOCK_SEND_BUF_SIZE ${LTRD_DEFAULT_ETH_CRATE_SOCK_SEND_BUF_SIZE})
endif(NOT LTRD_ETH_CRATE_SOCK_SEND_BUF_SIZE)


include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)

add_executable(${PROJECT} ${HEADERS} ${SOURCES} ${CONFIGS})

set_target_properties(${PROJECT} PROPERTIES COMPILE_DEFINITIONS "${LTRD_COMPILE_DEFINITIONS}" )

target_link_libraries(${PROJECT} ${LIBS})

if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX4")
    set_target_properties(${PROJECT} PROPERTIES LINK_FLAGS "op st=64k op offset=72k")
endif()

if(UNIX)
    target_link_libraries(${PROJECT} m)

    if(LTRD_SYSTEMD_ENABLED)
        #поиск библиотеки для взаимодействия с systemd (в старых версиях называлась systemd-daemon)
        find_library(SYSTEMD_LIBRARY NAMES systemd systemd-daemon)
        if(NOT SYSTEMD_LIBRARY)
            message(FATAL_ERROR "systemd library not found")
        endif(NOT SYSTEMD_LIBRARY)

        message(STATUS "systemd library found: ${SYSTEMD_LIBRARY}")
        target_link_libraries(${PROJECT} ${SYSTEMD_LIBRARY})
    endif(LTRD_SYSTEMD_ENABLED)
endif(UNIX)

if(WIN32)
    target_link_libraries(${PROJECT} Ws2_32 Iphlpapi)
elseif(${CMAKE_SYSTEM_NAME} STREQUAL "QNX")
    #в QNX для работы с API-сокетов нужно подключать отдельно библиотеку socket
    target_link_libraries(${PROJECT} socket)
elseif(${CMAKE_SYSTEM_NAME} STREQUAL "QNX4")
    target_link_libraries(${PROJECT} socket3r clib3r getifaddrs)
endif(WIN32)

if(UNIX OR ${CMAKE_SYSTEM_NAME} STREQUAL "QNX4")
    #Если используется система UpStart - то устанавливаем стартовый скрипт для нее
    if(SETUP_UPSTART AND IS_DIRECTORY lib/init)
        message(STATUS "Upsatart preset! setup ltrd.conf in /etc/init")
        install(FILES ltrd.conf  DESTINATION /etc/init)
    endif()

    if(LTRD_SYSTEMD_ENABLED)
        if(NOT SYSTEMD_SERVICE_INSTALL_DIR)
            set(SYSTEMD_SERVICE_INSTALL_DIR lib/systemd/system)
        endif()
        install(FILES systemd/ltrd.service  DESTINATION ${SYSTEMD_SERVICE_INSTALL_DIR})
    endif()

    if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX" AND CMAKE_CROSSCOMPILING)
        install(TARGETS ${PROJECT} RUNTIME  DESTINATION /${CMAKE_SYSTEM_PROCESSOR}/${CMAKE_INSTALL_PREFIX}/bin)
    else()
        install(TARGETS ${PROJECT} RUNTIME  DESTINATION bin)
    endif()

    set(COPY_CFG_SRC_FILE ${CMAKE_CURRENT_SOURCE_DIR}/config.xml)
    if (NOT LTRD_CONFIG_DIR)
        if("${CMAKE_INSTALL_PREFIX}" STREQUAL "/usr")
            set(LTRD_CONFIG_DIR /etc/${PROJECT})
        else()
            set(LTRD_CONFIG_DIR ${CMAKE_INSTALL_PREFIX}/etc/${PROJECT})
        endif()
    endif(NOT LTRD_CONFIG_DIR)
    set(LTRSRV_DEFAULT_CONFIG_FILE ${LTRD_CONFIG_DIR}/config.xml)

    # в FreeBSD файлы конфигурации должны быть с префиксом sample при установке,
    # который уже обрабатывается стандартно системой сборки портов
    if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
        install(FILES ${COPY_CFG_SRC_FILE} DESTINATION ${LTRD_CONFIG_DIR} RENAME config.xml.sample)
    else()
        install(FILES ${COPY_CFG_SRC_FILE} DESTINATION ${LTRD_CONFIG_DIR})
    endif()
else()
    set(LTRSRV_DEFAULT_CONFIG_FILE config.xml)
endif()


configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
include_directories(${CMAKE_CURRENT_BINARY_DIR})


if(UNIX AND LTRD_USB_ENABLED)
    if(NOT LTRD_UDEV_RULES_DIR)
        set(LTRD_UDEV_RULES_DIR lib/udev/rules.d)
    endif(NOT LTRD_UDEV_RULES_DIR)

    install(FILES ltr-crates.rules DESTINATION ${LTRD_UDEV_RULES_DIR})
    install(FILES firmware/${LTRD_LTR010_FIRMWARE_FILENAME} DESTINATION ${LTRD_FIRMWARE_DIR})
endif()

#цели для сборки пакетов
if(UNIX AND LTR_CMAKE_PACKAGES)
    set(PACKAGE_NAME     ${PROJECT})
    set(PACKAGE_VERSION  ${LTRD_VERSION})
    set(PACKAGE_ARCH_INSTALL_FILE ${PACKAGE_NAME}.install)
    set(PACKAGE_FREEBSD_CATEGORY  science)
    include(${LTR_CMAKE_PACKAGES})
endif(UNIX AND LTR_CMAKE_PACKAGES)


#создание установщика под Windows
if(WIN32 AND LTR_BUILD_WIN_INSTALLERS)
    get_filename_component(LIBXML_BINARY_BASENAME  ${LIBXML_BINARY} NAME)
    get_filename_component(LIBXML_ZLIB_BINARY_BASENAME  ${LIBXML_ZLIB_BINARY} NAME)
    get_filename_component(LIBXML_ICONV_BINARY_BASENAME  ${LIBXML_ICONV_BINARY} NAME)

    string(REGEX REPLACE "/" "\\\\" LIBXML_BINARY ${LIBXML_BINARY})
    string(REGEX REPLACE "/" "\\\\" LIBXML_ZLIB_BINARY ${LIBXML_ZLIB_BINARY})
    string(REGEX REPLACE "/" "\\\\" LIBXML_ICONV_BINARY ${LIBXML_ICONV_BINARY})

    set(INSTALLER_NAME ${PROJECT}_${LTRD_VERSION}.exe)

    configure_file(win_installer/ltrd.nsi.in
                   ${CMAKE_CURRENT_BINARY_DIR}/ltrd.nsi @ONLY)
    configure_file(win_installer/ltrd_start.bat.in
                    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT}_start.bat @ONLY)
    configure_file(win_installer/ltrd_stop.bat.in
                    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT}_stop.bat @ONLY)
    configure_file(win_installer/ltrd_autostart_enable.bat.in
                    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT}_autostart_enable.bat @ONLY)
    configure_file(win_installer/ltrd_autostart_disable.bat.in
                    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT}_autostart_disable.bat @ONLY)

    #собираем сам установщик
    add_custom_command(OUTPUT ${INSTALLER_NAME}
        #по nsi файлу создаем установщик
        COMMAND ${NSIS_EXEC} ltrd.nsi       
        DEPENDS ${PROJECT}
        DEPENDS ${PROJECT_BINARY_DIR}/ltrd.nsi
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
    )

    add_custom_target(ltrd-installer
                      DEPENDS ${INSTALLER_NAME})

    if(NOT WIN_INSTALLER_NOSIGN)
        #подписываем установщик при неободимости
        add_custom_command(TARGET ltrd-installer POST_BUILD
            COMMAND "${SIGNTOOL}" sign /v /ac "${SIGN_CERT}" /n "${SIGN_COMPANY_NAME}" /t ${CERT_TIMESTAMP_URL} ${INSTALLER_NAME}
            WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        )
    endif(NOT WIN_INSTALLER_NOSIGN)


endif(WIN32 AND LTR_BUILD_WIN_INSTALLERS)


