@oxmc/node-smbios 1.0.0

package/src/mac/smbios_macos.cpp

@@ -0,0 +1,224 @@
+#include "../smbios_common.h"
+
+#ifdef __APPLE__
+
+#include <IOKit/IOKitLib.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <string>
+
+namespace smbios {
+
+/**
+ * Helper function to get string property from IORegistry
+ */
+std::string GetIORegistryString(const char* service, const char* property) {
+    std::string result;
+    
+    io_service_t platformExpert = IOServiceGetMatchingService(
+        kIOMasterPortDefault,
+        IOServiceMatching(service)
+    );
+    
+    if (platformExpert) {
+        CFTypeRef cfProperty = IORegistryEntryCreateCFProperty(
+            platformExpert,
+            CFStringCreateWithCString(kCFAllocatorDefault, property, kCFStringEncodingUTF8),
+            kCFAllocatorDefault,
+            0
+        );
+        
+        if (cfProperty) {
+            if (CFGetTypeID(cfProperty) == CFStringGetTypeID()) {
+                CFStringRef cfString = (CFStringRef)cfProperty;
+                CFIndex length = CFStringGetLength(cfString);
+                CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
+                char* buffer = new char[maxSize];
+                
+                if (CFStringGetCString(cfString, buffer, maxSize, kCFStringEncodingUTF8)) {
+                    result = buffer;
+                }
+                
+                delete[] buffer;
+            } else if (CFGetTypeID(cfProperty) == CFDataGetTypeID()) {
+                CFDataRef cfData = (CFDataRef)cfProperty;
+                CFIndex length = CFDataGetLength(cfData);
+                const UInt8* bytes = CFDataGetBytePtr(cfData);
+                result = std::string((const char*)bytes, length);
+                
+                // Remove null terminators
+                size_t pos = result.find('\0');
+                if (pos != std::string::npos) {
+                    result = result.substr(0, pos);
+                }
+            }
+            
+            CFRelease(cfProperty);
+        }
+        
+        IOObjectRelease(platformExpert);
+    }
+    
+    return TrimString(result);
+}
+
+/**
+ * Helper function to get data property as hex string (for UUID)
+ */
+std::string GetIORegistryUUID(const char* service, const char* property) {
+    std::string result;
+    
+    io_service_t platformExpert = IOServiceGetMatchingService(
+        kIOMasterPortDefault,
+        IOServiceMatching(service)
+    );
+    
+    if (platformExpert) {
+        CFTypeRef cfProperty = IORegistryEntryCreateCFProperty(
+            platformExpert,
+            CFStringCreateWithCString(kCFAllocatorDefault, property, kCFStringEncodingUTF8),
+            kCFAllocatorDefault,
+            0
+        );
+        
+        if (cfProperty) {
+            if (CFGetTypeID(cfProperty) == CFStringGetTypeID()) {
+                CFStringRef cfString = (CFStringRef)cfProperty;
+                CFIndex length = CFStringGetLength(cfString);
+                CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8) + 1;
+                char* buffer = new char[maxSize];
+                
+                if (CFStringGetCString(cfString, buffer, maxSize, kCFStringEncodingUTF8)) {
+                    result = buffer;
+                }
+                
+                delete[] buffer;
+            }
+            
+            CFRelease(cfProperty);
+        }
+        
+        IOObjectRelease(platformExpert);
+    }
+    
+    return TrimString(result);
+}
+
+BiosInfo GetBiosInfo() {
+    BiosInfo info;
+    
+    // On macOS, BIOS info is limited
+    info.vendor = "Apple Inc.";
+    info.version = GetIORegistryString("IOPlatformExpertDevice", "version");
+    info.releaseDate = GetIORegistryString("IOPlatformExpertDevice", "release-date");
+    
+    // Try getting boot ROM version
+    std::string bootRomVersion = GetIORegistryString("IOPlatformExpertDevice", "target-type");
+    if (!bootRomVersion.empty()) {
+        info.version = bootRomVersion;
+    }
+    
+    // Get ROM version
+    std::string romVersion = GetIORegistryString("IOPlatformExpertDevice", "version-major");
+    if (!romVersion.empty()) {
+        info.biosCharacteristics = "ROM Version: " + romVersion;
+    }
+    
+    return info;
+}
+
+SystemInfo GetSystemInfo() {
+    SystemInfo info;
+    
+    info.manufacturer = "Apple Inc.";
+    info.productName = GetIORegistryString("IOPlatformExpertDevice", "model");
+    info.serialNumber = GetIORegistryString("IOPlatformExpertDevice", "IOPlatformSerialNumber");
+    info.uuid = GetIORegistryUUID("IOPlatformExpertDevice", "IOPlatformUUID");
+    
+    // Get additional info
+    std::string modelName = GetIORegistryString("IOPlatformExpertDevice", "model-name");
+    if (!modelName.empty()) {
+        info.family = modelName;
+    }
+    
+    info.skuNumber = GetIORegistryString("IOPlatformExpertDevice", "model-number");
+    info.wakeUpType = GetIORegistryString("IOPlatformExpertDevice", "clock-frequency");
+    
+    return info;
+}
+
+BoardInfo GetBoardInfo() {
+    BoardInfo info;
+    
+    info.manufacturer = "Apple Inc.";
+    info.product = GetIORegistryString("IOPlatformExpertDevice", "board-id");
+    info.serialNumber = GetIORegistryString("IOPlatformExpertDevice", "IOPlatformSerialNumber");
+    
+    // Try to get more board info
+    std::string modelNumber = GetIORegistryString("IOPlatformExpertDevice", "model-number");
+    if (!modelNumber.empty()) {
+        info.version = modelNumber;
+    }
+    
+    info.assetTag = GetIORegistryString("IOPlatformExpertDevice", "target-type");
+    info.locationInChassis = GetIORegistryString("IOPlatformExpertDevice", "product-name");
+    
+    return info;
+}
+
+ProcessorInfo GetProcessorInfo() {
+    ProcessorInfo info;
+    
+    // Get CPU info from sysctl or IORegistry
+    info.manufacturer = GetIORegistryString("IODeviceTree:/cpus/cpu@0", "vendor");
+    if (info.manufacturer.empty()) {
+        info.manufacturer = "Apple";
+    }
+    
+    info.version = GetIORegistryString("IODeviceTree:/cpus/cpu@0", "name");
+    info.socketDesignation = GetIORegistryString("IOPlatformExpertDevice", "target-type");
+    info.processorType = GetIORegistryString("IODeviceTree:/cpus/cpu@0", "device_type");
+    info.processorFamily = GetIORegistryString("IOPlatformExpertDevice", "compatible");
+    
+    // Note: More detailed CPU info would require sysctlbyname calls
+    info.maxSpeed = "N/A (use sysctl for detailed info)";
+    info.currentSpeed = "N/A";
+    info.coreCount = "N/A";
+    info.threadCount = "N/A";
+    info.l2CacheSize = "N/A";
+    info.l3CacheSize = "N/A";
+    
+    return info;
+}
+
+MemoryInfo GetMemoryInfo() {
+    MemoryInfo info;
+    
+    // Note: Full implementation would use sysctlbyname
+    info.totalPhysicalMemory = "N/A (use sysctl hw.memsize)";
+    info.availablePhysicalMemory = "N/A";
+    info.totalVirtualMemory = "N/A";
+    info.availableVirtualMemory = "N/A";
+    info.memoryDevices = "N/A";
+    info.maxCapacity = "N/A";
+    
+    return info;
+}
+
+ChassisInfo GetChassisInfo() {
+    ChassisInfo info;
+    
+    info.manufacturer = "Apple Inc.";
+    info.type = GetIORegistryString("IOPlatformExpertDevice", "product-name");
+    info.version = GetIORegistryString("IOPlatformExpertDevice", "version");
+    info.serialNumber = GetIORegistryString("IOPlatformExpertDevice", "IOPlatformSerialNumber");
+    info.assetTag = GetIORegistryString("IOPlatformExpertDevice", "model");
+    info.bootUpState = "Normal";
+    info.powerSupplyState = "Safe";
+    info.thermalState = "Safe";
+    
+    return info;
+}
+
+} // namespace smbios
+
+#endif // __APPLE__

