Merge branch 'develop' of http://139.9.88.116:3000/r/module/open-license-ma...

nancy.liao

2025-05-29 8d405b265285c368df2e9cf1c14acee7532e0ee7

 src/library/os/linux/os_linux.cpp

@@ -1,19 +1,38 @@
#include <paths.h>
#include <sys/stat.h>
#include <stdio.h>
#include <cerrno>
#include <cstring>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <string>
#include <stdio.h>
#include <string.h>
#include <sstream>
#include "../os.h"
#include "../../base/logger.h"
#include "../../base/string_utils.h"

#include <mntent.h>
#include <dirent.h>
#include <sys/utsname.h>
#ifdef _DEBUG
#include <valgrind/memcheck.h>
#endif
// #ifndef NDEBUG
// #include <valgrind/memcheck.h>
// #endif

//#ifdef USE_DISK_MODEL
///#define PARSE_ID_FUNC parse_disk_id
//#define ID_FOLDER "/dev/disk/by-id"
//#else
#define PARSE_ID_FUNC parseUUID
#define ID_FOLDER "/dev/disk/by-uuid"
//#endif
#ifdef USE_DBUS
#include <dbus-1.0/dbus/dbus.h>
#endif

using namespace license;

/**
 *Usually uuid are hex number separated by "-". this method read up to 8 hex
@@ -52,130 +71,267 @@
   free(hexuuid);
}

#define MAX_UNITS 20
FUNCTION_RETURN getDiskInfos(DiskInfo *diskInfos, size_t *disk_info_size) {
   struct stat mount_stat, sym_stat;
   /*static char discard[1024];
    char device[64], name[64], type[64];
    */
   char cur_dir[MAX_PATH];
   struct mntent *ent;

   int maxDrives, currentDrive, i, drive_found;
   __ino64_t *statDrives = NULL;
   DiskInfo *tmpDrives = NULL;
   FILE *aFile = NULL;
   DIR *disk_by_uuid_dir = NULL, *disk_by_label = NULL;
   struct dirent *dir = NULL;
   FUNCTION_RETURN result;

   if (diskInfos != NULL) {
      maxDrives = *disk_info_size;
      tmpDrives = diskInfos;
   } else {
      maxDrives = MAX_UNITS;
      tmpDrives = (DiskInfo *)malloc(sizeof(DiskInfo) * maxDrives);
static void parse_disk_id(const char *uuid, unsigned char *buffer_out, size_t out_size) {
   unsigned int i;
   size_t len = strlen(uuid);
   memset(buffer_out, 0, out_size);
   for (i = 0; i < len; i++) {
      buffer_out[i % out_size] = buffer_out[i % out_size] ^ uuid[i];
   }
   memset(tmpDrives, 0, sizeof(DiskInfo) * maxDrives);
   statDrives = (__ino64_t *)malloc(maxDrives * sizeof(__ino64_t));
   memset(statDrives, 0, sizeof(__ino64_t) * maxDrives);
}

   aFile = setmntent("/proc/mounts", "r");
   if (aFile == NULL) {
      /*proc not mounted*/
      free(tmpDrives);
      free(statDrives);
      return FUNC_RET_ERROR;
/**
 *    int id;
   char device[MAX_PATH];
   unsigned char disk_sn[8];
   char label[255];
   int preferred;
 * @param blkidfile
 * @param diskInfos_out
 * @return
 */

static std::string getAttribute(const std::string &source, const std::string &attrName) {
   std::string attr_namefull = attrName + "=\"";
   std::size_t startpos = source.find(attr_namefull) + attr_namefull.size();
   std::size_t endpos = source.find("\"", startpos);
   return source.substr(startpos, endpos - startpos);
}

FUNCTION_RETURN parse_blkid(const std::string &blkid_file_content, std::vector<DiskInfo> &diskInfos_out,
                     std::unordered_map<std::string, int> &disk_by_uuid) {
   DiskInfo diskInfo = {};
   int diskNum = 0;
   for (std::size_t oldpos = 0, pos = 0; (pos = blkid_file_content.find("</device>", oldpos)) != std::string::npos;
       oldpos = pos + 1) {
      std::string cur_dev = blkid_file_content.substr(oldpos, pos);
      diskInfo.id = diskNum++;
      std::string device = cur_dev.substr(cur_dev.find_last_of(">") + 1);
      mstrlcpy(diskInfo.device, device.c_str(), MAX_PATH);
      std::string label = getAttribute(cur_dev, "PARTLABEL");
      mstrlcpy(diskInfo.label, label.c_str(), 255);
      std::string disk_sn = getAttribute(cur_dev, "UUID");
      parseUUID(disk_sn.c_str(), diskInfo.disk_sn, sizeof(diskInfo.disk_sn));
      std::string disk_type = getAttribute(cur_dev, "TYPE");
      disk_by_uuid.insert(std::pair<std::string, int>(disk_sn, diskInfo.id));
      diskInfo.label_initialized = true;
      diskInfo.sn_initialized = true;
      // unlikely that somebody put the swap on a removable disk.
      // this is a first rough guess on what can be a preferred disk for blkid devices
      // just in case /etc/fstab can't be accessed or it is not up to date.
      diskInfo.preferred = (disk_type == "swap");
      diskInfos_out.push_back(diskInfo);
   }
   return FUNCTION_RETURN::FUNC_RET_OK;
}

#define BLKID_LOCATIONS {"/run/blkid/blkid.tab", "/etc/blkid.tab"};

static FUNCTION_RETURN getDiskInfos_blkid(std::vector<DiskInfo> &diskInfos,
                                std::unordered_map<std::string, int> &disk_by_uuid) {
   const char *strs[] = BLKID_LOCATIONS;
   bool can_read = false;
   std::stringstream buffer;
   for (int i = 0; i < sizeof(strs) / sizeof(const char *); i++) {
      const char *location = strs[i];
      std::ifstream t(location);
      if (t.is_open()) {
         buffer << t.rdbuf();
         can_read = true;
         break;
      }
   }
   if (!can_read) {
      return FUNCTION_RETURN::FUNC_RET_NOT_AVAIL;
   }

   currentDrive = 0;
   while (NULL != (ent = getmntent(aFile))) {
      if ((strncmp(ent->mnt_type, "ext", 3) == 0 || strncmp(ent->mnt_type, "xfs", 3) == 0 ||
          strncmp(ent->mnt_type, "vfat", 4) == 0 || strncmp(ent->mnt_type, "ntfs", 4) == 0
            || strncmp(ent->mnt_type, "btr", 3) == 0) &&
         ent->mnt_fsname != NULL && strncmp(ent->mnt_fsname, "/dev/", 5) == 0) {
         if (stat(ent->mnt_fsname, &mount_stat) == 0) {
            drive_found = -1;
            for (i = 0; i < currentDrive; i++) {
               if (statDrives[i] == mount_stat.st_ino) {
                  drive_found = i;
   return parse_blkid(buffer.str(), diskInfos, disk_by_uuid);
}

#define MAX_UNITS 40

static void read_disk_labels(std::vector<DiskInfo> &disk_infos) {
   struct stat sym_stat;
   struct dirent *dir;

   std::string label_dir("/dev/disk/by-label");
   DIR *disk_by_label = opendir(label_dir.c_str());
   if (disk_by_label == nullptr) {
      label_dir = "/dev/disk/by-partlabel";
      disk_by_label = opendir(label_dir.c_str());
   }
   if (disk_by_label != nullptr) {
      while ((dir = readdir(disk_by_label)) != nullptr) {
         if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
            continue;
         }
         std::string cur_disk_label = label_dir + "/" + dir->d_name;
         if (stat(cur_disk_label.c_str(), &sym_stat) == 0) {
            bool found = false;
            for (auto &diskInfo : disk_infos) {
               if (((int)(sym_stat.st_ino)) == diskInfo.id) {
                  mstrlcpy(diskInfo.label, dir->d_name, 255);
                  diskInfo.label_initialized = true;
                  LOG_DEBUG("Label for disk ino %d device %s, set to %s", sym_stat.st_ino, diskInfo.device,
                          diskInfo.label);
                  break;
               }
            }
            if (drive_found == -1) {
               LOG_DEBUG("mntent: %s %s %d\n", ent->mnt_fsname, ent->mnt_dir,
                       (unsigned long int)mount_stat.st_ino);
               strncpy(tmpDrives[currentDrive].device, ent->mnt_fsname, 255 - 1);
               statDrives[currentDrive] = mount_stat.st_ino;
               drive_found = currentDrive;
               currentDrive++;
            }
            if (strcmp(ent->mnt_dir, "/") == 0) {
               strcpy(tmpDrives[drive_found].label, "root");
               LOG_DEBUG("drive %s set to preferred\n", ent->mnt_fsname);
               tmpDrives[drive_found].preferred = 1;
            } else {
               tmpDrives[drive_found].preferred = 0;
            }
         } else {
            LOG_DEBUG("Stat %s for fail:F %s", cur_disk_label.c_str(), std::strerror(errno));
         }
      }
      closedir(disk_by_label);
   } else {
      LOG_DEBUG("Open %s for reading disk labels fail: %s", label_dir.c_str(), std::strerror(errno));
   }
   endmntent(aFile);
}

   if (diskInfos == NULL) {
      *disk_info_size = currentDrive;
      free(tmpDrives);
      result = (currentDrive > 0) ? FUNC_RET_OK : FUNC_RET_NOT_AVAIL;
   } else if (*disk_info_size >= currentDrive) {
      disk_by_uuid_dir = opendir("/dev/disk/by-uuid");
      if (disk_by_uuid_dir == NULL) {
         LOG_WARN("Open /dev/disk/by-uuid fail");
         free(statDrives);
         return FUNC_RET_ERROR;
      }
      result = FUNC_RET_OK;
      *disk_info_size = currentDrive;
      while ((dir = readdir(disk_by_uuid_dir)) != NULL) {
         strcpy(cur_dir, "/dev/disk/by-uuid/");
         strncat(cur_dir, dir->d_name, 200);
         if (stat(cur_dir, &sym_stat) == 0) {
            for (i = 0; i < currentDrive; i++) {
               if (sym_stat.st_ino == statDrives[i]) {
                  parseUUID(dir->d_name, tmpDrives[i].disk_sn, sizeof(tmpDrives[i].disk_sn));
#ifdef _DEBUG
                  VALGRIND_CHECK_VALUE_IS_DEFINED(tmpDrives[i].device);
FUNCTION_RETURN getDiskInfos_dev(std::vector<DiskInfo> &disk_infos,
                         std::unordered_map<std::string, int> &disk_by_uuid) {
   struct dirent *dir = NULL;
   struct stat sym_stat;
   FUNCTION_RETURN result;
   char device_name[MAX_PATH];

                  LOG_DEBUG("uuid %d %s %02x%02x%02x%02x\n", i, tmpDrives[i].device, tmpDrives[i].disk_sn[0],
                          tmpDrives[i].disk_sn[1], tmpDrives[i].disk_sn[2], tmpDrives[i].disk_sn[3]);
#endif
   DIR *disk_by_uuid_dir = opendir(ID_FOLDER);
   if (disk_by_uuid_dir == nullptr) {
      LOG_DEBUG("Open " ID_FOLDER " fail: %s", std::strerror(errno));
   } else {
      const std::string base_dir(ID_FOLDER "/");
      while ((dir = readdir(disk_by_uuid_dir)) != nullptr && disk_infos.size() < MAX_UNITS) {
         if (::strcmp(dir->d_name, ".") == 0 || ::strcmp(dir->d_name, "..") == 0 ||
            ::strncmp(dir->d_name, "usb", 3) == 0) {
            continue;
         }

         std::string cur_dir = base_dir + dir->d_name;
         if (stat(cur_dir.c_str(), &sym_stat) == 0) {
            DiskInfo tmpDiskInfo;
            tmpDiskInfo.id = sym_stat.st_ino;
            ssize_t len = ::readlink(cur_dir.c_str(), device_name, MAX_PATH - 1);
            if (len != -1) {
               device_name[len] = '\0';
               std::string device_name_s(device_name, len);
               auto pos = device_name_s.find_last_of("/");
               if (pos != std::string::npos) {
                  device_name_s = device_name_s.substr(pos + 1);
               }
               mstrlcpy(tmpDiskInfo.device, device_name_s.c_str(), sizeof(tmpDiskInfo.device));
               PARSE_ID_FUNC(dir->d_name, tmpDiskInfo.disk_sn, sizeof(tmpDiskInfo.disk_sn));
               tmpDiskInfo.sn_initialized = true;
               tmpDiskInfo.label_initialized = false;
               tmpDiskInfo.preferred = false;
               bool found = false;
               for (auto diskInfo : disk_infos) {
                  if (tmpDiskInfo.id == diskInfo.id) {
                     found = true;
                     break;
                  }
               }
               disk_by_uuid.insert(std::pair<std::string, int>(std::string(dir->d_name), tmpDiskInfo.id));
               if (!found) {
                  LOG_DEBUG("Found disk inode %d device %s, sn %s", sym_stat.st_ino, tmpDiskInfo.device,
                          dir->d_name);
                  disk_infos.push_back(tmpDiskInfo);
               }
            } else {
               LOG_DEBUG("Error %s during readlink of %s", std::strerror(errno), cur_dir.c_str());
            }
         } else {
            LOG_DEBUG("Error %s during stat of %s", std::strerror(errno), cur_dir.c_str());
         }
      }
      closedir(disk_by_uuid_dir);

      disk_by_label = opendir("/dev/disk/by-label");
      if (disk_by_label != NULL) {
         while ((dir = readdir(disk_by_label)) != NULL) {
            strcpy(cur_dir, "/dev/disk/by-label/");
            strcat(cur_dir, dir->d_name);
            if (stat(cur_dir, &sym_stat) == 0) {
               for (i = 0; i < currentDrive; i++) {
                  if (sym_stat.st_ino == statDrives[i]) {
                     strncpy(tmpDrives[i].label, dir->d_name, 255 - 1);
                     printf("label %d %s %s\n", i, tmpDrives[i].label, tmpDrives[i].device);
                  }
               }
            }
         }
         closedir(disk_by_label);
      }
   } else {
      result = FUNC_RET_BUFFER_TOO_SMALL;
   }
   free(statDrives);

   result = disk_infos.size() > 0 ? FUNCTION_RETURN::FUNC_RET_OK : FUNCTION_RETURN::FUNC_RET_NOT_AVAIL;
   read_disk_labels(disk_infos);
   return result;
}

/**
 * Try to determine removable devices: as a first guess removable devices doesn't have
 * an entry in /etc/fstab
 *
 * @param diskInfos
 */
static void set_preferred_disks(std::vector<DiskInfo> &diskInfos, std::unordered_map<std::string, int> &disk_by_uuid) {
   FILE *fstabFile = setmntent("/etc/fstab", "r");
   if (fstabFile == nullptr) {
      LOG_DEBUG("/etc/fstab not accessible");
      return;
   }
   struct mntent *ent;
   while (nullptr != (ent = getmntent(fstabFile))) {
      bool found = false;
      std::string device_name_s(ent->mnt_fsname);
      LOG_DEBUG("found fstab entry %s ", ent->mnt_fsname);
      if (strncmp("UUID=", ent->mnt_fsname, 5) == 0) {
         // fstab entry is uuid
         device_name_s = device_name_s.substr(5);
         auto it = disk_by_uuid.find(device_name_s);
         if (it != disk_by_uuid.end()) {
            for (auto &disk_info : diskInfos) {
               if (it->second == disk_info.id) {
                  disk_info.preferred = true;
                  LOG_DEBUG("Disk %d device %s set as preferred", disk_info.id, disk_info.device);
                  break;
               }
            }
         } else {
            LOG_DEBUG("fstab device %s found, but no corresponding diskInfo", ent->mnt_fsname);
         }
      } else if (strncmp("LABEL=", ent->mnt_fsname, 6) == 0) {
         // fstab entry is uuid
         device_name_s = device_name_s.substr(6);
         for (auto &disk_info : diskInfos) {
            if (device_name_s == disk_info.label) {
               disk_info.preferred = true;
               LOG_DEBUG("Disk %d device %s set as preferred", disk_info.id, disk_info.device);
               break;
            }
         }
      } else {
         // fstab entry is a device
         auto pos = device_name_s.find_last_of("/");
         if (pos != std::string::npos) {
            device_name_s = device_name_s.substr(pos + 1);
         }

         for (auto disk_info : diskInfos) {
            if (device_name_s == disk_info.device) {
               disk_info.preferred = true;
               LOG_DEBUG("Disk %d device %s set as preferred", disk_info.id, disk_info.device);
               break;
            }
         }
      }
   }
   endmntent(fstabFile);
   return;
}

/**
 * First try to read disk_infos from /dev/disk/by-uuid folder, if fails try to use
 * blkid cache to see what's in there, then try to exclude removable disks
 * looking at /etc/fstab
 * @param diskInfos_out vector used to output the disk informations
 * @return
 */
FUNCTION_RETURN getDiskInfos(std::vector<DiskInfo> &disk_infos) {
   std::unordered_map<std::string, int> disk_by_uuid;

   FUNCTION_RETURN result = getDiskInfos_dev(disk_infos, disk_by_uuid);

   if (result != FUNCTION_RETURN::FUNC_RET_OK) {
      result = getDiskInfos_blkid(disk_infos, disk_by_uuid);
   }
   if (result == FUNCTION_RETURN::FUNC_RET_OK) {
      set_preferred_disks(disk_infos, disk_by_uuid);
   }
   return result;
}

FUNCTION_RETURN getMachineName(unsigned char identifier[6]) {
   static struct utsname u;
@@ -212,12 +368,11 @@
   strcat(proc_path, "/exe");

   int ch = readlink(proc_path, path, MAX_PATH - 1);
   if (ch != -1) {
      path[ch] = '\0';
      strncpy(buffer, path, ch);
      result = FUNC_RET_OK;
   } else {
   if (ch > MAX_PATH || ch < 0) {
      result = FUNC_RET_ERROR;
   } else {
      mstrlcpy(buffer, path, ch + 1);
      result = FUNC_RET_OK;
   }
   return result;
}