IOFireWireLibConfigDirectory.cpp [plain text]
#import "IOFireWireLibConfigDirectory.h"
#import "IOFireWireLibDevice.h"
#import <System/libkern/OSCrossEndian.h>
namespace IOFireWireLib {
ConfigDirectoryCOM::Interface ConfigDirectoryCOM::sInterface = {
INTERFACEIMP_INTERFACE,
1, 0, & ConfigDirectoryCOM::SUpdate,
& ConfigDirectoryCOM::SGetKeyType,
& ConfigDirectoryCOM::SGetKeyValue_UInt32,
& ConfigDirectoryCOM::SGetKeyValue_Data,
& ConfigDirectoryCOM::SGetKeyValue_ConfigDirectory,
& ConfigDirectoryCOM::SGetKeyOffset_FWAddress,
& ConfigDirectoryCOM::SGetIndexType,
& ConfigDirectoryCOM::SGetIndexKey,
& ConfigDirectoryCOM::SGetIndexValue_UInt32,
& ConfigDirectoryCOM::SGetIndexValue_Data,
& ConfigDirectoryCOM::SGetIndexValue_String,
& ConfigDirectoryCOM::SGetIndexValue_ConfigDirectory,
& ConfigDirectoryCOM::SGetIndexOffset_FWAddress,
& ConfigDirectoryCOM::SGetIndexOffset_UInt32,
& ConfigDirectoryCOM::SGetIndexEntry,
& ConfigDirectoryCOM::SGetSubdirectories,
& ConfigDirectoryCOM::SGetKeySubdirectories,
& ConfigDirectoryCOM::SGetType,
& ConfigDirectoryCOM::SGetNumEntries
} ;
ConfigDirectory::ConfigDirectory( const IUnknownVTbl & interface, Device& userclient, UserObjectHandle inKernConfigDirectoryRef)
: IOFireWireIUnknown( interface ),
mUserClient( userclient ),
mKernConfigDirectoryRef( inKernConfigDirectoryRef )
{
mUserClient.AddRef() ;
}
ConfigDirectory::ConfigDirectory( const IUnknownVTbl & interface, Device& userclient )
: IOFireWireIUnknown( interface ),
mUserClient( userclient )
{
uint32_t outputCnt = 1;
uint64_t outputVal = 0;
IOReturn err = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_Create,
NULL,0,
&outputVal,&outputCnt);
mKernConfigDirectoryRef = (UserObjectHandle) outputVal;
if (err)
throw err ;
mUserClient.AddRef() ;
}
ConfigDirectory::~ConfigDirectory()
{
IOReturn error = kIOReturnSuccess;
uint32_t outputCnt = 0;
const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
error = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kReleaseUserObject,
inputs,1,
NULL,&outputCnt);
DebugLogCond( error, "release config dir failed err=%x\n", error ) ;
mUserClient.Release() ;
}
IOReturn
ConfigDirectory::Update(UInt32 offset)
{
return kIOReturnUnsupported ;
}
IOReturn
ConfigDirectory::GetKeyType(int key, IOConfigKeyType& type)
{
uint32_t outputCnt = 1;
uint64_t outputVal = 0;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, key};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyType,
inputs,2,
&outputVal,&outputCnt);
type = (IOConfigKeyType) (outputCnt & 0xFFFFFFFF);
return result;
}
IOReturn
ConfigDirectory::GetKeyValue(int key, UInt32 &value, CFStringRef*& text)
{
UserObjectHandle kernelStringRef ;
UInt32 stringLen ;
uint32_t outputCnt = 3;
uint64_t outputVal[3];
const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,(text != nil)};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyValue_UInt32,
inputs,3,
outputVal,&outputCnt);
value = outputVal[0] & 0xFFFFFFFF;
kernelStringRef = (UserObjectHandle) outputVal[1];
stringLen = outputVal[2] & 0xFFFFFFFF;
if (text && (kIOReturnSuccess == result))
result = mUserClient.CreateCFStringWithOSStringRef(kernelStringRef, stringLen, text) ;
return result ;
}
IOReturn
ConfigDirectory::GetKeyValue(int key, CFDataRef* value, CFStringRef*& text)
{
GetKeyValueDataResults results ;
uint32_t outputCnt = 0;
size_t outputStructSize = sizeof(results) ;
const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key, (text != nil)};
IOReturn error = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyValue_Data,
inputs,3,
NULL,0,
NULL,&outputCnt,
& results,&outputStructSize);
ROSETTA_ONLY(
{
results.data = (UserObjectHandle)OSSwapInt32( (UInt32)results.data );
results.dataLength = OSSwapInt32( results.dataLength );
results.textLength = OSSwapInt32( results.textLength );
}
);
if ( text && (kIOReturnSuccess == error))
error = mUserClient.CreateCFStringWithOSStringRef( results.text, results.textLength, text ) ;
if ( kIOReturnSuccess == error )
error = mUserClient.CreateCFDataWithOSDataRef( results.data, results.dataLength, value ) ;
return error ;
}
IOReturn
ConfigDirectory::GetKeyValue(int key, DirRef& value, REFIID iid, CFStringRef*& text)
{
UserObjectHandle kernelStringRef ;
UserObjectHandle kernelDirectoryRef ;
UInt32 stringLen ;
uint32_t outputCnt = 3;
uint64_t outputVal[3];
const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,(text != nil)};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyValue_ConfigDirectory,
inputs,3,
outputVal,&outputCnt);
kernelDirectoryRef =(UserObjectHandle) outputVal[0];
kernelStringRef = (UserObjectHandle) outputVal[1];
stringLen = outputVal[2] & 0xFFFFFFFF;
IUnknownVTbl** iUnknown = nil ;
if (kIOReturnSuccess == result)
{
iUnknown = reinterpret_cast<IUnknownVTbl**>(ConfigDirectoryCOM::Alloc(mUserClient, kernelDirectoryRef)) ;
if (!iUnknown)
result = kIOReturnNoMemory ;
else
{
if (S_OK != (*iUnknown)->QueryInterface(iUnknown, iid, (void**) & value))
result = kIOReturnError ;
(*iUnknown)->Release(iUnknown) ;
}
if (text && (kIOReturnSuccess == result))
result = mUserClient.CreateCFStringWithOSStringRef(kernelStringRef, stringLen, text) ;
}
return result ;
}
IOReturn
ConfigDirectory::GetKeyOffset (
int key,
FWAddress & value,
CFStringRef * & text)
{
GetKeyOffsetResults results ;
uint32_t outputCnt = 0;
size_t outputStructSize = sizeof(results) ;
const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key, (text != nil)};
IOReturn error = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyOffset_FWAddress,
inputs,3,
NULL,0,
NULL,&outputCnt,
& results,&outputStructSize);
ROSETTA_ONLY(
{
results.address.nodeID = OSSwapInt16( results.address.nodeID );
results.address.addressHi = OSSwapInt16( results.address.addressHi );
results.address.addressLo = OSSwapInt32( results.address.addressLo );
results.length = OSSwapInt32( results.length );
}
);
value = results.address ;
if (text && (kIOReturnSuccess == error))
error = mUserClient.CreateCFStringWithOSStringRef( results.text, results.length, text ) ;
return error ;
}
IOReturn
ConfigDirectory::GetKeyValue(int key, UserObjectHandle& value)
{
UserObjectHandle kernelStringRef ;
UserObjectHandle kernelDirectoryRef ;
UInt32 stringLen ;
uint32_t outputCnt = 3;
uint64_t outputVal[3];
const uint64_t inputs[3] = {(const uint64_t)mKernConfigDirectoryRef, key,false};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeyValue_ConfigDirectory,
inputs,3,
outputVal,&outputCnt);
kernelDirectoryRef =(UserObjectHandle) outputVal[0];
kernelStringRef = (UserObjectHandle) outputVal[1];
stringLen = outputVal[2] & 0xFFFFFFFF;
return result ;
}
IOReturn
ConfigDirectory::GetIndexType(int index, IOConfigKeyType &type)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexType,
inputs,2,
&outputVal,&outputCnt);
type = (IOConfigKeyType)(outputVal & 0xFFFFFFFF);
return result;
}
IOReturn
ConfigDirectory::GetIndexKey(int index, int &key)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexKey,
inputs,2,
&outputVal,&outputCnt);
key = outputVal & 0xFFFFFFFF;
return result;
}
IOReturn
ConfigDirectory::GetIndexValue(int index, UInt32& value)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexValue_UInt32,
inputs,2,
&outputVal,&outputCnt);
value = outputVal & 0xFFFFFFFF;
return result;
}
IOReturn
ConfigDirectory::GetIndexValue(int index, CFDataRef* value)
{
UserObjectHandle dataRef ;
IOByteCount dataLen ;
uint32_t outputCnt = 2;
uint64_t outputVal[2];
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexValue_Data,
inputs,2,
outputVal,&outputCnt);
dataRef = (UserObjectHandle) outputVal[0];
dataLen = outputVal[1] & 0xFFFFFFFF;
if (kIOReturnSuccess == result)
result = mUserClient.CreateCFDataWithOSDataRef(dataRef, dataLen, value) ;
return result ;
}
IOReturn
ConfigDirectory::GetIndexValue(int index, CFStringRef* value)
{
UserObjectHandle stringRef ;
UInt32 stringLen ;
uint32_t outputCnt = 2;
uint64_t outputVal[2];
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexValue_String,
inputs,2,
outputVal,&outputCnt);
stringRef = (UserObjectHandle) outputVal[0];
stringLen = outputVal[1] & 0xFFFFFFFF;
if (kIOReturnSuccess == result)
result = mUserClient.CreateCFStringWithOSStringRef(stringRef, stringLen, value) ;
return result ;
}
#if 0
IOReturn
ConfigDirectory::GetIndexValue(int index, UserObjectHandle& value)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexValue_ConfigDirectory,
inputs,2,
&outputVal,&outputCnt);
value = (UserObjectHandle) outputVal;
return result;
}
#endif
IOReturn
ConfigDirectory::GetIndexValue (
int index,
IOFireWireLibConfigDirectoryRef & value,
REFIID iid)
{
UserObjectHandle directoryRef ;
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexValue_ConfigDirectory,
inputs,2,
&outputVal,&outputCnt);
directoryRef = (UserObjectHandle) outputVal;
IUnknownVTbl** iUnknown ;
if (kIOReturnSuccess == result)
{
iUnknown = reinterpret_cast<IUnknownVTbl**>(ConfigDirectoryCOM::Alloc(mUserClient, directoryRef)) ;
if (!iUnknown)
result = kIOReturnNoMemory ;
else
{
if (S_OK != (*iUnknown)->QueryInterface(iUnknown, iid, (void**) & value))
result = kIOReturnError ;
(*iUnknown)->Release(iUnknown) ;
}
}
return result ;
}
IOReturn
ConfigDirectory::GetIndexOffset(int index, FWAddress& value)
{
uint32_t outputCnt = 0;
size_t outputStructSize = sizeof(value) ;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexOffset_FWAddress,
inputs,2,
NULL,0,
NULL,&outputCnt,
& value,&outputStructSize);
ROSETTA_ONLY(
{
value.nodeID = OSSwapInt16( value.nodeID );
value.addressHi = OSSwapInt16( value.addressHi );
value.addressLo = OSSwapInt32( value.addressLo );
}
);
return result ;
}
IOReturn
ConfigDirectory::GetIndexOffset(int index, UInt32& value)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexOffset_UInt32,
inputs,2,
&outputVal,&outputCnt);
value = outputVal & 0xFFFFFFFF;
return result;
}
IOReturn
ConfigDirectory::GetIndexEntry(int index, UInt32 &value)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, index};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetIndexEntry,
inputs,2,
&outputVal,&outputCnt);
value = outputVal & 0xFFFFFFFF;
return result;
}
IOReturn
ConfigDirectory::GetSubdirectories(io_iterator_t *outIterator)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetSubdirectories,
inputs,1,
&outputVal,&outputCnt);
*outIterator = (io_iterator_t) outputVal;
return result;
}
IOReturn
ConfigDirectory::GetKeySubdirectories(int key, io_iterator_t *outIterator)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[2] = {(const uint64_t)mKernConfigDirectoryRef, key};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetKeySubdirectories,
inputs,2,
&outputVal,&outputCnt);
*outIterator = (io_iterator_t) outputVal;
return result;
}
IOReturn
ConfigDirectory::GetType(int *outType)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetType,
inputs,1,
&outputVal,&outputCnt);
*outType = outputVal & 0xFFFFFFFF;
return result;
}
IOReturn
ConfigDirectory::GetNumEntries(int *outNumEntries)
{
uint32_t outputCnt = 1;
uint64_t outputVal;
const uint64_t inputs[1]={(const uint64_t)mKernConfigDirectoryRef};
IOReturn result = IOConnectCallScalarMethod(mUserClient.GetUserClientConnection(),
kConfigDirectory_GetNumEntries,
inputs,1,
&outputVal,&outputCnt);
*outNumEntries = outputVal & 0xFFFFFFFF;
return result;
}
#pragma mark -
ConfigDirectoryCOM::ConfigDirectoryCOM( Device& inUserClient, UserObjectHandle inDirRef )
: ConfigDirectory( reinterpret_cast<const IUnknownVTbl &>( sInterface ), inUserClient, inDirRef)
{
}
ConfigDirectoryCOM::ConfigDirectoryCOM( Device& inUserClient )
: ConfigDirectory( reinterpret_cast<const IUnknownVTbl &>( sInterface ), inUserClient)
{
}
ConfigDirectoryCOM::~ConfigDirectoryCOM()
{
}
IUnknownVTbl**
ConfigDirectoryCOM::Alloc( Device& inUserClient, UserObjectHandle inDirRef )
{
ConfigDirectoryCOM* me = nil ;
try {
me = new ConfigDirectoryCOM(inUserClient, inDirRef) ;
} catch(...) {
}
return ( nil == me ) ? nil : reinterpret_cast<IUnknownVTbl**>(& me->GetInterface()) ;
}
IUnknownVTbl**
ConfigDirectoryCOM::Alloc(Device& inUserClient)
{
ConfigDirectoryCOM * me = nil ;
try {
me = new ConfigDirectoryCOM(inUserClient) ;
} catch (...) {
}
return ( nil == me ) ? nil : reinterpret_cast<IUnknownVTbl**>(& me->GetInterface()) ;
}
HRESULT STDMETHODCALLTYPE
ConfigDirectoryCOM::QueryInterface(REFIID iid, LPVOID* ppv)
{
HRESULT result = S_OK ;
*ppv = nil ;
CFUUIDRef interfaceID = CFUUIDCreateFromUUIDBytes(kCFAllocatorDefault, iid) ;
if ( CFEqual(interfaceID, IUnknownUUID) || CFEqual(interfaceID, kIOFireWireConfigDirectoryInterfaceID) )
{
*ppv = & GetInterface() ;
AddRef() ;
}
else
{
*ppv = nil ;
result = E_NOINTERFACE ;
}
CFRelease(interfaceID) ;
return result ;
}
IOReturn
ConfigDirectoryCOM::SUpdate(
IOFireWireLibConfigDirectoryRef inDir,
UInt32 inOffset)
{
return kIOReturnUnsupported ;
}
IOReturn
ConfigDirectoryCOM::SGetKeyType(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
IOConfigKeyType* outType)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyType(inKey, *outType) ;
}
IOReturn
ConfigDirectoryCOM::SGetKeyValue_UInt32(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
UInt32* outValue,
CFStringRef* outText)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, * outValue, outText) ;
}
IOReturn
ConfigDirectoryCOM::SGetKeyValue_Data(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
CFDataRef * outValue,
CFStringRef* outText)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, outValue, outText) ;
}
IOReturn
ConfigDirectoryCOM::SGetKeyValue_ConfigDirectory(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
IOFireWireLibConfigDirectoryRef* outValue,
REFIID iid,
CFStringRef* outText)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyValue(inKey, * outValue, iid, outText) ;
}
IOReturn
ConfigDirectoryCOM::SGetKeyOffset_FWAddress(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
FWAddress* outValue,
CFStringRef* text)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeyOffset(inKey, *outValue, text) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexType(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
IOConfigKeyType* outType)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexType(inIndex, *outType) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexKey(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
int * outKey)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexKey(inIndex, *outKey) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexValue_UInt32(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
UInt32 * outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, *outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexValue_Data(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
CFDataRef * outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexValue_String(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
CFStringRef* outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexValue_ConfigDirectory(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
IOFireWireLibConfigDirectoryRef* outValue,
REFIID iid)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexValue(inIndex, *outValue, iid) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexOffset_FWAddress(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
FWAddress* outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexOffset(inIndex, *outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexOffset_UInt32(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
UInt32* outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexOffset(inIndex, *outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetIndexEntry(
IOFireWireLibConfigDirectoryRef inDir,
int inIndex,
UInt32* outValue)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetIndexEntry(inIndex, *outValue) ;
}
IOReturn
ConfigDirectoryCOM::SGetSubdirectories(
IOFireWireLibConfigDirectoryRef inDir,
io_iterator_t* outIterator)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetSubdirectories(outIterator) ;
}
IOReturn
ConfigDirectoryCOM::SGetKeySubdirectories(
IOFireWireLibConfigDirectoryRef inDir,
int inKey,
io_iterator_t * outIterator)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetKeySubdirectories(inKey, outIterator) ;
}
IOReturn
ConfigDirectoryCOM::SGetType(
IOFireWireLibConfigDirectoryRef inDir,
int * outType)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetType(outType) ;
}
IOReturn
ConfigDirectoryCOM::SGetNumEntries(
IOFireWireLibConfigDirectoryRef inDir,
int * outNumEntries)
{
return IOFireWireIUnknown::InterfaceMap<ConfigDirectoryCOM>::GetThis(inDir)->GetNumEntries(outNumEntries) ;
}
}