package/src/smbios_common.cpp

@@ -0,0 +1,70 @@
+#include "smbios_common.h"
+#include <algorithm>
+#include <cctype>
+#include <fstream>
+#include <sstream>
+
+#ifdef _WIN32
+#include <sys/stat.h>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+namespace smbios {
+
+/**
+ * Trim whitespace from both ends of a string
+ */
+std::string TrimString(const std::string& str) {
+    size_t start = 0;
+    size_t end = str.length();
+    
+    // Trim from start
+    while (start < end && std::isspace(static_cast<unsigned char>(str[start]))) {
+        start++;
+    }
+    
+    // Trim from end
+    while (end > start && std::isspace(static_cast<unsigned char>(str[end - 1]))) {
+        end--;
+    }
+    
+    return str.substr(start, end - start);
+}
+
+/**
+ * Check if a file exists
+ */
+bool FileExists(const std::string& path) {
+#ifdef _WIN32
+    struct _stat buffer;
+    return (_stat(path.c_str(), &buffer) == 0);
+#else
+    struct stat buffer;
+    return (stat(path.c_str(), &buffer) == 0);
+#endif
+}
+
+/**
+ * Read entire file contents
+ */
+std::string ReadFile(const std::string& path) {
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        return "";
+    }
+    
+    std::stringstream buffer;
+    buffer << file.rdbuf();
+    std::string content = buffer.str();
+    
+    // Remove trailing newlines
+    while (!content.empty() && (content.back() == '\n' || content.back() == '\r')) {
+        content.pop_back();
+    }
+    
+    return TrimString(content);
+}
+
+} // namespace smbios

