static int sleepImmediately (void) { mach_port_t masterPort; io_connect_t rootPort; IOReturn err; if (IOPMSleepEnabled()) { if ((err = IOMasterPort(MACH_PORT_NULL, &masterPort))) { fprintf (stderr, "%s: can't get mach master port: %ld\n", args.progname, (long) err); return (1); } rootPort = IOPMFindPowerManagement(masterPort); if (rootPort) { err = IOPMSleepSystem(rootPort); if (err) { fprintf (stderr, "%s: IOPMSleepSystem failed: %ld\n", args.progname, (long) err); return (1); } } else { fprintf (stderr, "%s: IOPMFindPowerManagement failed\n", args.progname); return (1); } } else { fprintf (stderr, "%s: sleep mode is disabled\n", args.progname); return (1); } return (0); }
int AoEProperties::configure_matching(void) { // debugVerbose("AoEProperties::configure_matching\n"); // Obtain ports for notifications (this will be used for all service matching notifications) kern_return_t kresult; mach_port_t MasterPort; kresult = IOMasterPort(MACH_PORT_NULL, &MasterPort); if ( kresult ) { debugError("Could not get masterport. Error=%d\n", kresult); return false; } ms_NotificationPort = IONotificationPortCreate(MasterPort); ms_IOKitNotificationRunLoopSource = IONotificationPortGetRunLoopSource(ms_NotificationPort); CFRunLoopAddSource(CFRunLoopGetCurrent(), ms_IOKitNotificationRunLoopSource, kCFRunLoopDefaultMode); // SetUp Notification for matching to our device CFMutableDictionaryRef MatchingDict = IOServiceMatching(AOE_KEXT_NAME_Q); IOServiceAddMatchingNotification(ms_NotificationPort, kIOMatchedNotification, MatchingDict, AoEProperties::matched_callback, this, &ms_MatchIt); // Call the callback immediately to check if our iterator already contains our device (ie. the device is already loaded) matched_callback(this, ms_MatchIt); return m_fMatched ? 0 : -1; }
/** * Use the DiskArbitration Daemon to inform us of media changes */ void MonitorThreadDarwin::run(void) { CFDictionaryRef match = kDADiskDescriptionMatchVolumeMountable; DASessionRef daSession = DASessionCreate(kCFAllocatorDefault); IOMasterPort(MACH_PORT_NULL, &sMasterPort); DARegisterDiskAppearedCallback(daSession, match, diskAppearedCallback, this); DARegisterDiskDisappearedCallback(daSession, match, diskDisappearedCallback, this); DARegisterDiskDescriptionChangedCallback(daSession, match, kDADiskDescriptionWatchVolumeName, diskChangedCallback, this); DASessionScheduleWithRunLoop(daSession, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode); // Nice and simple, as long as our monitor is valid and active, // loop and let daSession check the devices. while (m_Monitor && m_Monitor->IsActive()) { // Run the run loop for interval (milliseconds) - this will // handle any disk arbitration appeared/dissappeared events CFRunLoopRunInMode(kCFRunLoopDefaultMode, (float) m_Interval / 1000.0f, false ); } DAUnregisterCallback(daSession, (void(*))diskChangedCallback, this); DAUnregisterCallback(daSession, (void(*))diskDisappearedCallback, this); DAUnregisterCallback(daSession, (void(*))diskAppearedCallback, this); CFRelease(daSession); }
kern_return_t SMCOpen(io_connect_t *conn, const char *serviceName) { kern_return_t result; mach_port_t masterPort; io_iterator_t iterator; io_object_t device; IOMasterPort(MACH_PORT_NULL, &masterPort); CFMutableDictionaryRef matchingDictionary = IOServiceMatching(serviceName); result = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator); if (result != kIOReturnSuccess) { //printf("Error: IOServiceGetMatchingServices() = %08x\n", result); return 1; } device = IOIteratorNext(iterator); IOObjectRelease((io_object_t)iterator); if (device == 0) { //printf("Error: no SMC found\n"); return 1; } result = IOServiceOpen(device, mach_task_self(), 0, conn); IOObjectRelease(device); if (result != kIOReturnSuccess) { //printf("Error: IOServiceOpen() = %08x\n", result); return 1; } return kIOReturnSuccess; }
int main(int argc, char **argv) { mach_port_t masterPort; kern_return_t status; int arg; // Parse args if( argc < 2 ) { printf("%s ClassName...\n", argv[0]); exit(0); } // Obtain the I/O Kit communication handle. status = IOMasterPort(bootstrap_port, &masterPort); assert(status == KERN_SUCCESS); for( arg = 1; arg < argc; arg++ ) { printf("terminate %s...", argv[arg]); status = IOCatalogueTerminate( masterPort, 0, argv[arg] ); printf("(%08x)\n", status); } exit(0); }
int inputopen(usbdevice* kb){ // Open master port (if not done yet) static mach_port_t master = 0; kern_return_t res; if(!master&& (res = IOMasterPort(bootstrap_port, &master)) != KERN_SUCCESS){ master = 0; printf("Unable to open master port: 0x%08x\n", res); return 0; } // Open an HID service io_iterator_t iter; if((res = IOServiceGetMatchingServices(master, IOServiceMatching(kIOHIDSystemClass), &iter)) != KERN_SUCCESS){ printf("Unable to get input service iterator: 0x%08x\n", res); return 0; } if((res = IOServiceOpen(IOIteratorNext(iter), mach_task_self(), kIOHIDParamConnectType, &kb->event)) != KERN_SUCCESS){ IOObjectRelease(iter); printf("Unable to open IO service: 0x%08x\n", res); kb->event = 0; return 0; } IOObjectRelease(iter); clearkeys(kb); return 1; }
// Opens HID service. Returns kIOReturnSuccess on success. static int open_iohid(io_connect_t* connection){ io_iterator_t iter; io_service_t service; // Open master port (if not done yet) static mach_port_t master = 0; kern_return_t res; if(!master && (res = IOMasterPort(bootstrap_port, &master)) != kIOReturnSuccess){ master = 0; ckb_err("Unable to open master port: 0x%08x\n", res); goto failure; } // Open the HID service if((res = IOServiceGetMatchingServices(master, IOServiceMatching(kIOHIDSystemClass), &iter)) != kIOReturnSuccess) goto failure; service = IOIteratorNext(iter); if(!service){ res = kIOReturnNotOpen; goto failure_release_iter; } if((res = IOServiceOpen(service, mach_task_self(), kIOHIDParamConnectType, connection)) != kIOReturnSuccess){ *connection = 0; goto failure_release_iter; } // Finished; release objects and return success IOObjectRelease(service); failure_release_iter: IOObjectRelease(iter); failure: return res; }
static kern_return_t FindModems(io_iterator_t *matchingServices) { kern_return_t kernResult; mach_port_t masterPort; CFMutableDictionaryRef classesToMatch; kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort); if (KERN_SUCCESS != kernResult) { /* printf("IOMasterPort returned %d\n", kernResult); */ goto exit; } classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue); if (classesToMatch != NULL) { CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType)); } kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch, matchingServices); if (KERN_SUCCESS != kernResult) { /* printf("IOServiceGetMatchingServices returned %d\n", kernResult); */ goto exit; } exit: return kernResult; }
static kern_return_t createSerialIterator(io_iterator_t *serialIterator) { kern_return_t kernResult; mach_port_t masterPort; CFMutableDictionaryRef classesToMatch; if ((kernResult = IOMasterPort(0, &masterPort)) != KERN_SUCCESS) { printf("IOMasterPort returned %d\n", kernResult); return kernResult; } if ((classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue)) == NULL) { printf("IOServiceMatching returned NULL\n"); return kernResult; } CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),CFSTR(kIOSerialBSDAllTypes)); kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch, serialIterator); if (kernResult != KERN_SUCCESS) { printf("IOServiceGetMatchingServices returned %d\n", kernResult); } return kernResult; }
bool fetch_raw_smbios(unsigned char** data, unsigned int* length) { CFDataRef value = NULL; io_object_t device; io_iterator_t objectIterator; CFMutableDictionaryRef properties = NULL; mach_port_t master_port; bool result = false; if (kIOReturnSuccess == IOMasterPort(MACH_PORT_NULL, &master_port)) { if (kIOReturnSuccess == IOServiceGetMatchingServices(master_port, IOServiceMatching("AppleSMBIOS"), &objectIterator)) { while ((device = IOIteratorNext(objectIterator))) { if (kIOReturnSuccess == IORegistryEntryCreateCFProperties(device, &properties, kCFAllocatorDefault, kNilOptions)) { if (CFDictionaryGetValueIfPresent(properties, CFSTR("SMBIOS"), (const void **)&value)) { *length = CFDataGetLength(value); *data = new uint8[*length]; memcpy(*data, (uint8 *)CFDataGetBytePtr(value), *length); result = true; break; } CFRelease(properties); } IOObjectRelease(device); } IOObjectRelease(objectIterator); } mach_port_deallocate(mach_task_self(), master_port); } return result; }
/* =============== IN_GetIOHandle =============== */ static io_connect_t IN_GetIOHandle( void ) // mac os x mouse accel hack { io_connect_t iohandle = MACH_PORT_NULL; kern_return_t status; io_service_t iohidsystem = MACH_PORT_NULL; mach_port_t masterport; status = IOMasterPort( MACH_PORT_NULL, &masterport ); if ( status != KERN_SUCCESS ) { return 0; } iohidsystem = IORegistryEntryFromPath( masterport, kIOServicePlane ":/IOResources/IOHIDSystem" ); if ( !iohidsystem ) { return 0; } status = IOServiceOpen( iohidsystem, mach_task_self(), kIOHIDParamConnectType, &iohandle ); IOObjectRelease( iohidsystem ); return iohandle; }
static int pyidle_init(PyIdle *self, PyObject *args, PyObject *kwargs) { if (!PyArg_ParseTuple(args, ":__init__")) return -1; if (self) { io_iterator_t iterator; int ret; if ((ret = IOMasterPort(MACH_PORT_NULL, &self->machPort)) != kIOReturnSuccess) { PyErr_Format(PyExc_RuntimeError, "IOMasterPort failed: %d", ret); return -1; } if ((ret = IOServiceGetMatchingServices(self->machPort, IOServiceMatching("IOHIDSystem"), &iterator)) != kIOReturnSuccess) { PyErr_Format(PyExc_RuntimeError, "IOServiceGetMatchingServices failed: %d", ret); return -1; } if (!(self->regEntry = IOIteratorNext(iterator))) { PyErr_SetString(PyExc_RuntimeError, "Empty IO iterator"); return -1; } IOObjectRelease(iterator); } return 0; }
kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator ) { kern_return_t kernResult; mach_port_t masterPort; CFMutableDictionaryRef classesToMatch; kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort ); if ( KERN_SUCCESS != kernResult ) { printf( "IOMasterPort returned %d\n", kernResult ); } classesToMatch = IOServiceMatching( kIOCDMediaClass ); if ( classesToMatch == NULL ) { printf( "IOServiceMatching returned a NULL dictionary.\n" ); } else { CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue ); } kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator ); if ( KERN_SUCCESS != kernResult ) { printf( "IOServiceGetMatchingServices returned %d\n", kernResult ); } return kernResult; }
io_connect_t get_event_driver(void){ static mach_port_t sEventDrvrRef = 0; mach_port_t masterPort, service, iter; kern_return_t kr; if (!sEventDrvrRef) { // Get master device port kr = IOMasterPort( bootstrap_port, &masterPort ); check( KERN_SUCCESS == kr); kr = IOServiceGetMatchingServices( masterPort, IOServiceMatching( kIOHIDSystemClass ), &iter ); check( KERN_SUCCESS == kr); service = IOIteratorNext( iter ); check( service ); kr = IOServiceOpen( service, mach_task_self(), kIOHIDParamConnectType, &sEventDrvrRef ); check( KERN_SUCCESS == kr ); IOObjectRelease( service ); IOObjectRelease( iter ); } return sEventDrvrRef; }
int main(int argc, char **argv) { kern_return_t result; result = IOMasterPort(bootstrap_port, &masterPort); if (result != KERN_SUCCESS) { errx(1, "Error getting the IOMaster port: %s", mach_error_string(result)); } gPlatform = IORegistryEntryFromPath(masterPort, "IODeviceTree:/efi/platform"); if (gPlatform == 0) { errx(1, "EFI is not supported on this system"); } CFTypeRef data; result = GetOFVariable("Settings", &data); if (result != KERN_SUCCESS) { errx(1, "Clover absent or too old : %s", mach_error_string(result)); } PrintConfig(data); CFRelease(data); IOObjectRelease(gPlatform); return 0; }
/* Open and Close */ NXEventHandle NXOpenEventStatus(void) { NXEventHandle handle = MACH_PORT_NULL; register kern_return_t kr; io_service_t service = MACH_PORT_NULL; mach_port_t masterPort; do { kr = IOMasterPort( MACH_PORT_NULL, &masterPort ); if( kr != KERN_SUCCESS) break; service = IORegistryEntryFromPath( masterPort, kIOServicePlane ":/IOResources/IOHIDSystem" ); if( !service) break; kr = IOServiceOpen( service, mach_task_self(), kIOHIDParamConnectType, &handle); IOObjectRelease( service ); } while( false ); return( handle ); }
/** * Opens the IOKit service, instantiating org_virtualbox_SupDrvClient. * * @returns VBox status code. */ static int suplibDarwinOpenService(PSUPLIBDATA pThis) { /* * Open the IOKit client first - The first step is finding the service. */ mach_port_t MasterPort; kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort); if (kr != kIOReturnSuccess) { LogRel(("IOMasterPort -> %d\n", kr)); return VERR_GENERAL_FAILURE; } CFDictionaryRef ClassToMatch = IOServiceMatching(IOCLASS_NAME); if (!ClassToMatch) { LogRel(("IOServiceMatching(\"%s\") failed.\n", IOCLASS_NAME)); return VERR_GENERAL_FAILURE; } /* Create an io_iterator_t for all instances of our drivers class that exist in the IORegistry. */ io_iterator_t Iterator; kr = IOServiceGetMatchingServices(MasterPort, ClassToMatch, &Iterator); if (kr != kIOReturnSuccess) { LogRel(("IOServiceGetMatchingServices returned %d\n", kr)); return VERR_GENERAL_FAILURE; } /* Get the first item in the iterator and release it. */ io_service_t ServiceObject = IOIteratorNext(Iterator); IOObjectRelease(Iterator); if (!ServiceObject) { LogRel(("SUP: Couldn't find any matches. The kernel module is probably not loaded.\n")); return VERR_VM_DRIVER_NOT_INSTALLED; } /* * Open the service. * * This will cause the user client class in SUPDrv-darwin.cpp to be * instantiated and create a session for this process. */ io_connect_t Connection = NULL; kr = IOServiceOpen(ServiceObject, mach_task_self(), SUP_DARWIN_IOSERVICE_COOKIE, &Connection); IOObjectRelease(ServiceObject); if (kr != kIOReturnSuccess) { LogRel(("SUP: IOServiceOpen returned %d. Driver open failed.\n", kr)); pThis->uConnection = 0; return VERR_VM_DRIVER_OPEN_ERROR; } AssertCompile(sizeof(pThis->uConnection) >= sizeof(Connection)); pThis->uConnection = Connection; return VINF_SUCCESS; }
int main (int argc, const char * argv[]) { kern_return_t err; CFMutableDictionaryRef matchingDictionary = 0; // requires <IOKit/IOKitLib.h> SInt32 idVendor = 1351; SInt32 idProduct = 8193; CFNumberRef numberRef; io_iterator_t iterator = 0; io_service_t usbDeviceRef; err = IOMasterPort(MACH_PORT_NULL, &masterPort); if (err) { printf("USBSimpleExample: could not create master port, err = %08x\n", err); return err; } matchingDictionary = IOServiceMatching(kIOUSBDeviceClassName); // requires <IOKit/usb/IOUSBLib.h> if (!matchingDictionary) { printf("USBSimpleExample: could not create matching dictionary\n"); return -1; } numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &idVendor); if (!numberRef) { printf("USBSimpleExample: could not create CFNumberRef for vendor\n"); return -1; } CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBVendorID), numberRef); CFRelease(numberRef); numberRef = 0; numberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &idProduct); if (!numberRef) { printf("USBSimpleExample: could not create CFNumberRef for product\n"); return -1; } CFDictionaryAddValue(matchingDictionary, CFSTR(kUSBProductID), numberRef); CFRelease(numberRef); numberRef = 0; err = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator); matchingDictionary = 0; // this was consumed by the above call while ( (usbDeviceRef = IOIteratorNext(iterator)) ) { printf("Found device %p\n", (void*)usbDeviceRef); dealWithDevice(usbDeviceRef); IOObjectRelease(usbDeviceRef); // no longer need this reference } IOObjectRelease(iterator); iterator = 0; mach_port_deallocate(mach_task_self(), masterPort); return 0; }
void resetBaseband() { LOG(LOGLEVEL_INFO, "Resetting baseband...\n"); mach_port_t masterPort; kern_return_t result = IOMasterPort(MACH_PORT_NULL, &masterPort); CFMutableDictionaryRef matchingDict = IOServiceMatching("AppleBaseband"); io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, matchingDict); io_connect_t conn; result = IOServiceOpen(service, mach_task_self(), 0, &conn); result = IOConnectCallScalarMethod(conn, 0, 0, 0, 0, 0); IOServiceClose(conn); }
static long int getIdleTime (void) /* returns mouse and keyboard idle time in TIMER_RESOLUTION seconds; returns -1 on error */ { mach_port_t masterPort = 0; io_iterator_t iter = 0; io_registry_entry_t curObj = 0; CFMutableDictionaryRef properties = NULL; CFTypeRef obj = NULL; CFTypeID type = 0; uint64_t idletime = -1; if (IOMasterPort (MACH_PORT_NULL, &masterPort) != KERN_SUCCESS) { message (LOG_ERR, "can't get IOMasterPort\n"); goto error; } IOServiceGetMatchingServices (masterPort, IOServiceMatching(kIOHIDSystemClass), &iter); if (iter == 0) { message (LOG_ERR, "can't access IOHIDSystem\n"); goto error; } curObj = IOIteratorNext(iter); if (curObj == 0) { message (LOG_ERR, "got empty IOIterator\n"); goto error; } if (IORegistryEntryCreateCFProperties(curObj, &properties, kCFAllocatorDefault, 0) != KERN_SUCCESS || ! properties) { message (LOG_ERR, "can't access HIDIdleTime\n"); goto error; } obj = CFDictionaryGetValue(properties, CFSTR(kIOHIDIdleTimeKey)); CFRetain (obj); type = CFGetTypeID(obj); if (type == CFDataGetTypeID()) CFDataGetBytes ((CFDataRef) obj, CFRangeMake(0, sizeof(idletime)), (UInt8 *) &idletime); else if (type == CFNumberGetTypeID()) CFNumberGetValue ((CFNumberRef) obj, kCFNumberSInt64Type, &idletime); else { message (LOG_ERR, "unsupported idle time data type\n", (int) type); goto error; } idletime /= 1000000000l * TIMER_RESOLUTION; /* transform from 10**-9 to TIMER_RESOLUTION seconds */ error : if (masterPort) mach_port_deallocate (mach_task_self(), masterPort); if (obj) CFRelease(obj); if (curObj) IOObjectRelease (curObj); if (iter) IOObjectRelease (iter); if (properties) CFRelease ((CFTypeRef) properties); return (idletime); }
int wxHIDDevice::GetCount (int nClass, int nType) { mach_port_t m_pPort; //Create the mach port wxIOCHECK(IOMasterPort(bootstrap_port, &m_pPort), "Could not create mach port"); //Dictionary that will hold first //the matching dictionary for determining which kind of devices we want, //then later some registry properties from an iterator (see below) CFMutableDictionaryRef pDictionary; //Create a dictionary //The call to IOServiceMatching filters down the //the services we want to hid services (and also eats the //dictionary up for us (consumes one reference)) wxVERIFY((pDictionary = IOServiceMatching(kIOHIDDeviceKey)) != NULL ); //Here we'll filter down the services to what we want if (nType != -1) { CFNumberRef pType = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nType); CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsageKey), pType); CFRelease(pType); } if (nClass != -1) { CFNumberRef pClass = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nClass); CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsagePageKey), pClass); CFRelease(pClass); } //Now get the maching services io_iterator_t pIterator; wxIOCHECK(IOServiceGetMatchingServices(m_pPort, pDictionary, &pIterator), "No Matching HID Services"); if(pIterator == NULL) return 0; //Now we iterate through them io_object_t pObject; int nCount = 0; while ( (pObject = IOIteratorNext(pIterator)) != 0) ++nCount; //iterator cleanup IOObjectRelease(pIterator); return nCount; }//end Create()
int OpenDataPort(char *DriverClassName, io_connect_t *DataPort) { kern_return_t kernResult; mach_port_t masterPort; io_service_t serviceObject; io_connect_t dataPort; io_iterator_t iterator; CFDictionaryRef classToMatch; kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort); if (kernResult != KERN_SUCCESS) { syslog(LOG_ERR, "OpenDataPort: IOMasterPort Failed. %d\n", kernResult); return kernResult; } classToMatch = IOServiceMatching(DriverClassName); if (classToMatch == NULL) { syslog(LOG_ERR, "OpenDataPort: IOServiceMatching returned a NULL dictionary."); return -1; } kernResult = IOServiceGetMatchingServices(masterPort, classToMatch, &iterator); if (kernResult != KERN_SUCCESS) { syslog(LOG_ERR, "OpenDataPort: IOServiceGetMatchingServices Failed %d\n", kernResult); return kernResult; } serviceObject = IOIteratorNext(iterator); IOObjectRelease(iterator); if (!serviceObject) { syslog(LOG_ERR, "OpenDataPort: Couldn't find any matches."); return kernResult; } kernResult = IOServiceOpen(serviceObject, mach_task_self(), 0, &dataPort); IOObjectRelease(serviceObject); if (kernResult != KERN_SUCCESS) { syslog(LOG_ERR, "OpenDataPort: IOServiceOpen Failed %d\n", kernResult); return kernResult; } *DataPort = dataPort; return 0; }
/** * Updates the cached keyboard data. * * @todo The current implementation is very brute force... * Rewrite it so that it doesn't flush the cache completely but simply checks whether * anything has changed in the HID config. With any luck, there might even be a callback * or something we can poll for HID config changes... * setRemovalCallback() is a start... */ static void darwinHIDKeyboardCacheDoUpdate(void) { g_u64KeyboardTS = RTTimeMilliTS(); /* * Dispense with the old cache data. */ darwinHIDKeyboardCacheZap(); /* * Open the master port on the first invocation. */ if (!g_MasterPort) { kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort); AssertReturnVoid(krc == KERN_SUCCESS); } /* * Create a matching dictionary for searching for keyboards devices. */ static const UInt32 s_Page = kHIDPage_GenericDesktop; static const UInt32 s_Usage = kHIDUsage_GD_Keyboard; CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOHIDDeviceKey); AssertReturnVoid(RefMatchingDict); CFDictionarySetValue(RefMatchingDict, CFSTR(kIOHIDPrimaryUsagePageKey), CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &s_Page)); CFDictionarySetValue(RefMatchingDict, CFSTR(kIOHIDPrimaryUsageKey), CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &s_Usage)); /* * Perform the search and get a collection of keyboard devices. */ io_iterator_t Keyboards = NULL; IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &Keyboards); AssertMsgReturnVoid(rc == kIOReturnSuccess, ("rc=%d\n", rc)); RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */ /* * Enumerate the keyboards and query the cache data. */ unsigned i = 0; io_object_t KeyboardDevice; while ( i < RT_ELEMENTS(g_aKeyboards) && (KeyboardDevice = IOIteratorNext(Keyboards)) != 0) { if (darwinHIDKeyboardCacheCreateEntry(&g_aKeyboards[i], KeyboardDevice)) i++; IOObjectRelease(KeyboardDevice); } g_cKeyboards = i; IOObjectRelease(Keyboards); }
// // functions // IOReturn GetDeviceInterface( IOCFPlugInInterfaceRef* outCFPlugInInterface, IOFireWireLibNubRef* outLocalNode ) { IOReturn error = kIOReturnSuccess ; mach_port_t masterPort = 0 ; error = IOMasterPort( MACH_PORT_NULL, & masterPort ) ; io_service_t theService = 0 ; if ( error == kIOReturnSuccess ) { io_iterator_t iterator = 0 ; error = IOServiceGetMatchingServices( masterPort, IOServiceMatching( "IOFireWireLocalNode" ), & iterator ) ; if ( !iterator ) { cout << i << _file << "Couldn't get iterator\n" ; error = kIOReturnError ; } else { theService = IOIteratorNext( iterator ) ; if ( !theService ) { cout << i << _file << "Iterator returned no service\n" ; error = kIOReturnError ; } } } if ( error == kIOReturnSuccess ) { SInt32 theScore ; error = IOCreatePlugInInterfaceForService( theService, kIOFireWireLibTypeID, kIOCFPlugInInterfaceID, outCFPlugInInterface, & theScore) ; if ( error == kIOReturnSuccess ) { error = (***outCFPlugInInterface).QueryInterface( *outCFPlugInInterface, CFUUIDGetUUIDBytes( kIOFireWireNubInterfaceID ), (void**) outLocalNode ) ; if ( error != S_OK ) { cout << i << _file << "CFPlugInInterface->QueryInterface returned error\n" ; error = kIOReturnError ; } } } return error ; }
int main(int argc, char **argv) { io_registry_entry_t root; char * plane; unsigned int options; kern_return_t status; ///na int arg; // Parse args plane = kIOServicePlane; options = kDoPropsOption; for(arg = 1; arg < argc; arg++) { if ('-' == argv[arg][0]) switch(argv[arg][1]) { case 'h': printf("%s [-p] [-r] [-h] [plane]\n", argv[0]); exit(0); break; case 'p': options &= ~kDoPropsOption; break; case 'r': options |= kDoRootOption; break; } else { plane = argv[arg]; } } // Obtain the I/O Kit communication handle. // status = IOGetMasterPort(&masterPort); status = IOMasterPort(bootstrap_port, &masterPort); assert(status == KERN_SUCCESS); // Obtain the registry root entry. root = IORegistryGetRootEntry(masterPort); assert(root); // Traverse below the root in the plane. traverse(options, plane, 0, root, 0, 0); // Quit. exit(0); }
void *init_usb (void) { usb_handle_t *h = (usb_handle_t *) malloc (sizeof (usb_handle_t)); kern_return_t kr; kr = IOMasterPort (MACH_PORT_NULL, &(h->port)); if (kr || !h->port) { fprintf (stderr, "Unable to make I/O Kit port: %08x\n", kr); free (h); return NULL; } return h; }
static void _buildsysdev(void) { mach_port_t port; CFMutableDictionaryRef classesToMatch; io_iterator_t serialPortIterator; io_object_t serialDevice; CFMutableArrayRef paths; CFTypeRef path; char eiapath[MAXPATHLEN]; CFIndex i, o, npath; if(IOMasterPort(MACH_PORT_NULL, &port) != KERN_SUCCESS) return; classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue); if(classesToMatch == NULL){ printf("IOServiceMatching returned a NULL dictionary.\n"); goto Failed; } CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes)); if(IOServiceGetMatchingServices(port, classesToMatch, &serialPortIterator) != KERN_SUCCESS) goto Failed; paths = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); while((serialDevice = IOIteratorNext(serialPortIterator)) != 0){ path = IORegistryEntryCreateCFProperty(serialDevice, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0); if(path != NULL) CFArrayAppendValue(paths, path); IOObjectRelease(serialDevice); } npath = CFArrayGetCount(paths); o = 0; for(i = 0; i < npath && i < nelem(sysdev); i++){ if(CFStringGetCString(CFArrayGetValueAtIndex(paths, i), eiapath, sizeof(eiapath), kCFStringEncodingUTF8)){ sysdev[o] = strdup(eiapath); if(vflag > 1) print("BSD path: '%s'\n", sysdev[o]); o++; } } CFRelease(paths); IOObjectRelease(serialPortIterator); Failed: mach_port_deallocate(mach_task_self(), port); }
kern_return_t SMCOpen(void) { kern_return_t result; mach_port_t masterPort; io_iterator_t iterator; io_object_t device; result = IOMasterPort(MACH_PORT_NULL, &masterPort); CFMutableDictionaryRef matchingDictionary = IOServiceMatching("AppleSMC"); result = IOServiceGetMatchingServices(masterPort, matchingDictionary, &iterator); if (result != kIOReturnSuccess) { printf("Error: IOServiceGetMatchingServices() = %08x\n", result); return 1; } device = IOIteratorNext(iterator); IOObjectRelease(iterator); if (device == 0) { printf("Error: no SMC found\n"); return 1; } result = IOServiceOpen(device, mach_task_self(), 0, &conn); IOObjectRelease(device); if (result != kIOReturnSuccess) { printf("Error: IOServiceOpen() = %08x\n", result); return 1; } io_service_t platformExpert = IOServiceGetMatchingService(kIOMasterPortDefault, IOServiceMatching("IOPlatformExpertDevice")); if (platformExpert) { CFTypeRef CFProductData = IORegistryEntryCreateCFProperty(platformExpert, CFSTR("product-name"), kCFAllocatorDefault, 0); if (CFProductData) { CFIndex length = CFDataGetLength((CFDataRef)CFProductData); char buffer[length]; CFDataGetBytes((CFDataRef) CFProductData, CFRangeMake(0,length), (UInt8*)buffer); CFRelease(CFProductData); modelNo = *new std::string(buffer); } IOObjectRelease(platformExpert); } return kIOReturnSuccess; }
int IdlePlatform::secondsIdle() { mach_port_t masterPort; io_iterator_t iter; io_registry_entry_t curObj; IOMasterPort(MACH_PORT_NULL, &masterPort); IOServiceGetMatchingServices(masterPort, IOServiceMatching("IOHIDSystem"), &iter); if (iter == 0) return -1; curObj = IOIteratorNext(iter); if (curObj == 0) return -1; CFMutableDictionaryRef properties = 0; CFTypeRef obj; int result = -1; if (IORegistryEntryCreateCFProperties(curObj, &properties, kCFAllocatorDefault, 0) == KERN_SUCCESS && properties != NULL) { obj = CFDictionaryGetValue(properties, CFSTR("HIDIdleTime")); CFRetain(obj); } else obj = NULL; if (obj) { uint64_t tHandle; CFTypeID type = CFGetTypeID(obj); if (type == CFDataGetTypeID()) CFDataGetBytes((CFDataRef) obj, CFRangeMake(0, sizeof(tHandle)), (UInt8*) &tHandle); else if (type == CFNumberGetTypeID()) CFNumberGetValue((CFNumberRef)obj, kCFNumberSInt64Type, &tHandle); else return -1; CFRelease(obj); // essentially divides by 10^9 tHandle >>= 30; result = tHandle; } /* Release our resources */ IOObjectRelease(curObj); IOObjectRelease(iter); CFRelease((CFTypeRef)properties); return result; }
UsbSerial::UsbSerial( ) { deviceOpen = false; readInProgress = false; #ifdef Q_WS_MAC kern_return_t err; masterPort = 0; if( ( err = IOMasterPort( MACH_PORT_NULL, &masterPort ) ) ) printf( "could not create master port, err = %08x\n", err ); #endif #ifdef Q_WS_WIN deviceHandle = INVALID_HANDLE_VALUE; #endif }