Initial commit - WPinternals 2.6

DiscUtils/Ntfs/Directory.cs

@@ -0,0 +1,291 @@
+//
+// 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.Ntfs
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using DirectoryIndexEntry = System.Collections.Generic.KeyValuePair<DiscUtils.Ntfs.FileNameRecord, DiscUtils.Ntfs.FileRecordReference>;
+
+    internal class Directory : File
+    {
+        private IndexView<FileNameRecord, FileRecordReference> _index;
+
+        public Directory(INtfsContext context, FileRecord baseRecord)
+            : base(context, baseRecord)
+        {
+        }
+
+        public bool IsEmpty
+        {
+            get { return Index.Count == 0; }
+        }
+
+        private IndexView<FileNameRecord, FileRecordReference> Index
+        {
+            get
+            {
+                if (_index == null && StreamExists(AttributeType.IndexRoot, "$I30"))
+                {
+                    _index = new IndexView<FileNameRecord, FileRecordReference>(GetIndex("$I30"));
+                }
+
+                return _index;
+            }
+        }
+
+        public IEnumerable<DirectoryEntry> GetAllEntries(bool filter)
+        {
+            IEnumerable<DirectoryIndexEntry> entries = filter ? FilterEntries(Index.Entries) : Index.Entries;
+
+            foreach (var entry in entries)
+            {
+                yield return new DirectoryEntry(this, entry.Value, entry.Key);
+            }
+        }
+
+        public void UpdateEntry(DirectoryEntry entry)
+        {
+            Index[entry.Details] = entry.Reference;
+            UpdateRecordInMft();
+        }
+
+        public override void Dump(TextWriter writer, string indent)
+        {
+            writer.WriteLine(indent + "DIRECTORY (" + base.ToString() + ")");
+            writer.WriteLine(indent + "  File Number: " + IndexInMft);
+
+            if (Index != null)
+            {
+                foreach (var entry in Index.Entries)
+                {
+                    writer.WriteLine(indent + "  DIRECTORY ENTRY (" + entry.Key.FileName + ")");
+                    writer.WriteLine(indent + "    MFT Ref: " + entry.Value);
+                    entry.Key.Dump(writer, indent + "    ");
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            return base.ToString() + @"\";
+        }
+
+        internal static new Directory CreateNew(INtfsContext context, FileAttributeFlags parentDirFlags)
+        {
+            Directory dir = (Directory)context.AllocateFile(FileRecordFlags.IsDirectory);
+
+            StandardInformation.InitializeNewFile(
+                dir,
+                FileAttributeFlags.Archive | (parentDirFlags & FileAttributeFlags.Compressed));
+
+            // Create the index root attribute by instantiating a new index
+            dir.CreateIndex("$I30", AttributeType.FileName, AttributeCollationRule.Filename);
+
+            dir.UpdateRecordInMft();
+
+            return dir;
+        }
+
+        internal DirectoryEntry GetEntryByName(string name)
+        {
+            string searchName = name;
+
+            int streamSepPos = name.IndexOf(':');
+            if (streamSepPos >= 0)
+            {
+                searchName = name.Substring(0, streamSepPos);
+            }
+
+            DirectoryIndexEntry entry = Index.FindFirst(new FileNameQuery(searchName, _context.UpperCase));
+            if (entry.Key != null)
+            {
+                return new DirectoryEntry(this, entry.Value, entry.Key);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        internal DirectoryEntry AddEntry(File file, string name, FileNameNamespace nameNamespace)
+        {
+            if (name.Length > 255)
+            {
+                throw new IOException("Invalid file name, more than 255 characters: " + name);
+            }
+            else if (name.IndexOfAny(new char[] { '\0', '/' }) != -1)
+            {
+                throw new IOException(@"Invalid file name, contains '\0' or '/': " + name);
+            }
+
+            FileNameRecord newNameRecord = file.GetFileNameRecord(null, true);
+            newNameRecord.FileNameNamespace = nameNamespace;
+            newNameRecord.FileName = name;
+            newNameRecord.ParentDirectory = MftReference;
+
+            NtfsStream nameStream = file.CreateStream(AttributeType.FileName, null);
+            nameStream.SetContent(newNameRecord);
+
+            file.HardLinkCount++;
+            file.UpdateRecordInMft();
+
+            Index[newNameRecord] = file.MftReference;
+
+            Modified();
+            UpdateRecordInMft();
+
+            return new DirectoryEntry(this, file.MftReference, newNameRecord);
+        }
+
+        internal void RemoveEntry(DirectoryEntry dirEntry)
+        {
+            File file = _context.GetFileByRef(dirEntry.Reference);
+
+            FileNameRecord nameRecord = dirEntry.Details;
+
+            Index.Remove(dirEntry.Details);
+
+            foreach (NtfsStream stream in file.GetStreams(AttributeType.FileName, null))
+            {
+                FileNameRecord streamName = stream.GetContent<FileNameRecord>();
+                if (nameRecord.Equals(streamName))
+                {
+                    file.RemoveStream(stream);
+                    break;
+                }
+            }
+
+            file.HardLinkCount--;
+            file.UpdateRecordInMft();
+
+            Modified();
+            UpdateRecordInMft();
+        }
+
+        internal string CreateShortName(string name)
+        {
+            string baseName = string.Empty;
+            string ext = string.Empty;
+
+            int lastPeriod = name.LastIndexOf('.');
+
+            int i = 0;
+            while (baseName.Length < 6 && i < name.Length && i != lastPeriod)
+            {
+                char upperChar = Char.ToUpperInvariant(name[i]);
+                if (Utilities.Is8Dot3Char(upperChar))
+                {
+                    baseName += upperChar;
+                }
+
+                ++i;
+            }
+
+            if (lastPeriod >= 0)
+            {
+                i = lastPeriod + 1;
+                while (ext.Length < 3 && i < name.Length)
+                {
+                    char upperChar = Char.ToUpperInvariant(name[i]);
+                    if (Utilities.Is8Dot3Char(upperChar))
+                    {
+                        ext += upperChar;
+                    }
+
+                    ++i;
+                }
+            }
+
+            i = 1;
+            string candidate;
+            do
+            {
+                string suffix = string.Format(CultureInfo.InvariantCulture, "~{0}", i);
+                candidate = baseName.Substring(0, Math.Min(8 - suffix.Length, baseName.Length)) + suffix + (ext.Length > 0 ? "." + ext : string.Empty);
+                i++;
+            }
+            while (GetEntryByName(candidate) != null);
+
+            return candidate;
+        }
+
+        private List<DirectoryIndexEntry> FilterEntries(IEnumerable<DirectoryIndexEntry> entriesIter)
+        {
+            List<DirectoryIndexEntry> entries = new List<DirectoryIndexEntry>(entriesIter);
+
+            // Weed out short-name entries for files and any hidden / system / metadata files.
+            int i = 0;
+            while (i < entries.Count)
+            {
+                DirectoryIndexEntry entry = entries[i];
+
+                if (((entry.Key.Flags & FileAttributeFlags.Hidden) != 0) && _context.Options.HideHiddenFiles)
+                {
+                    entries.RemoveAt(i);
+                }
+                else if (((entry.Key.Flags & FileAttributeFlags.System) != 0) && _context.Options.HideSystemFiles)
+                {
+                    entries.RemoveAt(i);
+                }
+                else if (entry.Value.MftIndex < 24 && _context.Options.HideMetafiles)
+                {
+                    entries.RemoveAt(i);
+                }
+                else if (entry.Key.FileNameNamespace == FileNameNamespace.Dos && _context.Options.HideDosFileNames)
+                {
+                    entries.RemoveAt(i);
+                }
+                else
+                {
+                    ++i;
+                }
+            }
+
+            return entries;
+        }
+
+        private sealed class FileNameQuery : IComparable<byte[]>
+        {
+            private byte[] _query;
+            private UpperCase _upperCase;
+
+            public FileNameQuery(string query, UpperCase upperCase)
+            {
+                _query = Encoding.Unicode.GetBytes(query);
+                _upperCase = upperCase;
+            }
+
+            public int CompareTo(byte[] buffer)
+            {
+                // Note: this is internal knowledge of FileNameRecord structure - but for performance
+                // reasons, we don't want to decode the entire structure.  In fact can avoid the string
+                // conversion as well.
+                byte fnLen = buffer[0x40];
+                return _upperCase.Compare(_query, 0, _query.Length, buffer, 0x42, fnLen * 2);
+            }
+        }
+    }
+}