package/src/smbios_common.h

@@ -0,0 +1,107 @@
+#ifndef SMBIOS_COMMON_H
+#define SMBIOS_COMMON_H
+
+#include <string>
+#include <vector>
+
+namespace smbios {
+
+/**
+ * BIOS Information structure
+ */
+struct BiosInfo {
+    std::string vendor;
+    std::string version;
+    std::string releaseDate;
+    std::string biosCharacteristics;
+};
+
+/**
+ * System Information structure
+ */
+struct SystemInfo {
+    std::string manufacturer;
+    std::string productName;
+    std::string serialNumber;
+    std::string uuid;
+    std::string skuNumber;
+    std::string family;
+    std::string wakeUpType;
+};
+
+/**
+ * Board/Baseboard Information structure
+ */
+struct BoardInfo {
+    std::string manufacturer;
+    std::string product;
+    std::string version;
+    std::string serialNumber;
+    std::string assetTag;
+    std::string locationInChassis;
+};
+
+/**
+ * Processor Information structure
+ */
+struct ProcessorInfo {
+    std::string manufacturer;
+    std::string version;
+    std::string socketDesignation;
+    std::string processorType;
+    std::string processorFamily;
+    std::string maxSpeed;
+    std::string currentSpeed;
+    std::string coreCount;
+    std::string threadCount;
+    std::string l2CacheSize;
+    std::string l3CacheSize;
+};
+
+/**
+ * Memory Information structure
+ */
+struct MemoryInfo {
+    std::string totalPhysicalMemory;
+    std::string availablePhysicalMemory;
+    std::string totalVirtualMemory;
+    std::string availableVirtualMemory;
+    std::string memoryDevices;
+    std::string maxCapacity;
+};
+
+/**
+ * Chassis Information structure
+ */
+struct ChassisInfo {
+    std::string manufacturer;
+    std::string type;
+    std::string version;
+    std::string serialNumber;
+    std::string assetTag;
+    std::string bootUpState;
+    std::string powerSupplyState;
+    std::string thermalState;
+};
+
+/**
+ * Platform-specific implementations
+ * These functions must be implemented for each platform
+ */
+BiosInfo GetBiosInfo();
+SystemInfo GetSystemInfo();
+BoardInfo GetBoardInfo();
+ProcessorInfo GetProcessorInfo();
+MemoryInfo GetMemoryInfo();
+ChassisInfo GetChassisInfo();
+
+/**
+ * Utility functions
+ */
+std::string TrimString(const std::string& str);
+bool FileExists(const std::string& path);
+std::string ReadFile(const std::string& path);
+
+} // namespace smbios
+
+#endif // SMBIOS_COMMON_H

package/src/windows/smbios_windows.cpp

