void createHIDDeviceInterface(io_object_t hidDevice, IOHIDDeviceInterface ***hdi) { io_name_t className; IOCFPlugInInterface **plugInInterface = NULL; HRESULT plugInResult = S_OK; SInt32 score = 0; IOReturn ioReturnValue = kIOReturnSuccess; ioReturnValue = IOObjectGetClass(hidDevice, className); print_errmsg_if_io_err(ioReturnValue, "Failed to get class name."); ioReturnValue = IOCreatePlugInInterfaceForService( hidDevice, kIOHIDDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score); if (ioReturnValue != kIOReturnSuccess) return; plugInResult = (*plugInInterface)->QueryInterface( plugInInterface, CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID), (LPVOID)hdi); print_errmsg_if_err(plugInResult != S_OK, "Failed to create device interface.\n"); (*plugInInterface)->Release(plugInInterface); }
static int CreateHIDDeviceInterface(io_object_t hidDevice, IOHIDDeviceInterface ***hidDeviceInterface) { io_name_t className; IOCFPlugInInterface **plugInInterface = NULL; SInt32 score = 0; if (IOObjectGetClass(hidDevice, className) != kIOReturnSuccess) return -1; if (IOCreatePlugInInterfaceForService(hidDevice, kIOHIDDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score) != kIOReturnSuccess) return -1; // Call a method of the intermediate plugin to create the device interface if ((*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID), (LPVOID)hidDeviceInterface) != S_OK || *hidDeviceInterface == NULL || **hidDeviceInterface == NULL) { (*plugInInterface)->Release(plugInInterface); return -1; } (*plugInInterface)->Release(plugInInterface); return 0; }
void IOKitEventPublisher::newEvent(const io_service_t& device, IOKitEventContext::Action action) { auto ec = createEventContext(); ec->action = action; { // The IORegistry name is not needed. io_name_t class_name = {0}; if (IOObjectGetClass(device, class_name) != kIOReturnSuccess) { return; } ec->type = std::string(class_name); } // Get the device details CFMutableDictionaryRef details; IORegistryEntryCreateCFProperties( device, &details, kCFAllocatorDefault, kNilOptions); if (ec->type == kIOUSBDeviceClassName_) { ec->path = getIOKitProperty(details, "USB Address") + ":"; ec->path += getIOKitProperty(details, "PortNum"); ec->model = getIOKitProperty(details, "USB Product Name"); ec->model_id = getIOKitProperty(details, "idProduct"); ec->vendor = getIOKitProperty(details, "USB Vendor Name"); ec->vendor_id = getIOKitProperty(details, "idVendor"); idToHex(ec->vendor_id); idToHex(ec->model_id); ec->serial = getIOKitProperty(details, "USB Serial Number"); if (ec->serial.size() == 0) { ec->serial = getIOKitProperty(details, "iSerialNumber"); } ec->version = ""; ec->driver = getIOKitProperty(details, "IOUserClientClass"); } else if (ec->type == kIOPCIDeviceClassName_) { auto compatible = getIOKitProperty(details, "compatible"); auto properties = IOKitPCIProperties(compatible); ec->model_id = properties.model_id; ec->vendor_id = properties.vendor_id; ec->driver = properties.driver; if (ec->driver.empty()) { ec->driver = getIOKitProperty(details, "IOName"); } ec->path = getIOKitProperty(details, "pcidebug"); ec->version = getIOKitProperty(details, "revision-id"); ec->model = getIOKitProperty(details, "model"); } else { // Get the name as the model. io_name_t name = {0}; IORegistryEntryGetName(device, name); if (name[0] != 0) { ec->model = std::string(name); } } CFRelease(details); fire(ec); }
bool isNotPointingDevice(IOHIDDeviceRef devRef) { // List of the URI substrings for which the corresponding devices will be ignored io_name_t ignored[] = { "Keyboard", "AppleUSBTCButtons", "BNBTrackpadDevice", "AppleMikeyHIDDriver", "AppleUSBMultitouchDriver" }; io_name_t className; IOObjectGetClass(IOHIDDeviceGetService(devRef), className); const int n = sizeof(ignored) / sizeof(ignored[0]); for (int i = 0; i < n; i++) if (strstr(className, ignored[i]) != NULL) return true; return false; }
int drive_open(int device){ CFMutableDictionaryRef main_dict = NULL; CFMutableDictionaryRef sec_dict = NULL; io_name_t cls_name; io_service_t sd = IO_OBJECT_NULL; SInt32 score = 0; drive_data_s* dd = 0; int count; int ret = 1; dd = (drive_data_s*)calloc(1, sizeof(drive_data_s)); if(!dd) return 0; dd->itt = IO_OBJECT_NULL; if((main_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks,&kCFTypeDictionaryValueCallBacks)) != NULL){ if((sec_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)) != NULL){ CFDictionarySetValue(sec_dict,CFSTR(kIOPropertySCSITaskDeviceCategory),CFSTR(kIOPropertySCSITaskAuthoringDevice)); CFDictionarySetValue(main_dict,CFSTR(kIOPropertyMatchKey),sec_dict); CFRelease(sec_dict); } } if(IOServiceGetMatchingServices(kIOMasterPortDefault,main_dict,&dd->itt)){ printf("no matching services\n"); return 0; } for(count = 0;count < device;++count){ sd = IOIteratorNext(dd->itt); } if(!sd){ printf("could not find drive based off id\n"); return 0; } if(!IOObjectGetClass(sd,cls_name) && !IOCreatePlugInInterfaceForService(sd,kIOMMCDeviceUserClientTypeID,kIOCFPlugInInterfaceID,&dd->plg_in_intf,&score) && !(*dd->plg_in_intf)->QueryInterface(dd->plg_in_intf,CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),(LPVOID*)&dd->mmc_intf)){ dd->dev_intf = (*dd->mmc_intf)->GetSCSITaskDeviceInterface(dd->mmc_intf); if(dd->dev_intf == NULL){ ret = 0; } } if(IOObjectRelease(sd)){ printf("could not release sd"); return 0; } if(ret) return(int)dd; else return 0; }
void IOKitDevicePrivate::init(const QString &udiString, const io_registry_entry_t &entry) { Q_ASSERT(entry != MACH_PORT_NULL); udi = udiString; properties = getProperties(entry); io_name_t className; IOObjectGetClass(entry, className); properties["className"] = QString::fromUtf8(className); parentUdi = getParentDeviceUdi(entry); type = typeFromEntry(entry, properties); IOObjectRelease(entry); }
unsigned int MT_HIDGamePad::FindGamePad() { IOReturn ioReturnValue = kIOReturnSuccess; io_name_t className; while( (hidDevice = IOIteratorNext(hidObjectIterator)) ) { ioReturnValue = IOObjectGetClass(hidDevice,className); if(ioReturnValue != kIOReturnSuccess) { fprintf(stderr,"Warning: Could not get HID class name.\n"); fflush(stderr); } if(strcmp(className,"IOUSBHIDDriver") == 0) return 0; } return 0; }
kern_return_t fake_IOServiceOpen( io_service_t service, task_port_t owningTask, uint32_t type, io_connect_t * connect ) { kern_return_t ret = IOServiceOpen(service, owningTask, type, connect); io_name_t className; IOObjectGetClass(service, className); printf("IOServiceOpen(service=%x, owningTask=%x, type=%x, connect=%p) (*connect after call = %x\n", service, owningTask, type, connect, *connect); printf(" (class: %s)\n", className); if (type == 0x100){ //IGAccelVideoContextMain main_port = *connect; } return ret; }
Boolean IsWholeMedia(io_service_t service) { // // Determine if the object passed in represents an IOMedia (or subclass) object. // If it does, retrieve the "Whole" property. // If this is the whole media object, find out if it is a CD, DVD, or something else. // If it isn't the whole media object, iterate across its parents in the IORegistry // until the whole media object is found. // // Note that media types other than CD and DVD are not distinguished by class name // but are generic IOMedia objects. // Boolean isWholeMedia = false; io_name_t className; kern_return_t kernResult; if (IOObjectConformsTo(service, kIOMediaClass)) { CFTypeRef wholeMedia; wholeMedia = IORegistryEntryCreateCFProperty(service, CFSTR(kIOMediaWholeKey), kCFAllocatorDefault, 0); if (NULL == wholeMedia) { printf("Could not retrieve Whole property\n"); } else { isWholeMedia = CFBooleanGetValue(wholeMedia); CFRelease(wholeMedia); } } if (isWholeMedia) { if (IOObjectConformsTo(service, kIOCDMediaClass)) { printf("is a CD\n"); } else if (IOObjectConformsTo(service, kIODVDMediaClass)) { printf("is a DVD\n"); } else { kernResult = IOObjectGetClass(service, className); printf("is of class %s\n", className); } } return isWholeMedia; }
io_object_t getInterfaceWithName( mach_port_t masterPort, char *className ) { io_iterator_t ite; io_object_t obj = 0; io_name_t name; kern_return_t rc; kern_return_t kr; kr = IORegistryCreateIterator( masterPort, kIOServicePlane, true, /* recursive */ &ite ); if ( kr != kIOReturnSuccess ) { printf( "IORegistryCreateIterator() error %08lx\n", (unsigned long)kr ); return 0; } while ( (obj = IOIteratorNext( ite )) ) { if ( IOObjectConformsTo( obj, (char*)className ) ) { // printf( "Found Realtek UserClient !!\n" ); break; } else { rc = IOObjectGetClass( obj, name ); if ( rc == kIOReturnSuccess ) { // printf( "Skipping class %s\n", name ); } } IOObjectRelease( obj ); obj = 0; } IORegistryDisposeEnumerator( ite ); return obj; }/* end getInterfaceWithName */
void CreateDeviceInterfaceUsingOldMethod(io_object_t scsiDevice, IOSCSIDeviceInterface ***interface) { io_name_t className; IOCFPlugInInterface **plugInInterface = NULL; HRESULT plugInResult = S_OK; kern_return_t kr = kIOReturnSuccess; SInt32 score = 0; // Get the object's class name just to display it kr = IOObjectGetClass(scsiDevice, className); if (kr != kIOReturnSuccess) { fprintf(stderr, "Failed to get class name. (0x%08x)\n", kr); } else { fprintf(stderr, "Found device class \"%s\" using old method.\n", className); // Create the base interface of type IOCFPlugInInterface. // This object will be used to create the SCSI device interface object. kr = IOCreatePlugInInterfaceForService( scsiDevice, kIOSCSIUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score); if (kr != kIOReturnSuccess) { fprintf(stderr, "Couldn't create a plugin interface for the io_service_t. (0x%08x)\n", kr); } else { // Query the base plugin interface for an instance of the specific SCSI device interface // object. plugInResult = (*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(kIOSCSIDeviceInterfaceID), (LPVOID *) interface); if (plugInResult != S_OK) { fprintf(stderr, "Couldn't create SCSI device interface. (%ld)\n", plugInResult); } // We're now finished with the instance of IOCFPlugInInterface. IODestroyPlugInInterface(plugInInterface); } } }
kern_return_t fake_IOServiceOpen( io_service_t service, task_port_t owningTask, uint32_t type, io_connect_t * connect ) { kern_return_t ret = IOServiceOpen(service, owningTask, type, connect); io_name_t className; IOObjectGetClass(service, className); printf("IOServiceOpen(service=%x, owningTask=%x, type=%x, connect=%p) (*connect after call = %x\n", service, owningTask, type, connect, *connect); printf(" (class: %s)\n", className); if (type == 0x101){ //IGAccelVideoContextMedia if (main_port != 0) { printf("$$$$$$$$$ got another service port/?\n"); } main_port = *connect; printf("**************** found correct userclient **************\n"); } return ret; }
static IOReturn PrintSMARTDataForBSDNode ( const char * bsdNode ) { IOReturn error = kIOReturnError; io_object_t object = MACH_PORT_NULL; io_object_t parent = MACH_PORT_NULL; bool found = false; char * bsdName = NULL; char deviceName[MAXPATHLEN]; sprintf ( deviceName, "%s", bsdNode ); if ( !strncmp ( deviceName, "/dev/r", 6 ) ) { // Strip off the /dev/r from /dev/rdiskX bsdName = &deviceName[6]; } else if ( !strncmp ( deviceName, "/dev/", 5 ) ) { // Strip off the /dev/r from /dev/rdiskX bsdName = &deviceName[5]; } else { bsdName = deviceName; } require_action ( ( strncmp ( bsdName, "disk", 4 ) == 0 ), ErrorExit, PrintUsage ( ) ); object = IOServiceGetMatchingService ( kIOMasterPortDefault, IOBSDNameMatching ( kIOMasterPortDefault, 0, bsdName ) ); require ( ( object != MACH_PORT_NULL ), ErrorExit ); parent = object; while ( IOObjectConformsTo ( object, kIOATABlockStorageDeviceClass ) == false ) { #if DEBUG io_name_t className; error = IOObjectGetClass ( object, className ); printf ( "Object class = %s\n", ( char * ) className ); #endif error = IORegistryEntryGetParentEntry ( object, kIOServicePlane, &parent ); require ( ( error == kIOReturnSuccess ), ReleaseObject ); require ( ( parent != MACH_PORT_NULL ), ReleaseObject ); IOObjectRelease ( object ); object = parent; } if ( IOObjectConformsTo ( object, kIOATABlockStorageDeviceClass ) ) { PrintSMARTDataForDevice ( object ); found = true; } ReleaseObject: require ( ( object != MACH_PORT_NULL ), ErrorExit ); IOObjectRelease ( object ); object = MACH_PORT_NULL; ErrorExit: if ( found == false ) { printf ( "No S.M.A.R.T. capable device at %s\n", bsdNode ); } return error; }
drives_s* drives_available(){ CFMutableDictionaryRef main_dict = NULL; CFMutableDictionaryRef sec_dict = NULL; io_iterator_t itt = IO_OBJECT_NULL; io_name_t cls_name; io_service_t sd = IO_OBJECT_NULL; IOCFPlugInInterface **plg_in_intf = NULL; SCSITaskDeviceInterface **dev_intf = NULL; MMCDeviceInterface **mmc_intf = NULL; SInt32 score = 0; int count; int ret = 1; drive_s* d = 0; drives_s* dd = 0; if((main_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks,&kCFTypeDictionaryValueCallBacks)) != NULL){ if((sec_dict = CFDictionaryCreateMutable(kCFAllocatorDefault,0,&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)) != NULL){ CFDictionarySetValue(sec_dict,CFSTR(kIOPropertySCSITaskDeviceCategory),CFSTR(kIOPropertySCSITaskAuthoringDevice)); CFDictionarySetValue(main_dict,CFSTR(kIOPropertyMatchKey),sec_dict); CFRelease(sec_dict); } } if(IOServiceGetMatchingServices(kIOMasterPortDefault,main_dict,&itt)){ printf("no matching services\n"); return 0; } count = 0; while((sd = IOIteratorNext(itt))) { if(!IOObjectGetClass(sd,cls_name)){ if(!IOCreatePlugInInterfaceForService(sd,kIOMMCDeviceUserClientTypeID,kIOCFPlugInInterfaceID,&plg_in_intf,&score) && !(*plg_in_intf)->QueryInterface(plg_in_intf,CFUUIDGetUUIDBytes(kIOMMCDeviceInterfaceID),(LPVOID*)&mmc_intf)) { dev_intf = (*mmc_intf)->GetSCSITaskDeviceInterface(mmc_intf); if(dev_intf){ drive_data_s dd; dd.mmc_intf = mmc_intf; dd.plg_in_intf = plg_in_intf; dd.itt = itt; dd.dev_intf = dev_intf; if(drive_type((int)&dd) == T_CDROM){ inquiry_s* inq; count++; d = (drive_s*)realloc(d,count*sizeof(drive_s)); inq = drive_inquiry((int)&dd); memcpy(&d[count-1].name,inq->p_id,sizeof(inq->p_id)); d[count-1].id = count; free(inq); } } } if(IOObjectRelease(sd)) ret = 0; } if(mmc_intf != NULL)(*mmc_intf)->Release(mmc_intf); if(plg_in_intf != NULL)IODestroyPlugInInterface(plg_in_intf); } IOObjectRelease(itt); dd = (drives_s*)malloc(sizeof(drives_s)); if(dd){ dd->drives = d; dd->number = count; }else{ free(d); return 0; } if(ret) return dd; else return 0; }
void genIOKitDevice(const io_service_t& device, const io_service_t& parent, const io_name_t plane, int depth, QueryData& results) { Row r; io_name_t name, device_class; auto kr = IORegistryEntryGetName(device, name); if (kr == KERN_SUCCESS) { r["name"] = std::string(name); } // Get the device class. kr = IOObjectGetClass(device, device_class); if (kr == KERN_SUCCESS) { r["class"] = std::string(device_class); } // The entry into the registry is the ID, and is used for children as parent. uint64_t device_id, parent_id; kr = IORegistryEntryGetRegistryEntryID(device, &device_id); if (kr == KERN_SUCCESS) { r["id"] = BIGINT(device_id); } else { r["id"] = "-1"; } kr = IORegistryEntryGetRegistryEntryID(parent, &parent_id); if (kr == KERN_SUCCESS) { r["parent"] = BIGINT(parent_id); } else { r["parent"] = "-1"; } r["depth"] = INTEGER(depth); if (IORegistryEntryInPlane(device, kIODeviceTreePlane)) { io_string_t device_path; kr = IORegistryEntryGetPath(device, kIODeviceTreePlane, device_path); if (kr == KERN_SUCCESS) { // Remove the "IODeviceTree:" from the device tree path. r["device_path"] = std::string(device_path).substr(13); } } // Fill in service bits and busy/latency time. if (IOObjectConformsTo(device, "IOService")) { r["service"] = "1"; } else { r["service"] = "0"; } uint32_t busy_state; kr = IOServiceGetBusyState(device, &busy_state); if (kr == KERN_SUCCESS) { r["busy_state"] = INTEGER(busy_state); } else { r["busy_state"] = "0"; } auto retain_count = IOObjectGetKernelRetainCount(device); r["retain_count"] = INTEGER(retain_count); results.push_back(r); }
void traverse(unsigned int options, io_name_t plane, io_iterator_t services, io_registry_entry_t serviceUpNext, int depth, UInt64 stackOfBits) { io_registry_entry_t service; ///ok Boolean doProps; // We loop for every service in the list of services provided. while ( (service = serviceUpNext) ) { io_iterator_t children; Boolean hasChildren; io_name_t name; kern_return_t status; io_registry_entry_t child; int busy; // Obtain the next service entry, if any. serviceUpNext = IOIteratorNext(services); // Obtain the current service entry's children, if any. status = IORegistryEntryGetChildIterator(service, plane, &children); assert(status == KERN_SUCCESS); child = IOIteratorNext(children); ///ok hasChildren = child ? true : false; // Save has-more-siblings state into stackOfBits for this depth. if (serviceUpNext) stackOfBits |= (1 << depth); else stackOfBits &= ~(1 << depth); // Save has-children state into stackOfBits for this depth. if (hasChildren) stackOfBits |= (2 << depth); else stackOfBits &= ~(2 << depth); indent(true, depth, stackOfBits); // Print out the name of the service. status = IORegistryEntryGetName(service, name); assert(status == KERN_SUCCESS); printf("%s", name); if (strcmp("Root", name)) doProps = (options & kDoPropsOption) != 0; else doProps = (options & kDoRootOption) != 0; // Print out the class of the service. status = IOObjectGetClass(service, name); assert(status == KERN_SUCCESS); printf(" <class %s", name); status = IOServiceGetBusyState(service, &busy); if(status == KERN_SUCCESS) printf(", busy %d", busy); // Print out the retain count of the service. printf(", retain count %d>\n", IOObjectGetRetainCount(service)); // Print out the properties of the service. if (doProps) properties(service, depth, stackOfBits); // Recurse down. traverse(options, plane, children, child, depth + 1, stackOfBits); // Release resources. IOObjectRelease(children); children = 0; IOObjectRelease(service); service = 0; } }