/src/Ntfs/Directory.cs

//

// 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);

            }

        }

    }

}