IOKitDevice::IOKitDevice(const IOKitDevice& device) : usBusNumber(device.usBusNumber), usAddress(device.usAddress), usVid(device.usVid), usPid(device.usPid), usConfigurationNum(device.usConfigurationNum), ulSerialNumber(device.ulSerialNumber), ulLocation(device.ulLocation), hSavedService(NULL) { if (device.hSavedService) { IOObjectRetain(device.hSavedService); hSavedService = device.hSavedService; } STRNCPY(szProductDescription, device.szProductDescription, sizeof(szProductDescription)); memcpy(szSerialString, device.szSerialString, sizeof(szSerialString)); memcpy(&stDeviceDescriptor, &(device.stDeviceDescriptor), sizeof(device.stDeviceDescriptor)); memcpy(szSystemPath, device.szSystemPath, sizeof(device.szSystemPath)); return; }
void FindWholeMedia(io_service_t service) { kern_return_t kernResult; io_iterator_t iter; // Create an iterator across all parents of the service object passed in. kernResult = IORegistryEntryCreateIterator(service, kIOServicePlane, kIORegistryIterateRecursively | kIORegistryIterateParents, &iter); if (KERN_SUCCESS != kernResult) { printf("IORegistryEntryCreateIterator returned %d\n", kernResult); } else if (NULL == iter) { printf("IORegistryEntryCreateIterator returned a NULL iterator\n"); } else { Boolean isWholeMedia; // A reference on the initial service object is released in the do-while loop below, // so add a reference to balance IOObjectRetain(service); do { isWholeMedia = IsWholeMedia(service); IOObjectRelease(service); } while ((service = IOIteratorNext(iter)) && !isWholeMedia); IOObjectRelease(iter); } }
IOKitDevice& IOKitDevice::operator=(const IOKitDevice& clDevice_) { if(this == &clDevice_) return *this; if (hSavedService) { IOObjectRelease(hSavedService); hSavedService = NULL; } if (clDevice_.hSavedService) { IOObjectRetain(clDevice_.hSavedService); hSavedService = clDevice_.hSavedService; } usBusNumber = clDevice_.usBusNumber; usAddress = clDevice_.usAddress; usVid = clDevice_.usVid; usPid = clDevice_.usPid; usConfigurationNum = clDevice_.usConfigurationNum; ulSerialNumber = clDevice_.ulSerialNumber; ulLocation = clDevice_.ulLocation; STRNCPY(szProductDescription, clDevice_.szProductDescription, sizeof(szProductDescription)); memcpy(szSerialString, clDevice_.szSerialString, sizeof(szSerialString)); memcpy(&stDeviceDescriptor, &(clDevice_.stDeviceDescriptor), sizeof(clDevice_.stDeviceDescriptor)); memcpy(szSystemPath, clDevice_.szSystemPath, sizeof(clDevice_.szSystemPath)); return *this; }
void matched_callback(io_iterator_t iterator) { bool connected = false; while (auto service = IOIteratorNext(iterator)) { std::lock_guard<std::mutex> guard(connect_mutex_); // Use first matched service. if (!service_) { service_ = service; IOObjectRetain(service_); auto kr = IOServiceOpen(service_, mach_task_self(), kIOHIDServerConnectType, &connect_); if (kr != KERN_SUCCESS) { logger_.error("IOServiceOpen error: {1} @ {0}", __PRETTY_FUNCTION__, kr); connect_ = IO_OBJECT_NULL; } logger_.info("IOServiceOpen is succeeded @ {0}", __PRETTY_FUNCTION__); connected = true; } IOObjectRelease(service); } // We have to call callback after connect_mutex_ is unlocked. if (connected && connected_callback_) { connected_callback_(*this); } }
const void * _IOObjectCFRetain( CFAllocatorRef allocator __unused, const void * value) { if (kIOReturnSuccess != IOObjectRetain((io_object_t)(uintptr_t)value)) return NULL; return value; }
/* * Given disk2s1, look up "disk2" is IOKit and attempt to determine if * it is an optical device. */ int is_optical_media(const char *bsdname) { CFMutableDictionaryRef matchingDict; int ret = 0; io_service_t service, start; kern_return_t kernResult; io_iterator_t iter; if ((matchingDict = IOBSDNameMatching(kIOMasterPortDefault, 0, bsdname)) == NULL) return(0); start = IOServiceGetMatchingService(kIOMasterPortDefault, matchingDict); if (IO_OBJECT_NULL == start) return (0); service = start; // Create an iterator across all parents of the service object passed in. // since only disk2 would match with ConfirmsTo, and not disk2s1, so // we search the parents until we find "Whole", ie, disk2. kernResult = IORegistryEntryCreateIterator(service, kIOServicePlane, kIORegistryIterateRecursively | kIORegistryIterateParents, &iter); if (KERN_SUCCESS == kernResult) { Boolean isWholeMedia = false; IOObjectRetain(service); do { // Lookup "Whole" if we can if (IOObjectConformsTo(service, kIOMediaClass)) { CFTypeRef wholeMedia; wholeMedia = IORegistryEntryCreateCFProperty(service, CFSTR(kIOMediaWholeKey), kCFAllocatorDefault, 0); if (wholeMedia) { isWholeMedia = CFBooleanGetValue(wholeMedia); CFRelease(wholeMedia); } } // If we found "Whole", check the service type. if (isWholeMedia && ( (IOObjectConformsTo(service, kIOCDMediaClass)) || (IOObjectConformsTo(service, kIODVDMediaClass)) )) { ret = 1; // Is optical, skip } IOObjectRelease(service); } while ((service = IOIteratorNext(iter)) && !isWholeMedia); IOObjectRelease(iter); } IOObjectRelease(start); return ret; }
IOKitDevice::IOKitDevice(const io_service_t& hService_) : usBusNumber(0), usAddress(0), usConfigurationNum(0), ulSerialNumber(0), ulLocation(0), hSavedService(NULL) { UCHAR ucSerialIndex = 0; szProductDescription[0] = '\0'; szSerialString[0] = '\0'; memset(&stDeviceDescriptor, 0, sizeof(stDeviceDescriptor)); //!! Can initialize in stDeviceDescriptor constructor instead memset(szSystemPath, 0, sizeof(szSystemPath)); if(hService_ == 0) throw IOKitError::INVALID_PARAM; if(!IOObjectConformsTo(hService_, "IOUSBDevice")) throw IOKitError::INVALID_PARAM; IOObjectRetain(hService_); hSavedService = hService_; //IOKitError::Enum eReturn; //!!eReturn = IOKitDevice::GetNewDescriptor(ppstDeviceInterface, stDeviceDescriptor); //if(eReturn != IOKitError::SUCCESS) // throw eReturn; IOKitDevice::GetDeviceString(hService_, CFSTR("USB Product Name"), (UCHAR*)szProductDescription, sizeof(szProductDescription)); //could also use "Product Name" (with a search) to get from drivers usVid = IOKitDevice::GetDeviceNumber(hService_, CFSTR("idVendor")); usPid = IOKitDevice::GetDeviceNumber(hService_, CFSTR("idProduct")); usConfigurationNum = IOKitDevice::GetDeviceNumber(hService_, CFSTR("bNumConfigurations")); ulLocation = IOKitDevice::GetDeviceNumber(hService_, CFSTR("locationID")); usAddress = IOKitDevice::GetDeviceNumber(hService_, CFSTR("USB Address")); usBusNumber = ulLocation >> 24; UCHAR bDeviceClass = IOKitDevice::GetDeviceNumber(hService_, CFSTR("bDeviceClass")); UCHAR bDeviceSubClass = IOKitDevice::GetDeviceNumber(hService_, CFSTR("bDeviceSubClass")); ulSerialNumber = IOKitDevice::GetSerialNumber(hService_, (UCHAR*) szSerialString, sizeof(szSerialString), ucSerialIndex); stDeviceDescriptor.iSerialNumber = (UInt8)ucSerialIndex; //update descriptor with serial string index SNPRINTF(szSystemPath, sizeof(szSystemPath), "%03i-%04x-%04x-%02x-%02x", usAddress, usVid, usPid, bDeviceClass, bDeviceSubClass); //!!eReturn = CheckDeviceSanity(); //if(eReturn != IOKitError::SUCCESS) // throw eReturn; return; }
static int darwinIsMountedDisc(char *bsdName, mach_port_t masterPort) { int retval = 0; CFMutableDictionaryRef matchingDict; kern_return_t rc; io_iterator_t iter; io_service_t service; if ((matchingDict = IOBSDNameMatching(masterPort, 0, bsdName)) == NULL) return(0); rc = IOServiceGetMatchingServices(masterPort, matchingDict, &iter); if ((rc != KERN_SUCCESS) || (!iter)) return(0); service = IOIteratorNext(iter); IOObjectRelease(iter); if (!service) return(0); rc = IORegistryEntryCreateIterator(service, kIOServicePlane, kIORegistryIterateRecursively | kIORegistryIterateParents, &iter); if (!iter) return(0); if (rc != KERN_SUCCESS) { IOObjectRelease(iter); return(0); } /* if */ IOObjectRetain(service); /* add an extra object reference... */ do { if (darwinIsWholeMedia(service)) { if ( (IOObjectConformsTo(service, kIOCDMediaClass)) || (IOObjectConformsTo(service, kIODVDMediaClass)) ) { retval = 1; } /* if */ } /* if */ IOObjectRelease(service); } while ((service = IOIteratorNext(iter)) && (!retval)); IOObjectRelease(iter); IOObjectRelease(service); return(retval); } /* darwinIsMountedDisc */
io_registry_entry_t lookService(uint32_t segment, uint32_t bus, uint32_t device, uint32_t function) { kern_return_t status; io_iterator_t iter; io_service_t service; IOPCIAddressSpace space; space.bits = 0; space.es.busNum = bus; space.es.deviceNum = device; space.es.functionNum = function; status = IOServiceGetMatchingServices(kIOMasterPortDefault, IOServiceMatching("IOPCIDevice"), &iter); assert(kIOReturnSuccess == status); while ((service = IOIteratorNext(iter))) { CFDataRef reg; UInt32 bits; reg = IORegistryEntryCreateCFProperty(service, CFSTR("reg"), kCFAllocatorDefault, kNilOptions); bits = 0; if (reg) { if (CFDataGetTypeID() == CFGetTypeID(reg)) bits = ((UInt32 *)CFDataGetBytePtr(reg))[0]; CFRelease(reg); } if (bits == space.bits) { IOObjectRetain(service); break; } } IOObjectRelease(iter); return (service); }
int MacHaptic_MaybeAddDevice( io_object_t device ) { IOReturn result; CFMutableDictionaryRef hidProperties; CFTypeRef refCF; SDL_hapticlist_item *item; if (numhaptics == -1) { return -1; /* not initialized. We'll pick these up on enumeration if we init later. */ } /* Check for force feedback. */ if (FFIsForceFeedback(device) != FF_OK) { return -1; } /* Make sure we don't already have it */ for (item = SDL_hapticlist; item ; item = item->next) { if (IOObjectIsEqualTo((io_object_t) item->dev, device)) { /* Already added */ return -1; } } item = (SDL_hapticlist_item *)SDL_calloc(1, sizeof(SDL_hapticlist_item)); if (item == NULL) { return SDL_SetError("Could not allocate haptic storage"); } /* retain it as we are going to keep it around a while */ IOObjectRetain(device); /* Set basic device data. */ HIDGetDeviceProduct(device, item->name); item->dev = device; /* Set usage pages. */ hidProperties = 0; refCF = 0; result = IORegistryEntryCreateCFProperties(device, &hidProperties, kCFAllocatorDefault, kNilOptions); if ((result == KERN_SUCCESS) && hidProperties) { refCF = CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDPrimaryUsagePageKey)); if (refCF) { if (!CFNumberGetValue(refCF, kCFNumberLongType, &item->usagePage)) { SDL_SetError("Haptic: Receiving device's usage page."); } refCF = CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDPrimaryUsageKey)); if (refCF) { if (!CFNumberGetValue(refCF, kCFNumberLongType, &item->usage)) { SDL_SetError("Haptic: Receiving device's usage."); } } } CFRelease(hidProperties); } if (SDL_hapticlist_tail == NULL) { SDL_hapticlist = SDL_hapticlist_tail = item; } else { SDL_hapticlist_tail->next = item; SDL_hapticlist_tail = item; } /* Device has been added. */ ++numhaptics; return numhaptics; }
/** * Guess the media that a volume/partition is on */ MythMediaType FindMediaType(io_service_t service) { kern_return_t kernResult; io_iterator_t iter; MythMediaType mediaType = MEDIATYPE_UNKNOWN; QString msg = QString("FindMediaType() - "); bool isWholeMedia = false; // Create an iterator across all parents of the service object passed in. kernResult = IORegistryEntryCreateIterator(service, kIOServicePlane, kIORegistryIterateRecursively | kIORegistryIterateParents, &iter); if (KERN_SUCCESS != kernResult) LOG(VB_GENERAL, LOG_CRIT, msg + QString("IORegistryEntryCreateIterator returned %1") .arg(kernResult)); else if (!iter) LOG(VB_GENERAL, LOG_CRIT, msg + "IORegistryEntryCreateIterator returned NULL iterator"); else { // A reference on the initial service object is released in // the do-while loop below, so add a reference to balance IOObjectRetain(service); do { isWholeMedia = false; if (IOObjectConformsTo(service, kIOMediaClass)) { CFTypeRef wholeMedia; wholeMedia = IORegistryEntryCreateCFProperty (service, CFSTR(kIOMediaWholeKey), kCFAllocatorDefault, 0); if (!wholeMedia) LOG(VB_GENERAL, LOG_ALERT, msg + "Could not retrieve Whole property"); else { isWholeMedia = CFBooleanGetValue((CFBooleanRef)wholeMedia); CFRelease(wholeMedia); } } if (isWholeMedia) { if (IOObjectConformsTo(service, kIODVDMediaClass)) mediaType = MEDIATYPE_DVD; else if (IOObjectConformsTo(service, kIOCDMediaClass)) mediaType = MEDIATYPE_AUDIO; } IOObjectRelease(service); } while ((service = IOIteratorNext(iter)) && (mediaType == MEDIATYPE_UNKNOWN)); IOObjectRelease(iter); } return mediaType; }