@@ -0,0 +1,255 @@
+#include "../smbios_common.h"
+
+#ifdef _WIN32
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <comdef.h>
+#include <Wbemidl.h>
+#include <string>
+#include <vector>
+
+#pragma comment(lib, "wbemuuid.lib")
+
+namespace smbios {
+
+/**
+ * Helper class for WMI queries
+ */
+class WMIQuery {
+private:
+    IWbemLocator* pLoc;
+    IWbemServices* pSvc;
+    bool initialized;
+
+public:
+    WMIQuery() : pLoc(nullptr), pSvc(nullptr), initialized(false) {
+        // Initialize COM
+        HRESULT hres = CoInitializeEx(0, COINIT_MULTITHREADED);
+        if (FAILED(hres) && hres != RPC_E_CHANGED_MODE) {
+            return;
+        }
+
+        // Set general COM security levels
+        hres = CoInitializeSecurity(
+            NULL, -1, NULL, NULL,
+            RPC_C_AUTHN_LEVEL_DEFAULT,
+            RPC_C_IMP_LEVEL_IMPERSONATE,
+            NULL, EOAC_NONE, NULL
+        );
+
+        if (FAILED(hres) && hres != RPC_E_TOO_LATE) {
+            CoUninitialize();
+            return;
+        }
+
+        // Obtain the initial locator to WMI
+        hres = CoCreateInstance(
+            CLSID_WbemLocator, 0,
+            CLSCTX_INPROC_SERVER,
+            IID_IWbemLocator, (LPVOID*)&pLoc
+        );
+
+        if (FAILED(hres)) {
+            CoUninitialize();
+            return;
+        }
+
+        // Connect to WMI
+        hres = pLoc->ConnectServer(
+            _bstr_t(L"ROOT\\CIMV2"), NULL, NULL, 0,
+            NULL, 0, 0, &pSvc
+        );
+
+        if (FAILED(hres)) {
+            pLoc->Release();
+            CoUninitialize();
+            return;
+        }
+
+        // Set security levels on the proxy
+        hres = CoSetProxyBlanket(
+            pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
+            RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE,
+            NULL, EOAC_NONE
+        );
+
+        if (FAILED(hres)) {
+            pSvc->Release();
+            pLoc->Release();
+            CoUninitialize();
+            return;
+        }
+
+        initialized = true;
+    }
+
+    ~WMIQuery() {
+        if (pSvc) pSvc->Release();
+        if (pLoc) pLoc->Release();
+        CoUninitialize();
+    }
+
+    std::string QueryProperty(const wchar_t* wmiClass, const wchar_t* property) {
+        if (!initialized) return "";
+
+        std::wstring query = L"SELECT ";
+        query += property;
+        query += L" FROM ";
+        query += wmiClass;
+
+        IEnumWbemClassObject* pEnumerator = NULL;
+        HRESULT hres = pSvc->ExecQuery(
+            bstr_t("WQL"),
+            bstr_t(query.c_str()),
+            WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
+            NULL, &pEnumerator
+        );
+
+        if (FAILED(hres)) {
+            return "";
+        }
+
+        IWbemClassObject* pclsObj = NULL;
+        ULONG uReturn = 0;
+        std::string result;
+
+        while (pEnumerator) {
+            HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+            if (0 == uReturn) {
+                break;
+            }
+
+            VARIANT vtProp;
+            VariantInit(&vtProp);
+            hr = pclsObj->Get(property, 0, &vtProp, 0, 0);
+            
+            if (SUCCEEDED(hr)) {
+                if (vtProp.vt == VT_BSTR) {
+                    _bstr_t bstr(vtProp.bstrVal);
+                    result = (char*)bstr;
+                } else if (vtProp.vt == VT_I4 || vtProp.vt == VT_UI4) {
+                    result = std::to_string(vtProp.lVal);
+                } else if (vtProp.vt == VT_I2 || vtProp.vt == VT_UI2) {
+                    result = std::to_string(vtProp.iVal);
+                } else if (vtProp.vt == VT_UI1) {
+                    result = std::to_string(vtProp.bVal);
+                }
+            }
+            
+            VariantClear(&vtProp);
+            pclsObj->Release();
+            break; // Get only first result
+        }
+
+        pEnumerator->Release();
+        return TrimString(result);
+    }
+};
+
+BiosInfo GetBiosInfo() {
+    BiosInfo info;
+    WMIQuery wmi;
+    
+    info.vendor = wmi.QueryProperty(L"Win32_BIOS", L"Manufacturer");
+    info.version = wmi.QueryProperty(L"Win32_BIOS", L"SMBIOSBIOSVersion");
+    info.releaseDate = wmi.QueryProperty(L"Win32_BIOS", L"ReleaseDate");
+    info.biosCharacteristics = wmi.QueryProperty(L"Win32_BIOS", L"BIOSVersion");
+    
+    return info;
+}
+
+SystemInfo GetSystemInfo() {
+    SystemInfo info;
+    WMIQuery wmi;
+    
+    info.manufacturer = wmi.QueryProperty(L"Win32_ComputerSystem", L"Manufacturer");
+    info.productName = wmi.QueryProperty(L"Win32_ComputerSystem", L"Model");
+    info.uuid = wmi.QueryProperty(L"Win32_ComputerSystemProduct", L"UUID");
+    info.wakeUpType = wmi.QueryProperty(L"Win32_ComputerSystem", L"WakeUpType");
+    
+    // Try to get serial number from ComputerSystemProduct
+    std::string serial = wmi.QueryProperty(L"Win32_ComputerSystemProduct", L"IdentifyingNumber");
+    if (serial.empty() || serial == "To Be Filled By O.E.M.") {
+        serial = wmi.QueryProperty(L"Win32_BIOS", L"SerialNumber");
+    }
+    info.serialNumber = serial;
+    
+    info.skuNumber = wmi.QueryProperty(L"Win32_ComputerSystemProduct", L"SKUNumber");
+    info.family = wmi.QueryProperty(L"Win32_ComputerSystemProduct", L"Version");
+    
+    return info;
+}
+
+BoardInfo GetBoardInfo() {
+    BoardInfo info;
+    WMIQuery wmi;
+    
+    info.manufacturer = wmi.QueryProperty(L"Win32_BaseBoard", L"Manufacturer");
+    info.product = wmi.QueryProperty(L"Win32_BaseBoard", L"Product");
+    info.version = wmi.QueryProperty(L"Win32_BaseBoard", L"Version");
+    info.serialNumber = wmi.QueryProperty(L"Win32_BaseBoard", L"SerialNumber");
+    info.assetTag = wmi.QueryProperty(L"Win32_BaseBoard", L"Tag");
+    info.locationInChassis = wmi.QueryProperty(L"Win32_BaseBoard", L"Model");
+    
+    return info;
+}
+
+ProcessorInfo GetProcessorInfo() {
+    ProcessorInfo info;
+    WMIQuery wmi;
+    
+    info.manufacturer = wmi.QueryProperty(L"Win32_Processor", L"Manufacturer");
+    info.version = wmi.QueryProperty(L"Win32_Processor", L"Name");
+    info.socketDesignation = wmi.QueryProperty(L"Win32_Processor", L"SocketDesignation");
+    info.processorType = wmi.QueryProperty(L"Win32_Processor", L"Architecture");
+    info.processorFamily = wmi.QueryProperty(L"Win32_Processor", L"Family");
+    info.maxSpeed = wmi.QueryProperty(L"Win32_Processor", L"MaxClockSpeed");
+    info.currentSpeed = wmi.QueryProperty(L"Win32_Processor", L"CurrentClockSpeed");
+    info.coreCount = wmi.QueryProperty(L"Win32_Processor", L"NumberOfCores");
+    info.threadCount = wmi.QueryProperty(L"Win32_Processor", L"NumberOfLogicalProcessors");
+    info.l2CacheSize = wmi.QueryProperty(L"Win32_Processor", L"L2CacheSize");
+    info.l3CacheSize = wmi.QueryProperty(L"Win32_Processor", L"L3CacheSize");
+    
+    return info;
+}
+
+MemoryInfo GetMemoryInfo() {
+    MemoryInfo info;
+    WMIQuery wmi;
+    
+    info.totalPhysicalMemory = wmi.QueryProperty(L"Win32_ComputerSystem", L"TotalPhysicalMemory");
+    info.maxCapacity = wmi.QueryProperty(L"Win32_PhysicalMemoryArray", L"MaxCapacity");
+    info.memoryDevices = wmi.QueryProperty(L"Win32_PhysicalMemoryArray", L"MemoryDevices");
+    
+    // Get available memory from OS
+    MEMORYSTATUSEX memStatus;
+    memStatus.dwLength = sizeof(memStatus);
+    if (GlobalMemoryStatusEx(&memStatus)) {
+        info.availablePhysicalMemory = std::to_string(memStatus.ullAvailPhys);
+        info.totalVirtualMemory = std::to_string(memStatus.ullTotalVirtual);
+        info.availableVirtualMemory = std::to_string(memStatus.ullAvailVirtual);
+    }
+    
+    return info;
+}
+
+ChassisInfo GetChassisInfo() {
+    ChassisInfo info;
+    WMIQuery wmi;
+    
+    info.manufacturer = wmi.QueryProperty(L"Win32_SystemEnclosure", L"Manufacturer");
+    info.type = wmi.QueryProperty(L"Win32_SystemEnclosure", L"ChassisTypes");
+    info.version = wmi.QueryProperty(L"Win32_SystemEnclosure", L"Version");
+    info.serialNumber = wmi.QueryProperty(L"Win32_SystemEnclosure", L"SerialNumber");
+    info.assetTag = wmi.QueryProperty(L"Win32_SystemEnclosure", L"SMBIOSAssetTag");
+    info.bootUpState = wmi.QueryProperty(L"Win32_ComputerSystem", L"BootupState");
+    info.powerSupplyState = wmi.QueryProperty(L"Win32_ComputerSystem", L"PowerState");
+    info.thermalState = wmi.QueryProperty(L"Win32_ComputerSystem", L"ThermalState");
+    
+    return info;
+}
+
+} // namespace smbios
+
+#endif // _WIN32