test boost install

gcontini

2021-05-19 90ff59fbd8e41b457576116e87a6a79c44b678ed

 src/library/hw_identifier/disk_strategy.cpp

@@ -12,73 +12,62 @@
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, available_disk_info = 0;
   FUNCTION_RETURN result_diskinfos;
   unsigned int i;
   DiskInfo *diskInfos;
static array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> generate_id_by_sn(const DiskInfo &disk_info) {
   array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> a_disk_id = {};
   size_t size = min((size_t) HW_IDENTIFIER_PROPRIETARY_DATA,
         sizeof(disk_info.disk_sn));
   memcpy(&a_disk_id[0], disk_info.disk_sn, size);

   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;
   }
   return a_disk_id;
}

   diskInfos = (DiskInfo *)malloc(disk_num * sizeof(DiskInfo));
   if (diskInfos == nullptr) {
      return FUNC_RET_NOT_AVAIL;
   }
   memset(diskInfos, 0, disk_num * sizeof(DiskInfo));
   result_diskinfos = getDiskInfos(diskInfos, &disk_num);
static array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> generate_id_by_label(const DiskInfo &disk_info) {
   array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> a_disk_id = {};
   strncpy((char *)&a_disk_id[0], disk_info.label, a_disk_id.size() - 1);
   return a_disk_id;
}

static FUNCTION_RETURN generate_disk_pc_id(vector<array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA>> &v_disk_id) {
   std::vector<DiskInfo> disk_infos;
   FUNCTION_RETURN result_diskinfos = getDiskInfos(disk_infos);
   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);
   if (disk_infos.size() == 0) {
      return FUNC_RET_NOT_AVAIL;
   }
   v_disk_id.reserve(available_disk_info);
   for (i = 0; i < disk_num; i++) {
      array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> a_disk_id;
      if (use_id) {
         if (diskInfos[i].disk_sn[0] != 0) {
            memcpy(&a_disk_id[0], &diskInfos[i].disk_sn[2], a_disk_id.size());
            v_disk_id.push_back(a_disk_id);
         }
      } else {
         if (diskInfos[i].label[0] != 0) {
            a_disk_id.fill(0);
            strncpy((char *)&a_disk_id[0], diskInfos[i].label, a_disk_id.size());
            v_disk_id.push_back(a_disk_id);

   v_disk_id.reserve(disk_infos.size() * 2);
   for (int j = 0; j < 2; j++) {
      bool preferred = (j == 0);
      for (size_t i = 0; i < disk_infos.size(); i++) {
         if (disk_infos[i].preferred == preferred) {
            if (disk_infos[i].sn_initialized) {
               array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> a_disk_id = generate_id_by_sn(disk_infos[i]);
               v_disk_id.push_back(a_disk_id);
            }
            if (disk_infos[i].label_initialized) {
               array<uint8_t, HW_IDENTIFIER_PROPRIETARY_DATA> l_disk_id = generate_id_by_label(disk_infos[i]);
               v_disk_id.push_back(l_disk_id);
            }
         }
      }
   }
   free(diskInfos);
   return FUNC_RET_OK;
   return v_disk_id.size() > 0 ? FUNC_RET_OK : FUNC_RET_NOT_AVAIL;
}

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;
LCC_API_HW_IDENTIFICATION_STRATEGY DiskStrategy::identification_strategy() const {
   return LCC_API_HW_IDENTIFICATION_STRATEGY::STRATEGY_DISK;
}

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);
   FUNCTION_RETURN result = generate_disk_pc_id(data);
   vector<HwIdentifier> identifiers;
   if (result == FUNC_RET_OK) {
      identifiers.resize(data.size());
      identifiers.reserve(data.size());
      for (auto &it : data) {
         HwIdentifier pc_id;
         pc_id.set_identification_strategy(identification_strategy());