modified cmake scripts for easy export and import

gcontini

2019-12-07 74001fb4ce5041c3deb42a0ca252ae338aa571db

modified cmake scripts for easy export and import

 CMakeLists.txt

@@ -1,11 +1,5 @@
cmake_minimum_required(VERSION 2.8.11 FATAL_ERROR)

#version variables, major and minor must be 1 character only
SET(LICENSECC_MAJOR_VERSION 1)
SET(LICENSECC_MINOR_VERSION 1)
SET(LICENSECC_PATCH_VERSION 0 CACHE STRING "Licensecc patch version string")
SET(LICENSECC_INT_VERSION "${LICENSECC_MAJOR_VERSION}${LICENSECC_MINOR_VERSION}${LICENSECC_PATCH_VERSION}")
SET(LICENSECC_VERSION "${LICENSECC_MAJOR_VERSION}.${LICENSECC_MINOR_VERSION}.${LICENSECC_PATCH_VERSION}")
SET(LICENSECC_SHORT_LICENSE "BSD Software License")

SET(CMAKE_DISABLE_SOURCE_CHANGES OFF) #keys are generated in the source tree by default
@@ -22,10 +16,15 @@
    set(LCC_PROJECTS_BASE_DIR "${CMAKE_SOURCE_DIR}/projects") 
ENDIF(NOT LCC_PROJECTS_BASE_DIR)

project (licensecc C CXX )
cmake_policy(SET CMP0048 NEW)
project (licensecc 
            VERSION 2.0.0
            DESCRIPTION "Copy protection and licensing library" 
            LANGUAGES C CXX)

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/")
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")

#find lcc executable or build it.
find_package(lcc REQUIRED) 
@@ -35,33 +34,10 @@
    SET(CMAKE_CROSSCOMPILING_EMULATOR "wine")    
ENDIF()

