new identifier strategy (to be reverted

open-license-manager

2014-08-04 8af6b12ee8716d2004d13bbfc81281953975b466

new identifier strategy (to be reverted

 src/library/os/linux/os-linux.c

@@ -31,6 +31,9 @@
#include <dirent.h>
#include <stdio.h>

#include <dbus-1.0/dbus/dbus.h>
#include <sys/utsname.h>

static int ifname_position(char *ifnames, char * ifname, int ifnames_max) {
    int i, position;
    position = -1;
@@ -408,3 +411,22 @@
    return NONE;
}

FUNCTION_RETURN getMachineName(unsigned char identifier[6]) {
    static struct utsname u;

    if (uname(&u) < 0) {
        return ERROR;
    }
    memcpy(identifier, u.nodename, 6);
    return OK;
}

FUNCTION_RETURN getOsSpecificIdentifier(unsigned char identifier[6]) {
    char* dbus_id = dbus_get_local_machine_id();
    if (dbus_id == NULL) {
        return ERROR;
    }
    memcpy(identifier, dbus_id, 6);
    dbus_free(dbus_id);
    return OK;
}

 src/library/pc-identifiers.c

@@ -13,6 +13,14 @@
#include "base/base64.h"
#include <valgrind/memcheck.h>

FUNCTION_RETURN generate_ethernet_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, bool use_mac);
static void encodeStrategy(PcIdentifier * identifier,
        IDENTIFICATION_STRATEGY strategy);
static FUNCTION_RETURN generate_platform_specific_pc_id(
        PcIdentifier * identifiers, unsigned int * num_identifiers);


static FUNCTION_RETURN generate_default_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers) {
    size_t adapter_num, disk_num, plat_spec_id;
@@ -64,18 +72,20 @@
                    identifiers[current_identifier][k] = diskInfos[i].disk_sn[k
                            + 2] ^ adapterInfos[j].mac_address[k + 2];
                }
                encodeStrategy(identifiers[current_identifier], DEFAULT);
                encodeStrategy(&identifiers[current_identifier], DEFAULT);
                current_identifier++;
            }
        }
        free(diskInfos);
        free(adapterInfos);
    } else if (result_adapterInfos == OK) {
        i=defined_identifiers-current_identifier;
        return generate_ethernet_pc_id(&identifiers[current_identifier],
                defined_identifiers-current_identifier, true);
                &i, true);
    } else if (result_diskinfos == OK) {
        i=defined_identifiers-current_identifier;
        return generate_disk_pc_id(&identifiers[current_identifier],
                defined_identifiers-current_identifier, false);
                &i, false);
    }

    return OK;
@@ -84,12 +94,14 @@
static void encodeStrategy(PcIdentifier * identifier,
        IDENTIFICATION_STRATEGY strategy) {
    unsigned char strategy_num = strategy << 5;
    identifier[0] = (identifier[0] & 15) | strategy_num;
    identifier[0][0] = (identifier[0][0] & 15)

                    ++     | strategy_num;

}

static FUNCTION_RETURN generate_platform_specific_pc_id(
        PcIdentifier * identifiers, unsigned int * num_identifiers) {
           * identifiers, unsigned int * num_identifiers) {

}


 test/functional/CMakeLists.txt

@@ -44,3 +44,17 @@
ADD_TEST(standard_license_test ${EXECUTABLE_OUTPUT_PATH}/standard_license_test)
ADD_TEST(date_test ${EXECUTABLE_OUTPUT_PATH}/date_test)
ADD_TEST(volid_test ${EXECUTABLE_OUTPUT_PATH}/volid_test)



add_executable(
 stackoverflow
 stackoverflow.cpp
)

target_link_libraries(
    stackoverflow
    license_generator_lib
)

SET_TARGET_PROPERTIES(stackoverflow PROPERTIES LINK_SEARCH_START_STATIC ON)

 test/functional/volid_test.cpp

