IOReturn HoRNDIS::getHardwareAddress(IOEthernetAddress *ea) {
UInt32 i;
void *buf;
unsigned char *bp;
int rlen = -1;
int rv;
buf = IOMalloc(RNDIS_CMD_BUF_SZ);
if (!buf)
return kIOReturnNoMemory;
rv = rndisQuery(buf, OID_802_3_PERMANENT_ADDRESS, 48, (void **) &bp, &rlen);
if (rv < 0) {
LOG(V_ERROR, "getHardwareAddress OID failed?");
IOFree(buf, RNDIS_CMD_BUF_SZ);
return kIOReturnIOError;
}
LOG(V_DEBUG, "MAC Address %02x:%02x:%02x:%02x:%02x:%02x -- rlen %d",
bp[0], bp[1], bp[2], bp[3], bp[4], bp[5],
rlen);
for (i=0; i<6; i++)
ea->bytes[i] = bp[i];
IOFree(buf, RNDIS_CMD_BUF_SZ);
return kIOReturnSuccess;
}
// Queue a read on a controller
bool WirelessGamingReceiver::QueueRead(int index)
{
IOUSBCompletion complete;
IOReturn err;
WGRREAD *data;
data = (WGRREAD*)IOMalloc(sizeof(WGRREAD));
if (data == NULL)
return false;
data->index = index;
data->buffer = IOBufferMemoryDescriptor::inTaskWithOptions(kernel_task, 0, GetMaxPacketSize(connections[index].controllerIn));
if (data->buffer == NULL)
{
IOFree(data, sizeof(WGRREAD));
return false;
}
complete.target = this;
complete.action = _ReadComplete;
complete.parameter = data;
err = connections[index].controllerIn->Read(data->buffer, 0, 0, data->buffer->getLength(), &complete);
if (err == kIOReturnSuccess)
return true;
data->buffer->release();
IOFree(data, sizeof(WGRREAD));
// IOLog("read - failed to start (0x%.8x)\n", err);
return false;
}
bool HoRNDIS::rndisSetPacketFilter(uint32_t filter) {
union {
unsigned char *buf;
struct rndis_msg_hdr *hdr;
struct rndis_set *set;
struct rndis_set_c *set_c;
} u;
int rc;
u.buf = (unsigned char *)IOMalloc(RNDIS_CMD_BUF_SZ);
if (!u.buf) {
LOG(V_ERROR, "out of memory?");
return false;;
}
memset(u.buf, 0, sizeof *u.set);
u.set->msg_type = RNDIS_MSG_SET;
u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
u.set->len = cpu_to_le32(4);
u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
*(uint32_t *)(u.buf + sizeof *u.set) = filter;
rc = rndisCommand(u.hdr, RNDIS_CMD_BUF_SZ);
if (rc != kIOReturnSuccess) {
LOG(V_ERROR, "SET not successful?");
IOFree(u.buf, RNDIS_CMD_BUF_SZ);
return false;
}
IOFree(u.buf, RNDIS_CMD_BUF_SZ);
return true;
}
void VoodooI2CHIDDevice::stop(IOService* device) {
IOLog("I2C HID Device is stopping\n");
destroy_wrapper();
if (hid_device->timerSource){
hid_device->timerSource->cancelTimeout();
hid_device->timerSource->release();
hid_device->timerSource = NULL;
}
//hid_device->workLoop->removeEventSource(hid_device->interruptSource);
//hid_device->interruptSource->disable();
hid_device->interruptSource = NULL;
hid_device->workLoop->release();
hid_device->workLoop = NULL;
i2c_hid_free_buffers(ihid, HID_MIN_BUFFER_SIZE);
IOFree(ihid, sizeof(i2c_hid));
IOFree(hid_device, sizeof(I2CDevice));
//hid_device->provider->close(this);
}
void VoodooI2CHIDDevice::i2c_hid_free_buffers(i2c_hid *ihid, UInt report_size) {
IOFree(ihid->inbuf, report_size);
IOFree(ihid->argsbuf, report_size);
IOFree(ihid->cmdbuf, sizeof(UInt8) + sizeof(UInt16) + sizeof(UInt16) + report_size);
ihid->inbuf = NULL;
ihid->cmdbuf = NULL;
ihid->argsbuf = NULL;
ihid->bufsize = 0;
}
void SuperIOSensor::free()
{
if (name)
IOFree(name, 5);
if (type)
IOFree(type, 5);
OSObject::free();
}
void vm_delete(VM* vm) {
if (vm->cpus) {
for (int i = 0; i < vm->num_cpus; i++) {
if (vm->cpus[i])
cpu_delete(vm->cpus[i]);
}
IOFree(vm->cpus, sizeof(CPU*) * vm->num_cpus);
}
IOFree(vm, sizeof(VM));
LOG("destroyed VM");
}
void FakeSMCKey::free()
{
if (key)
IOFree(key, 5);
if (type)
IOFree(type, 5);
if (value)
IOFree(value, size);
super::free();
}
void eqMac2DriverEngine::free()
{
//IOLog("eqMac2DriverEngine[%p]::free()\n", this);
if (mBuffer) {
IOFree(mBuffer, mBufferSize);
mBuffer = NULL;
}
if (mThruBuffer) {
IOFree(mThruBuffer, mBufferSize);
mThruBuffer = NULL;
}
super::free();
}
void BluetoothClusterEngine::free()
{
//IOLog("BluetoothClusterEngine[%p]::free()\n", this);
if (mBuffer) {
IOFree(mBuffer, mBufferSize);
mBuffer = NULL;
}
if (mThruBuffer) {
IOFree(mThruBuffer, mBufferSize);
mThruBuffer = NULL;
}
super::free();
}
void SoundflowerEngine::free()
{
//IOLog("SoundflowerEngine[%p]::free()\n", this);
if (mBuffer) {
IOFree(mBuffer, mBufferSize);
mBuffer = NULL;
}
if (mThruBuffer) {
IOFree(mThruBuffer, mBufferSize);
mThruBuffer = NULL;
}
super::free();
}
void protoss_unload() {
protoss_stop();
if(trace_start) {
IOLog("trace_ptr was %d\n", trace_ptr - trace_start);
IOFree(trace_start);
trace_start = NULL;
trace_ptr = NULL;
}
if(watch_start) {
//IOLog("watch_ptr was %d\n", watch_ptr - watch_start);
IOFree(watch_start);
watch_start = NULL;
watch_ptr = NULL;
}
}
void REACConnection::deinit() {
stop();
if (NULL != dataStream) {
dataStream->release();
dataStream = NULL;
}
if (NULL != deviceInfo) {
IOFree(deviceInfo, sizeof(REACDeviceInfo));
}
if (NULL != filterCommandGate) {
workLoop->removeEventSource(filterCommandGate);
filterCommandGate->release();
filterCommandGate = NULL;
}
if (NULL != workLoop) {
workLoop->release();
}
if (NULL != timerEventSource) {
timerEventSource->cancelTimeout();
workLoop->removeEventSource(timerEventSource);
timerEventSource->release();
timerEventSource = NULL;
}
if (NULL != interface) {
ifnet_release(interface);
interface = NULL;
}
}
bool GeforceSensors::shadowBios()
{
struct nouveau_device *device = &card;
//try to load bios from registry first from "vbios" property created by Chameleon boolloader
if (OSData *vbios = OSDynamicCast(OSData, pciDevice->getProperty("vbios"))) {
device->bios.size = vbios->getLength();
device->bios.data = (u8*)IOMalloc(card.bios.size);
memcpy(device->bios.data, vbios->getBytesNoCopy(), device->bios.size);
}
if (!device->bios.data || !device->bios.size || nouveau_bios_score(device, true) < 1) {
if (nouveau_bios_shadow(device)) {
//nv_info(device, "early shadow VBIOS succeeded\n");
}
else {
if (device->bios.data && device->bios.size) {
IOFree(card.bios.data, card.bios.size);
device->bios.data = NULL;
device->bios.size = 0;
}
return false;
}
}
return true;
}
bool
IOSCSITape::GrowDeviceMinorNumberMemory(void)
{
IOSCSITape **newDevices;
int cur_size = sizeof(IOSCSITape *) * deviceCount;
int new_size = sizeof(IOSCSITape *) * (deviceCount + GROW_FACTOR);
newDevices = (IOSCSITape **)IOMalloc(new_size);
if (!newDevices)
return false;
bzero(newDevices, new_size);
if (deviceCount)
{
memcpy(newDevices, devices, cur_size);
IOFree(devices, cur_size);
}
devices = newDevices;
deviceCount += GROW_FACTOR;
return true;
}
int32_t CLASS::CleanupControlEndpoint(uint8_t slot, bool justDisable)
{
TRBStruct localTrb = { 0U };
SlotStruct* pSlot;
ringStruct* pRing;
if (justDisable)
goto do_disable;
pSlot = SlotPtr(slot);
pRing = pSlot->ringArrayForEndpoint[1];
if (pRing) {
DeallocRing(pRing);
IOFree(pRing, sizeof *pRing);
pSlot->ringArrayForEndpoint[1] = 0;
}
if (pSlot->md) {
pSlot->md->complete();
pSlot->md->release();
pSlot->md = 0;
pSlot->ctx = 0;
pSlot->physAddr = 0U;
}
_addressMapper.Slot[0] = 0U;
_addressMapper.Active[0] = false;
do_disable:
localTrb.d = XHCI_TRB_3_SLOT_SET(static_cast<uint32_t>(slot));
return WaitForCMD(&localTrb, XHCI_TRB_TYPE_DISABLE_SLOT, 0);
}
//==============================================================================
// IOHIDEvent::initWithCapacity
//==============================================================================
bool IOHIDEvent::initWithCapacity(IOByteCount capacity)
{
if (!super::init())
return false;
if (_data && (!capacity || _capacity < capacity) ) {
// clean out old data's storage if it isn't big enough
IOFree(_data, _capacity);
_data = 0;
}
_capacity = capacity;
if ( !_capacity )
return false;
if ( !_data && !(_data = (IOHIDEventData *) IOMalloc(_capacity)))
return false;
bzero(_data, _capacity);
_data->size = _capacity;
_children = NULL;
clock_get_uptime(&_creationTimeStamp);
return true;
}
bool FakeSMCKey::setValueFromBuffer(const void *aBuffer, UInt8 aSize)
{
if (!aBuffer || aSize == 0)
return false;
if (aSize != size) {
if (value)
IOFree(value, size);
size = aSize;
if (!(value = IOMalloc(size)))
return false;
}
bcopy(aBuffer, value, size);
if (handler) {
IOReturn result = handler->callPlatformFunction(kFakeSMCSetValueCallback, false, (void *)key, (void *)value, (void *)size, 0);
if (kIOReturnSuccess != result)
HWSensorsWarningLog("value changed event callback error for key %s, return 0x%x", key, result);
}
return true;
}
bool VoodooI2CHIDDevice::probe(IOService* device) {
hid_device = (I2CDevice *)IOMalloc(sizeof(I2CDevice));
//hid_device->_dev = _controller->_dev;
if (!super::start(device))
return false;
hid_device->provider = OSDynamicCast(IOACPIPlatformDevice, device);
hid_device->provider->retain();
int ret = i2c_get_slave_address(hid_device);
if (ret < 0){
IOLog("%s::%s::Failed to get a slave address for an I2C device, aborting.\n", getName(), _controller->_dev->name);
IOFree(hid_device, sizeof(I2CDevice));
return false;
}
IOLog("%s::%s::HID Probe called for i2c 0x%02x\n", getName(), _controller->_dev->name, hid_device->addr);
initHIDDevice(hid_device);
//super::stop(device);
return 0;
}
void IOHIKeyboard::free()
// Description: Go Away. Be careful when freeing the lock.
{
IOLock * lock = NULL;
if ( _deviceLock )
{
lock = _deviceLock;
IOLockLock( lock);
_deviceLock = NULL;
}
if ( _keyMap ) {
_keyMap->release();
}
if( _keyState )
IOFree( _keyState, _keyStateSize);
// RY: MENTAL NOTE Do this last
if ( lock )
{
IOLockUnlock( lock);
IOLockFree( lock);
}
super::free();
}
bool
ZFSDatasetProxy::init(OSDictionary *properties)
{
char *str = (char *)IOMalloc(1);
if (!str) {
dprintf("string allocation failed\n");
return (false);
}
str[0] = '\0';
vendorString = str;
revisionString = str;
infoString = str;
if (IOBlockStorageDevice::init(properties) == false) {
dprintf("BlockStorageDevice start failed");
goto error;
}
return (true);
error:
if (str) {
vendorString = 0;
revisionString = 0;
infoString = 0;
IOFree(str, 1);
}
return (false);
}
void DldAclWithProcsObject::free()
{
if( this->acl )
IOFree( this->acl, DldAclWithProcsSize( this->acl ) );
super::free();
}
// Handle a completed read on a controller
void WirelessGamingReceiver::ReadComplete(void *parameter, IOReturn status, UInt32 bufferSizeRemaining)
{
WGRREAD *data = (WGRREAD*)parameter;
bool reread = true;
switch (status)
{
case kIOReturnOverrun:
// IOLog("read - kIOReturnOverrun, clearing stall\n");
connections[data->index].controllerIn->ClearStall();
// fall through
case kIOReturnSuccess:
ProcessMessage(data->index, (unsigned char*)data->buffer->getBytesNoCopy(), data->buffer->getLength() - bufferSizeRemaining);
break;
case kIOReturnNotResponding:
// IOLog("read - kIOReturnNotResponding\n");
// fall through
default:
reread = false;
break;
}
int newIndex = data->index;
data->buffer->release();
IOFree(data, sizeof(WGRREAD));
if (reread)
QueueRead(newIndex);
}
bool FileNVRAM::setProperty(const OSSymbol *aKey, OSObject *anObject)
{
// Verify permissions.
if (IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator) != kIOReturnSuccess)
{
// Not priveleged!
return false;
}
// Check for SIP configuration variables.
if ((strncmp("csr-data", aKey->getCStringNoCopy(), 8) == 0) || (strncmp("csr-active-config", aKey->getCStringNoCopy(), 17) == 0))
{
// We have a match so first verify the entitlements.
if (IOUserClient::copyClientEntitlement(current_task(), "com.apple.private.iokit.nvram-csr") == NULL)
{
LOG(INFO, "setProperty(%s, (%s) %p) failed (not entitled)\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), anObject);
// Not entitled!
return false;
}
}
OSSerialize *s = OSSerialize::withCapacity(1000);
if (anObject->serialize(s))
{
LOG(INFO, "setProperty(%s, (%s) %s) called\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), s->text());
}
else
{
LOG(INFO, "setProperty(%s, (%s) %p) called\n", aKey->getCStringNoCopy(), anObject->getMetaClass()->getClassName(), anObject);
}
s->release();
// Check for special FileNVRAM properties:
if (strncmp(FILE_NVRAM_GUID ":", aKey->getCStringNoCopy(), MIN(aKey->getLength(), strlen(FILE_NVRAM_GUID ":"))) == 0)
{
unsigned long bytes = aKey->getLength() - strlen(FILE_NVRAM_GUID ":") + 1;
// Found GUID
char* newKey = (char*)IOMalloc(bytes);
snprintf(newKey, bytes+1, "%s", &(aKey->getCStringNoCopy()[strlen(FILE_NVRAM_GUID ":")]));
// Send d
OSString* str = OSString::withCString(newKey);
handleSetting(str, anObject, this);
str->release();
IOFree(newKey, bytes);
}
bool stat = IOService::setProperty(aKey, cast(aKey, anObject));
if (mInitComplete)
{
sync();
}
return stat;
}
void
IOI2CDevice::free ( void )
{
DLOG("IOI2CDevice@%lx::free\n",fI2CAddress);
freeI2CResources();
if (reserved) { IOFree(reserved, sizeof(struct ExpansionData)); reserved = 0; }
super::free();
}
void XHCIAsyncEndpoint::nuke(void)
{
wipeAsyncList(queuedHead, queuedTail);
wipeAsyncList(scheduledHead, scheduledTail);
wipeAsyncList(doneHead, doneTail);
wipeAsyncList(freeHead, freeTail);
IOFree(this, sizeof *this);
}
void IOFWPseudoAddressSpaceAux::destroyMemberVariables( void )
{
if( fMembers != NULL )
{
IOFree( fMembers, sizeof(MemberVariables) );
fMembers = NULL;
}
}
void IOFWCompareAndSwapCommand::destroyMemberVariables( void )
{
if( fMembers != NULL )
{
IOFree( fMembers, sizeof(MemberVariables) );
fMembers = NULL;
}
}
IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource)
{
int cnt, interruptType;
IOReturn error;
if (!super::init())
return kIOReturnNoResources;
// Set provider to this so enable/disable nub stuff works.
provider = this;
// Allocate the IOInterruptSource so this can act like a nub.
_interruptSources = (IOInterruptSource *)IOMalloc(sizeof(IOInterruptSource));
if (_interruptSources == 0) return kIOReturnNoMemory;
_numInterruptSources = 1;
// Set up the IOInterruptSource to point at this.
_interruptSources[0].interruptController = parentController;
_interruptSources[0].vectorData = parentSource;
sourceIsLevel = false;
error = provider->getInterruptType(0, &interruptType);
if (error == kIOReturnSuccess) {
if (interruptType & kIOInterruptTypeLevel)
sourceIsLevel = true;
}
// Allocate the memory for the vectors
numVectors = 32; // For now a constant number.
vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector));
if (vectors == NULL) {
IOFree(_interruptSources, sizeof(IOInterruptSource));
return kIOReturnNoMemory;
}
bzero(vectors, numVectors * sizeof(IOInterruptVector));
// Allocate the lock for the controller.
controllerLock = IOSimpleLockAlloc();
if (controllerLock == 0) return kIOReturnNoResources;
// Allocate locks for the vectors.
for (cnt = 0; cnt < numVectors; cnt++) {
vectors[cnt].interruptLock = IOLockAlloc();
if (vectors[cnt].interruptLock == NULL) {
for (cnt = 0; cnt < numVectors; cnt++) {
if (vectors[cnt].interruptLock != NULL)
IOLockFree(vectors[cnt].interruptLock);
}
return kIOReturnNoResources;
}
}
vectorsRegistered = 0;
vectorsEnabled = 0;
controllerDisabled = 1;
return kIOReturnSuccess;
}
void kXAudioDevice::free_func(void *buff)
{
int *mem=(int *)buff;
if(mem)
{
mem--;
IOFree(mem,*mem);
}
}
