windows ok

open-license-manager

2014-10-14 8ce201d0207a93d26c19fd136df4040f11ebcef1

windows ok

 src/library/os/win/os-win.c

@@ -37,6 +37,7 @@
//http://www.ok-soft-gmbh.com/ForStackOverflow/EnumMassStorage.c

//http://stackoverflow.com/questions/3098696/same-code-returns-diffrent-result-on-windows7-32-bit-system

#define MAX_UNITS 30

//bug check return with diskinfos == null func_ret_ok

FUNCTION_RETURN getDiskInfos(DiskInfo * diskInfos, size_t * disk_info_size) {

    DWORD FileMaxLen;

    int ndrives = 0;

@@ -64,32 +65,42 @@
                        &volSerial, &FileMaxLen, &FileFlags, FileSysName,

                        MAX_PATH);

                if (success) {

                    LOG_INFO("drive         : %s\n", szSingleDrive);

                    LOG_INFO("Volume Name   : %s\n", volName);

                    LOG_INFO("Volume Serial : 0x%x\n", volSerial); LOG_DEBUG("Max file length : %d\n", FileMaxLen); LOG_DEBUG("Filesystem      : %s\n", FileSysName);

                    if (diskInfos != NULL && *disk_info_size < ndrives) {

                        strncpy(diskInfos[ndrives].device, volName, MAX_PATH);

                        strncpy(diskInfos[ndrives].label, FileSysName,

                                MAX_PATH);

                        diskInfos[ndrives].id = ndrives;

                        diskInfos[ndrives].preferred = (strncmp(szSingleDrive,

                                "C", 1) != 0);



                    LOG_INFO("drive         : %s", szSingleDrive);

                    LOG_INFO("Volume Name   : %s", volName);

                    LOG_INFO("Volume Serial : 0x%x", volSerial); 
                    LOG_DEBUG("Max file length : %d", FileMaxLen); 
                    LOG_DEBUG("Filesystem      : %s", FileSysName);

                    if (diskInfos != NULL) {

                        if (ndrives < *disk_info_size) {

                            diskInfos[ndrives].id = ndrives;

                            strncpy(diskInfos[ndrives].device, volName, MAX_PATH);

                            strncpy(diskInfos[ndrives].label, FileSysName, MAX_PATH);

                            memcpy(diskInfos[ndrives].disk_sn, &volSerial, sizeof(DWORD));

                            diskInfos[ndrives].preferred = (strncmp(szSingleDrive, "C", 1) != 0);

                        } else {

                            return_value = FUNC_RET_BUFFER_TOO_SMALL;

                        }

                    }

                    ndrives++;

                } else {

                    LOG_WARN("Unable to retrieve information of '%s'\n",

                            szSingleDrive);

                    LOG_WARN("Unable to retrieve information of '%s'", szSingleDrive);

                }

            } else {

                LOG_INFO("This volume is not fixed : %s, type: %d",    szSingleDrive);

            }

            LOG_INFO("This volume is not fixed : %s, type: %d\n",

                    szSingleDrive);

            szSingleDrive += strlen(szSingleDrive) + 1;

        }

    }



    if (*disk_info_size >= ndrives) {

        return_value = FUNC_RET_BUFFER_TOO_SMALL;

    if (diskInfos == NULL || *disk_info_size == 0) {

        if (ndrives > 0) {

            return_value = FUNC_RET_OK;						 
        } else {

            return_value = FUNC_RET_NOT_AVAIL;

            LOG_INFO("No fixed drive was detected");

        }

        *disk_info_size = ndrives;

    } else {

        *disk_info_size = min(ndrives, *disk_info_size);

    }

    return return_value;

}

