Chassis (Windows): add detectWithWmi to detect chassis version and chassis vendor

src/util/windows/wmi.cpp

@@ -1,6 +1,10 @@
 #include "wmi.hpp"
 #include "util/windows/com.hpp"
 
+extern "C" {
+#include "util/windows/unicode.h"
+}
+
 #include <synchapi.h>
 #include <wchar.h>
 #include <math.h>
@@ -144,8 +148,7 @@ bool FFWmiRecord::getString(const wchar_t* key, FFstrbuf* strbuf)
 {
     bool result = true;
 
-    VARIANT vtProp;
-    VariantInit(&vtProp);
+    FFWmiVariant vtProp;
 
     CIMTYPE type;
     if(FAILED(obj->Get(key, 0, &vtProp, &type, nullptr)) || vtProp.vt != VT_BSTR)
@@ -180,13 +183,12 @@ bool FFWmiRecord::getString(const wchar_t* key, FFstrbuf* strbuf)
                 ffStrbufAppendS(strbuf, vtProp.pcVal);
                 break;
 
-            case VT_LPWSTR: // TODO
+            case VT_LPWSTR:
             default:
-                result = false;
+                ffStrbufSetWS(strbuf, vtProp.bstrVal);
                 break;
         }
     }
-    VariantClear(&vtProp);
     return result;
 }
 
@@ -194,8 +196,7 @@ bool FFWmiRecord::getSigned(const wchar_t* key, int64_t* integer)
 {
     bool result = true;
 
-    VARIANT vtProp;
-    VariantInit(&vtProp);
+    FFWmiVariant vtProp;
 
     CIMTYPE type;
     if(FAILED(obj->Get(key, 0, &vtProp, &type, nullptr)))
@@ -221,7 +222,6 @@ bool FFWmiRecord::getSigned(const wchar_t* key, int64_t* integer)
             default: *integer = 0; result = false;
         }
     }
-    VariantClear(&vtProp);
     return result;
 }
 
@@ -229,8 +229,7 @@ bool FFWmiRecord::getUnsigned(const wchar_t* key, uint64_t* integer)
 {
     bool result = true;
 
-    VARIANT vtProp;
-    VariantInit(&vtProp);
+    FFWmiVariant vtProp;
 
     if(FAILED(obj->Get(key, 0, &vtProp, nullptr, nullptr)))
     {
@@ -255,7 +254,6 @@ bool FFWmiRecord::getUnsigned(const wchar_t* key, uint64_t* integer)
             default: *integer = 0; result = false;
         }
     }
-    VariantClear(&vtProp);
     return result;
 }
 
@@ -263,8 +261,7 @@ bool FFWmiRecord::getReal(const wchar_t* key, double* real)
 {
     bool result = true;
 
-    VARIANT vtProp;
-    VariantInit(&vtProp);
+    FFWmiVariant vtProp;
 
     if(FAILED(obj->Get(key, 0, &vtProp, nullptr, nullptr)))
     {
@@ -291,6 +288,5 @@ bool FFWmiRecord::getReal(const wchar_t* key, double* real)
             default: *real = NAN; result = false;
         }
     }
-    VariantClear(&vtProp);
     return result;
 }

src/util/windows/wmi.hpp

@@ -11,6 +11,9 @@ extern "C" {
 
 #include <initguid.h>
 #include <Wbemidl.h>
+#include <utility>
+#include <string_view>
+#include <cassert>
 
 enum class FFWmiNamespace {
     CIMV2,
@@ -74,6 +77,117 @@ struct FFWmiQuery
     }
 };
 
+struct FFWmiVariant: VARIANT {
+    explicit FFWmiVariant() { VariantInit(this); }
+    ~FFWmiVariant() { VariantClear(this); }
+
+    FFWmiVariant(const FFWmiVariant&) = delete;
+
+    // boolean
+    explicit operator bool() {
+        assert(this->vt == VT_BOOL);
+        return this->boolVal != VARIANT_FALSE;
+    }
+
+    // signed
+    explicit operator int8_t() {
+        assert(this->vt == VT_I1);
+        return this->cVal;
+    }
+    explicit operator int16_t() {
+        assert(vt == VT_I2);
+        return this->iVal;
+    }
+    explicit operator int32_t() {
+        assert(this->vt == VT_I4 || vt == VT_INT);
+        return this->intVal;
+    }
+    explicit operator int64_t() {
+        assert(this->vt == VT_I8);
+        return this->llVal;
+    }
+
+    // unsigned
+    explicit operator uint8_t() {
+        assert(this->vt == VT_I1);
+        return this->bVal;
+    }
+    explicit operator uint16_t() {
+        assert(this->vt == VT_I2);
+        return this->uiVal;
+    }
+    explicit operator uint32_t() {
+        assert(this->vt == VT_UI4 || vt == VT_UINT);
+        return this->uintVal;
+    }
+    explicit operator uint64_t() {
+        assert(this->vt == VT_UI8);
+        return this->ullVal;
+    }
+    explicit operator float() {
+        assert(this->vt == VT_R4);
+        return this->fltVal;
+    }
+    explicit operator double() {
+        assert(this->vt == VT_R8);
+        return this->dblVal;
+    }
+
+    // string
+    explicit operator const std::string_view() {
+        assert(this->vt == VT_LPSTR);
+        return this->pcVal;
+    }
+    explicit operator const std::wstring_view() {
+        assert(this->vt == VT_BSTR || this->vt == VT_LPWSTR);
+        return this->bstrVal;
+    }
+
+    // array signed
+    explicit operator std::pair<const int8_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_I1);
+        return std::make_pair((int8_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const int16_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_I2);
+        return std::make_pair((int16_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const int32_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_I4);
+        return std::make_pair((int32_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const int64_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_I8);
+        return std::make_pair((int64_t*)this->parray->pvData, this->parray->cDims);
+    }
+
+    // array unsigned
+    explicit operator std::pair<const uint8_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_UI1);
+        return std::make_pair((uint8_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const uint16_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_UI2);
+        return std::make_pair((uint16_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const uint32_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_UI4);
+        return std::make_pair((uint32_t*)this->parray->pvData, this->parray->cDims);
+    }
+    explicit operator std::pair<const uint64_t*, uint32_t>() {
+        assert(this->vt & VT_ARRAY);
+        assert((this->vt & ~VT_ARRAY) == VT_UI8);
+        return std::make_pair((uint64_t*)this->parray->pvData, this->parray->cDims);
+    }
+};
+
 #else
     // Win32 COM headers requires C++ compiler
     #error Must be included in C++ source file