MacMonitor/Sources/Telemetry/Peripherals/MMPeripheralsProvider.m

//
//  MMPeripheralsProvider.m
//  MacMonitor
//
//  Telemetry provider enumerating connected USB, Thunderbolt, and PCI peripheral devices via IOKit.
//

#import "MMPeripheralsProvider.h"
#import <IOKit/IOKitLib.h>

@implementation MMPeripheralDevice

- (NSDictionary<NSString *, id> *)toDictionary {
    NSString *busStr = @"USB";
    if (self.busType == MMPeripheralBusTypeThunderbolt) {
        busStr = @"Thunderbolt";
    } else if (self.busType == MMPeripheralBusTypePCI) {
        busStr = @"PCI";
    }
    
    return @{
        @"name": self.name ?: @"Unknown Device",
        @"busType": busStr,
        @"vendorName": self.vendorName ?: @"Unknown",
        @"vendorID": @(self.vendorID),
        @"productID": @(self.productID),
        @"serialNumber": self.serialNumber ?: @"",
        @"deviceClass": self.deviceClass ?: @"",
        @"locationID": @(self.locationID),
        @"isBuiltIn": @(self.isBuiltIn)
    };
}

@end

@implementation MMPeripheralsProvider

- (instancetype)init {
    self = [super init];
    return self;
}

- (MMTelemetryDomain)domain {
    return MMTelemetryDomainPeripherals;
}

- (NSString *)providerIdentifier {
    return @"com.i3omb.macmonitor.telemetry.peripherals";
}

- (BOOL)isAvailable {
    return YES;
}

+ (NSArray<MMPeripheralDevice *> *)sampleUSBDevices {
    NSMutableArray<MMPeripheralDevice *> *devices = [NSMutableArray array];
    
    // Query both IOUSBHostDevice (macOS modern) and IOUSBDevice (legacy/fallback)
    const char *classes[] = { "IOUSBHostDevice", "IOUSBDevice" };
    NSMutableSet<NSNumber *> *seenRegistryIDs = [NSMutableSet set];
    
    for (int i = 0; i < 2; i++) {
        CFMutableDictionaryRef matching = IOServiceMatching(classes[i]);
        if (!matching) continue;
        
        io_iterator_t iterator = IO_OBJECT_NULL;
        kern_return_t kr = IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iterator);
        if (kr != KERN_SUCCESS || iterator == IO_OBJECT_NULL) continue;
        
        io_service_t service = IO_OBJECT_NULL;
        while ((service = IOIteratorNext(iterator)) != IO_OBJECT_NULL) {
            uint64_t regID = 0;
            IORegistryEntryGetRegistryEntryID(service, &regID);
            if ([seenRegistryIDs containsObject:@(regID)]) {
                IOObjectRelease(service);
                continue;
            }
            [seenRegistryIDs addObject:@(regID)];
            
            CFMutableDictionaryRef props = NULL;
            if (IORegistryEntryCreateCFProperties(service, &props, kCFAllocatorDefault, 0) == KERN_SUCCESS && props) {
                NSDictionary *dict = (__bridge NSDictionary *)props;
                
                NSString *name = dict[@"USB Product Name"] ?: (dict[@"kUSBProductString"] ?: dict[@"IOName"]);
                if (!name || name.length == 0) {
                    name = @"USB Device";
                }
                
                NSString *vendor = dict[@"USB Vendor Name"] ?: (dict[@"kUSBVendorString"] ?: @"");
                uint32_t vendorID = [dict[@"idVendor"] unsignedIntValue];
                uint32_t productID = [dict[@"idProduct"] unsignedIntValue];
                NSString *serial = dict[@"USB Serial Number"] ?: dict[@"kUSBSerialNumberString"];
                uint64_t locID = [dict[@"locationID"] unsignedLongLongValue];
                
                BOOL builtIn = NO;
                if (dict[@"Built-In"]) {
                    builtIn = [dict[@"Built-In"] boolValue];
                } else if ([dict[@"non-removable"] isKindOfClass:[NSString class]]) {
                    builtIn = [dict[@"non-removable"] isEqualToString:@"yes"];
                }
                
                MMPeripheralDevice *dev = [[MMPeripheralDevice alloc] init];
                dev.name = name;
                dev.busType = MMPeripheralBusTypeUSB;
                dev.vendorName = vendor;
                dev.vendorID = vendorID;
                dev.productID = productID;
                dev.serialNumber = serial;
                dev.locationID = locID;
                dev.isBuiltIn = builtIn;
                
                [devices addObject:dev];
                CFRelease(props);
            }
            IOObjectRelease(service);
        }
        IOObjectRelease(iterator);
    }
    
    return devices;
}