@@ -121,29 +132,30 @@
    FUNCTION_RETURN result;

    PIP_ADAPTER_INFO pAdapterInfo, pAdapter = NULL;

    //IP_ADAPTER_INFO AdapterInfo[20];              // Allocate information for up to 16 NICs

    DWORD dwBufLen = 20; //sizeof(AdapterInfo);         // Save the memory size of buffer

    DWORD dwBufLen = 0; //10 * sizeof(IP_ADAPTER_INFO);  // Save the memory size of buffer



    i = 3;

    do {

        pAdapterInfo = (PIP_ADAPTER_INFO) malloc(

                sizeof(IP_ADAPTER_INFO) * dwBufLen);

        pAdapterInfo = (PIP_ADAPTER_INFO) malloc(dwBufLen);

        dwStatus = GetAdaptersInfo(               // Call GetAdapterInfo

                pAdapterInfo, // [out] buffer to receive data

                &dwBufLen   // [in] size of receive data buffer

                );

        dwBufLen = dwBufLen / sizeof(IP_ADAPTER_INFO);

        if (dwStatus != NO_ERROR) {

            free(pAdapterInfo);

        }

    } while (dwStatus == ERROR_BUFFER_OVERFLOW && i-- > 0);



    if (dwStatus != ERROR_BUFFER_OVERFLOW) {

    if (dwStatus == ERROR_BUFFER_OVERFLOW) {

        return FUNC_RET_ERROR;

    }



    if (adapterInfos == NULL || *adapter_info_size == 0) {

        *adapter_info_size = dwBufLen;

        free(pAdapterInfo);

        return FUNC_RET_BUFFER_TOO_SMALL;

        *adapter_info_size = dwBufLen / sizeof(IP_ADAPTER_INFO);

        if (pAdapterInfo != NULL){

            free(pAdapterInfo);

        }

        return FUNC_RET_OK;

    }



    memset(adapterInfos, 0, *adapter_info_size);

@@ -169,6 +181,7 @@
    *adapter_info_size = i;

    return result;

}



