kern_return_t
fake_IOConnectGetService(
io_connect_t connect,
io_service_t * service )
{
kern_return_t ret = IOConnectGetService(connect, service);
printf("IOConnectGetService(connect=%x, service=%p) (*service after call = %x\n", connect, service, *service);
return ret;
}
kern_return_t IOHIDSetHIDParameterToEventSystem(io_connect_t handle, CFStringRef key, CFTypeRef parameter) {
IOHIDEventSystemClientRef client = IOHIDEventSystemClientCreateWithType (kCFAllocatorDefault, kIOHIDEventSystemClientTypeMonitor, NULL);
kern_return_t kr = kIOReturnNotReady;
if (!client) {
goto exit;
}
kr = kIOReturnUnsupported;
io_service_t service = 0;
if (IOConnectGetService (handle, &service) == kIOReturnSuccess) {
if (IOObjectConformsTo (service, "IOHIDSystem")) {
IOHIDEventSystemClientSetProperty(client, key, parameter);
kr = kIOReturnSuccess;
} else {
uint64_t entryID = 0;
if (IORegistryEntryGetRegistryEntryID (service, &entryID) == kIOReturnSuccess) {
IOHIDServiceClientRef serviceClient = IOHIDEventSystemClientCopyServiceForRegistryID(client, entryID);
if (serviceClient) {
if (IOHIDServiceClientSetProperty(serviceClient, key, parameter)) {
kr = kIOReturnSuccess;
} else {
kr = kIOReturnInternalError;
}
CFRelease(serviceClient);
}
}
}
IOObjectRelease(service);
}
exit:
if (client) {
CFRelease(client);
}
if (kr) {
os_log_error(_IOHIDLog(), "Fail to set parameter with status 0x%x", kr);
}
return kr;
}
kern_return_t IOHIDCopyHIDParameterFromEventSystem(io_connect_t handle, CFStringRef key, CFTypeRef *parameter) {
CFTypeRef param = NULL;
IOHIDEventSystemClientRef client = IOHIDEventSystemClientCreateWithType (kCFAllocatorDefault, kIOHIDEventSystemClientTypePassive, NULL);
kern_return_t kr = kIOReturnNotReady;
if (!client) {
goto exit;
}
io_service_t service = 0;
if (IOConnectGetService (handle, &service) == kIOReturnSuccess) {
if (IOObjectConformsTo (service, "IOHIDSystem")) {
param = IOHIDEventSystemClientCopyProperty(client, key);
} else {
uint64_t entryID = 0;
if (IORegistryEntryGetRegistryEntryID (service, &entryID) == kIOReturnSuccess) {
IOHIDServiceClientRef serviceClient = IOHIDEventSystemClientCopyServiceForRegistryID(client, entryID);
if (serviceClient) {
param = IOHIDServiceClientCopyProperty(serviceClient, key);
CFRelease(serviceClient);
}
}
}
IOObjectRelease(service);
}
exit:
if (param) {
*parameter = param;
kr = kIOReturnSuccess;
}
if (client) {
CFRelease(client);
}
if (kr) {
os_log_error(_IOHIDLog(), "Fail to get parameter with status 0x%x", kr);
}
return kr;
}
kern_return_t IOHIDCopyCFTypeParameter( io_connect_t handle, CFStringRef key, CFTypeRef * parameter )
{
kern_return_t kr;
io_service_t hidsystem = MACH_PORT_NULL;
CFDictionaryRef paramDict;
CFTypeRef tempParameter = NULL;
if (!parameter)
return kIOReturnError;
kr = IOConnectGetService( handle, &hidsystem );
if (KERN_SUCCESS == kr) {
if( (paramDict = IORegistryEntryCreateCFProperty( hidsystem, CFSTR(kIOHIDParametersKey), kCFAllocatorDefault, kNilOptions)))
{
if ( (tempParameter = CFDictionaryGetValue( paramDict, key)) )
CFRetain(tempParameter);
CFRelease(paramDict);
}
if ( !tempParameter )
tempParameter = IORegistryEntryCreateCFProperty( hidsystem, key, kCFAllocatorDefault, kNilOptions);
if ( !tempParameter )
kr = kIOReturnBadArgument;
*parameter = tempParameter;
}
if (KERN_SUCCESS != kr) {
kr = IOHIDCopyHIDParameterFromEventSystem(handle, key, parameter);
}
if (hidsystem) {
IOObjectRelease( hidsystem );
}
return( kr );
}
IOReturn
IONetworkGetPacketFiltersMask( io_connect_t connect,
const io_name_t filterGroup,
UInt32 * filtersMask,
IOOptionBits options )
{
IOReturn kr;
io_service_t service = 0;
CFMutableDictionaryRef dict = 0;
CFArrayRef keysArray = 0;
CFStringRef group = 0;
CFStringRef keys[2];
CFTypeRef value;
do {
*filtersMask = 0;
// Locate our service provider.
kr = IOConnectGetService( connect, &service );
if ( kr != kIOReturnSuccess ) break;
if ( kIONetworkSupportedPacketFilters & options )
{
io_service_t parentService;
kr = IORegistryEntryGetParentEntry( service, kIOServicePlane,
&parentService );
if ( kr != kIOReturnSuccess ) break;
IOObjectRelease( service );
service = parentService;
}
// Fetch properties from registry.
kr = IORegistryEntryCreateCFProperties( service,
&dict,
kCFAllocatorDefault,
kNilOptions );
if ( kr != kIOReturnSuccess ) break;
group = CFStringCreateWithCString( kCFAllocatorDefault, filterGroup,
CFStringGetSystemEncoding() );
if ( group == 0 )
{
kr = kIOReturnNoMemory;
break;
}
// Create an array of keys to the value.
keys[0] = (kIONetworkSupportedPacketFilters & options) ?
CFSTR( kIOPacketFilters ) :
CFSTR( kIORequiredPacketFilters );
keys[1] = group;
keysArray = CFArrayCreate( NULL, (void *)keys, 2, &kCFTypeArrayCallBacks );
if ( keysArray == 0 )
{
kr = kIOReturnNoMemory;
break;
}
value = GetDictionaryValueUsingKeys( dict, keysArray, CFNumberGetTypeID() );
if ( value == 0 )
{
kr = kIOReturnNotFound;
break;
}
CFNumberGetValue( (CFNumberRef)value, kCFNumberSInt32Type, filtersMask );
}
while ( 0 );
if ( dict ) CFRelease( dict );
if ( group ) CFRelease( group );
if ( keysArray ) CFRelease( keysArray );
if ( service ) IOObjectRelease( service );
return kr;
}
/* Status query */
NXEventSystemInfoType NXEventSystemInfo(NXEventHandle handle,
char *flavor,
NXEventSystemInfoType evs_info,
unsigned int *evs_info_cnt)
{
kern_return_t kr;
NXEventSystemDevice * info = (NXEventSystemDevice *) evs_info;
int maxDeviceCount = (*evs_info_cnt) * sizeof( int) / sizeof( NXEventSystemDevice);
int deviceCount = 0;
int i;
io_registry_entry_t hidsystem;
CFArrayRef array;
CFDictionaryRef dict;
CFNumberRef num;
SInt32 val;
// Translate the one existing old case to new format
if ( ((uintptr_t) flavor) == __OLD_NX_EVS_DEVICE_INFO )
flavor = NX_EVS_DEVICE_INFO;
if( strcmp( flavor, NX_EVS_DEVICE_INFO))
kr = kIOReturnUnsupported;
do {
kr = IOConnectGetService( handle, &hidsystem );
if( KERN_SUCCESS != kr )
break;
array = IORegistryEntryCreateCFProperty(hidsystem, CFSTR("NXSystemInfo"),
kCFAllocatorDefault, kNilOptions);
IOObjectRelease( hidsystem );
if( !array )
break;
deviceCount = CFArrayGetCount(array);
if ( deviceCount > maxDeviceCount )
deviceCount = maxDeviceCount;
for ( i=0; i<deviceCount; i++) {
dict = CFArrayGetValueAtIndex(array, i);
if( !dict )
continue;
if( (num = CFDictionaryGetValue( dict, CFSTR(kIOHIDKindKey )))) {
CFNumberGetValue( num, kCFNumberSInt32Type, &val );
info[ i ].dev_type = val;
if( (num = CFDictionaryGetValue( dict, CFSTR(kIOHIDInterfaceIDKey ))))
CFNumberGetValue( num, kCFNumberSInt32Type, &val );
else
val = 0;
info[ i ].interface = val;
if( (num = CFDictionaryGetValue( dict, CFSTR(kIOHIDSubinterfaceIDKey ))))
CFNumberGetValue( num, kCFNumberSInt32Type, &val );
else
val = 0;
info[ i ].id = val;
info[ i ].interface_addr = 0;
}
}
CFRelease(array);
} while( false );
if ( kr == KERN_SUCCESS )
*evs_info_cnt = (deviceCount * sizeof( NXEventSystemDevice) / sizeof( int));
else
evs_info = (NXEventSystemInfoType) 0;
return evs_info;
}
