int doAES(void* inbuf, void *outbuf, uint32_t size, uint32_t keyMask, void* key, void* iv, int mode, int bits) {
IOReturn ret;
IOAESStruct in;
pthread_once(&once_control, aes_init);
in.mode = mode;
in.bits = bits;
in.inbuf = inbuf;
in.outbuf = outbuf;
in.size = size;
in.mask = keyMask;
memset(in.keybuf, 0, sizeof(in.keybuf));
if(key)
memcpy(in.keybuf, key, in.bits / 8);
if(iv)
memcpy(in.iv, iv, 16);
else
memset(in.iv, 0, 16);
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
if(ret == kIOReturnBadArgument) {
IOAESStructSize = IOAESStruct_sizeold;
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
}
if(iv)
memcpy(iv, in.iv, 16);
return ret;
}
int doAES(void* cleartext, void *ciphertext, uint32_t size, uint32_t keyMask, void* key, void* iv, int mode, int bits) {
IOReturn ret;
IOAESStruct in;
pthread_once(&once_control, aes_init);
in.mode = mode;
in.bits = bits;
in.cleartext = cleartext;
in.ciphertext = ciphertext;
in.size = size;
in.mask = keyMask;
in.length_of_uidplus_params = 0;
memset(in.keybuf, 0, sizeof(in.keybuf));
if(key)
memcpy(in.keybuf, key, in.bits / 8);
if(iv)
memcpy(in.iv, iv, 16);
else
memset(in.iv, 0, 16);
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
if(ret == kIOReturnBadArgument) {
IOAESStructSize = IOAESStruct_sizeold;
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
}
if(iv)
memcpy(iv, in.iv, 16);
return ret;
}
static void configWrite32(io_connect_t connect, uint32_t segment,
uint32_t bus, uint32_t device, uint32_t function,
uint32_t offset,
uint32_t data)
{
AddressSpaceParam param;
kern_return_t status;
param.spaceID = kIOACPIAddressSpaceIDPCIConfiguration;
param.bitWidth = 32;
param.bitOffset = 0;
param.options = 0;
param.address.pci.offset = offset;
param.address.pci.function = function;
param.address.pci.device = device;
param.address.pci.bus = bus;
param.address.pci.segment = segment;
param.address.pci.reserved = 0;
param.value = data;
size_t outSize = 0;
status = IOConnectCallStructMethod(connect, kACPIMethodAddressSpaceWrite,
¶m, sizeof(param),
NULL, &outSize);
assert(kIOReturnSuccess == status);
}
static int darwin_iowrite(int pos, unsigned char * buf, int len)
{
kern_return_t err;
size_t dataInLen = sizeof(iomem_t);
size_t dataOutLen = sizeof(iomem_t);
iomem_t in;
iomem_t out;
in.width = len;
in.offset = pos;
memcpy(&in.data, buf, len);
if (len > 4)
return 1;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kWriteIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kWriteIO, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
return 0;
}
msr_t rdmsr(int addr)
{
kern_return_t err;
size_t dataInLen = sizeof(msrcmd_t);
size_t dataOutLen = sizeof(msrcmd_t);
msrcmd_t in, out;
msr_t ret = { INVALID_MSR_HI, INVALID_MSR_LO };
in.core = current_logical_cpu;
in.index = addr;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kReadMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kReadMSR, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return ret;
ret.lo = out.lo;
ret.hi = out.hi;
return ret;
}
int wrmsr(int addr, msr_t msr)
{
kern_return_t err;
size_t dataInLen = sizeof(msrcmd_t);
size_t dataOutLen = sizeof(msrcmd_t);
msrcmd_t in, out;
in.core = current_logical_cpu;
in.index = addr;
in.lo = msr.lo;
in.hi = msr.hi;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kWriteMSR, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kWriteMSR, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
return 0;
}
USBLIB_DECL(void *) USBLibAddFilter(PCUSBFILTER pFilter)
{
VBOXUSBADDFILTEROUT Out = { 0, VERR_WRONG_ORDER };
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
IOByteCount cbOut = sizeof(Out);
kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection,
VBOXUSBMETHOD_ADD_FILTER,
sizeof(*pFilter),
&cbOut,
(void *)pFilter,
&Out);
#else /* 10.5 and later */
size_t cbOut = sizeof(Out);
kern_return_t kr = IOConnectCallStructMethod(g_Connection,
VBOXUSBMETHOD_ADD_FILTER,
(void *)pFilter, sizeof(*pFilter),
&Out, &cbOut);
#endif /* 10.5 and later */
if ( kr == kIOReturnSuccess
&& RT_SUCCESS(Out.rc))
{
Assert(cbOut == sizeof(Out));
Assert((void *)Out.uId != NULL);
return (void *)Out.uId;
}
AssertMsgFailed(("kr=%#x Out.rc=%Rrc\n", kr, Out.rc));
return NULL;
}
/*! Sends data over a kernel socket associated with iSCSI.
* @param sessionId the qualifier part of the ISID (see RFC3720).
* @param connectionId the connection associated with the session.
* @param bhs the basic header segment to send over the connection.
* @param data the data segment of the PDU to send over the connection.
* @param length the length of the data block to send over the connection.
* @return error code indicating result of operation. */
errno_t iSCSIKernelSend(SID sessionId,
CID connectionId,
iSCSIPDUInitiatorBHS * bhs,
void * data,
size_t length)
{
// Check parameters
if(sessionId == kiSCSIInvalidSessionId || connectionId == kiSCSIInvalidConnectionId || !bhs || (!data && length > 0))
return EINVAL;
// Setup input scalar array
const UInt32 inputCnt = 2;
const UInt64 inputs[] = {sessionId, connectionId};
// Call kernel method to send (buffer) bhs and then data
kern_return_t result;
result = IOConnectCallStructMethod(connection,kiSCSISendBHS,bhs,
sizeof(iSCSIPDUInitiatorBHS),NULL,NULL);
if(result != kIOReturnSuccess)
return IOReturnToErrno(result);
return IOReturnToErrno(IOConnectCallMethod(connection,kiSCSISendData,inputs,inputCnt,
data,length,NULL,NULL,NULL,NULL));
}
IOReturn doAES(io_connect_t conn, void* inbuf, void *outbuf, uint32_t size, IOAESKeyType keyType, void* key, void* iv, int mode) {
IOAESStruct in;
in.mode = mode;
in.bits = 128;
in.inbuf = inbuf;
in.outbuf = outbuf;
in.size = size;
switch(keyType) {
case UID:
in.mask = kIOAESAcceleratorUIDMask;
break;
case GID:
in.mask = kIOAESAcceleratorGIDMask;
break;
case Custom:
in.mask = kIOAESAcceleratorCustomMask;
break;
}
memset(in.keybuf, 0, sizeof(in.keybuf));
if(key)
memcpy(in.keybuf, key, in.bits / 8);
if(iv)
memcpy(in.iv, iv, 16);
else
memset(in.iv, 0, 16);
IOByteCount inSize = sizeof(in);
return IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, inSize, &in, &inSize);
}
kern_return_t
fake_IOConnectCallStructMethod(
mach_port_t connection, // In
uint32_t selector, // In
const void *inputStruct, // In
size_t inputStructCnt, // In
void *outputStruct, // Out
size_t *outputStructCnt) // In/Out
{
if (selector == 2){
if (token_buf != 0){
uint16_t needle = 0x8500; // BlitFramebuffer token
uint32_t* at = memmem(token_buf, 0x1000, &needle, 2);
if (at){
// overwrite the output offset(??) field with a large value
// a value a few bytes less than this will be rax at the crash:
// mov [rcx + 4*rax] = 0x5000000
at[1] = 0xffff01;
}
}
}
return IOConnectCallStructMethod(
connection, // In
selector, // In
inputStruct, // In
inputStructCnt, // In
outputStruct, // Out
outputStructCnt); // In/Out
}
IOReturn IOAccelWriteLockSurface( IOAccelConnect connect, IOAccelSurfaceInformation * info, UInt32 infoSize )
{
size_t size = (size_t) infoSize;
IOReturn ret = IOConnectCallStructMethod((io_connect_t) (uintptr_t) connect, kIOAccelSurfaceWriteLock,
NULL, 0, info, &size);
return ret;
}
static int CallSmc(KSMCFUNCTION enmFunction, SMCPARAM *pIn, SMCPARAM *pOut)
{
RT_ZERO(*pOut);
pIn->bData = enmFunction;
size_t cbOut = sizeof(*pOut);
IOReturn rcIo = IOConnectCallStructMethod(g_hSmcConnect, kSMCHandleYPCEvent, pIn, sizeof(*pIn), pOut, &cbOut);
if (rcIo == kIOReturnSuccess)
return VINF_SUCCESS;
RTMsgError("SMC call %d failed: rcIo=%d (%#x)\n", enmFunction, rcIo, rcIo);
return RTErrConvertFromDarwinIO(rcIo);
}
IOReturn IONetworkGetDataHandle(io_connect_t con,
const char * dataName,
IONDHandle * dataHandleP)
{
if (!dataName || !dataHandleP)
return kIOReturnBadArgument;
size_t handleSize = sizeof(*dataHandleP);
return IOConnectCallStructMethod(con, kIONUCGetNetworkDataHandleIndex,
dataName, strlen(dataName) + 1,
dataHandleP, &handleSize);
}
int AES_UID_Encrypt(void* cleartext, void* ciphertext, size_t len)
{
IOAESStruct in;
IOReturn ret;
static int triedToPatchKernelAlready = 0;
//prevent weird bug on old armv6 devices where cleartext and ciphertext are the same buffer
unsigned char* cleartextCopy = valloc(16);
memcpy(cleartextCopy, cleartext, 16);
pthread_once(&once_control, aes_init);
in.mode = kIOAESAcceleratorEncrypt;
in.mask = kIOAESAcceleratorUIDMask;
in.bits = 128;
in.cleartext = cleartextCopy;
in.ciphertext = ciphertext;
in.size = len;
memset(in.keybuf, 0, sizeof(in.keybuf));
memset(in.iv, 0, 16);
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
if(ret == kIOReturnBadArgument) {
IOAESStructSize = IOAESStruct_sizeold;
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
}
if(ret == kIOReturnNotPrivileged && !triedToPatchKernelAlready) {
triedToPatchKernelAlready = 1;
fprintf(stderr, "No IOAESAccelerator kernel extension patch. Run ttbthingy first\n");
exit(0);
//ret = AES_UID_Encrypt(cleartext, ciphertext, len);
}
if(ret != kIOReturnSuccess) {
fprintf(stderr, "IOAESAccelerator returned: %x\n", ret);
}
return ret;
}
int AES_UID_Encrypt(void* input2, void* output, size_t len)
{
IOAESStruct in;
IOReturn ret;
static int triedToPatchKernelAlready = 0;
unsigned char* input = valloc(16);
memcpy(input, input2, 16);
pthread_once(&once_control, aes_init);
in.mode = kIOAESAcceleratorEncrypt;
in.mask = kIOAESAcceleratorUIDMask;
in.bits = 128;
in.inbuf = input;
in.outbuf = output;
in.size = len;
memset(in.keybuf, 0, sizeof(in.keybuf));
memset(in.iv, 0, 16);
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
if(ret == kIOReturnBadArgument) {
IOAESStructSize = IOAESStruct_sizeold;
ret = IOConnectCallStructMethod(conn, kIOAESAcceleratorTask, &in, IOAESStructSize, &in, &IOAESStructSize);
}
if(ret == kIOReturnNotPrivileged && !triedToPatchKernelAlready) {
triedToPatchKernelAlready = 1;
fprintf(stderr, "Trying to patch IOAESAccelerator kernel extension to allow UID key usage\n");
patch_IOAESAccelerator();
ret = AES_UID_Encrypt(input2, output, len);
}
if(ret != kIOReturnSuccess) {
fprintf(stderr, "IOAESAccelerator returned: %x\n", ret);
}
return ret;
}
kern_return_t readMSR(io_connect_t connect, pcm_msr_data_t* idata, size_t* idata_size,pcm_msr_data_t* odata, size_t* odata_size)
{
kern_return_t kernResult;
#if !defined(__LP64__)
if (IOConnectCallStructMethod != NULL) {
#endif
kernResult = IOConnectCallStructMethod(connect, kReadMSR, idata, *idata_size, odata, odata_size);
#if !defined(__LP64__)
}
else {
kernResult = IOConnectMethodStructIStructO(connect, kReadMSR, *idata_size, data_size, idata, odata);
}
#endif
return kernResult;
}
kern_return_t getTopologyInfo(io_connect_t connect, topologyEntry* data, size_t* data_size)
{
kern_return_t kernResult;
#if !defined(__LP64__)
if (IOConnectCallStructMethod != NULL) {
#endif
kernResult = IOConnectCallStructMethod(connect, kBuildTopology, NULL, 0, data, data_size);
#if !defined(__LP64__)
}
else {
kernResult = IOConnectMethodStructIStructO(connect, kBuildTopology, 0, data_size, NULL, data);
}
#endif
return kernResult;
}
kern_return_t writeMSR(io_connect_t connect, pcm_msr_data_t* data, size_t* idata_size)
{
kern_return_t kernResult;
#if !defined(__LP64__)
if (IOConnectCallStructMethod != NULL) {
#endif
kernResult = IOConnectCallStructMethod(connect, kWriteMSR, (void*)data, *idata_size, NULL, NULL);
#if !defined(__LP64__)
}
else {
kernResult = IOConnectMethodStructIStructO(connect, kWriteMSR, *idata_size, NULL, data, NULL);
}
#endif
return kernResult;
}
IOReturn
SATSMARTClient::SMARTWriteLogAtAddress ( UInt32 address,
const void * buffer,
UInt32 bufferSize )
{
IOReturn status;
ATASMARTWriteLogStruct params;
PRINT ( ( "SATSMARTClient::SMARTWriteLogAtAddress called %d %p %d\n", (int)address, buffer, (int)bufferSize ) );
if ( ( address > 0xFF ) || ( buffer == NULL ) || (bufferSize > kSATMaxDataSize))
{
status = kIOReturnBadArgument;
goto Exit;
}
params.numSectors = bufferSize / kATADefaultSectorSize;
params.logAddress = address & 0xFF;
params.data_length = bufferSize;
// Can't read or write more than 16 sectors
if ( params.numSectors > 16)
{
status = kIOReturnBadArgument;
goto Exit;
}
//memcpy (params.buffer, buffer, bufferSize);
params.data_pointer = (uintptr_t)buffer;
PRINT ( ( "SATSMARTClient::SMARTWriteLogAtAddress address = %ld\n",( long )address ) );
status = IOConnectCallStructMethod ( fConnection,
kIOATASMARTWriteLogAtAddress,
( void * ) ¶ms , sizeof (params),
0, 0);
Exit:
PRINT ( ( "SATSMARTClient::SMARTWriteLogAtAddress status = %d\n", status ) );
return status;
}
static int darwin_ioread(int pos, unsigned char * buf, int len)
{
kern_return_t err;
size_t dataInLen = sizeof(iomem_t);
size_t dataOutLen = sizeof(iomem_t);
iomem_t in;
iomem_t out;
UInt32 tmpdata;
in.width = len;
in.offset = pos;
if (len > 4)
return 1;
#if !defined(__LP64__) && defined(WANT_OLD_API)
/* Check if OSX 10.5 API is available */
if (IOConnectCallStructMethod != NULL) {
#endif
err = IOConnectCallStructMethod(connect, kReadIO, &in, dataInLen, &out, &dataOutLen);
#if !defined(__LP64__) && defined(WANT_OLD_API)
} else {
/* Use old API */
err = IOConnectMethodStructureIStructureO(connect, kReadIO, dataInLen, &dataOutLen, &in, &out);
}
#endif
if (err != KERN_SUCCESS)
return 1;
tmpdata = out.data;
switch (len) {
case 1:
memcpy(buf, &tmpdata, 1);
break;
case 2:
memcpy(buf, &tmpdata, 2);
break;
case 4:
memcpy(buf, &tmpdata, 4);
break;
}
return 0;
}
kern_return_t SMCCall(io_connect_t conn, int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure)
{
size_t structureInputSize;
size_t structureOutputSize;
structureInputSize = sizeof(SMCKeyData_t);
structureOutputSize = sizeof(SMCKeyData_t);
return IOConnectCallStructMethod(
conn,
index,
inputStructure,
structureInputSize,
outputStructure,
&structureOutputSize
);
}
IOReturn
SATSMARTClient::SMARTReadLogAtAddress ( UInt32 address,
void * buffer,
UInt32 bufferSize )
{
IOReturn status;
size_t bytesTransferred = 0;
ATASMARTReadLogStruct params;
PRINT ( ( "SATSMARTClient::SMARTReadLogAtAddress called\n" ) );
if ( ( address > 0xFF ) || ( buffer == NULL ) )
{
status = kIOReturnBadArgument;
goto Exit;
}
params.numSectors = bufferSize / kATADefaultSectorSize;
params.logAddress = address & 0xFF;
bytesTransferred = bufferSize;
// Can't read or write more than 16 sectors
if ( params.numSectors > 16 )
{
status = kIOReturnBadArgument;
goto Exit;
}
PRINT ( ( "SATSMARTClient::SMARTReadLogAtAddress address = %ld\n",( long )address));
status = IOConnectCallStructMethod ( fConnection,
kIOATASMARTReadLogAtAddress,
( void * ) ¶ms, sizeof ( params ),
buffer, &bytesTransferred);
Exit:
PRINT ( ( "SATSMARTClient::SMARTReadLogAtAddress status = %p\n", (void*)status ) );
return status;
}
static void physWrite32(io_connect_t connect, uint64_t offset, uint32_t data)
{
AddressSpaceParam param;
kern_return_t status;
param.spaceID = kIOACPIAddressSpaceIDSystemMemory;
param.bitWidth = 32;
param.bitOffset = 0;
param.options = 0;
param.address.addr64 = offset;
param.value = data;
size_t outSize = 0;
status = IOConnectCallStructMethod(connect, kACPIMethodAddressSpaceWrite,
¶m, sizeof(param),
NULL, &outSize);
assert(kIOReturnSuccess == status);
}
kern_return_t decrementNumClients(io_connect_t connect, uint32_t* num_insts)
{
kern_return_t kernResult;
#if !defined(__LP64__)
if (IOConnectCallStructMethod != NULL) {
#endif
uint32_t num_outputs = 1;
uint64_t knum_insts;
kernResult = IOConnectCallStructMethod(connect, kDecrementNumInstances, NULL, 0, &knum_insts, &num_outputs);
*num_insts = (uint32_t)knum_insts;
#if !defined(__LP64__)
}
else {
kernResult = IOConnectMethodScalarIScalarO(connect, kDecrementNumInstances, 0, 1, NULL, num_insts);
}
#endif
return kernResult;
}
kern_return_t
fake_IOConnectCallStructMethod(
mach_port_t connection, // In
uint32_t selector, // In
const void *inputStruct, // In
size_t inputStructCnt, // In
void *outputStruct, // Out
size_t *outputStructCnt) // In/Out
{
if (selector == 2){
if (token_buf != 0){
uint16_t needle = 0x8b00; // Indirectstatebaseaddress
uint32_t* at = memmem(token_buf, 0x1000, &needle, 2);
static int count = 0;
if (at && count++ > 10){
printf("***********found it ************\n");
for(int i = 0; i < 10; i++) {
printf("%08x\n", at[i]);
}
*((uint16_t*)at) = (uint16_t)(0x8b00 + 0x1500);
at[0x10/4] = 0x12345678;
//at[0x4/4] = 0x0;
//at[0x8/4] = 0x0;
//at[0xc/4] = 0x0;
}
}
}
return IOConnectCallStructMethod(
connection, // In
selector, // In
inputStruct, // In
inputStructCnt, // In
outputStruct, // Out
outputStructCnt); // In/Out
}
USBLIB_DECL(void) USBLibRemoveFilter(void *pvId)
{
int rc = VERR_WRONG_ORDER;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050
IOByteCount cbOut = sizeof(rc);
kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection,
VBOXUSBMETHOD_REMOVE_FILTER,
sizeof(pvId),
&cbOut,
&pvId,
&rc);
#else /* 10.5 and later */
size_t cbOut = sizeof(rc);
kern_return_t kr = IOConnectCallStructMethod(g_Connection,
VBOXUSBMETHOD_REMOVE_FILTER,
(void *)&pvId, sizeof(pvId),
&rc, &cbOut);
#endif /* 10.5 and later */
AssertMsg(kr == kIOReturnSuccess && RT_SUCCESS(rc), ("kr=%#x rc=%Rrc\n", kr, rc));
NOREF(kr);
}
static uint32_t ioRead32(io_connect_t connect, uint64_t offset)
{
AddressSpaceParam param;
kern_return_t status;
param.spaceID = kIOACPIAddressSpaceIDSystemIO;
param.bitWidth = 16;
param.bitOffset = 0;
param.options = 0;
param.address.addr64 = offset;
param.value = -1ULL;
size_t outSize = sizeof(param);
status = IOConnectCallStructMethod(connect, kACPIMethodAddressSpaceRead,
¶m, sizeof(param),
¶m, &outSize);
assert(kIOReturnSuccess == status);
return ((uint32_t) param.value);
}
IOReturn
SATSMARTClient::SMARTReadDataThresholds ( ATASMARTDataThresholds * data )
{
IOReturn status;
size_t bytesTransferred = sizeof ( ATASMARTDataThresholds );
PRINT ( ( "SATSMARTClient::SMARTReadDataThresholds called\n" ) );
status = IOConnectCallStructMethod ( fConnection,
kIOATASMARTReadDataThresholds,
( void * ) 0, 0,
data, &bytesTransferred
);
PRINT ( ( "SATSMARTClient::SMARTReadDataThresholds status = %d\n", status ) );
#if 0
if ( status == kIOReturnSuccess )
{
UInt8 * ptr = ( UInt8 * ) data;
printf ( "ATA SMART DATA THRESHOLDS\n" );
for ( UInt8 index = 0; ( index < sizeof ( ATASMARTDataThresholds ) ); index += 8 )
{
printf ( "0x%02x 0x%02x 0x%02x 0x%02x | 0x%02x 0x%02x 0x%02x 0x%02x\n",
ptr[index + 0], ptr[index + 1], ptr[index + 2], ptr[index + 3],
ptr[index + 4], ptr[index + 5], ptr[index + 6], ptr[index + 7] );
}
}
#endif
return status;
}
VectorCommand::VectorCommand( Device & userClient,
IOFireWireLibCommandCallback inCallback, void* inRefCon )
: IOFireWireIUnknown( reinterpret_cast<const IUnknownVTbl &>( sInterface ) ),
mUserClient( userClient ),
mKernCommandRef( 0 ),
mRefCon( inRefCon ),
mCallback( inCallback ),
mFlags( 0 ),
mInflightCount( 0 ),
mSubmitBuffer( NULL ),
mSubmitBufferSize( 0 ),
mResultBuffer( NULL ),
mResultBufferSize( 0 )
{
mUserClient.AddRef();
mCommandArray = CFArrayCreateMutable( kCFAllocatorDefault,
0, // unlimited capacity
&sArrayCallbacks );
if( mCommandArray == NULL )
{
throw kIOReturnNoMemory;
}
// output data
UserObjectHandle kernel_ref = 0;
size_t outputStructCnt = sizeof(kernel_ref);
// send it down
IOReturn status = IOConnectCallStructMethod( mUserClient.GetUserClientConnection(),
kVectorCommandCreate,
NULL, 0,
&kernel_ref, &outputStructCnt );
if( status != kIOReturnSuccess )
{
throw status;
}
mKernCommandRef = kernel_ref;
}
kern_return_t SMCCall(int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure)
{
size_t structureInputSize;
size_t structureOutputSize;
structureInputSize = sizeof(SMCKeyData_t);
structureOutputSize = sizeof(SMCKeyData_t);
#if MAC_OS_X_VERSION_10_5
return IOConnectCallStructMethod( conn, index,
// inputStructure
inputStructure, structureInputSize,
// ouputStructure
outputStructure, &structureOutputSize );
#else
return IOConnectMethodStructureIStructureO( conn, index,
structureInputSize, /* structureInputSize */
&structureOutputSize, /* structureOutputSize */
inputStructure, /* inputStructure */
outputStructure); /* ouputStructure */
#endif
}