FUNCTION_RETURN getModuleName(char buffer[MAX_PATH]) {

    FUNCTION_RETURN result = FUNC_RET_OK;

    DWORD wres = GetModuleFileName(NULL, buffer, MAX_PATH);


 src/library/pc-identifiers.c

@@ -2,7 +2,7 @@
 * pc-identifiers.c
 *
 *  Created on: Apr 16, 2014
 *      
 *
 */

#include "os/os.h"
@@ -18,94 +18,112 @@
#include <Windows.h>
#endif

//FIXME if adapterinfo or diskinfo fail the function fails
static FUNCTION_RETURN generate_default_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers) {
                                              unsigned int * num_identifiers) {
    size_t adapter_num, disk_num;
    FUNCTION_RETURN result_adapterInfos, result_diskinfos;
    unsigned int required_id_size, defined_identifiers, i, j, k;
    DiskInfo * diskInfos;
    OsAdapterInfo *adapterInfos;
    FUNCTION_RETURN result_adapterInfos, result_diskinfos, function_return;
    unsigned int caller_identifiers, i, j, k, array_index;
    DiskInfo * diskInfoPtr;
    OsAdapterInfo *adapterInfoPtr;

    result_adapterInfos = getAdapterInfos(NULL, &adapter_num);
    if (result_adapterInfos != FUNC_RET_OK) {
        //call generate_disk_pc_id;
        return result_adapterInfos;
    }
    result_diskinfos = getDiskInfos(NULL, &disk_num);
    if (result_diskinfos == FUNC_RET_OK) {
        required_id_size = disk_num * adapter_num;
    } else {
        required_id_size = disk_num;
    }
    defined_identifiers = *num_identifiers;
    *num_identifiers = required_id_size;
    if (identifiers == NULL) {
        return FUNC_RET_OK;
    } else if (required_id_size > defined_identifiers) {
        return FUNC_RET_BUFFER_TOO_SMALL;
    }
    diskInfos = (DiskInfo*) malloc(disk_num * sizeof(DiskInfo));
    result_diskinfos = getDiskInfos(diskInfos, &disk_num);
    adapterInfos = (OsAdapterInfo*) malloc(adapter_num * sizeof(OsAdapterInfo));
    result_adapterInfos = getAdapterInfos(adapterInfos, &adapter_num);
    for (i = 0; i < disk_num; i++) {
        for (j = 0; j < adapter_num; j++) {
            for (k = 0; k < 6; k++)
                identifiers[i * adapter_num + j][k] =
                        diskInfos[i].disk_sn[k + 2]
                                ^ adapterInfos[j].mac_address[k + 2];
    if (identifiers == NULL || *num_identifiers == 0) {
        result_adapterInfos = getAdapterInfos(NULL, &adapter_num);
        if (result_adapterInfos != FUNC_RET_OK) {
            return generate_disk_pc_id(identifiers,    num_identifiers, false);
        }
    }
        result_diskinfos = getDiskInfos(NULL, &disk_num);
        if (result_diskinfos != FUNC_RET_OK) {
            return generate_ethernet_pc_id(identifiers, num_identifiers, true);
        }
        *num_identifiers = disk_num * adapter_num;
        function_return = FUNC_RET_OK;
    } else {
        adapterInfoPtr = (OsAdapterInfo*)malloc((*num_identifiers) * sizeof(OsAdapterInfo));
        adapter_num = *num_identifiers;
        result_adapterInfos = getAdapterInfos(adapterInfoPtr, &adapter_num);
        if (result_adapterInfos != FUNC_RET_OK && result_adapterInfos != FUNC_RET_BUFFER_TOO_SMALL) {
            free(diskInfoPtr);
            return generate_disk_pc_id(identifiers, num_identifiers, false);
        }
        diskInfoPtr = (DiskInfo*)malloc((*num_identifiers) * sizeof(DiskInfo));
        disk_num = *num_identifiers;
        result_diskinfos = getDiskInfos(adapterInfoPtr, &disk_num);
        if (result_diskinfos != FUNC_RET_OK && result_diskinfos != FUNC_RET_BUFFER_TOO_SMALL) {
            free(diskInfoPtr);
            free(adapterInfoPtr);
            return generate_ethernet_pc_id(identifiers, num_identifiers, true);
        }
        function_return = FUNC_RET_OK;

    free(diskInfos);
    free(adapterInfos);
    return FUNC_RET_OK;
        caller_identifiers = *num_identifiers;
        for (i = 0; i < disk_num; i++) {
            for (j = 0; j < adapter_num ; j++) {
                array_index = i * adapter_num + j;
                if (array_index>=caller_identifiers)    {
                    function_return = FUNC_RET_BUFFER_TOO_SMALL;
                    //sweet memories...
                    goto end;
                }
                for (k = 0; k < 6; k++)
                    identifiers[array_index][k] =
                    diskInfoPtr[i].disk_sn[k + 2]
                    ^ adapterInfoPtr[j].mac_address[k + 2];
            }
        }
end:
        *num_identifiers = min(*num_identifiers, adapter_num * disk_num);
        free(diskInfoPtr);
        free(adapterInfoPtr);
    }
    return function_return;
}

static FUNCTION_RETURN generate_ethernet_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, int use_mac) {
    size_t adapters;
    int defined_adapters;
                                               unsigned int * num_identifiers, int use_mac) {
    FUNCTION_RETURN result_adapterInfos;
    unsigned int i, j, k;
    OsAdapterInfo *adapterInfos;
    size_t defined_adapters, adapters = 0;

    result_adapterInfos = getAdapterInfos(NULL, &adapters);
    if (result_adapterInfos != FUNC_RET_OK) {
        return result_adapterInfos;
    }

    defined_adapters = *num_identifiers;
    *num_identifiers = adapters;
    if (identifiers == NULL) {
        return FUNC_RET_OK;
    } else if (adapters > defined_adapters) {
        return FUNC_RET_BUFFER_TOO_SMALL;
    }

    adapterInfos = (OsAdapterInfo*)malloc(adapters * sizeof(OsAdapterInfo));
    result_adapterInfos = getAdapterInfos(adapterInfos, &adapters);
    for (j = 0; j < adapters; j++) {
        for (k = 0; k < 6; k++)
            if (use_mac) {
                identifiers[j][k] = adapterInfos[j].mac_address[k + 2];
            } else {
                //use ip
                if (k < 4) {
                    identifiers[j][k] = adapterInfos[j].ipv4_address[k];
                } else {
                    //padding
                    identifiers[j][k] = 42;
    if (identifiers == NULL || *num_identifiers == 0) {
        result_adapterInfos = getAdapterInfos(NULL, &adapters);
        if (result_adapterInfos == FUNC_RET_OK || result_adapterInfos == FUNC_RET_BUFFER_TOO_SMALL) {
            *num_identifiers = adapters;
            result_adapterInfos=FUNC_RET_OK;
        }
    } else {
        defined_adapters = adapters = *num_identifiers;
        adapterInfos = (OsAdapterInfo*)malloc(adapters * sizeof(OsAdapterInfo));
        result_adapterInfos = getAdapterInfos(adapterInfos, &adapters);
        if (result_adapterInfos == FUNC_RET_BUFFER_TOO_SMALL || result_adapterInfos == FUNC_RET_OK){
            for (j = 0; j < adapters; j++) {
                for (k = 0; k < 6; k++)
                if (use_mac) {
                    identifiers[j][k] = adapterInfos[j].mac_address[k + 2];
                }
                else {
                    //use ip
                    if (k < 4) {
                        identifiers[j][k] = adapterInfos[j].ipv4_address[k];
                    }
                    else {
                        //padding
                        identifiers[j][k] = 42;
                    }
                }
            }
            result_adapterInfos = (adapters>defined_adapters ? FUNC_RET_BUFFER_TOO_SMALL : FUNC_RET_OK);
        }
        free(adapterInfos);
    }
    free(adapterInfos);
    return FUNC_RET_OK;
    return result_adapterInfos;
}

static FUNCTION_RETURN generate_disk_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, bool use_label) {
    size_t disk_num, available_disk_info=0;
                                           unsigned int * num_identifiers, bool use_label) {
    size_t disk_num, available_disk_info = 0;
    FUNCTION_RETURN result_diskinfos;
    unsigned int i, k, j;
    int defined_identifiers;
@@ -116,7 +134,7 @@
    if (result_diskinfos != FUNC_RET_OK) {
        return result_diskinfos;
    }
    diskInfos = (DiskInfo*) malloc(disk_num * sizeof(DiskInfo));
    diskInfos = (DiskInfo*)malloc(disk_num * sizeof(DiskInfo));
    //memset(diskInfos,0,disk_num * sizeof(DiskInfo));
    result_diskinfos = getDiskInfos(diskInfos, &disk_num);
    if (result_diskinfos != FUNC_RET_OK) {
@@ -133,22 +151,24 @@
    if (identifiers == NULL) {
        free(diskInfos);
        return FUNC_RET_OK;
    } else if (available_disk_info > defined_identifiers) {
    }
    else if (available_disk_info > defined_identifiers) {
        free(diskInfos);
        return FUNC_RET_BUFFER_TOO_SMALL;
    }

    j=0;
    j = 0;
    for (i = 0; i < disk_num; i++) {
        if(use_label){
            if(diskInfos[i].label[0]!=0){
                memset(identifiers[j],0,sizeof(PcIdentifier)); //!!!!!!!
                strncpy(identifiers[j],diskInfos[i].label,sizeof(PcIdentifier));
        if (use_label){
            if (diskInfos[i].label[0] != 0){
                memset(identifiers[j], 0, sizeof(PcIdentifier)); //!!!!!!!
                strncpy(identifiers[j], diskInfos[i].label, sizeof(PcIdentifier));
                j++;
            }
        }else{
            if(diskInfos[i].disk_sn[0]!=0){
                memcpy(identifiers[j],&diskInfos[i].disk_sn[2],sizeof(PcIdentifier));
        }
        else{
            if (diskInfos[i].disk_sn[0] != 0){
                memcpy(identifiers[j], &diskInfos[i].disk_sn[2], sizeof(PcIdentifier));
                j++;
            }
        }
@@ -174,7 +194,7 @@
 */

FUNCTION_RETURN generate_pc_id(PcIdentifier * identifiers,
        unsigned int * array_size, IDENTIFICATION_STRATEGY strategy) {
                               unsigned int * array_size, IDENTIFICATION_STRATEGY strategy) {
    FUNCTION_RETURN result;
    unsigned int i, j;
    const unsigned int original_array_size = *array_size;
@@ -184,10 +204,10 @@
        result = generate_default_pc_id(identifiers, array_size);
        break;
    case ETHERNET:
        result = generate_ethernet_pc_id(identifiers, array_size, true );
        result = generate_ethernet_pc_id(identifiers, array_size, true);
        break;
    case IP_ADDRESS:
        result = generate_ethernet_pc_id(identifiers, array_size, false );
        result = generate_ethernet_pc_id(identifiers, array_size, false);
        break;
    case DISK_NUM:
        result = generate_disk_pc_id(identifiers, array_size, false);
@@ -240,23 +260,23 @@
}

FUNCTION_RETURN encode_pc_id(PcIdentifier identifier1, PcIdentifier identifier2,
        PcSignature pc_identifier_out) {
//TODO base62 encoding, now uses base64
                             PcSignature pc_identifier_out) {
    //TODO base62 encoding, now uses base64
    PcIdentifier concat_identifiers[2];
    char* b64_data;
    int b64_size = 0;
    size_t concatIdentifiersSize = sizeof(PcIdentifier) * 2;
//concat_identifiers = (PcIdentifier *) malloc(concatIdentifiersSize);
    size_t concatIdentifiersSize = sizeof(PcIdentifier)* 2;
    //concat_identifiers = (PcIdentifier *) malloc(concatIdentifiersSize);
    memcpy(&concat_identifiers[0], identifier1, sizeof(PcIdentifier));
    memcpy(&concat_identifiers[1], identifier2, sizeof(PcIdentifier));
    b64_data = base64(concat_identifiers, concatIdentifiersSize,
            &b64_size);
                      &b64_size);
    if (b64_size > sizeof(PcSignature)) {
        return FUNC_RET_BUFFER_TOO_SMALL;
    }
    sprintf(pc_identifier_out, "%.4s-%.4s-%.4s-%.4s", &b64_data[0],
            &b64_data[4], &b64_data[8], &b64_data[12]);
//free(concat_identifiers);
    //free(concat_identifiers);
    free(b64_data);
    return FUNC_RET_OK;
}
@@ -266,7 +286,7 @@
}

FUNCTION_RETURN generate_user_pc_signature(PcSignature identifier_out,
        IDENTIFICATION_STRATEGY strategy) {
                                           IDENTIFICATION_STRATEGY strategy) {
    FUNCTION_RETURN result;
    PcIdentifier* identifiers;
    unsigned int req_buffer_size = 0;
@@ -278,8 +298,8 @@
        return FUNC_RET_ERROR;
    }
    req_buffer_size = req_buffer_size < 2 ? 2 : req_buffer_size;
    identifiers = (PcIdentifier *) malloc(
            sizeof(PcIdentifier) * req_buffer_size);
    identifiers = (PcIdentifier *)malloc(
        sizeof(PcIdentifier)* req_buffer_size);
    result = generate_pc_id(identifiers, &req_buffer_size, strategy);
    if (result != FUNC_RET_OK) {
        free(identifiers);
@@ -305,28 +325,28 @@
 * @return
 */
static FUNCTION_RETURN decode_pc_id(PcIdentifier identifier1_out,
        PcIdentifier identifier2_out, PcSignature pc_signature_in) {
//TODO base62 encoding, now uses base64
                                    PcIdentifier identifier2_out, PcSignature pc_signature_in) {
    //TODO base62 encoding, now uses base64

    unsigned char * concat_identifiers;
    char base64ids[17];
    int identifiers_size;

    sscanf(pc_signature_in, "%4s-%4s-%4s-%4s", &base64ids[0], &base64ids[4],
            &base64ids[8], &base64ids[12]);
           &base64ids[8], &base64ids[12]);
    concat_identifiers = unbase64(base64ids, 16, &identifiers_size);
    if (identifiers_size > sizeof(PcIdentifier) * 2) {
    if (identifiers_size > sizeof(PcIdentifier)* 2) {
        return FUNC_RET_BUFFER_TOO_SMALL;
    }
    memcpy(identifier1_out, concat_identifiers, sizeof(PcIdentifier));
    memcpy(identifier2_out, concat_identifiers + sizeof(PcIdentifier),
            sizeof(PcIdentifier));
           sizeof(PcIdentifier));
    free(concat_identifiers);
    return FUNC_RET_OK;
}

static IDENTIFICATION_STRATEGY strategy_from_pc_id(PcIdentifier identifier) {
    return (IDENTIFICATION_STRATEGY) identifier[0] >> 5;
    return (IDENTIFICATION_STRATEGY)identifier[0] >> 5;
}

EVENT_TYPE validate_pc_signature(PcSignature str_code) {
@@ -336,7 +356,7 @@
    PcIdentifier* calculated_identifiers = NULL;
    unsigned int calc_identifiers_size = 0;
    int i = 0, j = 0;
//bool found;
    //bool found;
#ifdef _DEBUG
    printf("Comparing pc identifiers: \n");
#endif
@@ -345,7 +365,7 @@
        return result;
    }
    previous_strategy_id = STRATEGY_UNKNOWN;
//found = false;
    //found = false;
    for (i = 0; i < 2; i++) {
        current_strategy_id = strategy_from_pc_id(user_identifiers[i]);
        if (current_strategy_id == STRATEGY_UNKNOWN) {
@@ -357,22 +377,22 @@
            }
            previous_strategy_id = current_strategy_id;
            generate_pc_id(NULL, &calc_identifiers_size, current_strategy_id);
            calculated_identifiers = (PcIdentifier *) malloc(
                    sizeof(PcIdentifier) * calc_identifiers_size);
            calculated_identifiers = (PcIdentifier *)malloc(
                sizeof(PcIdentifier)* calc_identifiers_size);
            generate_pc_id(calculated_identifiers, &calc_identifiers_size,
                    current_strategy_id);
                           current_strategy_id);
        }
        //maybe skip the byte 0
        for (j = 0; j < calc_identifiers_size; j++) {
#ifdef _DEBUG
            printf("generated id: %02x%02x%02x%02x%02x%02x index %d, user_supplied id %02x%02x%02x%02x%02x%02x idx: %d\n",
                    calculated_identifiers[j][0],calculated_identifiers[j][1],calculated_identifiers[j][2],
                    calculated_identifiers[j][3],calculated_identifiers[j][4],calculated_identifiers[j][5],j,
                    user_identifiers[i][0],user_identifiers[i][1],user_identifiers[i][2],user_identifiers[i][3],user_identifiers[i][4],user_identifiers[i][5],i);
                   calculated_identifiers[j][0], calculated_identifiers[j][1], calculated_identifiers[j][2],
                   calculated_identifiers[j][3], calculated_identifiers[j][4], calculated_identifiers[j][5], j,
                   user_identifiers[i][0], user_identifiers[i][1], user_identifiers[i][2], user_identifiers[i][3], user_identifiers[i][4], user_identifiers[i][5], i);

#endif
            if (!memcmp(user_identifiers[i], calculated_identifiers[j],
                    sizeof(PcIdentifier))) {
                sizeof(PcIdentifier))) {
                free(calculated_identifiers);
                return LICENSE_OK;
            }

 test/functional/volid_test.cpp

@@ -3,6 +3,7 @@
//#undef BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
#include <fstream>
#include <stdio.h>
#include <cstring>
#include "../../../src/tools/license-generator/license-generator.h"
#include "../../../src/library/api/license++.h"
@@ -21,6 +22,7 @@
    PcSignature identifier_out;

    IDENTIFICATION_STRATEGY strategy = IDENTIFICATION_STRATEGY::ETHERNET;
    BOOST_CHECKPOINT("Before generate");
    FUNCTION_RETURN generate_ok = generate_user_pc_signature(identifier_out,
            strategy);
    BOOST_ASSERT(generate_ok == FUNCTION_RETURN::FUNC_RET_OK);
@@ -38,7 +40,7 @@
    BOOST_CHECK_EQUAL(license.has_expiry, false);
    BOOST_CHECK_EQUAL(license.linked_to_pc, true);
}

			  
static void generate_reference_file(const string& idfileLocation,
        IDENTIFICATION_STRATEGY strategies[], int num_strategies) {
    ofstream idfile(idfileLocation);
@@ -46,6 +48,11 @@
    for (int i = 0; i < num_strategies; i++) {
        FUNCTION_RETURN generate_ok = generate_user_pc_signature(identifier_out,
                strategies[i]);
        if (generate_ok != FUNC_RET_OK){
            idfile.close();
            remove(idfileLocation.c_str());
            BOOST_ERROR("Generating identifier for strategy " << strategies[i] << "failed with: " << generate_ok);
        }
        BOOST_ASSERT(generate_ok == FUNC_RET_OK);
        idfile << identifier_out << endl;
    }
@@ -64,10 +71,21 @@
    if (!test_idfile_exist.good()) {
        generate_reference_file(idfileLocation, strategies, num_strategies);
    }
    std::ifstream is(idfileLocation);
    std::istream_iterator<string> start(is), end;
    std::vector<string> reference_signatures(start, end);
    BOOST_ASSERT(reference_signatures.size() == num_strategies);
    //try to locate a "good" reference file.
    int tries = 2;
    std::vector<string> reference_signatures;
    do{
        std::ifstream is(idfileLocation);
        std::istream_iterator<string> start(is), end;
        reference_signatures = vector<string>(start, end);
        if (reference_signatures.size() != num_strategies){
            is.close();
            remove(idfileLocation.c_str());
            generate_reference_file(idfileLocation, strategies, num_strategies);
        }
    } while (reference_signatures.size() != num_strategies && tries-- > 0);
    BOOST_ASSERT(tries > 0);

    PcSignature generated_identifier;
    BOOST_CHECKPOINT("Generating current signatures and comparing with past");
    for (int i = 0; i < num_strategies; i++) {