Support timing helpers on Windows.

[libserialport.git] / windows.c

diff --git a/windows.c b/windows.c
index b4119187de70a820f7e44ac113a5da437c620c08..ee15a11964a900e6224bb1ec93ac2e59dade22bf 100644 (file)
--- a/windows.c
+++ b/windows.c
@@ -26,16 +26,17 @@
 #define MAX_USB_PATH ((8 * 3) + (7 * 1) + 1)
 
 static void enumerate_hub(struct sp_port *port, const char *hub_name,
-                          const char *parent_path);
+                          const char *parent_path, DEVINST dev_inst);
 
 static char *wc_to_utf8(PWCHAR wc_buffer, ULONG size)
 {
-       WCHAR wc_str[(size / sizeof(WCHAR)) + 1];
+       ULONG wc_length = size / sizeof(WCHAR);
+       WCHAR wc_str[wc_length + 1];
        char *utf8_str;
 
        /* Zero-terminate the wide char string. */
        memcpy(wc_str, wc_buffer, size);
-       wc_str[sizeof(wc_str) - 1] = 0;
+       wc_str[wc_length] = 0;
 
        /* Compute the size of the UTF-8 converted string. */
        if (!(size = WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, wc_str, -1,
@@ -81,7 +82,7 @@ static char *get_root_hub_name(HANDLE host_controller)
        }
 
        /* Convert the root hub name string to UTF-8. */
-       root_hub_name_utf8 = wc_to_utf8(root_hub_name_wc->RootHubName, size);
+       root_hub_name_utf8 = wc_to_utf8(root_hub_name_wc->RootHubName, size - offsetof(USB_ROOT_HUB_NAME, RootHubName));
        free(root_hub_name_wc);
        return root_hub_name_utf8;
 }
@@ -116,7 +117,7 @@ static char *get_external_hub_name(HANDLE hub, ULONG connection_index)
        }
 
        /* Convert the external hub name string to UTF-8. */
-       ext_hub_name_utf8 = wc_to_utf8(ext_hub_name_wc->NodeName, size);
+       ext_hub_name_utf8 = wc_to_utf8(ext_hub_name_wc->NodeName, size - offsetof(USB_NODE_CONNECTION_NAME, NodeName));
        free(ext_hub_name_wc);
        return ext_hub_name_utf8;
 }
@@ -145,11 +146,11 @@ static char *get_string_descriptor(HANDLE hub_device, ULONG connection_index,
            || desc->bLength % 2)
                return NULL;
 
-       return wc_to_utf8(desc->bString, desc->bLength);
+       return wc_to_utf8(desc->bString, desc->bLength - offsetof(USB_STRING_DESCRIPTOR, bString));
 }
 
 static void enumerate_hub_ports(struct sp_port *port, HANDLE hub_device,
-                                ULONG nb_ports, const char *parent_path)
+                                ULONG nb_ports, const char *parent_path, DEVINST dev_inst)
 {
        char path[MAX_USB_PATH];
        ULONG index = 0;
@@ -200,7 +201,7 @@ static void enumerate_hub_ports(struct sp_port *port, HANDLE hub_device,
                        if ((ext_hub_name = get_external_hub_name(hub_device, index))) {
                                snprintf(path, sizeof(path), "%s%ld.",
                                         parent_path, connection_info_ex->ConnectionIndex);
-                               enumerate_hub(port, ext_hub_name, path);
+                               enumerate_hub(port, ext_hub_name, path, dev_inst);
                        }
                        free(connection_info_ex);
                } else {
@@ -219,14 +220,23 @@ static void enumerate_hub_ports(struct sp_port *port, HANDLE hub_device,
                        port->usb_pid = connection_info_ex->DeviceDescriptor.idProduct;
 
                        if (connection_info_ex->DeviceDescriptor.iManufacturer)
-                               port->usb_manufacturer = get_string_descriptor(hub_device,index,
+                               port->usb_manufacturer = get_string_descriptor(hub_device, index,
                                           connection_info_ex->DeviceDescriptor.iManufacturer);
                        if (connection_info_ex->DeviceDescriptor.iProduct)
                                port->usb_product = get_string_descriptor(hub_device, index,
                                           connection_info_ex->DeviceDescriptor.iProduct);
-                       if (connection_info_ex->DeviceDescriptor.iSerialNumber)
+                       if (connection_info_ex->DeviceDescriptor.iSerialNumber) {
                                port->usb_serial = get_string_descriptor(hub_device, index,
                                           connection_info_ex->DeviceDescriptor.iSerialNumber);
+                               if (port->usb_serial == NULL) {
+                                       //composite device, get the parent's serial number
+                                       char device_id[MAX_DEVICE_ID_LEN];
+                                       if (CM_Get_Parent(&dev_inst, dev_inst, 0) == CR_SUCCESS) {
+                                               if (CM_Get_Device_IDA(dev_inst, device_id, sizeof(device_id), 0) == CR_SUCCESS)
+                                                       port->usb_serial = strdup(strrchr(device_id, '\\')+1);
+                                       }
+                               }
+                       }
 
                        free(connection_info_ex);
                        break;
@@ -235,7 +245,7 @@ static void enumerate_hub_ports(struct sp_port *port, HANDLE hub_device,
 }
 
 static void enumerate_hub(struct sp_port *port, const char *hub_name,
-                          const char *parent_path)
+                          const char *parent_path, DEVINST dev_inst)
 {
        USB_NODE_INFORMATION hub_info;
        HANDLE hub_device;
@@ -258,18 +268,19 @@ static void enumerate_hub(struct sp_port *port, const char *hub_name,
                            &hub_info, size, &hub_info, size, &size, NULL))
                /* Enumerate the ports of the hub. */
                enumerate_hub_ports(port, hub_device,
-                  hub_info.u.HubInformation.HubDescriptor.bNumberOfPorts, parent_path);
+                  hub_info.u.HubInformation.HubDescriptor.bNumberOfPorts, parent_path, dev_inst);
 
        CloseHandle(hub_device);
 }
 
 static void enumerate_host_controller(struct sp_port *port,
-                                      HANDLE host_controller_device)
+                                      HANDLE host_controller_device,
+                                      DEVINST dev_inst)
 {
        char *root_hub_name;
 
        if ((root_hub_name = get_root_hub_name(host_controller_device))) {
-               enumerate_hub(port, root_hub_name, "");
+               enumerate_hub(port, root_hub_name, "", dev_inst);
                free(root_hub_name);
        }
 }
@@ -324,7 +335,7 @@ static void get_usb_details(struct sp_port *port, DEVINST dev_inst_match)
                                                    GENERIC_WRITE, FILE_SHARE_WRITE,
                                                    NULL, OPEN_EXISTING, 0, NULL);
                if (host_controller_device != INVALID_HANDLE_VALUE) {
-                       enumerate_host_controller(port, host_controller_device);
+                       enumerate_host_controller(port, host_controller_device, dev_inst_match);
                        CloseHandle(host_controller_device);
                }
                free(device_detail_data);
@@ -370,7 +381,7 @@ SP_PRIV enum sp_return get_port_details(struct sp_port *port)
                        continue;
                }
                RegCloseKey(device_key);
-               value[sizeof(value)-1] = 0;
+               value[sizeof(value) - 1] = 0;
                if (strcmp(value, port->name))
                        continue;