Example #1
0
        /// <summary>
        /// Create an array of XBATBlocks from an array of int block
        /// allocation table entries
        /// </summary>
        /// <param name="bigBlockSize"></param>
        /// <param name="entries">the array of int entries</param>
        /// <param name="startBlock">the start block of the array of XBAT blocks</param>
        /// <returns>the newly created array of BATBlocks</returns>
        public static BATBlock[] CreateXBATBlocks(POIFSBigBlockSize bigBlockSize, int[] entries,
                                                  int startBlock)
        {
            int block_count =
                CalculateXBATStorageRequirements(entries.Length);

            BATBlock[] blocks    = new BATBlock[block_count];
            int        index     = 0;
            int        remaining = entries.Length;

            if (block_count != 0)
            {
                for (int j = 0; j < entries.Length; j += _entries_per_xbat_block)
                {
                    blocks[index++] =
                        new BATBlock(bigBlockSize, entries, j,
                                     (remaining > _entries_per_xbat_block)
                                     ? j + _entries_per_xbat_block
                                     : entries.Length);
                    remaining -= _entries_per_xbat_block;
                }
                for (index = 0; index < blocks.Length - 1; index++)
                {
                    blocks[index].SetXBATChain(bigBlockSize, startBlock + index + 1);
                }
                blocks[index].SetXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
            }
            return(blocks);
        }
Example #2
0
        /// <summary>
        /// Create the BATBlocks we need
        /// </summary>
        /// <returns>start block index of BAT blocks</returns>
        public int CreateBlocks()
        {
            int xbat_blocks = 0;
            int bat_blocks  = 0;

            while (true)
            {
                int calculated_bat_blocks =
                    BATBlock.CalculateStorageRequirements(_bigBlockSize,
                                                          bat_blocks
                                                          + xbat_blocks
                                                          + _entries.Count);
                int calculated_xbat_blocks =
                    HeaderBlockWriter.CalculateXBATStorageRequirements(_bigBlockSize, calculated_bat_blocks);

                if ((bat_blocks == calculated_bat_blocks) &&
                    (xbat_blocks == calculated_xbat_blocks))
                {
                    // stable ... we're OK
                    break;
                }
                else
                {
                    bat_blocks  = calculated_bat_blocks;
                    xbat_blocks = calculated_xbat_blocks;
                }
            }
            int startBlock = AllocateSpace(bat_blocks);

            AllocateSpace(xbat_blocks);
            SimpleCreateBlocks();
            return(startBlock);
        }
Example #3
0
        ///**
        // * Creates a single BATBlock, with all the values set to empty.
        // */
        public static BATBlock CreateEmptyBATBlock(POIFSBigBlockSize bigBlockSize, bool isXBAT)
        {
            BATBlock block = new BATBlock(bigBlockSize);

            if (isXBAT)
            {
                block.SetXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
            }
            return(block);
        }
Example #4
0
        /**
         * Create a single BATBlock from the byte buffer, which must hold at least
         *  one big block of data to be read.
         */
        public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, BinaryReader data)
        {
            // Create an empty block
            BATBlock block = new BATBlock(bigBlockSize);

            // Fill it
            byte[] buffer = new byte[LittleEndianConsts.INT_SIZE];
            for (int i = 0; i < block._values.Length; i++)
            {
                data.Read(buffer, 0, buffer.Length);
                block._values[i] = LittleEndian.GetInt(buffer);
            }
            block.RecomputeFree();

            // All done
            return(block);
        }
Example #5
0
        /// <summary>
        /// Create an array of BATBlocks from an array of int block
        /// allocation table entries
        /// </summary>
        /// <param name="bigBlockSize">the poifs bigBlockSize</param>
        /// <param name="entries">the array of int entries</param>
        /// <returns>the newly created array of BATBlocks</returns>
        public static BATBlock[] CreateBATBlocks(POIFSBigBlockSize bigBlockSize, int[] entries)
        {
            int block_count = CalculateStorageRequirements(entries.Length);

            BATBlock[] blocks    = new BATBlock[block_count];
            int        index     = 0;
            int        remaining = entries.Length;

            for (int j = 0; j < entries.Length; j += _entries_per_block)
            {
                blocks[index++] = new BATBlock(bigBlockSize, entries, j,
                                               (remaining > _entries_per_block)
                                                 ? j + _entries_per_block
                                                 : entries.Length);
                remaining -= _entries_per_block;
            }
            return(blocks);
        }
