646 lines
25 KiB
Plaintext
646 lines
25 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Research Singularity
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// File: LongDirectoryEntry.sg
|
|
//
|
|
// Note:
|
|
//
|
|
// Based on pages 27-34 of "Microsoft Extensible Firmware
|
|
// Initiative FAT32 File System Specification", Version 1.03,
|
|
// December 6, 2000, Microsoft Corporation.
|
|
|
|
using Microsoft.Singularity.Channels;
|
|
|
|
using System.Runtime.InteropServices;
|
|
using System;
|
|
|
|
using Microsoft.Singularity.Io;
|
|
|
|
namespace Microsoft.Singularity.Services.Fat.Fs
|
|
{
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
internal pointerfree struct LongDirectoryEntry
|
|
{
|
|
internal const uint Length = 32;
|
|
internal const int CharactersPerEntry = 13;
|
|
internal const int MaxLongNameLength = 255;
|
|
internal const int MaxShortNameAttempts = 1000000;
|
|
|
|
private const byte LastLongEntryMask = 0x40;
|
|
private const byte AttributeLongName = DirectoryEntry.AttributeLongName;
|
|
|
|
// Long name terminator constants
|
|
private const char TerminateFirst = Char.MinValue;
|
|
private const char TerminateOther = Char.MaxValue;
|
|
|
|
// Short name constants
|
|
internal const int MaxBaseLength
|
|
= DirectoryEntry.ShortNameMaxBaseName;
|
|
internal const int MaxExtensionLength
|
|
= DirectoryEntry.ShortNameMaxExtension;
|
|
|
|
private byte ordinal; // 0
|
|
private char name00; // 1..2
|
|
private char name01; // 3..4
|
|
private char name02; // 5..6
|
|
private char name03; // 7..8
|
|
private char name04; // 9..10
|
|
internal byte Attribute; // 11
|
|
internal byte Type; // 12
|
|
private byte checksum; // 13
|
|
private char name05; // 14..15
|
|
private char name06; // 16..17
|
|
private char name07; // 18..19
|
|
private char name08; // 20..21
|
|
private char name09; // 22..23
|
|
private char name10; // 24..25
|
|
private char zero; // 26..27
|
|
private char name11; // 28..29
|
|
private char name12; // 30..31
|
|
|
|
internal bool IsLastEntry
|
|
{
|
|
get {
|
|
assert this.IsValid;
|
|
return (ordinal & LastLongEntryMask) == LastLongEntryMask;
|
|
}
|
|
}
|
|
|
|
internal bool IsValid
|
|
{
|
|
get { return ((Attribute & DirectoryEntry.AttributeLongNameMask) ==
|
|
DirectoryEntry.AttributeLongName); }
|
|
}
|
|
|
|
internal int GetNumberOfLongEntries()
|
|
{
|
|
// This is only valid on last entry which has the ordinal bit set.
|
|
assert ((int)ordinal & (int)LastLongEntryMask) != 0;
|
|
return (int)ordinal & ~((int)LastLongEntryMask);
|
|
}
|
|
|
|
internal int GetPathLength()
|
|
{
|
|
// This is only valid on last entry which has the ordinal bit set.
|
|
assert ((int)ordinal & (int)LastLongEntryMask) != 0;
|
|
return (ComponentNumber - 1) * CharactersPerEntry
|
|
+ GetPathComponentLength();
|
|
}
|
|
|
|
internal int ComponentNumber
|
|
{
|
|
get { return (int)ordinal & ~((int)LastLongEntryMask); }
|
|
}
|
|
|
|
internal byte Checksum
|
|
{
|
|
get { return checksum; }
|
|
}
|
|
|
|
internal int GetPathComponentLength()
|
|
{
|
|
if (name00 == TerminateFirst) return 0;
|
|
if (name01 == TerminateFirst) return 1;
|
|
if (name02 == TerminateFirst) return 2;
|
|
if (name03 == TerminateFirst) return 3;
|
|
if (name04 == TerminateFirst) return 4;
|
|
if (name05 == TerminateFirst) return 5;
|
|
if (name06 == TerminateFirst) return 6;
|
|
if (name07 == TerminateFirst) return 7;
|
|
if (name08 == TerminateFirst) return 8;
|
|
if (name09 == TerminateFirst) return 9;
|
|
if (name10 == TerminateFirst) return 10;
|
|
if (name11 == TerminateFirst) return 11;
|
|
if (name12 == TerminateFirst) return 12;
|
|
return 13;
|
|
}
|
|
|
|
internal bool NameComponentMatches(char[]! in ExHeap name)
|
|
{
|
|
if (this.IsLastEntry) {
|
|
return MatchNameLast(name);
|
|
}
|
|
return MatchName(name);
|
|
}
|
|
|
|
private bool MatchName(char[]! in ExHeap name)
|
|
{
|
|
// Component numbers are 1-indexed.
|
|
int nOffset = (this.ComponentNumber - 1) * CharactersPerEntry;
|
|
return
|
|
Char.ToUpper(name00) == Char.ToUpper(name[nOffset + 0]) &&
|
|
Char.ToUpper(name01) == Char.ToUpper(name[nOffset + 1]) &&
|
|
Char.ToUpper(name02) == Char.ToUpper(name[nOffset + 2]) &&
|
|
Char.ToUpper(name03) == Char.ToUpper(name[nOffset + 3]) &&
|
|
Char.ToUpper(name04) == Char.ToUpper(name[nOffset + 4]) &&
|
|
Char.ToUpper(name05) == Char.ToUpper(name[nOffset + 5]) &&
|
|
Char.ToUpper(name06) == Char.ToUpper(name[nOffset + 6]) &&
|
|
Char.ToUpper(name07) == Char.ToUpper(name[nOffset + 7]) &&
|
|
Char.ToUpper(name08) == Char.ToUpper(name[nOffset + 8]) &&
|
|
Char.ToUpper(name09) == Char.ToUpper(name[nOffset + 9]) &&
|
|
Char.ToUpper(name10) == Char.ToUpper(name[nOffset + 10]) &&
|
|
Char.ToUpper(name11) == Char.ToUpper(name[nOffset + 11]) &&
|
|
Char.ToUpper(name12) == Char.ToUpper(name[nOffset + 12]);
|
|
}
|
|
|
|
private bool MatchNameLast(char[]! in ExHeap name)
|
|
{
|
|
int nOffset = (this.ComponentNumber - 1) * CharactersPerEntry;
|
|
int todo = GetPathComponentLength();
|
|
assert name.Length == nOffset + todo;
|
|
switch (todo) {
|
|
case 13:
|
|
if (Char.ToUpper(name12) !=
|
|
Char.ToUpper(name[nOffset + 12])) {
|
|
return false;
|
|
}
|
|
goto case 12;
|
|
case 12:
|
|
if (Char.ToUpper(name11) !=
|
|
Char.ToUpper(name[nOffset + 11])) {
|
|
return false;
|
|
}
|
|
goto case 11;
|
|
case 11:
|
|
if (Char.ToUpper(name10) !=
|
|
Char.ToUpper(name[nOffset + 10])) {
|
|
return false;
|
|
}
|
|
goto case 10;
|
|
case 10:
|
|
if (Char.ToUpper(name09) !=
|
|
Char.ToUpper(name[nOffset + 9])) {
|
|
return false;
|
|
}
|
|
goto case 9;
|
|
case 9:
|
|
if (Char.ToUpper(name08) !=
|
|
Char.ToUpper(name[nOffset + 8])) {
|
|
return false;
|
|
}
|
|
goto case 8;
|
|
case 8:
|
|
if (Char.ToUpper(name07) !=
|
|
Char.ToUpper(name[nOffset + 7])) {
|
|
return false;
|
|
}
|
|
goto case 7;
|
|
case 7:
|
|
if (Char.ToUpper(name06) !=
|
|
Char.ToUpper(name[nOffset + 6])) {
|
|
return false;
|
|
}
|
|
goto case 6;
|
|
case 6:
|
|
if (Char.ToUpper(name05) !=
|
|
Char.ToUpper(name[nOffset + 5])) {
|
|
return false;
|
|
}
|
|
goto case 5;
|
|
case 5:
|
|
if (Char.ToUpper(name04) !=
|
|
Char.ToUpper(name[nOffset + 4])) {
|
|
return false;
|
|
}
|
|
goto case 4;
|
|
case 4:
|
|
if (Char.ToUpper(name03) !=
|
|
Char.ToUpper(name[nOffset + 3])) {
|
|
return false;
|
|
}
|
|
goto case 3;
|
|
case 3:
|
|
if (Char.ToUpper(name02) !=
|
|
Char.ToUpper(name[nOffset + 2])) {
|
|
return false;
|
|
}
|
|
goto case 2;
|
|
case 2:
|
|
if (Char.ToUpper(name01) !=
|
|
Char.ToUpper(name[nOffset + 1])) {
|
|
return false;
|
|
}
|
|
goto case 1;
|
|
case 1:
|
|
if (Char.ToUpper(name00) !=
|
|
Char.ToUpper(name[nOffset + 0])) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Copies characters from LongDirectoryEntry
|
|
/// into character array at specified offset. </summary>
|
|
internal void GetPathComponent(char[]! in ExHeap longName,
|
|
int offset)
|
|
{
|
|
switch ( GetPathComponentLength() ) {
|
|
case 13: longName[offset + 12] = name12; goto case 12;
|
|
case 12: longName[offset + 11] = name11; goto case 11;
|
|
case 11: longName[offset + 10] = name10; goto case 10;
|
|
case 10: longName[offset + 9] = name09; goto case 9;
|
|
case 9: longName[offset + 8] = name08; goto case 8;
|
|
case 8: longName[offset + 7] = name07; goto case 7;
|
|
case 7: longName[offset + 6] = name06; goto case 6;
|
|
case 6: longName[offset + 5] = name05; goto case 5;
|
|
case 5: longName[offset + 4] = name04; goto case 4;
|
|
case 4: longName[offset + 3] = name03; goto case 3;
|
|
case 3: longName[offset + 2] = name02; goto case 2;
|
|
case 2: longName[offset + 1] = name01; goto case 1;
|
|
case 1: longName[offset + 0] = name00; break;
|
|
case 0: break;
|
|
}
|
|
}
|
|
|
|
internal void GetPathComponent(char[]! in ExHeap longName)
|
|
{
|
|
int offset = (ComponentNumber - 1) * CharactersPerEntry;
|
|
GetPathComponent(longName, offset);
|
|
}
|
|
|
|
private void SetCharacters(char[]! in ExHeap longName,
|
|
int offset,
|
|
int length)
|
|
requires length > 0 && length <= CharactersPerEntry;
|
|
{
|
|
switch (length) {
|
|
case 13: name12 = longName[offset + 12]; goto case 12;
|
|
case 12: name11 = longName[offset + 11]; goto case 11;
|
|
case 11: name10 = longName[offset + 10]; goto case 10;
|
|
case 10: name09 = longName[offset + 9]; goto case 9;
|
|
case 9: name08 = longName[offset + 8]; goto case 8;
|
|
case 8: name07 = longName[offset + 7]; goto case 7;
|
|
case 7: name06 = longName[offset + 6]; goto case 6;
|
|
case 6: name05 = longName[offset + 5]; goto case 5;
|
|
case 5: name04 = longName[offset + 4]; goto case 4;
|
|
case 4: name03 = longName[offset + 3]; goto case 3;
|
|
case 3: name02 = longName[offset + 2]; goto case 2;
|
|
case 2: name01 = longName[offset + 1]; goto case 1;
|
|
case 1: name00 = longName[offset + 0]; break;
|
|
}
|
|
}
|
|
|
|
private void PadCharacters(int length)
|
|
requires length > 0 && length < CharactersPerEntry;
|
|
{
|
|
char v = TerminateFirst;
|
|
switch (length) {
|
|
// case 13: unlucky for some and not allowed for padding.
|
|
case 12: name01 = v; v = TerminateOther; goto case 11;
|
|
case 11: name02 = v; v = TerminateOther; goto case 10;
|
|
case 10: name03 = v; v = TerminateOther; goto case 9;
|
|
case 9: name04 = v; v = TerminateOther; goto case 8;
|
|
case 8: name05 = v; v = TerminateOther; goto case 7;
|
|
case 7: name06 = v; v = TerminateOther; goto case 6;
|
|
case 6: name07 = v; v = TerminateOther; goto case 5;
|
|
case 5: name08 = v; v = TerminateOther; goto case 4;
|
|
case 4: name09 = v; v = TerminateOther; goto case 3;
|
|
case 3: name10 = v; v = TerminateOther; goto case 2;
|
|
case 2: name11 = v; v = TerminateOther; goto case 1;
|
|
case 1: name12 = v; v = TerminateOther; break;
|
|
}
|
|
}
|
|
|
|
internal void SetNameComponent(int ordinal,
|
|
int maxOrdinal,
|
|
char[]! in ExHeap longName,
|
|
byte shortNameChecksum)
|
|
requires ordinal >= 1 && ordinal <= maxOrdinal;
|
|
requires maxOrdinal >= 1;
|
|
{
|
|
this.Attribute = DirectoryEntry.AttributeLongName;
|
|
this.Type = 0;
|
|
this.checksum = shortNameChecksum;
|
|
this.zero = Char.MinValue;
|
|
|
|
int offset = (ordinal - 1) * CharactersPerEntry;
|
|
int length = longName.Length - offset;
|
|
|
|
if (ordinal == maxOrdinal) {
|
|
ordinal |= (int)LastLongEntryMask;
|
|
}
|
|
this.ordinal = (byte)ordinal;
|
|
|
|
if (length >= CharactersPerEntry) {
|
|
SetCharacters(longName, offset, CharactersPerEntry);
|
|
}
|
|
else {
|
|
assert length > 0;
|
|
SetCharacters(longName, offset, length);
|
|
PadCharacters(CharactersPerEntry - length);
|
|
}
|
|
}
|
|
|
|
internal static byte ComputeChecksum(char[]! in ExHeap shortName)
|
|
requires shortName.Length == MaxBaseLength + MaxExtensionLength;
|
|
{
|
|
byte sum = 0;
|
|
for (int i = 0; i < MaxBaseLength + MaxExtensionLength; i++) {
|
|
int tmp = ((((int)sum) & 1) << 7) + (((int)sum) >> 1);
|
|
tmp += (int)shortName[i];
|
|
sum = unchecked((byte)tmp);
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
private static void GetLongNameBounds(char[]! in ExHeap longName,
|
|
out int start,
|
|
out int length)
|
|
{
|
|
// Leading spaces are ignored.
|
|
start = 0;
|
|
while (start < longName.Length) {
|
|
if (longName[start] != ' ') {
|
|
break;
|
|
}
|
|
start++;
|
|
}
|
|
|
|
// Trailing spaces and periods are ignored.
|
|
int end = longName.Length - 1;
|
|
while (end >= 0) {
|
|
if (longName[end] != ' ' && longName[end] != '.') {
|
|
break;
|
|
}
|
|
end--;
|
|
}
|
|
length = end - start + 1;
|
|
}
|
|
|
|
private static int GetExtensionStart(char[]! in ExHeap name,
|
|
int start,
|
|
int length)
|
|
{
|
|
int extension = length - 1;
|
|
while (extension >= start) {
|
|
if (name[extension] == '.') {
|
|
return extension + 1;
|
|
}
|
|
extension--;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
internal static bool ValidLongNameCharacter(char c)
|
|
{
|
|
return (c == '.' || c == '+' || c == ',' || c == ';' ||
|
|
c == '=' || c == '[' || c == ']' ||
|
|
DirectoryEntry.ValidShortNameCharacter(c));
|
|
}
|
|
|
|
[ Microsoft.Contracts.Pure ]
|
|
internal static bool ValidName(char[]! in ExHeap longName)
|
|
{
|
|
int start, length;
|
|
GetLongNameBounds(longName, out start, out length);
|
|
if (length <= 0 || length > MaxLongNameLength) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < longName.Length; i++) {
|
|
if (!ValidLongNameCharacter(longName[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool MapLongToShort(char input, out char output)
|
|
{
|
|
char c = Char.ToUpper(input);
|
|
|
|
if (DirectoryEntry.ValidShortNameCharacter(c)) {
|
|
output = c;
|
|
return false;
|
|
}
|
|
else {
|
|
output = '_';
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static int GetAbsoluteOffsetOfFinalPeriod(char[]! in ExHeap longName,
|
|
int start,
|
|
int length)
|
|
{
|
|
int offset = start + length - 2;
|
|
while (offset > start) {
|
|
if (longName[offset] == '.') {
|
|
return offset;
|
|
}
|
|
offset--;
|
|
}
|
|
return Int32.MaxValue;
|
|
}
|
|
|
|
static bool CopyLongToShort(char[]! in ExHeap src,
|
|
int srcStart,
|
|
int srcLength,
|
|
char[]! in ExHeap dst,
|
|
int dstStart,
|
|
int dstLength,
|
|
out int dstUsed)
|
|
{
|
|
assert (srcStart >= 0 &&
|
|
srcStart <= src.Length);
|
|
assert (srcLength >= 0 &&
|
|
srcStart + srcLength <= src.Length);
|
|
assert (dstStart >= 0 &&
|
|
dstStart < dst.Length);
|
|
assert (dstLength >= 0 &&
|
|
dstStart + dstLength <= dst.Length);
|
|
|
|
bool lossy = false;
|
|
|
|
// Skip leading spaces and periods
|
|
while ((src[srcStart] == '.' || src[srcStart] == ' ') &&
|
|
srcLength != 0) {
|
|
srcStart++;
|
|
srcLength--;
|
|
}
|
|
|
|
dstUsed = 0;
|
|
|
|
for (int i = 0; i < srcLength && dstUsed < dstLength; i++) {
|
|
if (src[srcStart + i] == ' ') {
|
|
continue; // Skip embedded spaces
|
|
}
|
|
lossy |= MapLongToShort(src[srcStart + i],
|
|
out dst[dstStart + dstUsed]);
|
|
dstUsed++;
|
|
}
|
|
return lossy;
|
|
}
|
|
|
|
static void WriteNumericTail(char[]! in ExHeap shortName,
|
|
int baseNameLength,
|
|
int attempt)
|
|
{
|
|
int tailWidth = (int)Math.Log10((double)attempt) + 2; // "~NNNN"
|
|
|
|
int index = Math.Min(baseNameLength + tailWidth,
|
|
DirectoryEntry.ShortNameMaxBaseName) - 1;
|
|
|
|
while (attempt > 0) {
|
|
shortName[index] = (char)('0' + (attempt % 10));
|
|
attempt /= 10;
|
|
index --;
|
|
}
|
|
shortName[index] = '~';
|
|
}
|
|
|
|
static internal void
|
|
WriteShortNameEntry(char[]! in ExHeap longName,
|
|
int attempt,
|
|
char[]! in ExHeap shortName)
|
|
requires longName.Length > 0;
|
|
requires shortName.Length == DirectoryEntry.ShortNameEntryLength;
|
|
requires attempt >= 1 && attempt < MaxShortNameAttempts;
|
|
{
|
|
assert (ValidName(longName));
|
|
|
|
for (int i = 0; i < shortName.Length; i++) {
|
|
shortName[i] = ' ';
|
|
}
|
|
|
|
int longNameStart;
|
|
int longNameLength;
|
|
GetLongNameBounds(longName,
|
|
out longNameStart,
|
|
out longNameLength);
|
|
|
|
int extensionStart = GetExtensionStart(longName,
|
|
longNameStart,
|
|
longNameLength);
|
|
|
|
int baseUsed = 0;
|
|
bool lossy;
|
|
|
|
if (extensionStart > longNameStart) {
|
|
lossy = CopyLongToShort(
|
|
longName,
|
|
longNameStart,
|
|
extensionStart - longNameStart - 1,
|
|
shortName,
|
|
0,
|
|
DirectoryEntry.ShortNameMaxBaseName,
|
|
out baseUsed
|
|
);
|
|
|
|
int extUsed;
|
|
lossy |= CopyLongToShort(
|
|
longName,
|
|
extensionStart,
|
|
longNameStart + longNameLength - extensionStart,
|
|
shortName,
|
|
DirectoryEntry.ShortNameMaxBaseName,
|
|
DirectoryEntry.ShortNameMaxExtension,
|
|
out extUsed
|
|
);
|
|
}
|
|
else {
|
|
lossy = CopyLongToShort(
|
|
longName,
|
|
longNameStart,
|
|
longNameLength,
|
|
shortName,
|
|
0,
|
|
DirectoryEntry.ShortNameMaxBaseName,
|
|
out baseUsed
|
|
);
|
|
}
|
|
|
|
WriteNumericTail(shortName, baseUsed, attempt);
|
|
}
|
|
|
|
private const int HiBitMask = 1 << (DHashtable.MaxKeyBits - 1);
|
|
|
|
private static int HOP(int v)
|
|
{
|
|
// left rotation of DHashtable.MaxKeyBits wide unsigned integer
|
|
return (v << 1) | ((v & HiBitMask) >> (DHashtable.MaxKeyBits - 1));
|
|
}
|
|
|
|
internal int GetDirHashCode(int sum, int length)
|
|
requires length > 0;
|
|
requires length <= LongDirectoryEntry.CharactersPerEntry;
|
|
{
|
|
switch (length) {
|
|
case 13:
|
|
sum = HOP(sum) + Char.ToUpper(name12);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 12;
|
|
case 12:
|
|
sum = HOP(sum) + Char.ToUpper(name11);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 11;
|
|
case 11:
|
|
sum = HOP(sum) + Char.ToUpper(name10);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 10;
|
|
case 10:
|
|
sum = HOP(sum) + Char.ToUpper(name09);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 9;
|
|
case 9:
|
|
sum = HOP(sum) + Char.ToUpper(name08);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 8;
|
|
case 8:
|
|
sum = HOP(sum) + Char.ToUpper(name07);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 7;
|
|
case 7:
|
|
sum = HOP(sum) + Char.ToUpper(name06);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 6;
|
|
case 6:
|
|
sum = HOP(sum) + Char.ToUpper(name05);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 5;
|
|
case 5:
|
|
sum = HOP(sum) + Char.ToUpper(name04);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 4;
|
|
case 4:
|
|
sum = HOP(sum) + Char.ToUpper(name03);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 3;
|
|
case 3:
|
|
sum = HOP(sum) + Char.ToUpper(name02);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 2;
|
|
case 2:
|
|
sum = HOP(sum) + Char.ToUpper(name01);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 1;
|
|
case 1:
|
|
sum = HOP(sum) + Char.ToUpper(name00);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
goto case 0;
|
|
case 0:
|
|
break;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
internal static int GetDirHashCode(char []! in ExHeap longName)
|
|
{
|
|
int start;
|
|
int length;
|
|
GetLongNameBounds(longName, out start, out length);
|
|
|
|
int sum = 0;
|
|
for (int i = start + length - 1; i >= start; i--) {
|
|
sum = HOP(sum) + Char.ToUpper(longName[i]);
|
|
sum &= DHashtable.MaxKeyValue;
|
|
}
|
|
return sum;
|
|
}
|
|
}
|
|
}
|