if(MSVC)
    include(target_arch)
    target_architecture( TARGET_ARCHITECTURE )
    message(STATUS "architecture detected: ${TARGET_ARCHITECTURE}")
	
    #cmake > 3.15 handle the /MD flag more nicely than this
    if(${STATIC_RUNTIME})
        string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
        string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
        string(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
        string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
        SET(Boost_USE_STATIC_RUNTIME ON)
    endif(${STATIC_RUNTIME})

    add_definitions("/D _CRT_SECURE_NO_WARNINGS")
else(MSVC)
    if(MINGW)
        list(APPEND EXTERNAL_LIBS "-lcrypt32 -lbcrypt -lws2_32 -liphlpapi")
        SET(CMAKE_EXE_LINKER_FLAGS "-static")
    endif(MINGW)
endif(MSVC)

SET ( OPENSSL_USE_STATIC_LIBS ON )
find_package(OpenSSL COMPONENTS Crypto)
IF(OPENSSL_FOUND)
    add_definitions(-DHAS_OPENSSL)
    include_directories(${OPENSSL_INCLUDE_DIR})
    MESSAGE(STATUS "Found openssl version ${OPENSSL_VERSION}")
ELSE(OPENSSL_FOUND)
    MESSAGE(STATUS "OpenSSL not found")
@@ -90,7 +66,31 @@
        include_directories(${DBUS_INCLUDE_DIR})
        include_directories(${DBUS_ARCH_INCLUDE_DIR})
        list(APPEND EXTERNAL_LIBS ${DBUS_LIBRARIES})
    endif(USE_DBUS_IDENTIFIER)    
    endif(USE_DBUS_IDENTIFIER)  
    set(main_lib_dest "lib/${PROJECT_NAME}")  
else(UNIX)
    if(MSVC)
        include(target_arch)
        target_architecture( TARGET_ARCHITECTURE )
        message(STATUS "architecture detected: ${TARGET_ARCHITECTURE}")
		
        #cmake > 3.15 handle the /MD flag more nicely than this
        if(${STATIC_RUNTIME})
            string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
            string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
            string(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
            string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
            SET(Boost_USE_STATIC_RUNTIME ON)
        endif(${STATIC_RUNTIME})
	
        add_definitions("/D _CRT_SECURE_NO_WARNINGS")
    else(MSVC)
        if(MINGW)
            list(APPEND EXTERNAL_LIBS "-lcrypt32 -lbcrypt -lws2_32 -liphlpapi")
            SET(CMAKE_EXE_LINKER_FLAGS "-static")
        endif(MINGW)
    endif(MSVC)
    set(main_lib_dest "${PROJECT_NAME}")  
endif(UNIX)

#initialize project
@@ -106,7 +106,6 @@
  USES_TERMINAL
)
add_custom_target(project_initialize DEPENDS "${LCC_PROJECT_PUBLIC_KEY}" "${LCC_PROJECT_PRIVATE_KEY}")

include_directories( ${LCC_INCLUDE_DIR} ${CMAKE_BINARY_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/include")

message( STATUS "C compiler        : " ${CMAKE_C_COMPILER})
@@ -122,7 +121,6 @@
message( STATUS "Project name      : " ${LCC_PROJECT_NAME} )
message( STATUS "Project base dir  : " ${LCC_PROJECTS_BASE_DIR}/${LCC_PROJECT_NAME} )

install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION include)
add_subdirectory(src)

#boost is required only for tests
@@ -150,3 +148,12 @@
ELSE(Boost_FOUND)
    message(WARNING "Boost not found, disabling tests")
ENDIF(Boost_FOUND)

install(DIRECTORY ${LCC_INCLUDE_DIR} DESTINATION include/${PROJECT_NAME})
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION include)
install(FILES src/cmake/licensecc-config.cmake DESTINATION ${main_lib_dest})

include(CMakePackageConfigHelpers)
write_basic_package_version_file(${CMAKE_BINARY_DIR}/licensecc-config-version.cmake COMPATIBILITY SameMajorVersion)
install(FILES ${CMAKE_BINARY_DIR}/licensecc-config-version.cmake DESTINATION ${main_lib_dest})


 README.md

@@ -1,18 +1,21 @@
# Open License Manager

A copy protection, licensing software written in C++ for Windows and Linux (with a simple C api for use in C projects).

[![Standard](https://img.shields.io/badge/c%2B%2B-11-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization)
[![experimental](http://badges.github.io/stability-badges/dist/experimental.svg)](http://github.com/badges/stability-badges)[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![experimental](http://badges.github.io/stability-badges/dist/experimental.svg)](http://github.com/badges/stability-badges)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Build Status](https://travis-ci.org/open-license-manager/open-license-manager.svg?branch=develop)](https://travis-ci.org/open-license-manager/open-license-manager)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/62d6e1bb22d648bd85b6f3bc344a545a)](https://www.codacy.com/manual/gcontini/open-license-manager?utm_source=github.com&utm_medium=referral&utm_content=open-license-manager/open-license-manager&utm_campaign=Badge_Grade)
[![Github Issues](![GitHub issues](https://img.shields.io/github/issues/open-license-manager/open-license-manager))](http://github.com/open-license-manager/open-license-manager/issues)

A copy protection, licensing software written in C++ for Windows and Linux (with a simple C api for use in C projects).

It allows to protect the software you develop from unauthorized copies,
limit the usage in time, to a specific set of machines, or prevent the usage in 
virtualized environments. It is an Open License Manager that helps to keep your 
software closed :smirk: . A comprehensive [list of features](https://github.com/open-license-manager/open-license-manager/wiki/features), and their status is available in the project wiki.

** Warning! documentation outdated. We're in process of releasing the 2.0.0 verision that include a large update. Documentation still refers to 1.1.x series. In case of doubts look to .travis.yml file for hints on how to build the library. **

## License
The project is donated to the community. It comes with a very large freedom of use for everyone, and it will always be. 
It uses a [BSD 3 clauses](https://opensource.org/licenses/BSD-3-Clause) licensing schema, that allows free modification and inclusion in commercial software. 

 cmake/Findlcc.cmake

@@ -55,7 +55,7 @@
    add_executable(license_generator::lcc IMPORTED GLOBAL)                                            
    set_property(TARGET license_generator::lcc PROPERTY IMPORTED_LOCATION ${LCC_EXECUTABLE})  
ELSE(LCC_LOCATION)
    find_package(lcc HINTS ${CMAKE_BINARY_DIR}     NO_CMAKE_PATH) #try to find it without looping on this module
    find_package(lcc HINTS ${CMAKE_BINARY_DIR} CONFIG) #try to find it without looping on this module

    IF(NOT lcc_FOUND)     
        find_package(Git QUIET)

 include/licensecc/datatypes.h

@@ -1,8 +1,6 @@
#ifndef DATATYPES_H_
#define DATATYPES_H_

#include <licensecc_properties.h>

#ifdef __cplusplus
extern "C" {
#endif
@@ -24,7 +22,10 @@
#define DllExport __declspec(dllexport)
#endif


// define api structure sizes
#define PC_IDENTIFIER_SIZE 18
#define PROPRIETARY_DATA_SIZE 16
#define AUDIT_EVENT_NUM 5

typedef enum {
    LICENSE_OK = 0,  // OK
@@ -116,12 +117,12 @@
 * in most cases.
 */
typedef enum {
    DEFAULT,
    ETHERNET,
    IP_ADDRESS,
    DISK_NUM,
    DISK_LABEL,
    PLATFORM_SPECIFIC,
    STRATEGY_DEFAULT,
    STRATEGY_ETHERNET,
    STRATEGY_IP_ADDRESS,
    STRATEGY_DISK_NUM,
    STRATEGY_DISK_LABEL,
    STRATEGY_PLATFORM_SPECIFIC,
    STRATEGY_UNKNOWN
} IDENTIFICATION_STRATEGY;


 include/licensecc/licensecc.h

@@ -20,9 +20,7 @@
 * This method calculate the pc identifier. The string has to be shown
 * to the user in order to calculate the license.
 */
void identify_pc(IDENTIFICATION_STRATEGY pc_id_method,
        char chbuffer[PC_IDENTIFIER_SIZE + 1]);

bool identify_pc(IDENTIFICATION_STRATEGY pc_id_method, char* identifier_out, size_t bufSize);

/**
 * This method is used to request the use of one license for a product.

 src/cmake/licensecc-config.cmake

New file
@@ -0,0 +1,34 @@
# licensecc-config.cmake - package configuration file

get_filename_component(SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
if(licensecc_FIND_COMPONENTS)
    foreach(component ${licensecc_FIND_COMPONENTS})
        set(cmakefile "${SELF_DIR}/${component}/cmake/licensecc.cmake")
        if(EXISTS "${cmakefile}")
            include("${cmakefile}")
            set(${component}_FOUND true CACHE BOOL "Licensecc ${component} present")
        else(EXISTS "${cmakefile}")
            set(${component}_FOUND false CACHE BOOL "Licensecc ${component} present")
        endif(EXISTS "${cmakefile}")
        mark_as_advanced(${component}_FOUND)
    endforeach(component)
else(licensecc_FIND_COMPONENTS)
    if(LCC_PROJECT_NAME AND (EXISTS "${SELF_DIR}/${LCC_PROJECT_NAME}/cmake/licensecc.cmake"))
        include("${SELF_DIR}/${LCC_PROJECT_NAME}/cmake/licensecc.cmake")
        set(${LCC_PROJECT_NAME}_FOUND true CACHE BOOL "Licensecc ${LCC_PROJECT_NAME} present")
        mark_as_advanced(${LCC_PROJECT_NAME}_FOUND)
    else()
        if(PROJECT_NAME AND (EXISTS "${SELF_DIR}/${PROJECT_NAME}/cmake/licensecc.cmake"))
            include("${SELF_DIR}/${PROJECT_NAME}/cmake/licensecc.cmake")
            set(${PROJECT_NAME}_FOUND true CACHE BOOL "Licensecc ${PROJECT_NAME} present")
            mark_as_advanced(${PROJECT_NAME}_FOUND)
        endif()
    endif()
endif(licensecc_FIND_COMPONENTS)

get_property(COMPILE_DEF TARGET licensecc::licensecc_static PROPERTY INTERFACE_COMPILE_DEFINITIONS)
if("HAS_OPENSSL" IN_LIST COMPILE_DEF AND NOT OpenSSL_FOUND)
    message(DEBUG "Trying to find openssl (required by the target)")
    SET ( OPENSSL_USE_STATIC_LIBS ON )
    find_package(OpenSSL REQUIRED COMPONENTS Crypto)
endif()

 src/library/CMakeLists.txt

@@ -1,7 +1,4 @@
add_subdirectory("os")
add_subdirectory("base")
add_subdirectory("locate")


ADD_LIBRARY(licensecc_static STATIC
    licensecc.cpp
@@ -11,18 +8,34 @@
    ini/ConvertUTF.c
)

target_link_libraries(
     licensecc_static
     locators
     os
     base
)
add_subdirectory("locate")
add_subdirectory("os")

define_property(TARGET PROPERTY WITH_OPENSSL BRIEF_DOCS "need openssl to compile" FULL_DOCS "ff")
IF(UNIX OR OPENSSL_FOUND)
    target_compile_definitions(licensecc_static PUBLIC HAS_OPENSSL)
    set_target_properties(licensecc_static PROPERTIES WITH_OPENSSL 1)
    if (CMAKE_VERSION VERSION_GREATER 3.5)
        target_link_libraries(licensecc_static PUBLIC base OpenSSL::Crypto ${EXTERNAL_LIBS} ${CMAKE_DL_LIBS})
    #patch for old cmake in Centos 7
    ELSE(CMAKE_VERSION VERSION_GREATER 3.5)
        target_link_libraries(licensecc_static PUBLIC base ${OPENSSL_CRYPTO_LIBRARY} ${EXTERNAL_LIBS} ${CMAKE_DL_LIBS})
        include_directories(${OPENSSL_INCLUDE_DIR})
    ENDIF(CMAKE_VERSION VERSION_GREATER 3.5)
ELSE(UNIX OR OPENSSL_FOUND)
    set_target_properties(licensecc_static PROPERTIES WITH_OPENSSL 0)
    target_link_libraries(licensecc_static ${EXTERNAL_LIBS})
ENDIF(UNIX OR OPENSSL_FOUND)

target_include_directories(licensecc_static
    INTERFACE 
        $<INSTALL_INTERFACE:include/${PROJECT_NAME}>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include>
)

install(TARGETS licensecc_static ARCHIVE DESTINATION lib/${PROJECT_NAME}/${LCC_PROJECT_NAME})

add_library(licensecc::licensecc_static ALIAS licensecc_static)
install(TARGETS licensecc_static EXPORT licensecc
    ARCHIVE DESTINATION ${main_lib_dest}/${LCC_PROJECT_NAME})
	
install(EXPORT licensecc NAMESPACE licensecc:: DESTINATION  ${main_lib_dest}/${LCC_PROJECT_NAME}/cmake)
export(EXPORT licensecc NAMESPACE licensecc:: FILE ${CMAKE_BINARY_DIR}/${PROJECT_NAME}-config.cmake)

 src/library/base/CMakeLists.txt

@@ -8,4 +8,5 @@

add_dependencies( base project_initialize )

install(TARGETS base ARCHIVE DESTINATION lib/${PROJECT_NAME}/${LCC_PROJECT_NAME})
install(TARGETS base EXPORT licensecc ARCHIVE DESTINATION lib/${PROJECT_NAME}/${LCC_PROJECT_NAME})


 src/library/licensecc.cpp

@@ -13,14 +13,24 @@

#include <licensecc/datatypes.h>
#include <licensecc/licensecc.h>
#include <licensecc_properties.h>

#include "limits/license_verifier.hpp"
#include "LicenseReader.hpp"
#include "pc-identifiers.h"

using namespace std;
void print_error(char out_buffer[256], LicenseInfo* licenseInfo) {}

void identify_pc(IDENTIFICATION_STRATEGY pc_id_method, char chbuffer[PC_IDENTIFIER_SIZE + 1]) {}
bool identify_pc(IDENTIFICATION_STRATEGY pc_id_method, char* chbuffer, size_t bufSize) {
    PcSignature identifier_out;
    FUNCTION_RETURN result = FUNC_RET_BUFFER_TOO_SMALL;
    if (bufSize >= sizeof(PcSignature)) {
        result = generate_user_pc_signature(identifier_out, pc_id_method);
        strncpy(chbuffer, identifier_out, bufSize);
    }
    return result == FUNC_RET_OK;
}

static void mergeLicenses(const vector<LicenseInfo>& licenses, LicenseInfo* license_out) {
    if (license_out != nullptr) {

 src/library/locate/CMakeLists.txt

@@ -1,18 +1,9 @@
ADD_LIBRARY(locators STATIC
    ApplicationFolder.cpp
    EnvironmentVarLocation.cpp
    EnvironmentVarData.cpp
    ExternalDefinition.cpp
    LocatorStrategy.cpp
    LocatorFactory.cpp
target_sources(licensecc_static PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/ApplicationFolder.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/EnvironmentVarLocation.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/EnvironmentVarData.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/ExternalDefinition.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/LocatorStrategy.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/LocatorFactory.cpp
)

add_dependencies( locators os base )

target_link_libraries(
     locators
     os
     base
)

install(TARGETS locators ARCHIVE DESTINATION lib/${PROJECT_NAME}/${LCC_PROJECT_NAME})

 src/library/os/CMakeLists.txt

@@ -1,27 +1,19 @@
target_sources(licensecc_static PRIVATE 
     ${CMAKE_CURRENT_SOURCE_DIR}/os.c)

IF(UNIX OR OPENSSL_FOUND)
    IF(UNIX)
        ADD_LIBRARY(os STATIC openssl/signature_verifier.cpp os.c os-linux.c network_id.c)
        target_sources(licensecc_static PRIVATE
            ${CMAKE_CURRENT_SOURCE_DIR}/openssl/signature_verifier.cpp
            ${CMAKE_CURRENT_SOURCE_DIR}/os-linux.c 
            ${CMAKE_CURRENT_SOURCE_DIR}/network_id.c)
    ELSE(UNIX)
          ADD_LIBRARY(os STATIC openssl/signature_verifier.cpp os.c os-win.c)
          target_sources(licensecc_static PRIVATE 
              ${CMAKE_CURRENT_SOURCE_DIR}/os-win.c)
    ENDIF(UNIX)
	
    if (CMAKE_VERSION VERSION_GREATER 3.5)
        target_link_libraries(os base OpenSSL::Crypto ${EXTERNAL_LIBS} ${CMAKE_DL_LIBS})
    #patch for old cmake in Centos 7
    ELSE(CMAKE_VERSION VERSION_GREATER 3.5)
        target_link_libraries(os base ${OPENSSL_CRYPTO_LIBRARY} ${EXTERNAL_LIBS} ${CMAKE_DL_LIBS})
    ENDIF(CMAKE_VERSION VERSION_GREATER 3.5)
ELSE(UNIX OR OPENSSL_FOUND)
    ADD_LIBRARY(os STATIC
        windows/signature_verifier.cpp
        os.c
        os-win.c)

    target_link_libraries(
         os
         base
         ${EXTERNAL_LIBS} 
    )
    target_sources(licensecc_static STATIC
        ${CMAKE_CURRENT_SOURCE_DIR}/windows/signature_verifier.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/os-win.c)
ENDIF(UNIX OR OPENSSL_FOUND)

install(TARGETS os ARCHIVE DESTINATION lib/${PROJECT_NAME}/${LCC_PROJECT_NAME})

 src/library/pc-identifiers.c

@@ -201,19 +201,19 @@
    const unsigned int original_array_size = *array_size;
    unsigned char strategy_num;
    switch (strategy) {
        case DEFAULT:
        case STRATEGY_DEFAULT:
            result = generate_default_pc_id(identifiers, array_size);
            break;
        case ETHERNET:
        case STRATEGY_ETHERNET:
            result = generate_ethernet_pc_id(identifiers, array_size, true);
            break;
        case IP_ADDRESS:
        case STRATEGY_IP_ADDRESS:
            result = generate_ethernet_pc_id(identifiers, array_size, false);
            break;
        case DISK_NUM:
        case STRATEGY_DISK_NUM:
            result = generate_disk_pc_id(identifiers, array_size, false);
            break;
        case DISK_LABEL:
        case STRATEGY_DISK_LABEL:
            result = generate_disk_pc_id(identifiers, array_size, true);
            break;
        default:

 src/library/pc-identifiers.h

@@ -16,7 +16,7 @@
#endif

typedef unsigned char PcIdentifier[6];
typedef char PcSignature[21];
typedef char PcSignature[PC_IDENTIFIER_SIZE + 1];

FUNCTION_RETURN generate_pc_id(PcIdentifier * identifiers, unsigned int * array_size,
        IDENTIFICATION_STRATEGY strategy);
@@ -30,8 +30,7 @@
 * @param strategy
 * @return
 */
FUNCTION_RETURN generate_user_pc_signature(PcSignature identifier_out,
        IDENTIFICATION_STRATEGY strategy);
FUNCTION_RETURN generate_user_pc_signature(PcSignature identifier_out, IDENTIFICATION_STRATEGY strategy);

#ifdef __cplusplus
}

 src/templates/licensecc_properties.h.in

@@ -2,8 +2,6 @@
#define BUILD_PROPERTIES_H_

#define LCC_PROJECT_NAME "@LCC_PROJECT_NAME@"
#define PROJECT_INT_VERSION @LICENSECC_INT_VERSION@
#define PROJECT_VERSION "@LICENSECC_VERSION@"

//License retrieval configuration
#define FIND_LICENSE_NEAR_MODULE 1
@@ -11,11 +9,6 @@

#define LICENSE_LOCATION_ENV_VAR "LICENSE_LOCATION"
#define LICENSE_DATA_ENV_VAR "LICENSE_DATA"

//define api structure sizes
#define PC_IDENTIFIER_SIZE 18
#define PROPRIETARY_DATA_SIZE 16
#define AUDIT_EVENT_NUM 5

//Internal data structures limits
#define MAX_LICENSE_LENGTH 256*1024

 test/functional/volid_test.cpp

@@ -25,7 +25,7 @@
BOOST_AUTO_TEST_CASE( default_volid_lic_file ) {
    PcSignature identifier_out;

    const IDENTIFICATION_STRATEGY strategy = IDENTIFICATION_STRATEGY::ETHERNET;
    const IDENTIFICATION_STRATEGY strategy = IDENTIFICATION_STRATEGY::STRATEGY_ETHERNET;
    BOOST_TEST_CHECKPOINT("Before generate");
    const FUNCTION_RETURN generate_ok = generate_user_pc_signature(identifier_out,
            strategy);
@@ -72,7 +72,7 @@
    size_t disk_num;
    getDiskInfos(NULL, &disk_num);
    if (disk_num >0) {
        strategies = { DEFAULT, DISK_NUM, DISK_LABEL };
        strategies = {STRATEGY_DEFAULT, STRATEGY_DISK_NUM, STRATEGY_DISK_LABEL};
    } else {
        BOOST_TEST_CHECKPOINT("if no disk default strategy fails see #49");
        //strategies = { DEFAULT };
@@ -81,7 +81,7 @@
    size_t adapters;
    getAdapterInfos(nullptr, &adapters);
    if(adapters > 0){
        strategies.push_back(ETHERNET);
        strategies.push_back(STRATEGY_ETHERNET);
    }

    size_t num_strategies = strategies.size();

 test/library/CMakeLists.txt

@@ -21,7 +21,7 @@

    target_link_libraries(
         test_os_linux
         os
         licensecc_static
         ${Boost_LIBRARIES}
    )

@@ -36,7 +36,7 @@

target_link_libraries(
 test_license_locator
 locators
 licensecc_static
 ${Boost_LIBRARIES}
)