示例#1
0
 public FileProps(string name, uint filesize, string backgroundfile = null)
 {
     Name                = FATBlock.GetValidFullname(name);
     Filesize            = filesize;
     PseudoFileBlockList = new SortedDictionary <ushort, int>();
     Backgroundfile      = !string.IsNullOrEmpty(backgroundfile) ? backgroundfile : Name;
 }
示例#2
0
        /// <summary>
        /// liefert die nötige Anzahl FAT-Blöcke für die Dateigröße; abh. von der <see cref="Header.FileBlockLength"/> und der <see cref="Header.FATBlockLength"/>
        /// </summary>
        /// <param name="filesize"></param>
        /// <returns></returns>
        int FATBlocks4File(int filesize)
        {
            int blocks    = blocks4File(filesize);
            int maxblocks = FATBlock.MaxBlocks(ImgHeader.FATBlockLength);

            return(blocks / maxblocks + (blocks % maxblocks != 0 ? 1 : 0));
        }
示例#3
0
 public FATBlock(FATBlock bl) :
     this(bl.BlockSize)
 {
     BlockSize = bl.BlockSize;
     Name      = bl.Name;
     Typ       = bl.Typ;
     Filesize  = bl.Filesize;
     Used      = bl.Used;
     Flag      = bl.Flag;
     Part      = bl.Part;
     Unknown   = new byte[bl.Unknown.Length];
     bl.Unknown.CopyTo(Unknown, 0);
 }
示例#4
0
        /// <summary>
        /// erzeugt so viele Blöcke wie nötig, um die Blöcke für die Datei zu adressieren
        /// </summary>
        /// <param name="filename">Dateiname ("." für Root; "" oder null für einen ungenutzten Block)</param>
        /// <param name="filesize">Dateigröße</param>
        /// <param name="startblockno">erste Blocknummer für den Dateiinhalt</param>
        /// <returns></returns>
        List <FATBlock> buildFATEntry(string filename, uint filesize, ref ushort startblockno)
        {
            List <FATBlock> lst = new List <FATBlock>();

            FATBlock bl = new FATBlock((uint)ImgHeader.FATBlockLength);

            if (!string.IsNullOrEmpty(filename))
            {
                bl.Used     = true;
                bl.Flag     = (byte)(filename == "." ? 0x03 : 0x00);
                bl.FullName = filename;
                bl.Filesize = filesize;
                bl.Part     = 0;

                int blocks4file = blocks4File((int)filesize);
                do
                {
                    bl.ClearBlockNumbers();
                    while (blocks4file > 0 &&
                           !bl.BlockTableIsFull)
                    {
                        bl.AppendBlockNumber(startblockno++);
                        blocks4file--;
                    }
                    lst.Add(bl);

                    if (blocks4file > 0)
                    {
                        bl = new FATBlock(bl);
                        bl.Part++;
                        bl.Filesize = 0;
                    }
                }while (blocks4file > 0);
            }
            else
            {
                bl.Used = false;

                lst.Add(bl);
            }

            return(lst);
        }
示例#5
0
        /// <summary>
        /// liest das gesamte Dateisystem (aber ohne die Daten interner Dateien) ein und "behält" den <see cref="BinaryReaderWriter"/>
        /// <para>Der Dateiinhalt wird immer nur bei Bedarf eingelesen.</para>
        /// </summary>
        /// <param name="br"></param>
        public void Read(BinaryReaderWriter br)
        {
            binreader = br;

            // Header einlesen
            binreader.Seek(0);
            ImgHeader.Read(binreader);

            List <FATBlock> root = new List <FATBlock>();
            List <FATBlock> fat  = new List <FATBlock>();

            // gesamte FAT einlesen
            int sumfatblocks = -1;

            while (sumfatblocks != 0)
            {
                FATBlock bl = new FATBlock((uint)ImgHeader.FATBlockLength);
                bl.Read(binreader);
                if (sumfatblocks < 0)
                {
                    sumfatblocks = ((int)bl.Filesize - ImgHeader.HeaderLength) / ImgHeader.FATBlockLength; // Anzahl der FAT-Blocks aus dem 1. Block ("Dateigröße") ermitteln
                }
                if (bl.FullName == ".")
                {
                    root.Add(bl);
                }
                else
                {
                    fat.Add(bl);
                }
                sumfatblocks--;
            }

            // Dateiliste erzeugen
            file4block.Clear();
            Files.Clear();
            preblocks4read = (UInt16)(root[0].Filesize / ImgHeader.FileBlockLength);  // Anzahl der Datenblöcke bis zum Start des echten Dateiinhaltbereiches
            if (root[0].Filesize % ImgHeader.FileBlockLength != 0)
            {
                preblocks4read++;
            }
            FATSize = (int)root[0].Filesize - ImgHeader.HeaderLength;

            for (int block = 0; block < fat.Count; block++)
            {
                FATBlock bl = fat[block];
                if (bl.Used)
                {
                    FileProps file;
                    if (bl.Part == 0)
                    {
                        string name = bl.FullName;
                        if (name != ".")
                        {
                            file = new FileProps(name, bl.Filesize, string.IsNullOrEmpty(backgroundpath) ? null : getBackFilename(name));
                            Files.Add(file);
                        }
                    }
                    int fileidx = Files.Count - 1;
                    file = Files[fileidx];
                    for (int j = 0; j < bl.BlockNumberCount; j++)          // alle Blocknummern registrieren
                    {
                        UInt16 blockno = (UInt16)(bl.GetBlockNumber(j) - preblocks4read);
                        file.PseudoFileBlockAdd(blockno);                  // 0-basierte Blocknummern speichern
                        file4block.Add(blockno, fileidx);
                    }
                }
            }
        }