/*
* Copyright 2015 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8144071
* @run main/othervm MarkTryFinallyReproducer
* @summary Test that call to canDecodeInput in ImageIO don't corrupt
* mark/reset stack in ImageInputStream
* @author Jiri Vanek
*/
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteOrder;
import java.util.Locale;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.spi.IIORegistry;
import javax.imageio.spi.ImageReaderSpi;
import javax.imageio.stream.IIOByteBuffer;
import javax.imageio.stream.ImageInputStream;
public class MarkTryFinallyReproducer {
private static final byte[] bmp = new byte[]{
127,127, 66, 77, -86, 0, 0, 0, 0, 0, 0, 0,
122, 0, 0, 0, 108, 0, 0, 0, 4, 0, 0, 0, 4,
0, 0, 0, 1, 0, 24, 0, 0, 0, 0, 0, 48, 0, 0,
0, 19, 11, 0, 0, 19, 11, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 66, 71, 82, 115, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, -1, -1, -1,
-1, -1, -1, 0, -1, 0, -1, -1, -1, -1, 0, 0, 0, -17,
0, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, -1, -1, -1,
-1, 0, 0, 0, -1, -1, -1, -1, -1, -1, 0, 0, -1
};
//first two are evil, we are skipping them later. Others are normal BMP
private static class NotClosingImageInputStream implements ImageInputStream {
private final ImageInputStream src;
private NotClosingImageInputStream(ImageInputStream createImageInputStream) {
this.src = createImageInputStream;
}
@Override
public void setByteOrder(ByteOrder byteOrder) {
src.setByteOrder(byteOrder);
}
@Override
public ByteOrder getByteOrder() {
return src.getByteOrder();
}
@Override
public int read() throws IOException {
return src.read();
}
@Override
public int read(byte[] b) throws IOException {
return src.read(b);
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
return src.read(b, off, len);
}
@Override
public void readBytes(IIOByteBuffer buf, int len) throws IOException {
src.readBytes(buf, len);
}
@Override
public boolean readBoolean() throws IOException {
return src.readBoolean();
}
@Override
public byte readByte() throws IOException {
return src.readByte();
}
@Override
public int readUnsignedByte() throws IOException {
return src.readUnsignedByte();
}
@Override
public short readShort() throws IOException {
return src.readShort();
}
@Override
public int readUnsignedShort() throws IOException {
return src.readUnsignedShort();
}
@Override
public char readChar() throws IOException {
return src.readChar();
}
@Override
public int readInt() throws IOException {
return src.readInt();
}
@Override
public long readUnsignedInt() throws IOException {
return src.readUnsignedInt();
}
@Override
public long readLong() throws IOException {
return src.readLong();
}
@Override
public float readFloat() throws IOException {
return src.readFloat();
}
@Override
public double readDouble() throws IOException {
return src.readDouble();
}
@Override
public String readLine() throws IOException {
return src.readLine();
}
@Override
public String readUTF() throws IOException {
return src.readUTF();
}
@Override
public void readFully(byte[] b, int off, int len) throws IOException {
src.readFully(b, off, len);
}
@Override
public void readFully(byte[] b) throws IOException {
src.readFully(b);
}
@Override
public void readFully(short[] s, int off, int len) throws IOException {
src.readFully(s, off, len);
}
@Override
public void readFully(char[] c, int off, int len) throws IOException {
src.readFully(c, off, len);
}
@Override
public void readFully(int[] i, int off, int len) throws IOException {
src.readFully(i, off, len);
}
@Override
public void readFully(long[] l, int off, int len) throws IOException {
src.readFully(l, off, len);
}
@Override
public void readFully(float[] f, int off, int len) throws IOException {
src.readFully(f, off, len);
}
@Override
public void readFully(double[] d, int off, int len) throws IOException {
src.readFully(d, off, len);
}
@Override
public long getStreamPosition() throws IOException {
return src.getStreamPosition();
}
@Override
public int getBitOffset() throws IOException {
return src.getBitOffset();
}
@Override
public void setBitOffset(int bitOffset) throws IOException {
src.setBitOffset(bitOffset);
}
@Override
public int readBit() throws IOException {
return src.readBit();
}
@Override
public long readBits(int numBits) throws IOException {
return src.readBits(numBits);
}
@Override
public long length() throws IOException {
return src.length();
}
@Override
public int skipBytes(int n) throws IOException {
return src.skipBytes(n);
}
@Override
public long skipBytes(long n) throws IOException {
return src.skipBytes(n);
}
@Override
public void seek(long pos) throws IOException {
src.seek(pos);
}
@Override
public void mark() {
src.mark();
}
@Override
public void reset() throws IOException {
src.reset();
}
@Override
public void flushBefore(long pos) throws IOException {
src.flushBefore(pos);
}
@Override
public void flush() throws IOException {
src.flush();
}
@Override
public long getFlushedPosition() {
return src.getFlushedPosition();
}
@Override
public boolean isCached() {
return src.isCached();
}
@Override
public boolean isCachedMemory() {
return src.isCachedMemory();
}
@Override
public boolean isCachedFile() {
return src.isCachedFile();
}
@Override
public void close() throws IOException {
//the only important one. nothing
}
}
static final String readerClassName
= MarkTryFinallyReproducerSpi.class.getName();
static final String[] localNames = {"myNames"};
static final String[] localSuffixes = {"mySuffixes"};
static final String[] localMIMETypes = {"myMimes"};
public static class MarkTryFinallyReproducerSpi extends ImageReaderSpi {
public MarkTryFinallyReproducerSpi() {
super("MarkTryFinallyReproducerSpi",
"1.0",
localNames,
localSuffixes,
localMIMETypes,
readerClassName,
new Class[]{ImageInputStream.class},
new String[0],
false,
null,
null,
new String[0],
new String[0],
false,
null,
null,
new String[0],
new String[0]);
}
@Override
public String getDescription(Locale locale) {
return "";
}
@Override
public boolean canDecodeInput(Object input) throws IOException {
throw new IOException("Bad luck");
}
@Override
public ImageReader createReaderInstance(Object extension) {
return null;
}
}
public static void main(String[] args) throws IOException {
MarkTryFinallyReproducerSpi spi = new MarkTryFinallyReproducerSpi();
IIORegistry.getDefaultInstance().registerServiceProvider(spi);
ImageInputStream iis1 =
new NotClosingImageInputStream(ImageIO.createImageInputStream(new ByteArrayInputStream(bmp)));
iis1.readByte();
iis1.mark();
long p1 = iis1.getStreamPosition();
iis1.readByte();
iis1.mark();
long p2 = iis1.getStreamPosition();
BufferedImage bi1 = ImageIO.read(iis1);
iis1.reset();
long pn2 = iis1.getStreamPosition();
iis1.reset();
long pn1 = iis1.getStreamPosition();
if (p1 != pn1 || p2!= pn2) {
throw new RuntimeException("Exception from call to canDecodeInput in ImageIO. " +
"Corrupted stack in ImageInputStream");
}
}
}