Example #6
0
        /// <summary>
        /// Set BAT block parameters. Assumes that all BAT blocks are
        /// contiguous. Will construct XBAT blocks if necessary and return
        /// the array of newly constructed XBAT blocks.
        /// </summary>
        /// <param name="blockCount">count of BAT blocks</param>
        /// <param name="startBlock">index of first BAT block</param>
        /// <returns>array of XBAT blocks; may be zero Length, will not be
        /// null</returns>
        public BATBlock[] SetBATBlocks(int blockCount, int startBlock)
        {
            BATBlock[] rvalue;

            POIFSBigBlockSize bigBlockSize = _header_block.BigBlockSize;

            _header_block.BATCount = blockCount;

            int limit = Math.Min(blockCount, _max_bats_in_header);

            int[] bat_blocks = new int[limit];
            for (int j = 0; j < limit; j++)
            {
                bat_blocks[j] = startBlock + j;
            }

            _header_block.BATArray = bat_blocks;

            if (blockCount > _max_bats_in_header)
            {
                int   excess_blocks      = blockCount - _max_bats_in_header;
                int[] excess_block_array = new int[excess_blocks];

                for (int j = 0; j < excess_blocks; j++)
                {
                    excess_block_array[j] = startBlock + j + _max_bats_in_header;
                }

                rvalue = BATBlock.CreateXBATBlocks(bigBlockSize, excess_block_array,
                                                   startBlock + blockCount);

                _header_block.XBATStart = startBlock + blockCount;
            }
            else
            {
                rvalue = BATBlock.CreateXBATBlocks(bigBlockSize, new int[0], 0);
                _header_block.XBATStart = POIFSConstants.END_OF_CHAIN;
            }

            _header_block.XBATCount = rvalue.Length;
            return(rvalue);
        }
Example #7
0
        //public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, byte[] data)
        public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, ByteBuffer data)
        {
            // Create an empty block
            BATBlock block = new BATBlock(bigBlockSize);

            // Fill it
            byte[] buffer = new byte[LittleEndianConsts.INT_SIZE];
            //int index = 0;
            for (int i = 0; i < block._values.Length; i++)
            {
                //data.Read(buffer, 0, buffer.Length);
                //for (int j = 0; j < buffer.Length; j++, index++)
                //   buffer[j] = data[index];
                data.Read(buffer);
                block._values[i] = LittleEndian.GetInt(buffer);
            }
            block.RecomputeFree();

            // All done
            return(block);
        }
Example #8
0
  public BATBlockAndIndex(int index, BATBlock block)
  {
    this.index = index;
    this.block = block;
 }
Example #9
0
        /// <summary>
        /// Create an array of XBATBlocks from an array of int block
        /// allocation table entries
        /// </summary>
        /// <param name="bigBlockSize"></param>
        /// <param name="entries">the array of int entries</param>
        /// <param name="startBlock">the start block of the array of XBAT blocks</param>
        /// <returns>the newly created array of BATBlocks</returns>
        public static BATBlock[] CreateXBATBlocks(POIFSBigBlockSize bigBlockSize, int[] entries,
                                                   int startBlock)
        {
            int block_count =
                CalculateXBATStorageRequirements(entries.Length);
            BATBlock[] blocks = new BATBlock[block_count];
            int index = 0;
            int remaining = entries.Length;

            if (block_count != 0)
            {
                for (int j = 0; j < entries.Length; j += _entries_per_xbat_block)
                {
                    blocks[index++] =
                        new BATBlock(bigBlockSize, entries, j,
                                     (remaining > _entries_per_xbat_block)
                                     ? j + _entries_per_xbat_block
                                     : entries.Length);
                    remaining -= _entries_per_xbat_block;
                }
                for (index = 0; index < blocks.Length - 1; index++)
                {
                    blocks[index].SetXBATChain(bigBlockSize, startBlock + index + 1);
                }
                blocks[index].SetXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
            }
            return blocks;
        }
Example #10
0
        /// <summary>
        /// Create an array of BATBlocks from an array of int block
        /// allocation table entries
        /// </summary>
        /// <param name="bigBlockSize">the poifs bigBlockSize</param>
        /// <param name="entries">the array of int entries</param>
        /// <returns>the newly created array of BATBlocks</returns>
        public static BATBlock[] CreateBATBlocks(POIFSBigBlockSize bigBlockSize, int[] entries)
        {
            int block_count = CalculateStorageRequirements(entries.Length);
            BATBlock[] blocks = new BATBlock[block_count];
            int index = 0;
            int remaining = entries.Length;

            for (int j = 0; j < entries.Length; j += _entries_per_block)
            {
                blocks[index++] = new BATBlock(bigBlockSize, entries, j,
                                                 (remaining > _entries_per_block)
                                                 ? j + _entries_per_block
                                                 : entries.Length);
                remaining -= _entries_per_block;
            }
            return blocks;
        }
