PacExtractor.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace RePacManager
{
    public class PacExtractor
    {
        public static void ExtractPac(string pacFile, string outDir, Action<string> logCallback = null, Action<double> progressCallback = null)
        {
            void Log(string msg) => logCallback?.Invoke(msg);

            using (FileStream fs = new FileStream(pacFile, FileMode.Open, FileAccess.Read))
            using (BinaryReader br = new BinaryReader(fs))
            {
                // Parse PAC Header (2124 bytes)
                string szVersion = ReadString(br, 44);
                uint dwHiSize = br.ReadUInt32();
                uint dwLoSize = br.ReadUInt32();
                
                string productName = ReadString(br, 512);
                string firmwareName = ReadString(br, 512);
                
                uint partitionCount = br.ReadUInt32();
                uint partitionsListStart = br.ReadUInt32();
                
                Log($"Product: {productName}");
                Log($"Firmware: {firmwareName}");
                Log($"Partitions: {partitionCount}");

                List<FileHeader> files = new List<FileHeader>();
                
                fs.Seek(partitionsListStart, SeekOrigin.Begin);
                
                for (int i = 0; i < partitionCount; i++)
                {
                    long startPos = fs.Position;
                    
                    uint length = br.ReadUInt32();
                    string partitionName = ReadString(br, 512);
                    string fileName = ReadString(br, 512);
                    string szFileName = ReadString(br, 504);    
                    
                    uint hiPartitionSize = br.ReadUInt32();
                    uint hiDataOffset = br.ReadUInt32();
                    uint loPartitionSize = br.ReadUInt32();
                    uint nFileFlag = br.ReadUInt32();
                    uint nCheckFlag = br.ReadUInt32();
                    uint loDataOffset = br.ReadUInt32();
                    
                    // Skip remaining to reach 2580 total header size for file
                    // Read so far is 4+512+512+504+24 = 1556
                    // 2580 - 1556 = 1024
                    fs.Seek(1024, SeekOrigin.Current); 
                    
                    long size = ((long)hiPartitionSize << 32) | loPartitionSize;
                    long offset = ((long)hiDataOffset << 32) | loDataOffset;
                    
                    files.Add(new FileHeader 
                    { 
                        FileName = fileName, 
                        PartitionName = partitionName,
                        Size = size, 
                        Offset = offset,
                        IsFile = nFileFlag == 1 
                    });
                }
                
                Log($"\nExtracting {files.Count} files to: {outDir}");
                Directory.CreateDirectory(outDir);
                
                int fileIndex = 0;
                foreach (var file in files)
                {
                    fileIndex++;
                    if (progressCallback != null)
                    {
                        progressCallback((double)fileIndex / files.Count * 100);
                    }

                    if (file.Size == 0) continue;
                    
                    string name = string.IsNullOrWhiteSpace(file.FileName) ? file.PartitionName : file.FileName;
                    if (string.IsNullOrWhiteSpace(name)) continue;
                    
                    foreach(char c in Path.GetInvalidFileNameChars()) { name = name.Replace(c, '_'); }
                    
                    string destPath = Path.Combine(outDir, name);
                    Log($"Extracting {name} ({file.Size} bytes)... ");
                    
                    try 
                    {
                        using (var destStream = new FileStream(destPath, FileMode.Create, FileAccess.Write))
                        {
                            fs.Seek(file.Offset, SeekOrigin.Begin);
                            
                            byte[] buffer = new byte[81920]; 
                            long remaining = file.Size;
                            while (remaining > 0)
                            {
                                int toRead = (int)Math.Min(remaining, buffer.Length);
                                int read = fs.Read(buffer, 0, toRead);
                                if (read == 0) break;
                                destStream.Write(buffer, 0, read);
                                remaining -= read;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log($"Failed: {ex.Message}");
                    }
                }
                Log("Extraction complete.");
            }
        }

        private static string ReadString(BinaryReader br, int length)
        {
            byte[] bytes = br.ReadBytes(length);
            string s = Encoding.Unicode.GetString(bytes);
            int nullIndex = s.IndexOf('\0');
            if (nullIndex >= 0) s = s.Substring(0, nullIndex);
            return s;
        }

        private class FileHeader
        {
            public string FileName { get; set; }
            public string PartitionName { get; set; }
            public long Size { get; set; }
            public long Offset { get; set; }
            public bool IsFile { get; set; }
        }
    }
}