mirror of
https://github.com/Thealexbarney/LibHac.git
synced 2024-11-14 10:49:41 +01:00
1942 lines
69 KiB
C#
1942 lines
69 KiB
C#
//
|
|
// Copyright (c) 2008-2011, Kenneth Bell
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including without limitation
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using DiscUtils.Internal;
|
|
using DiscUtils.Streams;
|
|
|
|
namespace DiscUtils.Fat
|
|
{
|
|
/// <summary>
|
|
/// Class for accessing FAT file systems.
|
|
/// </summary>
|
|
public sealed class FatFileSystem : DiscFileSystem
|
|
{
|
|
/// <summary>
|
|
/// The Epoch for FAT file systems (1st Jan, 1980).
|
|
/// </summary>
|
|
public static readonly DateTime Epoch = new DateTime(1980, 1, 1);
|
|
|
|
private readonly Dictionary<uint, Directory> _dirCache;
|
|
private readonly Ownership _ownsData;
|
|
|
|
private readonly TimeConverter _timeConverter;
|
|
private byte[] _bootSector;
|
|
private ushort _bpbBkBootSec;
|
|
|
|
private ushort _bpbBytesPerSec;
|
|
private ushort _bpbExtFlags;
|
|
private ushort _bpbFATSz16;
|
|
|
|
private uint _bpbFATSz32;
|
|
private ushort _bpbFSInfo;
|
|
private ushort _bpbFSVer;
|
|
private uint _bpbHiddSec;
|
|
private ushort _bpbNumHeads;
|
|
private uint _bpbRootClus;
|
|
private ushort _bpbRootEntCnt;
|
|
private ushort _bpbRsvdSecCnt;
|
|
private ushort _bpbSecPerTrk;
|
|
private ushort _bpbTotSec16;
|
|
private uint _bpbTotSec32;
|
|
|
|
private byte _bsBootSig;
|
|
private uint _bsVolId;
|
|
private string _bsVolLab;
|
|
private Stream _data;
|
|
private Directory _rootDir;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the FatFileSystem class.
|
|
/// </summary>
|
|
/// <param name="data">The stream containing the file system.</param>
|
|
/// <remarks>
|
|
/// Local time is the effective timezone of the new instance.
|
|
/// </remarks>
|
|
public FatFileSystem(Stream data)
|
|
: base(new FatFileSystemOptions())
|
|
{
|
|
_dirCache = new Dictionary<uint, Directory>();
|
|
_timeConverter = DefaultTimeConverter;
|
|
Initialize(data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the FatFileSystem class.
|
|
/// </summary>
|
|
/// <param name="data">The stream containing the file system.</param>
|
|
/// <param name="ownsData">Indicates if the new instance should take ownership
|
|
/// of <paramref name="data"/>.</param>
|
|
/// <remarks>
|
|
/// Local time is the effective timezone of the new instance.
|
|
/// </remarks>
|
|
public FatFileSystem(Stream data, Ownership ownsData)
|
|
: base(new FatFileSystemOptions())
|
|
{
|
|
_dirCache = new Dictionary<uint, Directory>();
|
|
_timeConverter = DefaultTimeConverter;
|
|
Initialize(data);
|
|
_ownsData = ownsData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the FatFileSystem class.
|
|
/// </summary>
|
|
/// <param name="data">The stream containing the file system.</param>
|
|
/// <param name="timeConverter">A delegate to convert to/from the file system's timezone.</param>
|
|
public FatFileSystem(Stream data, TimeConverter timeConverter)
|
|
: base(new FatFileSystemOptions())
|
|
{
|
|
_dirCache = new Dictionary<uint, Directory>();
|
|
_timeConverter = timeConverter;
|
|
Initialize(data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the FatFileSystem class.
|
|
/// </summary>
|
|
/// <param name="data">The stream containing the file system.</param>
|
|
/// <param name="ownsData">Indicates if the new instance should take ownership
|
|
/// of <paramref name="data"/>.</param>
|
|
/// <param name="timeConverter">A delegate to convert to/from the file system's timezone.</param>
|
|
public FatFileSystem(Stream data, Ownership ownsData, TimeConverter timeConverter)
|
|
: base(new FatFileSystemOptions())
|
|
{
|
|
_dirCache = new Dictionary<uint, Directory>();
|
|
_timeConverter = timeConverter;
|
|
Initialize(data);
|
|
_ownsData = ownsData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the FatFileSystem class.
|
|
/// </summary>
|
|
/// <param name="data">The stream containing the file system.</param>
|
|
/// <param name="ownsData">Indicates if the new instance should take ownership
|
|
/// of <paramref name="data"/>.</param>
|
|
/// <param name="parameters">The parameters for the file system.</param>
|
|
public FatFileSystem(Stream data, Ownership ownsData, FileSystemParameters parameters)
|
|
: base(new FatFileSystemOptions(parameters))
|
|
{
|
|
_dirCache = new Dictionary<uint, Directory>();
|
|
|
|
if (parameters != null && parameters.TimeConverter != null)
|
|
{
|
|
_timeConverter = parameters.TimeConverter;
|
|
}
|
|
else
|
|
{
|
|
_timeConverter = DefaultTimeConverter;
|
|
}
|
|
|
|
Initialize(data);
|
|
_ownsData = ownsData;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the active FAT (zero-based index).
|
|
/// </summary>
|
|
public byte ActiveFat
|
|
{
|
|
get { return (byte)((_bpbExtFlags & 0x08) != 0 ? _bpbExtFlags & 0x7 : 0); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the Sector location of the backup boot sector (FAT32 only).
|
|
/// </summary>
|
|
public int BackupBootSector
|
|
{
|
|
get { return _bpbBkBootSec; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the BIOS drive number for BIOS Int 13h calls.
|
|
/// </summary>
|
|
public byte BiosDriveNumber { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the number of bytes per sector (as stored in the file-system meta data).
|
|
/// </summary>
|
|
public int BytesPerSector
|
|
{
|
|
get { return _bpbBytesPerSec; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if this file system is read-only or read-write.
|
|
/// </summary>
|
|
/// <returns>.</returns>
|
|
public override bool CanWrite
|
|
{
|
|
get { return _data.CanWrite; }
|
|
}
|
|
|
|
internal ClusterReader ClusterReader { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the VolumeId, VolumeLabel and FileSystemType fields are valid.
|
|
/// </summary>
|
|
public bool ExtendedBootSignaturePresent
|
|
{
|
|
get { return _bsBootSig == 0x29; }
|
|
}
|
|
|
|
internal FileAllocationTable Fat { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the number of FATs present.
|
|
/// </summary>
|
|
public byte FatCount { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the FAT file system options, which can be modified.
|
|
/// </summary>
|
|
public FatFileSystemOptions FatOptions
|
|
{
|
|
get { return (FatFileSystemOptions)Options; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the size of a single FAT, in sectors.
|
|
/// </summary>
|
|
public long FatSize
|
|
{
|
|
get { return _bpbFATSz16 != 0 ? _bpbFATSz16 : _bpbFATSz32; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the FAT variant of the file system.
|
|
/// </summary>
|
|
public FatType FatVariant { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the (informational only) file system type recorded in the meta-data.
|
|
/// </summary>
|
|
public string FileSystemType { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the friendly name for the file system, including FAT variant.
|
|
/// </summary>
|
|
public override string FriendlyName
|
|
{
|
|
get
|
|
{
|
|
switch (FatVariant)
|
|
{
|
|
case FatType.Fat12:
|
|
return "Microsoft FAT12";
|
|
case FatType.Fat16:
|
|
return "Microsoft FAT16";
|
|
case FatType.Fat32:
|
|
return "Microsoft FAT32";
|
|
default:
|
|
return "Unknown FAT";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the sector location of the FSINFO structure (FAT32 only).
|
|
/// </summary>
|
|
public int FSInfoSector
|
|
{
|
|
get { return _bpbFSInfo; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of logical heads.
|
|
/// </summary>
|
|
public int Heads
|
|
{
|
|
get { return _bpbNumHeads; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of hidden sectors, hiding partition tables, etc.
|
|
/// </summary>
|
|
public long HiddenSectors
|
|
{
|
|
get { return _bpbHiddSec; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the maximum number of root directory entries (on FAT variants that have a limit).
|
|
/// </summary>
|
|
public int MaxRootDirectoryEntries
|
|
{
|
|
get { return _bpbRootEntCnt; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the Media marker byte, which indicates fixed or removable media.
|
|
/// </summary>
|
|
public byte Media { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether FAT changes are mirrored to all copies of the FAT.
|
|
/// </summary>
|
|
public bool MirrorFat
|
|
{
|
|
get { return (_bpbExtFlags & 0x08) == 0; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the OEM name from the file system.
|
|
/// </summary>
|
|
public string OemName { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the number of reserved sectors at the start of the disk.
|
|
/// </summary>
|
|
public int ReservedSectorCount
|
|
{
|
|
get { return _bpbRsvdSecCnt; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the cluster number of the first cluster of the root directory (FAT32 only).
|
|
/// </summary>
|
|
public long RootDirectoryCluster
|
|
{
|
|
get { return _bpbRootClus; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the number of contiguous sectors that make up one cluster.
|
|
/// </summary>
|
|
public byte SectorsPerCluster { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the number of sectors per logical track.
|
|
/// </summary>
|
|
public int SectorsPerTrack
|
|
{
|
|
get { return _bpbSecPerTrk; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the total number of sectors on the disk.
|
|
/// </summary>
|
|
public long TotalSectors
|
|
{
|
|
get { return _bpbTotSec16 != 0 ? _bpbTotSec16 : _bpbTotSec32; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the file-system version (usually 0).
|
|
/// </summary>
|
|
public int Version
|
|
{
|
|
get { return _bpbFSVer; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the volume serial number.
|
|
/// </summary>
|
|
public int VolumeId
|
|
{
|
|
get { return (int)_bsVolId; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the volume label.
|
|
/// </summary>
|
|
public override string VolumeLabel
|
|
{
|
|
get
|
|
{
|
|
long volId = _rootDir.FindVolumeId();
|
|
if (volId < 0)
|
|
{
|
|
return _bsVolLab;
|
|
}
|
|
return _rootDir.GetEntry(volId).Name.GetRawName(FatOptions.FileNameEncoding);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detects if a stream contains a FAT file system.
|
|
/// </summary>
|
|
/// <param name="stream">The stream to inspect.</param>
|
|
/// <returns><c>true</c> if the stream appears to be a FAT file system, else <c>false</c>.</returns>
|
|
public static bool Detect(Stream stream)
|
|
{
|
|
if (stream.Length < 512)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
stream.Position = 0;
|
|
byte[] bytes = StreamUtilities.ReadExact(stream, 512);
|
|
ushort bpbBytesPerSec = EndianUtilities.ToUInt16LittleEndian(bytes, 11);
|
|
if (bpbBytesPerSec != 512)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
byte bpbNumFATs = bytes[16];
|
|
if (bpbNumFATs == 0 || bpbNumFATs > 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ushort bpbTotSec16 = EndianUtilities.ToUInt16LittleEndian(bytes, 19);
|
|
uint bpbTotSec32 = EndianUtilities.ToUInt32LittleEndian(bytes, 32);
|
|
|
|
if (!((bpbTotSec16 == 0) ^ (bpbTotSec32 == 0)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
uint totalSectors = bpbTotSec16 + bpbTotSec32;
|
|
return totalSectors * (long)bpbBytesPerSec <= stream.Length;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Opens a file for reading and/or writing.
|
|
/// </summary>
|
|
/// <param name="path">The full path to the file.</param>
|
|
/// <param name="mode">The file mode.</param>
|
|
/// <param name="access">The desired access.</param>
|
|
/// <returns>The stream to the opened file.</returns>
|
|
public override SparseStream OpenFile(string path, FileMode mode, FileAccess access)
|
|
{
|
|
Directory parent;
|
|
long entryId;
|
|
try
|
|
{
|
|
entryId = GetDirectoryEntry(_rootDir, path, out parent);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
throw new IOException("Invalid path: " + path);
|
|
}
|
|
|
|
if (parent == null)
|
|
{
|
|
throw new FileNotFoundException("Could not locate file", path);
|
|
}
|
|
|
|
if (entryId < 0)
|
|
{
|
|
return parent.OpenFile(FileName.FromPath(path, FatOptions.FileNameEncoding), mode, access);
|
|
}
|
|
|
|
DirectoryEntry dirEntry = parent.GetEntry(entryId);
|
|
|
|
if ((dirEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new IOException("Attempt to open directory as a file");
|
|
}
|
|
return parent.OpenFile(dirEntry.Name, mode, access);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the attributes of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The file or directory to inspect.</param>
|
|
/// <returns>The attributes of the file or directory.</returns>
|
|
public override FileAttributes GetAttributes(string path)
|
|
{
|
|
// Simulate a root directory entry - doesn't really exist though
|
|
if (IsRootPath(path))
|
|
{
|
|
return FileAttributes.Directory;
|
|
}
|
|
|
|
DirectoryEntry dirEntry = GetDirectoryEntry(path);
|
|
if (dirEntry == null)
|
|
{
|
|
throw new FileNotFoundException("No such file", path);
|
|
}
|
|
|
|
// Luckily, FAT and .NET FileAttributes match, bit-for-bit
|
|
return (FileAttributes)dirEntry.Attributes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the attributes of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The file or directory to change.</param>
|
|
/// <param name="newValue">The new attributes of the file or directory.</param>
|
|
public override void SetAttributes(string path, FileAttributes newValue)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (newValue != FileAttributes.Directory)
|
|
{
|
|
throw new NotSupportedException("The attributes of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
Directory parent;
|
|
long id = GetDirectoryEntry(path, out parent);
|
|
DirectoryEntry dirEntry = parent.GetEntry(id);
|
|
|
|
FatAttributes newFatAttr = (FatAttributes)newValue;
|
|
|
|
if ((newFatAttr & FatAttributes.Directory) != (dirEntry.Attributes & FatAttributes.Directory))
|
|
{
|
|
throw new ArgumentException("Attempted to change the directory attribute");
|
|
}
|
|
|
|
dirEntry.Attributes = newFatAttr;
|
|
parent.UpdateEntry(id, dirEntry);
|
|
|
|
// For directories, need to update their 'self' entry also
|
|
if ((dirEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
dirEntry = dir.SelfEntry;
|
|
dirEntry.Attributes = newFatAttr;
|
|
dir.SelfEntry = dirEntry;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the creation time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The creation time.</returns>
|
|
public override DateTime GetCreationTime(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return Epoch;
|
|
}
|
|
|
|
return GetDirectoryEntry(path).CreationTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the creation time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetCreationTime(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (newTime != Epoch)
|
|
{
|
|
throw new NotSupportedException("The creation time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.CreationTime = newTime; });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the creation time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The creation time.</returns>
|
|
public override DateTime GetCreationTimeUtc(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return ConvertToUtc(Epoch);
|
|
}
|
|
|
|
return ConvertToUtc(GetDirectoryEntry(path).CreationTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the creation time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetCreationTimeUtc(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (ConvertFromUtc(newTime) != Epoch)
|
|
{
|
|
throw new NotSupportedException("The last write time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.CreationTime = ConvertFromUtc(newTime); });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the last access time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The time the file or directory was last accessed.</returns>
|
|
public override DateTime GetLastAccessTime(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return Epoch;
|
|
}
|
|
|
|
return GetDirectoryEntry(path).LastAccessTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the last access time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetLastAccessTime(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (newTime != Epoch)
|
|
{
|
|
throw new NotSupportedException("The last access time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.LastAccessTime = newTime; });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the last access time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The time the file or directory was last accessed.</returns>
|
|
public override DateTime GetLastAccessTimeUtc(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return ConvertToUtc(Epoch);
|
|
}
|
|
|
|
return ConvertToUtc(GetDirectoryEntry(path).LastAccessTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the last access time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetLastAccessTimeUtc(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (ConvertFromUtc(newTime) != Epoch)
|
|
{
|
|
throw new NotSupportedException("The last write time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.LastAccessTime = ConvertFromUtc(newTime); });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the last modification time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The time the file or directory was last modified.</returns>
|
|
public override DateTime GetLastWriteTime(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return Epoch;
|
|
}
|
|
|
|
return GetDirectoryEntry(path).LastWriteTime;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the last modification time (in local time) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetLastWriteTime(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (newTime != Epoch)
|
|
{
|
|
throw new NotSupportedException("The last write time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.LastWriteTime = newTime; });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the last modification time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <returns>The time the file or directory was last modified.</returns>
|
|
public override DateTime GetLastWriteTimeUtc(string path)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
return ConvertToUtc(Epoch);
|
|
}
|
|
|
|
return ConvertToUtc(GetDirectoryEntry(path).LastWriteTime);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the last modification time (in UTC) of a file or directory.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file or directory.</param>
|
|
/// <param name="newTime">The new time to set.</param>
|
|
public override void SetLastWriteTimeUtc(string path, DateTime newTime)
|
|
{
|
|
if (IsRootPath(path))
|
|
{
|
|
if (ConvertFromUtc(newTime) != Epoch)
|
|
{
|
|
throw new NotSupportedException("The last write time of the root directory cannot be modified");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
UpdateDirEntry(path, e => { e.LastWriteTime = ConvertFromUtc(newTime); });
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the length of a file.
|
|
/// </summary>
|
|
/// <param name="path">The path to the file.</param>
|
|
/// <returns>The length in bytes.</returns>
|
|
public override long GetFileLength(string path)
|
|
{
|
|
return GetDirectoryEntry(path).FileSize;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies an existing file to a new file, allowing overwriting of an existing file.
|
|
/// </summary>
|
|
/// <param name="sourceFile">The source file.</param>
|
|
/// <param name="destinationFile">The destination file.</param>
|
|
/// <param name="overwrite">Whether to permit over-writing of an existing file.</param>
|
|
public override void CopyFile(string sourceFile, string destinationFile, bool overwrite)
|
|
{
|
|
Directory sourceDir;
|
|
long sourceEntryId = GetDirectoryEntry(sourceFile, out sourceDir);
|
|
|
|
if (sourceDir == null || sourceEntryId < 0)
|
|
{
|
|
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The source file '{0}' was not found", sourceFile));
|
|
}
|
|
|
|
DirectoryEntry sourceEntry = sourceDir.GetEntry(sourceEntryId);
|
|
|
|
if ((sourceEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new IOException("The source file is a directory");
|
|
}
|
|
|
|
DirectoryEntry newEntry = new DirectoryEntry(sourceEntry);
|
|
newEntry.Name = FileName.FromPath(destinationFile, FatOptions.FileNameEncoding);
|
|
newEntry.FirstCluster = 0;
|
|
|
|
Directory destDir;
|
|
long destEntryId = GetDirectoryEntry(destinationFile, out destDir);
|
|
|
|
if (destDir == null)
|
|
{
|
|
throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The destination directory for '{0}' was not found", destinationFile));
|
|
}
|
|
|
|
// If the destination is a directory, use the old file name to construct a full path.
|
|
if (destEntryId >= 0)
|
|
{
|
|
DirectoryEntry destEntry = destDir.GetEntry(destEntryId);
|
|
if ((destEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
newEntry.Name = FileName.FromPath(sourceFile, FatOptions.FileNameEncoding);
|
|
destinationFile = Utilities.CombinePaths(destinationFile, Utilities.GetFileFromPath(sourceFile));
|
|
|
|
destEntryId = GetDirectoryEntry(destinationFile, out destDir);
|
|
}
|
|
}
|
|
|
|
// If there's an existing entry...
|
|
if (destEntryId >= 0)
|
|
{
|
|
DirectoryEntry destEntry = destDir.GetEntry(destEntryId);
|
|
|
|
if ((destEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new IOException("Destination file is an existing directory");
|
|
}
|
|
|
|
if (!overwrite)
|
|
{
|
|
throw new IOException("Destination file already exists");
|
|
}
|
|
|
|
// Remove the old file
|
|
destDir.DeleteEntry(destEntryId, true);
|
|
}
|
|
|
|
// Add the new file's entry
|
|
destEntryId = destDir.AddEntry(newEntry);
|
|
|
|
// Copy the contents...
|
|
using (Stream sourceStream = new FatFileStream(this, sourceDir, sourceEntryId, FileAccess.Read),
|
|
destStream = new FatFileStream(this, destDir, destEntryId, FileAccess.Write))
|
|
{
|
|
StreamUtilities.PumpStreams(sourceStream, destStream);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a directory.
|
|
/// </summary>
|
|
/// <param name="path">The directory to create.</param>
|
|
public override void CreateDirectory(string path)
|
|
{
|
|
string[] pathElements = path.Split(new[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
Directory focusDir = _rootDir;
|
|
|
|
for (int i = 0; i < pathElements.Length; ++i)
|
|
{
|
|
FileName name;
|
|
try
|
|
{
|
|
name = new FileName(pathElements[i], FatOptions.FileNameEncoding, false);
|
|
}
|
|
catch (ArgumentException ae)
|
|
{
|
|
throw new IOException("Invalid path", ae);
|
|
}
|
|
|
|
Directory child = focusDir.GetChildDirectory(name);
|
|
if (child == null)
|
|
{
|
|
child = focusDir.CreateChildDirectory(name);
|
|
}
|
|
|
|
focusDir = child;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes a directory, optionally with all descendants.
|
|
/// </summary>
|
|
/// <param name="path">The path of the directory to delete.</param>
|
|
public override void DeleteDirectory(string path)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
if (dir == null)
|
|
{
|
|
throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"No such directory: {0}", path));
|
|
}
|
|
|
|
if (!dir.IsEmpty)
|
|
{
|
|
throw new IOException("Unable to delete non-empty directory");
|
|
}
|
|
|
|
Directory parent;
|
|
long id = GetDirectoryEntry(path, out parent);
|
|
if (parent == null && id == 0)
|
|
{
|
|
throw new IOException("Unable to delete root directory");
|
|
}
|
|
if (parent != null && id >= 0)
|
|
{
|
|
DirectoryEntry deadEntry = parent.GetEntry(id);
|
|
parent.DeleteEntry(id, true);
|
|
ForgetDirectory(deadEntry);
|
|
}
|
|
else
|
|
{
|
|
throw new DirectoryNotFoundException("No such directory: " + path);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Deletes a file.
|
|
/// </summary>
|
|
/// <param name="path">The path of the file to delete.</param>
|
|
public override void DeleteFile(string path)
|
|
{
|
|
Directory parent;
|
|
long id = GetDirectoryEntry(path, out parent);
|
|
if (parent == null || id < 0)
|
|
{
|
|
throw new FileNotFoundException("No such file", path);
|
|
}
|
|
|
|
DirectoryEntry entry = parent.GetEntry(id);
|
|
if (entry == null || (entry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new FileNotFoundException("No such file", path);
|
|
}
|
|
|
|
parent.DeleteEntry(id, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if a directory exists.
|
|
/// </summary>
|
|
/// <param name="path">The path to test.</param>
|
|
/// <returns>true if the directory exists.</returns>
|
|
public override bool DirectoryExists(string path)
|
|
{
|
|
// Special case - root directory
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
return true;
|
|
}
|
|
DirectoryEntry dirEntry = GetDirectoryEntry(path);
|
|
return dirEntry != null && (dirEntry.Attributes & FatAttributes.Directory) != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if a file exists.
|
|
/// </summary>
|
|
/// <param name="path">The path to test.</param>
|
|
/// <returns>true if the file exists.</returns>
|
|
public override bool FileExists(string path)
|
|
{
|
|
// Special case - root directory
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
return true;
|
|
}
|
|
DirectoryEntry dirEntry = GetDirectoryEntry(path);
|
|
return dirEntry != null && (dirEntry.Attributes & FatAttributes.Directory) == 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates if a file or directory exists.
|
|
/// </summary>
|
|
/// <param name="path">The path to test.</param>
|
|
/// <returns>true if the file or directory exists.</returns>
|
|
public override bool Exists(string path)
|
|
{
|
|
// Special case - root directory
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
return true;
|
|
}
|
|
return GetDirectoryEntry(path) != null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of subdirectories in a specified directory.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <returns>Array of directories.</returns>
|
|
public override string[] GetDirectories(string path)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
if (dir == null)
|
|
{
|
|
throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The directory '{0}' was not found", path));
|
|
}
|
|
|
|
DirectoryEntry[] entries = dir.GetDirectories();
|
|
List<string> dirs = new List<string>(entries.Length);
|
|
foreach (DirectoryEntry dirEntry in entries)
|
|
{
|
|
dirs.Add(Utilities.CombinePaths(path, dirEntry.Name.GetDisplayName(FatOptions.FileNameEncoding)));
|
|
}
|
|
|
|
return dirs.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of subdirectories in a specified directory matching a specified
|
|
/// search pattern, using a value to determine whether to search subdirectories.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <param name="searchPattern">The search string to match against.</param>
|
|
/// <param name="searchOption">Indicates whether to search subdirectories.</param>
|
|
/// <returns>Array of directories matching the search pattern.</returns>
|
|
public override string[] GetDirectories(string path, string searchPattern, SearchOption searchOption)
|
|
{
|
|
Regex re = Utilities.ConvertWildcardsToRegEx(searchPattern);
|
|
|
|
List<string> dirs = new List<string>();
|
|
DoSearch(dirs, path, re, searchOption == SearchOption.AllDirectories, true, false);
|
|
return dirs.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of files in a specified directory.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <returns>Array of files.</returns>
|
|
public override string[] GetFiles(string path)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
DirectoryEntry[] entries = dir.GetFiles();
|
|
|
|
List<string> files = new List<string>(entries.Length);
|
|
foreach (DirectoryEntry dirEntry in entries)
|
|
{
|
|
files.Add(Utilities.CombinePaths(path, dirEntry.Name.GetDisplayName(FatOptions.FileNameEncoding)));
|
|
}
|
|
|
|
return files.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of files in a specified directory matching a specified
|
|
/// search pattern, using a value to determine whether to search subdirectories.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <param name="searchPattern">The search string to match against.</param>
|
|
/// <param name="searchOption">Indicates whether to search subdirectories.</param>
|
|
/// <returns>Array of files matching the search pattern.</returns>
|
|
public override string[] GetFiles(string path, string searchPattern, SearchOption searchOption)
|
|
{
|
|
Regex re = Utilities.ConvertWildcardsToRegEx(searchPattern);
|
|
|
|
List<string> results = new List<string>();
|
|
DoSearch(results, path, re, searchOption == SearchOption.AllDirectories, false, true);
|
|
return results.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of all files and subdirectories in a specified directory.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <returns>Array of files and subdirectories matching the search pattern.</returns>
|
|
public override string[] GetFileSystemEntries(string path)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
DirectoryEntry[] entries = dir.Entries;
|
|
|
|
List<string> result = new List<string>(entries.Length);
|
|
foreach (DirectoryEntry dirEntry in entries)
|
|
{
|
|
result.Add(Utilities.CombinePaths(path, dirEntry.Name.GetDisplayName(FatOptions.FileNameEncoding)));
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the names of files and subdirectories in a specified directory matching a specified
|
|
/// search pattern.
|
|
/// </summary>
|
|
/// <param name="path">The path to search.</param>
|
|
/// <param name="searchPattern">The search string to match against.</param>
|
|
/// <returns>Array of files and subdirectories matching the search pattern.</returns>
|
|
public override string[] GetFileSystemEntries(string path, string searchPattern)
|
|
{
|
|
Regex re = Utilities.ConvertWildcardsToRegEx(searchPattern);
|
|
|
|
Directory dir = GetDirectory(path);
|
|
DirectoryEntry[] entries = dir.Entries;
|
|
|
|
List<string> result = new List<string>(entries.Length);
|
|
foreach (DirectoryEntry dirEntry in entries)
|
|
{
|
|
if (re.IsMatch(dirEntry.Name.GetSearchName(FatOptions.FileNameEncoding)))
|
|
{
|
|
result.Add(Utilities.CombinePaths(path, dirEntry.Name.GetDisplayName(FatOptions.FileNameEncoding)));
|
|
}
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves a directory.
|
|
/// </summary>
|
|
/// <param name="sourceDirectoryName">The directory to move.</param>
|
|
/// <param name="destinationDirectoryName">The target directory name.</param>
|
|
public override void MoveDirectory(string sourceDirectoryName, string destinationDirectoryName)
|
|
{
|
|
if (string.IsNullOrEmpty(destinationDirectoryName))
|
|
{
|
|
if (destinationDirectoryName == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(destinationDirectoryName));
|
|
}
|
|
throw new ArgumentException("Invalid destination name (empty string)");
|
|
}
|
|
|
|
Directory destParent;
|
|
long destId = GetDirectoryEntry(destinationDirectoryName, out destParent);
|
|
if (destParent == null)
|
|
{
|
|
throw new DirectoryNotFoundException("Target directory doesn't exist");
|
|
}
|
|
if (destId >= 0)
|
|
{
|
|
throw new IOException("Target directory already exists");
|
|
}
|
|
|
|
Directory sourceParent;
|
|
long sourceId = GetDirectoryEntry(sourceDirectoryName, out sourceParent);
|
|
if (sourceParent == null || sourceId < 0)
|
|
{
|
|
throw new IOException("Source directory doesn't exist");
|
|
}
|
|
|
|
destParent.AttachChildDirectory(FileName.FromPath(destinationDirectoryName, FatOptions.FileNameEncoding),
|
|
GetDirectory(sourceDirectoryName));
|
|
sourceParent.DeleteEntry(sourceId, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves a file, allowing an existing file to be overwritten.
|
|
/// </summary>
|
|
/// <param name="sourceName">The file to move.</param>
|
|
/// <param name="destinationName">The target file name.</param>
|
|
/// <param name="overwrite">Whether to permit a destination file to be overwritten.</param>
|
|
public override void MoveFile(string sourceName, string destinationName, bool overwrite)
|
|
{
|
|
Directory sourceDir;
|
|
long sourceEntryId = GetDirectoryEntry(sourceName, out sourceDir);
|
|
|
|
if (sourceDir == null || sourceEntryId < 0)
|
|
{
|
|
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The source file '{0}' was not found", sourceName));
|
|
}
|
|
|
|
DirectoryEntry sourceEntry = sourceDir.GetEntry(sourceEntryId);
|
|
|
|
if ((sourceEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new IOException("The source file is a directory");
|
|
}
|
|
|
|
DirectoryEntry newEntry = new DirectoryEntry(sourceEntry);
|
|
newEntry.Name = FileName.FromPath(destinationName, FatOptions.FileNameEncoding);
|
|
|
|
Directory destDir;
|
|
long destEntryId = GetDirectoryEntry(destinationName, out destDir);
|
|
|
|
if (destDir == null)
|
|
{
|
|
throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The destination directory for '{0}' was not found", destinationName));
|
|
}
|
|
|
|
// If the destination is a directory, use the old file name to construct a full path.
|
|
if (destEntryId >= 0)
|
|
{
|
|
DirectoryEntry destEntry = destDir.GetEntry(destEntryId);
|
|
if ((destEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
newEntry.Name = FileName.FromPath(sourceName, FatOptions.FileNameEncoding);
|
|
destinationName = Utilities.CombinePaths(destinationName, Utilities.GetFileFromPath(sourceName));
|
|
|
|
destEntryId = GetDirectoryEntry(destinationName, out destDir);
|
|
}
|
|
}
|
|
|
|
// If there's an existing entry...
|
|
if (destEntryId >= 0)
|
|
{
|
|
DirectoryEntry destEntry = destDir.GetEntry(destEntryId);
|
|
|
|
if ((destEntry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
throw new IOException("Destination file is an existing directory");
|
|
}
|
|
|
|
if (!overwrite)
|
|
{
|
|
throw new IOException("Destination file already exists");
|
|
}
|
|
|
|
// Remove the old file
|
|
destDir.DeleteEntry(destEntryId, true);
|
|
}
|
|
|
|
// Add the new file's entry and remove the old link to the file's contents
|
|
destDir.AddEntry(newEntry);
|
|
sourceDir.DeleteEntry(sourceEntryId, false);
|
|
}
|
|
|
|
internal DateTime ConvertToUtc(DateTime dateTime)
|
|
{
|
|
return _timeConverter(dateTime, true);
|
|
}
|
|
|
|
internal DateTime ConvertFromUtc(DateTime dateTime)
|
|
{
|
|
return _timeConverter(dateTime, false);
|
|
}
|
|
|
|
internal Directory GetDirectory(string path)
|
|
{
|
|
Directory parent;
|
|
|
|
if (string.IsNullOrEmpty(path) || path == "\\")
|
|
{
|
|
return _rootDir;
|
|
}
|
|
|
|
long id = GetDirectoryEntry(_rootDir, path, out parent);
|
|
if (id >= 0)
|
|
{
|
|
return GetDirectory(parent, id);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal Directory GetDirectory(Directory parent, long parentId)
|
|
{
|
|
if (parent == null)
|
|
{
|
|
return _rootDir;
|
|
}
|
|
|
|
DirectoryEntry dirEntry = parent.GetEntry(parentId);
|
|
if ((dirEntry.Attributes & FatAttributes.Directory) == 0)
|
|
{
|
|
throw new DirectoryNotFoundException();
|
|
}
|
|
|
|
// If we have this one cached, return it
|
|
Directory result;
|
|
if (_dirCache.TryGetValue(dirEntry.FirstCluster, out result))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
// Not cached - create a new one.
|
|
result = new Directory(parent, parentId);
|
|
_dirCache[dirEntry.FirstCluster] = result;
|
|
return result;
|
|
}
|
|
|
|
internal void ForgetDirectory(DirectoryEntry entry)
|
|
{
|
|
uint index = entry.FirstCluster;
|
|
if (index != 0 && _dirCache.ContainsKey(index))
|
|
{
|
|
Directory dir = _dirCache[index];
|
|
_dirCache.Remove(index);
|
|
dir.Dispose();
|
|
}
|
|
}
|
|
|
|
internal DirectoryEntry GetDirectoryEntry(string path)
|
|
{
|
|
Directory parent;
|
|
|
|
long id = GetDirectoryEntry(_rootDir, path, out parent);
|
|
if (parent == null || id < 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return parent.GetEntry(id);
|
|
}
|
|
|
|
internal long GetDirectoryEntry(string path, out Directory parent)
|
|
{
|
|
return GetDirectoryEntry(_rootDir, path, out parent);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disposes of this instance.
|
|
/// </summary>
|
|
/// <param name="disposing">The value <c>true</c> if Disposing.</param>
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
try
|
|
{
|
|
if (disposing)
|
|
{
|
|
foreach (Directory dir in _dirCache.Values)
|
|
{
|
|
dir.Dispose();
|
|
}
|
|
|
|
_rootDir.Dispose();
|
|
|
|
if (_ownsData == Ownership.Dispose)
|
|
{
|
|
_data.Dispose();
|
|
_data = null;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a FAT12/FAT16 BPB.
|
|
/// </summary>
|
|
/// <param name="bootSector">The buffer to fill.</param>
|
|
/// <param name="sectors">The total capacity of the disk (in sectors).</param>
|
|
/// <param name="fatType">The number of bits in each FAT entry.</param>
|
|
/// <param name="maxRootEntries">The maximum number of root directory entries.</param>
|
|
/// <param name="hiddenSectors">The number of hidden sectors before this file system (i.e. partition offset).</param>
|
|
/// <param name="reservedSectors">The number of reserved sectors before the FAT.</param>
|
|
/// <param name="sectorsPerCluster">The number of sectors per cluster.</param>
|
|
/// <param name="diskGeometry">The geometry of the disk containing the Fat file system.</param>
|
|
/// <param name="isFloppy">Indicates if the disk is a removable media (a floppy disk).</param>
|
|
/// <param name="volId">The disk's volume Id.</param>
|
|
/// <param name="label">The disk's label (or null).</param>
|
|
private static void WriteBPB(
|
|
byte[] bootSector,
|
|
uint sectors,
|
|
FatType fatType,
|
|
ushort maxRootEntries,
|
|
uint hiddenSectors,
|
|
ushort reservedSectors,
|
|
byte sectorsPerCluster,
|
|
Geometry diskGeometry,
|
|
bool isFloppy,
|
|
uint volId,
|
|
string label)
|
|
{
|
|
uint fatSectors = CalcFatSize(sectors, fatType, sectorsPerCluster);
|
|
|
|
bootSector[0] = 0xEB;
|
|
bootSector[1] = 0x3C;
|
|
bootSector[2] = 0x90;
|
|
|
|
// OEM Name
|
|
EndianUtilities.StringToBytes("DISCUTIL", bootSector, 3, 8);
|
|
|
|
// Bytes Per Sector (512)
|
|
bootSector[11] = 0;
|
|
bootSector[12] = 2;
|
|
|
|
// Sectors Per Cluster
|
|
bootSector[13] = sectorsPerCluster;
|
|
|
|
// Reserved Sector Count
|
|
EndianUtilities.WriteBytesLittleEndian(reservedSectors, bootSector, 14);
|
|
|
|
// Number of FATs
|
|
bootSector[16] = 2;
|
|
|
|
// Number of Entries in the root directory
|
|
EndianUtilities.WriteBytesLittleEndian(maxRootEntries, bootSector, 17);
|
|
|
|
// Total number of sectors (small)
|
|
EndianUtilities.WriteBytesLittleEndian((ushort)(sectors < 0x10000 ? sectors : 0), bootSector, 19);
|
|
|
|
// Media
|
|
bootSector[21] = (byte)(isFloppy ? 0xF0 : 0xF8);
|
|
|
|
// FAT size (FAT12/FAT16)
|
|
EndianUtilities.WriteBytesLittleEndian((ushort)(fatType < FatType.Fat32 ? fatSectors : 0), bootSector, 22);
|
|
|
|
// Sectors Per Track
|
|
EndianUtilities.WriteBytesLittleEndian((ushort)diskGeometry.SectorsPerTrack, bootSector, 24);
|
|
|
|
// Heads Per Cylinder
|
|
EndianUtilities.WriteBytesLittleEndian((ushort)diskGeometry.HeadsPerCylinder, bootSector, 26);
|
|
|
|
// Hidden Sectors
|
|
EndianUtilities.WriteBytesLittleEndian(hiddenSectors, bootSector, 28);
|
|
|
|
// Total number of sectors (large)
|
|
EndianUtilities.WriteBytesLittleEndian(sectors >= 0x10000 ? sectors : 0, bootSector, 32);
|
|
|
|
if (fatType < FatType.Fat32)
|
|
{
|
|
WriteBS(bootSector, 36, isFloppy, volId, label, fatType);
|
|
}
|
|
else
|
|
{
|
|
// FAT size (FAT32)
|
|
EndianUtilities.WriteBytesLittleEndian(fatSectors, bootSector, 36);
|
|
|
|
// Ext flags: 0x80 = FAT 1 (i.e. Zero) active, mirroring
|
|
bootSector[40] = 0x00;
|
|
bootSector[41] = 0x00;
|
|
|
|
// Filesystem version (0.0)
|
|
bootSector[42] = 0;
|
|
bootSector[43] = 0;
|
|
|
|
// First cluster of the root directory, always 2 since we don't do bad sectors...
|
|
EndianUtilities.WriteBytesLittleEndian((uint)2, bootSector, 44);
|
|
|
|
// Sector number of FSINFO
|
|
EndianUtilities.WriteBytesLittleEndian((uint)1, bootSector, 48);
|
|
|
|
// Sector number of the Backup Boot Sector
|
|
EndianUtilities.WriteBytesLittleEndian((uint)6, bootSector, 50);
|
|
|
|
// Reserved area - must be set to 0
|
|
Array.Clear(bootSector, 52, 12);
|
|
|
|
WriteBS(bootSector, 64, isFloppy, volId, label, fatType);
|
|
}
|
|
|
|
bootSector[510] = 0x55;
|
|
bootSector[511] = 0xAA;
|
|
}
|
|
|
|
private static uint CalcFatSize(uint sectors, FatType fatType, byte sectorsPerCluster)
|
|
{
|
|
uint numClusters = sectors / sectorsPerCluster;
|
|
uint fatBytes = numClusters * (ushort)fatType / 8;
|
|
return (fatBytes + Sizes.Sector - 1) / Sizes.Sector;
|
|
}
|
|
|
|
private static void WriteBS(byte[] bootSector, int offset, bool isFloppy, uint volId, string label,
|
|
FatType fatType)
|
|
{
|
|
if (string.IsNullOrEmpty(label))
|
|
{
|
|
label = "NO NAME ";
|
|
}
|
|
|
|
string fsType = "FAT32 ";
|
|
if (fatType == FatType.Fat12)
|
|
{
|
|
fsType = "FAT12 ";
|
|
}
|
|
else if (fatType == FatType.Fat16)
|
|
{
|
|
fsType = "FAT16 ";
|
|
}
|
|
|
|
// Drive Number (for BIOS)
|
|
bootSector[offset + 0] = (byte)(isFloppy ? 0x00 : 0x80);
|
|
|
|
// Reserved
|
|
bootSector[offset + 1] = 0;
|
|
|
|
// Boot Signature (indicates next 3 fields present)
|
|
bootSector[offset + 2] = 0x29;
|
|
|
|
// Volume Id
|
|
EndianUtilities.WriteBytesLittleEndian(volId, bootSector, offset + 3);
|
|
|
|
// Volume Label
|
|
EndianUtilities.StringToBytes(label + " ", bootSector, offset + 7, 11);
|
|
|
|
// File System Type
|
|
EndianUtilities.StringToBytes(fsType, bootSector, offset + 18, 8);
|
|
}
|
|
|
|
private static FatType DetectFATType(byte[] bpb)
|
|
{
|
|
uint bpbBytesPerSec = EndianUtilities.ToUInt16LittleEndian(bpb, 11);
|
|
uint bpbRootEntCnt = EndianUtilities.ToUInt16LittleEndian(bpb, 17);
|
|
uint bpbFATSz16 = EndianUtilities.ToUInt16LittleEndian(bpb, 22);
|
|
uint bpbFATSz32 = EndianUtilities.ToUInt32LittleEndian(bpb, 36);
|
|
uint bpbTotSec16 = EndianUtilities.ToUInt16LittleEndian(bpb, 19);
|
|
uint bpbTotSec32 = EndianUtilities.ToUInt32LittleEndian(bpb, 32);
|
|
uint bpbResvdSecCnt = EndianUtilities.ToUInt16LittleEndian(bpb, 14);
|
|
uint bpbNumFATs = bpb[16];
|
|
uint bpbSecPerClus = bpb[13];
|
|
|
|
uint rootDirSectors = (bpbRootEntCnt * 32 + bpbBytesPerSec - 1) / bpbBytesPerSec;
|
|
uint fatSz = bpbFATSz16 != 0 ? bpbFATSz16 : bpbFATSz32;
|
|
uint totalSec = bpbTotSec16 != 0 ? bpbTotSec16 : bpbTotSec32;
|
|
|
|
uint dataSec = totalSec - (bpbResvdSecCnt + bpbNumFATs * fatSz + rootDirSectors);
|
|
uint countOfClusters = dataSec / bpbSecPerClus;
|
|
|
|
if (countOfClusters < 4085)
|
|
{
|
|
return FatType.Fat12;
|
|
}
|
|
if (countOfClusters < 65525)
|
|
{
|
|
return FatType.Fat16;
|
|
}
|
|
return FatType.Fat32;
|
|
}
|
|
|
|
private static bool IsRootPath(string path)
|
|
{
|
|
return string.IsNullOrEmpty(path) || path == @"\";
|
|
}
|
|
|
|
private static DateTime DefaultTimeConverter(DateTime time, bool toUtc)
|
|
{
|
|
return toUtc ? time.ToUniversalTime() : time.ToLocalTime();
|
|
}
|
|
|
|
private void Initialize(Stream data)
|
|
{
|
|
_data = data;
|
|
_data.Position = 0;
|
|
_bootSector = StreamUtilities.ReadSector(_data);
|
|
|
|
FatVariant = DetectFATType(_bootSector);
|
|
|
|
ReadBPB();
|
|
|
|
LoadFAT();
|
|
|
|
LoadClusterReader();
|
|
|
|
LoadRootDirectory();
|
|
}
|
|
|
|
private void LoadClusterReader()
|
|
{
|
|
int rootDirSectors = (_bpbRootEntCnt * 32 + (_bpbBytesPerSec - 1)) / _bpbBytesPerSec;
|
|
int firstDataSector = (int)(_bpbRsvdSecCnt + FatCount * FatSize + rootDirSectors);
|
|
ClusterReader = new ClusterReader(_data, firstDataSector, SectorsPerCluster, _bpbBytesPerSec);
|
|
}
|
|
|
|
private void LoadRootDirectory()
|
|
{
|
|
Stream fatStream;
|
|
if (FatVariant != FatType.Fat32)
|
|
{
|
|
fatStream = new SubStream(_data, (_bpbRsvdSecCnt + FatCount * _bpbFATSz16) * _bpbBytesPerSec,
|
|
_bpbRootEntCnt * 32);
|
|
}
|
|
else
|
|
{
|
|
fatStream = new ClusterStream(this, FileAccess.ReadWrite, _bpbRootClus, uint.MaxValue);
|
|
}
|
|
|
|
_rootDir = new Directory(this, fatStream);
|
|
}
|
|
|
|
private void LoadFAT()
|
|
{
|
|
Fat = new FileAllocationTable(FatVariant, _data, _bpbRsvdSecCnt, (uint)FatSize, FatCount, ActiveFat);
|
|
}
|
|
|
|
private void ReadBPB()
|
|
{
|
|
OemName = Encoding.ASCII.GetString(_bootSector, 3, 8).TrimEnd('\0');
|
|
_bpbBytesPerSec = EndianUtilities.ToUInt16LittleEndian(_bootSector, 11);
|
|
SectorsPerCluster = _bootSector[13];
|
|
_bpbRsvdSecCnt = EndianUtilities.ToUInt16LittleEndian(_bootSector, 14);
|
|
FatCount = _bootSector[16];
|
|
_bpbRootEntCnt = EndianUtilities.ToUInt16LittleEndian(_bootSector, 17);
|
|
_bpbTotSec16 = EndianUtilities.ToUInt16LittleEndian(_bootSector, 19);
|
|
Media = _bootSector[21];
|
|
_bpbFATSz16 = EndianUtilities.ToUInt16LittleEndian(_bootSector, 22);
|
|
_bpbSecPerTrk = EndianUtilities.ToUInt16LittleEndian(_bootSector, 24);
|
|
_bpbNumHeads = EndianUtilities.ToUInt16LittleEndian(_bootSector, 26);
|
|
_bpbHiddSec = EndianUtilities.ToUInt32LittleEndian(_bootSector, 28);
|
|
_bpbTotSec32 = EndianUtilities.ToUInt32LittleEndian(_bootSector, 32);
|
|
|
|
if (FatVariant != FatType.Fat32)
|
|
{
|
|
ReadBS(36);
|
|
}
|
|
else
|
|
{
|
|
_bpbFATSz32 = EndianUtilities.ToUInt32LittleEndian(_bootSector, 36);
|
|
_bpbExtFlags = EndianUtilities.ToUInt16LittleEndian(_bootSector, 40);
|
|
_bpbFSVer = EndianUtilities.ToUInt16LittleEndian(_bootSector, 42);
|
|
_bpbRootClus = EndianUtilities.ToUInt32LittleEndian(_bootSector, 44);
|
|
_bpbFSInfo = EndianUtilities.ToUInt16LittleEndian(_bootSector, 48);
|
|
_bpbBkBootSec = EndianUtilities.ToUInt16LittleEndian(_bootSector, 50);
|
|
ReadBS(64);
|
|
}
|
|
}
|
|
|
|
private void ReadBS(int offset)
|
|
{
|
|
BiosDriveNumber = _bootSector[offset];
|
|
_bsBootSig = _bootSector[offset + 2];
|
|
_bsVolId = EndianUtilities.ToUInt32LittleEndian(_bootSector, offset + 3);
|
|
_bsVolLab = Encoding.ASCII.GetString(_bootSector, offset + 7, 11);
|
|
FileSystemType = Encoding.ASCII.GetString(_bootSector, offset + 18, 8);
|
|
}
|
|
|
|
private long GetDirectoryEntry(Directory dir, string path, out Directory parent)
|
|
{
|
|
string[] pathElements = path.Split(new[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
|
|
return GetDirectoryEntry(dir, pathElements, 0, out parent);
|
|
}
|
|
|
|
private long GetDirectoryEntry(Directory dir, string[] pathEntries, int pathOffset, out Directory parent)
|
|
{
|
|
long entryId;
|
|
|
|
if (pathEntries.Length == 0)
|
|
{
|
|
// Looking for root directory, simulate the directory entry in its parent...
|
|
parent = null;
|
|
return 0;
|
|
}
|
|
entryId = dir.FindEntry(new FileName(pathEntries[pathOffset], FatOptions.FileNameEncoding, true));
|
|
if (entryId >= 0)
|
|
{
|
|
if (pathOffset == pathEntries.Length - 1)
|
|
{
|
|
parent = dir;
|
|
return entryId;
|
|
}
|
|
return GetDirectoryEntry(GetDirectory(dir, entryId), pathEntries, pathOffset + 1, out parent);
|
|
}
|
|
if (pathOffset == pathEntries.Length - 1)
|
|
{
|
|
parent = dir;
|
|
return -1;
|
|
}
|
|
parent = null;
|
|
return -1;
|
|
}
|
|
|
|
private void DoSearch(List<string> results, string path, Regex regex, bool subFolders, bool dirs, bool files)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
if (dir == null)
|
|
{
|
|
throw new DirectoryNotFoundException(string.Format(CultureInfo.InvariantCulture,
|
|
"The directory '{0}' was not found", path));
|
|
}
|
|
|
|
DirectoryEntry[] entries = dir.Entries;
|
|
|
|
foreach (DirectoryEntry de in entries)
|
|
{
|
|
bool isDir = (de.Attributes & FatAttributes.Directory) != 0;
|
|
|
|
if ((isDir && dirs) || (!isDir && files))
|
|
{
|
|
if (regex.IsMatch(de.Name.GetSearchName(FatOptions.FileNameEncoding)))
|
|
{
|
|
results.Add(Utilities.CombinePaths(path, de.Name.GetDisplayName(FatOptions.FileNameEncoding)));
|
|
}
|
|
}
|
|
|
|
if (subFolders && isDir)
|
|
{
|
|
DoSearch(results, Utilities.CombinePaths(path, de.Name.GetDisplayName(FatOptions.FileNameEncoding)),
|
|
regex, subFolders, dirs, files);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateDirEntry(string path, EntryUpdateAction action)
|
|
{
|
|
Directory parent;
|
|
long id = GetDirectoryEntry(path, out parent);
|
|
DirectoryEntry entry = parent.GetEntry(id);
|
|
action(entry);
|
|
parent.UpdateEntry(id, entry);
|
|
|
|
if ((entry.Attributes & FatAttributes.Directory) != 0)
|
|
{
|
|
Directory dir = GetDirectory(path);
|
|
DirectoryEntry selfEntry = dir.SelfEntry;
|
|
action(selfEntry);
|
|
dir.SelfEntry = selfEntry;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Size of the Filesystem in bytes
|
|
/// </summary>
|
|
public override long Size { get { return ((TotalSectors - ReservedSectorCount - (FatSize * FatCount))*BytesPerSector); } }
|
|
|
|
/// <summary>
|
|
/// Used space of the Filesystem in bytes
|
|
/// </summary>
|
|
public override long UsedSpace
|
|
{
|
|
get
|
|
{
|
|
uint usedCluster = 0;
|
|
for (uint i = 2; i < Fat.NumEntries; i++)
|
|
{
|
|
var fatValue = Fat.GetNext(i);
|
|
if (!Fat.IsFree(fatValue))
|
|
{
|
|
usedCluster++;
|
|
}
|
|
}
|
|
return (usedCluster *SectorsPerCluster*BytesPerSector);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Available space of the Filesystem in bytes
|
|
/// </summary>
|
|
public override long AvailableSpace { get { return Size - UsedSpace; } }
|
|
|
|
private delegate void EntryUpdateAction(DirectoryEntry entry);
|
|
|
|
#region Disk Formatting
|
|
|
|
/// <summary>
|
|
/// Creates a formatted floppy disk image in a stream.
|
|
/// </summary>
|
|
/// <param name="stream">The stream to write the blank image to.</param>
|
|
/// <param name="type">The type of floppy to create.</param>
|
|
/// <param name="label">The volume label for the floppy (or null).</param>
|
|
/// <returns>An object that provides access to the newly created floppy disk image.</returns>
|
|
public static FatFileSystem FormatFloppy(Stream stream, FloppyDiskType type, string label)
|
|
{
|
|
long pos = stream.Position;
|
|
|
|
long ticks = DateTime.UtcNow.Ticks;
|
|
uint volId = (uint)((ticks & 0xFFFF) | (ticks >> 32));
|
|
|
|
// Write the BIOS Parameter Block (BPB) - a single sector
|
|
byte[] bpb = new byte[512];
|
|
uint sectors;
|
|
if (type == FloppyDiskType.DoubleDensity)
|
|
{
|
|
sectors = 1440;
|
|
WriteBPB(bpb, sectors, FatType.Fat12, 224, 0, 1, 1, new Geometry(80, 2, 9), true, volId, label);
|
|
}
|
|
else if (type == FloppyDiskType.HighDensity)
|
|
{
|
|
sectors = 2880;
|
|
WriteBPB(bpb, sectors, FatType.Fat12, 224, 0, 1, 1, new Geometry(80, 2, 18), true, volId, label);
|
|
}
|
|
else if (type == FloppyDiskType.Extended)
|
|
{
|
|
sectors = 5760;
|
|
WriteBPB(bpb, sectors, FatType.Fat12, 224, 0, 1, 1, new Geometry(80, 2, 36), true, volId, label);
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentException("Unrecognised Floppy Disk type", nameof(type));
|
|
}
|
|
|
|
stream.Write(bpb, 0, bpb.Length);
|
|
|
|
// Write both FAT copies
|
|
uint fatSize = CalcFatSize(sectors, FatType.Fat12, 1);
|
|
byte[] fat = new byte[fatSize * Sizes.Sector];
|
|
FatBuffer fatBuffer = new FatBuffer(FatType.Fat12, fat);
|
|
fatBuffer.SetNext(0, 0xFFFFFFF0);
|
|
fatBuffer.SetEndOfChain(1);
|
|
stream.Write(fat, 0, fat.Length);
|
|
stream.Write(fat, 0, fat.Length);
|
|
|
|
// Write the (empty) root directory
|
|
uint rootDirSectors = (224 * 32 + Sizes.Sector - 1) / Sizes.Sector;
|
|
byte[] rootDir = new byte[rootDirSectors * Sizes.Sector];
|
|
stream.Write(rootDir, 0, rootDir.Length);
|
|
|
|
// Write a single byte at the end of the disk to ensure the stream is at least as big
|
|
// as needed for this disk image.
|
|
stream.Position = pos + sectors * Sizes.Sector - 1;
|
|
stream.WriteByte(0);
|
|
|
|
// Give the caller access to the new file system
|
|
stream.Position = pos;
|
|
return new FatFileSystem(stream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Formats a virtual hard disk partition.
|
|
/// </summary>
|
|
/// <param name="disk">The disk containing the partition.</param>
|
|
/// <param name="partitionIndex">The index of the partition on the disk.</param>
|
|
/// <param name="label">The volume label for the partition (or null).</param>
|
|
/// <returns>An object that provides access to the newly created partition file system.</returns>
|
|
public static FatFileSystem FormatPartition(VirtualDisk disk, int partitionIndex, string label)
|
|
{
|
|
using (Stream partitionStream = disk.Partitions[partitionIndex].Open())
|
|
{
|
|
return FormatPartition(
|
|
partitionStream,
|
|
label,
|
|
disk.Geometry,
|
|
(int)disk.Partitions[partitionIndex].FirstSector,
|
|
(int)(1 + disk.Partitions[partitionIndex].LastSector - disk.Partitions[partitionIndex].FirstSector),
|
|
0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a formatted hard disk partition in a stream.
|
|
/// </summary>
|
|
/// <param name="stream">The stream to write the new file system to.</param>
|
|
/// <param name="label">The volume label for the partition (or null).</param>
|
|
/// <param name="diskGeometry">The geometry of the disk containing the partition.</param>
|
|
/// <param name="firstSector">The starting sector number of this partition (hide's sectors in other partitions).</param>
|
|
/// <param name="sectorCount">The number of sectors in this partition.</param>
|
|
/// <param name="reservedSectors">The number of reserved sectors at the start of the partition.</param>
|
|
/// <returns>An object that provides access to the newly created partition file system.</returns>
|
|
public static FatFileSystem FormatPartition(
|
|
Stream stream,
|
|
string label,
|
|
Geometry diskGeometry,
|
|
int firstSector,
|
|
int sectorCount,
|
|
short reservedSectors)
|
|
{
|
|
long pos = stream.Position;
|
|
|
|
long ticks = DateTime.UtcNow.Ticks;
|
|
uint volId = (uint)((ticks & 0xFFFF) | (ticks >> 32));
|
|
|
|
byte sectorsPerCluster;
|
|
FatType fatType;
|
|
ushort maxRootEntries;
|
|
|
|
/*
|
|
* Write the BIOS Parameter Block (BPB) - a single sector
|
|
*/
|
|
|
|
byte[] bpb = new byte[512];
|
|
if (sectorCount <= 8400)
|
|
{
|
|
throw new ArgumentException("Requested size is too small for a partition");
|
|
}
|
|
if (sectorCount < 1024 * 1024)
|
|
{
|
|
fatType = FatType.Fat16;
|
|
maxRootEntries = 512;
|
|
if (sectorCount <= 32680)
|
|
{
|
|
sectorsPerCluster = 2;
|
|
}
|
|
else if (sectorCount <= 262144)
|
|
{
|
|
sectorsPerCluster = 4;
|
|
}
|
|
else if (sectorCount <= 524288)
|
|
{
|
|
sectorsPerCluster = 8;
|
|
}
|
|
else
|
|
{
|
|
sectorsPerCluster = 16;
|
|
}
|
|
|
|
if (reservedSectors < 1)
|
|
{
|
|
reservedSectors = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fatType = FatType.Fat32;
|
|
maxRootEntries = 0;
|
|
if (sectorCount <= 532480)
|
|
{
|
|
sectorsPerCluster = 1;
|
|
}
|
|
else if (sectorCount <= 16777216)
|
|
{
|
|
sectorsPerCluster = 8;
|
|
}
|
|
else if (sectorCount <= 33554432)
|
|
{
|
|
sectorsPerCluster = 16;
|
|
}
|
|
else if (sectorCount <= 67108864)
|
|
{
|
|
sectorsPerCluster = 32;
|
|
}
|
|
else
|
|
{
|
|
sectorsPerCluster = 64;
|
|
}
|
|
|
|
if (reservedSectors < 32)
|
|
{
|
|
reservedSectors = 32;
|
|
}
|
|
}
|
|
|
|
WriteBPB(bpb, (uint)sectorCount, fatType, maxRootEntries, (uint)firstSector, (ushort)reservedSectors,
|
|
sectorsPerCluster, diskGeometry, false, volId, label);
|
|
stream.Write(bpb, 0, bpb.Length);
|
|
|
|
/*
|
|
* Skip the reserved sectors
|
|
*/
|
|
|
|
stream.Position = pos + (ushort)reservedSectors * Sizes.Sector;
|
|
|
|
/*
|
|
* Write both FAT copies
|
|
*/
|
|
|
|
byte[] fat = new byte[CalcFatSize((uint)sectorCount, fatType, sectorsPerCluster) * Sizes.Sector];
|
|
FatBuffer fatBuffer = new FatBuffer(fatType, fat);
|
|
fatBuffer.SetNext(0, 0xFFFFFFF8);
|
|
fatBuffer.SetEndOfChain(1);
|
|
if (fatType >= FatType.Fat32)
|
|
{
|
|
// Mark cluster 2 as End-of-chain (i.e. root directory
|
|
// is a single cluster in length)
|
|
fatBuffer.SetEndOfChain(2);
|
|
}
|
|
|
|
stream.Write(fat, 0, fat.Length);
|
|
stream.Write(fat, 0, fat.Length);
|
|
|
|
/*
|
|
* Write the (empty) root directory
|
|
*/
|
|
|
|
uint rootDirSectors;
|
|
if (fatType < FatType.Fat32)
|
|
{
|
|
rootDirSectors = (uint)((maxRootEntries * 32 + Sizes.Sector - 1) / Sizes.Sector);
|
|
}
|
|
else
|
|
{
|
|
rootDirSectors = sectorsPerCluster;
|
|
}
|
|
|
|
byte[] rootDir = new byte[rootDirSectors * Sizes.Sector];
|
|
stream.Write(rootDir, 0, rootDir.Length);
|
|
|
|
/*
|
|
* Make sure the stream is at least as large as the partition requires.
|
|
*/
|
|
|
|
if (stream.Length < pos + sectorCount * Sizes.Sector)
|
|
{
|
|
stream.SetLength(pos + sectorCount * Sizes.Sector);
|
|
}
|
|
|
|
/*
|
|
* Give the caller access to the new file system
|
|
*/
|
|
|
|
stream.Position = pos;
|
|
return new FatFileSystem(stream);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|