|
|
/***************************************************************************
Copyright (c) 2002 Microsoft Corporation
Module Name:
SCUTIL.C
Abstract:
Routines for Smartcard Driver Utility Library
Environment:
Kernel Mode Only
Notes:
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
Copyright (c) 2001 Microsoft Corporation. All Rights Reserved.
Revision History:
05/14/2002 : created
Authors:
Randy Aull
****************************************************************************/
#include "pch.h"
VOIDIncIoCount( PSCUTIL_EXTENSION pExt ){ ULONG count; count = InterlockedIncrement(&pExt->IoCount);
KeClearEvent(&pExt->OkToStop);
}
VOIDDecIoCount( PSCUTIL_EXTENSION pExt ){ ULONG count;
count = InterlockedDecrement(&pExt->IoCount);
if (count == 0) { KeSetEvent(&pExt->OkToStop, 0, FALSE); }
} VOIDStartIoctls( PSCUTIL_EXTENSION pExt ){
LIST_ENTRY head;
InterlockedExchange(&pExt->IoctlQueueState, PASS_IOCTLS);
pExt->RestartIoctls = TRUE; // Now drain the queued list
InitializeListHead(&head); IrpList_Drain(&pExt->PendingIrpQueue, &head); while (!IsListEmpty(&head)) { PLIST_ENTRY ple; PIRP pIrp; ple = RemoveHeadList(&head); pIrp = CONTAINING_RECORD(ple, IRP, Tail.Overlay.ListEntry);
IncIoCount(pExt); SmartcardDeviceControl(pExt->SmartcardExtension, pIrp); DecIoCount(pExt);
IoReleaseRemoveLock(pExt->RemoveLock, pIrp); } }
VOIDStopIoctls( PSCUTIL_EXTENSION pExt ){ InterlockedExchange(&pExt->IoctlQueueState, QUEUE_IOCTLS);
}
VOIDFailIoctls( PSCUTIL_EXTENSION pExt ){
LIST_ENTRY head;
InterlockedExchange(&pExt->IoctlQueueState, FAIL_IOCTLS);
InitializeListHead(&head); IrpList_Drain(&pExt->PendingIrpQueue, &head);
while (!IsListEmpty(&head)) {
PLIST_ENTRY ple; PIRP pIrp;
ple = RemoveHeadList(&head); pIrp = CONTAINING_RECORD(ple, IRP, Tail.Overlay.ListEntry);
IoReleaseRemoveLock(pExt->RemoveLock, pIrp);
pIrp->IoStatus.Information = 0; pIrp->IoStatus.Status = STATUS_DELETE_PENDING; IoCompleteRequest(pIrp, IO_NO_INCREMENT); }
}
QUEUE_STATE GetIoctlQueueState( PSCUTIL_EXTENSION pExt ){
return InterlockedCompareExchange(&pExt->IoctlQueueState, PASS_IOCTLS, INVALID_STATE);
}
NTSTATUSScUtil_SystemControl( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: forwards IRP_MJ_SYSTEM_CONTROL
Arguments:
Return Value:
--*/{ PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); NTSTATUS status = STATUS_SUCCESS;
__try { SmartcardDebug( DEBUG_TRACE, ("ScUtilSystemControl Enter\n"));
IoSkipCurrentIrpStackLocation(Irp); status = IoCallDriver(pExt->LowerDeviceObject, Irp);
}
__finally { SmartcardDebug( DEBUG_TRACE, ("ScUtilSystemControl Exit : 0x%x\n",status ));
}
return status; }
NTSTATUS OnRequestComplete( PDEVICE_OBJECT DeviceObject, PIRP Irp, PKEVENT Event )/*++
Routine Description: Completion routine for UsbScForwardAndWait
Arguments:
Return Value:
--*/{ NTSTATUS status = STATUS_SUCCESS; __try {
SmartcardDebug( DEBUG_TRACE, ("OnRequestComplete Enter\n")); KeSetEvent(Event, 0, FALSE);
status = STATUS_MORE_PROCESSING_REQUIRED;
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("OnRequestComplete Exit : 0x%x\n",status ));
}
return status;
}
NTSTATUSScUtil_ForwardAndWait( PDEVICE_OBJECT DeviceObject, PIRP Irp )/*++
Routine Description: Sends an irp down the stack and waits for its completion.
Arguments:
Return Value:
--*/{ KEVENT event; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); NTSTATUS status = STATUS_UNSUCCESSFUL;
__try {
SmartcardDebug( DEBUG_TRACE, ("ScUtilForwardAndWait Enter\n"));
KeInitializeEvent(&event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp); IoSetCompletionRoutine(Irp, (PIO_COMPLETION_ROUTINE) OnRequestComplete, (PVOID) &event, TRUE, TRUE, TRUE); ASSERT(pExt->LowerDeviceObject); IoCallDriver(pExt->LowerDeviceObject, Irp); KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
status = Irp->IoStatus.Status;
}
__finally {
SmartcardDebug( DEBUG_TRACE, ("ScUtilForwardAndWait Exit : 0x%x\n",status));
}
return status;
}
NTSTATUSScUtil_Cancel( PDEVICE_OBJECT DeviceObject, PIRP Irp ){
PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); NTSTATUS status = STATUS_SUCCESS; KIRQL irql;
__try { SmartcardDebug( DEBUG_TRACE, ("ScUtil_Cancel Enter\n"));
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_CANCELLED;
KeAcquireSpinLock(&pExt->SmartcardExtension->OsData->SpinLock, &irql);
pExt->SmartcardExtension->OsData->NotificationIrp = NULL;
KeReleaseSpinLock(&pExt->SmartcardExtension->OsData->SpinLock, irql);
IoReleaseCancelSpinLock(Irp->CancelIrql);
IoReleaseRemoveLock(pExt->RemoveLock, Irp);
IoCompleteRequest( Irp, IO_NO_INCREMENT);
}
__finally { SmartcardDebug( DEBUG_TRACE, ("ScUtil_Cancel Exit : 0x%x\n",status ));
}
return status;
}
NTSTATUSScUtil_CancelTrackingIrp( PSCUTIL_EXTENSION pExt ){
NTSTATUS status = STATUS_UNSUCCESSFUL; PSMARTCARD_EXTENSION pSmartcardExtension = pExt->SmartcardExtension; PIRP notificationIrp = NULL; KIRQL irql; KIRQL cancelIrql;
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_CancelTrackingIrp\n"));
IoAcquireCancelSpinLock(&cancelIrql);
// cancel pending notification irps
KeAcquireSpinLock(&pSmartcardExtension->OsData->SpinLock, &irql);
if ( pSmartcardExtension->OsData->NotificationIrp ) {
// reset the cancel function so that it won't be called anymore
IoSetCancelRoutine(pSmartcardExtension->OsData->NotificationIrp, NULL);
pSmartcardExtension->OsData->NotificationIrp->CancelIrql = cancelIrql;
notificationIrp = pSmartcardExtension->OsData->NotificationIrp; pSmartcardExtension->OsData->NotificationIrp = NULL;
}
KeReleaseSpinLock(&pSmartcardExtension->OsData->SpinLock, irql);
if (notificationIrp) {
IoSetCancelRoutine(notificationIrp, NULL);
}
IoReleaseCancelSpinLock(cancelIrql);
if (notificationIrp) {
notificationIrp->IoStatus.Information = 0; notificationIrp->IoStatus.Status = STATUS_CANCELLED; status = STATUS_CANCELLED;
IoReleaseRemoveLock(pExt->RemoveLock, notificationIrp);
IoCompleteRequest(notificationIrp, IO_NO_INCREMENT);
}
}
__finally { SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_CancelTrackingIrp (0x%x)\n", status)); }
return status; }
NTSTATUSScUtil_Initialize( SCUTIL_HANDLE *UtilHandle, PDEVICE_OBJECT PhysicalDeviceObject, PDEVICE_OBJECT LowerDeviceObject, PSMARTCARD_EXTENSION SmartcardExtension, PIO_REMOVE_LOCK RemoveLock, PNP_CALLBACK StartDevice, PNP_CALLBACK StopDevice, PNP_CALLBACK RemoveDevice, PNP_CALLBACK FreeResources, POWER_CALLBACK SetPowerState ){ NTSTATUS status = STATUS_UNSUCCESSFUL;
PSCUTIL_EXTENSION pExt = (PSCUTIL_EXTENSION) ExAllocatePool(NonPagedPool, sizeof(SCUTIL_EXTENSION));
*UtilHandle = pExt;
PAGED_CODE();
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_Initialize\n"));
pExt->LowerDeviceObject = LowerDeviceObject; pExt->PhysicalDeviceObject = PhysicalDeviceObject; pExt->SmartcardExtension = SmartcardExtension; pExt->RemoveLock = RemoveLock; pExt->StartDevice = StartDevice; pExt->StopDevice = StopDevice; pExt->RemoveDevice = RemoveDevice; pExt->FreeResources = FreeResources; pExt->SetPowerState = SetPowerState;
IoInitializeRemoveLock(RemoveLock, 'LUCS', 0, 20);
KeInitializeEvent(&pExt->OkToStop, NotificationEvent, TRUE);
pExt->IoCount = 0; pExt->ReaderOpen = 0;
pExt->PowerState = PowerDeviceUnspecified; IrpList_Init(&pExt->PendingIrpQueue, IrpList_CancelRoutine, NULL);
pExt->RestartIoctls = FALSE; SetPnPState(pExt, DEVICE_STATE_INITIALIZED);
// register our new device
status = IoRegisterDeviceInterface(PhysicalDeviceObject, &SmartCardReaderGuid, NULL, &pExt->DeviceName);
}
__finally { SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_Initialize (0x%x)\n", status)); }
return status;
}
NTSTATUSScUtil_DeviceIOControl( PDEVICE_OBJECT DeviceObject, PIRP Irp ){ NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); QUEUE_STATE state; BOOLEAN complete = FALSE;
ASSERT(pExt);
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_DeviceIOControl\n"));
status = IoAcquireRemoveLock(pExt->RemoveLock, Irp);
if (!NT_SUCCESS(status)) {
// the device has been removed. Fail the call
status = STATUS_DEVICE_REMOVED; complete = TRUE; __leave;
} state = GetIoctlQueueState(pExt); if ( state == QUEUE_IOCTLS) { //
// Need to queue Irp
//
status = IrpList_EnqueueEx(&pExt->PendingIrpQueue, Irp, TRUE); if (!NT_SUCCESS(status)) { // the irp couldn't be queued.
IoReleaseRemoveLock(pExt->RemoveLock, Irp);
complete = TRUE; }
__leave;
} else if (state == FAIL_IOCTLS) {
status = STATUS_DEVICE_REMOVED; complete = TRUE; __leave;
} IncIoCount(pExt);
status = SmartcardDeviceControl(pExt->SmartcardExtension, Irp);
IoReleaseRemoveLock(pExt->RemoveLock, Irp);
DecIoCount(pExt);
}
__finally { if (complete) {
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = status; IoCompleteRequest(Irp, IO_NO_INCREMENT); } SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_DeviceIOControl (0x%x)\n", status)); }
return status;
}
NTSTATUSScUtil_Cleanup( PDEVICE_OBJECT DeviceObject, PIRP Irp ){ NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); PSMARTCARD_EXTENSION pSmartcardExtension = pExt->SmartcardExtension; KIRQL cancelIrql; ASSERT(pExt); __try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_Cleanup\n"));
ScUtil_CancelTrackingIrp(pExt);
Irp->IoStatus.Information = 0; Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
status = STATUS_SUCCESS;
}
__finally { SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_Cleanup (0x%x)\n", status)); }
return status;
}
NTSTATUSScUtil_UnloadDriver( PDRIVER_OBJECT DriverObject ){ NTSTATUS status = STATUS_UNSUCCESSFUL; PAGED_CODE();
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_UnloadDriver\n")); }
__finally { SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_UnloadDriver (0x%x)\n", status)); }
return status;
}
NTSTATUSScUtil_CreateClose( PDEVICE_OBJECT DeviceObject, PIRP Irp ){ NTSTATUS status = STATUS_UNSUCCESSFUL; PSCUTIL_EXTENSION pExt = *((PSCUTIL_EXTENSION*) DeviceObject->DeviceExtension); PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(Irp);
ASSERT(pExt);
PAGED_CODE();
__try { SmartcardDebug(DEBUG_TRACE, ("Enter: ScUtil_CreateClose\n"));
if ( pIrpStack->MajorFunction == IRP_MJ_CREATE ) {
status = IoAcquireRemoveLock(pExt->RemoveLock, DeviceObject);
if (!NT_SUCCESS(status)) {
status = STATUS_DEVICE_REMOVED; __leave;
}
// test if the device has been opened already
if ( InterlockedCompareExchange(&pExt->ReaderOpen, 1, 0) == 0 ) { //
//
} else {
// the device is already in use
status = STATUS_UNSUCCESSFUL;
// release the lock
IoReleaseRemoveLock(pExt->RemoveLock, DeviceObject);
}
} else {
if (InterlockedCompareExchange(&pExt->ReaderOpen, 0, 1) == 1) { IoReleaseRemoveLock(pExt->RemoveLock, DeviceObject);
} }
}
__finally {
Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest(Irp, IO_NO_INCREMENT);
SmartcardDebug(DEBUG_TRACE, ("Exit: ScUtil_CreateClose (0x%x)\n", status)); }
return status;
}
|
