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
}
