Back to index...

	/*
	* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
	* 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package sun.security.provider;

	import java.io.*;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.WeakReference;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.ConcurrentMap;

	/**
	* A pool of {@code InputStream}s opened from distinct files. Only a single
	* instance is ever opened from the same file. This is used to read special
	* infinite files like {@code /dev/random} where the current file pointer is not
	* relevant, so multiple readers can share the same file descriptor and
	* consequently the same {@code InputStream}.
	*/
	class FileInputStreamPool {

	/**
	* a pool of: StreamRef -> UnclosableInputStream -> FileInputStream(s)
	*/
	private static final ConcurrentMap<File, StreamRef> pool =
	new ConcurrentHashMap<>();

	/**
	* a reference queue of cleared StreamRef(s)
	*/
	private static final ReferenceQueue<UnclosableInputStream> refQueue =
	new ReferenceQueue<>();

	/**
	* This method opens an underlying {@link java.io.FileInputStream} for a
	* given {@code file} and returns a wrapper over it. The wrapper is shared
	* among multiple readers of the same {@code file} and ignores
	* {@link java.io.InputStream#close()} requests. The underlying stream is
	* closed when all references to the wrapper are relinquished.
	*
	* @param file the file to be opened for reading.
	* @return a shared {@link java.io.InputStream} instance opened from given
	* file.
	* @throws FileNotFoundException if the file does not exist, is a directory
	* rather than a regular file, or for some
	* other reason cannot be opened for reading.
	* @throws SecurityException if a security manager exists and its
	* <code>checkRead</code> method denies read
	* access to the file.
	*/
	static InputStream getInputStream(File file) throws IOException {

	// expunge any cleared references
	StreamRef oldRref;
	while ((oldRref = (StreamRef) refQueue.poll()) != null) {
	pool.remove(oldRref.file, oldRref);
	}

	// canonicalize the path
	// (this also checks the read permission on the file if SecurityManager
	// is present, so no checking is needed later when we just return the
	// already opened stream)
	File cfile = file.getCanonicalFile();

	// check if it exists in pool
	oldRref = pool.get(cfile);
	UnclosableInputStream oldStream = (oldRref == null)
	? null
	: oldRref.get();
	StreamRef newRef = null;
	UnclosableInputStream newStream = null;

	// retry loop
	while (true) {
	if (oldStream != null) {
	// close our optimistically opened stream 1st (if we opened it)
	if (newStream != null) {
	try {
	newStream.getWrappedStream().close();
	} catch (IOException ignore) {
	// can't do anything here
	}
	}
	// return it
	return oldStream;
	} else {
	// we need to open new stream optimistically (if not already)
	if (newStream == null) {
	newStream = new UnclosableInputStream(
	new FileInputStream(cfile));
	newRef = new StreamRef(cfile, newStream, refQueue);
	}
	// either try to install newRef or replace oldRef with newRef
	if (oldRref == null) {
	oldRref = pool.putIfAbsent(cfile, newRef);
	} else {
	oldRref = pool.replace(cfile, oldRref, newRef)
	? null
	: pool.get(cfile);
	}
	if (oldRref == null) {
	// success
	return newStream;
	} else {
	// lost race
	oldStream = oldRref.get();
	// another loop
	}
	}
	}
	}

	private static class StreamRef extends WeakReference<UnclosableInputStream> {
	final File file;

	StreamRef(File file,
	UnclosableInputStream stream,
	ReferenceQueue<UnclosableInputStream> refQueue) {
	super(stream, refQueue);
	this.file = file;
	}
	}

	private static final class UnclosableInputStream extends FilterInputStream {
	UnclosableInputStream(InputStream in) {
	super(in);
	}

	@Override
	public void close() throws IOException {
	// Ignore close attempts since underlying InputStream is shared.
	}

	InputStream getWrappedStream() {
	return in;
	}
	}
	}

Back to index...