public static FileInformation GetFileInformation(byte[] buffer, int offset, FileInformationClass informationClass)
{
return(informationClass switch
{
FileInformationClass.FileBasicInformation => new FileBasicInformation(buffer, offset),
FileInformationClass.FileStandardInformation => new FileStandardInformation(buffer, offset),
FileInformationClass.FileInternalInformation => new FileInternalInformation(buffer, offset),
FileInformationClass.FileEaInformation => new FileEaInformation(buffer, offset),
FileInformationClass.FileAccessInformation => new FileAccessInformation(buffer, offset),
FileInformationClass.FileRenameInformation => new FileRenameInformationType2(buffer, offset),
FileInformationClass.FileLinkInformation => new FileLinkInformationType2(buffer, offset),
FileInformationClass.FileNamesInformation => throw new NotImplementedException(),
FileInformationClass.FileDispositionInformation => new FileDispositionInformation(buffer, offset),
FileInformationClass.FilePositionInformation => new FilePositionInformation(buffer, offset),
FileInformationClass.FileFullEaInformation => new FileFullEAInformation(buffer, offset),
FileInformationClass.FileModeInformation => new FileModeInformation(buffer, offset),
FileInformationClass.FileAlignmentInformation => new FileAlignmentInformation(buffer, offset),
FileInformationClass.FileAllInformation => new FileAllInformation(buffer, offset),
FileInformationClass.FileAllocationInformation => new FileAllocationInformation(buffer, offset),
FileInformationClass.FileEndOfFileInformation => new FileEndOfFileInformation(buffer, offset),
FileInformationClass.FileAlternateNameInformation => new FileAlternateNameInformation(buffer, offset),
FileInformationClass.FileStreamInformation => new FileStreamInformation(buffer, offset),
FileInformationClass.FilePipeInformation => throw new NotImplementedException(),
FileInformationClass.FilePipeLocalInformation => throw new NotImplementedException(),
FileInformationClass.FilePipeRemoteInformation => throw new NotImplementedException(),
FileInformationClass.FileCompressionInformation => new FileCompressionInformation(buffer, offset),
FileInformationClass.FileNetworkOpenInformation => new FileNetworkOpenInformation(buffer, offset),
FileInformationClass.FileAttributeTagInformation => throw new NotImplementedException(),
FileInformationClass.FileValidDataLengthInformation => new FileValidDataLengthInformation(buffer,
offset),
FileInformationClass.FileShortNameInformation => throw new NotImplementedException(),
_ => throw new UnsupportedInformationLevelException()
});
private NtStatus NtQueryInformationFileImpl(IntPtr hfile, out IO_STATUS_BLOCK ioStatusBlock, void *fileInformation,
uint length, FileInformationClass fileInformationClass)
{
#if DEBUG
try
{
#endif
foreach (var filter in _filters)
{
if (filter.Accept(hfile))
{
return(filter.NtQueryInformationFileImpl(hfile, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
#if DEBUG
}
catch (Exception e)
{
_logger.WriteLine($"[{nameof(modloader)}:{nameof(FileAccessServer)}] {nameof(CloseHandleImpl)} Exception Thrown: {e.Message}\nStack Trace: {e.StackTrace}");
}
#endif
return(_hooks.NtQueryInformationFileHook.OriginalFunction(hfile, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
public static extern NtStatus NtSetInformationFile(
SafeKernelObjectHandle FileHandle,
[Out] IoStatus IoStatusBlock,
SafeBuffer FileInformation,
int Length,
FileInformationClass FileInformationClass
);
/// <exception cref="SmbLibraryStd.UnsupportedInformationLevelException"></exception>
public static QueryInformationLevel ToFileInformationLevel(FileInformationClass informationClass)
{
switch (informationClass)
{
case FileInformationClass.FileBasicInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_BASIC_INFO);
case FileInformationClass.FileStandardInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_STANDARD_INFO);
case FileInformationClass.FileEaInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_EA_INFO);
case FileInformationClass.FileNameInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_NAME_INFO);
case FileInformationClass.FileAllInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_ALL_INFO);
case FileInformationClass.FileAlternateNameInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_ALT_NAME_INFO);
case FileInformationClass.FileStreamInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_STREAM_INFO);
case FileInformationClass.FileCompressionInformation:
return(QueryInformationLevel.SMB_QUERY_FILE_COMPRESSION_INFO);
default:
throw new UnsupportedInformationLevelException();
}
}
private NtStatus NtSetInformationFileImpl(IntPtr handle, out IO_STATUS_BLOCK ioStatusBlock, void *fileInformation,
uint length, FileInformationClass fileInformationClass)
{
#if DEBUG
try
{
#endif
if (fileInformationClass == FileInformationClass.FilePositionInformation && _handleToInfoMap.ContainsKey(handle))
{
_handleToInfoMap[handle].FilePointer = *(long *)fileInformation;
}
foreach (var filter in _filters)
{
if (filter.Accept(handle))
{
return(filter.NtSetInformationFileImpl(handle, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
#if DEBUG
}
catch (Exception e)
{
_logger.WriteLine($"[{nameof(modloader)}:{nameof(FileAccessServer)}] {nameof(NtSetInformationFileImpl)} Exception Thrown: {e.Message}\nStack Trace: {e.StackTrace}");
}
#endif
return(_hooks.NtSetInformationFileHook.OriginalFunction(handle, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
public List <QueryDirectoryFileInformation> GetFileInformationList(FileInformationClass fileInformationClass)
{
if (OutputBuffer.Length > 0)
{
return(QueryDirectoryFileInformation.ReadFileInformationList(OutputBuffer, 0, fileInformationClass));
}
return(new List <QueryDirectoryFileInformation>());
}
unsafe private static void GetFileInformation(SafeFileHandle fileHandle, FileInformationClass fileInformationClass, void *value, uint size)
{
Imports.NtQueryInformationFile(
FileHandle: fileHandle,
IoStatusBlock: out _,
FileInformation: value,
Length: size,
FileInformationClass: fileInformationClass)
.ThrowIfFailed();
}
public QueryDirectoryRequest(byte[] buffer, int offset) : base(buffer, offset)
{
StructureSize = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 0);
FileInformationClass = (FileInformationClass)ByteReader.ReadByte(buffer, offset + SMB2Header.Length + 2);
Flags = (QueryDirectoryFlags)ByteReader.ReadByte(buffer, offset + SMB2Header.Length + 3);
FileIndex = LittleEndianConverter.ToUInt32(buffer, offset + SMB2Header.Length + 4);
FileId = new FileID(buffer, offset + SMB2Header.Length + 8);
FileNameOffset = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 24);
FileNameLength = LittleEndianConverter.ToUInt16(buffer, offset + SMB2Header.Length + 26);
OutputBufferLength = LittleEndianConverter.ToUInt32(buffer, offset + SMB2Header.Length + 28);
FileName = ByteReader.ReadUTF16String(buffer, offset + FileNameOffset, FileNameLength / 2);
}
public unsafe static extern NTStatus NtQueryDirectoryFile(
SafeFileHandle FileHandle,
IntPtr Event,
AsyncProcedureCall ApcRoutine,
IntPtr ApcContext,
out IO_STATUS_BLOCK IoStatusBlock,
void *FileInformation,
uint Length,
FileInformationClass FileInformationClass,
Boolean8 ReturnSingleEntry,
UNICODE_STRING *FileName,
Boolean8 RestartScan);
public static extern NtStatus NtQueryDirectoryFile(
SafeKernelObjectHandle FileHandle,
SafeKernelObjectHandle Event,
IntPtr ApcRoutine,
IntPtr ApcContext,
SafeIoStatusBuffer IoStatusBlock,
SafeBuffer FileInformation,
int Length,
FileInformationClass FileInformationClass,
[MarshalAs(UnmanagedType.U1)] bool ReturnSingleEntry,
UnicodeString FileName,
[MarshalAs(UnmanagedType.U1)] bool RestartScan
);
unsafe private static void GetFileInformation(SafeFileHandle fileHandle, FileInformationClass fileInformationClass, void *value, uint size)
{
NTSTATUS status = Imports.NtQueryInformationFile(
FileHandle: fileHandle,
IoStatusBlock: out _,
FileInformation: value,
Length: size,
FileInformationClass: fileInformationClass);
if (status != NTSTATUS.STATUS_SUCCESS)
{
throw ErrorMethods.GetIoExceptionForNTStatus(status);
}
}
public void GetFileInformation(out FileInformation result, NtHandle handle, FileInformationClass informationClass)
{
if (m_client.InfoLevelPassthrough)
{
int maxOutputLength = 4096;
Transaction2QueryFileInformationRequest subcommand = new Transaction2QueryFileInformationRequest
{
FID = ((Smb1Handle)handle).FID,
FileInformationClass = informationClass
};
Transaction2Request request = new Transaction2Request
{
Setup = subcommand.GetSetup(),
TransParameters = subcommand.GetParameters(m_client.Unicode),
TransData = subcommand.GetData(m_client.Unicode)
};
request.TotalDataCount = (ushort)request.TransData.Length;
request.TotalParameterCount = (ushort)request.TransParameters.Length;
request.MaxParameterCount = Transaction2QueryFileInformationResponse.ParametersLength;
request.MaxDataCount = (ushort)maxOutputLength;
TrySendMessage(request);
SMB1Message reply = m_client.WaitForMessage(CommandName.SMB_COM_TRANSACTION2);
reply.IsSuccessElseThrow();
if (!(reply.Commands[0] is Transaction2Response transaction2Response))
{
throw new NtStatusException(reply.Header.Status);
}
Transaction2QueryFileInformationResponse subcommandResponse = new Transaction2QueryFileInformationResponse(transaction2Response.TransParameters, transaction2Response.TransData);
if (informationClass == FileInformationClass.FileAllInformation)
{
// Windows implementations return SMB_QUERY_FILE_ALL_INFO when a client specifies native NT passthrough level "FileAllInformation".
QueryInformation queryFileAllInfo = subcommandResponse.GetQueryInformation(QueryInformationLevel.SMB_QUERY_FILE_ALL_INFO);
result = QueryInformationHelper.ToFileInformation(queryFileAllInfo);
}
else
{
result = subcommandResponse.GetFileInformation(informationClass);
}
reply.IsSuccessElseThrow();
return;
}
QueryInformationLevel informationLevel = QueryInformationHelper.ToFileInformationLevel(informationClass);
GetFileInformation(out QueryInformation? queryInformation, handle, informationLevel);
result = QueryInformationHelper.ToFileInformation(queryInformation);
}
private NtStatus NtQueryInformationFileImpl(IntPtr hfile, out IO_STATUS_BLOCK ioStatusBlock, void *fileInformation,
uint length, FileInformationClass fileInformationClass)
{
lock ( _getInfoLock )
{
foreach (var filter in _filters)
{
if (filter.Accept(hfile))
{
return(filter.NtQueryInformationFileImpl(hfile, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
return(_hooks.NtQueryInformationFileHook.OriginalFunction(hfile, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
public void GetFileInformation(out FileInformation result, NtHandle handle, FileInformationClass informationClass)
{
QueryInfoRequest request = new QueryInfoRequest
{
InfoType = InfoType.File,
FileInformationClass = informationClass,
OutputBufferLength = 4096,
FileId = (FileID)handle
};
SendCommand(request);
QueryInfoResponse queryInfoResponse = (QueryInfoResponse)WaitForCommand(request.MessageID);
queryInfoResponse.IsSuccessElseThrow();
result = queryInfoResponse.GetFileInformation(informationClass);
}
private NtStatus NtSetInformationFileImpl(IntPtr handle, out IO_STATUS_BLOCK ioStatusBlock, void *fileInformation,
uint length, FileInformationClass fileInformationClass)
{
lock ( _setInfoLock )
{
if (fileInformationClass == FileInformationClass.FilePositionInformation && _handleToInfoMap.ContainsKey(handle))
{
_handleToInfoMap[handle].FilePointer = *( long * )fileInformation;
}
foreach (var filter in _filters)
{
if (filter.Accept(handle))
{
return(filter.NtSetInformationFileImpl(handle, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
return(_hooks.NtSetInformationFileHook.OriginalFunction(handle, out ioStatusBlock, fileInformation, length, fileInformationClass));
}
}
public void QueryDirectory(out List <QueryDirectoryFileInformation> result, NtHandle handle, string fileName, FileInformationClass informationClass)
{
result = new List <QueryDirectoryFileInformation>();
QueryDirectoryRequest request = new QueryDirectoryRequest
{
Header = { CreditCharge = (ushort)Math.Ceiling((double)m_client.MaxTransactSize / BytesPerCredit) },
FileInformationClass = informationClass,
Reopen = true,
FileId = (FileID)handle,
OutputBufferLength = m_client.MaxTransactSize,
FileName = fileName
};
SendCommand(request);
SMB2Command?response = WaitForCommand(request.MessageID);
response.IsSuccessElseThrow();
while (response is QueryDirectoryResponse queryDirectoryResponse)
{
List <QueryDirectoryFileInformation> page = queryDirectoryResponse.GetFileInformationList(informationClass);
result.AddRange(page);
request.Reopen = false;
SendCommand(request);
response = WaitForCommand(request.MessageID);
if (response.Header.Status == NTStatus.STATUS_NO_MORE_FILES)
{
break;
}
response.IsSuccessElseThrow();
}
}
public abstract NtStatus NtSetInformationFileImpl(IntPtr hfile, out IO_STATUS_BLOCK ioStatusBlock,
void *fileInformation, uint length, FileInformationClass fileInformationClass);
public unsafe static extern NTStatus NtSetInformationFile(
SafeFileHandle FileHandle,
out IO_STATUS_BLOCK IoStatusBlock,
void *FileInformation,
FileInformationClass FileInformationClass);
public NTStatus GetFileInformation(out FileInformation result, object handle, FileInformationClass informationClass)
{
switch (informationClass)
{
case FileInformationClass.FileBasicInformation:
{
FileBasicInformation information = new FileBasicInformation();
information.FileAttributes = FileAttributes.Temporary;
result = information;
return(NTStatus.STATUS_SUCCESS);
}
case FileInformationClass.FileStandardInformation:
{
FileStandardInformation information = new FileStandardInformation();
information.DeletePending = false;
result = information;
return(NTStatus.STATUS_SUCCESS);
}
case FileInformationClass.FileNetworkOpenInformation:
{
FileNetworkOpenInformation information = new FileNetworkOpenInformation();
information.FileAttributes = FileAttributes.Temporary;
result = information;
return(NTStatus.STATUS_SUCCESS);
}
default:
result = null;
return(NTStatus.STATUS_INVALID_INFO_CLASS);
}
}
private static List <QueryDirectoryFileInformation> FromFileSystemEntries(List <FileSystemEntry> entries, FileInformationClass informationClass)
{
List <QueryDirectoryFileInformation> result = new List <QueryDirectoryFileInformation>();
foreach (FileSystemEntry entry in entries)
{
QueryDirectoryFileInformation information = FromFileSystemEntry(entry, informationClass);
result.Add(information);
}
return(result);
}
public NTStatus GetFileInformation(out FileInformation result, object handle, FileInformationClass informationClass)
{
IO_STATUS_BLOCK ioStatusBlock;
byte[] buffer = new byte[8192];
NTStatus status = NtQueryInformationFile((IntPtr)handle, out ioStatusBlock, buffer, (uint)buffer.Length, (uint)informationClass);
if (status == NTStatus.STATUS_SUCCESS)
{
int numberOfBytesWritten = (int)ioStatusBlock.Information;
buffer = ByteReader.ReadBytes(buffer, 0, numberOfBytesWritten);
result = FileInformation.GetFileInformation(buffer, 0, informationClass);
}
else
{
result = null;
}
return(status);
}
private unsafe static string GetFileInformationString(SafeFileHandle fileHandle, FileInformationClass fileInformationClass)
{
return(BufferHelper.BufferInvoke((HeapBuffer buffer) =>
{
NTStatus status = NTStatus.STATUS_BUFFER_OVERFLOW;
// Start with MAX_PATH
uint byteLength = 260 * sizeof(char);
FILE_NAME_INFORMATION *value = null;
while (status == NTStatus.STATUS_BUFFER_OVERFLOW)
{
// Add space for the FileNameLength
buffer.EnsureByteCapacity(byteLength + sizeof(uint));
status = Imports.NtQueryInformationFile(
FileHandle: fileHandle,
IoStatusBlock: out _,
FileInformation: buffer.VoidPointer,
Length: checked ((uint)buffer.ByteCapacity),
FileInformationClass: fileInformationClass);
if (status == NTStatus.STATUS_SUCCESS || status == NTStatus.STATUS_BUFFER_OVERFLOW)
{
value = (FILE_NAME_INFORMATION *)buffer.VoidPointer;
byteLength = value->FileNameLength;
}
}
status.ThrowIfFailed();
return value->FileName.CreateString();
}));
}
public override unsafe Native.NtStatus NtSetInformationFileImpl(IntPtr hfile, out IO_STATUS_BLOCK ioStatusBlock, void *fileInformation, uint length, FileInformationClass fileInformationClass)
{
if (fileInformationClass == FileInformationClass.FilePositionInformation)
{
if (mWaveBankByHandle.TryGetValue(hfile, out var waveBank))
{
waveBank.FilePointer = *( long * )fileInformation;
mLogger.Debug($"{waveBank.FileName} Hnd: {hfile} SetFilePointer -> 0x{waveBank.FilePointer:X8}");
}
}
else
{
mLogger.Warning($"SetInformationFileImpl(hfile = {hfile}, out ioStatusBlock, fileInformation = *0x{( long )fileInformation:X8}, " +
$"length = {length}, fileInformationClass = {fileInformationClass}");
}
mHooks.NtSetInformationFileHook.OriginalFunction(hfile, out ioStatusBlock, fileInformation, length, fileInformationClass);
// Spoof return value as we extend beyond the end of the file
return(NtStatus.Success);
}
/// <param name="fileName">Expression as described in [MS-FSA] 2.1.4.4</param>
public NTStatus QueryDirectory(out List <QueryDirectoryFileInformation> result, object handle, string fileName, FileInformationClass informationClass)
{
result = null;
FileHandle directoryHandle = (FileHandle)handle;
if (!directoryHandle.IsDirectory)
{
return(NTStatus.STATUS_INVALID_PARAMETER);
}
if (fileName == String.Empty)
{
return(NTStatus.STATUS_INVALID_PARAMETER);
}
string path = directoryHandle.Path;
bool findExactName = !ContainsWildcardCharacters(fileName);
List <FileSystemEntry> entries;
if (!findExactName)
{
try
{
entries = m_fileSystem.ListEntriesInDirectory(path);
}
catch (UnauthorizedAccessException)
{
return(NTStatus.STATUS_ACCESS_DENIED);
}
entries = GetFiltered(entries, fileName);
// Windows will return "." and ".." when enumerating directory files.
// The SMB1 / SMB2 specifications mandate that when zero entries are found, the server SHOULD / MUST return STATUS_NO_SUCH_FILE.
// For this reason, we MUST include the current directory and/or parent directory when enumerating a directory
// in order to diffrentiate between a directory that does not exist and a directory with no entries.
FileSystemEntry currentDirectory = m_fileSystem.GetEntry(path);
currentDirectory.Name = ".";
FileSystemEntry parentDirectory = m_fileSystem.GetEntry(FileSystem.GetParentDirectory(path));
parentDirectory.Name = "..";
entries.Insert(0, parentDirectory);
entries.Insert(0, currentDirectory);
}
else
{
path = FileSystem.GetDirectoryPath(path);
FileSystemEntry entry = m_fileSystem.GetEntry(path + fileName);
if (entry == null)
{
return(NTStatus.STATUS_NO_SUCH_FILE);
}
entries = new List <FileSystemEntry>();
entries.Add(entry);
}
try
{
result = FromFileSystemEntries(entries, informationClass);
}
catch (UnsupportedInformationLevelException)
{
return(NTStatus.STATUS_INVALID_INFO_CLASS);
}
return(NTStatus.STATUS_SUCCESS);
}
public NTStatus QueryDirectory(out List <QueryDirectoryFileInformation> result, object handle, string fileName, FileInformationClass informationClass)
{
result = new List <QueryDirectoryFileInformation>();
QueryDirectoryRequest request = new QueryDirectoryRequest();
request.FileInformationClass = informationClass;
request.Reopen = true;
request.FileId = (FileID)handle;
request.OutputBufferLength = m_client.MaxTransactSize;
request.FileName = fileName;
ulong messageId = TrySendCommand(request);
SMB2Command response = m_client.WaitForCommand(SMB2CommandName.QueryDirectory, messageId);
if (response != null)
{
while (response.Header.Status == NTStatus.STATUS_SUCCESS && response is QueryDirectoryResponse)
{
List <QueryDirectoryFileInformation> page = ((QueryDirectoryResponse)response).GetFileInformationList(informationClass);
result.AddRange(page);
request.Reopen = false;
messageId = TrySendCommand(request);
response = m_client.WaitForCommand(SMB2CommandName.QueryDirectory, messageId);
}
return(response.Header.Status);
}
return(NTStatus.STATUS_INVALID_SMB);
}
/// <remarks>
/// Support for pass-through Information Levels must be enabled.
/// </remarks>
public FileInformation GetFileInformation(FileInformationClass informationClass)
{
return(FileInformation.GetFileInformation(InformationBytes, 0, informationClass));
}
public NTStatus QueryDirectory(out List <QueryDirectoryFileInformation> result, object handle, string fileName, FileInformationClass informationClass)
{
IO_STATUS_BLOCK ioStatusBlock;
byte[] buffer = new byte[4096];
UNICODE_STRING fileNameStructure = new UNICODE_STRING(fileName);
result = new List <QueryDirectoryFileInformation>();
bool restartScan = true;
while (true)
{
NTStatus status = NtQueryDirectoryFile((IntPtr)handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, out ioStatusBlock, buffer, (uint)buffer.Length, (byte)informationClass, false, ref fileNameStructure, restartScan);
if (status == NTStatus.STATUS_NO_MORE_FILES)
{
break;
}
else if (status != NTStatus.STATUS_SUCCESS)
{
return(status);
}
int numberOfBytesWritten = (int)ioStatusBlock.Information;
buffer = ByteReader.ReadBytes(buffer, 0, numberOfBytesWritten);
List <QueryDirectoryFileInformation> page = QueryDirectoryFileInformation.ReadFileInformationList(buffer, 0, informationClass);
result.AddRange(page);
restartScan = false;
}
fileNameStructure.Dispose();
return(NTStatus.STATUS_SUCCESS);
}
public NTStatus QueryDirectory(out List <QueryDirectoryFileInformation> result, object directoryHandle, string fileName, FileInformationClass informationClass)
{
result = null;
return(NTStatus.STATUS_NOT_SUPPORTED);
}
public NTStatus GetFileInformation(out FileInformation result, object handle, FileInformationClass informationClass)
{
result = null;
QueryInfoRequest request = new QueryInfoRequest();
request.InfoType = InfoType.File;
request.FileInformationClass = informationClass;
request.OutputBufferLength = 4096;
request.FileId = (FileID)handle;
ulong messageId = TrySendCommand(request);
SMB2Command response = m_client.WaitForCommand(SMB2CommandName.QueryInfo, messageId);
if (response != null)
{
if (response.Header.Status == NTStatus.STATUS_SUCCESS && response is QueryInfoResponse)
{
result = ((QueryInfoResponse)response).GetFileInformation(informationClass);
}
return(response.Header.Status);
}
return(NTStatus.STATUS_INVALID_SMB);
}
private static QueryDirectoryFileInformation FromFileSystemEntry(FileSystemEntry entry, FileInformationClass informationClass)
{
switch (informationClass)
{
case FileInformationClass.FileBothDirectoryInformation:
{
FileBothDirectoryInformation result = new FileBothDirectoryInformation();
result.CreationTime = entry.CreationTime;
result.LastAccessTime = entry.LastAccessTime;
result.LastWriteTime = entry.LastWriteTime;
result.ChangeTime = entry.LastWriteTime;
result.EndOfFile = (long)entry.Size;
result.AllocationSize = (long)GetAllocationSize(entry.Size);
result.FileAttributes = GetFileAttributes(entry);
result.EaSize = 0;
result.ShortName = GetShortName(entry.Name);
result.FileName = entry.Name;
return(result);
}
case FileInformationClass.FileDirectoryInformation:
{
FileDirectoryInformation result = new FileDirectoryInformation();
result.CreationTime = entry.CreationTime;
result.LastAccessTime = entry.LastAccessTime;
result.LastWriteTime = entry.LastWriteTime;
result.ChangeTime = entry.LastWriteTime;
result.EndOfFile = (long)entry.Size;
result.AllocationSize = (long)GetAllocationSize(entry.Size);
result.FileAttributes = GetFileAttributes(entry);
result.FileName = entry.Name;
return(result);
}
case FileInformationClass.FileFullDirectoryInformation:
{
FileFullDirectoryInformation result = new FileFullDirectoryInformation();
result.CreationTime = entry.CreationTime;
result.LastAccessTime = entry.LastAccessTime;
result.LastWriteTime = entry.LastWriteTime;
result.ChangeTime = entry.LastWriteTime;
result.EndOfFile = (long)entry.Size;
result.AllocationSize = (long)GetAllocationSize(entry.Size);
result.FileAttributes = GetFileAttributes(entry);
result.EaSize = 0;
result.FileName = entry.Name;
return(result);
}
case FileInformationClass.FileIdBothDirectoryInformation:
{
FileIdBothDirectoryInformation result = new FileIdBothDirectoryInformation();
result.CreationTime = entry.CreationTime;
result.LastAccessTime = entry.LastAccessTime;
result.LastWriteTime = entry.LastWriteTime;
result.ChangeTime = entry.LastWriteTime;
result.EndOfFile = (long)entry.Size;
result.AllocationSize = (long)GetAllocationSize(entry.Size);
result.FileAttributes = GetFileAttributes(entry);
result.EaSize = 0;
result.ShortName = GetShortName(entry.Name);
result.FileId = 0;
result.FileName = entry.Name;
return(result);
}
case FileInformationClass.FileIdFullDirectoryInformation:
{
FileIdFullDirectoryInformation result = new FileIdFullDirectoryInformation();
result.CreationTime = entry.CreationTime;
result.LastAccessTime = entry.LastAccessTime;
result.LastWriteTime = entry.LastWriteTime;
result.ChangeTime = entry.LastWriteTime;
result.EndOfFile = (long)entry.Size;
result.AllocationSize = (long)GetAllocationSize(entry.Size);
result.FileAttributes = GetFileAttributes(entry);
result.EaSize = 0;
result.FileId = 0;
result.FileName = entry.Name;
return(result);
}
case FileInformationClass.FileNamesInformation:
{
FileNamesInformation result = new FileNamesInformation();
result.FileName = entry.Name;
return(result);
}
default:
{
throw new UnsupportedInformationLevelException();
}
}
}
