Attachment #18875 for bug #35928

View | Details | Raw Unified | Return to bug 35928
Collapse All | Expand All





                    writer.processPOIFSWriterEvent(
                        new POIFSWriterEvent(dstream, path, name, size));
                    dstream.writeFiller(countBlocks() *
                                            POIFSFileSystem
                                            .getBigBlockSize(), DocumentBlock
                                            .getFillByte());
                }
                else

            {
                if (writer != null)
                {
                    rval = (size + POIFSFileSystem.getBigBlockSize() - 1)
                           / POIFSFileSystem.getBigBlockSize();
                }
                else
                {

Lines 55-60 Link Here

(-)src/java/org/apache/poi/poifs/filesystem/POIFSFileSystem.java (-2 / +24 lines)
55	private List _documents;	55	private List _documents;
56	private DirectoryNode _root;	56	private DirectoryNode _root;
57		57
		58	private static int bigBlockSize = POIFSConstants.BIG_BLOCK_SIZE;
		59
		60
58	/**	61	/**
59	* Constructor, intended for writing	62	* Constructor, intended for writing
60	*/	63	*/
Lines 79-89 Link Here
79	{	82	{
80	this();	83	this();
81		84
		85	// check the big block size in the file
		86	PushbackInputStream pbis = new PushbackInputStream(stream, 64);
		87	byte[] b = new byte[31];
		88	pbis.read(b);
		89
		90	if (b[30] == 12) bigBlockSize = POIFSConstants.ALT_BIG_BLOCK_SIZE;
		91
		92	pbis.unread(b);
		93
		94
82	// read the header block from the stream	95	// read the header block from the stream
83	HeaderBlockReader header_block_reader = new HeaderBlockReader(stream);	96	HeaderBlockReader header_block_reader = new HeaderBlockReader(pbis);
84		97
85	// read the rest of the stream into blocks	98	// read the rest of the stream into blocks
86	RawDataBlockList data_blocks = new RawDataBlockList(stream);	99	RawDataBlockList data_blocks = new RawDataBlockList(pbis);
87		100
88	// set up the block allocation table (necessary for the	101	// set up the block allocation table (necessary for the
89	// data_blocks to be manageable	102	// data_blocks to be manageable
Lines 290-295 Link Here
290	}	303	}
291		304
292	/**	305	/**
		306	* get the size of a big block
		307	*
		308	* @return size of a big block
		309	*/
		310	public static int getBigBlockSize() {
		311	return bigBlockSize;
		312	}
		313
		314	/**
293	* get the root entry	315	* get the root entry
294	*	316	*
295	* @return the root entry	317	* @return the root entry

Lines 23-28 Link Here

(-)src/java/org/apache/poi/poifs/storage/PropertyBlock.java (-1 / +2 lines)
23	import java.util.*;	23	import java.util.*;
24		24
25	import org.apache.poi.poifs.common.POIFSConstants;	25	import org.apache.poi.poifs.common.POIFSConstants;
		26	import org.apache.poi.poifs.filesystem.POIFSFileSystem;
26	import org.apache.poi.poifs.property.Property;	27	import org.apache.poi.poifs.property.Property;
27	import org.apache.poi.util.IntegerField;	28	import org.apache.poi.util.IntegerField;
28	import org.apache.poi.util.LittleEndian;	29	import org.apache.poi.util.LittleEndian;
Lines 38-44 Link Here
38	extends BigBlock	39	extends BigBlock
39	{	40	{
40	private static final int _properties_per_block =	41	private static final int _properties_per_block =
41	POIFSConstants.BIG_BLOCK_SIZE / POIFSConstants.PROPERTY_SIZE;	42	POIFSFileSystem.getBigBlockSize() / POIFSConstants.PROPERTY_SIZE;
42	private Property[] _properties;	43	private Property[] _properties;
43		44
44	/**	45	/**

Lines 19-24 Link Here

(-)src/java/org/apache/poi/poifs/storage/HeaderBlockConstants.java (-1 / +2 lines)
19	package org.apache.poi.poifs.storage;	19	package org.apache.poi.poifs.storage;
20		20
21	import org.apache.poi.poifs.common.POIFSConstants;	21	import org.apache.poi.poifs.common.POIFSConstants;
		22	import org.apache.poi.poifs.filesystem.POIFSFileSystem;
22	import org.apache.poi.util.IntegerField;	23	import org.apache.poi.util.IntegerField;
23	import org.apache.poi.util.LittleEndian;	24	import org.apache.poi.util.LittleEndian;
24	import org.apache.poi.util.LittleEndianConsts;	25	import org.apache.poi.util.LittleEndianConsts;
Lines 36-42 Link Here
36	public static final long _signature = 0xE11AB1A1E011CFD0L;	37	public static final long _signature = 0xE11AB1A1E011CFD0L;
37	public static final int _bat_array_offset = 0x4c;	38	public static final int _bat_array_offset = 0x4c;
38	public static final int _max_bats_in_header =	39	public static final int _max_bats_in_header =
39	(POIFSConstants.BIG_BLOCK_SIZE - _bat_array_offset)	40	(POIFSFileSystem.getBigBlockSize() - _bat_array_offset)
40	/ LittleEndianConsts.INT_SIZE;	41	/ LittleEndianConsts.INT_SIZE;
41		42
42	// useful offsets	43	// useful offsets

Lines 23-28 Link Here

(-)src/java/org/apache/poi/poifs/storage/HeaderBlockWriter.java (-1 / +2 lines)
23	import java.util.*;	23	import java.util.*;
24		24
25	import org.apache.poi.poifs.common.POIFSConstants;	25	import org.apache.poi.poifs.common.POIFSConstants;
		26	import org.apache.poi.poifs.filesystem.POIFSFileSystem;
26	import org.apache.poi.util.IntegerField;	27	import org.apache.poi.util.IntegerField;
27	import org.apache.poi.util.LittleEndianConsts;	28	import org.apache.poi.util.LittleEndianConsts;
28	import org.apache.poi.util.LongField;	29	import org.apache.poi.util.LongField;
Lines 65-71 Link Here
65		66
66	public HeaderBlockWriter()	67	public HeaderBlockWriter()
67	{	68	{
68	_data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];	69	_data = new byte[ POIFSFileSystem.getBigBlockSize() ];
69	Arrays.fill(_data, _default_value);	70	Arrays.fill(_data, _default_value);
70	new LongField(_signature_offset, _signature, _data);	71	new LongField(_signature_offset, _signature, _data);
71	new IntegerField(0x08, 0, _data);	72	new IntegerField(0x08, 0, _data);




import java.util.Arrays;

import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IntegerField;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.LittleEndianConsts;

    extends BigBlock
{
    private static final int  _entries_per_block      =
        POIFSFileSystem.getBigBlockSize() / LittleEndianConsts.INT_SIZE;
    private static final int  _entries_per_xbat_block = _entries_per_block
                                                            - 1;
    private static final int  _xbat_chain_offset      =


    private BATBlock()
    {
        _data = new byte[ POIFSFileSystem.getBigBlockSize() ];
        Arrays.fill(_data, _default_value);
        _fields = new IntegerField[ _entries_per_block ];
        int offset = 0;




import java.util.*;

import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

/**
 * Storage for documents that are too small to use regular

    private static final byte _default_fill         = ( byte ) 0xff;
    private static final int  _block_size           = 64;
    private static final int  _blocks_per_big_block =
        POIFSFileSystem.getBigBlockSize() / _block_size;

    private SmallDocumentBlock(final byte [] data, final int index)
    {

        {
            int buffer_offset = 0;

            try {
                 System.arraycopy(
                        (( SmallDocumentBlock ) blocks[ firstBlockIndex ])._data,
                        firstBlockOffset, buffer, buffer_offset,
                        _block_size - firstBlockOffset);
                    buffer_offset += _block_size - firstBlockOffset;
                    for (int j = firstBlockIndex + 1; j < lastBlockIndex; j++)
                    {
                        System.arraycopy(((SmallDocumentBlock) blocks[ j ])._data,
                                       0, buffer, buffer_offset, _block_size);
                        buffer_offset += _block_size;
                    }
                    System.arraycopy(
                        ((SmallDocumentBlock) blocks[ lastBlockIndex ])._data, 0,
                        buffer, buffer_offset, buffer.length - buffer_offset);
                    }
            catch (ArrayIndexOutOfBoundsException ignore) {
            }
            System.arraycopy(
                (( SmallDocumentBlock ) blocks[ lastBlockIndex ])._data, 0,
                buffer, buffer_offset, buffer.length - buffer_offset);
        }
    }





import java.util.*;

import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.IntegerField;
import org.apache.poi.util.LittleEndian;

    public HeaderBlockReader(final InputStream stream)
        throws IOException
    {
        _data = new byte[ POIFSFileSystem.getBigBlockSize() ];
        int byte_count = IOUtils.readFully(stream, _data);

        if (byte_count != POIFSFileSystem.getBigBlockSize())
        {
        	if (byte_count == -1)
        		//Cant have -1 bytes read in the error message!


            throw new IOException("Unable to read entire header; "
                                  + byte_count + type + " read; expected "
                                  + POIFSFileSystem.getBigBlockSize() + 
                                  " bytes");
        }

        // verify signature




import java.util.Arrays;

import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.IntegerField;
import org.apache.poi.util.LittleEndian;


    private DocumentBlock()
    {
        _data = new byte[ POIFSFileSystem.getBigBlockSize() ];
        Arrays.fill(_data, _default_value);
    }



    public boolean partiallyRead()
    {
        return _bytes_read != POIFSFileSystem.getBigBlockSize();
    }

    /**

                                           final int size)
    {
        DocumentBlock[] rval   =
            new DocumentBlock[ (size + POIFSFileSystem.getBigBlockSize() - 1) /
                POIFSFileSystem.getBigBlockSize() ];
        int             offset = 0;

        for (int k = 0; k < rval.length; k++)

            rval[ k ] = new DocumentBlock();
            if (offset < array.length)
            {
                int length = Math.min(POIFSFileSystem.getBigBlockSize(),
                                      array.length - offset);

                System.arraycopy(array, offset, rval[ k ]._data, 0, length);
                if (length != POIFSFileSystem.getBigBlockSize())
                {
                    Arrays.fill(rval[ k ]._data, length,
                                POIFSFileSystem.getBigBlockSize(),
                                _default_value);
                }
            }

            {
                Arrays.fill(rval[ k ]._data, _default_value);
            }
            offset += POIFSFileSystem.getBigBlockSize();
        }
        return rval;
    }

    public static void read(final DocumentBlock [] blocks,
                            final byte [] buffer, final int offset)
    {
        int firstBlockIndex  = offset / POIFSFileSystem.getBigBlockSize();
        int firstBlockOffset = offset % POIFSFileSystem.getBigBlockSize();
        int lastBlockIndex   = (offset + buffer.length - 1)
                               / POIFSFileSystem.getBigBlockSize();

        if (firstBlockIndex == lastBlockIndex)
        {


            System.arraycopy(blocks[ firstBlockIndex ]._data,
                             firstBlockOffset, buffer, buffer_offset,
                             POIFSFileSystem.getBigBlockSize()
                             - firstBlockOffset);
            buffer_offset += POIFSFileSystem.getBigBlockSize() - 
                firstBlockOffset;
            for (int j = firstBlockIndex + 1; j < lastBlockIndex; j++)
            {
                System.arraycopy(blocks[ j ]._data, 0, buffer, buffer_offset,
                                 POIFSFileSystem.getBigBlockSize());
                buffer_offset += POIFSFileSystem.getBigBlockSize();
            }
            System.arraycopy(blocks[ lastBlockIndex ]._data, 0, buffer,
                             buffer_offset, buffer.length - buffer_offset);

Lines 186-193 Link Here

(-)src/java/org/apache/poi/poifs/storage/BlockAllocationTableReader.java (-2 / +7 lines)
186		186
187	while (currentBlock != POIFSConstants.END_OF_CHAIN)	187	while (currentBlock != POIFSConstants.END_OF_CHAIN)
188	{	188	{
189	blocks.add(blockList.remove(currentBlock));	189	try {
190	currentBlock = _entries.get(currentBlock);	190	blocks.add(blockList.remove(currentBlock));
		191	currentBlock = _entries.get(currentBlock);
		192	}
		193	catch (IOException io) {
		194	currentBlock = POIFSConstants.END_OF_CHAIN;
		195	}
191	}	196	}
192	return ( ListManagedBlock [] ) blocks	197	return ( ListManagedBlock [] ) blocks
193	.toArray(new ListManagedBlock[ 0 ]);	198	.toArray(new ListManagedBlock[ 0 ]);




package org.apache.poi.poifs.storage;

import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.IOUtils;

import java.io.*;

    public RawDataBlock(final InputStream stream)
        throws IOException
    {
        _data = new byte[ POIFSFileSystem.getBigBlockSize() ];
        int count = IOUtils.readFully(stream, _data);

        if (count == -1)
        {
            _eof = true;
        }
        else if (count != POIFSFileSystem.getBigBlockSize())
        {
        	if (count == -1)
        		//Cant have -1 bytes read in the error message!


            throw new IOException("Unable to read entire block; " + count
                                  + type + " read; expected "
                                  + POIFSFileSystem.getBigBlockSize() + 
                                  " bytes");
        }
        else
        {

Lines 27-32 Link Here

(-)src/java/org/apache/poi/poifs/common/POIFSConstants.java (+1 lines)
27	public interface POIFSConstants	27	public interface POIFSConstants
28	{	28	{
29	public static final int BIG_BLOCK_SIZE = 0x0200;	29	public static final int BIG_BLOCK_SIZE = 0x0200;
		30	public static final int ALT_BIG_BLOCK_SIZE = 0x1000;
30	public static final int END_OF_CHAIN = -2;	31	public static final int END_OF_CHAIN = -2;
31	public static final int PROPERTY_SIZE = 0x0080;	32	public static final int PROPERTY_SIZE = 0x0080;
32	public static final int UNUSED_BLOCK = -1;	33	public static final int UNUSED_BLOCK = -1;

Return to bug 35928

Lines 590-598 Link Here

(-)src/java/org/apache/poi/poifs/filesystem/POIFSDocument.java (-5 / +5 lines)
590		590
591	writer.processPOIFSWriterEvent(	591	writer.processPOIFSWriterEvent(
592	new POIFSWriterEvent(dstream, path, name, size));	592	new POIFSWriterEvent(dstream, path, name, size));
593	dstream.writeFiller(countBlocks()	593	dstream.writeFiller(countBlocks() *
594	* POIFSConstants	594	POIFSFileSystem
595	.BIG_BLOCK_SIZE, DocumentBlock	595	.getBigBlockSize(), DocumentBlock
596	.getFillByte());	596	.getFillByte());
597	}	597	}
598	else	598	else
Lines 617-624 Link Here
617	{	617	{
618	if (writer != null)	618	if (writer != null)
619	{	619	{
620	rval = (size + POIFSConstants.BIG_BLOCK_SIZE - 1)	620	rval = (size + POIFSFileSystem.getBigBlockSize() - 1)
621	/ POIFSConstants.BIG_BLOCK_SIZE;	621	/ POIFSFileSystem.getBigBlockSize();
622	}	622	}
623	else	623	else
624	{	624	{

Lines 24-29 Link Here

(-)src/java/org/apache/poi/poifs/storage/BATBlock.java (-2 / +3 lines)
24	import java.util.Arrays;	24	import java.util.Arrays;
25		25
26	import org.apache.poi.poifs.common.POIFSConstants;	26	import org.apache.poi.poifs.common.POIFSConstants;
		27	import org.apache.poi.poifs.filesystem.POIFSFileSystem;
27	import org.apache.poi.util.IntegerField;	28	import org.apache.poi.util.IntegerField;
28	import org.apache.poi.util.LittleEndian;	29	import org.apache.poi.util.LittleEndian;
29	import org.apache.poi.util.LittleEndianConsts;	30	import org.apache.poi.util.LittleEndianConsts;
Lines 39-45 Link Here
39	extends BigBlock	40	extends BigBlock
40	{	41	{
41	private static final int _entries_per_block =	42	private static final int _entries_per_block =
42	POIFSConstants.BIG_BLOCK_SIZE / LittleEndianConsts.INT_SIZE;	43	POIFSFileSystem.getBigBlockSize() / LittleEndianConsts.INT_SIZE;
43	private static final int _entries_per_xbat_block = _entries_per_block	44	private static final int _entries_per_xbat_block = _entries_per_block
44	- 1;	45	- 1;
45	private static final int _xbat_chain_offset =	46	private static final int _xbat_chain_offset =
Lines 54-60 Link Here
54		55
55	private BATBlock()	56	private BATBlock()
56	{	57	{
57	_data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];	58	_data = new byte[ POIFSFileSystem.getBigBlockSize() ];
58	Arrays.fill(_data, _default_value);	59	Arrays.fill(_data, _default_value);
59	_fields = new IntegerField[ _entries_per_block ];	60	_fields = new IntegerField[ _entries_per_block ];
60	int offset = 0;	61	int offset = 0;