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__)