+ (NSArray<MMPeripheralDevice *> *)sampleThunderboltDevices {
    NSMutableArray<MMPeripheralDevice *> *devices = [NSMutableArray array];
    
    CFMutableDictionaryRef matching = IOServiceMatching("IOThunderboltDevice");
    if (!matching) return devices;
    
    io_iterator_t iterator = IO_OBJECT_NULL;
    kern_return_t kr = IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iterator);
    if (kr != KERN_SUCCESS || iterator == IO_OBJECT_NULL) return devices;
    
    io_service_t service = IO_OBJECT_NULL;
    while ((service = IOIteratorNext(iterator)) != IO_OBJECT_NULL) {
        CFMutableDictionaryRef props = NULL;
        if (IORegistryEntryCreateCFProperties(service, &props, kCFAllocatorDefault, 0) == KERN_SUCCESS && props) {
            NSDictionary *dict = (__bridge NSDictionary *)props;
            
            NSString *name = dict[@"Device Name"] ?: dict[@"IOName"];
            if (!name) name = @"Thunderbolt Device";
            
            NSString *vendor = dict[@"Vendor Name"] ?: @"";
            uint32_t vendorID = [dict[@"Vendor ID"] unsignedIntValue];
            uint32_t productID = [dict[@"Device ID"] unsignedIntValue];
            
            MMPeripheralDevice *dev = [[MMPeripheralDevice alloc] init];
            dev.name = name;
            dev.busType = MMPeripheralBusTypeThunderbolt;
            dev.vendorName = vendor;
            dev.vendorID = vendorID;
            dev.productID = productID;
            dev.isBuiltIn = NO;
            
            [devices addObject:dev];
            CFRelease(props);
        }
        IOObjectRelease(service);
    }
    IOObjectRelease(iterator);
    return devices;
}

static uint32_t ParseDataUInt32(NSData *data) {
    if (![data isKindOfClass:[NSData class]] || data.length == 0) return 0;
    uint32_t val = 0;
    size_t copyLen = MIN(sizeof(val), data.length);
    memcpy(&val, data.bytes, copyLen);
    return val;
}

+ (NSArray<MMPeripheralDevice *> *)samplePCIDevices {
    NSMutableArray<MMPeripheralDevice *> *devices = [NSMutableArray array];
    
    CFMutableDictionaryRef matching = IOServiceMatching("IOPCIDevice");
    if (!matching) return devices;
    
    io_iterator_t iterator = IO_OBJECT_NULL;
    kern_return_t kr = IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iterator);
    if (kr != KERN_SUCCESS || iterator == IO_OBJECT_NULL) return devices;
    
    io_service_t service = IO_OBJECT_NULL;
    while ((service = IOIteratorNext(iterator)) != IO_OBJECT_NULL) {
        CFMutableDictionaryRef props = NULL;
        if (IORegistryEntryCreateCFProperties(service, &props, kCFAllocatorDefault, 0) == KERN_SUCCESS && props) {
            NSDictionary *dict = (__bridge NSDictionary *)props;
            
            NSString *name = nil;
            if ([dict[@"model"] isKindOfClass:[NSData class]]) {
                name = [[NSString alloc] initWithData:dict[@"model"] encoding:NSUTF8StringEncoding];
                name = [name stringByTrimmingCharactersInSet:[NSCharacterSet controlCharacterSet]];
            }
            if (!name || name.length == 0) {
                name = dict[@"IOName"];
            }
            if (!name || name.length == 0) {
                name = @"PCI Device";
            }
            
            uint32_t vendorID = 0;
            if ([dict[@"vendor-id"] isKindOfClass:[NSData class]]) {
                vendorID = ParseDataUInt32(dict[@"vendor-id"]);
            }
            
            uint32_t deviceID = 0;
            if ([dict[@"device-id"] isKindOfClass:[NSData class]]) {
                deviceID = ParseDataUInt32(dict[@"device-id"]);
            }
            
            MMPeripheralDevice *dev = [[MMPeripheralDevice alloc] init];
            dev.name = name;
            dev.busType = MMPeripheralBusTypePCI;
            dev.vendorID = vendorID;
            dev.productID = deviceID;
            dev.isBuiltIn = YES;
            
            [devices addObject:dev];
            CFRelease(props);
        }
        IOObjectRelease(service);
    }
    IOObjectRelease(iterator);
    return devices;
}

- (nullable NSDictionary<NSString *, id> *)sampleTelemetryWithError:(NSError **)error {
    NSArray<MMPeripheralDevice *> *usb = [MMPeripheralsProvider sampleUSBDevices];
    NSArray<MMPeripheralDevice *> *tb = [MMPeripheralsProvider sampleThunderboltDevices];
    NSArray<MMPeripheralDevice *> *pci = [MMPeripheralsProvider samplePCIDevices];
    
    NSMutableArray<NSDictionary<NSString *, id> *> *usbList = [NSMutableArray arrayWithCapacity:usb.count];
    for (MMPeripheralDevice *d in usb) {
        [usbList addObject:[d toDictionary]];
    }
    
    NSMutableArray<NSDictionary<NSString *, id> *> *tbList = [NSMutableArray arrayWithCapacity:tb.count];
    for (MMPeripheralDevice *d in tb) {
        [tbList addObject:[d toDictionary]];
    }
    
    NSMutableArray<NSDictionary<NSString *, id> *> *pciList = [NSMutableArray arrayWithCapacity:pci.count];
    for (MMPeripheralDevice *d in pci) {
        [pciList addObject:[d toDictionary]];
    }
    
    NSUInteger totalCount = usb.count + tb.count + pci.count;
    
    return @{
        @"totalDeviceCount": @(totalCount),
        @"usbDevices": usbList,
        @"thunderboltDevices": tbList,
        @"pciDevices": pciList
    };
}

@end