Issues #14 and #6

gcontini

2020-02-24 d4edbb5a0aae0211389ce86264809b4237c73769

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
/*
 * disk_strategy.cpp
 *
 *  Created on: Jan 14, 2020
 *      Author: devel
 */
#include <string.h>
#include "../os/os.h"
#include "disk_strategy.hpp"
 
using namespace std;
namespace license {
namespace hw_identifier {
 
static FUNCTION_RETURN generate_disk_pc_id(vector<array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA>> &v_disk_id,
                                           bool use_id) {
    size_t disk_num = 0;
    size_t available_disk_info = 0;
    FUNCTION_RETURN result_diskinfos;
    unsigned int i;
 
    result_diskinfos = getDiskInfos(nullptr, &disk_num);
    if (result_diskinfos != FUNC_RET_OK && result_diskinfos != FUNC_RET_BUFFER_TOO_SMALL) {
        return result_diskinfos;
    }
    if (disk_num == 0) {
        return FUNC_RET_NOT_AVAIL;
    }
    size_t mem = disk_num * sizeof(DiskInfo);
    DiskInfo *diskInfos = (DiskInfo *)malloc(mem);
    if (diskInfos == nullptr) {
        return FUNC_RET_NOT_AVAIL;
    }
    memset(diskInfos, 0, mem);
    result_diskinfos = getDiskInfos(diskInfos, &disk_num);
    
    if (result_diskinfos != FUNC_RET_OK) {
        free(diskInfos);
        return result_diskinfos;
    }
    for (i = 0; i < disk_num; i++) {
        char firstChar = use_id ? diskInfos[i].label[0] : diskInfos[i].disk_sn[0];
        available_disk_info += firstChar == 0 ? 0 : 1;
    }
    if (available_disk_info == 0) {
        free(diskInfos);
        return FUNC_RET_NOT_AVAIL;
    }
    v_disk_id.reserve(available_disk_info);
    //FIXME use preferred drive.
    for (i = 0; i < disk_num; i++) {
        array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> a_disk_id;
        a_disk_id.fill(0);
        if (use_id) {
            if (diskInfos[i].disk_sn[0] != 0) {
                size_t size = min(a_disk_id.size(), sizeof(&diskInfos[i].disk_sn));
                memcpy(&a_disk_id[0], diskInfos[i].disk_sn, size);
                v_disk_id.push_back(a_disk_id);
            }
        } else {
            if (diskInfos[i].label[0] != 0) {
                strncpy((char *)&a_disk_id[0], diskInfos[i].label, a_disk_id.size()-1);
                v_disk_id.push_back(a_disk_id);
            }
        }
    }
    free(diskInfos);
    return FUNC_RET_OK;
}
 
DiskStrategy::DiskStrategy(bool use_id) : m_use_id(use_id) {}
 
DiskStrategy::~DiskStrategy() {}
 
LCC_API_IDENTIFICATION_STRATEGY DiskStrategy::identification_strategy() const {
    return m_use_id ? STRATEGY_DISK_NUM : STRATEGY_DISK_LABEL;
}
 
std::vector<HwIdentifier> DiskStrategy::alternative_ids() const {
    vector<array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA>> data;
    FUNCTION_RETURN result = generate_disk_pc_id(data, m_use_id);
    vector<HwIdentifier> identifiers;
    if (result == FUNC_RET_OK) {
        identifiers.resize(data.size());
        for (auto &it : data) {
            HwIdentifier pc_id;
            pc_id.set_identification_strategy(identification_strategy());
            pc_id.set_data(it);
            identifiers.push_back(pc_id);
        }
    }
    return identifiers;
}
 
}  // namespace hw_identifier
} /* namespace license */