@@ -11,12 +11,12 @@
#include "../../src/library/ini/SimpleIni.h"
#include "generate-license.h"
#include "../../src/library/pc-identifiers.h"
#include <dbus/dbus.h>
#include <dbus-1.0/dbus/dbus.h>

namespace fs = boost::filesystem;
using namespace license;
using namespace std;
/*

 BOOST_AUTO_TEST_CASE( default_volid_lic_file ) {
 const string licLocation(PROJECT_TEST_TEMP_DIR "/volid_license.lic");
 PcSignature identifier_out;
@@ -99,7 +99,5 @@
 }
 }
 }
 */
BOOST_AUTO_TEST_CASE( ciiii ) {
    cout << dbus_get_local_machine_id() << endl;
}



 test/scratch/base62.c

New file
@@ -0,0 +1,131 @@


/* Division by 62 on an arbitrary length input.
   (TODO: Note: the cast will segfault on some systems, so you will need
   to use a memcpy instead).
   Also TODO: Optimisation: use >32 bit integers if available.
 */
static void b62_divide(const unsigned char* dividend, int dividend_len,
                       unsigned char* quotient, unsigned int* remainder)
{
    unsigned int quantity;
    int i;

    quantity = 0;
    for (i=dividend_len-2;i>=0;i-=2) {
        quantity |= *((unsigned short*)&dividend[i]);
        *((unsigned short *)&quotient[i]) = (unsigned short)(quantity/62);
        quantity = (quantity%62)<<16;
    }
    *remainder = quantity>>16;
}

/* pseudo-base62 encode
    base62 encoding is not a very nice mapping to character data.  The only
    way that we can properly do this is to divide by 62 each time and get
    the remainder, this will ensure full use of the base62 space.  This is
    /not/ very performant.  So instead we operate the base62 encoding on
    56 bit (7 byte) chunks.  This gives a pretty good usage, with far less
    lengthy division operations on moderately sized input.  I only did this
    for completeness as I got interested in it, but we can prove that you have
    to do the full division each time (although you may find a better way of
    implementing it!) as follows.  We want to encode data as a bitstream, so
    we want to find N,M s.t. 62^M = 2^N, and M,N are integers.  There are
    no such M,N (proof on request).  For base64 encoding we get 64^M = 2^N,
    obviously we can fit M=1,N=6 which equates to sucking up 6 bits each time
    for the encoding algorithm.  So instead we try to find a comprise between
    the the block size, and the number of bits wasted by the conversion to
    base62 space.  The constraints here are

    (1) we want to deal with whole numbers of bytes to simplify the code
    (2) we want to waste as little of the encoding space as possible
    (3) we want to keep the division operations restricted to a reasonable
    number of bits as the running time of the division operation depends
    on the length of the input bit string.

    The ratio of the length of the bit strings in the two bases will be
    log2(256)/log2(62)
    For base64 encoding we get 4/3 exactly.  So to minimize waste here we
    want to take chunks of 3 bytes, then there is no wastage between blocks.
    For base62 encoding we get ~1.34.  Picking 5 as the block size wastes
    some 30% of the encoding space for the last byte.  Let me know if you
    think another pick is better.  This one means that we are operating
    on 40-bit strings, so the division isn't too strenuous to compute, and
    on a 64-bit platform can be done all in a register.
 */
#define msg_id_length (((134359*(sizeof(time_t)+sizeof(int)*2))/100000)+2)

static char base62_tab[62] = {
    'A','B','C','D','E','F','G','H',
    'I','J','K','L','M','N','O','P',
    'Q','R','S','T','U','V','W','X',
    'Y','Z','a','b','c','d','e','f',
    'g','h','i','j','k','l','m','n',
    'o','p','q','r','s','t','u','v',
    'w','x','y','z','0','1','2','3',
    '4','5','6','7','8','9'
};

