list_ports_osx.cc

Go to the documentation of this file.

#if defined(__APPLE__)

#include <sys/param.h>
#include <stdint.h>

#include <CoreFoundation/CoreFoundation.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/serial/IOSerialKeys.h>
#include <IOKit/IOBSD.h>

#include <iostream>
#include <string>
#include <vector>

#include "serial/serial.h"

using serial::PortInfo;
using std::string;
using std::vector;

#define HARDWARE_ID_STRING_LENGTH 128

string cfstring_to_string(CFStringRef cfstring);
string get_device_path(io_object_t& serial_port);
string get_class_name(io_object_t& obj);
io_registry_entry_t get_parent_iousb_device(io_object_t& serial_port);
string get_string_property(io_object_t& device, const char* property);
uint16_t get_int_property(io_object_t& device, const char* property);
string rtrim(const string& str);

string
cfstring_to_string(CFStringRef cfstring)
{
        char cstring[MAXPATHLEN];
        string result;

        if (cfstring)
        {
                Boolean success = CFStringGetCString(cfstring,
                        cstring,
                        sizeof(cstring),
                        kCFStringEncodingASCII);

                if (success)
                        result = cstring;
        }

        return result;
}

string
get_device_path(io_object_t& serial_port)
{
        CFTypeRef callout_path;
        string device_path;

        callout_path = IORegistryEntryCreateCFProperty(serial_port,
                CFSTR(kIOCalloutDeviceKey),
                kCFAllocatorDefault,
                0);

        if (callout_path)
        {
                if (CFGetTypeID(callout_path) == CFStringGetTypeID())
                        device_path = cfstring_to_string(static_cast<CFStringRef>(callout_path));

                CFRelease(callout_path);
        }

        return device_path;
}

string
get_class_name(io_object_t& obj)
{
        string result;
        io_name_t class_name;
        kern_return_t kern_result;

        kern_result = IOObjectGetClass(obj, class_name);

        if (kern_result == KERN_SUCCESS)
                result = class_name;

        return result;
}

io_registry_entry_t
get_parent_iousb_device(io_object_t& serial_port)
{
        io_object_t device = serial_port;
        io_registry_entry_t parent = 0;
        io_registry_entry_t result = 0;
        kern_return_t kern_result = KERN_FAILURE;
        string name = get_class_name(device);

        // Walk the IO Registry tree looking for this devices parent IOUSBDevice.
        while (name != "IOUSBDevice")
        {
                kern_result = IORegistryEntryGetParentEntry(device,
                        kIOServicePlane,
                        &parent);

                if (kern_result != KERN_SUCCESS)
                {
                        result = 0;
                        break;
                }

                device = parent;

                name = get_class_name(device);
        }

        if (kern_result == KERN_SUCCESS)
                result = device;

        return result;
}

string
get_string_property(io_object_t& device, const char* property)
{
        string property_name;

        if (device)
        {
                CFStringRef property_as_cfstring = CFStringCreateWithCString(
                        kCFAllocatorDefault,
                        property,
                        kCFStringEncodingASCII);

                CFTypeRef name_as_cfstring = IORegistryEntryCreateCFProperty(
                        device,
                        property_as_cfstring,
                        kCFAllocatorDefault,
                        0);

                if (name_as_cfstring)
                {
                        if (CFGetTypeID(name_as_cfstring) == CFStringGetTypeID())
                                property_name = cfstring_to_string(static_cast<CFStringRef>(name_as_cfstring));

                        CFRelease(name_as_cfstring);
                }

                if (property_as_cfstring)
                        CFRelease(property_as_cfstring);
        }

        return property_name;
}

uint16_t
get_int_property(io_object_t& device, const char* property)
{
        uint16_t result = 0;

        if (device)
        {
                CFStringRef property_as_cfstring = CFStringCreateWithCString(
                        kCFAllocatorDefault,
                        property,
                        kCFStringEncodingASCII);

                CFTypeRef number = IORegistryEntryCreateCFProperty(device,
                        property_as_cfstring,
                        kCFAllocatorDefault,
                        0);

                if (property_as_cfstring)
                        CFRelease(property_as_cfstring);

                if (number)
                {
                        if (CFGetTypeID(number) == CFNumberGetTypeID())
                        {
                                bool success = CFNumberGetValue(static_cast<CFNumberRef>(number),
                                        kCFNumberSInt16Type,
                                        &result);

                                if (!success)
                                        result = 0;
                        }

                        CFRelease(number);
                }

        }

        return result;
}

string rtrim(const string& str)
{
        string result = str;

        string whitespace = " \t\f\v\n\r";

        std::size_t found = result.find_last_not_of(whitespace);

        if (found != std::string::npos)
                result.erase(found + 1);
        else
                result.clear();

        return result;
}

vector<PortInfo>
serial::list_ports(void)
{
        vector<PortInfo> devices_found;
        CFMutableDictionaryRef classes_to_match;
        io_iterator_t serial_port_iterator;
        io_object_t serial_port;
        mach_port_t master_port;
        kern_return_t kern_result;

        kern_result = IOMasterPort(MACH_PORT_NULL, &master_port);

        if (kern_result != KERN_SUCCESS)
                return devices_found;

        classes_to_match = IOServiceMatching(kIOSerialBSDServiceValue);

        if (classes_to_match == NULL)
                return devices_found;

        CFDictionarySetValue(classes_to_match,
                CFSTR(kIOSerialBSDTypeKey),
                CFSTR(kIOSerialBSDAllTypes));

        kern_result = IOServiceGetMatchingServices(master_port, classes_to_match, &serial_port_iterator);

        if (KERN_SUCCESS != kern_result)
                return devices_found;

        while ((serial_port = IOIteratorNext(serial_port_iterator)))
        {
                string device_path = get_device_path(serial_port);
                io_registry_entry_t parent = get_parent_iousb_device(serial_port);
                IOObjectRelease(serial_port);

                if (device_path.empty())
                        continue;

                PortInfo port_info;
                port_info.port = device_path;
                port_info.description = "n/a";
                port_info.hardware_id = "n/a";

                string device_name = rtrim(get_string_property(parent, "USB Product Name"));
                string vendor_name = rtrim(get_string_property(parent, "USB Vendor Name"));
                string description = rtrim(vendor_name + " " + device_name);
                if (!description.empty())
                        port_info.description = description;

                string serial_number = rtrim(get_string_property(parent, "USB Serial Number"));
                uint16_t vendor_id = get_int_property(parent, "idVendor");
                uint16_t product_id = get_int_property(parent, "idProduct");

                if (vendor_id && product_id)
                {
                        char cstring[HARDWARE_ID_STRING_LENGTH];

                        if (serial_number.empty())
                                serial_number = "None";

                        int ret = snprintf(cstring, HARDWARE_ID_STRING_LENGTH, "USB VID:PID=%04x:%04x SNR=%s",
                                vendor_id,
                                product_id,
                                serial_number.c_str());

                        if ((ret >= 0) && (ret < HARDWARE_ID_STRING_LENGTH))
                                port_info.hardware_id = cstring;
                }

                devices_found.push_back(port_info);
        }

        IOObjectRelease(serial_port_iterator);
        return devices_found;
}

#endif // defined(__APPLE__)