NTSTATUS tdi_recv_stream(PFILE_OBJECT connectionFileObject, char *buf, int len, ULONG flags)
{
PDEVICE_OBJECT devObj;
KEVENT event;
PIRP irp;
PMDL mdl;
IO_STATUS_BLOCK iosb;
NTSTATUS status;
devObj = IoGetRelatedDeviceObject(connectionFileObject);
KeInitializeEvent(&event, NotificationEvent, FALSE);
irp = TdiBuildInternalDeviceControlIrp(TDI_RECEIVE, devObj, connectionFileObject, &event, &iosb);
if (irp == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
if (len)
{
mdl = IoAllocateMdl((void*) buf, len, FALSE, FALSE, NULL);
if (mdl == NULL)
{
IoFreeIrp(irp);
return STATUS_INSUFFICIENT_RESOURCES;
}
__try
{
MmProbeAndLockPages(mdl, KernelMode, IoWriteAccess);
status = STATUS_SUCCESS;
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
IoFreeMdl(mdl);
IoFreeIrp(irp);
status = STATUS_INVALID_USER_BUFFER;
}
if (!NT_SUCCESS(status))
{
return status;
}
}
TdiBuildReceive(irp, devObj, connectionFileObject, NULL, NULL, len ? mdl : 0, flags, len);
status = IoCallDriver(devObj, irp);
if (status == STATUS_PENDING)
{
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = iosb.Status;
}
return NT_SUCCESS(status) ? iosb.Information : status;
}
/*
* DestroyTransferPacket
*
*/
VOID DestroyTransferPacket(PTRANSFER_PACKET Pkt)
{
PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
KIRQL oldIrql;
ASSERT(!Pkt->SlistEntry.Next);
// ASSERT(!Pkt->OriginalIrp);
KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
/*
* Delete the packet from our all-packets queue.
*/
ASSERT(!IsListEmpty(&Pkt->AllPktsListEntry));
ASSERT(!IsListEmpty(&fdoData->AllTransferPacketsList));
RemoveEntryList(&Pkt->AllPktsListEntry);
InitializeListHead(&Pkt->AllPktsListEntry);
KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
IoFreeMdl(Pkt->PartialMdl);
IoFreeIrp(Pkt->Irp);
FREE_POOL(Pkt->RetryHistory);
FREE_POOL(Pkt);
}
VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDeviceSpeed(PDEVICE_OBJECT pDevObj, BOOLEAN *pbIsHigh)
{
Assert(pbIsHigh);
*pbIsHigh = FALSE;
PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE);
Assert(pIrp);
if (!pIrp)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
USB_BUS_INTERFACE_USBDI_V1 BusIf;
PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp);
pSl->MajorFunction = IRP_MJ_PNP;
pSl->MinorFunction = IRP_MN_QUERY_INTERFACE;
pSl->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_USBDI_GUID;
pSl->Parameters.QueryInterface.Size = sizeof (BusIf);
pSl->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_1;
pSl->Parameters.QueryInterface.Interface = (PINTERFACE)&BusIf;
pSl->Parameters.QueryInterface.InterfaceSpecificData = NULL;
pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
NTSTATUS Status = VBoxDrvToolIoPostSync(pDevObj, pIrp);
Assert(NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED);
if (NT_SUCCESS(Status))
{
*pbIsHigh = BusIf.IsDeviceHighSpeed(BusIf.BusContext);
BusIf.InterfaceDereference(BusIf.BusContext);
}
IoFreeIrp(pIrp);
return Status;
}
NTSTATUS
IoCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
UNREFERENCED_PARAMETER(DeviceObject);
UNREFERENCED_PARAMETER(Context);
PAGED_CODE();
KdPrint(("SYS(%d:%d):IoCompletionRoutine!\n", PsGetCurrentProcessId(), PsGetCurrentThreadId()));
*Irp->UserIosb = Irp->IoStatus;
if (Irp->UserEvent)
KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, 0);
if (Irp->MdlAddress)
{
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
}
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
IoCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
//DbgPrint(("IoCompletionRoutine!\n"));
*Irp->UserIosb = Irp->IoStatus;
if (Irp->MdlAddress)
{
//MmUnmapLockedPages( Irp->MdlAddress,
// MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority ) );
MmUnlockPages( Irp->MdlAddress );
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
}
if (Irp->UserEvent)
KeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, 0);
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;
//return STATUS_SUCCESS;
}
NTSTATUS
DeviceArrivalCompletion(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
PHUB_DEVICE_EXTENSION DeviceExtension;
LONG i;
PWORKITEMDATA WorkItemData;
DeviceExtension = (PHUB_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
for (i=0; i < DeviceExtension->UsbExtHubInfo.NumberOfPorts; i++)
DPRINT1("Port %x DeviceExtension->PortStatus %x\n",i+1, DeviceExtension->PortStatus[i]);
IoFreeIrp(Irp);
WorkItemData = ExAllocatePool(NonPagedPool, sizeof(WORKITEMDATA));
if (!WorkItemData)
{
DPRINT1("Failed to allocate memory\n");
return STATUS_NO_MEMORY;
}
RtlZeroMemory(WorkItemData, sizeof(WORKITEMDATA));
WorkItemData->Context = Context;
ExInitializeWorkItem(&WorkItemData->WorkItem, (PWORKER_THREAD_ROUTINE)WorkerThread, (PVOID)WorkItemData);
ExQueueWorkItem(&WorkItemData->WorkItem, DelayedWorkQueue);
return STATUS_MORE_PROCESSING_REQUIRED;
}
void CIrp::DestroyIrp()
{
ASSERT(m_Irp != nullptr);
IoFreeIrp(m_Irp);
m_Irp = nullptr;
}
NTSTATUS SelectiveSuspendCompletionRoutine(PDEVICE_OBJECT pdo, PIRP Irp, UsbDev *pUsbDev)
{
NTSTATUS ntStatus = Irp->IoStatus.Status;
DBGU_TRACE("SelectiveSuspendCompletionRoutine: 0x%08X\n",ntStatus);
//test
/*if (InterlockedExchangePointer((PVOID *)&pUsbDev->m_SuspendIrp, NULL))
{
DBGU_TRACE("IoFreeIrp Suspend IRP at Completion Routine..\n");
IoFreeIrp(Irp);
}*/
InterlockedExchangePointer((PVOID *)&pUsbDev->m_SuspendIrp, NULL);
DBGU_TRACE("IoFreeIrp Suspend IRP at Completion Routine..\n");
IoFreeIrp(Irp);
// fix incorrect power state transition during S0 -> S3 (ymwu, 2005/7/16)
// this irp will be cancelled when system power state is changed to S3
// device power state should not be set to D0 in this situation
// if you make incorrect power state transition, the system sometimes hangs
{
DBGU_TRACE("Cancel Selective Suspend..\n");
pUsbDev->m_SuspendCancelled = 1;
}
KeSetEvent(&pUsbDev->m_SuspendIrpCancelEvent, IO_NO_INCREMENT, FALSE);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
TdiQueryAddress(
PFILE_OBJECT AddressObject,
PTDI_ADDRESS_INFO AddressInfo,
PULONG pInfoLength
)
{
NTSTATUS ntStatus;
PIRP Irp;
PMDL Mdl;
PDEVICE_OBJECT DeviceObject = IoGetRelatedDeviceObject(AddressObject);
IO_STATUS_BLOCK IoStatus;
if (!(Irp = TdiBuildInternalDeviceControlIrp(TDI_QUERY_INFORMATION, DeviceObject, FileObject, NULL, &IoStatus)))
return STATUS_INSUFFICIENT_RESOURCES;
if (!(Mdl = IoAllocateMdl(AddressInfo, *pInfoLength, FALSE, FALSE, Irp)))
{
IoFreeIrp(Irp);
return STATUS_INSUFFICIENT_RESOURCES;
}
MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
TdiBuildQueryInformation(Irp, DeviceObject, AddressObject, NULL, NULL, TDI_QUERY_ADDRESS_INFO, Mdl);
ntStatus = IoCallDriver(DeviceObject, Irp);
return(ntStatus == STATUS_SUCCESS ? IoStatus.Status : ntStatus);
}
NTSTATUS
disconnectfromserver(PWSK_SOCKET sock)
{
NTSTATUS status;
KEVENT event;
PIRP irp;
irp = IoAllocateIrp(1, FALSE);
if(!irp){
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoSetCompletionRoutine(irp, disconnectcomplete, &event, TRUE, TRUE,
TRUE);
status = ((PWSK_PROVIDER_CONNECTION_DISPATCH)(sock->Dispatch))->
WskCloseSocket(sock, irp);
if(status == STATUS_PENDING){
KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = irp->IoStatus.Status;
}
IoFreeIrp(irp);
return status;
}
NTSTATUS
SkillSetFileCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
BOOL bInit = FALSE;
ReLoadNtosCALL(&RKeSetEvent,L"KeSetEvent",SystemKernelModuleBase,ImageModuleBase);
if (RKeSetEvent)
{
bInit = TRUE;
}
if (!bInit)
return STATUS_UNSUCCESSFUL;
Irp->UserIosb->Status = Irp->IoStatus.Status;
Irp->UserIosb->Information = Irp->IoStatus.Information;
RKeSetEvent(Irp->UserEvent, IO_NO_INCREMENT, FALSE);
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
CloseWskEventSocket()
{
if (!netlink_server_socket)
{
return STATUS_SUCCESS;
}
KEVENT CompletionEvent = {0};
PIRP irp = NULL;
NTSTATUS status = InitWskData(&irp, &CompletionEvent);
if (!NT_SUCCESS(status))
{
return status;
}
status = ((PWSK_PROVIDER_BASIC_DISPATCH)netlink_server_socket->Dispatch)->WskCloseSocket(netlink_server_socket, irp);
if (STATUS_PENDING == status)
{
KeWaitForSingleObject(&CompletionEvent, Executive, KernelMode, FALSE, NULL);
status = irp->IoStatus.Status;
}
IoFreeIrp(irp);
WskDeregister(&gWskEventRegistration);
return status;
}
static
NTSTATUS
NTAPI
PopRequestPowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
{
PIO_STACK_LOCATION Stack;
PREQUEST_POWER_COMPLETE CompletionRoutine;
POWER_STATE PowerState;
Stack = IoGetCurrentIrpStackLocation(Irp);
CompletionRoutine = Context;
PowerState.DeviceState = (ULONG_PTR)Stack->Parameters.Others.Argument3;
CompletionRoutine(Stack->Parameters.Others.Argument1,
(UCHAR)(ULONG_PTR)Stack->Parameters.Others.Argument2,
PowerState,
Stack->Parameters.Others.Argument4,
&Irp->IoStatus);
IoSkipCurrentIrpStackLocation(Irp);
IoFreeIrp(Irp);
ObDereferenceObject(DeviceObject);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
Ext2ReadWriteBlockSyncCompletionRoutine (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context )
{
PEXT2_RW_CONTEXT pContext = (PEXT2_RW_CONTEXT)Context;
if (Irp != pContext->MasterIrp) {
if (!NT_SUCCESS(Irp->IoStatus.Status)) {
pContext->MasterIrp->IoStatus = Irp->IoStatus;
}
IoFreeMdl(Irp->MdlAddress);
IoFreeIrp(Irp );
}
if (InterlockedDecrement(&pContext->Blocks) == 0) {
pContext->MasterIrp->IoStatus.Information = 0;
if (NT_SUCCESS(pContext->MasterIrp->IoStatus.Status)) {
pContext->MasterIrp->IoStatus.Information =
pContext->Length;
}
KeSetEvent(&pContext->Event, 0, FALSE);
}
return STATUS_MORE_PROCESSING_REQUIRED;
}
static
NTSTATUS
NTAPI
PopRequestPowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
{
PIO_STACK_LOCATION Stack;
PREQUEST_POWER_ITEM RequestPowerItem;
Stack = IoGetNextIrpStackLocation(Irp);
RequestPowerItem = (PREQUEST_POWER_ITEM)Context;
RequestPowerItem->CompletionRoutine(DeviceObject,
Stack->MinorFunction,
RequestPowerItem->PowerState,
RequestPowerItem->Context,
&Irp->IoStatus);
IoFreeIrp(Irp);
ObDereferenceObject(RequestPowerItem->TopDeviceObject);
ExFreePool(Context);
return STATUS_MORE_PROCESSING_REQUIRED;
}
VOID CancelSelectSuspend(IN PTDeviceExtension DeviceExtension)
{
PIRP irp;
KIRQL oldIrql;
irp = NULL;
BulkUsb_DbgPrint(3, ("file bulkdev: CancelSelectSuspend - begins\n"));
KeAcquireSpinLock(&DeviceExtension->IdleReqStateLock, &oldIrql);
if(!CanDeviceSuspend(DeviceExtension))
{
BulkUsb_DbgPrint(3, ("file bulkdev: Device is not idle\n"));
irp = (PIRP)InterlockedExchangePointer(&DeviceExtension->PendingIdleIrp, NULL);
}
KeReleaseSpinLock(&DeviceExtension->IdleReqStateLock, oldIrql);
if(irp)
{
IoCancelIrp(irp);
if(0 == InterlockedDecrement(&DeviceExtension->FreeIdleIrpCount))
{
BulkUsb_DbgPrint(3, ("file bulkdev: CancelSelectSuspend frees the irp\n"));
IoFreeIrp(irp);
KeSetEvent(&DeviceExtension->NoIdleReqPendEvent, IO_NO_INCREMENT, FALSE);
}
}
BulkUsb_DbgPrint(3, ("file bulkdev: CancelSelectSuspend - ends\n"));
return;
}
NTSTATUS
KTdiStreamSocket::AcceptCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context
)
{
KTdiStreamSocket* _this = (KTdiStreamSocket*) Context;
if (Irp->UserIosb != NULL)
*Irp->UserIosb = Irp->IoStatus;
// if (Irp->MdlAddress != NULL)
// {
// MmUnlockPages(Irp->MdlAddress);
// IoFreeMdl(Irp->MdlAddress);
// }
if (Irp->UserEvent != NULL)
KeSetEvent(Irp->UserEvent, 0, FALSE);
IoFreeIrp(Irp);
if (_this != NULL)
//InterlockedDecrement(&(_this->m_dwTreatAcceptIrpsCount));
--(_this->m_TreatAcceptIrpsCount);
DbgPrint ("AcceptCompletion: %08x!!!\n", Irp->IoStatus.Status);
return STATUS_MORE_PROCESSING_REQUIRED;
}
static NTSTATUS
redirect_irp_completion(PDEVICE_OBJECT dev_obj, PIRP irp, PVOID ctxt)
{
IO_STACK_LOCATION *const isl = IoGetCurrentIrpStackLocation(irp);
struct scsifilt *const sf = get_scsifilt(dev_obj);
SCSI_REQUEST_BLOCK *const new_srb = isl->Parameters.Scsi.Srb;
SCSI_REQUEST_BLOCK *const srb = new_srb->OriginalRequest;
MDL *const mdl = irp->MdlAddress;
void *const buf = new_srb->DataBuffer;
UNREFERENCED_PARAMETER(ctxt);
srb->SrbStatus = new_srb->SrbStatus;
srb->ScsiStatus = new_srb->ScsiStatus;
memcpy(srb->DataBuffer, buf, srb->DataTransferLength);
IoFreeIrp(irp);
IoFreeMdl(mdl);
ExFreePool(buf);
XmFreeMemory(new_srb);
queue_srb_for_completion(sf, srb);
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS
NTAPI
Bind(
__in PWSK_SOCKET WskSocket,
__in PSOCKADDR LocalAddress
)
{
KEVENT CompletionEvent = { 0 };
PIRP Irp = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
if (g_SocketsState != INITIALIZED || !WskSocket || !LocalAddress)
return STATUS_INVALID_PARAMETER;
Status = InitWskData(&Irp, &CompletionEvent);
if (!NT_SUCCESS(Status)) {
return Status;
}
Status = ((PWSK_PROVIDER_CONNECTION_DISPATCH) WskSocket->Dispatch)->WskBind(
WskSocket,
LocalAddress,
0,
Irp);
if (Status == STATUS_PENDING) {
KeWaitForSingleObject(&CompletionEvent, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
IoFreeIrp(Irp);
return Status;
}
VOID
NTAPI
CdRomDeAllocateMmcResources(
IN PDEVICE_OBJECT Fdo
)
{
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
PCDROM_DATA cddata = commonExtension->DriverData;
PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
//NTSTATUS status;
if (mmcData->CapabilitiesWorkItem) {
IoFreeWorkItem(mmcData->CapabilitiesWorkItem);
mmcData->CapabilitiesWorkItem = NULL;
}
if (mmcData->CapabilitiesIrp) {
IoFreeIrp(mmcData->CapabilitiesIrp);
mmcData->CapabilitiesIrp = NULL;
}
if (mmcData->CapabilitiesMdl) {
IoFreeMdl(mmcData->CapabilitiesMdl);
mmcData->CapabilitiesMdl = NULL;
}
if (mmcData->CapabilitiesBuffer) {
ExFreePool(mmcData->CapabilitiesBuffer);
mmcData->CapabilitiesBuffer = NULL;
}
mmcData->CapabilitiesBuffer = 0;
mmcData->IsMmc = FALSE;
mmcData->WriteAllowed = FALSE;
return;
}
FORCEINLINE
FxAutoIrp::~FxAutoIrp()
{
if (m_Irp != NULL) {
IoFreeIrp(m_Irp);
}
}
PWSK_SOCKET
NTAPI
WSKCreateSocket(
IN ADDRESS_FAMILY AddressFamily,
IN USHORT SocketType,
IN ULONG Protocol,
IN ULONG Flags
)
{
KEVENT CompletionEvent = { 0 };
PIRP Irp = NULL;
PWSK_SOCKET WskSocket = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
TRACE_ENTER();
if (g_SocketsState != INITIALIZED)
{
TRACE_EXIT();
return NULL;
}
Status = InitWskData(&Irp, &CompletionEvent);
if (!NT_SUCCESS(Status))
{
TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCreateSocket()::InitWskData() failed with status 0x%08X\n", Status);
TRACE_EXIT();
return NULL;
}
Status = g_WskProvider.Dispatch->WskSocket(
g_WskProvider.Client,
AddressFamily,
SocketType,
Protocol,
Flags,
NULL,
NULL,
NULL,
NULL,
NULL,
Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&CompletionEvent, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
if (!NT_SUCCESS(Status))
{
TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "WSKCreateSocket()::Dispatch::WskSocket() failed with status 0x%08X\n", Status);
}
WskSocket = NT_SUCCESS(Status) ? (PWSK_SOCKET)Irp->IoStatus.Information : NULL;
IoFreeIrp(Irp);
TRACE_EXIT();
return (PWSK_SOCKET)WskSocket;
}
static
FORCEINLINE
VOID
xTdiFreeInternalIrp(
__in PIRP Irp)
{
IoFreeIrp(Irp);
}
FORCEINLINE
VOID
FxIrp::FreeIrp(
VOID
)
{
IoFreeIrp(m_Irp);
}
VOID
FreeWskData(
__in PIRP pIrp
)
{
if (pIrp)
IoFreeIrp(pIrp);
}
static NTSTATUS FspIopPostWorkRequestCompletion(
PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
{
// !PAGED_CODE();
IoFreeIrp(Irp);
return STATUS_MORE_PROCESSING_REQUIRED;
}
BOOLEAN KTdiStreamSocket::Unbind()
{
//KLocker locker(&m_KSynchroObject);
BOOLEAN bRes = TRUE;
PIRP pIrp = NULL, pIrpError = NULL;
PDEVICE_OBJECT pDeviceObject;
NTSTATUS NtStatus;
IO_STATUS_BLOCK IoStatusBlock;
__try
{
if (m_bOpen == TRUE && m_bBind == TRUE && m_bConnected == FALSE && m_bListen == FALSE)
{
bRes = FALSE;
pDeviceObject = IoGetRelatedDeviceObject(m_pTdiConnectionObject);
pIrp = TdiBuildInternalDeviceControlIrp(
TDI_DISASSOCIATE_ADDRESS,
pDeviceObject,
m_pTdiConnectionObject,
NULL,
NULL);
pIrpError = pIrp;
if (pIrp != NULL)
{
TdiBuildDisassociateAddress(
pIrp,
pDeviceObject,
m_pTdiConnectionObject,
NULL,
NULL);
pIrpError = NULL;
NtStatus = TdiCall(pIrp, pDeviceObject, &IoStatusBlock);
if (NT_SUCCESS(NtStatus))
{
m_bBind = FALSE;
bRes = TRUE;
}
else
{
DbgPrint ("TdiUnbind: ERROR (%08x)!!!\n", NtStatus);
}
}
}
}
__finally
{
if (pIrpError != NULL)
IoFreeIrp(pIrpError);
}
return bRes;
}
VOID
LspDataCleanup(
__in PLSP_TRANSFER_DATA LspTransferData)
{
if (LspTransferData->Irp)
{
IoFreeIrp(LspTransferData->Irp);
LspTransferData->Irp = NULL;
}
}
NTSTATUS
FreeDigiIrp( PDEVICE_OBJECT deviceObject, PIRP irp, PVOID context )
{
#ifdef IO_ALLOC_IRP_WORKS
IoFreeIrp( irp );
#else
DigiFreeMem( irp );
#endif
// Prevent further cleanup by I/O Manager.
return STATUS_MORE_PROCESSING_REQUIRED;
}
static
NTSTATUS File_ReadWriteFileComplete(
PDEVICE_OBJECT dev,
PIRP irp,
PVOID context
)
{
*irp->UserIosb = irp->IoStatus;
KeSetEvent(irp->UserEvent, 0, FALSE);
IoFreeIrp(irp);
return STATUS_MORE_PROCESSING_REQUIRED;
}