int b62_encode(char* out, const unsigned char* data, int length, int linelength)
{
    int i,j;
    char *start = out;
    uint64_t bitstring;

    linelength;
    for (i=0;i<length-4;i+=5) {
        bitstring =
            (uint64_t)data[i]<<32|(uint64_t)data[i+1]<<24|(uint64_t)data[i+2]<<16|
            (uint64_t)data[i+3]<<8|(uint64_t)data[i+4];

        for (j=0;j<7;++j) {
            *out++ = base62_tab[bitstring%62];
            bitstring /= 62;
        }
/*
        b62_divide(quotient,len,quotient,&rem);
        *out++ = base62_tab[rem];
        for (j=1;j<len;++j) {
            b62_divide(quotient,len,quotient,&rem);
            *out++ = base62_tab[rem];
        }*/
    }
    switch (length-i) {
    case 1:
        *out++ = base62_tab[data[i]%62];
        *out++ = base62_tab[data[i]/62];
        break;
    case 2:
        bitstring = data[i]<<8|data[i+1];
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        *out++ = base62_tab[bitstring/62];
        break;
    case 3:
        bitstring = data[i]<<16|data[i+1]<<8|data[i];
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        *out++ = base62_tab[bitstring/62];
        break;
    case 4:
        bitstring = data[i]<<24|data[i+1]<<16|data[i+2]<<8|data[i];
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        bitstring /= 62;
        *out++ = base62_tab[bitstring%62];
        *out++ = base62_tab[bitstring/62];
        break;
    }
    return (int)(out-start);
}

 test/scratch/pc-identifiers.c

New file
@@ -0,0 +1,415 @@
/*
 * pc-identifiers.c
 *
 *  Created on: Apr 16, 2014
 *      Author: devel
 */

#include "os/os.h"
#include "pc-identifiers.h"
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "base/base64.h"
#include <valgrind/memcheck.h>

FUNCTION_RETURN generate_ethernet_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, bool use_mac);
static void encodeStrategy(PcIdentifier * identifier,
        IDENTIFICATION_STRATEGY strategy);
static FUNCTION_RETURN generate_platform_specific_pc_id(
        PcIdentifier * identifiers, unsigned int * num_identifiers);


static FUNCTION_RETURN generate_default_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers) {
    size_t adapter_num, disk_num, plat_spec_id;
    FUNCTION_RETURN result_adapterInfos, result_diskinfos, result_plat_spec;
    unsigned int required_id_size, current_identifier, i, j, k;
    DiskInfo * diskInfos;
    AdapterInfo *adapterInfos;
    required_id_size = 0;

    //just calculate the number of required identifiers
    result_plat_spec = generate_platform_specific_pc_id(NULL, &plat_spec_id);
    if (result_plat_spec == OK) {
        required_id_size += 1;
    }
    result_adapterInfos = getAdapterInfos(NULL, &adapter_num);
    result_diskinfos = getDiskInfos(NULL, &disk_num);
    if (result_diskinfos == OK && result_adapterInfos == OK) {
        required_id_size += disk_num * adapter_num;
    } else if (result_adapterInfos == OK) {
        required_id_size += adapter_num;
    } else if (result_diskinfos == OK) {
        required_id_size += disk_num;
    }
    int defined_identifiers = *num_identifiers;
    if (identifiers == NULL) {
        *num_identifiers = required_id_size;
        return OK;
    } else if (required_id_size > defined_identifiers) {
        return BUFFER_TOO_SMALL;
    }

    //calculate the identifiers
    current_identifier = 0;
    if (result_plat_spec == OK) {
        generate_platform_specific_pc_id(identifiers, 1);
        current_identifier += 1;
    }
    if (result_diskinfos == OK && result_adapterInfos == OK) {
        diskInfos = (DiskInfo*) malloc(disk_num * sizeof(DiskInfo));
        result_diskinfos = getDiskInfos(diskInfos, &disk_num);
        adapterInfos = (AdapterInfo*) malloc(adapter_num * sizeof(AdapterInfo));
        result_adapterInfos = getAdapterInfos(adapterInfos, &adapter_num);
        for (i = 0; i < disk_num; i++) {
            for (j = 0; j < adapter_num; j++) {
                if (current_identifier > defined_identifiers) {
                    break;
                }
                for (k = 0; k < 6; k++) {
                    identifiers[current_identifier][k] = diskInfos[i].disk_sn[k
                            + 2] ^ adapterInfos[j].mac_address[k + 2];
                }
                encodeStrategy(&identifiers[current_identifier], DEFAULT);
                current_identifier++;
            }
        }
        free(diskInfos);
        free(adapterInfos);
    } else if (result_adapterInfos == OK) {
        i=defined_identifiers-current_identifier;
        return generate_ethernet_pc_id(&identifiers[current_identifier],
                &i, true);
    } else if (result_diskinfos == OK) {
        i=defined_identifiers-current_identifier;
        return generate_disk_pc_id(&identifiers[current_identifier],
                &i, false);
    }

    return OK;
}