Example #11
0
        private void verifyXBATContents(BATBlock[] blocks, int entries,
                                        int start_block)
        {
            byte[] expected = new byte[512 * blocks.Length];
            for (int i = 0; i < expected.Length; i++)
            {
                expected[i] = (byte)0xFF;
            }
            int offset = 0;

            for (int j = 0; j < entries; j++)
            {
                if ((j % 127) == 0)
                {
                    if (j != 0)
                    {
                        offset += 4;
                    }
                }
                expected[offset++] = (byte)j;
                expected[offset++] = 0;
                expected[offset++] = 0;
                expected[offset++] = 0;
            }
            for (int j = 0; j < (blocks.Length - 1); j++)
            {
                offset = 508 + (j * 512);
                expected[offset++] = (byte)(start_block + j + 1);
                expected[offset++] = 0;
                expected[offset++] = 0;
                expected[offset++] = 0;
            }
            offset = (blocks.Length * 512) - 4;
            expected[offset++] = unchecked((byte)-2);
            expected[offset++] = unchecked((byte)-1);
            expected[offset++] = unchecked((byte)-1);
            expected[offset++] = unchecked((byte)-1);
            MemoryStream stream = new MemoryStream(512
                                               * blocks.Length);

            for (int j = 0; j < blocks.Length; j++)
            {
                blocks[j].WriteBlocks(stream);
            }
            byte[] actual = stream.ToArray();

            Assert.AreEqual(expected.Length, actual.Length);
            for (int j = 0; j < expected.Length; j++)
            {
                Assert.AreEqual(expected[j], actual[j], "offset " + j);
            }
        }
Example #12
0
        /**
         * Create a single BATBlock from the byte buffer, which must hold at least
         *  one big block of data to be read.
         */
        public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, BinaryReader data)
        {
            // Create an empty block
            BATBlock block = new BATBlock(bigBlockSize);

            // Fill it
            byte[] buffer = new byte[LittleEndianConsts.INT_SIZE];
            for (int i = 0; i < block._values.Length; i++)
            {
                data.Read(buffer,0,buffer.Length);
                block._values[i] = LittleEndian.GetInt(buffer);
            }
            block.RecomputeFree();

            // All done
            return block;
        }
Example #13
0
 //public static void WriteBlock(BATBlock bat, byte[] block)
 public static void WriteBlock(BATBlock bat, ByteBuffer block)
 {
     bat.WriteData(block);
 }
Example #14
0
 /// <summary>
 /// create the BATBlocks
 /// </summary>
 internal void SimpleCreateBlocks()
 {
     _blocks = BATBlock.CreateBATBlocks(_bigBlockSize, _entries.ToArray());
 }
Example #15
0
 /// <summary>
 /// For a given number of BAT blocks, calculate how many XBAT
 /// blocks will be needed
 /// </summary>
 /// <param name="bigBlockSize"></param>
 /// <param name="blockCount">number of BAT blocks</param>
 /// <returns>number of XBAT blocks needed</returns>
 public static int CalculateXBATStorageRequirements(POIFSBigBlockSize bigBlockSize, int blockCount)
 {
     return((blockCount > _max_bats_in_header)
         ? BATBlock.CalculateXBATStorageRequirements(bigBlockSize, blockCount - _max_bats_in_header) : 0);
 }
Example #16
0
        private void VerifyContents(BATBlock[] blocks, int entries)
        {
            byte[] expected = new byte[512 * blocks.Length];
            for (int i = 0; i < expected.Length; i++)
            {
                expected[i] = (byte)0xFF;
            }
            int offset = 0;

            for (int j = 0; j < entries; j++)
            {
                expected[offset++] = (byte)j;
                expected[offset++] = 0;
                expected[offset++] = 0;
                expected[offset++] = 0;
            }
            MemoryStream stream = new MemoryStream(512
                                               * blocks.Length);

            for (int j = 0; j < blocks.Length; j++)
            {
                blocks[j].WriteBlocks(stream);
            }
            byte[] actual = stream.ToArray();

            Assert.AreEqual(expected.Length, actual.Length);
            for (int j = 0; j < expected.Length; j++)
            {
                Assert.AreEqual(expected[j], actual[j]);
            }
        }
Example #17
0
        //public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, byte[] data)
        public static BATBlock CreateBATBlock(POIFSBigBlockSize bigBlockSize, ByteBuffer data)
        {
            // Create an empty block
            BATBlock block = new BATBlock(bigBlockSize);

            // Fill it
            byte[] buffer = new byte[LittleEndianConsts.INT_SIZE];
            //int index = 0;
            for (int i = 0; i < block._values.Length; i++)
            {
                //data.Read(buffer, 0, buffer.Length);
                //for (int j = 0; j < buffer.Length; j++, index++)
                 //   buffer[j] = data[index];
                data.Read(buffer);
                block._values[i] = LittleEndian.GetInt(buffer);
            }
            block.RecomputeFree();

            // All done
            return block;
        }
Example #18
0
 ///**
 // * Creates a single BATBlock, with all the values set to empty.
 // */
 public static BATBlock CreateEmptyBATBlock(POIFSBigBlockSize bigBlockSize, bool isXBAT)
 {
     BATBlock block = new BATBlock(bigBlockSize);
     if (isXBAT)
     {
         block.SetXBATChain(bigBlockSize, POIFSConstants.END_OF_CHAIN);
     }
     return block;
 }
Example #19
0
 public BATBlockAndIndex(int index, BATBlock block)
 {
     this.index = index;
     this.block = block;
 }
 //public static void WriteBlock(BATBlock bat, byte[] block)
 public static void WriteBlock(BATBlock bat, ByteBuffer block)
 {
     bat.WriteData(block);
 }