public FatDirectoryEntry CreateSub(Fat fat)
        {
            var chain = new ClusterChain(fat, false);

            chain.SetChainLength(1);

            var entry = FatDirectoryEntry.Create(true);

            entry.SetStartCluster(chain.GetStartCluster());

            var dir =
                new ClusterChainDirectory(chain, false);

            /* add "." entry */

            var dot = FatDirectoryEntry.Create(true);

            dot.SetShortName(ShortName.Dot);
            dot.SetStartCluster(dir.GetStorageCluster());
            CopyDateTimeFields(entry, dot);
            dir.AddEntry(dot);

            /* add ".." entry */

            var dotDot = FatDirectoryEntry.Create(true);

            dotDot.SetShortName(ShortName.DotDot);
            dotDot.SetStartCluster(GetStorageCluster());
            CopyDateTimeFields(entry, dotDot);
            dir.AddEntry(dotDot);

            dir.Flush();

            return(entry);
        }
Exemple #2
0
        public static ClusterChainDirectory ReadRoot(ClusterChain chain)
        {
            var result = new ClusterChainDirectory(chain, true);

            result.Read();
            return(result);
        }
Exemple #3
0
        /// <summary>
        /// Constructor for FatFileSystem in specified readOnly mode
        /// </summary>
        /// <param name="device">the <see cref="IBlockDevice"/> holding the file system</param>
        /// <param name="readOnly"></param>
        /// <param name="ignoreFatDifferences"></param>
        /// <exception cref="IOException">IOException on read error</exception>
        private FatFileSystem(IBlockDevice device, bool readOnly,
                              bool ignoreFatDifferences) : base(readOnly)
        {
            bs = BootSector.Read(device);

            if (bs.GetNrFats() <= 0)
            {
                throw new IOException(
                          "boot sector says there are no FATs");
            }

            filesOffset = FatUtils.GetFilesOffset(bs);
            fatType     = bs.GetFatType();
            fat         = Fat.Read(bs, 0);

            if (!ignoreFatDifferences)
            {
                for (var i = 1; i < bs.GetNrFats(); i++)
                {
                    var tmpFat = Fat.Read(bs, i);
                    if (!fat.Equals(tmpFat))
                    {
                        throw new IOException("FAT " + i + " differs from FAT 0");
                    }
                }
            }

            if (fatType == FatType.BaseFat32)
            {
                var f32Bs       = (Fat32BootSector)bs;
                var rootDirFile = new ClusterChain(fat,
                                                   f32Bs.GetRootDirFirstCluster(), IsReadOnly());
                rootDirStore = ClusterChainDirectory.ReadRoot(rootDirFile);
                fsiSector    = FsInfoSector.Read(f32Bs);

                if (fsiSector.GetFreeClusterCount() != fat.GetFreeClusterCount())
                {
                    throw new IOException("free cluster count mismatch - fat: " +
                                          fat.GetFreeClusterCount() + " - fsinfo: " +
                                          fsiSector.GetFreeClusterCount());
                }
            }
            else
            {
                rootDirStore =
                    Fat16RootDirectory.Read((Fat16BootSector)bs, readOnly);
                fsiSector = null;
            }

            rootDir = new FatLfnDirectory(rootDirStore, fat, IsReadOnly());
        }
        private static ClusterChainDirectory Read(FatDirectoryEntry entry, Fat fat)
        {
            if (!entry.IsDirectory())
            {
                throw
                    new ArgumentException(entry + " is no directory");
            }

            var chain = new ClusterChain(
                fat, entry.GetStartCluster(),
                entry.IsReadonlyFlag());

            var result =
                new ClusterChainDirectory(chain, false);

            result.Read();
            return(result);
        }
Exemple #5
0
        public static ClusterChainDirectory CreateRoot(Fat fat)
        {
            if (fat.GetFatType() != FatType.BaseFat32)
            {
                throw new ArgumentException(
                          "only FAT32 stores root directory in a cluster chain");
            }

            var bs = (Fat32BootSector)fat.GetBootSector();
            var cc = new ClusterChain(fat, false);

            cc.SetChainLength(1);

            bs.SetRootDirFirstCluster(cc.GetStartCluster());

            var result =
                new ClusterChainDirectory(cc, true);

            result.Flush();
            return(result);
        }
        /// <summary>
        /// Initializes the boot sector and file system for the device. The file
        /// system created by this method will always be in read-write mode.
        /// </summary>
        /// <returns>the file system that was created</returns>
        /// <exception cref="System.IO.IOException">IOException on write error</exception>
        public FatFileSystem Format()
        {
            var sectorSize   = device.GetSectorSize();
            var totalSectors = (int)(device.GetSize() / sectorSize);

            FsInfoSector fsi;
            BootSector   bs;

            if (sectorsPerCluster == 0)
            {
                throw new Exception();
            }

            if (fatType == FatType.BaseFat32)
            {
                bs = new Fat32BootSector(device);
                InitBootSector(bs);

                var f32Bs = (Fat32BootSector)bs;

                f32Bs.SetFsInfoSectorNr(1);

                f32Bs.SetSectorsPerFat(SectorsPerFat(0, totalSectors));
                var rnd = new Random();
                f32Bs.SetFileSystemId(rnd.Next());

                f32Bs.SetVolumeLabel(label);

                /* create FS info sector */
                fsi = FsInfoSector.Create(f32Bs);
            }
            else
            {
                bs = new Fat16BootSector(device);
                InitBootSector(bs);

                var f16Bs = (Fat16BootSector)bs;

                var rootDirEntries = RootDirectorySize(
                    device.GetSectorSize(), totalSectors);

                f16Bs.SetRootDirEntryCount(rootDirEntries);
                f16Bs.SetSectorsPerFat(SectorsPerFat(rootDirEntries, totalSectors));
                if (label != null)
                {
                    f16Bs.SetVolumeLabel(label);
                }
                fsi = null;
            }

            //        bs.write();

            if (fatType == FatType.BaseFat32)
            {
                var f32Bs = (Fat32BootSector)bs;
                /* possibly writes the boot sector copy */
                f32Bs.WriteCopy(device);
            }

            var fat = Fat.Create(bs, 0);

            AbstractDirectory rootDirStore;

            if (fatType == FatType.BaseFat32)
            {
                rootDirStore = ClusterChainDirectory.CreateRoot(fat);
                fsi.SetFreeClusterCount(fat.GetFreeClusterCount());
                fsi.SetLastAllocatedCluster(fat.GetLastAllocatedCluster());
                fsi.Write();
            }
            else
            {
                rootDirStore = Fat16RootDirectory.Create((Fat16BootSector)bs);
            }

            var rootDir =
                new FatLfnDirectory(rootDirStore, fat, false);

            rootDir.Flush();

            for (var i = 0; i < bs.GetNrFats(); i++)
            {
                fat.WriteCopy(FatUtils.GetFatOffset(bs, i));
            }

            bs.Write();

            var fs = FatFileSystem.Read(device, false);

            if (label != null)
            {
                fs.SetVolumeLabel(label);
            }

            fs.Flush();
            return(fs);
        }