static void encodeStrategy(PcIdentifier * identifier,
        IDENTIFICATION_STRATEGY strategy) {
    unsigned char strategy_num = strategy << 5;
    identifier[0][0] = (identifier[0][0] & 15)

                    ++     | strategy_num;

}

static FUNCTION_RETURN generate_platform_specific_pc_id(
           * identifiers, unsigned int * num_identifiers) {

}

static FUNCTION_RETURN generate_ethernet_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, bool use_mac) {
    size_t adapters;
    FUNCTION_RETURN result_adapterInfos;
    unsigned int j, k;
    AdapterInfo *adapterInfos;

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

    int defined_adapters = *num_identifiers;
    *num_identifiers = adapters;
    if (identifiers == NULL) {
        return OK;
    } else if (adapters > defined_adapters) {
        return BUFFER_TOO_SMALL;
    }

    adapterInfos = (AdapterInfo*) malloc(adapters * sizeof(AdapterInfo));
    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;
                }
            }
    }
    free(adapterInfos);
    return OK;
}

static FUNCTION_RETURN generate_disk_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers, bool use_label) {
    size_t disk_num, available_disk_info = 0;
    FUNCTION_RETURN result_diskinfos;
    unsigned int i, j;
    char firstChar;
    DiskInfo * diskInfos;

    result_diskinfos = getDiskInfos(NULL, &disk_num);
    if (result_diskinfos != OK) {
        return result_diskinfos;
    }
    diskInfos = (DiskInfo*) malloc(disk_num * sizeof(DiskInfo));
//memset(diskInfos,0,disk_num * sizeof(DiskInfo));
    result_diskinfos = getDiskInfos(diskInfos, &disk_num);
    if (result_diskinfos != OK) {
        free(diskInfos);
        return result_diskinfos;
    }
    for (i = 0; i < disk_num; i++) {
        firstChar = use_label ? diskInfos[i].label[0] : diskInfos[i].disk_sn[0];
        available_disk_info += firstChar == 0 ? 0 : 1;
    }

    int defined_identifiers = *num_identifiers;
    *num_identifiers = available_disk_info;
    if (identifiers == NULL) {
        free(diskInfos);
        return OK;
    } else if (available_disk_info > defined_identifiers) {
        free(diskInfos);
        return BUFFER_TOO_SMALL;
    }

    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));
                j++;
            }
        } else {
            if (diskInfos[i].disk_sn[0] != 0) {
                memcpy(identifiers[j], &diskInfos[i].disk_sn[2],
                        sizeof(PcIdentifier));
                j++;
            }
        }
    }
    free(diskInfos);
    return OK;
}

