test/jdk/javax/imageio/spi/MarkTryFinallyReproducer.java - platform/libcore - Git at Google

 /*
  * 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");
         }

     }

 }
	/*
	* 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");
	}

	}

	}