Initial Commit

Author: kwsch

LICENSE

@@ -0,0 +1,2 @@
+# pkNX
+pkNX... for lack of a better name!

README.md

@@ -0,0 +1,73 @@
+using System;
+using System.IO;
+
+namespace pkNX.Containers
+{
+    public static class Container
+    {
+        /// <summary>
+        /// Gets a new <see cref="IFileContainer"/> for the provided <see cref="path"/> and type.
+        /// </summary>
+        /// <param name="path">File location</param>
+        /// <param name="t">File type</param>
+        public static IFileContainer GetContainer(string path, ContainerType t)
+        {
+            switch (t)
+            {
+                case ContainerType.GARC: return new GARC(path);
+                case ContainerType.Mini: return MiniUtil.GetMini(path);
+                case ContainerType.SARC: return new SARC(path);
+                case ContainerType.Folder: return new FolderContainer(path);
+                case ContainerType.SingleFile: return new SingleFileContainer(path);
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(t), t, null);
+            }
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IFileContainer"/> for the stream.
+        /// </summary>
+        /// <param name="path">Path to the binary data</param>
+        public static IFileContainer GetContainer(string path)
+        {
+            var fs = new FileStream(path, FileMode.Open);
+            var container = GetContainer(fs);
+            if (!(container is LargeContainer)) // not kept
+                fs.Dispose();
+            if (container == null)
+                return null;
+
+            container.FilePath = path;
+            return container;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IFileContainer"/> for the stream.
+        /// </summary>
+        /// <param name="stream">Stream for the binary data</param>
+        public static IFileContainer GetContainer(Stream stream)
+        {
+            BinaryReader br = new BinaryReader(stream);
+            var container = GetContainer(br);
+            if (!(container is LargeContainer)) // not kept
+                br.Dispose();
+            return container;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IFileContainer"/> for the stream within the <see cref="BinaryReader"/>.
+        /// </summary>
+        /// <param name="br">Reader for the binary data</param>
+        public static IFileContainer GetContainer(BinaryReader br)
+        {
+            IFileContainer container;
+            if ((container = GARC.GetGARC(br)) != null)
+                return container;
+            if ((container = MiniUtil.GetMini(br)) != null)
+                return container;
+            if ((container = SARC.GetSARC(br)) != null)
+                return container;
+            return null;
+        }
+    }
+}

pkNX.Containers/Container.cs

@@ -0,0 +1,29 @@
+using System;
+// ReSharper disable ClassNeverInstantiated.Global
+// ReSharper disable EventNeverSubscribedTo.Global
+
+namespace pkNX.Containers
+{
+    public sealed class ContainerHandler
+    {
+        public event EventHandler<FileCountDeterminedEventArgs> FileCountDetermined;
+        public event EventHandler<FileProgressedEventArgs> FileProgressed;
+
+        private int count;
+
+        public void Initialize(int total)
+        {
+            count = total;
+            var args = new FileCountDeterminedEventArgs {Total = total};
+            FileCountDetermined?.Invoke(null, args);
+        }
+
+        public void StepFile(int ctr, int total = -1, string fileName = null)
+        {
+            if (total < 0)
+                total = count;
+            var args = new FileProgressedEventArgs {Current = ctr, Total = total, CurrentFile = fileName};
+            FileProgressed?.Invoke(null, args);
+        }
+    }
+}

pkNX.Containers/ContainerHandler/ContainerHandler.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace pkNX.Containers
+{
+    public class FileCountDeterminedEventArgs : EventArgs
+    {
+        public int Total { get; set; }
+    }
+}

pkNX.Containers/ContainerHandler/FileCountDeterminedEventArgs.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace pkNX.Containers
+{
+    public class FileProgressedEventArgs : EventArgs
+    {
+        public int Current { get; set; }
+        public int Total { get; set; }
+        public string CurrentFile { get; set; }
+    }
+}

pkNX.Containers/ContainerHandler/FileProgressedEventArgs.cs

@@ -0,0 +1,15 @@
+namespace pkNX.Containers
+{
+    public enum ContainerParent
+    {
+        /// <summary>
+        /// File is located in the RomFS.
+        /// </summary>
+        RomFS,
+
+        /// <summary>
+        /// File is located in the ExeFS.
+        /// </summary>
+        ExeFS,
+    }
+}

pkNX.Containers/ContainerParent.cs

@@ -0,0 +1,11 @@
+namespace pkNX.Containers
+{
+    public enum ContainerType
+    {
+        GARC,
+        Mini,
+        SARC,
+        Folder,
+        SingleFile,
+    }
+}

pkNX.Containers/ContainerType.cs

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace pkNX.Containers
+{
+    public class FolderContainer : IFileContainer
+    {
+        private readonly List<string> Paths = new List<string>();
+        private readonly List<byte[]> Data = new List<byte[]>();
+        private readonly List<bool> TrackModify = new List<bool>();
+
+        public FolderContainer() { }
+        public FolderContainer(IEnumerable<string> files) => AddFiles(files);
+
+        public FolderContainer(string path)
+        {
+            FilePath = path;
+            AddFiles(Directory.GetFiles(path, "*", SearchOption.AllDirectories));
+        }
+
+        public void AddFile(string file, byte[] data = null)
+        {
+            Paths.Add(file);
+            Data.Add(data);
+            TrackModify.Add(false);
+        }
+
+        public void AddFiles(IEnumerable<string> files)
+        {
+            foreach (var f in files)
+                AddFile(f);
+        }
+
+        public byte[] GetFileData(string file)
+        {
+            var index = Paths.IndexOf(file);
+            if (index < 0)
+                return null;
+            return Data[index] ?? (Data[index] = File.ReadAllBytes(file));
+        }
+
+        public byte[] GetFileData(int index)
+        {
+            if (index < 0 || Data.Count >= index)
+                return null;
+            return Data[index] ?? (Data[index] = File.ReadAllBytes(Paths[index]));
+        }
+
+        public byte[] this[int index]
+        {
+            get => GetFileData(index);
+            set
+            {
+                if (value != null && Data[index] != null)
+                    TrackModify[index] = value.SequenceEqual(Data[index]);
+                Data[index] = value;
+            }
+        }
+
+        public string FilePath { get; set; }
+        public bool Modified => TrackModify.Count != 0;
+        public int Count => Paths.Count;
+
+        public Task<byte[][]> GetFiles() => new Task<byte[][]>(() => Paths.Select(File.ReadAllBytes).ToArray());
+        public Task<byte[]> GetFile(int file, int subFile = 0) => new Task<byte[]>(() => this[file]);
+        public Task SetFile(int file, byte[] value, int subFile = 0) => new Task(() => this[file] = value);
+        public Task SaveAs(string path, ContainerHandler handler, CancellationToken token) => new Task(SaveAll);
+
+        private void SaveAll()
+        {
+            for (int i = 0; i < Paths.Count; i++)
+            {
+                if (!TrackModify[i])
+                    continue;
+                var data = Data[i];
+                if (data == null)
+                    continue;
+                File.WriteAllBytes(Paths[i], data);
+            }
+        }
+
+        public void Dump(string path, ContainerHandler handler)
+        {
+            SaveAll(); // there's really nothing to dump, just save any modified
+        }
+    }
+}

pkNX.Containers/FolderContainer.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.IO;
+
+namespace pkNX.Containers
+{
+    internal class FATB
+    {
+        private const uint MAGIC = 0x46415442;
+
+        private readonly uint Magic = MAGIC;
+        private readonly int HeaderSize = 0xC;
+        private readonly ushort EntryCount;
+        private readonly short Padding = -1;
+
+        private FATBEntry[] Entries { get; }
+        public FATBEntry this[int index] => Entries[index];
+
+        public FATB(BinaryReader br, int DataOffset)
+        {
+            Magic = br.ReadUInt32();
+            HeaderSize = br.ReadInt32();
+            EntryCount = br.ReadUInt16();
+            Padding = br.ReadInt16();
+
+            Entries = new FATBEntry[EntryCount];
+            for (int i = 0; i < EntryCount; i++)
+                Entries[i] = new FATBEntry(br, DataOffset);
+        }
+
+        public FATB(IReadOnlyList<string> files)
+        {
+            EntryCount = (ushort)files.Count;
+            Entries = new FATBEntry[EntryCount];
+            for (int i = 0; i < EntryCount; i++)
+            {
+                if (!Directory.Exists(files[i]))
+                    Entries[i] = new FATBEntry(files[i]);
+                else
+                    Entries[i] = new FATBEntry(Directory.GetFiles(files[i]));
+            }
+        }
+
+        public void Write(BinaryWriter bw)
+        {
+            bw.Write(Magic);
+            bw.Write(HeaderSize);
+            bw.Write(EntryCount);
+            bw.Write(Padding);
+            foreach (var entry in Entries)
+                entry.Write(bw);
+            // sub entry writing handled separately
+        }
+    }
+}