/**
 *
 * Calculates all the possible identifiers for the current machine, for the
 * given calculation strategy requested. Pc identifiers are more than one,
 * for instance a machine with more than one disk and one network interface has
 * usually multiple identifiers.
 *
 * First 4 bit of each pc identifier are reserved 3 for the type of strategy
 * used in calculation and 1 for parity checks (not implemented here)
 *
 * @param identifiers
 * @param array_size
 * @param
 * @return
 */
FUNCTION_RETURN generate_pc_id(PcIdentifier * identifiers,
        unsigned int * array_size, IDENTIFICATION_STRATEGY strategy) {
    FUNCTION_RETURN result;
    unsigned int i, j;
    const unsigned int original_array_size = *array_size;
    unsigned char strategy_num;
    switch (strategy) {
    case DEFAULT:
        result = generate_default_pc_id(identifiers, array_size);
        break;
    case ETHERNET:
        result = generate_ethernet_pc_id(identifiers, array_size, true);
        break;
    case IP_ADDRESS:
        result = generate_ethernet_pc_id(identifiers, array_size, false);
        break;
    case DISK_NUM:
        result = generate_disk_pc_id(identifiers, array_size, false);
        break;
    case PLATFORM_SPECIFIC:
        result = generate_platform_specific_pc_id(identifiers, array_size);
        break;
    default:
        return ERROR;
    }

    if (result == OK && identifiers != NULL) {
        //fill array if larger
        for (i = *array_size; i < original_array_size; i++) {
            identifiers[i][0] = STRATEGY_UNKNOWN << 5;
            for (j = 1; j < sizeof(PcIdentifier); j++) {
                identifiers[i][j] = 42; //padding
            }
        }
    }
    return result;
}

char *MakeCRC(char *BitString) {
    static char Res[3];                                 // CRC Result
    char CRC[2];
    int i;
    char DoInvert;

    for (i = 0; i < 2; ++i)
        CRC[i] = 0;                    // Init before calculation

    for (i = 0; i < strlen(BitString); ++i) {
        DoInvert = ('1' == BitString[i]) ^ CRC[1];         // XOR required?

        CRC[1] = CRC[0];
        CRC[0] = DoInvert;
    }

    for (i = 0; i < 2; ++i)
        Res[1 - i] = CRC[i] ? '1' : '0'; // Convert binary to ASCII
    Res[2] = 0;                                         // Set string terminator

    return (Res);
}

FUNCTION_RETURN encode_pc_id(PcIdentifier identifier1, PcIdentifier identifier2,
        PcSignature pc_identifier_out) {
//TODO base62 encoding, now uses base64
    PcIdentifier concat_identifiers[2];
    int b64_size = 0;
    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));
    char* b64_data = base64(concat_identifiers, concatIdentifiersSize,
            &b64_size);
    if (b64_size > sizeof(PcSignature)) {
        return 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(b64_data);
    return OK;
}

FUNCTION_RETURN parity_check_id(PcSignature pc_identifier) {
    return OK;
}

FUNCTION_RETURN generate_user_pc_signature(PcSignature identifier_out,
        IDENTIFICATION_STRATEGY strategy) {
    FUNCTION_RETURN result;
    PcIdentifier* identifiers;
    unsigned int req_buffer_size = 0;
    result = generate_pc_id(NULL, &req_buffer_size, strategy);
    if (result != OK) {
        return result;
    }
    if (req_buffer_size == 0) {
        return ERROR;
    }
    req_buffer_size = req_buffer_size < 2 ? 2 : req_buffer_size;
    identifiers = (PcIdentifier *) malloc(
            sizeof(PcIdentifier) * req_buffer_size);
    result = generate_pc_id(identifiers, &req_buffer_size, strategy);
    if (result != OK) {
        free(identifiers);
        return result;
    }
    VALGRIND_CHECK_VALUE_IS_DEFINED(identifiers[0]);
    VALGRIND_CHECK_VALUE_IS_DEFINED(identifiers[1]);
    result = encode_pc_id(identifiers[0], identifiers[1], identifier_out);
    VALGRIND_CHECK_VALUE_IS_DEFINED(identifier_out);
    free(identifiers);
    return result;
}

