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>

#pragma comment (lib, "Setupapi.lib")

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)