761 lines
17 KiB
C
761 lines
17 KiB
C
/***************************************************************************
|
|
|
|
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"
|
|
|
|
VOID
|
|
IncIoCount(
|
|
PSCUTIL_EXTENSION pExt
|
|
)
|
|
{
|
|
ULONG count;
|
|
|
|
count = InterlockedIncrement(&pExt->IoCount);
|
|
|
|
KeClearEvent(&pExt->OkToStop);
|
|
|
|
}
|
|
|
|
VOID
|
|
DecIoCount(
|
|
PSCUTIL_EXTENSION pExt
|
|
)
|
|
{
|
|
ULONG count;
|
|
|
|
count = InterlockedDecrement(&pExt->IoCount);
|
|
|
|
if (count == 0) {
|
|
KeSetEvent(&pExt->OkToStop,
|
|
0,
|
|
FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
StartIoctls(
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
StopIoctls(
|
|
PSCUTIL_EXTENSION pExt
|
|
)
|
|
{
|
|
InterlockedExchange(&pExt->IoctlQueueState,
|
|
QUEUE_IOCTLS);
|
|
|
|
}
|
|
|
|
VOID
|
|
FailIoctls(
|
|
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);
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ScUtil_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;
|
|
|
|
}
|
|
|
|
|