/**
 * Extract the two pc identifiers from the user provided code.
 * @param identifier1_out
 * @param identifier2_out
 * @param str_code: the code in the string format XXXX-XXXX-XXXX-XXXX
 * @return
 */
static FUNCTION_RETURN decode_pc_id(PcIdentifier identifier1_out,
        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]);
    concat_identifiers = unbase64(base64ids, 16, &identifiers_size);
    if (identifiers_size > sizeof(PcIdentifier) * 2) {
        return BUFFER_TOO_SMALL;
    }
    memcpy(identifier1_out, concat_identifiers, sizeof(PcIdentifier));
    memcpy(identifier2_out, concat_identifiers + sizeof(PcIdentifier),
            sizeof(PcIdentifier));
    free(concat_identifiers);
    return OK;
}

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

EVENT_TYPE validate_pc_signature(PcSignature str_code) {
    PcIdentifier user_identifiers[2];
    FUNCTION_RETURN result;
    IDENTIFICATION_STRATEGY previous_strategy_id, current_strategy_id;
    PcIdentifier* calculated_identifiers = NULL;
    unsigned int calc_identifiers_size = 0;
    int i = 0, j = 0;
//bool found;
#ifdef _DEBUG
    printf("Comparing pc identifiers: \n");
#endif
    result = decode_pc_id(user_identifiers[0], user_identifiers[1], str_code);
    if (result != OK) {
        return result;
    }
    previous_strategy_id = STRATEGY_UNKNOWN;
//found = false;
    for (i = 0; i < 2; i++) {
        current_strategy_id = strategy_from_pc_id(user_identifiers[i]);
        if (current_strategy_id == STRATEGY_UNKNOWN) {
            return LICENSE_MALFORMED;
        }
        if (current_strategy_id != previous_strategy_id) {
            if (calculated_identifiers != NULL) {
                free(calculated_identifiers);
            }
            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);
            generate_pc_id(calculated_identifiers, &calc_identifiers_size,
                    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);

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

 test/scratch/stackoverflow.cpp

New file
@@ -0,0 +1,187 @@
//http://stackoverflow.com/questions/16858782/how-to-obtain-almost-unique-system-identifier-in-a-cross-platform-way
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <assert.h>
#include <stdbool.h>

#ifdef DARWIN
#include <net/if_dl.h>
#include <ifaddrs.h>
#include <net/if_types.h>
#else //!DARWIN
#include <linux/if.h>
#include <linux/sockios.h>
#endif //!DARWIN

const char* getMachineName() {
    static struct utsname u;

    if (uname(&u) < 0) {
        assert(0);
        return "unknown";
    }

    return u.nodename;
}

//---------------------------------get MAC addresses ------------------------------------unsigned short-unsigned short----------
// we just need this for purposes of unique machine id. So any one or two mac's is fine.
unsigned short hashMacAddress(unsigned char* mac) {
    unsigned short hash = 0;

    for (unsigned int i = 0; i < 6; i++) {
        hash += (mac[i] << ((i & 1) * 8));
    }
    return hash;
}

void getMacHash(unsigned short *mac1, unsigned short *mac2) {
    *mac1 = 0;
    *mac2 = 0;

#ifdef DARWIN

    struct ifaddrs* ifaphead;
    if ( getifaddrs( &ifaphead ) != 0 )
    return;

    // iterate over the net interfaces
    bool foundMac1 = false;
    struct ifaddrs* ifap;
    for ( ifap = ifaphead; ifap; ifap = ifap->ifa_next )
    {
        struct sockaddr_dl* sdl = (struct sockaddr_dl*)ifap->ifa_addr;
        if ( sdl && ( sdl->sdl_family == AF_LINK ) && ( sdl->sdl_type == IFT_ETHER ))
        {
            if ( !foundMac1 )
            {
                foundMac1 = true;
                mac1 = hashMacAddress( (unsigned char*)(LLADDR(sdl))); //sdl->sdl_data) + sdl->sdl_nlen) );
            } else {
                mac2 = hashMacAddress( (unsigned char*)(LLADDR(sdl))); //sdl->sdl_data) + sdl->sdl_nlen) );
                break;
            }
        }
    }

    freeifaddrs( ifaphead );

#else // !DARWIN

    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
    if (sock < 0)
        return;

    // enumerate all IP addresses of the system
    struct ifconf conf;
    char ifconfbuf[128 * sizeof(struct ifreq)];
    memset(ifconfbuf, 0, sizeof(ifconfbuf));
    conf.ifc_buf = ifconfbuf;
    conf.ifc_len = sizeof(ifconfbuf);
    if (ioctl(sock, SIOCGIFCONF, &conf)) {
        assert(0);
        return;
    }

    // get MAC address
    bool foundMac1 = false;
    struct ifreq* ifr;
    for (ifr = conf.ifc_req; (char*) ifr < (char*) conf.ifc_req + conf.ifc_len;
            ifr++) {
        if (ifr->ifr_addr.sa_data == (ifr + 1)->ifr_addr.sa_data)
            continue;  // duplicate, skip it

        if (ioctl(sock, SIOCGIFFLAGS, ifr))
            continue;  // failed to get flags, skip it
        if (ioctl(sock, SIOCGIFHWADDR, ifr) == 0) {
            if (!foundMac1) {
                foundMac1 = true;
                *mac1 = hashMacAddress(
                        (unsigned char*) &(ifr->ifr_addr.sa_data));
            } else {
                *mac2 = hashMacAddress(
                        (unsigned char*) &(ifr->ifr_addr.sa_data));
                break;
            }
        }
    }

    close(sock);

#endif // !DARWIN

    // sort the mac addresses. We don't want to invalidate
    // both macs if they just change order.
    if (*mac1 > *mac2) {
        unsigned short tmp = *mac2;
        *mac2 = *mac1;
        *mac1 = tmp;
    }
}

unsigned short getVolumeHash() {
    // we don't have a 'volume serial number' like on windows. Lets hash the system name instead.
    unsigned char* sysname = (unsigned char*) getMachineName();
    unsigned short hash = 0;

    for (unsigned int i = 0; sysname[i]; i++)
        hash += (sysname[i] << ((i & 1) * 8));

    return hash;
}

#ifdef DARWIN
#include <mach-o/arch.h>
unsigned short getCpuHash()
{
    const NXArchInfo* info = NXGetLocalArchInfo();
    unsigned short val = 0;
    val += (unsigned short)info->cputype;
    val += (unsigned short)info->cpusubtype;
    return val;
}

#else // !DARWIN

static void getCpuid(unsigned int* p, unsigned int ax) {
    __asm __volatile
    ( "movl %%ebx, %%esi\n\t"
            "cpuid\n\t"
            "xchgl %%ebx, %%esi"
            : "=a" (p[0]), "=S" (p[1]),
            "=c" (p[2]), "=d" (p[3])
            : "0" (ax)
    );
}

unsigned short getCpuHash() {
    unsigned int cpuinfo[4] = { 0, 0, 0, 0 };
    getCpuid(cpuinfo, 0);
    unsigned short hash = 0;
    unsigned int* ptr = (&cpuinfo[0]);
    for (unsigned int i = 0; i < 4; i++)
        hash += (ptr[i] & 0xFFFF) + (ptr[i] >> 16);

    return hash;
}
#endif // !DARWIN

int main() {

    printf("Machine: %s\n", getMachineName());
    printf("CPU: %d\n", getCpuHash());
    printf("Volume: %d\n", getVolumeHash());
    return 0;
}