VOID
NTAPI
FatSetFcbNames(IN PFAT_IRP_CONTEXT IrpContext,
IN PFCB Fcb)
{
FF_DIRENT DirEnt;
FF_ERROR Err;
POEM_STRING ShortName;
CHAR ShortNameRaw[13];
UCHAR EntryBuffer[32];
UCHAR NumLFNs;
PUNICODE_STRING UnicodeName;
OEM_STRING LongNameOem;
NTSTATUS Status;
/* Get the dir entry */
Err = FF_GetEntry(Fcb->Vcb->Ioman,
Fcb->FatHandle->DirEntry,
Fcb->FatHandle->DirCluster,
&DirEnt);
if (Err != FF_ERR_NONE)
{
DPRINT1("Error %d getting dirent of a file\n", Err);
return;
}
/* Read the dirent to fetch the raw short name */
FF_FetchEntry(Fcb->Vcb->Ioman,
Fcb->FatHandle->DirCluster,
Fcb->FatHandle->DirEntry,
EntryBuffer);
NumLFNs = (UCHAR)(EntryBuffer[0] & ~0x40);
RtlCopyMemory(ShortNameRaw, EntryBuffer, 11);
/* Initialize short name string */
ShortName = &Fcb->ShortName.Name.Ansi;
ShortName->Buffer = Fcb->ShortNameBuffer;
ShortName->Length = 0;
ShortName->MaximumLength = sizeof(Fcb->ShortNameBuffer);
/* Convert raw short name to a proper string */
Fati8dot3ToString(ShortNameRaw, FALSE, ShortName);
/* Add the short name link */
FatInsertName(IrpContext, &Fcb->ParentFcb->Dcb.SplayLinksAnsi, &Fcb->ShortName);
Fcb->ShortName.Fcb = Fcb;
/* Get the long file name (if any) */
if (NumLFNs > 0)
{
/* Prepare the oem string */
LongNameOem.Buffer = DirEnt.FileName;
LongNameOem.MaximumLength = FF_MAX_FILENAME;
LongNameOem.Length = strlen(DirEnt.FileName);
/* Prepare the unicode string */
UnicodeName = &Fcb->LongName.Name.String;
UnicodeName->Length = (LongNameOem.Length + 1) * sizeof(WCHAR);
UnicodeName->MaximumLength = UnicodeName->Length;
UnicodeName->Buffer = FsRtlAllocatePool(PagedPool, UnicodeName->Length);
/* Convert it to unicode */
Status = RtlOemStringToUnicodeString(UnicodeName, &LongNameOem, FALSE);
if (!NT_SUCCESS(Status))
{
ASSERT(FALSE);
}
/* Set its length */
Fcb->FileNameLength = UnicodeName->Length;
/* Save case-preserved copy */
Fcb->ExactCaseLongName.Length = UnicodeName->Length;
Fcb->ExactCaseLongName.MaximumLength = UnicodeName->Length;
Fcb->ExactCaseLongName.Buffer =
FsRtlAllocatePoolWithTag(PagedPool, UnicodeName->Length, TAG_FILENAME);
RtlCopyMemory(Fcb->ExactCaseLongName.Buffer,
UnicodeName->Buffer,
UnicodeName->Length);
/* Perform a trick which is done by MS's FASTFAT driver to monocase
the filename */
RtlDowncaseUnicodeString(UnicodeName, UnicodeName, FALSE);
RtlUpcaseUnicodeString(UnicodeName, UnicodeName, FALSE);
DPRINT("Converted long name: %wZ\n", UnicodeName);
/* Add the long unicode name link */
FatInsertName(IrpContext, &Fcb->ParentFcb->Dcb.SplayLinksUnicode, &Fcb->LongName);
Fcb->LongName.Fcb = Fcb;
/* Indicate that this FCB has a unicode long name */
SetFlag(Fcb->State, FCB_STATE_HAS_UNICODE_NAME);
}
else
{
/* No LFN, set exact case name to 0 length */
Fcb->ExactCaseLongName.Length = 0;
Fcb->ExactCaseLongName.MaximumLength = 0;
/* Set the length based on the short name */
Fcb->FileNameLength = RtlOemStringToCountedUnicodeSize(ShortName);
}
/* Mark the fact that names were added to splay trees*/
SetFlag(Fcb->State, FCB_STATE_HAS_NAMES);
}
NTSTATUS
NcStreamHandleContextEnumSetup (
_Inout_ PNC_DIR_QRY_CONTEXT DirContext,
_In_ PNC_INSTANCE_CONTEXT InstanceContext,
_In_ PDIRECTORY_CONTROL_OFFSETS Offsets,
_In_ PFLT_CALLBACK_DATA Data,
_In_ PCFLT_RELATED_OBJECTS FltObjects,
_In_ NC_PATH_OVERLAP UserMappingOverlap,
_Out_ PBOOLEAN FirstUsage
)
/*++
Routine Description:
Acquires the stream handle context and initializes it for a directory
enumeration.
Arguments:
DirContext - Pointer to the directory context.
InstanceContext - Pointer to this instance's context.
Offsets - Offsets structure for this enumeration class.
Data - Callback data for this operation.
FltObjects - FltObjects structure for this operation.
UserMappingOverlap - The overlap between the user mapping and this file
object.
FirstUsage - Weather or not this is the first usage of this handle in a
directory enumeration.
Return Value:
The return value is the Status of the operation.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PUNICODE_STRING SearchString = Data->Iopb->Parameters.DirectoryControl.QueryDirectory.FileName;
FILE_INFORMATION_CLASS InformationClass = Data->Iopb->Parameters.DirectoryControl.QueryDirectory.FileInformationClass;
BOOLEAN ResetSearch = BooleanFlagOn( Data->Iopb->OperationFlags, SL_RESTART_SCAN );
BOOLEAN IgnoreCase = !BooleanFlagOn( FltObjects->FileObject->Flags,
FO_OPENED_CASE_SENSITIVE );
PAGED_CODE();
//
// This context could be in its first use. If it is, then we need to
// setup the search string and information class.
//
if (DirContext->InUse == FALSE) {
//
// This was the first usage of the context.
// We should set up the search string.
//
if (SearchString != NULL) {
DirContext->SearchString.Buffer = ExAllocatePoolWithTag( PagedPool,
SearchString->Length,
NC_DIR_QRY_SEARCH_STRING );
if (DirContext->SearchString.Buffer == NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto NcStreamHandleContextEnumSetupCleanup;
}
DirContext->SearchString.MaximumLength = SearchString->Length;
if (IgnoreCase) {
RtlUpcaseUnicodeString( &DirContext->SearchString, SearchString, FALSE );
} else {
RtlCopyUnicodeString( &DirContext->SearchString, SearchString );
}
DirContext->SearchString.Length = SearchString->Length;
} else {
RtlInitEmptyUnicodeString( &DirContext->SearchString,
NULL,
0 );
}
DirContext->InformationClass = InformationClass;
//
// We should write back to the caller so they know its the first usage.
//
*FirstUsage = TRUE;
} else {
//
// This is not the fist usage, so write back to user.
//
*FirstUsage = FALSE;
//
// This is not the first query. Lets make sure that our data
// is consistent. If the information classes don't line up
// then our cache might be inconsistant. We should fail this
// operation.
//
// TODO: Is this correct?
//
if (DirContext->InformationClass != InformationClass) {
Status = STATUS_INVALID_PARAMETER;
goto NcStreamHandleContextEnumSetupCleanup;
}
}
if (!DirContext->InUse || ResetSearch) {
//
// Either this is the first use of the context,
// or they are reseting the enumeration. We
// should clear the cache either way.
//
if (DirContext->Cache.Buffer != NULL) {
ExFreePoolWithTag( DirContext->Cache.Buffer, NC_TAG );
DirContext->Cache.Buffer = NULL;
DirContext->Cache.CurrentOffset = 0;
}
if (DirContext->InjectionEntry.Buffer != NULL) {
ExFreePoolWithTag( DirContext->InjectionEntry.Buffer, NC_TAG );
DirContext->InjectionEntry.Buffer = NULL;
DirContext->InjectionEntry.CurrentOffset = 0;
}
//
// Now that the cache is clear we can set up the injection entry.
// The injection entry is the user mapping itself. Thus it only needs
// to be injected if the directory being enumerated is the parent of
// the user mapping.
//
if (UserMappingOverlap.Parent) {
Status = NcEnumerateDirectorySetupInjection( DirContext,
FltObjects,
InstanceContext,
Offsets,
InformationClass );
if (!NT_SUCCESS( Status )) {
goto NcStreamHandleContextEnumSetupCleanup;
}
}
}
//
// Now we know that the entry is setup.
// Mark it as in use.
//
DirContext->InUse = TRUE;
Status = STATUS_SUCCESS;
NcStreamHandleContextEnumSetupCleanup:
if (!NT_SUCCESS( Status )) {
if (!DirContext->InUse) {
//
// We failed to set up the context for first use.
// We should free our buffer we allocated.
//
if (DirContext->SearchString.Buffer != NULL) {
ExFreePoolWithTag( DirContext->SearchString.Buffer, NC_TAG );
DirContext->SearchString.Buffer = NULL;
DirContext->SearchString.Length = 0;
DirContext->SearchString.MaximumLength = 0;
}
}
}
return Status;
}
NTSTATUS
FatQueryDirectory (
IN PIRP_CONTEXT IrpContext,
IN PIRP Irp
)
/*++
Routine Description:
This routine performs the query directory operation. It is responsible
for either completing of enqueuing the input Irp.
Arguments:
Irp - Supplies the Irp to process
Return Value:
NTSTATUS - The return status for the operation
--*/
{
NTSTATUS Status;
PIO_STACK_LOCATION IrpSp;
PVCB Vcb;
PDCB Dcb;
PCCB Ccb;
PBCB Bcb;
ULONG i;
PUCHAR Buffer;
CLONG UserBufferLength;
PUNICODE_STRING UniArgFileName;
WCHAR LongFileNameBuffer[ FAT_CREATE_INITIAL_NAME_BUF_SIZE];
UNICODE_STRING LongFileName;
FILE_INFORMATION_CLASS FileInformationClass;
ULONG FileIndex;
BOOLEAN RestartScan;
BOOLEAN ReturnSingleEntry;
BOOLEAN IndexSpecified;
BOOLEAN InitialQuery;
VBO CurrentVbo;
BOOLEAN UpdateCcb;
PDIRENT Dirent;
UCHAR Fat8Dot3Buffer[12];
OEM_STRING Fat8Dot3String;
ULONG DiskAllocSize;
ULONG NextEntry;
ULONG LastEntry;
PFILE_DIRECTORY_INFORMATION DirInfo;
PFILE_FULL_DIR_INFORMATION FullDirInfo;
PFILE_BOTH_DIR_INFORMATION BothDirInfo;
PFILE_ID_FULL_DIR_INFORMATION IdFullDirInfo;
PFILE_ID_BOTH_DIR_INFORMATION IdBothDirInfo;
PFILE_NAMES_INFORMATION NamesInfo;
PAGED_CODE();
//
// Get the current Stack location
//
IrpSp = IoGetCurrentIrpStackLocation( Irp );
//
// Display the input values.
//
DebugTrace(+1, Dbg, "FatQueryDirectory...\n", 0);
DebugTrace( 0, Dbg, " Wait = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
DebugTrace( 0, Dbg, " Irp = %08lx\n", Irp);
DebugTrace( 0, Dbg, " ->Length = %08lx\n", IrpSp->Parameters.QueryDirectory.Length);
DebugTrace( 0, Dbg, " ->FileName = %08lx\n", IrpSp->Parameters.QueryDirectory.FileName);
DebugTrace( 0, Dbg, " ->FileInformationClass = %08lx\n", IrpSp->Parameters.QueryDirectory.FileInformationClass);
DebugTrace( 0, Dbg, " ->FileIndex = %08lx\n", IrpSp->Parameters.QueryDirectory.FileIndex);
DebugTrace( 0, Dbg, " ->UserBuffer = %08lx\n", Irp->AssociatedIrp.SystemBuffer);
DebugTrace( 0, Dbg, " ->RestartScan = %08lx\n", FlagOn( IrpSp->Flags, SL_RESTART_SCAN ));
DebugTrace( 0, Dbg, " ->ReturnSingleEntry = %08lx\n", FlagOn( IrpSp->Flags, SL_RETURN_SINGLE_ENTRY ));
DebugTrace( 0, Dbg, " ->IndexSpecified = %08lx\n", FlagOn( IrpSp->Flags, SL_INDEX_SPECIFIED ));
//
// Reference our input parameters to make things easier
//
UserBufferLength = IrpSp->Parameters.QueryDirectory.Length;
FileInformationClass = IrpSp->Parameters.QueryDirectory.FileInformationClass;
FileIndex = IrpSp->Parameters.QueryDirectory.FileIndex;
UniArgFileName = IrpSp->Parameters.QueryDirectory.FileName;
RestartScan = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
IndexSpecified = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
//
// Check on the type of open. We return invalid parameter for all
// but UserDirectoryOpens. Also check that the filename is a valid
// UNICODE string.
//
if (FatDecodeFileObject( IrpSp->FileObject,
&Vcb,
&Dcb,
&Ccb) != UserDirectoryOpen ||
(UniArgFileName &&
UniArgFileName->Length % sizeof(WCHAR))) {
FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
DebugTrace(-1, Dbg, "FatQueryDirectory -> STATUS_INVALID_PARAMETER\n", 0);
return STATUS_INVALID_PARAMETER;
}
//
// Initialize the local variables.
//
Bcb = NULL;
UpdateCcb = TRUE;
Dirent = NULL;
Fat8Dot3String.MaximumLength = 12;
Fat8Dot3String.Buffer = Fat8Dot3Buffer;
LongFileName.Length = 0;
LongFileName.MaximumLength = sizeof( LongFileNameBuffer);
LongFileName.Buffer = LongFileNameBuffer;
InitialQuery = (BOOLEAN)((Ccb->UnicodeQueryTemplate.Buffer == NULL) &&
!FlagOn(Ccb->Flags, CCB_FLAG_MATCH_ALL));
Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
DiskAllocSize = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
//
// If this is the initial query, then grab exclusive access in
// order to update the search string in the Ccb. We may
// discover that we are not the initial query once we grab the Fcb
// and downgrade our status.
//
if (InitialQuery) {
if (!FatAcquireExclusiveFcb( IrpContext, Dcb )) {
DebugTrace(0, Dbg, "FatQueryDirectory -> Enqueue to Fsp\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatQueryDirectory -> %08lx\n", Status);
return Status;
}
if (Ccb->UnicodeQueryTemplate.Buffer != NULL) {
InitialQuery = FALSE;
FatConvertToSharedFcb( IrpContext, Dcb );
}
} else {
if (!FatAcquireSharedFcb( IrpContext, Dcb )) {
DebugTrace(0, Dbg, "FatQueryDirectory -> Enqueue to Fsp\n", 0);
Status = FatFsdPostRequest( IrpContext, Irp );
DebugTrace(-1, Dbg, "FatQueryDirectory -> %08lx\n", Status);
return Status;
}
}
try {
ULONG BaseLength;
ULONG BytesConverted;
//
// If we are in the Fsp now because we had to wait earlier,
// we must map the user buffer, otherwise we can use the
// user's buffer directly.
//
Buffer = FatMapUserBuffer( IrpContext, Irp );
//
// Make sure the Dcb is still good.
//
FatVerifyFcb( IrpContext, Dcb );
//
// Determine where to start the scan. Highest priority is given
// to the file index. Lower priority is the restart flag. If
// neither of these is specified, then the Vbo offset field in the
// Ccb is used.
//
if (IndexSpecified) {
CurrentVbo = FileIndex + sizeof( DIRENT );
} else if (RestartScan) {
CurrentVbo = 0;
} else {
CurrentVbo = Ccb->OffsetToStartSearchFrom;
}
//
// If this is the first try then allocate a buffer for the file
// name.
//
if (InitialQuery) {
//
// If either:
//
// - No name was specified
// - An empty name was specified
// - We received a '*'
// - The user specified the DOS equivolent of ????????.???
//
// then match all names.
//
if ((UniArgFileName == NULL) ||
(UniArgFileName->Length == 0) ||
(UniArgFileName->Buffer == NULL) ||
((UniArgFileName->Length == sizeof(WCHAR)) &&
(UniArgFileName->Buffer[0] == L'*')) ||
((UniArgFileName->Length == 12*sizeof(WCHAR)) &&
(RtlEqualMemory( UniArgFileName->Buffer,
Fat8QMdot3QM,
12*sizeof(WCHAR) )))) {
Ccb->ContainsWildCards = TRUE;
SetFlag( Ccb->Flags, CCB_FLAG_MATCH_ALL );
} else {
BOOLEAN ExtendedName = FALSE;
OEM_STRING LocalBestFit;
//
// First and formost, see if the name has wild cards.
//
Ccb->ContainsWildCards =
FsRtlDoesNameContainWildCards( UniArgFileName );
//
// Now check to see if the name contains any extended
// characters
//
for (i=0; i < UniArgFileName->Length / sizeof(WCHAR); i++) {
if (UniArgFileName->Buffer[i] >= 0x80) {
ExtendedName = TRUE;
break;
}
}
//
// OK, now do the conversions we need.
//
if (ExtendedName) {
Status = RtlUpcaseUnicodeString( &Ccb->UnicodeQueryTemplate,
UniArgFileName,
TRUE );
if (!NT_SUCCESS(Status)) {
try_return( Status );
}
SetFlag( Ccb->Flags, CCB_FLAG_FREE_UNICODE );
//
// Upcase the name and convert it to the Oem code page.
//
Status = RtlUpcaseUnicodeStringToCountedOemString( &LocalBestFit,
UniArgFileName,
TRUE );
//
// If this conversion failed for any reason other than
// an unmappable character fail the request.
//
if (!NT_SUCCESS(Status)) {
if (Status == STATUS_UNMAPPABLE_CHARACTER) {
SetFlag( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE );
} else {
try_return( Status );
}
} else {
SetFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
} else {
PVOID Buffers;
//
// This case is optimized because I know I only have to
// worry about a-z.
//
Buffers = FsRtlAllocatePoolWithTag( PagedPool,
UniArgFileName->Length +
UniArgFileName->Length / sizeof(WCHAR),
TAG_FILENAME_BUFFER );
Ccb->UnicodeQueryTemplate.Buffer = Buffers;
Ccb->UnicodeQueryTemplate.Length = UniArgFileName->Length;
Ccb->UnicodeQueryTemplate.MaximumLength = UniArgFileName->Length;
LocalBestFit.Buffer = (PUCHAR)Buffers + UniArgFileName->Length;
LocalBestFit.Length = UniArgFileName->Length / sizeof(WCHAR);
LocalBestFit.MaximumLength = LocalBestFit.Length;
SetFlag( Ccb->Flags, CCB_FLAG_FREE_UNICODE );
for (i=0; i < UniArgFileName->Length / sizeof(WCHAR); i++) {
WCHAR c = UniArgFileName->Buffer[i];
LocalBestFit.Buffer[i] = (UCHAR)
(Ccb->UnicodeQueryTemplate.Buffer[i] =
(c < 'a' ? c : c <= 'z' ? c - ('a' - 'A') : c));
}
}
//
// At this point we now have the upcased unicode name,
// and the two Oem names if they could be represented in
// this code page.
//
// Now determine if the Oem names are legal for what we
// going to try and do. Mark them as not usable is they
// are not legal. Note that we can optimize extended names
// since they are actually both the same string.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE ) &&
!FatIsNameShortOemValid( IrpContext,
LocalBestFit,
Ccb->ContainsWildCards,
FALSE,
FALSE )) {
if (ExtendedName) {
RtlFreeOemString( &LocalBestFit );
ClearFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
SetFlag( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE );
}
//
// OK, now both locals oem strings correctly reflect their
// usability. Now we want to load up the Ccb structure.
//
// Now we will branch on two paths of wheather the name
// is wild or not.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_SKIP_SHORT_NAME_COMPARE )) {
if (Ccb->ContainsWildCards) {
Ccb->OemQueryTemplate.Wild = LocalBestFit;
} else {
FatStringTo8dot3( IrpContext,
LocalBestFit,
&Ccb->OemQueryTemplate.Constant );
if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT)) {
RtlFreeOemString( &LocalBestFit );
ClearFlag( Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT );
}
}
}
}
//
// We convert to shared access.
//
FatConvertToSharedFcb( IrpContext, Dcb );
}
LastEntry = 0;
NextEntry = 0;
switch (FileInformationClass) {
case FileDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_DIRECTORY_INFORMATION,
FileName[0] );
break;
case FileFullDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_FULL_DIR_INFORMATION,
FileName[0] );
break;
case FileIdFullDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_ID_FULL_DIR_INFORMATION,
FileName[0] );
break;
case FileNamesInformation:
BaseLength = FIELD_OFFSET( FILE_NAMES_INFORMATION,
FileName[0] );
break;
case FileBothDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_BOTH_DIR_INFORMATION,
FileName[0] );
break;
case FileIdBothDirectoryInformation:
BaseLength = FIELD_OFFSET( FILE_ID_BOTH_DIR_INFORMATION,
FileName[0] );
break;
default:
try_return( Status = STATUS_INVALID_INFO_CLASS );
}
//
// At this point we are about to enter our query loop. We have
// determined the index into the directory file to begin the
// search. LastEntry and NextEntry are used to index into the user
// buffer. LastEntry is the last entry we've added, NextEntry is
// current one we're working on. If NextEntry is non-zero, then
// at least one entry was added.
//
while ( TRUE ) {
VBO NextVbo;
ULONG FileNameLength;
ULONG BytesRemainingInBuffer;
DebugTrace(0, Dbg, "FatQueryDirectory -> Top of loop\n", 0);
//
// If the user had requested only a single match and we have
// returned that, then we stop at this point.
//
if (ReturnSingleEntry && NextEntry != 0) {
try_return( Status );
}
//
// We call FatLocateDirent to lock down the next matching dirent.
//
FatLocateDirent( IrpContext,
Dcb,
Ccb,
CurrentVbo,
&Dirent,
&Bcb,
&NextVbo,
NULL,
&LongFileName);
//
// If we didn't receive a dirent, then we are at the end of the
// directory. If we have returned any files, we exit with
// success, otherwise we return STATUS_NO_MORE_FILES.
//
if (!Dirent) {
DebugTrace(0, Dbg, "FatQueryDirectory -> No dirent\n", 0);
if (NextEntry == 0) {
UpdateCcb = FALSE;
if (InitialQuery) {
Status = STATUS_NO_SUCH_FILE;
} else {
Status = STATUS_NO_MORE_FILES;
}
}
try_return( Status );
}
//
// Protect access to the user buffer with an exception handler.
// Since (at our request) IO doesn't buffer these requests, we have
// to guard against a user messing with the page protection and other
// such trickery.
//
try {
if (LongFileName.Length == 0) {
//
// Now we have an entry to return to our caller. We'll convert
// the name from the form in the dirent to a <name>.<ext> form.
// We'll case on the type of information requested and fill up
// the user buffer if everything fits.
//
Fat8dot3ToString( IrpContext, Dirent, TRUE, &Fat8Dot3String );
//
// Determine the UNICODE length of the file name.
//
FileNameLength = RtlOemStringToCountedUnicodeSize(&Fat8Dot3String);
//
// Here are the rules concerning filling up the buffer:
//
// 1. The Io system garentees that there will always be
// enough room for at least one base record.
//
// 2. If the full first record (including file name) cannot
// fit, as much of the name as possible is copied and
// STATUS_BUFFER_OVERFLOW is returned.
//
// 3. If a subsequent record cannot completely fit into the
// buffer, none of it (as in 0 bytes) is copied, and
// STATUS_SUCCESS is returned. A subsequent query will
// pick up with this record.
//
BytesRemainingInBuffer = UserBufferLength - NextEntry;
if ( (NextEntry != 0) &&
( (BaseLength + FileNameLength > BytesRemainingInBuffer) ||
(UserBufferLength < NextEntry) ) ) {
DebugTrace(0, Dbg, "Next entry won't fit\n", 0);
try_return( Status = STATUS_SUCCESS );
}
ASSERT( BytesRemainingInBuffer >= BaseLength );
//
// Zero the base part of the structure.
//
RtlZeroMemory( &Buffer[NextEntry], BaseLength );
switch ( FileInformationClass ) {
//
// Now fill the base parts of the strucure that are applicable.
//
case FileBothDirectoryInformation:
case FileFullDirectoryInformation:
case FileIdBothDirectoryInformation:
case FileIdFullDirectoryInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file full directory information\n", 0);
//
// Get the Ea file length.
//
FullDirInfo = (PFILE_FULL_DIR_INFORMATION)&Buffer[NextEntry];
//
// If the EAs are corrupt, ignore the error. We don't want
// to abort the directory query.
//
try {
FatGetEaLength( IrpContext,
Vcb,
Dirent,
&FullDirInfo->EaSize );
} except(EXCEPTION_EXECUTE_HANDLER) {
FatResetExceptionState( IrpContext );
FullDirInfo->EaSize = 0;
}
case FileDirectoryInformation:
DirInfo = (PFILE_DIRECTORY_INFORMATION)&Buffer[NextEntry];
FatGetDirTimes( IrpContext, Dirent, DirInfo );
DirInfo->EndOfFile.QuadPart = Dirent->FileSize;
if (!FlagOn( Dirent->Attributes, FAT_DIRENT_ATTR_DIRECTORY )) {
DirInfo->AllocationSize.QuadPart =
(((Dirent->FileSize + DiskAllocSize - 1) / DiskAllocSize) *
DiskAllocSize );
}
DirInfo->FileAttributes = Dirent->Attributes != 0 ?
Dirent->Attributes :
FILE_ATTRIBUTE_NORMAL;
DirInfo->FileIndex = NextVbo;
DirInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String);
break;
case FileNamesInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file names information\n", 0);
NamesInfo = (PFILE_NAMES_INFORMATION)&Buffer[NextEntry];
NamesInfo->FileIndex = NextVbo;
NamesInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String );
break;
default:
FatBugCheck( FileInformationClass, 0, 0 );
}
BytesConverted = 0;
Status = RtlOemToUnicodeN( (PWCH)&Buffer[NextEntry + BaseLength],
BytesRemainingInBuffer - BaseLength,
&BytesConverted,
Fat8Dot3String.Buffer,
Fat8Dot3String.Length );
//
// Check for the case that a single entry doesn't fit.
// This should only get this far on the first entry
//
if (BytesConverted < FileNameLength) {
ASSERT( NextEntry == 0 );
Status = STATUS_BUFFER_OVERFLOW;
}
//
// Set up the previous next entry offset
//
*((PULONG)(&Buffer[LastEntry])) = NextEntry - LastEntry;
//
// And indicate how much of the user buffer we have currently
// used up. We must compute this value before we long align
// ourselves for the next entry
//
Irp->IoStatus.Information = QuadAlign( Irp->IoStatus.Information ) +
BaseLength + BytesConverted;
//
// If something happened with the conversion, bail here.
//
if ( !NT_SUCCESS( Status ) ) {
try_return( NOTHING );
}
} else {
ULONG ShortNameLength;
FileNameLength = LongFileName.Length;
//
// Here are the rules concerning filling up the buffer:
//
// 1. The Io system garentees that there will always be
// enough room for at least one base record.
//
// 2. If the full first record (including file name) cannot
// fit, as much of the name as possible is copied and
// STATUS_BUFFER_OVERFLOW is returned.
//
// 3. If a subsequent record cannot completely fit into the
// buffer, none of it (as in 0 bytes) is copied, and
// STATUS_SUCCESS is returned. A subsequent query will
// pick up with this record.
//
BytesRemainingInBuffer = UserBufferLength - NextEntry;
if ( (NextEntry != 0) &&
( (BaseLength + FileNameLength > BytesRemainingInBuffer) ||
(UserBufferLength < NextEntry) ) ) {
DebugTrace(0, Dbg, "Next entry won't fit\n", 0);
try_return( Status = STATUS_SUCCESS );
}
ASSERT( BytesRemainingInBuffer >= BaseLength );
//
// Zero the base part of the structure.
//
RtlZeroMemory( &Buffer[NextEntry], BaseLength );
switch ( FileInformationClass ) {
//
// Now fill the base parts of the strucure that are applicable.
//
case FileBothDirectoryInformation:
case FileIdBothDirectoryInformation:
BothDirInfo = (PFILE_BOTH_DIR_INFORMATION)&Buffer[NextEntry];
//
// Now we have an entry to return to our caller. We'll convert
// the name from the form in the dirent to a <name>.<ext> form.
// We'll case on the type of information requested and fill up
// the user buffer if everything fits.
//
Fat8dot3ToString( IrpContext, Dirent, FALSE, &Fat8Dot3String );
ASSERT( Fat8Dot3String.Length <= 12 );
Status = RtlOemToUnicodeN( &BothDirInfo->ShortName[0],
12*sizeof(WCHAR),
&ShortNameLength,
Fat8Dot3String.Buffer,
Fat8Dot3String.Length );
ASSERT( Status != STATUS_BUFFER_OVERFLOW );
ASSERT( ShortNameLength <= 12*sizeof(WCHAR) );
//
// Copy the length into the dirinfo structure. Note
// that the LHS below is a USHORT, so it can not
// be specificed as the OUT parameter above.
//
BothDirInfo->ShortNameLength = (UCHAR)ShortNameLength;
//
// If something happened with the conversion, bail here.
//
if ( !NT_SUCCESS( Status ) ) {
try_return( NOTHING );
}
case FileFullDirectoryInformation:
case FileIdFullDirectoryInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file full directory information\n", 0);
//
// Get the Ea file length.
//
FullDirInfo = (PFILE_FULL_DIR_INFORMATION)&Buffer[NextEntry];
//
// If the EAs are corrupt, ignore the error. We don't want
// to abort the directory query.
//
try {
FatGetEaLength( IrpContext,
Vcb,
Dirent,
&FullDirInfo->EaSize );
} except(EXCEPTION_EXECUTE_HANDLER) {
FatResetExceptionState( IrpContext );
FullDirInfo->EaSize = 0;
}
case FileDirectoryInformation:
DirInfo = (PFILE_DIRECTORY_INFORMATION)&Buffer[NextEntry];
FatGetDirTimes( IrpContext, Dirent, DirInfo );
DirInfo->EndOfFile.QuadPart = Dirent->FileSize;
if (!FlagOn( Dirent->Attributes, FAT_DIRENT_ATTR_DIRECTORY )) {
DirInfo->AllocationSize.QuadPart = (
(( Dirent->FileSize
+ DiskAllocSize - 1 )
/ DiskAllocSize )
* DiskAllocSize );
}
DirInfo->FileAttributes = Dirent->Attributes != 0 ?
Dirent->Attributes :
FILE_ATTRIBUTE_NORMAL;
DirInfo->FileIndex = NextVbo;
DirInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String);
break;
case FileNamesInformation:
DebugTrace(0, Dbg, "FatQueryDirectory -> Getting file names information\n", 0);
NamesInfo = (PFILE_NAMES_INFORMATION)&Buffer[NextEntry];
NamesInfo->FileIndex = NextVbo;
NamesInfo->FileNameLength = FileNameLength;
DebugTrace(0, Dbg, "FatQueryDirectory -> Name = \"%Z\"\n", &Fat8Dot3String );
break;
default:
FatBugCheck( FileInformationClass, 0, 0 );
}
BytesConverted = BytesRemainingInBuffer - BaseLength >= FileNameLength ?
FileNameLength :
BytesRemainingInBuffer - BaseLength;
RtlCopyMemory( &Buffer[NextEntry + BaseLength],
&LongFileName.Buffer[0],
BytesConverted );
//
// Set up the previous next entry offset
//
*((PULONG)(&Buffer[LastEntry])) = NextEntry - LastEntry;
//
// And indicate how much of the user buffer we have currently
// used up. We must compute this value before we long align
// ourselves for the next entry
//
Irp->IoStatus.Information = QuadAlign( Irp->IoStatus.Information ) +
BaseLength + BytesConverted;
//
// Check for the case that a single entry doesn't fit.
// This should only get this far on the first entry.
//
if (BytesConverted < FileNameLength) {
ASSERT( NextEntry == 0 );
try_return( Status = STATUS_BUFFER_OVERFLOW );
}
}
//
// Finish up by filling in the FileId
//
switch ( FileInformationClass ) {
case FileIdBothDirectoryInformation:
IdBothDirInfo = (PFILE_ID_BOTH_DIR_INFORMATION)&Buffer[NextEntry];
IdBothDirInfo->FileId.QuadPart = FatGenerateFileIdFromDirentAndOffset( Dcb, Dirent, NextVbo );
break;
case FileIdFullDirectoryInformation:
IdFullDirInfo = (PFILE_ID_FULL_DIR_INFORMATION)&Buffer[NextEntry];
IdFullDirInfo->FileId.QuadPart = FatGenerateFileIdFromDirentAndOffset( Dcb, Dirent, NextVbo );
break;
default:
break;
}
} except (EXCEPTION_EXECUTE_HANDLER) {
//
// We had a problem filling in the user's buffer, so stop and
// fail this request. This is the only reason any exception
// would have occured at this level.
//
Irp->IoStatus.Information = 0;
UpdateCcb = FALSE;
try_return( Status = GetExceptionCode());
}
//
// Set ourselves up for the next iteration
//
LastEntry = NextEntry;
NextEntry += (ULONG)QuadAlign(BaseLength + BytesConverted);
CurrentVbo = NextVbo + sizeof( DIRENT );
}
try_exit: NOTHING;
} finally {
/*
* @implemented
*/
VOID
EXPORT
NdisRegisterProtocol(
OUT PNDIS_STATUS Status,
OUT PNDIS_HANDLE NdisProtocolHandle,
IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics,
IN UINT CharacteristicsLength)
/*
* FUNCTION: Registers an NDIS driver's ProtocolXxx entry points
* ARGUMENTS:
* Status = Address of buffer for status information
* NdisProtocolHandle = Address of buffer for handle used to identify the driver
* ProtocolCharacteristics = Pointer to NDIS_PROTOCOL_CHARACTERISTICS structure
* CharacteristicsLength = Size of structure which ProtocolCharacteristics targets
* NOTES:
* - you *must* set NdisProtocolHandle before doing anything that could wind up
* getting BindAdapterHandler, as it will probably call OpenAdapter with this handle
* - the above implies that the initialization of the protocol block must be complete
* by then
* TODO:
* - break this function up - probably do a 'ndisRefreshProtocolBindings' function
* - make this thing able to handle >1 protocol
*/
{
PPROTOCOL_BINDING Protocol;
NTSTATUS NtStatus;
UINT MinSize;
PNET_PNP_EVENT PnPEvent;
NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
*NdisProtocolHandle = NULL;
/* first validate the PROTOCOL_CHARACTERISTICS */
switch (ProtocolCharacteristics->MajorNdisVersion)
{
case 0x03:
/* we don't really want to support ndis3 drivers - so we complain for now */
NDIS_DbgPrint(MID_TRACE, ("NDIS 3 protocol attempting to register\n"));
MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS);
break;
case 0x04:
MinSize = sizeof(NDIS40_PROTOCOL_CHARACTERISTICS);
break;
case 0x05:
MinSize = sizeof(NDIS50_PROTOCOL_CHARACTERISTICS);
break;
default:
*Status = NDIS_STATUS_BAD_VERSION;
NDIS_DbgPrint(MIN_TRACE, ("Incorrect characteristics size\n"));
return;
}
if (CharacteristicsLength < MinSize)
{
NDIS_DbgPrint(MIN_TRACE, ("Bad protocol characteristics.\n"));
*Status = NDIS_STATUS_BAD_CHARACTERISTICS;
return;
}
/* set up the protocol block */
Protocol = ExAllocatePool(NonPagedPool, sizeof(PROTOCOL_BINDING));
if (!Protocol)
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
*Status = NDIS_STATUS_RESOURCES;
return;
}
RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name, &ProtocolCharacteristics->Name, TRUE);
if (!NT_SUCCESS(NtStatus))
{
NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
ExFreePool(Protocol);
*Status = NDIS_STATUS_RESOURCES;
return;
}
KeInitializeSpinLock(&Protocol->Lock);
InitializeListHead(&Protocol->AdapterListHead);
/* We must set this before the call to ndisBindMiniportsToProtocol because the protocol's
* BindAdapter handler might need it */
*NdisProtocolHandle = Protocol;
ndisBindMiniportsToProtocol(Status, Protocol);
/* Should we only send this if ndisBindMiniportsToProtocol succeeds? */
PnPEvent = ProSetupPnPEvent(NetEventBindsComplete, NULL, 0);
if (PnPEvent)
{
if (Protocol->Chars.PnPEventHandler)
{
/* We call this with a NULL binding context because it affects all bindings */
NtStatus = (*Protocol->Chars.PnPEventHandler)(NULL,
PnPEvent);
/* FIXME: We don't support this yet */
ASSERT(NtStatus != NDIS_STATUS_PENDING);
}
ExFreePool(PnPEvent);
}
if (*Status == NDIS_STATUS_SUCCESS) {
ExInterlockedInsertTailList(&ProtocolListHead, &Protocol->ListEntry, &ProtocolListLock);
} else {
NDIS_DbgPrint(MIN_TRACE, ("Binding failed (%x)\n", *Status));
ExFreePool(Protocol);
*NdisProtocolHandle = NULL;
}
}
NDIS_STATUS
NdisIMRegisterLayeredMiniport(
IN NDIS_HANDLE NdisWrapperHandle,
IN PNDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics,
IN UINT CharacteristicsLength,
OUT PNDIS_HANDLE DriverHandle
)
/*++
Routine Description:
Used to register a layered Miniport driver with the wrapper.
Arguments:
Status - Status of the operation.
NdisWrapperHandle - Handle returned by NdisWInitializeWrapper.
MiniportCharacteritics - The NDIS_MINIPORT_CHARACTERISTICS table.
CharacteristicsLength - The length of MiniportCharacteristics.
DriverHandle - Returns a handle which can be used to call NdisMInitializeDeviceInstance.
Return Value:
None.
--*/
{
PNDIS_M_DRIVER_BLOCK MiniBlock;
PNDIS_WRAPPER_HANDLE DriverInfo = (PNDIS_WRAPPER_HANDLE)(NdisWrapperHandle);
UNICODE_STRING Us;
PWSTR pWch;
USHORT i, size;
UINT MemNeeded;
NDIS_STATUS Status;
KIRQL OldIrql;
DBGPRINT(DBG_COMP_CONFIG, DBG_LEVEL_INFO,
("Enter mini-port register\n"));
do
{
if (DriverInfo == NULL)
{
Status = NDIS_STATUS_FAILURE;
break;
}
//
// Check version numbers and CharacteristicsLength.
//
size = 0; // Used to indicate bad version below
if (MiniportCharacteristics->MajorNdisVersion == 3)
{
if (MiniportCharacteristics->MinorNdisVersion == 0)
size = sizeof(NDIS30_MINIPORT_CHARACTERISTICS);
}
else if (MiniportCharacteristics->MajorNdisVersion == 4)
{
if (MiniportCharacteristics->MinorNdisVersion == 0)
{
size = sizeof(NDIS40_MINIPORT_CHARACTERISTICS);
}
else if (MiniportCharacteristics->MinorNdisVersion == 1)
{
size = sizeof(NDIS41_MINIPORT_CHARACTERISTICS);
}
}
//
// Check that this is an NDIS 3.0/4.0/4.1 miniport.
//
if (size == 0)
{
Status = NDIS_STATUS_BAD_VERSION;
break;
}
//
// Check that CharacteristicsLength is enough.
//
if (CharacteristicsLength < size)
{
Status = NDIS_STATUS_BAD_CHARACTERISTICS;
break;
}
//
// Allocate memory for the NDIS MINIPORT block.
//
MemNeeded = sizeof(NDIS_M_DRIVER_BLOCK);
//
// Extract the base-name, determine its length and allocate that much more
//
Us = *(PUNICODE_STRING)(DriverInfo->NdisWrapperConfigurationHandle);
for (i = Us.Length/sizeof(WCHAR), pWch = Us.Buffer + i - 1;
i > 0;
pWch --, i--)
{
if (*pWch == L'\\')
{
Us.Buffer = pWch + 1;
Us.Length -= i*sizeof(WCHAR);
Us.MaximumLength = Us.Length + sizeof(WCHAR);
break;
}
}
MemNeeded += Us.MaximumLength;
MiniBlock = (PNDIS_M_DRIVER_BLOCK)ALLOC_FROM_POOL(MemNeeded, NDIS_TAG_MINI_BLOCK);
if (MiniBlock == (PNDIS_M_DRIVER_BLOCK)NULL)
{
return NDIS_STATUS_RESOURCES;
}
ZeroMemory(MiniBlock, MemNeeded);
MiniBlock->Length = MemNeeded;
//
// Copy over the characteristics table.
//
CopyMemory(&MiniBlock->MiniportCharacteristics,
MiniportCharacteristics,
size);
//
// Upcase the base-name and save it in the MiniBlock
//
MiniBlock->BaseName.Buffer = (PWSTR)((PUCHAR)MiniBlock + sizeof(NDIS_M_DRIVER_BLOCK));
MiniBlock->BaseName.Length =
MiniBlock->BaseName.MaximumLength = Us.Length;
RtlUpcaseUnicodeString(&MiniBlock->BaseName,
&Us,
FALSE);
//
// No adapters yet registered for this Miniport.
//
MiniBlock->MiniportQueue = (PNDIS_MINIPORT_BLOCK)NULL;
//
// Set up unload handler
//
DriverInfo->NdisWrapperDriver->DriverUnload = ndisMUnload;
//
// Set up shutdown handler
//
DriverInfo->NdisWrapperDriver->MajorFunction[IRP_MJ_SHUTDOWN] = ndisMShutdown;
//
// Set up the handlers for this driver (they all do nothing).
//
DriverInfo->NdisWrapperDriver->MajorFunction[IRP_MJ_CREATE] = ndisCreateIrpHandler;
DriverInfo->NdisWrapperDriver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ndisDeviceControlIrpHandler;
DriverInfo->NdisWrapperDriver->MajorFunction[IRP_MJ_CLEANUP] = ndisSuccessIrpHandler;
DriverInfo->NdisWrapperDriver->MajorFunction[IRP_MJ_CLOSE] = ndisCloseIrpHandler;
//
// Use this event to tell us when all adapters are removed from the mac
// during an unload
//
INITIALIZE_EVENT(&MiniBlock->MiniportsRemovedEvent);
MiniBlock->Unloading = FALSE;
MiniBlock->NdisDriverInfo = DriverInfo;
MiniBlock->MiniportIdField = (NDIS_HANDLE)0x1;
NdisInitializeRef(&MiniBlock->Ref);
// Lock the init code down now - before we take the lock below
MiniportReferencePackage();
//
// Put Driver on global list.
//
ACQUIRE_SPIN_LOCK(&ndisDriverListLock, &OldIrql);
MiniBlock->NextDriver = ndisMiniDriverList;
ndisMiniDriverList = MiniBlock;
RELEASE_SPIN_LOCK(&ndisDriverListLock, OldIrql);
MiniportDereferencePackage();
*DriverHandle = MiniBlock;
Status = NDIS_STATUS_SUCCESS;
} while (FALSE);
return Status;
}
NTSTATUS
NpTranslateAlias (
IN OUT PUNICODE_STRING String
)
/*++
Routine Description:
This routine translates a pipe name string based on information
obtained from the registry at boot time. This translation is used
to allow RPC services that had different names in NT 1.0 to have
common names in 1.0a and beyond.
Arguments:
String - Supplies the input string to search for; returns the output
string, if the name was translated. If so, the string points to
a buffer allocated from paged pool. The caller should NOT free
this buffer.
Return Value:
NTSTATUS - Returns STATUS_SUCCESS unless an allocation failure occurs.
The status does NOT indicate whether the name was translated.
--*/
{
NTSTATUS Status;
UNICODE_STRING UpcaseString;
ULONG Length;
PSINGLE_LIST_ENTRY Entry;
PALIAS Alias;
PWCH sp, ap;
WCHAR a, s;
BOOLEAN NoSlash;
WCHAR UpcaseBuffer[MAX_LENGTH_ALIAS_ARRAY];
BOOLEAN FreeUpcaseBuffer;
PAGED_CODE();
//
// Before upcasing the string (a relatively expensive operation),
// make sure that the string length matches at least one alias.
//
Length = String->Length;
if ( Length == 0 ) {
return STATUS_SUCCESS;
}
if ( *String->Buffer != L'\\' ) {
Length += sizeof(WCHAR);
NoSlash = TRUE;
} else {
NoSlash = FALSE;
}
if ( (Length >= MIN_LENGTH_ALIAS_ARRAY) &&
(Length <= MAX_LENGTH_ALIAS_ARRAY) ) {
Entry = NpAliasListByLength[(Length - MIN_LENGTH_ALIAS_ARRAY) / sizeof(WCHAR)].Next;
Alias = CONTAINING_RECORD( Entry, ALIAS, ListEntry );
} else {
Entry = NpAliasList.Next;
while ( Entry != NULL ) {
Alias = CONTAINING_RECORD( Entry, ALIAS, ListEntry );
if ( Alias->AliasString.Length == Length ) {
break;
}
if ( Alias->AliasString.Length > Length ) {
return STATUS_SUCCESS;
}
Entry = Entry->Next;
}
}
if ( Entry == NULL ) {
return STATUS_SUCCESS;
}
//
// The string's length matches at least one alias. Upcase the string.
//
if ( Length <= MAX_LENGTH_ALIAS_ARRAY ) {
UpcaseString.MaximumLength = MAX_LENGTH_ALIAS_ARRAY;
UpcaseString.Buffer = UpcaseBuffer;
Status = RtlUpcaseUnicodeString( &UpcaseString, String, FALSE );
ASSERT( NT_SUCCESS(Status) );
FreeUpcaseBuffer = FALSE;
} else {
Status = RtlUpcaseUnicodeString( &UpcaseString, String, TRUE );
if ( !NT_SUCCESS(Status) ) {
return Status;
}
FreeUpcaseBuffer = TRUE;
}
ASSERT( UpcaseString.Length == (Length - (NoSlash ? sizeof(WCHAR) : 0)) );
//
// At this point, Entry points to an alias list entry whose length
// matches that of the input string. This list entry may be the
// first element of a length-specific list (in which all entries
// have the same length), or it may be an element of a length-ordered
// list (in which case we'll need to check each next entry to see if
// it's the same length. In both cases, strings of the same length
// are in lexical order.
//
// Try to match the upcased string up to an alias.
//
do {
sp = UpcaseString.Buffer;
ap = Alias->AliasString.Buffer;
if ( NoSlash ) {
ap++;
}
while ( TRUE ) {
a = *ap;
if ( a == 0 ) {
*String = *Alias->TranslationString;
if ( NoSlash ) {
String->Length -= sizeof(WCHAR);
String->Buffer++;
}
goto exit;
}
s = *sp;
if ( s < a ) goto exit;
if ( s > a ) break;
sp++;
ap++;
}
//
// The input string doesn't match the current alias. Move to
// the next one.
//
Entry = Entry->Next;
if ( Entry == NULL ) {
goto exit;
}
Alias = CONTAINING_RECORD( Entry, ALIAS, ListEntry );
} while ( Alias->AliasString.Length == Length );
exit:
if (FreeUpcaseBuffer) {
ASSERT( UpcaseString.Buffer != UpcaseBuffer );
ExFreePool( UpcaseString.Buffer );
}
return STATUS_SUCCESS;
}
NTSTATUS
ReadAlias (
IN PWSTR ValueName,
IN ULONG ValueType,
IN PVOID ValueData,
IN ULONG ValueLength,
IN PVOID Context,
IN PVOID EntryContext
)
{
PALIAS_CONTEXT Ctx = Context;
USHORT Length;
PWCH p;
PUNICODE_STRING TranslationString;
PALIAS Alias;
//
// The value must be a REG_MULTI_SZ value.
//
if (ValueType != REG_MULTI_SZ) {
return STATUS_INVALID_PARAMETER;
}
//
// In phase 1, we calculate the required size of the alias buffer.
// In phase 2, we build the alias descriptors.
//
if ( Ctx->Phase1 ) {
//
// The value name is the translation. The value data is one or
// more strings that are aliases for the translation.
//
// The "1+" and "sizeof(WCHAR)+" are for the '\' that will be
// placed in front of the translation string and the alias string.
//
Ctx->TranslationCount++;
Length = (USHORT)((1 + wcslen(ValueName) + 1) * sizeof(WCHAR));
Ctx->RequiredSize += Length + sizeof(UNICODE_STRING);
p = ValueData;
while ( *p != 0 ) {
Ctx->AliasCount++;
Length = (USHORT)((wcslen(p) + 1) * sizeof(WCHAR));
Ctx->RequiredSize += sizeof(WCHAR) + Length + sizeof(ALIAS);
p = (PWCH)((PCHAR)p + Length);
}
} else {
//
// Build a string descriptor for the translation string.
//
TranslationString = Ctx->NextTranslation++;
Length = (USHORT)((1 + wcslen(ValueName) + 1) * sizeof(WCHAR));
TranslationString->Length = Length - sizeof(WCHAR);
TranslationString->MaximumLength = Length;
TranslationString->Buffer = Ctx->NextStringData;
Ctx->NextStringData = (PWCH)((PCHAR)Ctx->NextStringData + Length);
//
// Copy the string data. Place a '\' at the beginning.
//
TranslationString->Buffer[0] = L'\\';
RtlCopyMemory( &TranslationString->Buffer[1],
ValueName,
Length - sizeof(WCHAR) );
//
// Build aliases descriptors.
//
p = ValueData;
while ( *p != 0 ) {
Alias = Ctx->NextAlias++;
//
// Point the alias descriptor to the translation string.
//
Alias->TranslationString = TranslationString;
//
// Build the alias string descriptor.
//
Length = (USHORT)((1 + wcslen(p) + 1) * sizeof(WCHAR));
Alias->AliasString.Length = Length - sizeof(WCHAR);
Alias->AliasString.MaximumLength = Length;
Alias->AliasString.Buffer = Ctx->NextStringData;
Ctx->NextStringData = (PWCH)((PCHAR)Ctx->NextStringData + Length);
//
// Copy the string data. Place a '\' at the beginning.
//
Alias->AliasString.Buffer[0] = L'\\';
RtlCopyMemory( &Alias->AliasString.Buffer[1],
p,
Length - sizeof(WCHAR) );
//
// Upcase the string.
//
RtlUpcaseUnicodeString( &Alias->AliasString,
&Alias->AliasString,
FALSE );
p = (PWCH)((PCHAR)p + Length - sizeof(WCHAR));
}
}
return STATUS_SUCCESS;
}
VOID
CdUpcaseName (
IN PIRP_CONTEXT IrpContext,
IN PCD_NAME Name,
IN OUT PCD_NAME UpcaseName
)
/*++
Routine Description:
This routine is called to upcase a CdName structure. We will do both
the filename and version strings.
Arguments:
Name - This is the mixed case version of the name.
UpcaseName - This is the destination for the upcase operation.
Return Value:
None. This routine will raise all errors.
--*/
{
NTSTATUS Status;
PVOID NewBuffer;
PAGED_CODE();
//
// If the name structures are different then initialize the different components.
//
if (Name != UpcaseName) {
//
// Initialize the version string portion of the name.
//
UpcaseName->VersionString.Length = 0;
if (Name->VersionString.Length != 0) {
UpcaseName->VersionString.MaximumLength =
UpcaseName->VersionString.Length = Name->VersionString.Length;
//
// Initially set the buffer to point to where we need to insert
// the separator.
//
UpcaseName->VersionString.Buffer = Add2Ptr( UpcaseName->FileName.Buffer,
Name->FileName.Length,
PWCHAR );
//
// We are currently pointing to the location to store the separator.
// Store the ';' and then move to the next character to
// copy the data.
//
*(UpcaseName->VersionString.Buffer) = L';';
UpcaseName->VersionString.Buffer += 1;
}
}
//
// Upcase the string using the correct upcase routine.
//
Status = RtlUpcaseUnicodeString( &UpcaseName->FileName,
&Name->FileName,
FALSE );
//
// This should never fail.
//
ASSERT( Status == STATUS_SUCCESS );
if (Name->VersionString.Length != 0) {
Status = RtlUpcaseUnicodeString( &UpcaseName->VersionString,
&Name->VersionString,
FALSE );
//
// This should never fail.
//
ASSERT( Status == STATUS_SUCCESS );
}
return;
}
VOID
CdInitializeEnumeration (
__in PIRP_CONTEXT IrpContext,
__in PIO_STACK_LOCATION IrpSp,
__in PFCB Fcb,
__inout PCCB Ccb,
__inout PFILE_ENUM_CONTEXT FileContext,
__out PBOOLEAN ReturnNextEntry,
__out PBOOLEAN ReturnSingleEntry,
__out PBOOLEAN InitialQuery
)
/*++
Routine Description:
This routine is called to initialize the enumeration variables and structures.
We look at the state of a previous enumeration from the Ccb as well as any
input values from the user. On exit we will position the FileContext at
a file in the directory and let the caller know whether this entry or the
next entry should be returned.
Arguments:
IrpSp - Irp stack location for this request.
Fcb - Fcb for this directory.
Ccb - Ccb for the directory handle.
FileContext - FileContext to use for this enumeration.
ReturnNextEntry - Address to store whether we should return the entry at
the FileContext position or the next entry.
ReturnSingleEntry - Address to store whether we should only return
a single entry.
InitialQuery - Address to store whether this is the first enumeration
query on this handle.
Return Value:
None.
--*/
{
NTSTATUS Status;
PUNICODE_STRING FileName;
CD_NAME WildCardName;
CD_NAME SearchExpression;
ULONG CcbFlags;
ULONG DirentOffset;
ULONG LastDirentOffset;
BOOLEAN KnownOffset;
BOOLEAN Found;
PAGED_CODE();
//
// If this is the initial query then build a search expression from the input
// file name.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_ENUM_INITIALIZED )) {
FileName = IrpSp->Parameters.QueryDirectory.FileName;
CcbFlags = 0;
//
// If the filename is not specified or is a single '*' then we will
// match all names.
//
if ((FileName == NULL) ||
(FileName->Buffer == NULL) ||
(FileName->Length == 0) ||
((FileName->Length == sizeof( WCHAR )) &&
(FileName->Buffer[0] == L'*'))) {
SetFlag( CcbFlags, CCB_FLAG_ENUM_MATCH_ALL );
RtlZeroMemory( &SearchExpression, sizeof( SearchExpression ));
//
// Otherwise build the CdName from the name in the stack location.
// This involves building both the name and version portions and
// checking for wild card characters. We also upcase the string if
// this is a case-insensitive search.
//
} else {
//
// Create a CdName to check for wild cards.
//
WildCardName.FileName = *FileName;
CdConvertNameToCdName( IrpContext, &WildCardName );
//
// The name better have at least one character.
//
if (WildCardName.FileName.Length == 0) {
CdRaiseStatus( IrpContext, STATUS_INVALID_PARAMETER );
}
//
// Check for wildcards in the separate components.
//
if (FsRtlDoesNameContainWildCards( &WildCardName.FileName)) {
SetFlag( CcbFlags, CCB_FLAG_ENUM_NAME_EXP_HAS_WILD );
}
if ((WildCardName.VersionString.Length != 0) &&
(FsRtlDoesNameContainWildCards( &WildCardName.VersionString ))) {
SetFlag( CcbFlags, CCB_FLAG_ENUM_VERSION_EXP_HAS_WILD );
//
// Check if this is a wild card only and match all version
// strings.
//
if ((WildCardName.VersionString.Length == sizeof( WCHAR )) &&
(WildCardName.VersionString.Buffer[0] == L'*')) {
SetFlag( CcbFlags, CCB_FLAG_ENUM_VERSION_MATCH_ALL );
}
}
//
// Now create the search expression to store in the Ccb.
//
SearchExpression.FileName.Buffer = FsRtlAllocatePoolWithTag( CdPagedPool,
FileName->Length,
TAG_ENUM_EXPRESSION );
SearchExpression.FileName.MaximumLength = FileName->Length;
//
// Either copy the name directly or perform the upcase.
//
if (FlagOn( Ccb->Flags, CCB_FLAG_IGNORE_CASE )) {
Status = RtlUpcaseUnicodeString( (PUNICODE_STRING) &SearchExpression.FileName,
FileName,
FALSE );
//
// This should never fail.
//
ASSERT( Status == STATUS_SUCCESS );
} else {
RtlCopyMemory( SearchExpression.FileName.Buffer,
FileName->Buffer,
FileName->Length );
}
//
// Now split into the separate name and version components.
//
SearchExpression.FileName.Length = WildCardName.FileName.Length;
SearchExpression.VersionString.Length = WildCardName.VersionString.Length;
SearchExpression.VersionString.MaximumLength = WildCardName.VersionString.MaximumLength;
SearchExpression.VersionString.Buffer = Add2Ptr( SearchExpression.FileName.Buffer,
SearchExpression.FileName.Length + sizeof( WCHAR ),
PWCHAR );
}
//
// But we do not want to return the constant "." and ".." entries for
// the root directory, for consistency with the rest of Microsoft's
// filesystems.
//
if (Fcb == Fcb->Vcb->RootIndexFcb) {
SetFlag( CcbFlags, CCB_FLAG_ENUM_NOMATCH_CONSTANT_ENTRY );
}
//
// Now lock the Fcb in order to update the Ccb with the inital
// enumeration values.
//
CdLockFcb( IrpContext, Fcb );
//
// Check again that this is the initial search.
//
if (!FlagOn( Ccb->Flags, CCB_FLAG_ENUM_INITIALIZED )) {
//
// Update the values in the Ccb.
//
Ccb->CurrentDirentOffset = Fcb->StreamOffset;
Ccb->SearchExpression = SearchExpression;
//
// Set the appropriate flags in the Ccb.
//
SetFlag( Ccb->Flags, CcbFlags | CCB_FLAG_ENUM_INITIALIZED );
//
// Otherwise cleanup any buffer allocated here.
//
} else {
if (!FlagOn( CcbFlags, CCB_FLAG_ENUM_MATCH_ALL )) {
CdFreePool( &SearchExpression.FileName.Buffer );
}
}
//
// Otherwise lock the Fcb so we can read the current enumeration values.
//
} else {
CdLockFcb( IrpContext, Fcb );
}
//
// Capture the current state of the enumeration.
//
// If the user specified an index then use his offset. We always
// return the next entry in this case.
//
if (FlagOn( IrpSp->Flags, SL_INDEX_SPECIFIED )) {
KnownOffset = FALSE;
DirentOffset = IrpSp->Parameters.QueryDirectory.FileIndex;
*ReturnNextEntry = TRUE;
//
// If we are restarting the scan then go from the self entry.
//
} else if (FlagOn( IrpSp->Flags, SL_RESTART_SCAN )) {
KnownOffset = TRUE;
DirentOffset = Fcb->StreamOffset;
*ReturnNextEntry = FALSE;
//
// Otherwise use the values from the Ccb.
//
} else {
KnownOffset = TRUE;
DirentOffset = Ccb->CurrentDirentOffset;
*ReturnNextEntry = BooleanFlagOn( Ccb->Flags, CCB_FLAG_ENUM_RETURN_NEXT );
}
//
// Unlock the Fcb.
//
CdUnlockFcb( IrpContext, Fcb );
//
// We have the starting offset in the directory and whether to return
// that entry or the next. If we are at the beginning of the directory
// and are returning that entry, then tell our caller this is the
// initial query.
//
*InitialQuery = FALSE;
if ((DirentOffset == Fcb->StreamOffset) &&
!(*ReturnNextEntry)) {
*InitialQuery = TRUE;
}
//
// If there is no file object then create it now.
//
CdVerifyOrCreateDirStreamFile( IrpContext, Fcb);
//
// Determine the offset in the stream to position the FileContext and
// whether this offset is known to be a file offset.
//
// If this offset is known to be safe then go ahead and position the
// file context. This handles the cases where the offset is the beginning
// of the stream, the offset is from a previous search or this is the
// initial query.
//
if (KnownOffset) {
CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, DirentOffset );
//
// Otherwise we walk through the directory from the beginning until
// we reach the entry which contains this offset.
//
} else {
LastDirentOffset = Fcb->StreamOffset;
Found = TRUE;
CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, LastDirentOffset );
//
// If the requested offset is prior to the beginning offset in the stream
// then don't return the next entry.
//
if (DirentOffset < LastDirentOffset) {
*ReturnNextEntry = FALSE;
//
// Else look for the last entry which ends past the desired index.
//
} else {
//
// Keep walking through the directory until we run out of
// entries or we find an entry which ends beyond the input
// index value.
//
do {
//
// If we have passed the index value then exit.
//
if (FileContext->InitialDirent->Dirent.DirentOffset > DirentOffset) {
Found = FALSE;
break;
}
//
// Remember the current position in case we need to go back.
//
LastDirentOffset = FileContext->InitialDirent->Dirent.DirentOffset;
//
// Exit if the next entry is beyond the desired index value.
//
if (LastDirentOffset + FileContext->InitialDirent->Dirent.DirentLength > DirentOffset) {
break;
}
Found = CdLookupNextInitialFileDirent( IrpContext, Fcb, FileContext );
} while (Found);
//
// If we didn't find the entry then go back to the last known entry.
// This can happen if the index lies in the unused range at the
// end of a sector.
//
if (!Found) {
CdCleanupFileContext( IrpContext, FileContext );
CdInitializeFileContext( IrpContext, FileContext );
CdLookupInitialFileDirent( IrpContext, Fcb, FileContext, LastDirentOffset );
}
}
}
//
// Only update the dirent name if we will need it for some reason.
// Don't update this name if we are returning the next entry and
// the search string has a version component.
//
FileContext->ShortName.FileName.Length = 0;
if (!(*ReturnNextEntry) ||
(Ccb->SearchExpression.VersionString.Length == 0)) {
//
// Update the name in the dirent into filename and version components.
//
CdUpdateDirentName( IrpContext,
&FileContext->InitialDirent->Dirent,
FlagOn( Ccb->Flags, CCB_FLAG_IGNORE_CASE ));
}
//
// Look at the flag in the IrpSp indicating whether to return just
// one entry.
//
*ReturnSingleEntry = FALSE;
if (FlagOn( IrpSp->Flags, SL_RETURN_SINGLE_ENTRY )) {
*ReturnSingleEntry = TRUE;
}
return;
}
