feat(windows): Fetch USB serial number by lookups in win registry

Initial work to get serialnumbers from registry. Needs cleanup.

Only run the win32 serialnumberparser if we can not find the serialnumber in the bindings.

WIP: Ugly and half-working iteration through win registry for USB S/Ns

Finish and cleanup of getSerialNumber() in win. It seems to work.

Cleanup: make serialNumber an in/out parameter

Cleanup: unused includes & constants, commented-out-printf()s.

Add range checks all around

rm trailing whitespace

Make linter happier

Make linter happier.

Author: Per Kristian Schanke

lib/bindings/win32.js

@@ -9,7 +9,7 @@ class WindowsBinding extends BaseBinding {
     return promisify(binding.list)().then(ports => {
       // Grab the serial number from the pnp id
       ports.forEach(port => {
-        if (port.pnpId) {
+        if (port.pnpId && !port.serialNumber) {
           const serialNumber = serialNumParser(port.pnpId);
           if (serialNumber) {
             port.serialNumber = serialNumber;

src/serialport_win.cpp

@@ -6,11 +6,18 @@
 #include <string.h>
 #include <windows.h>
 #include <Setupapi.h>
+#include <initguid.h>
+#include <devpkey.h>
 #include <devguid.h>
 #pragma comment(lib, "setupapi.lib")
 
+#define ARRAY_SIZE(arr)     (sizeof(arr)/sizeof(arr[0]))
+
 #define MAX_BUFFER_SIZE 1000
 
+// As per https://msdn.microsoft.com/en-us/library/windows/desktop/ms724872(v=vs.85).aspx
+#define MAX_REGISTRY_KEY_SIZE 255
+
 // Declare type of pointer to CancelIoEx function
 typedef BOOL (WINAPI *CancelIoExType)(HANDLE hFile, LPOVERLAPPED lpOverlapped);
 
@@ -610,6 +617,162 @@ NAN_METHOD(List) {
   uv_queue_work(uv_default_loop(), req, EIO_List, (uv_after_work_cb)EIO_AfterList);
 }
 
+// It's possible that the s/n is a construct and not the s/n of the parent USB
+// composite device. This performs some convoluted registry lookups to fetch the USB s/n.
+void getSerialNumber(const char *vid,
+                     const char *pid,
+                     const HDEVINFO hDevInfo,
+                     SP_DEVINFO_DATA deviceInfoData,
+                     const unsigned int maxSerialNumberLength,
+                     char* serialNumber) {
+  _snprintf_s(serialNumber, maxSerialNumberLength, _TRUNCATE, "");
+  if (vid == NULL || pid == NULL) {
+    return;
+  }
+
+  DWORD dwSize;
+  WCHAR szWUuidBuffer[MAX_BUFFER_SIZE];
+  WCHAR containerUuid[MAX_BUFFER_SIZE];
+
+
+  // Fetch the "Container ID" for this device node. In USB context, this "Container
+  // ID" refers to the composite USB device, i.e. the USB device as a whole, not
+  // just one of its interfaces with a serial port driver attached.
+
+  // From https://stackoverflow.com/questions/3438366/setupdigetdeviceproperty-usage-example:
+  // Because this is not compiled with UNICODE defined, the call to SetupDiGetDevicePropertyW
+  // has to be setup manually.
+  DEVPROPTYPE ulPropertyType;
+  typedef BOOL (WINAPI *FN_SetupDiGetDevicePropertyW)(
+    __in       HDEVINFO DeviceInfoSet,
+    __in       PSP_DEVINFO_DATA DeviceInfoData,
+    __in       const DEVPROPKEY *PropertyKey,
+    __out      DEVPROPTYPE *PropertyType,
+    __out_opt  PBYTE PropertyBuffer,
+    __in       DWORD PropertyBufferSize,
+    __out_opt  PDWORD RequiredSize,
+    __in       DWORD Flags);
+
+  FN_SetupDiGetDevicePropertyW fn_SetupDiGetDevicePropertyW = (FN_SetupDiGetDevicePropertyW)
+        GetProcAddress(GetModuleHandle(TEXT("Setupapi.dll")), "SetupDiGetDevicePropertyW");
+
+  if (fn_SetupDiGetDevicePropertyW (
+        hDevInfo,
+        &deviceInfoData,
+        &DEVPKEY_Device_ContainerId,
+        &ulPropertyType,
+        reinterpret_cast<BYTE*>(szWUuidBuffer),
+        sizeof(szWUuidBuffer),
+        &dwSize,
+        0)) {
+    szWUuidBuffer[dwSize] = '\0';
+
+    // Given the UUID bytes, build up a (widechar) string from it. There's some mangling
+    // going on.
+    StringFromGUID2((REFGUID)szWUuidBuffer, containerUuid, ARRAY_SIZE(containerUuid));
+  } else {
+    // Container UUID could not be fetched, return empty serial number.
+    return;
+  }
+
+  // NOTE: Devices might have a containerUuid like {00000000-0000-0000-FFFF-FFFFFFFFFFFF}
+  // This means they're non-removable, and are not handled (yet).
+  // Maybe they should inherit the s/n from somewhere else.
+
+  // Sanitize input - for whatever reason, StringFromGUID2() returns a WCHAR* but
+  // the comparisons later need a plain old char*, in lowercase ASCII.
+  char wantedUuid[MAX_BUFFER_SIZE];
+  _snprintf_s(wantedUuid, MAX_BUFFER_SIZE, _TRUNCATE, "%ws", containerUuid);
+  strlwr(wantedUuid);
+
+  // Iterate through all the USB devices with the given VendorID/ProductID
+
+  HKEY vendorProductHKey;
+  DWORD retCode;
+  char hkeyPath[MAX_BUFFER_SIZE];
+
+  _snprintf_s(hkeyPath, MAX_BUFFER_SIZE, _TRUNCATE, "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_%s&PID_%s", vid, pid);
+
+  retCode = RegOpenKeyEx(
+    HKEY_LOCAL_MACHINE,
+    hkeyPath,
+    0,
+    KEY_READ,
+    &vendorProductHKey);
+
+  if (retCode == ERROR_SUCCESS) {
+    DWORD    serialNumbersCount = 0;       // number of subkeys
+
+    // Fetch how many subkeys there are for this VendorID/ProductID pair.
+    // That's the number of devices for this VendorID/ProductID known to this machine.
+
+    retCode = RegQueryInfoKey(
+        vendorProductHKey,    // hkey handle
+        NULL,      // buffer for class name
+        NULL,      // size of class string
+        NULL,      // reserved
+        &serialNumbersCount,  // number of subkeys
+        NULL,      // longest subkey size
+        NULL,      // longest class string
+        NULL,      // number of values for this key
+        NULL,      // longest value name
+        NULL,      // longest value data
+        NULL,      // security descriptor
+        NULL);     // last write time
+
+    if (retCode == ERROR_SUCCESS && serialNumbersCount > 0) {
+        for (unsigned int i=0; i < serialNumbersCount; i++) {
+          // Each of the subkeys here is the serial number of a USB device with the
+          // given VendorId/ProductId. Now fetch the string for the S/N.
+          DWORD serialNumberLength = maxSerialNumberLength;
+          retCode = RegEnumKeyEx(vendorProductHKey,
+                                  i,
+                                  serialNumber,
+                                  &serialNumberLength,
+                                  NULL,
+                                  NULL,
+                                  NULL,
+                                  NULL);
+
+          if (retCode == ERROR_SUCCESS) {
+            // Lookup info for VID_(vendorId)&PID_(productId)\(serialnumber)
+
+            _snprintf_s(hkeyPath, MAX_BUFFER_SIZE, _TRUNCATE,
+                        "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_%s&PID_%s\\%s",
+                        vid, pid, serialNumber);
+
+            HKEY deviceHKey;
+
+            if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, hkeyPath, 0, KEY_READ, &deviceHKey) == ERROR_SUCCESS) {
+                char readUuid[MAX_BUFFER_SIZE];
+                DWORD readSize = sizeof(readUuid);
+
+                // Query VID_(vendorId)&PID_(productId)\(serialnumber)\ContainerID
+                DWORD retCode = RegQueryValueEx(deviceHKey, "ContainerID", NULL, NULL, (LPBYTE)&readUuid, &readSize);
+                if (retCode == ERROR_SUCCESS) {
+                    readUuid[readSize] = '\0';
+                    if (strcmp(wantedUuid, readUuid) == 0) {
+                        // The ContainerID UUIDs match, return now that serialNumber has
+                        // the right value.
+                        RegCloseKey(deviceHKey);
+                        RegCloseKey(vendorProductHKey);
+                        return;
+                    }
+                }
+            }
+            RegCloseKey(deviceHKey);
+          }
+       }
+    }
+
+    /* In case we did not obtain the path, for whatever reason, we close the key and return an empty string. */
+    RegCloseKey(vendorProductHKey);
+  }
+
+  _snprintf_s(serialNumber, maxSerialNumberLength, _TRUNCATE, "");
+  return;
+}
+
 void EIO_List(uv_work_t* req) {
   ListBaton* data = static_cast<ListBaton*>(req->data);
 
@@ -619,13 +782,14 @@ void EIO_List(uv_work_t* req) {
 
   int memberIndex = 0;
   DWORD dwSize, dwPropertyRegDataType;
-  char szBuffer[400];
+  char szBuffer[MAX_BUFFER_SIZE];
   char *pnpId;
   char *vendorId;
   char *productId;
   char *name;
   char *manufacturer;
   char *locationId;
+  char serialNumber[MAX_REGISTRY_KEY_SIZE];
   bool isCom;
   while (true) {
     pnpId = NULL;
@@ -660,6 +824,8 @@ void EIO_List(uv_work_t* req) {
       productId = copySubstring(productId, 4);
     }
 
+    getSerialNumber(vendorId, productId, hDevInfo, deviceInfoData, MAX_REGISTRY_KEY_SIZE, serialNumber);
+
     if (SetupDiGetDeviceRegistryProperty(hDevInfo, &deviceInfoData,
                                          SPDRP_LOCATION_INFORMATION, &dwPropertyRegDataType,
                                          reinterpret_cast<BYTE*>(szBuffer),
@@ -693,6 +859,7 @@ void EIO_List(uv_work_t* req) {
       if (productId) {
         resultItem->productId = productId;
       }
+      resultItem->serialNumber = serialNumber;
       if (locationId) {
         resultItem->locationId = locationId;
       }