/*++ Copyright (c) 1993 Microsoft Corporation Module Name: dir.c Abstract: This module implements the file directory routines for the Netware Redirector. Author: Manny Weiser (mannyw) 4-Mar-1993 Revision History: --*/ #include "procs.h" // // Local debug trace level // #define Dbg (DEBUG_TRACE_DIRCTRL) NTSTATUS NwCommonDirectoryControl ( IN PIRP_CONTEXT pIrpContext ); NTSTATUS NwQueryDirectory ( IN PIRP_CONTEXT pIrpContext, IN PICB pIcb ); NTSTATUS GetNextFile( PIRP_CONTEXT pIrpContext, PICB Icb, PULONG fileIndexLow, PULONG fileIndexHigh, UCHAR SearchAttributes, PNW_DIRECTORY_INFO NwDirInfo ); NTSTATUS NtSearchMaskToNw( IN PUNICODE_STRING UcSearchMask, IN OUT POEM_STRING OemSearchMask, IN PICB Icb, IN BOOLEAN ShortNameSearch ); #if 0 VOID NwCancelFindNotify ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ); #endif #ifdef ALLOC_PRAGMA #pragma alloc_text( PAGE, NwFsdDirectoryControl ) #pragma alloc_text( PAGE, NwQueryDirectory ) #pragma alloc_text( PAGE, GetNextFile ) #pragma alloc_text( PAGE, NtSearchMaskToNw ) #ifndef QFE_BUILD #pragma alloc_text( PAGE1, NwCommonDirectoryControl ) #endif #endif #if 0 // Not pageable // see ifndef QFE_BUILD above #endif NTSTATUS NwFsdDirectoryControl ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine is the FSD routine that handles directory control functions (i.e., query and notify). Arguments: NwfsDeviceObject - Supplies the device object for the directory function. Irp - Supplies the IRP to process. Return Value: NTSTATUS - The result status. --*/ { PIRP_CONTEXT pIrpContext = NULL; NTSTATUS status; BOOLEAN TopLevel; PAGED_CODE(); DebugTrace(+1, Dbg, "NwFsdDirectoryControl\n", 0); // // Call the common directory control routine. // FsRtlEnterFileSystem(); TopLevel = NwIsIrpTopLevel( Irp ); try { pIrpContext = AllocateIrpContext( Irp ); status = NwCommonDirectoryControl( pIrpContext ); } except(NwExceptionFilter( Irp, GetExceptionInformation() )) { if ( pIrpContext == NULL ) { // // If we couldn't allocate an irp context, just complete // irp without any fanfare. // status = STATUS_INSUFFICIENT_RESOURCES; Irp->IoStatus.Status = status; Irp->IoStatus.Information = 0; IoCompleteRequest ( Irp, IO_NETWORK_INCREMENT ); } else { // // We had some trouble trying to perform the requested // operation, so we'll abort the I/O request with // the error status that we get back from the // execption code. // status = NwProcessException( pIrpContext, GetExceptionCode() ); } } if ( pIrpContext ) { NwCompleteRequest( pIrpContext, status ); } if ( TopLevel ) { NwSetTopLevelIrp( NULL ); } FsRtlExitFileSystem(); // // Return to the caller. // DebugTrace(-1, Dbg, "NwFsdDirectoryControl -> %08lx\n", status ); return status; } NTSTATUS NwCommonDirectoryControl ( IN PIRP_CONTEXT IrpContext ) /*++ Routine Description: This routine does the common code for directory control functions. Arguments: IrpContext - Supplies the request being processed. Return Value: NTSTATUS - The return status for the operation --*/ { NTSTATUS status; PIRP Irp; PIO_STACK_LOCATION irpSp; NODE_TYPE_CODE nodeTypeCode; PICB icb; PDCB dcb; PVOID fsContext; // // Get the current stack location // Irp = IrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( Irp ); DebugTrace(+1, Dbg, "CommonDirectoryControl...\n", 0); DebugTrace( 0, Dbg, "Irp = %08lx\n", (ULONG_PTR)Irp); // // Decode the file object to figure out who we are. If the result // is not an ICB then its an illegal parameter. // if ((nodeTypeCode = NwDecodeFileObject( irpSp->FileObject, &fsContext, (PVOID *)&icb )) != NW_NTC_ICB) { DebugTrace(0, Dbg, "Not a directory\n", 0); status = STATUS_INVALID_PARAMETER; DebugTrace(-1, Dbg, "CommonDirectoryControl -> %08lx\n", status ); return status; } dcb = (PDCB)icb->SuperType.Fcb; nodeTypeCode = dcb->NodeTypeCode; if ( nodeTypeCode != NW_NTC_DCB ) { DebugTrace(0, Dbg, "Not a directory\n", 0); status = STATUS_INVALID_PARAMETER; DebugTrace(-1, Dbg, "CommonDirectoryControl -> %08lx\n", status ); return status; } IrpContext->pScb = icb->SuperType.Fcb->Scb; IrpContext->pNpScb = IrpContext->pScb->pNpScb; IrpContext->Icb = icb; // // Acquire exclusive access to the DCB. Get to front of queue // first to avoid deadlock potential. // NwAppendToQueueAndWait( IrpContext ); NwAcquireExclusiveFcb( dcb->NonPagedFcb, TRUE ); try { NwVerifyIcb( icb ); // // We know this is a directory control so we'll case on the // minor function, and call the appropriate work routines. // switch (irpSp->MinorFunction) { case IRP_MN_QUERY_DIRECTORY: status = NwQueryDirectory( IrpContext, icb ); break; case IRP_MN_NOTIFY_CHANGE_DIRECTORY: #if 0 if ( !icb->FailedFindNotify ) { icb->FailedFindNotify = TRUE; #endif status = STATUS_NOT_SUPPORTED; #if 0 } else { // // HACKHACK // Cover for process that keeps trying to use // find notify even though we don't support it. // NwAcquireExclusiveRcb( &NwRcb, TRUE ); IoAcquireCancelSpinLock( &Irp->CancelIrql ); if ( Irp->Cancel ) { status = STATUS_CANCELLED; } else { InsertTailList( &FnList, &IrpContext->NextRequest ); IoMarkIrpPending( Irp ); IoSetCancelRoutine( Irp, NwCancelFindNotify ); status = STATUS_PENDING; } IoReleaseCancelSpinLock( Irp->CancelIrql ); NwReleaseRcb( &NwRcb ); } #endif break; default: // // For all other minor function codes we say they're invalid // and complete the request. // DebugTrace(0, Dbg, "Invalid FS Control Minor Function Code %08lx\n", irpSp->MinorFunction); status = STATUS_INVALID_DEVICE_REQUEST; break; } } finally { NwDequeueIrpContext( IrpContext, FALSE ); NwReleaseFcb( dcb->NonPagedFcb ); DebugTrace(-1, Dbg, "CommonDirectoryControl -> %08lx\n", status); } return status; } NTSTATUS NwQueryDirectory ( IN PIRP_CONTEXT pIrpContext, IN PICB Icb ) /*++ Routine Description: This is the work routine for querying a directory. Arugments: IrpContext - Supplies the Irp context information. Icb - Pointer the ICB for the request. Return Value: NTSTATUS - The return status for the operation. --*/ { NTSTATUS status = STATUS_SUCCESS; PIRP Irp; PIO_STACK_LOCATION irpSp; PUCHAR buffer; CLONG systemBufferLength; UNICODE_STRING searchMask; ULONG fileIndexLow; ULONG fileIndexHigh; FILE_INFORMATION_CLASS fileInformationClass; BOOLEAN restartScan; BOOLEAN returnSingleEntry; BOOLEAN indexSpecified; PVCB vcb; BOOLEAN ansiStringAllocated = FALSE; UCHAR SearchAttributes; BOOLEAN searchRetry; static WCHAR star[] = L"*"; BOOLEAN caseInsensitive = TRUE; //*** Make searches case insensitive ULONG lastEntry; ULONG nextEntry; ULONG totalBufferLength = 0; PFILE_BOTH_DIR_INFORMATION dirInfo; PFILE_NAMES_INFORMATION namesInfo; BOOLEAN canContinue = FALSE; BOOLEAN useCache = FALSE; BOOLEAN isSystem = FALSE; BOOLEAN lastIndexFromServer = FALSE; PNW_DIRECTORY_INFO dirCache; PLIST_ENTRY entry; ULONG i; PAGED_CODE(); // // Get the current stack location. // Irp = pIrpContext->pOriginalIrp; irpSp = IoGetCurrentIrpStackLocation( Irp ); vcb = Icb->SuperType.Fcb->Vcb; DebugTrace(+1, Dbg, "NwQueryDirectory\n", 0 ); DebugTrace( 0, Dbg, "Icb = %08lx\n", (ULONG_PTR)Icb); DebugTrace( 0, Dbg, "SystemBuffer = %08lx\n", (ULONG_PTR)Irp->AssociatedIrp.SystemBuffer); DebugTrace( 0, Dbg, "Length = %08lx\n", irpSp->Parameters.QueryDirectory.Length); DebugTrace( 0, Dbg, "Search Mask = %08lx\n", (ULONG_PTR)irpSp->Parameters.QueryDirectory.FileName); DebugTrace( 0, Dbg, "FileIndex = %08lx\n", irpSp->Parameters.QueryDirectory.FileIndex); DebugTrace( 0, Dbg, "FileInformationClass = %08lx\n", irpSp->Parameters.QueryDirectory.FileInformationClass); DebugTrace( 0, Dbg, "RestartScan = %08lx\n", BooleanFlagOn(irpSp->Flags, SL_RESTART_SCAN)); DebugTrace( 0, Dbg, "ReturnSingleEntry = %08lx\n", BooleanFlagOn(irpSp->Flags, SL_RETURN_SINGLE_ENTRY)); DebugTrace( 0, Dbg, "IndexSpecified = %08lx\n", BooleanFlagOn(irpSp->Flags, SL_INDEX_SPECIFIED)); // // Make local copies of the input parameters. // systemBufferLength = irpSp->Parameters.QueryDirectory.Length; restartScan = BooleanFlagOn(irpSp->Flags, SL_RESTART_SCAN); indexSpecified = BooleanFlagOn(irpSp->Flags, SL_INDEX_SPECIFIED); returnSingleEntry = BooleanFlagOn(irpSp->Flags, SL_RETURN_SINGLE_ENTRY); if (pIrpContext->pScb->UserUid.QuadPart != DefaultLuid.QuadPart) { fileIndexLow = 0; fileIndexHigh = 0; } else { // // Tell the gateway we do support resume from index so long // as the index returned is the same as the last file we // returned. Otherwise the SMB server does a brute force rewind // on each find next. // isSystem = TRUE; if( indexSpecified ) { fileIndexLow = irpSp->Parameters.QueryDirectory.FileIndex; } else { fileIndexLow = 0; } // // See if we can avoid a rewind. // if( fileIndexLow != 0 ) { if( fileIndexLow == Icb->SearchIndexLow ) { fileIndexHigh = Icb->SearchIndexHigh; canContinue = TRUE; } else { if( Icb->CacheHint ) { entry = Icb->CacheHint; searchRetry = TRUE; } else { entry = Icb->DirCache.Flink; searchRetry = FALSE; } do { if( entry == &(Icb->DirCache) ) { entry = Icb->DirCache.Flink; searchRetry = FALSE; } while( entry != &(Icb->DirCache) ) { dirCache = CONTAINING_RECORD( entry, NW_DIRECTORY_INFO, ListEntry ); if( dirCache->FileIndexLow == fileIndexLow ) { canContinue = TRUE; useCache = TRUE; Icb->CacheHint = entry->Flink; searchRetry = FALSE; break; } entry = entry->Flink; } } while( searchRetry ); } } } fileInformationClass = irpSp->Parameters.QueryDirectory.FileInformationClass; if (irpSp->Parameters.QueryDirectory.FileName != NULL) { searchMask = *(PUNICODE_STRING)irpSp->Parameters.QueryDirectory.FileName; } else { searchMask.Length = 0; searchMask.Buffer = NULL; } buffer = Irp->UserBuffer; DebugTrace(0, Dbg, "Users Buffer -> %08lx\n", buffer); // // It is ok to attempt a reconnect if this request fails with a // connection error. // SetFlag( pIrpContext->Flags, IRP_FLAG_RECONNECTABLE ); // // Check if the ICB already has a query template attached. If it // does not already have one then we either use the string we are // given or we attach our own containing "*" // if ( Icb->NwQueryTemplate.Buffer == NULL ) { // // This is our first time calling query directory so we need // to either set the query template to the user specified string // or to "*.*". // if ( searchMask.Buffer == NULL ) { DebugTrace(0, Dbg, "Set template to *", 0); searchMask.Length = sizeof( star ) - sizeof(WCHAR); searchMask.Buffer = star; } DebugTrace(0, Dbg, "Set query template -> %wZ\n", (ULONG_PTR)&searchMask); // // Map the NT search names to NCP. Note that this must be // done after the Unicode to OEM translation. // searchRetry = FALSE; do { status = NtSearchMaskToNw( &searchMask, &Icb->NwQueryTemplate, Icb, searchRetry ); if ( !NT_SUCCESS( status ) ) { DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", status); return( status ); } Icb->UQueryTemplate.Buffer = ALLOCATE_POOL( PagedPool, searchMask.Length ); if (Icb->UQueryTemplate.Buffer == NULL ) { DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", STATUS_INSUFFICIENT_RESOURCES ); return( STATUS_INSUFFICIENT_RESOURCES ); } Icb->UQueryTemplate.MaximumLength = searchMask.Length; RtlCopyUnicodeString( &Icb->UQueryTemplate, &searchMask ); // // Now send a Search Initialize NCP. // // Do a short search if the server doesn't support long names, // or this is a short-name non-wild card search // if ( !Icb->ShortNameSearch ) { status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "Lbb-DbC", NCP_LFN_SEARCH_INITIATE, vcb->Specific.Disk.LongNameSpace, vcb->Specific.Disk.VolumeNumber, vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, &Icb->SuperType.Fcb->RelativeFileName ); if ( NT_SUCCESS( status ) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nbee", &Icb->SearchVolume, &Icb->SearchIndexHigh, &Icb->SearchIndexLow ); } } else { status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "FbJ", NCP_SEARCH_INITIATE, vcb->Specific.Disk.Handle, &Icb->SuperType.Fcb->RelativeFileName ); if ( NT_SUCCESS( status ) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nbww-", &Icb->SearchVolume, &Icb->SearchHandle, &Icb->SearchIndexLow ); } } // // If we couldn't find the search path, and we did a long // name search initiate, try again with a short name. // if ( status == STATUS_OBJECT_PATH_NOT_FOUND && !Icb->ShortNameSearch ) { searchRetry = TRUE; if ( Icb->UQueryTemplate.Buffer != NULL ) { FREE_POOL( Icb->UQueryTemplate.Buffer ); } RtlFreeOemString ( &Icb->NwQueryTemplate ); } else { searchRetry = FALSE; } } while ( searchRetry ); if ( !NT_SUCCESS( status ) ) { if (status == STATUS_UNSUCCESSFUL) { DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", STATUS_NO_SUCH_FILE); return( STATUS_NO_SUCH_FILE ); } DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", status); return( status ); } // // Since we are doing a search we will need to send an End Of Job // for this PID. // NwSetEndOfJobRequired(pIrpContext->pNpScb, Icb->Pid ); fileIndexLow = Icb->SearchIndexLow; fileIndexHigh = Icb->SearchIndexHigh; // // We can't ask for both files and directories, so first ask for // files, then ask for directories. // SearchAttributes = NW_ATTRIBUTE_SYSTEM | NW_ATTRIBUTE_HIDDEN | NW_ATTRIBUTE_READ_ONLY; // // If there are no wildcards in the search mask, then setup to // not generate the . and .. entries. // if ( !FsRtlDoesNameContainWildCards( &Icb->UQueryTemplate ) ) { Icb->DotReturned = TRUE; Icb->DotDotReturned = TRUE; } else { Icb->DotReturned = FALSE; Icb->DotDotReturned = FALSE; } } else { // // Check if we were given an index to start with or if we need to // restart the scan or if we should use the index that was saved in // the ICB. // if (restartScan) { // // Make sure we don't use any cached directory info if this is // for a system account. // useCache = FALSE; if( isSystem ) { NwFreeDirCacheForIcb( Icb ); } fileIndexLow = (ULONG)-1; fileIndexHigh = Icb->SearchIndexHigh; // // Send a Search Initialize NCP. The server often times out search // handles and if this one has been sitting at the end of the // directory then its likely we would get no files at all! // // Do a short search if the server doesn't support long names, // or this is a short-name non-wild card search // if ( !Icb->ShortNameSearch ) { status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "Lbb-DbC", NCP_LFN_SEARCH_INITIATE, vcb->Specific.Disk.LongNameSpace, vcb->Specific.Disk.VolumeNumber, vcb->Specific.Disk.Handle, LFN_FLAG_SHORT_DIRECTORY, &Icb->SuperType.Fcb->RelativeFileName ); if ( NT_SUCCESS( status ) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nbee", &Icb->SearchVolume, &Icb->SearchIndexHigh, &Icb->SearchIndexLow ); } } else { status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "FbJ", NCP_SEARCH_INITIATE, vcb->Specific.Disk.Handle, &Icb->SuperType.Fcb->RelativeFileName ); if ( NT_SUCCESS( status ) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nbww-", &Icb->SearchVolume, &Icb->SearchHandle, &Icb->SearchIndexLow ); } } Icb->ReturnedSomething = FALSE; // // We can't ask for both files and directories, so first ask for // files, then ask for directories. // SearchAttributes = NW_ATTRIBUTE_SYSTEM | NW_ATTRIBUTE_HIDDEN | NW_ATTRIBUTE_READ_ONLY; Icb->SearchAttributes = SearchAttributes; Icb->DotReturned = FALSE; Icb->DotDotReturned = FALSE; } else if ((!indexSpecified) || (canContinue) ) { // // Continue from the one of the last filenames. If an index is specified then its // only allowed for the gateway (and other system services). // SearchAttributes = Icb->SearchAttributes; if( !indexSpecified ) { // // We need to check to see if this is the sytem or not. If it // is, we need to continue from the last entry returned which may // be from the cache. // if( isSystem && Icb->CacheHint ) { entry = Icb->CacheHint; dirCache = CONTAINING_RECORD( entry, NW_DIRECTORY_INFO, ListEntry ); useCache = TRUE; } else { useCache = FALSE; fileIndexLow = Icb->SearchIndexLow; fileIndexHigh = Icb->SearchIndexHigh; } } if ( SearchAttributes == 0xFF && fileIndexLow == Icb->SearchIndexLow ) { // // This is a completed search. // DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", STATUS_NO_MORE_FILES); return( STATUS_NO_MORE_FILES ); } } else { // // SVR to avoid rescanning from end of dir all // the way through the directory again. // if ((Icb->SearchIndexLow == -1) && (Icb->LastSearchIndexLow == fileIndexLow) && (pIrpContext->pScb->UserUid.QuadPart == DefaultLuid.QuadPart) && (Icb->SearchAttributes == 0xFF )) { DebugTrace(-1, Dbg, "NwQueryDirectory SVR exit-> %08lx\n", STATUS_NO_MORE_FILES); return( STATUS_NO_MORE_FILES ); } // SVR end // // Someone's trying to do a resume from key. The netware // server doesn't support this, so neither do we. // DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", STATUS_NOT_IMPLEMENTED); return( STATUS_NOT_IMPLEMENTED ); } } // // Now we are committed to completing the Irp, we do that in // the finally clause of the following try. // try { ULONG baseLength; ULONG lengthAdded; PNW_DIRECTORY_INFO nwDirInfo; ULONG FileNameLength; ULONG entriesToCreate; 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 FileNamesInformation: baseLength = FIELD_OFFSET( FILE_NAMES_INFORMATION, FileName[0] ); break; case FileBothDirectoryInformation: baseLength = FIELD_OFFSET( FILE_BOTH_DIR_INFORMATION, FileName[0] ); break; default: try_return( status = STATUS_INVALID_INFO_CLASS ); } // // It is not ok to attempt a reconnect if this request fails with a // connection error, since our search handle would be invalid. // ClearFlag( pIrpContext->Flags, IRP_FLAG_RECONNECTABLE ); // // See if we have a dir cache. If not, create one. // if( !Icb->DirCacheBuffer ) { if( isSystem ) { entriesToCreate = DirCacheEntries; } else { entriesToCreate = 1; } Icb->DirCacheBuffer = ALLOCATE_POOL ( PagedPool, (sizeof(NW_DIRECTORY_INFO) * entriesToCreate) ); if( !Icb->DirCacheBuffer ) { try_return( status = STATUS_NO_MEMORY ); } RtlZeroMemory( Icb->DirCacheBuffer, sizeof(NW_DIRECTORY_INFO) * entriesToCreate ); dirCache = (PNW_DIRECTORY_INFO)Icb->DirCacheBuffer; for( i = 0; i < entriesToCreate; i++ ) { InsertTailList( &(Icb->DirCache), &(dirCache->ListEntry) ); dirCache++; } } while ( TRUE ) { ULONG bytesToCopy; ULONG bytesRemainingInBuffer; DebugTrace(0, Dbg, "Top of Loop\n", 0); DebugTrace(0, Dbg, "CurrentIndex = %08lx\n", fileIndexLow); DebugTrace(0, Dbg, "LastEntry = %08lx\n", lastEntry); DebugTrace(0, Dbg, "NextEntry = %08lx\n", nextEntry); if( useCache ) { // // We need to use the data out of the entry we found in the cache. // dirCache points to the entry that matches, and the request was not // for the last file we read, so the entry after dirCache is the one // we want. // DebugTrace(0, Dbg, "Using cache\n", 0); entry = dirCache->ListEntry.Flink; dirCache = CONTAINING_RECORD( entry, NW_DIRECTORY_INFO, ListEntry ); nwDirInfo = dirCache; fileIndexLow = nwDirInfo->FileIndexLow; fileIndexHigh = nwDirInfo->FileIndexHigh; status = nwDirInfo->Status; // // Check to see if we should still keep using the cache or not. // if( entry->Flink == &(Icb->DirCache) ) { // // This is the last entry. We need to stop using the cache. // useCache = FALSE; Icb->CacheHint = NULL; } else { Icb->CacheHint = entry; } } else { // // Pull an entry from the dir cache. // entry = RemoveHeadList( &(Icb->DirCache) ); nwDirInfo = CONTAINING_RECORD( entry, NW_DIRECTORY_INFO, ListEntry ); nwDirInfo->FileName.Buffer = nwDirInfo->FileNameBuffer; nwDirInfo->FileName.MaximumLength = NW_MAX_FILENAME_SIZE; status = GetNextFile( pIrpContext, Icb, &fileIndexLow, &fileIndexHigh, SearchAttributes, nwDirInfo ); // // Store the return and the file index number, // and then put this entry in the cache. // nwDirInfo->FileIndexLow = fileIndexLow; nwDirInfo->FileIndexHigh = fileIndexHigh; nwDirInfo->Status = status; InsertTailList( &(Icb->DirCache), &(nwDirInfo->ListEntry) ); lastIndexFromServer = TRUE; // SVR to avoid rescanning from end of dir all if (fileIndexLow != -1) { Icb->LastSearchIndexLow = fileIndexLow; } // SVR end } if ( NT_SUCCESS( status ) ) { DebugTrace(0, Dbg, "DirFileName = %wZ\n", &nwDirInfo->FileName); DebugTrace(0, Dbg, "FileIndexLow = %08lx\n", fileIndexLow); FileNameLength = nwDirInfo->FileName.Length; bytesRemainingInBuffer = systemBufferLength - nextEntry; ASSERT( bytesRemainingInBuffer >= baseLength ); if (IsTerminalServer() && (LONG)NW_MAX_FILENAME_SIZE < FileNameLength ) try_return( status = STATUS_BUFFER_OVERFLOW ); // // See how much of the name we will be able to copy into // the system buffer. This also dictates our return // value. // if ( baseLength + FileNameLength <= bytesRemainingInBuffer ) { bytesToCopy = FileNameLength; status = STATUS_SUCCESS; } else { if (IsTerminalServer()) { try_return( status = STATUS_BUFFER_OVERFLOW ); } bytesToCopy = bytesRemainingInBuffer - baseLength; status = STATUS_BUFFER_OVERFLOW; } // // Note how much of buffer we are consuming and zero // the base part of the structure. // lengthAdded = baseLength + bytesToCopy; RtlZeroMemory( &buffer[nextEntry], baseLength ); switch (fileInformationClass) { case FileBothDirectoryInformation: // // Fill in the short name, if this is a LFN volume. // DebugTrace(0, Dbg, "Getting directory both information\n", 0); if (!DisableAltFileName) { if ( nwDirInfo->DosDirectoryEntry != 0xFFFF && !IsFatNameValid( &nwDirInfo->FileName ) ) { UNICODE_STRING ShortName; status = ExchangeWithWait ( pIrpContext, SynchronousResponseCallback, "SbDb", NCP_DIR_FUNCTION, NCP_GET_SHORT_NAME, Icb->SearchVolume, nwDirInfo->DosDirectoryEntry, 0 ); if ( NT_SUCCESS( status ) ) { dirInfo = (PFILE_BOTH_DIR_INFORMATION)&buffer[nextEntry]; // // Short name is in form 8.3 plus nul terminator. // ShortName.MaximumLength = 13 * sizeof(WCHAR) ; ShortName.Buffer = dirInfo->ShortName; status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "N_P", 15, &ShortName ); if ( NT_SUCCESS( status ) ) { dirInfo->ShortNameLength = (CCHAR)ShortName.Length; } } } } case FileFullDirectoryInformation: // // We don't use EaLength, so fill in nothing here. // DebugTrace(0, Dbg, "Getting directory full information\n", 0); case FileDirectoryInformation: DebugTrace(0, Dbg, "Getting directory information\n", 0); // // The eof indicates the number of instances and // allocation size is the maximum allowed // dirInfo = (PFILE_BOTH_DIR_INFORMATION)&buffer[nextEntry]; dirInfo->FileAttributes = nwDirInfo->Attributes; dirInfo->FileNameLength = bytesToCopy; dirInfo->EndOfFile.LowPart = nwDirInfo->FileSize; dirInfo->EndOfFile.HighPart = 0; dirInfo->AllocationSize = dirInfo->EndOfFile; dirInfo->CreationTime = NwDateTimeToNtTime( nwDirInfo->CreationDate, nwDirInfo->CreationTime ); dirInfo->LastAccessTime = NwDateTimeToNtTime( nwDirInfo->LastAccessDate, 0 ); dirInfo->LastWriteTime = NwDateTimeToNtTime( nwDirInfo->LastUpdateDate, nwDirInfo->LastUpdateTime ); dirInfo->ChangeTime = dirInfo->LastWriteTime; if (pIrpContext->pScb->UserUid.QuadPart != DefaultLuid.QuadPart) { dirInfo->FileIndex = 0; } else { dirInfo->FileIndex = fileIndexLow; } break; case FileNamesInformation: DebugTrace(0, Dbg, "Getting names information\n", 0); namesInfo = (PFILE_NAMES_INFORMATION)&buffer[nextEntry]; namesInfo->FileNameLength = FileNameLength; if (pIrpContext->pScb->UserUid.QuadPart != DefaultLuid.QuadPart) { namesInfo->FileIndex = 0; } else { namesInfo->FileIndex = fileIndexLow; } break; default: KeBugCheck( RDR_FILE_SYSTEM ); } // Mapping for Novell's handling of Euro char in file names { int i = 0; WCHAR * pCurrChar = nwDirInfo->FileName.Buffer; for (i = 0; i < (nwDirInfo->FileName.Length / 2); i++) { if (*(pCurrChar + i) == (WCHAR) 0x2560) // Its Novell's mapping of a Euro *(pCurrChar + i) = (WCHAR) 0x20AC; // set it to Euro } } RtlMoveMemory( &buffer[nextEntry + baseLength], nwDirInfo->FileName.Buffer, bytesToCopy ); dump( Dbg, &buffer[nextEntry], lengthAdded); // // Setup the previous next entry offset. // *((PULONG)(&buffer[lastEntry])) = nextEntry - lastEntry; totalBufferLength = nextEntry + lengthAdded; // // Set ourselves up for the next iteration // lastEntry = nextEntry; nextEntry += (ULONG)QuadAlign( lengthAdded ); // // Check if the last entry didn't completely fit // if ( status == STATUS_BUFFER_OVERFLOW ) { try_return( NOTHING ); } // // Check if we are only to return a single entry // if (returnSingleEntry) { try_return( status = STATUS_SUCCESS ); } } else { // // The search response contained an error. If we have // not yet enumerated directories, do them now. Otherwise, // we are done searching for files. // if ( status == STATUS_UNSUCCESSFUL && (!FlagOn(SearchAttributes, NW_ATTRIBUTE_DIRECTORY) || useCache) ) { SetFlag( SearchAttributes, NW_ATTRIBUTE_DIRECTORY ); fileIndexLow = (ULONG)-1; continue; } else { // // Remember that this is a completed search and // quit the loop. // SearchAttributes = 0xFF; break; } } // // 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. // // Since we cannot rewind a search, we'll guess that the // next entry is a full length name. If it mightn't fix, // just bail and re the files we've got. // bytesRemainingInBuffer = systemBufferLength - nextEntry; if ( baseLength + NW_MAX_FILENAME_SIZE > bytesRemainingInBuffer ) { DebugTrace(0, Dbg, "Next entry won't fit\n", 0); try_return( status = STATUS_SUCCESS ); } } // while ( TRUE ) try_exit: NOTHING; } finally { // // At this point we're finished searching for files. // If the NextEntry is zero then we haven't found anything so we // will return no more files or no such file. // if ( status == STATUS_NO_MORE_FILES || status == STATUS_UNSUCCESSFUL || status == STATUS_SUCCESS ) { if (nextEntry == 0) { if (Icb->ReturnedSomething) { status = STATUS_NO_MORE_FILES; } else { status = STATUS_NO_SUCH_FILE; } } else { Icb->ReturnedSomething = TRUE; status = STATUS_SUCCESS; } } // // Indicate how much of the system buffer we have used up. // Irp->IoStatus.Information = totalBufferLength; // // Remember the last file index, so that we can resume this // search. // // // Update the last search index read as long as it didn't come from cache. // if( lastIndexFromServer ) { Icb->SearchIndexLow = fileIndexLow; Icb->SearchIndexHigh = fileIndexHigh; } Icb->SearchAttributes = SearchAttributes; DebugTrace(-1, Dbg, "NwQueryDirectory -> %08lx\n", status); } return status; } NTSTATUS GetNextFile( PIRP_CONTEXT pIrpContext, PICB Icb, PULONG FileIndexLow, PULONG FileIndexHigh, UCHAR SearchAttributes, PNW_DIRECTORY_INFO DirInfo ) /*++ Routine Description: Get the next file in the directory being searched. Arguments: pIrpContext - Supplies the request being processed. Icb - A pointer to the ICB for the directory to query. FileIndexLow, FileIndexHigh - On entry, the the index of the previous directory entry. On exit, the index to the directory entry returned. SearchAttributes - Search attributes to use. DirInfo - Returns information for the directory entry found. Return Value: NTSTATUS - The result status. --*/ { NTSTATUS status; PVCB vcb; static UNICODE_STRING DotFile = { 2, 2, L"." }; static UNICODE_STRING DotDotFile = { 4, 4, L".." }; PAGED_CODE(); DirInfo->DosDirectoryEntry = 0xFFFF; if ( !Icb->DotReturned ) { Icb->DotReturned = TRUE; // // Return '.' only if it we are not searching in the root directory // and it matches the search pattern. // if ( Icb->SuperType.Fcb->RelativeFileName.Length != 0 && FsRtlIsNameInExpression( &Icb->UQueryTemplate, &DotFile, TRUE, NULL ) ) { RtlCopyUnicodeString( &DirInfo->FileName, &DotFile ); DirInfo->Attributes = FILE_ATTRIBUTE_DIRECTORY; DirInfo->FileSize = 0; DirInfo->CreationDate = DEFAULT_DATE; DirInfo->LastAccessDate = DEFAULT_DATE; DirInfo->LastUpdateDate = DEFAULT_DATE; DirInfo->LastUpdateTime = DEFAULT_TIME; DirInfo->CreationTime = DEFAULT_TIME; return( STATUS_SUCCESS ); } } if ( !Icb->DotDotReturned ) { Icb->DotDotReturned = TRUE; // // Return '..' only if it we are not searching in the root directory // and it matches the search pattern. // if ( Icb->SuperType.Fcb->RelativeFileName.Length != 0 && FsRtlIsNameInExpression( &Icb->UQueryTemplate, &DotDotFile, TRUE, NULL ) ) { RtlCopyUnicodeString( &DirInfo->FileName, &DotDotFile ); DirInfo->Attributes = FILE_ATTRIBUTE_DIRECTORY; DirInfo->FileSize = 0; DirInfo->CreationDate = DEFAULT_DATE; DirInfo->LastAccessDate = DEFAULT_DATE; DirInfo->LastUpdateDate = DEFAULT_DATE; DirInfo->LastUpdateTime = DEFAULT_TIME; DirInfo->CreationTime = DEFAULT_TIME; return( STATUS_SUCCESS ); } } vcb = Icb->SuperType.Fcb->Vcb; if ( Icb->ShortNameSearch ) { status = ExchangeWithWait( pIrpContext, SynchronousResponseCallback, "Fbwwbp", NCP_SEARCH_CONTINUE, Icb->SearchVolume, Icb->SearchHandle, *(PUSHORT)FileIndexLow, SearchAttributes, Icb->NwQueryTemplate.Buffer ); if ( !NT_SUCCESS( status )) { return status; } *FileIndexLow = 0; *FileIndexHigh = 0; if ( FlagOn(SearchAttributes, NW_ATTRIBUTE_DIRECTORY) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nw=Rb-ww", FileIndexLow, &DirInfo->FileName, 14, &DirInfo->Attributes, &DirInfo->CreationDate, &DirInfo->CreationTime ); #if 0 if ( DirInfo->CreationDate == 0 && DirInfo->CreationTime == 0 ) { DirInfo->CreationDate = DEFAULT_DATE; DirInfo->CreationTime = DEFAULT_TIME; } #endif DirInfo->FileSize = 0; DirInfo->LastAccessDate = DirInfo->CreationDate; DirInfo->LastUpdateDate = DirInfo->CreationDate; DirInfo->LastUpdateTime = DirInfo->CreationTime; } else { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "Nw=Rb-dwwww", FileIndexLow, &DirInfo->FileName, 14, &DirInfo->Attributes, &DirInfo->FileSize, &DirInfo->CreationDate, &DirInfo->LastAccessDate, &DirInfo->LastUpdateDate, &DirInfo->LastUpdateTime ); DirInfo->CreationTime = DEFAULT_TIME; } } else { status = ExchangeWithWait ( pIrpContext, SynchronousResponseCallback, "LbbWDbDDp", NCP_LFN_SEARCH_CONTINUE, vcb->Specific.Disk.LongNameSpace, 0, // Data stream SearchAttributes & SEARCH_ALL_DIRECTORIES, LFN_FLAG_INFO_ATTRIBUTES | LFN_FLAG_INFO_FILE_SIZE | LFN_FLAG_INFO_MODIFY_TIME | LFN_FLAG_INFO_CREATION_TIME | LFN_FLAG_INFO_DIR_INFO | LFN_FLAG_INFO_NAME, vcb->Specific.Disk.VolumeNumber, *FileIndexHigh, *FileIndexLow, Icb->NwQueryTemplate.Buffer ); if ( NT_SUCCESS( status ) ) { status = ParseResponse( pIrpContext, pIrpContext->rsp, pIrpContext->ResponseLength, "N-ee_e_e_xx_xx_x_e_P", FileIndexHigh, FileIndexLow, 5, &DirInfo->Attributes, 2, &DirInfo->FileSize, 6, &DirInfo->CreationTime, &DirInfo->CreationDate, 4, &DirInfo->LastUpdateTime, &DirInfo->LastUpdateDate, 4, &DirInfo->LastAccessDate, 14, &DirInfo->DosDirectoryEntry, 20, &DirInfo->FileName ); } if ( FlagOn(SearchAttributes, NW_ATTRIBUTE_DIRECTORY) ) { DirInfo->FileSize = 0; } } if ( DirInfo->Attributes == 0 ) { DirInfo->Attributes = FILE_ATTRIBUTE_NORMAL; } return status; } NTSTATUS NtSearchMaskToNw( IN PUNICODE_STRING UcSearchMask, IN OUT POEM_STRING OemSearchMask, IN PICB Icb, IN BOOLEAN ShortNameSearch ) /*++ Routine Description: This routine maps a netware path name to the correct netware format. Arguments: UcSearchMask - The search mask in NT format. OemSearchMask - The search mask in Netware format. Icb - The ICB of the directory in which we are searching. ShortNameSearch - If TRUE, always do a short name search. Return Value: NTSTATUS - The result status. --*/ { USHORT i; NTSTATUS status; PAGED_CODE(); // // Use a short name search if the volume does not support long names. // or this is a short name ICB, and we are doing a short name, non // wild-card search. // if ( Icb->SuperType.Fcb->Vcb->Specific.Disk.LongNameSpace == LFN_NO_OS2_NAME_SPACE || ShortNameSearch || ( !BooleanFlagOn( Icb->SuperType.Fcb->Flags, FCB_FLAGS_LONG_NAME ) && !FsRtlDoesNameContainWildCards( UcSearchMask ) && IsFatNameValid( UcSearchMask ) ) ) { Icb->ShortNameSearch = TRUE; // Mapping for Novell's handling of Euro char in file names { int i = 0; WCHAR * pCurrChar = UcSearchMask->Buffer; for (i = 0; i < (UcSearchMask->Length / 2); i++) { if (*(pCurrChar + i) == (WCHAR) 0x20AC) // Its a Euro *(pCurrChar + i) = (WCHAR) 0x2560; // set it to Novell's mapping for Euro } } // // Allocate space for and initialize the query templates. // status = RtlUpcaseUnicodeStringToOemString( OemSearchMask, UcSearchMask, TRUE ); if ( !NT_SUCCESS( status ) ) { return( status ); } // // Special case. Map '*.*' to '*'. // if ( OemSearchMask->Length == 3 && RtlCompareMemory( OemSearchMask->Buffer, "*.*", 3 ) == 3 ) { OemSearchMask->Length = 1; OemSearchMask->Buffer[1] = '\0'; } else { for ( i = 0; i < OemSearchMask->Length ; i++ ) { // // In fact Novell server seems to convert all 0xBF, 0xAA, 0xAE // even if they are DBCS lead or trail byte. // We can't single out DBCS case in the conversion. // if( FsRtlIsLeadDbcsCharacter( OemSearchMask->Buffer[i] ) ) { if((UCHAR)(OemSearchMask->Buffer[i]) == 0xBF ) { OemSearchMask->Buffer[i] = (UCHAR)( 0x10 ); }else if((UCHAR)(OemSearchMask->Buffer[i]) == 0xAE ) { OemSearchMask->Buffer[i] = (UCHAR)( 0x11 ); }else if((UCHAR)(OemSearchMask->Buffer[i]) == 0xAA ) { OemSearchMask->Buffer[i] = (UCHAR)( 0x12 ); } i++; if((UCHAR)(OemSearchMask->Buffer[i]) == 0x5C ) { // // The trailbyte is 0x5C, replace it with 0x13 // OemSearchMask->Buffer[i] = (UCHAR)( 0x13 ); } // // Continue to check other conversions for trailbyte. // } // Single byte character that may need modification. switch ( (UCHAR)(OemSearchMask->Buffer[i]) ) { case ANSI_DOS_STAR: OemSearchMask->Buffer[i] = (UCHAR)( 0x80 | '*' ); break; case ANSI_DOS_QM: OemSearchMask->Buffer[i] = (UCHAR)( 0x80 | '?' ); break; case ANSI_DOS_DOT: OemSearchMask->Buffer[i] = (UCHAR)( 0x80 | '.' ); break; // // Netware Japanese version The following character is // replaced with another one if the string is for File // Name only when sendding from Client to Server. // // SO U+0xFF7F SJIS+0xBF -> 0x10 // SMALL_YO U+0xFF6E SJIS+0xAE -> 0x11 // SMALL_E U+0xFF64 SJIS+0xAA -> 0x12 // // The reason is unknown, Should ask Novell Japan. // // See Also exchange.c case 0xBF: // ANSI_DOS_KATAKANA_SO: if (Japan) { OemSearchMask->Buffer[i] = (UCHAR)( 0x10 ); } break; case 0xAE: // ANSI_DOS_KATAKANA_SMALL_YO: if (Japan) { OemSearchMask->Buffer[i] = (UCHAR)( 0x11 ); } break; case 0xAA: // ANSI_DOS_KATAKANA_SMALL_E: if (Japan) { OemSearchMask->Buffer[i] = (UCHAR)( 0x12 ); } break; } } } } else { USHORT size; PCHAR buffer; UNICODE_STRING src; OEM_STRING dest; Icb->ShortNameSearch = FALSE; // // Allocate space for and initialize the query templates. // We allocate an extra byte to account for the null terminator. // #ifndef QFE_BUILD buffer = ExAllocatePoolWithTag( PagedPool, (UcSearchMask->Length) + 1, 'scwn' ); #else buffer = ExAllocatePool( PagedPool, (UcSearchMask->Length) + 1 ); #endif if ( buffer == NULL ) { return( STATUS_INSUFFICIENT_RESOURCES ); } OemSearchMask->Buffer = buffer; // // Special case. Map '????????.???' to '*'. // if ( UcSearchMask->Length == 24 && RtlCompareMemory( UcSearchMask->Buffer, L">>>>>>>>\">>>", 24 ) == 24 ) { OemSearchMask->Length = 3; OemSearchMask->Buffer[0] = (UCHAR)0xFF; OemSearchMask->Buffer[1] = '*'; OemSearchMask->Buffer[2] = '\0'; return STATUS_SUCCESS; } // // Now convert the string, character by character // src.Buffer = UcSearchMask->Buffer; src.Length = 2; dest.Buffer = buffer; dest.MaximumLength = UcSearchMask->Length; size = UcSearchMask->Length / 2; for ( i = 0; i < size ; i++ ) { switch ( *src.Buffer ) { case L'*': case L'?': *dest.Buffer++ = LFN_META_CHARACTER; *dest.Buffer++ = (UCHAR)*src.Buffer++; break; case L'.': *dest.Buffer++ = (UCHAR)*src.Buffer++; break; case DOS_DOT: *dest.Buffer++ = LFN_META_CHARACTER; *dest.Buffer++ = (UCHAR)( 0x80 | '.' ); *src.Buffer++; break; case DOS_STAR: *dest.Buffer++ = LFN_META_CHARACTER; *dest.Buffer++ = (UCHAR)( 0x80 | '*' ); *src.Buffer++; break; case DOS_QM: *dest.Buffer++ = LFN_META_CHARACTER; *dest.Buffer++ = (UCHAR)( 0x80 | '?' ); *src.Buffer++; break; case 0x20AC: // Euro *src.Buffer = (WCHAR)0x2560; // change it to Novell's mapping // intentional fall-through to get it mapped to OEM default: RtlUnicodeStringToCountedOemString( &dest, &src, FALSE ); if( FsRtlIsLeadDbcsCharacter( dest.Buffer[0] ) ) { dest.Buffer++; } dest.Buffer++; src.Buffer++; } } *dest.Buffer = '\0'; OemSearchMask->Length = (USHORT)( dest.Buffer - buffer ); } return STATUS_SUCCESS; } #if 0 VOID NwCancelFindNotify ( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) /*++ Routine Description: This routine implements the cancel function for an find notify IRP. Arguments: DeviceObject - ignored Irp - Supplies the Irp being cancelled. Return Value: None. --*/ { PLIST_ENTRY listEntry; UNREFERENCED_PARAMETER( DeviceObject ); // // We now need to void the cancel routine and release the io cancel // spin-lock. // IoSetCancelRoutine( Irp, NULL ); IoReleaseCancelSpinLock( Irp->CancelIrql ); NwAcquireExclusiveRcb( &NwRcb, TRUE ); for ( listEntry = FnList.Flink; listEntry != &FnList ; listEntry = listEntry->Flink ) { PIRP_CONTEXT IrpContext; IrpContext = CONTAINING_RECORD( listEntry, IRP_CONTEXT, NextRequest ); if ( IrpContext->pOriginalIrp == Irp ) { RemoveEntryList( &IrpContext->NextRequest ); NwCompleteRequest( IrpContext, STATUS_CANCELLED ); break; } } NwReleaseRcb( &NwRcb ); } #endif