/* ==================================================================== Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for Additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ==================================================================== */ /* ================================================================ * About NPOI * Author: Tony Qu * Author's email: tonyqus (at) gmail.com * Author's Blog: tonyqus.wordpress.com.cn (wp.tonyqus.cn) * HomePage: http://www.codeplex.com/npoi * Contributors: * * ==============================================================*/ using System; using System.Collections.Generic; using System.IO; using HH.WMS.Utils.NPOI.Util; using HH.WMS.Utils.NPOI.POIFS.Common; namespace HH.WMS.Utils.NPOI.POIFS.Storage { /// /// This class manages and creates the Block Allocation Table, which is /// basically a set of linked lists of block indices. /// Each block of the filesystem has an index. The first block, the /// header, is skipped; the first block after the header is index 0, /// the next is index 1, and so on. /// A block's index is also its index into the Block Allocation /// Table. The entry that it finds in the Block Allocation Table is the /// index of the next block in the linked list of blocks making up a /// file, or it is set to -2: end of list. /// /// @author Marc Johnson (mjohnson at apache dot org) /// public class BlockAllocationTableReader { private static POILogger _logger = POILogFactory.GetLogger(typeof(BlockAllocationTableReader)); private static int MAX_BLOCK_COUNT = 65535; private List _entries; private POIFSBigBlockSize bigBlockSize; /// /// create a BlockAllocationTableReader for an existing filesystem. Side /// effect: when this method finishes, the BAT blocks will have /// been Removed from the raw block list, and any blocks labeled as /// 'unused' in the block allocation table will also have been /// Removed from the raw block list. /// the number of BAT blocks making up the block allocation table /// the array of BAT block indices from the /// filesystem's header /// the number of XBAT blocks /// the index of the first XBAT block /// the list of RawDataBlocks public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSizse, int block_count, int[] block_array, int xbat_count, int xbat_index, BlockList raw_block_list) : this(bigBlockSizse) { SanityCheckBlockCount(block_count); RawDataBlock[] blocks = new RawDataBlock[block_count]; int limit = Math.Min(block_count, block_array.Length); int block_index; for (block_index = 0; block_index < limit; block_index++) { int nextOffset = block_array[block_index]; if (nextOffset > raw_block_list.BlockCount()) { throw new IOException("Your file contains " + raw_block_list.BlockCount() + " sectors, but the initial DIFAT array at index " + block_index + " referenced block # " + nextOffset + ". This isn't allowed and " + " your file is corrupt"); } blocks[block_index] = (RawDataBlock)raw_block_list.Remove(nextOffset); } if (block_index < block_count) { // must have extended blocks if (xbat_index < 0) { throw new IOException( "BAT count exceeds limit, yet XBAT index indicates no valid entries"); } int chain_index = xbat_index; int max_entries_per_block = BATBlock.EntriesPerXBATBlock; int chain_index_offset = BATBlock.XBATChainOffset; // Each XBAT block contains either: // (maximum number of sector indexes) + index of next XBAT // some sector indexes + FREE sectors to max # + EndOfChain for (int j = 0; j < xbat_count; j++) { limit = Math.Min(block_count - block_index, max_entries_per_block); byte[] data = raw_block_list.Remove(chain_index).Data; int offset = 0; for (int k = 0; k < limit; k++) { blocks[block_index++] = (RawDataBlock)raw_block_list.Remove(LittleEndian.GetInt(data, offset)); offset += LittleEndianConsts.INT_SIZE; } chain_index = LittleEndian.GetInt(data, chain_index_offset); if (chain_index == POIFSConstants.END_OF_CHAIN) { break; } } } if (block_index != block_count) { throw new IOException("Could not find all blocks"); } // now that we have all of the raw data blocks, go through and // create the indices SetEntries((ListManagedBlock[])blocks, raw_block_list); } /// /// create a BlockAllocationTableReader from an array of raw data blocks /// /// the raw data /// the list holding the managed blocks public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize, ListManagedBlock[] blocks, BlockList raw_block_list) : this(bigBlockSize) { SetEntries(blocks, raw_block_list); } /// /// Initializes a new instance of the class. /// public BlockAllocationTableReader(POIFSBigBlockSize bigBlockSize) { this.bigBlockSize = bigBlockSize; _entries = new List(); } /// /// walk the entries from a specified point and return the /// associated blocks. The associated blocks are Removed from the block list /// /// the first block in the chain /// /// the raw data block list /// array of ListManagedBlocks, in their correct order public ListManagedBlock[] FetchBlocks(int startBlock, int headerPropertiesStartBlock, BlockList blockList) { List blocks = new List(); int currentBlock = startBlock; bool firstPass = true; ListManagedBlock dataBlock = null; while (currentBlock != POIFSConstants.END_OF_CHAIN) { try { dataBlock = blockList.Remove(currentBlock); blocks.Add(dataBlock); currentBlock = _entries[currentBlock]; firstPass = false; } catch(Exception) { if (currentBlock == headerPropertiesStartBlock) { // Special case where things are in the wrong order _logger.Log(POILogger.WARN, "Warning, header block comes after data blocks in POIFS block listing"); currentBlock = POIFSConstants.END_OF_CHAIN; } else if (currentBlock == 0 && firstPass) { // Special case where the termination isn't done right // on an empty set _logger.Log(POILogger.WARN, "Warning, incorrectly terminated empty data blocks in POIFS block listing (should end at -2, ended at 0)"); currentBlock = POIFSConstants.END_OF_CHAIN; } else { // Ripple up throw; } } } ListManagedBlock[] array = blocks.ToArray(); return (array); } /// /// determine whether the block specified by index is used or not /// /// determine whether the block specified by index is used or not /// /// true if the specified block is used; otherwise, false. /// public bool IsUsed(int index) { bool rval = false; try { rval = _entries[index] != -1; } catch (IndexOutOfRangeException) { } return rval; } /// /// return the next block index /// /// The index of the current block /// index of the next block (may be /// POIFSConstants.END_OF_CHAIN, indicating end of chain /// (duh)) public int GetNextBlockIndex(int index) { if (IsUsed(index)) { return _entries[index]; } else { throw new IOException("index " + index + " is unused"); } } /// /// Convert an array of blocks into a Set of integer indices /// /// the array of blocks containing the indices /// the list of blocks being managed. Unused /// blocks will be eliminated from the list private void SetEntries(ListManagedBlock[] blocks, BlockList raw_blocks) { int limit = bigBlockSize.GetBATEntriesPerBlock(); for (int block_index = 0; block_index < blocks.Length; block_index++) { byte[] data = blocks[block_index].Data; int offset = 0; for (int k = 0; k < limit; k++) { int entry = LittleEndian.GetInt(data, offset); if (entry == POIFSConstants.UNUSED_BLOCK) { raw_blocks.Zap(_entries.Count); } _entries.Add(entry); offset += LittleEndianConsts.INT_SIZE; } // discard block blocks[block_index] = null; } raw_blocks.BAT = this; } public static void SanityCheckBlockCount(int block_count) { if (block_count <= 0) { throw new IOException("Illegal block count; minimum count is 1, got " + block_count + " instead"); } if (block_count > MAX_BLOCK_COUNT) { throw new IOException( "Block count " + block_count + " is too high. POI maximum is " + MAX_BLOCK_COUNT + "."); } } } }