timamsk/WPinternals
1
0
Fork 0
mirror of https://github.com/ReneLergner/WPinternals.git synced 2026-06-14 03:16:40 +10:00
Code Issues Packages Projects Releases Wiki Activity

Project: Move WPinternals code to a WPinternals folder

Browse Source
This commit is contained in:
Gustave Monce
2021-08-14 11:04:37 +02:00
parent 668a9b7fe2
commit 17bc763761
203 changed files with 48170 additions and 48170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
DiscUtils/DiscUtils.Core/CoreCompat/EncodingHelper.cs
-23
View File
@@ -1,23 +0,0 @@
#if !NET40 && !NET45
using System.Text;
#endif
namespace DiscUtils.CoreCompat
{
internal static class EncodingHelper
{
private static bool _registered;
public static void RegisterEncodings()
{
if (_registered)
return;
_registered = true;
#if !NET40 && !NET45
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
#endif
}
}
}
DiscUtils/DiscUtils.Core/Internal/Utilities.cs
-459
View File
@@ -1,459 +0,0 @@
//
// 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.IO;
using System.Text;
using System.Text.RegularExpressions;
namespace DiscUtils.Internal
{
internal static class Utilities
{
/// <summary>
/// Converts between two arrays.
/// </summary>
/// <typeparam name="T">The type of the elements of the source array.</typeparam>
/// <typeparam name="U">The type of the elements of the destination array.</typeparam>
/// <param name="source">The source array.</param>
/// <param name="func">The function to map from source type to destination type.</param>
/// <returns>The resultant array.</returns>
public static U[] Map<T, U>(ICollection<T> source, Func<T, U> func)
{
U[] result = new U[source.Count];
int i = 0;
foreach (T sVal in source)
{
result[i++] = func(sVal);
}
return result;
}
/// <summary>
/// Converts between two arrays.
/// </summary>
/// <typeparam name="T">The type of the elements of the source array.</typeparam>
/// <typeparam name="U">The type of the elements of the destination array.</typeparam>
/// <param name="source">The source array.</param>
/// <param name="func">The function to map from source type to destination type.</param>
/// <returns>The resultant array.</returns>
public static U[] Map<T, U>(IEnumerable<T> source, Func<T, U> func)
{
List<U> result = new();
foreach (T sVal in source)
{
result.Add(func(sVal));
}
return result.ToArray();
}
/// <summary>
/// Filters a collection into a new collection.
/// </summary>
/// <typeparam name="C">The type of the new collection.</typeparam>
/// <typeparam name="T">The type of the collection entries.</typeparam>
/// <param name="source">The collection to filter.</param>
/// <param name="predicate">The predicate to select which entries are carried over.</param>
/// <returns>The new collection, containing all entries where the predicate returns <c>true</c>.</returns>
public static C Filter<C, T>(ICollection<T> source, Func<T, bool> predicate) where C : ICollection<T>, new()
{
C result = new();
foreach (T val in source)
{
if (predicate(val))
{
result.Add(val);
}
}
return result;
}
/// <summary>
/// Indicates if two ranges overlap.
/// </summary>
/// <typeparam name="T">The type of the ordinals.</typeparam>
/// <param name="xFirst">The lowest ordinal of the first range (inclusive).</param>
/// <param name="xLast">The highest ordinal of the first range (exclusive).</param>
/// <param name="yFirst">The lowest ordinal of the second range (inclusive).</param>
/// <param name="yLast">The highest ordinal of the second range (exclusive).</param>
/// <returns><c>true</c> if the ranges overlap, else <c>false</c>.</returns>
public static bool RangesOverlap<T>(T xFirst, T xLast, T yFirst, T yLast) where T : IComparable<T>
{
return !((xLast.CompareTo(yFirst) <= 0) || (xFirst.CompareTo(yLast) >= 0));
}
#region Bit Twiddling
public static bool IsAllZeros(byte[] buffer, int offset, int count)
{
int end = offset + count;
for (int i = offset; i < end; ++i)
{
if (buffer[i] != 0)
{
return false;
}
}
return true;
}
public static bool IsPowerOfTwo(uint val)
{
if (val == 0)
{
return false;
}
while ((val & 1) != 1)
{
val >>= 1;
}
return val == 1;
}
public static bool IsPowerOfTwo(long val)
{
if (val == 0)
{
return false;
}
while ((val & 1) != 1)
{
val >>= 1;
}
return val == 1;
}
public static bool AreEqual(byte[] a, byte[] b)
{
if (a.Length != b.Length)
{
return false;
}
for (int i = 0; i < a.Length; ++i)
{
if (a[i] != b[i])
{
return false;
}
}
return true;
}
public static ushort BitSwap(ushort value)
{
return (ushort)(((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8));
}
public static uint BitSwap(uint value)
{
return ((value & 0xFF) << 24) | ((value & 0xFF00) << 8) | ((value & 0x00FF0000) >> 8) |
((value & 0xFF000000) >> 24);
}
public static ulong BitSwap(ulong value)
{
return ((ulong)BitSwap((uint)(value & 0xFFFFFFFF)) << 32) | BitSwap((uint)(value >> 32));
}
public static short BitSwap(short value)
{
return (short)BitSwap((ushort)value);
}
public static int BitSwap(int value)
{
return (int)BitSwap((uint)value);
}
public static long BitSwap(long value)
{
return (long)BitSwap((ulong)value);
}
#endregion
#region Path Manipulation
/// <summary>
/// Extracts the directory part of a path.
/// </summary>
/// <param name="path">The path to process.</param>
/// <returns>The directory part.</returns>
public static string GetDirectoryFromPath(string path)
{
string trimmed = path.TrimEnd('\\');
int index = trimmed.LastIndexOf('\\');
if (index < 0)
{
return string.Empty; // No directory, just a file name
}
return trimmed.Substring(0, index);
}
/// <summary>
/// Extracts the file part of a path.
/// </summary>
/// <param name="path">The path to process.</param>
/// <returns>The file part of the path.</returns>
public static string GetFileFromPath(string path)
{
string trimmed = path.Trim('\\');
int index = trimmed.LastIndexOf('\\');
if (index < 0)
{
return trimmed; // No directory, just a file name
}
return trimmed.Substring(index + 1);
}
/// <summary>
/// Combines two paths.
/// </summary>
/// <param name="a">The first part of the path.</param>
/// <param name="b">The second part of the path.</param>
/// <returns>The combined path.</returns>
public static string CombinePaths(string a, string b)
{
if (string.IsNullOrEmpty(a) || (b.Length > 0 && b[0] == '\\'))
{
return b;
}
if (string.IsNullOrEmpty(b))
{
return a;
}
return a.TrimEnd('\\') + '\\' + b.TrimStart('\\');
}
/// <summary>
/// Resolves a relative path into an absolute one.
/// </summary>
/// <param name="basePath">The base path to resolve from.</param>
/// <param name="relativePath">The relative path.</param>
/// <returns>The absolute path. If no <paramref name="basePath"/> is specified
/// then relativePath is returned as-is. If <paramref name="relativePath"/>
/// contains more '..' characters than the base path contains levels of
/// directory, the resultant string be the root drive followed by the file name.
/// If no the basePath starts with '\' (no drive specified) then the returned
/// path will also start with '\'.
/// For example: (\TEMP\Foo.txt, ..\..\Bar.txt) gives (\Bar.txt).
/// </returns>
public static string ResolveRelativePath(string basePath, string relativePath)
{
if (string.IsNullOrEmpty(basePath))
{
return relativePath;
}
if (!basePath.EndsWith(@"\"))
basePath = Path.GetDirectoryName(basePath);
string merged = Path.GetFullPath(Path.Combine(basePath, relativePath));
if (basePath.StartsWith(@"\") && merged.Length > 2 && merged[1].Equals(':'))
{
return merged.Substring(2);
}
return merged;
}
public static string ResolvePath(string basePath, string path)
{
if (!path.StartsWith("\\", StringComparison.OrdinalIgnoreCase))
{
return ResolveRelativePath(basePath, path);
}
return path;
}
public static string MakeRelativePath(string path, string basePath)
{
List<string> pathElements =
new(path.Split(new[] { '\\' }, StringSplitOptions.RemoveEmptyEntries));
List<string> basePathElements =
new(basePath.Split(new[] { '\\' }, StringSplitOptions.RemoveEmptyEntries));
if (!basePath.EndsWith("\\", StringComparison.Ordinal) && basePathElements.Count > 0)
{
basePathElements.RemoveAt(basePathElements.Count - 1);
}
// Find first part of paths that don't match
int i = 0;
while (i < Math.Min(pathElements.Count - 1, basePathElements.Count))
{
if (!string.Equals(pathElements[i], basePathElements[i], StringComparison.InvariantCultureIgnoreCase))
{
break;
}
++i;
}
// For each remaining part of the base path, insert '..'
StringBuilder result = new();
if (i == basePathElements.Count)
{
result.Append(@".\");
}
else if (i < basePathElements.Count)
{
for (int j = 0; j < basePathElements.Count - i; ++j)
{
result.Append(@"..\");
}
}
// For each remaining part of the path, add the path element
for (int j = i; j < pathElements.Count - 1; ++j)
{
result.Append(pathElements[j]);
result.Append(@"\");
}
result.Append(pathElements[^1]);
// If the target was a directory, put the terminator back
if (path.EndsWith(@"\", StringComparison.Ordinal))
{
result.Append(@"\");
}
return result.ToString();
}
#endregion
#region Filesystem Support
/// <summary>
/// Indicates if a file name matches the 8.3 pattern.
/// </summary>
/// <param name="name">The name to test.</param>
/// <returns><c>true</c> if the name is 8.3, otherwise <c>false</c>.</returns>
public static bool Is8Dot3(string name)
{
if (name.Length > 12)
{
return false;
}
string[] split = name.Split('.');
if (split.Length > 2 || split.Length < 1)
{
return false;
}
if (split[0].Length > 8)
{
return false;
}
foreach (char ch in split[0])
{
if (!Is8Dot3Char(ch))
{
return false;
}
}
if (split.Length > 1)
{
if (split[1].Length > 3)
{
return false;
}
foreach (char ch in split[1])
{
if (!Is8Dot3Char(ch))
{
return false;
}
}
}
return true;
}
public static bool Is8Dot3Char(char ch)
{
return (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || "_^$~!#%£-{}()@'`&".IndexOf(ch) != -1;
}
/// <summary>
/// Converts a 'standard' wildcard file/path specification into a regular expression.
/// </summary>
/// <param name="pattern">The wildcard pattern to convert.</param>
/// <returns>The resultant regular expression.</returns>
/// <remarks>
/// The wildcard * (star) matches zero or more characters (including '.'), and ?
/// (question mark) matches precisely one character (except '.').
/// </remarks>
public static Regex ConvertWildcardsToRegEx(string pattern)
{
if (!pattern.Contains("."))
{
pattern += ".";
}
string query = "^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", "[^.]") + "$";
return new Regex(query, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
}
public static FileAttributes FileAttributesFromUnixFileType(UnixFileType fileType)
{
return fileType switch
{
UnixFileType.Fifo => FileAttributes.Device | FileAttributes.System,
UnixFileType.Character => FileAttributes.Device | FileAttributes.System,
UnixFileType.Directory => FileAttributes.Directory,
UnixFileType.Block => FileAttributes.Device | FileAttributes.System,
UnixFileType.Regular => FileAttributes.Normal,
UnixFileType.Link => FileAttributes.ReparsePoint,
UnixFileType.Socket => FileAttributes.Device | FileAttributes.System,
_ => 0,
};
}
#endregion
}
}
DiscUtils/DiscUtils.Fat/ClusterReader.cs
-95
View File
@@ -1,95 +0,0 @@
//
// 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.IO;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
internal sealed class ClusterReader
{
private readonly int _bytesPerSector;
/// <summary>
/// Pre-calculated value because of number of uses of this externally.
/// </summary>
private readonly int _clusterSize;
private readonly int _firstDataSector;
private readonly int _sectorsPerCluster;
private readonly Stream _stream;
public ClusterReader(Stream stream, int firstDataSector, int sectorsPerCluster, int bytesPerSector)
{
_stream = stream;
_firstDataSector = firstDataSector;
_sectorsPerCluster = sectorsPerCluster;
_bytesPerSector = bytesPerSector;
_clusterSize = _sectorsPerCluster * _bytesPerSector;
}
public int ClusterSize
{
get { return _clusterSize; }
}
public void ReadCluster(uint cluster, byte[] buffer, int offset)
{
if (offset + ClusterSize > buffer.Length)
{
throw new ArgumentOutOfRangeException(nameof(offset),
"buffer is too small - cluster would overflow buffer");
}
uint firstSector = (uint)(((cluster - 2) * _sectorsPerCluster) + _firstDataSector);
_stream.Position = firstSector * _bytesPerSector;
StreamUtilities.ReadExact(_stream, buffer, offset, _clusterSize);
}
internal void WriteCluster(uint cluster, byte[] buffer, int offset)
{
if (offset + ClusterSize > buffer.Length)
{
throw new ArgumentOutOfRangeException(nameof(offset),
"buffer is too small - cluster would overflow buffer");
}
uint firstSector = (uint)(((cluster - 2) * _sectorsPerCluster) + _firstDataSector);
_stream.Position = firstSector * _bytesPerSector;
_stream.Write(buffer, offset, _clusterSize);
}
internal void WipeCluster(uint cluster)
{
uint firstSector = (uint)(((cluster - 2) * _sectorsPerCluster) + _firstDataSector);
_stream.Position = firstSector * _bytesPerSector;
_stream.Write(new byte[_clusterSize], 0, _clusterSize);
}
}
}
DiscUtils/DiscUtils.Fat/ClusterStream.cs
-457
View File
@@ -1,457 +0,0 @@
//
// 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.IO;
namespace DiscUtils.Fat
{
internal class ClusterStream : Stream
{
private readonly FileAccess _access;
private readonly byte[] _clusterBuffer;
private readonly FileAllocationTable _fat;
private readonly List<uint> _knownClusters;
private readonly ClusterReader _reader;
private bool _atEOF;
private uint _currentCluster;
private uint _length;
private long _position;
internal ClusterStream(FatFileSystem fileSystem, FileAccess access, uint firstCluster, uint length)
{
_access = access;
_reader = fileSystem.ClusterReader;
_fat = fileSystem.Fat;
_length = length;
_knownClusters = new List<uint>();
if (firstCluster != 0)
{
_knownClusters.Add(firstCluster);
}
else
{
_knownClusters.Add(FatBuffer.EndOfChain);
}
if (_length == uint.MaxValue)
{
_length = DetectLength();
}
_currentCluster = uint.MaxValue;
_clusterBuffer = new byte[_reader.ClusterSize];
}
public override bool CanRead
{
get { return _access == FileAccess.Read || _access == FileAccess.ReadWrite; }
}
public override bool CanSeek
{
get { return true; }
}
public override bool CanWrite
{
get { return _access == FileAccess.ReadWrite || _access == FileAccess.Write; }
}
public override long Length
{
get { return _length; }
}
public override long Position
{
get { return _position; }
set
{
if (value >= 0)
{
_position = value;
_atEOF = false;
}
else
{
throw new ArgumentOutOfRangeException(nameof(value), "Attempt to move before beginning of stream");
}
}
}
public event FirstClusterChangedDelegate FirstClusterChanged;
public override void Flush() { }
public override int Read(byte[] buffer, int offset, int count)
{
if (!CanRead)
{
throw new IOException("Attempt to read from file not opened for read");
}
if (_position > _length)
{
throw new IOException("Attempt to read beyond end of file");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), "Attempt to read negative number of bytes");
}
int target = count;
if (_length - _position < count)
{
target = (int)(_length - _position);
}
if (!TryLoadCurrentCluster())
{
if ((_position == _length || _position == DetectLength()) && !_atEOF)
{
_atEOF = true;
return 0;
}
throw new IOException("Attempt to read beyond known clusters");
}
int numRead = 0;
while (numRead < target)
{
int clusterOffset = (int)(_position % _reader.ClusterSize);
int toCopy = Math.Min(_reader.ClusterSize - clusterOffset, target - numRead);
Array.Copy(_clusterBuffer, clusterOffset, buffer, offset + numRead, toCopy);
// Remember how many we've read in total
numRead += toCopy;
// Increment the position
_position += toCopy;
// Abort if we've hit the end of the file
if (!TryLoadCurrentCluster())
{
break;
}
}
if (numRead == 0)
{
_atEOF = true;
}
return numRead;
}
public override long Seek(long offset, SeekOrigin origin)
{
long newPos = offset;
if (origin == SeekOrigin.Current)
{
newPos += _position;
}
else if (origin == SeekOrigin.End)
{
newPos += Length;
}
_position = newPos;
_atEOF = false;
return newPos;
}
public override void SetLength(long value)
{
long desiredNumClusters = (value + _reader.ClusterSize - 1) / _reader.ClusterSize;
long actualNumClusters = (_length + _reader.ClusterSize - 1) / _reader.ClusterSize;
if (desiredNumClusters < actualNumClusters)
{
if (!TryGetClusterByPosition(value, out uint cluster))
{
throw new IOException("Internal state corrupt - unable to find cluster");
}
uint firstToFree = _fat.GetNext(cluster);
_fat.SetEndOfChain(cluster);
_fat.FreeChain(firstToFree);
while (_knownClusters.Count > desiredNumClusters)
{
_knownClusters.RemoveAt(_knownClusters.Count - 1);
}
_knownClusters.Add(FatBuffer.EndOfChain);
if (desiredNumClusters == 0)
{
FireFirstClusterAllocated(0);
}
}
else if (desiredNumClusters > actualNumClusters)
{
while (!TryGetClusterByPosition(value, out uint cluster))
{
cluster = ExtendChain();
_reader.WipeCluster(cluster);
}
}
if (_length != value)
{
_length = (uint)value;
if (_position > _length)
{
_position = _length;
}
}
}
public override void Write(byte[] buffer, int offset, int count)
{
int bytesRemaining = count;
if (!CanWrite)
{
throw new IOException("Attempting to write to file not opened for writing");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), count,
"Attempting to write negative number of bytes");
}
if (offset > buffer.Length || offset + count > buffer.Length)
{
throw new ArgumentException("Attempt to write bytes outside of the buffer");
}
// TODO: Free space check...
try
{
while (bytesRemaining > 0)
{
// Extend the stream until it encompasses _position
uint cluster;
while (!TryGetClusterByPosition(_position, out cluster))
{
cluster = ExtendChain();
_reader.WipeCluster(cluster);
}
// Fill this cluster with as much data as we can (WriteToCluster preserves existing cluster
// data, if necessary)
int numWritten = WriteToCluster(cluster, (int)(_position % _reader.ClusterSize), buffer, offset,
bytesRemaining);
offset += numWritten;
bytesRemaining -= numWritten;
_position += numWritten;
}
_length = (uint)Math.Max(_length, _position);
}
finally
{
_fat.Flush();
}
_atEOF = false;
}
/// <summary>
/// Writes up to the next cluster boundary, making sure to preserve existing data in the cluster
/// that falls outside of the updated range.
/// </summary>
/// <param name="cluster">The cluster to write to.</param>
/// <param name="pos">The file position of the write (within the cluster).</param>
/// <param name="buffer">The buffer with the new data.</param>
/// <param name="offset">Offset into buffer of the first byte to write.</param>
/// <param name="count">The maximum number of bytes to write.</param>
/// <returns>The number of bytes written - either count, or the number that fit up to
/// the cluster boundary.</returns>
private int WriteToCluster(uint cluster, int pos, byte[] buffer, int offset, int count)
{
if (pos == 0 && count >= _reader.ClusterSize)
{
_currentCluster = cluster;
Array.Copy(buffer, offset, _clusterBuffer, 0, _reader.ClusterSize);
WriteCurrentCluster();
return _reader.ClusterSize;
}
// Partial cluster, so need to read existing cluster data first
LoadCluster(cluster);
int copyLength = Math.Min(count, _reader.ClusterSize - (pos % _reader.ClusterSize));
Array.Copy(buffer, offset, _clusterBuffer, pos, copyLength);
WriteCurrentCluster();
return copyLength;
}
/// <summary>
/// Adds a new cluster to the end of the existing chain, by allocating a free cluster.
/// </summary>
/// <returns>The cluster allocated.</returns>
/// <remarks>This method does not initialize the data in the cluster, the caller should
/// perform a write to ensure the cluster data is in known state.</remarks>
private uint ExtendChain()
{
// Sanity check - make sure the final known cluster is the EOC marker
if (!_fat.IsEndOfChain(_knownClusters[^1]))
{
throw new IOException("Corrupt file system: final cluster isn't End-of-Chain");
}
if (!_fat.TryGetFreeCluster(out uint cluster))
{
throw new IOException("Out of disk space");
}
_fat.SetEndOfChain(cluster);
if (_knownClusters.Count == 1)
{
FireFirstClusterAllocated(cluster);
}
else
{
_fat.SetNext(_knownClusters[^2], cluster);
}
_knownClusters[^1] = cluster;
_knownClusters.Add(_fat.GetNext(cluster));
return cluster;
}
private void FireFirstClusterAllocated(uint cluster)
{
if (FirstClusterChanged != null)
{
FirstClusterChanged(cluster);
}
}
private bool TryLoadCurrentCluster()
{
return TryLoadClusterByPosition(_position);
}
private bool TryLoadClusterByPosition(long pos)
{
if (!TryGetClusterByPosition(pos, out uint cluster))
{
return false;
}
// Read the cluster, it's different to the one currently loaded
if (cluster != _currentCluster)
{
_reader.ReadCluster(cluster, _clusterBuffer, 0);
_currentCluster = cluster;
}
return true;
}
private void LoadCluster(uint cluster)
{
// Read the cluster, it's different to the one currently loaded
if (cluster != _currentCluster)
{
_reader.ReadCluster(cluster, _clusterBuffer, 0);
_currentCluster = cluster;
}
}
private void WriteCurrentCluster()
{
_reader.WriteCluster(_currentCluster, _clusterBuffer, 0);
}
private bool TryGetClusterByPosition(long pos, out uint cluster)
{
int index = (int)(pos / _reader.ClusterSize);
if (_knownClusters.Count <= index && !TryPopulateKnownClusters(index))
{
cluster = uint.MaxValue;
return false;
}
// Chain is shorter than the current stream position
if (_knownClusters.Count <= index)
{
cluster = uint.MaxValue;
return false;
}
cluster = _knownClusters[index];
// This is the 'special' End-of-chain cluster identifer, so the stream position
// is greater than the actual file length.
if (_fat.IsEndOfChain(cluster))
{
return false;
}
return true;
}
private bool TryPopulateKnownClusters(int index)
{
uint lastKnown = _knownClusters[^1];
while (!_fat.IsEndOfChain(lastKnown) && _knownClusters.Count <= index)
{
lastKnown = _fat.GetNext(lastKnown);
_knownClusters.Add(lastKnown);
}
return _knownClusters.Count > index;
}
private uint DetectLength()
{
while (!_fat.IsEndOfChain(_knownClusters[^1]))
{
if (!TryPopulateKnownClusters(_knownClusters.Count))
{
throw new IOException("Corrupt file stream - unable to discover end of cluster chain");
}
}
return (uint)((_knownClusters.Count - 1) * (long)_reader.ClusterSize);
}
}
}
DiscUtils/DiscUtils.Fat/DirectoryEntry.cs
-207
View File
@@ -1,207 +0,0 @@
//
// 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.IO;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
internal class DirectoryEntry
{
private readonly FatType _fatVariant;
private readonly FatFileSystemOptions _options;
private byte _attr;
private ushort _creationDate;
private ushort _creationTime;
private byte _creationTimeTenth;
private uint _fileSize;
private ushort _firstClusterHi;
private ushort _firstClusterLo;
private ushort _lastAccessDate;
private ushort _lastWriteDate;
private ushort _lastWriteTime;
internal DirectoryEntry(FatFileSystemOptions options, Stream stream, FatType fatVariant)
{
_options = options;
_fatVariant = fatVariant;
byte[] buffer = StreamUtilities.ReadExact(stream, 32);
Load(buffer, 0);
}
internal DirectoryEntry(FatFileSystemOptions options, FileName name, FatAttributes attrs, FatType fatVariant)
{
_options = options;
_fatVariant = fatVariant;
Name = name;
_attr = (byte)attrs;
}
internal DirectoryEntry(DirectoryEntry toCopy)
{
_options = toCopy._options;
_fatVariant = toCopy._fatVariant;
Name = toCopy.Name;
_attr = toCopy._attr;
_creationTimeTenth = toCopy._creationTimeTenth;
_creationTime = toCopy._creationTime;
_creationDate = toCopy._creationDate;
_lastAccessDate = toCopy._lastAccessDate;
_firstClusterHi = toCopy._firstClusterHi;
_lastWriteTime = toCopy._lastWriteTime;
_firstClusterLo = toCopy._firstClusterLo;
_fileSize = toCopy._fileSize;
}
public FatAttributes Attributes
{
get { return (FatAttributes)_attr; }
set { _attr = (byte)value; }
}
public DateTime CreationTime
{
get { return FileTimeToDateTime(_creationDate, _creationTime, _creationTimeTenth); }
set { DateTimeToFileTime(value, out _creationDate, out _creationTime, out _creationTimeTenth); }
}
public int FileSize
{
get { return (int)_fileSize; }
set { _fileSize = (uint)value; }
}
public uint FirstCluster
{
get
{
if (_fatVariant == FatType.Fat32)
{
return (uint)(_firstClusterHi << 16) | _firstClusterLo;
}
return _firstClusterLo;
}
set
{
if (_fatVariant == FatType.Fat32)
{
_firstClusterHi = (ushort)((value >> 16) & 0xFFFF);
}
_firstClusterLo = (ushort)(value & 0xFFFF);
}
}
public DateTime LastAccessTime
{
get { return FileTimeToDateTime(_lastAccessDate, 0, 0); }
set { DateTimeToFileTime(value, out _lastAccessDate); }
}
public DateTime LastWriteTime
{
get { return FileTimeToDateTime(_lastWriteDate, _lastWriteTime, 0); }
set { DateTimeToFileTime(value, out _lastWriteDate, out _lastWriteTime); }
}
public FileName Name { get; set; }
internal void WriteTo(Stream stream)
{
byte[] buffer = new byte[32];
Name.GetBytes(buffer, 0);
buffer[11] = _attr;
buffer[13] = _creationTimeTenth;
EndianUtilities.WriteBytesLittleEndian(_creationTime, buffer, 14);
EndianUtilities.WriteBytesLittleEndian(_creationDate, buffer, 16);
EndianUtilities.WriteBytesLittleEndian(_lastAccessDate, buffer, 18);
EndianUtilities.WriteBytesLittleEndian(_firstClusterHi, buffer, 20);
EndianUtilities.WriteBytesLittleEndian(_lastWriteTime, buffer, 22);
EndianUtilities.WriteBytesLittleEndian(_lastWriteDate, buffer, 24);
EndianUtilities.WriteBytesLittleEndian(_firstClusterLo, buffer, 26);
EndianUtilities.WriteBytesLittleEndian(_fileSize, buffer, 28);
stream.Write(buffer, 0, buffer.Length);
}
private static DateTime FileTimeToDateTime(ushort date, ushort time, byte tenths)
{
if (date == 0 || date == 0xFFFF)
{
// Return Epoch - this is an invalid date
return FatFileSystem.Epoch;
}
int year = 1980 + ((date & 0xFE00) >> 9);
int month = (date & 0x01E0) >> 5;
int day = date & 0x001F;
int hour = (time & 0xF800) >> 11;
int minute = (time & 0x07E0) >> 5;
int second = ((time & 0x001F) * 2) + (tenths / 100);
int millis = tenths % 100 * 10;
return new DateTime(year, month, day, hour, minute, second, millis);
}
private static void DateTimeToFileTime(DateTime value, out ushort date)
{
DateTimeToFileTime(value, out date, out ushort time, out byte tenths);
}
private static void DateTimeToFileTime(DateTime value, out ushort date, out ushort time)
{
DateTimeToFileTime(value, out date, out time, out byte tenths);
}
private static void DateTimeToFileTime(DateTime value, out ushort date, out ushort time, out byte tenths)
{
if (value.Year < 1980)
{
value = FatFileSystem.Epoch;
}
date =
(ushort)((((value.Year - 1980) << 9) & 0xFE00) | ((value.Month << 5) & 0x01E0) | (value.Day & 0x001F));
time =
(ushort)(((value.Hour << 11) & 0xF800) | ((value.Minute << 5) & 0x07E0) | ((value.Second / 2) & 0x001F));
tenths = (byte)((value.Second % 2 * 100) + (value.Millisecond / 10));
}
private void Load(byte[] data, int offset)
{
Name = new FileName(data, offset);
_attr = data[offset + 11];
_creationTimeTenth = data[offset + 13];
_creationTime = EndianUtilities.ToUInt16LittleEndian(data, offset + 14);
_creationDate = EndianUtilities.ToUInt16LittleEndian(data, offset + 16);
_lastAccessDate = EndianUtilities.ToUInt16LittleEndian(data, offset + 18);
_firstClusterHi = EndianUtilities.ToUInt16LittleEndian(data, offset + 20);
_lastWriteTime = EndianUtilities.ToUInt16LittleEndian(data, offset + 22);
_lastWriteDate = EndianUtilities.ToUInt16LittleEndian(data, offset + 24);
_firstClusterLo = EndianUtilities.ToUInt16LittleEndian(data, offset + 26);
_fileSize = EndianUtilities.ToUInt32LittleEndian(data, offset + 28);
}
}
}
DiscUtils/DiscUtils.Fat/FatAttributes.cs
-37
View File
@@ -1,37 +0,0 @@
//
// 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;
namespace DiscUtils.Fat
{
[Flags]
internal enum FatAttributes : byte
{
ReadOnly = 0x01,
Hidden = 0x02,
System = 0x04,
VolumeId = 0x08,
Directory = 0x10,
Archive = 0x20
}
}
DiscUtils/DiscUtils.Fat/FatBuffer.cs
-257
View File
@@ -1,257 +0,0 @@
//
// 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.IO;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
internal class FatBuffer
{
/// <summary>
/// The End-of-chain marker to WRITE (SetNext). Don't use this value to test for end of chain.
/// </summary>
/// <remarks>
/// The actual end-of-chain marker bits on disk vary by FAT type, and can end ...F8 through ...FF.
/// </remarks>
public const uint EndOfChain = 0xFFFFFFFF;
/// <summary>
/// The Bad-Cluster marker to WRITE (SetNext). Don't use this value to test for bad clusters.
/// </summary>
/// <remarks>
/// The actual bad-cluster marker bits on disk vary by FAT type.
/// </remarks>
public const uint BadCluster = 0xFFFFFFF7;
/// <summary>
/// The Free-Cluster marker to WRITE (SetNext). Don't use this value to test for free clusters.
/// </summary>
/// <remarks>
/// The actual free-cluster marker bits on disk vary by FAT type.
/// </remarks>
public const uint FreeCluster = 0;
private const uint DirtyRegionSize = 512;
private readonly byte[] _buffer;
private readonly Dictionary<uint, uint> _dirtySectors;
private readonly FatType _type;
private uint _nextFreeCandidate;
public FatBuffer(FatType type, byte[] buffer)
{
_type = type;
_buffer = buffer;
_dirtySectors = new Dictionary<uint, uint>();
}
internal int NumEntries
{
get
{
return _type switch
{
FatType.Fat12 => _buffer.Length / 3 * 2,
FatType.Fat16 => _buffer.Length / 2,
// FAT32
_ => _buffer.Length / 4,
};
}
}
internal int Size
{
get { return _buffer.Length; }
}
internal bool IsFree(uint val)
{
return val == 0;
}
internal bool IsEndOfChain(uint val)
{
return _type switch
{
FatType.Fat12 => (val & 0x0FFF) >= 0x0FF8,
FatType.Fat16 => (val & 0xFFFF) >= 0xFFF8,
FatType.Fat32 => (val & 0x0FFFFFF8) >= 0x0FFFFFF8,
_ => throw new ArgumentException("Unknown FAT type"),
};
}
internal bool IsBadCluster(uint val)
{
return _type switch
{
FatType.Fat12 => (val & 0x0FFF) == 0x0FF7,
FatType.Fat16 => (val & 0xFFFF) == 0xFFF7,
FatType.Fat32 => (val & 0x0FFFFFF8) == 0x0FFFFFF7,
_ => throw new ArgumentException("Unknown FAT type"),
};
}
internal uint GetNext(uint cluster)
{
if (_type == FatType.Fat16)
{
return EndianUtilities.ToUInt16LittleEndian(_buffer, (int)(cluster * 2));
}
if (_type == FatType.Fat32)
{
return EndianUtilities.ToUInt32LittleEndian(_buffer, (int)(cluster * 4)) & 0x0FFFFFFF;
}
// FAT12
if ((cluster & 1) != 0)
{
return
(uint)((EndianUtilities.ToUInt16LittleEndian(_buffer, (int)(cluster + (cluster / 2))) >> 4) & 0x0FFF);
}
return (uint)(EndianUtilities.ToUInt16LittleEndian(_buffer, (int)(cluster + (cluster / 2))) & 0x0FFF);
}
internal void SetEndOfChain(uint cluster)
{
SetNext(cluster, EndOfChain);
}
internal void SetBadCluster(uint cluster)
{
SetNext(cluster, BadCluster);
}
internal void SetFree(uint cluster)
{
if (cluster < _nextFreeCandidate)
{
_nextFreeCandidate = cluster;
}
SetNext(cluster, FreeCluster);
}
internal void SetNext(uint cluster, uint next)
{
if (_type == FatType.Fat16)
{
MarkDirty(cluster * 2);
EndianUtilities.WriteBytesLittleEndian((ushort)next, _buffer, (int)(cluster * 2));
}
else if (_type == FatType.Fat32)
{
MarkDirty(cluster * 4);
uint oldVal = EndianUtilities.ToUInt32LittleEndian(_buffer, (int)(cluster * 4));
uint newVal = (oldVal & 0xF0000000) | (next & 0x0FFFFFFF);
EndianUtilities.WriteBytesLittleEndian(newVal, _buffer, (int)(cluster * 4));
}
else
{
uint offset = cluster + (cluster / 2);
MarkDirty(offset);
MarkDirty(offset + 1); // On alternate sector boundaries, cluster info crosses two sectors
ushort maskedOldVal;
if ((cluster & 1) != 0)
{
next <<= 4;
maskedOldVal = (ushort)(EndianUtilities.ToUInt16LittleEndian(_buffer, (int)offset) & 0x000F);
}
else
{
next &= 0x0FFF;
maskedOldVal = (ushort)(EndianUtilities.ToUInt16LittleEndian(_buffer, (int)offset) & 0xF000);
}
ushort newVal = (ushort)(maskedOldVal | next);
EndianUtilities.WriteBytesLittleEndian(newVal, _buffer, (int)offset);
}
}
internal bool TryGetFreeCluster(out uint cluster)
{
// Simple scan - don't hold a free list...
uint numEntries = (uint)NumEntries;
for (uint i = 0; i < numEntries; i++)
{
uint candidate = (i + _nextFreeCandidate) % numEntries;
if (IsFree(GetNext(candidate)))
{
cluster = candidate;
_nextFreeCandidate = candidate + 1;
return true;
}
}
cluster = 0;
return false;
}
internal void FreeChain(uint head)
{
foreach (uint cluster in GetChain(head))
{
SetFree(cluster);
}
}
internal List<uint> GetChain(uint head)
{
List<uint> result = new();
if (head != 0)
{
uint focus = head;
while (!IsEndOfChain(focus))
{
result.Add(focus);
focus = GetNext(focus);
}
}
return result;
}
internal void MarkDirty(uint offset)
{
_dirtySectors[offset / DirtyRegionSize] = offset / DirtyRegionSize;
}
internal void WriteDirtyRegions(Stream stream, long position)
{
foreach (uint val in _dirtySectors.Values)
{
stream.Position = position + (val * DirtyRegionSize);
stream.Write(_buffer, (int)(val * DirtyRegionSize), (int)DirtyRegionSize);
}
}
internal void ClearDirtyRegions()
{
_dirtySectors.Clear();
}
}
}
DiscUtils/DiscUtils.Fat/FatFileStream.cs
-138
View File
@@ -1,138 +0,0 @@
//
// 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.IO;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
internal class FatFileStream : SparseStream
{
private readonly Directory _dir;
private readonly long _dirId;
private readonly ClusterStream _stream;
private bool didWrite;
public FatFileStream(FatFileSystem fileSystem, Directory dir, long fileId, FileAccess access)
{
_dir = dir;
_dirId = fileId;
DirectoryEntry dirEntry = _dir.GetEntry(_dirId);
_stream = new ClusterStream(fileSystem, access, dirEntry.FirstCluster, (uint)dirEntry.FileSize);
_stream.FirstClusterChanged += FirstClusterAllocatedHandler;
}
public override bool CanRead
{
get { return _stream.CanRead; }
}
public override bool CanSeek
{
get { return _stream.CanSeek; }
}
public override bool CanWrite
{
get { return _stream.CanWrite; }
}
public override IEnumerable<StreamExtent> Extents
{
get { return new[] { new StreamExtent(0, Length) }; }
}
public override long Length
{
get { return _stream.Length; }
}
public override long Position
{
get { return _stream.Position; }
set { _stream.Position = value; }
}
protected override void Dispose(bool disposing)
{
if (_dir.FileSystem.CanWrite)
{
try
{
DateTime now = _dir.FileSystem.ConvertFromUtc(DateTime.UtcNow);
DirectoryEntry dirEntry = _dir.GetEntry(_dirId);
dirEntry.LastAccessTime = now;
if (didWrite)
{
dirEntry.FileSize = (int)_stream.Length;
dirEntry.LastWriteTime = now;
}
_dir.UpdateEntry(_dirId, dirEntry);
}
finally
{
base.Dispose(disposing);
}
}
}
public override void SetLength(long value)
{
didWrite = true;
_stream.SetLength(value);
}
public override void Write(byte[] buffer, int offset, int count)
{
didWrite = true;
_stream.Write(buffer, offset, count);
}
public override void Flush()
{
_stream.Flush();
}
public override int Read(byte[] buffer, int offset, int count)
{
return _stream.Read(buffer, offset, count);
}
public override long Seek(long offset, SeekOrigin origin)
{
return _stream.Seek(offset, origin);
}
private void FirstClusterAllocatedHandler(uint cluster)
{
DirectoryEntry dirEntry = _dir.GetEntry(_dirId);
dirEntry.FirstCluster = cluster;
_dir.UpdateEntry(_dirId, dirEntry);
}
}
}
DiscUtils/DiscUtils.Fat/FatFileSystemOptions.cs
-70
View File
@@ -1,70 +0,0 @@
//
// 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.Text;
namespace DiscUtils.Fat
{
/// <summary>
/// FAT file system options.
/// </summary>
public sealed class FatFileSystemOptions : DiscFileSystemOptions
{
private Encoding _encoding;
internal FatFileSystemOptions()
{
FileNameEncoding = Encoding.GetEncoding(437);
}
internal FatFileSystemOptions(FileSystemParameters parameters)
{
if (parameters?.FileNameEncoding != null)
{
FileNameEncoding = parameters.FileNameEncoding;
}
else
{
FileNameEncoding = Encoding.GetEncoding(437);
}
}
/// <summary>
/// Gets or sets the character encoding used for file names.
/// </summary>
public Encoding FileNameEncoding
{
get { return _encoding; }
set
{
if (!value.IsSingleByte)
{
throw new ArgumentException(value.EncodingName + " is not a single byte encoding");
}
_encoding = value;
}
}
}
}
DiscUtils/DiscUtils.Fat/FatType.cs
-50
View File
@@ -1,50 +0,0 @@
//
// 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.
//
namespace DiscUtils.Fat
{
/// <summary>
/// Enumeration of known FAT types.
/// </summary>
public enum FatType
{
/// <summary>
/// Represents no known FAT type.
/// </summary>
None = 0,
/// <summary>
/// Represents a 12-bit FAT.
/// </summary>
Fat12 = 12,
/// <summary>
/// Represents a 16-bit FAT.
/// </summary>
Fat16 = 16,
/// <summary>
/// Represents a 32-bit FAT.
/// </summary>
Fat32 = 32
}
}
DiscUtils/DiscUtils.Fat/FileAllocationTable.cs
-106
View File
@@ -1,106 +0,0 @@
//
// 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.IO;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
internal class FileAllocationTable
{
private readonly FatBuffer _buffer;
private readonly ushort _firstFatSector;
private readonly byte _numFats;
private readonly Stream _stream;
public FileAllocationTable(FatType type, Stream stream, ushort firstFatSector, uint fatSize, byte numFats,
byte activeFat)
{
_stream = stream;
_firstFatSector = firstFatSector;
_numFats = numFats;
_stream.Position = (firstFatSector + (fatSize * activeFat)) * Sizes.Sector;
_buffer = new FatBuffer(type, StreamUtilities.ReadExact(_stream, (int)(fatSize * Sizes.Sector)));
}
internal bool IsFree(uint val)
{
return _buffer.IsFree(val);
}
internal bool IsEndOfChain(uint val)
{
return _buffer.IsEndOfChain(val);
}
internal bool IsBadCluster(uint val)
{
return _buffer.IsBadCluster(val);
}
internal uint GetNext(uint cluster)
{
return _buffer.GetNext(cluster);
}
internal void SetEndOfChain(uint cluster)
{
_buffer.SetEndOfChain(cluster);
}
internal void SetBadCluster(uint cluster)
{
_buffer.SetBadCluster(cluster);
}
internal void SetNext(uint cluster, uint next)
{
_buffer.SetNext(cluster, next);
}
internal void Flush()
{
for (int i = 0; i < _numFats; ++i)
{
_buffer.WriteDirtyRegions(_stream, (_firstFatSector * Sizes.Sector) + (_buffer.Size * i));
}
_buffer.ClearDirtyRegions();
}
internal bool TryGetFreeCluster(out uint cluster)
{
return _buffer.TryGetFreeCluster(out cluster);
}
internal void FreeChain(uint head)
{
_buffer.FreeChain(head);
}
internal int NumEntries
{
get { return _buffer.NumEntries; }
}
}
}
DiscUtils/DiscUtils.Fat/FileName.cs
-218
View File
@@ -1,218 +0,0 @@
//
// 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.Text;
using DiscUtils.Internal;
namespace DiscUtils.Fat
{
internal sealed class FileName : IEquatable<FileName>
{
private const byte SpaceByte = 0x20;
public static readonly FileName SelfEntryName =
new(new byte[] { 0x2E, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }, 0);
public static readonly FileName ParentEntryName =
new(new byte[] { 0x2E, 0x2E, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 }, 0);
public static readonly FileName Null =
new(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 0);
private static readonly byte[] InvalidBytes = { 0x22, 0x2A, 0x2B, 0x2C, 0x2E, 0x2F, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x5B, 0x5C, 0x5D, 0x7C };
private readonly byte[] _raw;
public FileName(byte[] data, int offset)
{
_raw = new byte[11];
Array.Copy(data, offset, _raw, 0, 11);
}
public FileName(string name, Encoding encoding)
{
_raw = new byte[11];
byte[] bytes = encoding.GetBytes(name.ToUpperInvariant());
int nameIdx = 0;
int rawIdx = 0;
while (nameIdx < bytes.Length && bytes[nameIdx] != '.' && rawIdx < _raw.Length)
{
byte b = bytes[nameIdx++];
if (b < 0x20 || Contains(InvalidBytes, b))
{
throw new ArgumentException("Invalid character in file name '" + (char)b + "'", nameof(name));
}
_raw[rawIdx++] = b;
}
if (rawIdx > 8)
{
throw new ArgumentException("File name too long '" + name + "'", nameof(name));
}
if (rawIdx == 0)
{
throw new ArgumentException("File name too short '" + name + "'", nameof(name));
}
while (rawIdx < 8)
{
_raw[rawIdx++] = SpaceByte;
}
if (nameIdx < bytes.Length && bytes[nameIdx] == '.')
{
++nameIdx;
}
while (nameIdx < bytes.Length && rawIdx < _raw.Length)
{
byte b = bytes[nameIdx++];
if (b < 0x20 || Contains(InvalidBytes, b))
{
throw new ArgumentException("Invalid character in file extension '" + (char)b + "'", nameof(name));
}
_raw[rawIdx++] = b;
}
while (rawIdx < 11)
{
_raw[rawIdx++] = SpaceByte;
}
if (nameIdx != bytes.Length)
{
throw new ArgumentException("File extension too long '" + name + "'", nameof(name));
}
}
public bool Equals(FileName other)
{
if (other == null)
{
return false;
}
return CompareRawNames(this, other) == 0;
}
public static FileName FromPath(string path, Encoding encoding)
{
return new FileName(Utilities.GetFileFromPath(path), encoding);
}
public static bool operator ==(FileName a, FileName b)
{
return CompareRawNames(a, b) == 0;
}
public static bool operator !=(FileName a, FileName b)
{
return CompareRawNames(a, b) != 0;
}
public string GetDisplayName(Encoding encoding)
{
return GetSearchName(encoding).TrimEnd('.');
}
public string GetSearchName(Encoding encoding)
{
return encoding.GetString(_raw, 0, 8).TrimEnd() + "." + encoding.GetString(_raw, 8, 3).TrimEnd();
}
public string GetRawName(Encoding encoding)
{
return encoding.GetString(_raw, 0, 11).TrimEnd();
}
public FileName Deleted()
{
byte[] data = new byte[11];
Array.Copy(_raw, data, 11);
data[0] = 0xE5;
return new FileName(data, 0);
}
public bool IsDeleted()
{
return _raw[0] == 0xE5;
}
public bool IsEndMarker()
{
return _raw[0] == 0x00;
}
public void GetBytes(byte[] data, int offset)
{
Array.Copy(_raw, 0, data, offset, 11);
}
public override bool Equals(object other)
{
return Equals(other as FileName);
}
public override int GetHashCode()
{
int val = 0x1A8D3C4E;
for (int i = 0; i < 11; ++i)
{
val = (val << 2) ^ _raw[i];
}
return val;
}
private static int CompareRawNames(FileName a, FileName b)
{
for (int i = 0; i < 11; ++i)
{
if (a._raw[i] != b._raw[i])
{
return a._raw[i] - b._raw[i];
}
}
return 0;
}
private static bool Contains(byte[] array, byte val)
{
foreach (byte b in array)
{
if (b == val)
{
return true;
}
}
return false;
}
}
}
DiscUtils/DiscUtils.Fat/FileSystemFactory.cs
-47
View File
@@ -1,47 +0,0 @@
//
// 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.IO;
using DiscUtils.Vfs;
using DiscUtils.Streams;
namespace DiscUtils.Fat
{
[VfsFileSystemFactory]
internal class FileSystemFactory : VfsFileSystemFactory
{
public override FileSystemInfo[] Detect(Stream stream, VolumeInfo volume)
{
if (FatFileSystem.Detect(stream))
{
return new FileSystemInfo[] { new VfsFileSystemInfo("FAT", "Microsoft FAT", Open) };
}
return System.Array.Empty<FileSystemInfo>();
}
private DiscFileSystem Open(Stream stream, VolumeInfo volumeInfo, FileSystemParameters parameters)
{
return new FatFileSystem(stream, Ownership.None, parameters);
}
}
}
DiscUtils/DiscUtils.Fat/FirstClusterChangedDelegate.cs
-4
View File
@@ -1,4 +0,0 @@
namespace DiscUtils.Fat
{
internal delegate void FirstClusterChangedDelegate(uint cluster);
}
DiscUtils/DiscUtils.Fat/Modified/Directory.cs
-563
View File
@@ -1,563 +0,0 @@
//
// 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.
//
namespace DiscUtils.Fat
{
using DiscUtils.Streams;
using System;
using System.Collections.Generic;
using System.IO;
internal class Directory : IDisposable
{
private FatFileSystem _fileSystem;
private Directory _parent;
private long _parentId;
private Stream _dirStream;
private Dictionary<long, DirectoryEntry> _entries;
private List<long> _freeEntries;
private long _endOfEntries;
private DirectoryEntry _selfEntry;
private long _selfEntryLocation;
private DirectoryEntry _parentEntry;
private long _parentEntryLocation;
internal Dictionary<string, string> LongFileNames_ShortKey = new(StringComparer.OrdinalIgnoreCase);
internal Dictionary<string, string> LongFileNames_LongKey = new(StringComparer.OrdinalIgnoreCase);
/// <summary>
/// Initializes a new instance of the Directory class. Use this constructor to represent non-root directories.
/// </summary>
/// <param name="parent">The parent directory.</param>
/// <param name="parentId">The identity of the entry representing this directory in the parent.</param>
internal Directory(Directory parent, long parentId)
{
_fileSystem = parent._fileSystem;
_parent = parent;
_parentId = parentId;
DirectoryEntry dirEntry = ParentsChildEntry;
_dirStream = new ClusterStream(_fileSystem, FileAccess.ReadWrite, dirEntry.FirstCluster, uint.MaxValue);
LoadEntries();
}
/// <summary>
/// Initializes a new instance of the Directory class. Use this constructor to represent the root directory.
/// </summary>
/// <param name="fileSystem">The file system.</param>
/// <param name="dirStream">The stream containing the directory info.</param>
internal Directory(FatFileSystem fileSystem, Stream dirStream)
{
_fileSystem = fileSystem;
_dirStream = dirStream;
LoadEntries();
}
private static string GetLfnChunk(byte[] buffer)
{
// see http://home.teleport.com/~brainy/lfn.htm
// NOTE: we assume ordinals are ok here.
char[] chars = new char[13];
chars[0] = (char)((256 * buffer[2]) + buffer[1]);
chars[1] = (char)((256 * buffer[4]) + buffer[3]);
chars[2] = (char)((256 * buffer[6]) + buffer[5]);
chars[3] = (char)((256 * buffer[8]) + buffer[7]);
chars[4] = (char)((256 * buffer[10]) + buffer[9]);
chars[5] = (char)((256 * buffer[15]) + buffer[14]);
chars[6] = (char)((256 * buffer[17]) + buffer[16]);
chars[7] = (char)((256 * buffer[19]) + buffer[18]);
chars[8] = (char)((256 * buffer[21]) + buffer[20]);
chars[9] = (char)((256 * buffer[23]) + buffer[22]);
chars[10] = (char)((256 * buffer[25]) + buffer[24]);
chars[11] = (char)((256 * buffer[29]) + buffer[28]);
chars[12] = (char)((256 * buffer[31]) + buffer[30]);
string chunk = new(chars);
int zero = chunk.IndexOf('\0');
return zero >= 0 ? chunk.Substring(0, zero) : chunk;
}
public FatFileSystem FileSystem
{
get { return _fileSystem; }
}
public bool IsEmpty
{
get { return _entries.Count == 0; }
}
public DirectoryEntry[] Entries
{
get { return new List<DirectoryEntry>(_entries.Values).ToArray(); }
}
#region Convenient accessors for special entries
internal DirectoryEntry ParentsChildEntry
{
get
{
if (_parent == null)
{
return new DirectoryEntry(_fileSystem.FatOptions, FileName.ParentEntryName, FatAttributes.Directory, _fileSystem.FatVariant);
}
else
{
return _parent.GetEntry(_parentId);
}
}
set
{
_parent?.UpdateEntry(_parentId, value);
}
}
internal DirectoryEntry SelfEntry
{
get
{
if (_parent == null)
{
// If we're the root directory, simulate the parent entry with a dummy record
return new DirectoryEntry(_fileSystem.FatOptions, FileName.Null, FatAttributes.Directory, _fileSystem.FatVariant);
}
else
{
return _selfEntry;
}
}
set
{
if (_selfEntryLocation >= 0)
{
_dirStream.Position = _selfEntryLocation;
value.WriteTo(_dirStream);
_selfEntry = value;
}
}
}
internal DirectoryEntry ParentEntry
{
get
{
return _parentEntry;
}
set
{
if (_parentEntryLocation < 0)
{
throw new IOException("No parent entry on disk to update");
}
_dirStream.Position = _parentEntryLocation;
value.WriteTo(_dirStream);
_parentEntry = value;
}
}
#endregion
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
public DirectoryEntry[] GetDirectories()
{
List<DirectoryEntry> dirs = new(_entries.Count);
foreach (DirectoryEntry dirEntry in _entries.Values)
{
if ((dirEntry.Attributes & FatAttributes.Directory) != 0)
{
dirs.Add(dirEntry);
}
}
return dirs.ToArray();
}
public DirectoryEntry[] GetFiles()
{
List<DirectoryEntry> files = new(_entries.Count);
foreach (DirectoryEntry dirEntry in _entries.Values)
{
if ((dirEntry.Attributes & (FatAttributes.Directory | FatAttributes.VolumeId)) == 0)
{
files.Add(dirEntry);
}
}
return files.ToArray();
}
public DirectoryEntry GetEntry(long id)
{
return (id < 0) ? null : _entries[id];
}
public Directory GetChildDirectory(FileName name)
{
long id = FindEntry(name);
if (id < 0)
{
return null;
}
else if ((_entries[id].Attributes & FatAttributes.Directory) == 0)
{
return null;
}
else
{
return _fileSystem.GetDirectory(this, id);
}
}
internal Directory CreateChildDirectory(FileName name)
{
long id = FindEntry(name);
if (id >= 0)
{
if ((_entries[id].Attributes & FatAttributes.Directory) == 0)
{
throw new IOException("A file exists with the same name");
}
else
{
return _fileSystem.GetDirectory(this, id);
}
}
else
{
try
{
if (!_fileSystem.Fat.TryGetFreeCluster(out uint firstCluster))
{
throw new IOException("Failed to allocate first cluster for new directory");
}
_fileSystem.Fat.SetEndOfChain(firstCluster);
DirectoryEntry newEntry = new(_fileSystem.FatOptions, name, FatAttributes.Directory, _fileSystem.FatVariant);
newEntry.FirstCluster = firstCluster;
newEntry.CreationTime = _fileSystem.ConvertFromUtc(DateTime.UtcNow);
newEntry.LastWriteTime = newEntry.CreationTime;
id = AddEntry(newEntry);
PopulateNewChildDirectory(newEntry);
// Rather than just creating a new instance, pull it through the fileSystem cache
// to ensure the cache model is preserved.
return _fileSystem.GetDirectory(this, id);
}
finally
{
_fileSystem.Fat.Flush();
}
}
}
internal void AttachChildDirectory(FileName name, Directory newChild)
{
long id = FindEntry(name);
if (id >= 0)
{
throw new IOException("Directory entry already exists");
}
DirectoryEntry newEntry = new(newChild.ParentsChildEntry);
newEntry.Name = name;
AddEntry(newEntry);
DirectoryEntry newParentEntry = new(SelfEntry);
newParentEntry.Name = FileName.ParentEntryName;
newChild.ParentEntry = newParentEntry;
}
internal long FindVolumeId()
{
foreach (long id in _entries.Keys)
{
DirectoryEntry focus = _entries[id];
if ((focus.Attributes & FatAttributes.VolumeId) != 0)
{
return id;
}
}
return -1;
}
internal long FindEntry(FileName name)
{
foreach (long id in _entries.Keys)
{
DirectoryEntry focus = _entries[id];
if (focus.Name == name && (focus.Attributes & FatAttributes.VolumeId) == 0)
{
return id;
}
}
return -1;
}
internal SparseStream OpenFile(FileName name, FileMode mode, FileAccess fileAccess)
{
if (mode == FileMode.Append || mode == FileMode.Truncate)
{
throw new NotImplementedException();
}
long fileId = FindEntry(name);
bool exists = fileId != -1;
if (mode == FileMode.CreateNew && exists)
{
throw new IOException("File already exists");
}
else if (mode == FileMode.Open && !exists)
{
throw new FileNotFoundException("File not found", name.GetDisplayName(_fileSystem.FatOptions.FileNameEncoding));
}
else if ((mode == FileMode.Open || mode == FileMode.OpenOrCreate || mode == FileMode.Create) && exists)
{
SparseStream stream = new FatFileStream(_fileSystem, this, fileId, fileAccess);
if (mode == FileMode.Create)
{
stream.SetLength(0);
}
HandleAccessed(false);
return stream;
}
else if ((mode == FileMode.OpenOrCreate || mode == FileMode.CreateNew || mode == FileMode.Create) && !exists)
{
// Create new file
DirectoryEntry newEntry = new(_fileSystem.FatOptions, name, FatAttributes.Archive, _fileSystem.FatVariant);
newEntry.FirstCluster = 0; // i.e. Zero-length
newEntry.CreationTime = _fileSystem.ConvertFromUtc(DateTime.UtcNow);
newEntry.LastWriteTime = newEntry.CreationTime;
fileId = AddEntry(newEntry);
return new FatFileStream(_fileSystem, this, fileId, fileAccess);
}
else
{
// Should never get here...
throw new NotImplementedException();
}
}
internal long AddEntry(DirectoryEntry newEntry)
{
// Unlink an entry from the free list (or add to the end of the existing directory)
long pos;
if (_freeEntries.Count > 0)
{
pos = _freeEntries[0];
_freeEntries.RemoveAt(0);
}
else
{
pos = _endOfEntries;
_endOfEntries += 32;
}
// Put the new entry into it's slot
_dirStream.Position = pos;
newEntry.WriteTo(_dirStream);
// Update internal structures to reflect new entry (as if read from disk)
_entries.Add(pos, newEntry);
HandleAccessed(true);
return pos;
}
internal void DeleteEntry(long id, bool releaseContents)
{
if (id < 0)
{
throw new IOException("Attempt to delete unknown directory entry");
}
try
{
DirectoryEntry entry = _entries[id];
DirectoryEntry copy = new(entry);
copy.Name = entry.Name.Deleted();
_dirStream.Position = id;
copy.WriteTo(_dirStream);
if (releaseContents)
{
_fileSystem.Fat.FreeChain(entry.FirstCluster);
}
_entries.Remove(id);
_freeEntries.Add(id);
HandleAccessed(true);
}
finally
{
_fileSystem.Fat.Flush();
}
}
internal void UpdateEntry(long id, DirectoryEntry entry)
{
if (id < 0)
{
throw new IOException("Attempt to update unknown directory entry");
}
_dirStream.Position = id;
entry.WriteTo(_dirStream);
_entries[id] = entry;
}
private void LoadEntries()
{
_entries = new Dictionary<long, DirectoryEntry>();
_freeEntries = new List<long>();
_selfEntryLocation = -1;
_parentEntryLocation = -1;
string lfn = null; //+++
while (_dirStream.Position < _dirStream.Length)
{
long streamPos = _dirStream.Position;
DirectoryEntry entry = new(_fileSystem.FatOptions, _dirStream, _fileSystem.FatVariant);
if (entry.Attributes == (FatAttributes.ReadOnly | FatAttributes.Hidden | FatAttributes.System | FatAttributes.VolumeId))
{
// Long File Name entry
_dirStream.Position = streamPos; //+++
lfn = GetLfnChunk(StreamUtilities.ReadExact(_dirStream, 32)) + lfn; //+++
}
else if (entry.Name.IsDeleted())
{
// E5 = Free Entry
_freeEntries.Add(streamPos);
lfn = null; //+++
}
else if (entry.Name == FileName.SelfEntryName)
{
_selfEntry = entry;
_selfEntryLocation = streamPos;
lfn = null; //+++
}
else if (entry.Name == FileName.ParentEntryName)
{
_parentEntry = entry;
_parentEntryLocation = streamPos;
lfn = null; //+++
}
else if (entry.Name.IsEndMarker())
{
// Free Entry, no more entries available
_endOfEntries = streamPos;
break;
}
else
{
if (lfn != null) //+++
{ //+++
LongFileNames_ShortKey.Add(entry.Name.GetDisplayName(_fileSystem.FatOptions.FileNameEncoding), lfn); //+++
LongFileNames_LongKey.Add(lfn, entry.Name.GetDisplayName(_fileSystem.FatOptions.FileNameEncoding)); //+++
} //+++
_entries.Add(streamPos, entry);
lfn = null; //+++
}
}
}
private void HandleAccessed(bool forWrite)
{
if (_fileSystem.CanWrite && _parent != null)
{
DateTime now = DateTime.Now;
DirectoryEntry entry = SelfEntry;
DateTime oldAccessTime = entry.LastAccessTime;
DateTime oldWriteTime = entry.LastWriteTime;
entry.LastAccessTime = now;
if (forWrite)
{
entry.LastWriteTime = now;
}
if (entry.LastAccessTime != oldAccessTime || entry.LastWriteTime != oldWriteTime)
{
SelfEntry = entry;
DirectoryEntry parentEntry = ParentsChildEntry;
parentEntry.LastAccessTime = entry.LastAccessTime;
parentEntry.LastWriteTime = entry.LastWriteTime;
ParentsChildEntry = parentEntry;
}
}
}
private void PopulateNewChildDirectory(DirectoryEntry newEntry)
{
// Populate new directory with initial (special) entries. First one is easy, just change the name!
using ClusterStream stream = new(_fileSystem, FileAccess.Write, newEntry.FirstCluster, uint.MaxValue);
// First is the self-referencing entry...
DirectoryEntry selfEntry = new(newEntry);
selfEntry.Name = FileName.SelfEntryName;
selfEntry.WriteTo(stream);
// Second is a clone of our self entry (i.e. parent) - though dates are odd...
DirectoryEntry parentEntry = new(SelfEntry);
parentEntry.Name = FileName.ParentEntryName;
parentEntry.CreationTime = newEntry.CreationTime;
parentEntry.LastWriteTime = newEntry.LastWriteTime;
parentEntry.WriteTo(stream);
}
private void Dispose(bool disposing)
{
if (disposing)
{
_dirStream.Dispose();
}
}
}
}
DiscUtils/DiscUtils.Fat/Modified/FatFileSystem.cs
-2033
View File
File diff suppressed because it is too large Load Diff