{
DocumentDescriptor d;
final DocumentInputStream is = event.getStream();
- if (!is.markSupported())
+ if (!is.markSupported()) {
throw new UnsupportedOperationException(is.getClass().getName() +
" does not support mark().");
+ }
/* Try do handle this document as a property set. We receive
* an exception if is no property set and handle it as a
}
catch (Exception t)
{
- System.err.println
- ("Unexpected exception while processing " +
- event.getName() + " in " + event.getPath().toString());
- t.printStackTrace(System.err);
- throw new RuntimeException(t.getMessage());
+ throw new RuntimeException("Unexpected exception while processing " + event.getName() + " in " + event.getPath(), t);
}
is.close();
final MutableTreeNode root)
{
MutableTreeNode n = pathToNode.get(path);
- if (n != null)
+ if (n != null) {
/* Node found in map, just return it. */
return n;
+ }
if (path.length() == 0)
{
/* This is the root path of the POI filesystem. Its tree
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.LittleEndianConsts;
+import org.apache.poi.util.NotImplemented;
/**
* Represents a property set in the Horrible Property Set Format
*/
int o = offset;
final int byteOrder = LittleEndian.getUShort(src, o);
- o += LittleEndian.SHORT_SIZE;
+ o += LittleEndianConsts.SHORT_SIZE;
if (byteOrder != BYTE_ORDER_ASSERTION) {
return false;
}
final int format = LittleEndian.getUShort(src, o);
- o += LittleEndian.SHORT_SIZE;
+ o += LittleEndianConsts.SHORT_SIZE;
if (format != FORMAT_ASSERTION) {
return false;
}
// final long osVersion = LittleEndian.getUInt(src, offset);
- o += LittleEndian.INT_SIZE;
+ o += LittleEndianConsts.INT_SIZE;
// final ClassID classID = new ClassID(src, offset);
o += ClassID.LENGTH;
final long sectionCount = LittleEndian.getUInt(src, o);
*/
int o = offset;
byteOrder = LittleEndian.getUShort(src, o);
- o += LittleEndian.SHORT_SIZE;
+ o += LittleEndianConsts.SHORT_SIZE;
format = LittleEndian.getUShort(src, o);
- o += LittleEndian.SHORT_SIZE;
+ o += LittleEndianConsts.SHORT_SIZE;
osVersion = (int) LittleEndian.getUInt(src, o);
- o += LittleEndian.INT_SIZE;
+ o += LittleEndianConsts.INT_SIZE;
classID = new ClassID(src, o);
o += ClassID.LENGTH;
final int sectionCount = LittleEndian.getInt(src, o);
- o += LittleEndian.INT_SIZE;
+ o += LittleEndianConsts.INT_SIZE;
if (sectionCount < 0) {
throw new HPSFRuntimeException("Section count " + sectionCount + " is negative.");
}
*/
for (int i = 0; i < sectionCount; i++) {
final Section s = new MutableSection(src, o);
- o += ClassID.LENGTH + LittleEndian.INT_SIZE;
+ o += ClassID.LENGTH + LittleEndianConsts.INT_SIZE;
sections.add(s);
}
}
/**
* @see Object#hashCode()
*/
+ @NotImplemented
+ @Override
public int hashCode() {
throw new UnsupportedOperationException("FIXME: Not yet implemented.");
}
/**
* @see Object#toString()
*/
+ @Override
public String toString() {
final StringBuilder b = new StringBuilder();
final int sectionCount = getSectionCount();
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
import org.apache.poi.util.StringUtil;
+import org.apache.poi.util.SuppressForbidden;
/**
* Utility for reading in BIFF8 records and displaying data from them.
public void processRecord(int globalOffset, int recordCounter, int sid, int dataSize,
byte[] data) {
String header = formatRecordDetails(globalOffset, sid, dataSize, recordCounter);
- if(!_noHeader) _headers.add(header);
+ if(!_noHeader) {
+ _headers.add(header);
+ }
Writer w = _hexDumpWriter;
if (w != null) {
try {
}
@Override
+ @SuppressForbidden("just delegating the call")
public int available() throws IOException {
return _currentSize - _currentPos + _is.available();
}
public ObjRecord(RecordInputStream in) {
// TODO - problems with OBJ sub-records stream
// MS spec says first sub-record is always CommonObjectDataSubRecord,
- // and last is
- // always EndSubRecord. OOO spec does not mention ObjRecord(0x005D).
+ // and last is always EndSubRecord. OOO spec does not mention ObjRecord(0x005D).
// Existing POI test data seems to violate that rule. Some test data
- // seems to contain
- // garbage, and a crash is only averted by stopping at what looks like
- // the 'EndSubRecord'
+ // seems to contain garbage, and a crash is only averted by stopping at
+ // what looks like the 'EndSubRecord'
// Check if this can be continued, if so then the
// following wont work properly
sb.append("[OBJ]\n");
if(subrecords != null) { // there are special cases where this can be, see comments in constructor above
- for (int i = 0; i < subrecords.size(); i++) {
- SubRecord record = subrecords.get(i);
- sb.append("SUBRECORD: ").append(record.toString());
- }
+ for (final SubRecord record : subrecords) {
+ sb.append("SUBRECORD: ").append(record.toString());
+ }
}
sb.append("[/OBJ]\n");
return sb.toString();
return _uninterpretedData.length + 4;
}
int size = 0;
- for (int i=subrecords.size()-1; i>=0; i--) {
- SubRecord record = subrecords.get(i);
+ for (SubRecord record : subrecords) {
size += record.getDataSize()+4;
}
if (_isPaddedToQuadByteMultiple) {
return sid;
}
+ // FIXME: return Collections.unmodifiableList?
public List<SubRecord> getSubRecords() {
return subrecords;
}
public ObjRecord clone() {
ObjRecord rec = new ObjRecord();
- for (int i = 0; i < subrecords.size(); i++) {
- SubRecord record = subrecords.get(i);
- rec.addSubRecord((SubRecord) record.clone());
+ for (SubRecord record : subrecords) {
+ rec.addSubRecord(record.clone());
}
return rec;
}
}
public abstract void serialize(LittleEndianOutput out);
- public abstract Object clone();
+
+ @Override
+ public abstract SubRecord clone();
/**
- * Wether this record terminates the sub-record stream.
+ * Whether this record terminates the sub-record stream.
* There are two cases when this method must be overridden and return <code>true</code>
* - EndSubRecord (sid = 0x00)
* - LbsDataSubRecord (sid = 0x12)
in.readFully(buf);
_data = buf;
}
+ @Override
protected int getDataSize() {
return _data.length;
}
+ @Override
public void serialize(LittleEndianOutput out) {
out.writeShort(_sid);
out.writeShort(_data.length);
out.write(_data);
}
- public Object clone() {
+ @Override
+ public UnknownSubRecord clone() {
return this;
}
+ @Override
public String toString() {
- StringBuffer sb = new StringBuffer(64);
+ StringBuilder sb = new StringBuilder(64);
sb.append(getClass().getName()).append(" [");
sb.append("sid=").append(HexDump.shortToHex(_sid));
sb.append(" size=").append(_data.length);
@Override
public int read() throws IOException {
- byte[] b = new byte[1];
- if (read(b) == 1) {
- return b[0];
- }
- return -1;
+ byte[] b = { 0 };
+ // FIXME: compare against -1 or 1?
+ return (read(b) == -1) ? -1 : b[0];
}
// do not implement! -> recursion
// the cipher can't be final, because for the last chunk we change the padding
// and therefore need to change the cipher too
private Cipher cipher;
+ private boolean isClosed = false;
public ChunkedCipherOutputStream(DirectoryNode dir, int chunkSize) throws IOException, GeneralSecurityException {
super(null);
@Override
public void close() throws IOException {
+ if (isClosed) {
+ LOG.log(POILogger.DEBUG, "ChunkedCipherOutputStream was already closed - ignoring");
+ return;
+ }
+
+ isClosed = true;
+
try {
writeChunk(false);
import org.apache.poi.poifs.property.DirectoryProperty;
import org.apache.poi.poifs.property.Property;
import org.apache.poi.poifs.property.PropertyTable;
+import org.apache.poi.poifs.property.RootProperty;
import org.apache.poi.poifs.storage.BlockAllocationTableReader;
import org.apache.poi.poifs.storage.BlockList;
import org.apache.poi.poifs.storage.HeaderBlock;
new PropertyTable(header_block, data_blocks);
// process documents
+ RootProperty root = properties.getRoot();
processProperties(SmallBlockTableReader
.getSmallDocumentBlocks(
header_block.getBigBlockSize(),
- data_blocks, properties.getRoot(),
- header_block.getSBATStart()),
- data_blocks, properties.getRoot()
- .getChildren(), new POIFSDocumentPath());
+ data_blocks, root,
+ header_block.getSBATStart()
+ ),
+ data_blocks, root.getChildren(), new POIFSDocumentPath()
+ );
}
/**
import java.io.InputStream;
import org.apache.poi.util.LittleEndianInput;
+import org.apache.poi.util.SuppressForbidden;
/**
* This class provides methods to read a DocumentEntry managed by a
}
@Override
+ @SuppressForbidden("just delegating")
public int available() {
return delegate.available();
}
private int _marked_offset_count;
/** the Document's size */
- private int _document_size;
+ private final int _document_size;
/** have we been closed? */
private boolean _closed;
/** the actual Document */
- private NPOIFSDocument _document;
+ private final NPOIFSDocument _document;
private Iterator<ByteBuffer> _data;
private ByteBuffer _buffer;
@Override
public int available() {
+ return remainingBytes();
+ }
+
+ /**
+ * Helper methods for forbidden api calls
+ *
+ * @return the bytes remaining until the end of the stream
+ */
+ private int remainingBytes() {
if (_closed) {
throw new IllegalStateException("cannot perform requested operation on a closed stream");
}
if (atEOD()) {
return EOF;
}
- int limit = Math.min(available(), len);
+ int limit = Math.min(remainingBytes(), len);
readFully(b, off, limit);
return limit;
}
return LittleEndian.getUShort(data);
}
- @Override
- public int readUByte() {
- checkAvaliable(1);
- byte[] data = new byte[1];
- readFully(data, 0, 1);
- if(data[0] >= 0)
- return data[0];
- return data[0] + 256;
- }
+ @Override
+ public int readUByte() {
+ checkAvaliable(1);
+ byte[] data = new byte[1];
+ readFully(data, 0, 1);
+ if (data[0] >= 0)
+ return data[0];
+ return data[0] + 256;
+ }
}
private int _marked_offset;
/** the Document's size */
- private int _document_size;
+ private final int _document_size;
/** have we been closed? */
private boolean _closed;
/** the actual Document */
- private OPOIFSDocument _document;
+ private final OPOIFSDocument _document;
/** the data block containing the current stream pointer */
private DataInputBlock _currentBlock;
*
* This class does not buffer any input, so the stream read position maintained
* by this class is consistent with that of the inner stream.
- *
- * @author Josh Micich
*/
public class LittleEndianInputStream extends FilterInputStream implements LittleEndianInput {
public LittleEndianInputStream(InputStream is) {
}
@Override
- public int available() {
+ @SuppressForbidden("just delegating")
+ public int available() {
try {
return super.available();
} catch (IOException e) {
}
@Override
- public byte readByte() {
+ public byte readByte() {
return (byte)readUByte();
}
@Override
- public int readUByte() {
+ public int readUByte() {
byte buf[] = new byte[1];
try {
checkEOF(read(buf), 1);
}
@Override
- public double readDouble() {
+ public double readDouble() {
return Double.longBitsToDouble(readLong());
}
@Override
- public int readInt() {
- byte buf[] = new byte[LittleEndianConsts.INT_SIZE];
+ public int readInt() {
+ byte buf[] = new byte[LittleEndianConsts.INT_SIZE];
try {
- checkEOF(read(buf), buf.length);
+ checkEOF(read(buf), buf.length);
} catch (IOException e) {
throw new RuntimeException(e);
}
* @exception RuntimeException
* wraps any IOException thrown from reading the stream.
*/
+ //@Override
public long readUInt() {
long retNum = readInt();
return retNum & 0x00FFFFFFFFL;
}
@Override
- public long readLong() {
+ public long readLong() {
byte buf[] = new byte[LittleEndianConsts.LONG_SIZE];
try {
checkEOF(read(buf), LittleEndianConsts.LONG_SIZE);
}
@Override
- public short readShort() {
+ public short readShort() {
return (short)readUShort();
}
@Override
- public int readUShort() {
+ public int readUShort() {
byte buf[] = new byte[LittleEndianConsts.SHORT_SIZE];
try {
checkEOF(read(buf), LittleEndianConsts.SHORT_SIZE);
}
}
- @Override
+ @Override
public void readFully(byte[] buf) {
- readFully(buf, 0, buf.length);
- }
+ readFully(buf, 0, buf.length);
+ }
- @Override
+ @Override
public void readFully(byte[] buf, int off, int len) {
- try {
- checkEOF(read(buf, off, len), len);
- } catch (IOException e) {
+ try {
+ checkEOF(read(buf, off, len), len);
+ } catch (IOException e) {
throw new RuntimeException(e);
}
- }
+ }
@Override
public void readPlain(byte[] buf, int off, int len) {
import org.apache.poi.poifs.storage.HeaderBlockConstants;
import org.apache.poi.util.IOUtils;
import org.apache.poi.util.LittleEndian;
+import org.apache.poi.util.Removal;
public final class ZipHelper {
/**
* Buffer to read data from file. Use big buffer to improve performaces. the
* InputStream class is reading only 8192 bytes per read call (default value
* set by sun)
+ *
+ * @deprecated in POI 3.16-beta3, not used anymore
*/
+ @Deprecated
+ @Removal(version="3.18")
public static final int READ_WRITE_FILE_BUFFER_SIZE = 8192;
/**
PackageRelationship corePropsRel = pkg.getRelationshipsByType(
PackageRelationshipTypes.CORE_PROPERTIES).getRelationship(0);
- if (corePropsRel == null)
+ if (corePropsRel == null) {
return null;
+ }
return new ZipEntry(corePropsRel.getTargetURI().getPath());
}
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (entry.getName().equals(
- ContentTypeManager.CONTENT_TYPES_PART_NAME))
+ ContentTypeManager.CONTENT_TYPES_PART_NAME)) {
return entry;
+ }
}
return null;
}
* @return An OPC compliant name.
*/
public static String getOPCNameFromZipItemName(String zipItemName) {
- if (zipItemName == null)
- throw new IllegalArgumentException("zipItemName");
+ if (zipItemName == null) {
+ throw new IllegalArgumentException("zipItemName cannot be null");
+ }
if (zipItemName.startsWith(FORWARD_SLASH)) {
return zipItemName;
}
* @return A zip item name without any leading slashes.
*/
public static String getZipItemNameFromOPCName(String opcItemName) {
- if (opcItemName == null)
- throw new IllegalArgumentException("opcItemName");
+ if (opcItemName == null) {
+ throw new IllegalArgumentException("opcItemName cannot be null");
+ }
String retVal = opcItemName;
- while (retVal.startsWith(FORWARD_SLASH))
+ while (retVal.startsWith(FORWARD_SLASH)) {
retVal = retVal.substring(1);
+ }
return retVal;
}
* @return A zip URI without any leading slashes.
*/
public static URI getZipURIFromOPCName(String opcItemName) {
- if (opcItemName == null)
+ if (opcItemName == null) {
throw new IllegalArgumentException("opcItemName");
+ }
String retVal = opcItemName;
- while (retVal.startsWith(FORWARD_SLASH))
+ while (retVal.startsWith(FORWARD_SLASH)) {
retVal = retVal.substring(1);
+ }
try {
return new URI(retVal);
} catch (URISyntaxException e) {
/**
* Zip part marshaller. This marshaller is use to save any part in a zip stream.
- *
- * @author Julien Chable
*/
public final class ZipPartMarshaller implements PartMarshaller {
private final static POILogger logger = POILogFactory.getLogger(ZipPartMarshaller.class);
* @throws OpenXML4JException
* Throws if an internal exception is thrown.
*/
+ @Override
public boolean marshall(PackagePart part, OutputStream os)
throws OpenXML4JException {
if (!(os instanceof ZipOutputStream)) {
* @throws IOException if an I/O error has occurred
* @throws IllegalStateException if the zip file has been closed
*/
+ @Override
@SuppressWarnings("resource")
public InputStream getInputStream(ZipEntry entry) throws IOException {
InputStream zipIS = super.getInputStream(entry);
ThresholdInputStream newInner;
if (zipIS instanceof InflaterInputStream) {
newInner = AccessController.doPrivileged(new PrivilegedAction<ThresholdInputStream>() { // NOSONAR
+ @Override
@SuppressForbidden("TODO: Fix this to not use reflection (it will break in Java 9)! " +
"Better would be to wrap *before* instead of trying to insert wrapper afterwards.")
public ThresholdInputStream run() {
Field f = FilterInputStream.class.getDeclaredField("in");
f.setAccessible(true);
InputStream oldInner = (InputStream)f.get(zipIS);
- ThresholdInputStream newInner = new ThresholdInputStream(oldInner, null);
- f.set(zipIS, newInner);
- return newInner;
+ ThresholdInputStream newInner2 = new ThresholdInputStream(oldInner, null);
+ f.set(zipIS, newInner2);
+ return newInner2;
} catch (Exception ex) {
LOG.log(POILogger.WARN, "SecurityManager doesn't allow manipulation via reflection for zipbomb detection - continue with original input stream", ex);
}
this.cis = cis;
}
+ @Override
public int read() throws IOException {
int b = in.read();
- if (b > -1) advance(1);
+ if (b > -1) {
+ advance(1);
+ }
return b;
}
+ @Override
public int read(byte b[], int off, int len) throws IOException {
int cnt = in.read(b, off, len);
- if (cnt > -1) advance(cnt);
+ if (cnt > -1) {
+ advance(cnt);
+ }
return cnt;
-
}
+ @Override
public long skip(long n) throws IOException {
counter = 0;
return in.skip(n);
}
+ @Override
public synchronized void reset() throws IOException {
counter = 0;
in.reset();
((ZipInputStream)in).closeEntry();
}
+ @Override
public void unread(int b) throws IOException {
if (!(in instanceof PushbackInputStream)) {
throw new UnsupportedOperationException("underlying stream is not a PushbackInputStream");
}
- if (--counter < 0) counter = 0;
+ if (--counter < 0) {
+ counter = 0;
+ }
((PushbackInputStream)in).unread(b);
}
+ @Override
public void unread(byte[] b, int off, int len) throws IOException {
if (!(in instanceof PushbackInputStream)) {
throw new UnsupportedOperationException("underlying stream is not a PushbackInputStream");
}
counter -= len;
- if (--counter < 0) counter = 0;
+ if (--counter < 0) {
+ counter = 0;
+ }
((PushbackInputStream)in).unread(b, off, len);
}
+ @Override
+ @SuppressForbidden("just delegating")
public int available() throws IOException {
return in.available();
}
+ @Override
public boolean markSupported() {
return in.markSupported();
}
+ @Override
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
Decryptor d = Decryptor.getInstance(info);
assertTrue(d.verifyPassword(Decryptor.DEFAULT_PASSWORD));
+
+ fs.close();
}
@Test
d.verifyPassword(Decryptor.DEFAULT_PASSWORD);
zipOk(fs.getRoot(), d);
+
+ fs.close();
}
@Test
assertTrue(d.verifyPassword(Decryptor.DEFAULT_PASSWORD));
zipOk(fs.getRoot(), d);
+
+ fs.close();
}
private void zipOk(DirectoryNode root, Decryptor d) throws IOException, GeneralSecurityException {
while (true) {
ZipEntry entry = zin.getNextEntry();
- if (entry==null) break;
+ if (entry==null) {
+ break;
+ }
// crc32 is checked within zip-stream
- if (entry.isDirectory()) continue;
+ if (entry.isDirectory()) {
+ continue;
+ }
zin.skip(entry.getSize());
byte buf[] = new byte[10];
int readBytes = zin.read(buf);
fs.close();
}
-}
\ No newline at end of file
+}
projects / poi.git / commitdiff