NTSTATUS
AFSFlushBuffers( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
__Enter
{
if( DeviceObject == AFSDeviceObject)
{
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
return ntStatus;
}
NTSTATUS
AFSQueryEA( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_EAS_NOT_SUPPORTED;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
__try
{
if( DeviceObject == AFSDeviceObject)
{
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgLogMsg( 0,
0,
"EXCEPTION - AFSQueryEA\n");
AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
AFSWrite( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
__try
{
if( DeviceObject == AFSDeviceObject)
{
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
//
// Increment the outstanding IO count again - this time for the
// completion routine.
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
AFSClearLibraryRequest();
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
//
// And send it down, but arrange to capture the comletion
// so we can free our lock against unloading.
//
IoCopyCurrentIrpStackLocationToNext( Irp);
AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"Setting AFSWriteComplete as IoCompletion Routine Irp %p\n",
Irp));
IoSetCompletionRoutine( Irp, AFSWriteComplete, NULL, TRUE, TRUE, TRUE);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library/thread pair is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
AFSCommonCleanup( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
PFILE_OBJECT pFileObject = NULL;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
BOOLEAN bCompleteRequest = TRUE;
__Enter
{
//
// Set some initial variables to make processing easier
//
pFileObject = pIrpSp->FileObject;
if( pIrpSp->FileObject->FsContext == NULL)
{
//
// Root open
//
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus == STATUS_PENDING)
{
bCompleteRequest = FALSE;
}
try_return( ntStatus);
}
bCompleteRequest = FALSE;
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
if( bCompleteRequest)
{
if( pFileObject != NULL)
{
//
// Setup the fileobject flags to indicate cleanup is complete.
//
SetFlag( pFileObject->Flags, FO_CLEANUP_COMPLETE);
}
//
// Complete the request
//
AFSCompleteRequest( Irp, ntStatus);
}
}
return ntStatus;
}
NTSTATUS
AFSProcessControlRequest( IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION pIrpSp;
ULONG ulIoControlCode;
BOOLEAN bCompleteRequest = TRUE;
AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
ULONG ulBytesProcessed = 0;
__try
{
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
ulIoControlCode = pIrpSp->Parameters.DeviceIoControl.IoControlCode;
switch( ulIoControlCode)
{
case IOCTL_AFS_INITIALIZE_CONTROL_DEVICE:
{
//
// Go intialize the pool
//
ntStatus = AFSInitIrpPool();
if( !NT_SUCCESS( ntStatus))
{
//
// Don't initialize
//
break;
}
//
// Tag this instance as the one to close the irp pool when it is closed
//
pIrpSp->FileObject->FsContext = (void *)((ULONG_PTR)pIrpSp->FileObject->FsContext | AFS_CONTROL_INSTANCE);
break;
}
case IOCTL_AFS_INITIALIZE_REDIRECTOR_DEVICE:
{
AFSRedirectorInitInfo *pRedirInitInfo = (AFSRedirectorInitInfo *)Irp->AssociatedIrp.SystemBuffer;
//
// Extract off the passed in information which contains the
// cache file parameters
//
if( pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSRedirectorInitInfo) ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < (ULONG)FIELD_OFFSET( AFSRedirectorInitInfo, CacheFileName) +
pRedirInitInfo->CacheFileNameLength)
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
//
// Initialize the Redirector device
//
ntStatus = AFSInitializeRedirector( pRedirInitInfo);
if( !NT_SUCCESS( ntStatus))
{
break;
}
//
// Stash away context so we know the instance used to initialize the redirector
//
pIrpSp->FileObject->FsContext = (void *)((ULONG_PTR)pIrpSp->FileObject->FsContext | AFS_REDIRECTOR_INSTANCE);
break;
}
case IOCTL_AFS_PROCESS_IRP_REQUEST:
{
ntStatus = AFSProcessIrpRequest( Irp);
break;
}
case IOCTL_AFS_PROCESS_IRP_RESULT:
{
ntStatus = AFSProcessIrpResult( Irp);
break;
}
case IOCTL_AFS_SYSNAME_NOTIFICATION:
{
AFSSysNameNotificationCB *pSysNameInfo = (AFSSysNameNotificationCB *)Irp->AssociatedIrp.SystemBuffer;
if( pSysNameInfo == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSSysNameNotificationCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSSetSysNameInformation( pSysNameInfo,
pIrpSp->Parameters.DeviceIoControl.InputBufferLength);
break;
}
case IOCTL_AFS_CONFIGURE_DEBUG_TRACE:
{
AFSTraceConfigCB *pTraceInfo = (AFSTraceConfigCB *)Irp->AssociatedIrp.SystemBuffer;
if( pTraceInfo == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSTraceConfigCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSConfigureTrace( pTraceInfo);
break;
}
case IOCTL_AFS_GET_TRACE_BUFFER:
{
if( pIrpSp->Parameters.DeviceIoControl.OutputBufferLength == 0)
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSGetTraceBuffer( pIrpSp->Parameters.DeviceIoControl.OutputBufferLength,
Irp->AssociatedIrp.SystemBuffer,
&Irp->IoStatus.Information);
break;
}
case IOCTL_AFS_FORCE_CRASH:
{
#if DBG
if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_FLAG_ENABLE_FORCE_CRASH))
{
KeBugCheck( (ULONG)-1);
}
#endif
break;
}
#ifdef NOT_IMPLEMENTED
case IOCTL_AFS_LOAD_LIBRARY:
{
AFSLoadLibraryCB *pLoadLib = (AFSLoadLibraryCB *)Irp->AssociatedIrp.SystemBuffer;
UNICODE_STRING uniServicePath;
if( pLoadLib == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSLoadLibraryCB) ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < (ULONG)FIELD_OFFSET( AFSLoadLibraryCB, LibraryServicePath) +
pLoadLib->LibraryServicePathLength)
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
uniServicePath.Length = pLoadLib->LibraryServicePathLength;
uniServicePath.MaximumLength = uniServicePath.Length;
uniServicePath.Buffer = pLoadLib->LibraryServicePath;
if( uniServicePath.Length == 0)
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSLoadLibrary( pLoadLib->Flags,
&uniServicePath);
if( NT_SUCCESS( ntStatus))
{
//
// Intialize the library
//
ntStatus = AFSInitializeLibrary( NULL,
FALSE);
}
break;
}
case IOCTL_AFS_UNLOAD_LIBRARY:
{
//
// Try to unload the library we currently have in place
//
ntStatus = AFSUnloadLibrary( FALSE);
break;
}
#endif
case IOCTL_AFS_SHUTDOWN:
{
ntStatus = AFSShutdownRedirector();
break;
}
case IOCTL_AFS_AUTHGROUP_CREATE_AND_SET:
{
AFSAuthGroupRequestCB *pAuthGroupRequestCB = (AFSAuthGroupRequestCB *)Irp->AssociatedIrp.SystemBuffer;
if( pAuthGroupRequestCB == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSAuthGroupRequestCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSCreateSetProcessAuthGroup( pAuthGroupRequestCB);
break;
}
case IOCTL_AFS_AUTHGROUP_QUERY:
{
ntStatus = AFSQueryProcessAuthGroupList( ( GUID *)Irp->AssociatedIrp.SystemBuffer,
pIrpSp->Parameters.DeviceIoControl.OutputBufferLength,
&Irp->IoStatus.Information);
break;
}
case IOCTL_AFS_AUTHGROUP_SET:
{
AFSAuthGroupRequestCB *pAuthGroupRequestCB = (AFSAuthGroupRequestCB *)Irp->AssociatedIrp.SystemBuffer;
if( pAuthGroupRequestCB == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSAuthGroupRequestCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSSetActiveProcessAuthGroup( pAuthGroupRequestCB);
break;
}
case IOCTL_AFS_AUTHGROUP_RESET:
{
AFSAuthGroupRequestCB *pAuthGroupRequestCB = (AFSAuthGroupRequestCB *)Irp->AssociatedIrp.SystemBuffer;
if( pAuthGroupRequestCB == NULL ||
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSAuthGroupRequestCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSResetActiveProcessAuthGroup( pAuthGroupRequestCB);
break;
}
case IOCTL_AFS_AUTHGROUP_LOGON_CREATE:
case IOCTL_AFS_AUTHGROUP_SID_CREATE:
{
AFSAuthGroupRequestCB *pAuthGroupRequestCB = (AFSAuthGroupRequestCB *)Irp->AssociatedIrp.SystemBuffer;
if( pAuthGroupRequestCB != NULL &&
pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof( AFSAuthGroupRequestCB))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
ntStatus = AFSCreateAuthGroupForSIDorLogonSession( pAuthGroupRequestCB,
ulIoControlCode == IOCTL_AFS_AUTHGROUP_LOGON_CREATE);
break;
}
case IOCTL_AFS_AUTHGROUP_SID_QUERY:
{
AFSAuthGroupRequestCB *pAuthGroupRequestCB = NULL;
if( pIrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof( GUID))
{
ntStatus = STATUS_INVALID_PARAMETER;
break;
}
if( pIrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof( AFSAuthGroupRequestCB))
{
pAuthGroupRequestCB = (AFSAuthGroupRequestCB *)Irp->AssociatedIrp.SystemBuffer;
}
ntStatus = AFSQueryAuthGroup( pAuthGroupRequestCB,
(GUID *)Irp->AssociatedIrp.SystemBuffer,
&Irp->IoStatus.Information);
break;
}
default:
{
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus == STATUS_PENDING)
{
bCompleteRequest = FALSE;
}
break;
}
bCompleteRequest = FALSE;
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pDevExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
break;
}
}
//try_exit:
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()))
{
ntStatus = STATUS_UNSUCCESSFUL;
AFSDumpTraceFilesFnc();
}
if( bCompleteRequest)
{
Irp->IoStatus.Status = ntStatus;
AFSCompleteRequest( Irp,
ntStatus);
}
return ntStatus;
}
NTSTATUS
AFSCommonCreate( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
FILE_OBJECT *pFileObject = NULL;
IO_STACK_LOCATION *pIrpSp;
AFSDeviceExt *pDeviceExt = NULL;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
GUID *pAuthGroup = NULL;
UNICODE_STRING uniGUIDString;
__Enter
{
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
pFileObject = pIrpSp->FileObject;
uniGUIDString.Buffer = NULL;
uniGUIDString.Length = 0;
uniGUIDString.MaximumLength = 0;
//
// Validate the process entry
//
pAuthGroup = AFSValidateProcessEntry();
if( pAuthGroup != NULL)
{
RtlStringFromGUID( *pAuthGroup,
&uniGUIDString);
AFSDbgLogMsg( AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"%s (%08lX) Located AuthGroup %wZ after validation\n",
__FUNCTION__,
Irp,
&uniGUIDString);
}
else
{
AFSDbgLogMsg( AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"%s (%08lX) Failed to locate AuthGroup\n",
__FUNCTION__,
Irp);
}
//
// Root open?
//
if( pFileObject == NULL ||
pFileObject->FileName.Buffer == NULL)
{
AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSCommonCreate (%08lX) Processing volume open request\n",
Irp);
ntStatus = AFSOpenRedirector( Irp);
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDevExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
if ( pFileObject) {
AFSDbgLogMsg( AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"%s (%08lX) File \"%wZ\" AuthGroup '%wZ' ntStatus %08lX\n",
__FUNCTION__,
Irp,
&pFileObject->FileName,
&uniGUIDString,
ntStatus);
}
if( uniGUIDString.Buffer != NULL)
{
RtlFreeUnicodeString( &uniGUIDString);
}
}
return ntStatus;
}
NTSTATUS
AFSSetSecurity( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_NOT_SUPPORTED;
IO_STACK_LOCATION *pIrpSp;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
AFSFcb* pFcb = NULL;
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
__try
{
AFSDbgTrace(( AFS_SUBSYSTEM_FILE_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSSetSecurity Entry for FO %p\n",
pIrpSp->FileObject));
if( DeviceObject == AFSDeviceObject)
{
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
pFcb = (AFSFcb*) pIrpSp->FileObject->FsContext;
if( pFcb == NULL ||
pFcb->Header.NodeTypeCode == AFS_REDIRECTOR_FCB)
{
//
// Root open
//
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
__except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
AFSDbgTrace(( 0,
0,
"EXCEPTION - AFSSetSecurity\n"));
AFSDumpTraceFilesFnc();
}
return ntStatus;
}
NTSTATUS
AFSRead( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
__try
{
if( DeviceObject == AFSDeviceObject)
{
ntStatus = STATUS_INVALID_DEVICE_REQUEST;
AFSCompleteRequest( Irp,
ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
__except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
{
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
return ntStatus;
}
NTSTATUS
AFSCommonClose( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
IO_STACK_LOCATION *pIrpSp = IoGetCurrentIrpStackLocation( Irp);
AFSDeviceExt *pDeviceExt = NULL;
AFSDeviceExt *pControlDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
AFSFcb* pFcb = NULL;
__Enter
{
pDeviceExt = (AFSDeviceExt *)DeviceObject->DeviceExtension;
pIrpSp = IoGetCurrentIrpStackLocation( Irp);
pFcb = (AFSFcb*) pIrpSp->FileObject->FsContext;
if( pFcb == NULL ||
pFcb->Header.NodeTypeCode == AFS_REDIRECTOR_FCB)
{
AFSCompleteRequest( Irp, ntStatus);
try_return( ntStatus);
}
//
// Check the state of the library
//
ntStatus = AFSCheckLibraryState( Irp);
if( !NT_SUCCESS( ntStatus) ||
ntStatus == STATUS_PENDING)
{
if( ntStatus != STATUS_PENDING)
{
AFSCompleteRequest( Irp, ntStatus);
}
try_return( ntStatus);
}
IoSkipCurrentIrpStackLocation( Irp);
ntStatus = IoCallDriver( pControlDeviceExt->Specific.Control.LibraryDeviceObject,
Irp);
//
// Indicate the library is done with the request
//
AFSClearLibraryRequest();
try_exit:
NOTHING;
}
return ntStatus;
}
