コード例 #1
0
        public static void Unpack(string tocFilePath, string outDirectoryPath)
        {
            abort          = false;
            overwriteFiles = false;
            SetProgressBarValue(0);
            progress = 0;

            byte[] rawToc = File.ReadAllBytes(tocFilePath);
            CryptTools.TocDecryptEncrypt(rawToc);

            Toc toc = new Toc(Path.GetFileNameWithoutExtension(tocFilePath), rawToc);

            packageSize = GetPackageSize(toc, 0);

            Unpack(toc, 0, "", Path.GetDirectoryName(tocFilePath), outDirectoryPath);

            if (abort)
            {
                SetProgressBarValue(0);
                SetStatusText("Aborted!");
            }
            else
            {
                SetStatusText("Finished!");
            }
        }
コード例 #2
0
        public static void Pack(string inDirectoryPath, string outDirectoryPath)
        {
            abort          = false;
            overwriteFiles = false;
            SetProgressBarValue(0);
            progress = 0;

            DirectoryInfo inDirectory = new DirectoryInfo(inDirectoryPath);

            inDirectoryPathLength = inDirectory.FullName.Length;
            packageSize           = GetDirectorySize(inDirectory);
            long entryCount = GetDirectoryItemCount(inDirectory) + 1;


            Toc toc = new Toc(inDirectory.Name, entryCount);

            Pack(toc, 0, 1, inDirectory, outDirectoryPath);

            if (!abort)
            {
                byte[] rawToc = toc.CreateRawToc();
                CryptTools.TocDecryptEncrypt(rawToc);
                SafeFileWrite(JoinPaths(outDirectoryPath, toc.name + ".toc"), rawToc);
            }


            if (abort)
            {
                SetProgressBarValue(0);
                SetStatusText("Aborted!");
            }
            else
            {
                SetStatusText("Finished!");
            }
        }
コード例 #3
0
        public static uint Pack(Toc toc, uint tocIndex, uint tocOffset, DirectoryInfo currentInDirectory, string outDirectoryPath)
        {
            if (abort)
            {
                return(0);
            }

            DirectoryInfo[] subDirectories = currentInDirectory.GetDirectories();
            FileInfo[]      files          = currentInDirectory.GetFiles();
            uint            itemCount      = (uint)(subDirectories.Length + files.Length);

            tocEntryStruct tocEntry = new tocEntryStruct()
            {
                isFolder = true,
                length   = itemCount,
                offset   = tocOffset
            };

            if (tocIndex == 0)
            {
                tocEntry.name         = "";
                tocEntry.nameChecksum = 0;
                tocEntry.container    = uint.MaxValue;
            }
            else
            {
                tocEntry.name         = currentInDirectory.Name;
                tocEntry.nameChecksum = CryptTools.GetNameChecksum(currentInDirectory.Name);
            }

            toc.entries[tocIndex] = tocEntry;

            uint i = 0;

            foreach (DirectoryInfo subDirectory in subDirectories)
            {
                itemCount += Pack(toc, tocOffset + i, tocOffset + itemCount, subDirectory, outDirectoryPath);
                toc.entries[tocOffset + i].container = tocIndex;
                i++;
            }
            foreach (FileInfo file in files)
            {
                SetStatusText(file.FullName.Substring(inDirectoryPathLength, file.FullName.Length - inDirectoryPathLength));

                string outFilePath = JoinPaths(outDirectoryPath, string.Format("{0}.M{1:00}", toc.name, toc.containerCount - 1));
                if (toc.containerCount == 0 || (new FileInfo(outFilePath).Length) + file.Length > uint.MaxValue)
                {
                    toc.containerCount++;
                    outFilePath = JoinPaths(outDirectoryPath, string.Format("{0}.M{1:00}", toc.name, toc.containerCount - 1));

                    SafeFileWrite(outFilePath, new byte[0]);
                    if (abort)
                    {
                        return(0);
                    }
                }

                byte[] fileBytes  = File.ReadAllBytes(file.FullName);
                string inFilePath = file.FullName;

                toc.entries[tocOffset + i] = new tocEntryStruct()
                {
                    isFolder     = false,
                    length       = (uint)file.Length,
                    name         = Path.GetFileName(inFilePath),
                    nameChecksum = CryptTools.GetNameChecksum(Path.GetFileName(inFilePath)),
                    offset       = (uint)(new FileInfo(outFilePath).Length),
                    container    = toc.containerCount - 1
                };

                AppendFile(outFilePath, fileBytes);

                progress += file.Length;
                SetProgressBarValue((int)((100 * progress) / packageSize));
                i++;
            }

            return(itemCount);
        }