list_ports_win.cc

Go to the documentation of this file.

#if defined(_WIN32)
 
/*
 * Copyright (c) 2014 Craig Lilley <cralilley@gmail.com>
 * This software is made available under the terms of the MIT licence.
 * A copy of the licence can be obtained from:
 * http://opensource.org/licenses/MIT
 */
 
#include "serial/serial.h"
#include <tchar.h>
#include <windows.h>
#include <setupapi.h>
#include <initguid.h>
#include <devguid.h>
#include <cstring>
 
using serial::PortInfo;
using std::vector;
using std::string;
 
static const DWORD port_name_max_length = 256;
static const DWORD friendly_name_max_length = 256;
static const DWORD hardware_id_max_length = 256;
 
// Convert a wide Unicode string to an UTF8 string
std::string utf8_encode(const std::wstring &wstr)
{
        int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
        std::string strTo( size_needed, 0 );
        WideCharToMultiByte                  (CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
        return strTo;
}
 
vector<PortInfo>
serial::list_ports()
{
        vector<PortInfo> devices_found;
 
        HDEVINFO device_info_set = SetupDiGetClassDevs(
                (const GUID *) &GUID_DEVCLASS_PORTS,
                NULL,
                NULL,
                DIGCF_PRESENT);
 
        unsigned int device_info_set_index = 0;
        SP_DEVINFO_DATA device_info_data;
 
        device_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
 
        while(SetupDiEnumDeviceInfo(device_info_set, device_info_set_index, &device_info_data))
        {
                device_info_set_index++;
 
                // Get port name
 
                HKEY hkey = SetupDiOpenDevRegKey(
                        device_info_set,
                        &device_info_data,
                        DICS_FLAG_GLOBAL,
                        0,
                        DIREG_DEV,
                        KEY_READ);
 
                TCHAR port_name[port_name_max_length];
                DWORD port_name_length = port_name_max_length;
 
                LONG return_code = RegQueryValueEx(
                                        hkey,
                                        _T("PortName"),
                                        NULL,
                                        NULL,
                                        (LPBYTE)port_name,
                                        &port_name_length);
 
                RegCloseKey(hkey);
 
                if(return_code != EXIT_SUCCESS)
                        continue;
 
                if(port_name_length > 0 && port_name_length <= port_name_max_length)
                        port_name[port_name_length-1] = '\0';
                else
                        port_name[0] = '\0';
 
                // Ignore parallel ports
 
                if(_tcsstr(port_name, _T("LPT")) != NULL)
                        continue;
 
                // Get port friendly name
 
                TCHAR friendly_name[friendly_name_max_length];
                DWORD friendly_name_actual_length = 0;
 
                BOOL got_friendly_name = SetupDiGetDeviceRegistryProperty(
                                        device_info_set,
                                        &device_info_data,
                                        SPDRP_FRIENDLYNAME,
                                        NULL,
                                        (PBYTE)friendly_name,
                                        friendly_name_max_length,
                                        &friendly_name_actual_length);
 
                if(got_friendly_name == TRUE && friendly_name_actual_length > 0)
                        friendly_name[friendly_name_actual_length-1] = '\0';
                else
                        friendly_name[0] = '\0';
 
                // Get hardware ID
 
                TCHAR hardware_id[hardware_id_max_length];
                DWORD hardware_id_actual_length = 0;
 
                BOOL got_hardware_id = SetupDiGetDeviceRegistryProperty(
                                        device_info_set,
                                        &device_info_data,
                                        SPDRP_HARDWAREID,
                                        NULL,
                                        (PBYTE)hardware_id,
                                        hardware_id_max_length,
                                        &hardware_id_actual_length);
 
                if(got_hardware_id == TRUE && hardware_id_actual_length > 0)
                        hardware_id[hardware_id_actual_length-1] = '\0';
                else
                        hardware_id[0] = '\0';
 
                #ifdef UNICODE
                        std::string portName = utf8_encode(port_name);
                        std::string friendlyName = utf8_encode(friendly_name);
                        std::string hardwareId = utf8_encode(hardware_id);
                #else
                        std::string portName = port_name;
                        std::string friendlyName = friendly_name;
                        std::string hardwareId = hardware_id;
                #endif
 
                PortInfo port_entry;
                port_entry.port = portName;
                port_entry.description = friendlyName;
                port_entry.hardware_id = hardwareId;
 
                devices_found.push_back(port_entry);
        }
 
        SetupDiDestroyDeviceInfoList(device_info_set);
 
        return devices_found;
}
 
#endif // #if defined(_WIN32)