/*
* Copyright (c) 2008, 2009, 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.jkernel;
import java.io.FilterOutputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import sun.jkernel.StandaloneMessageDigest;
/*
* This class provides the main functionality of <code>FilterOutputStream</code>,
* and accumulates a check value as bytes are written to
* it. The check value is available by method <code>getCheckValue</code>.
*<p>
* Operations on the public <code>out</code> field of this class should be
* avoided to prevent an invalid check code being generated.
*
* TODO: The javadoc HTML hasn't been generated and eyeballed for yet.
* TODO: There is a javadoc trick to cause the parent class javadoc to be
* automagically used: try to take advantage of this.
* TODO: Add javadoc links instead of <code>API</code> where it would be useful.
* TODO: Go visit the Docs style guide again and get the periods right and
* consistent for all sun.* classes.
* @author Pete Soper
* @see java.lang.FilterOutputStream
* @see getCheckValue
*/
public class DigestOutputStream extends FilterOutputStream {
private static final String DEFAULT_ALGORITHM = "SHA-1";
private final boolean debug = false;
private StandaloneMessageDigest smd = null;
private void initDigest(String algorithm) throws NoSuchAlgorithmException {
smd = StandaloneMessageDigest.getInstance(algorithm);
}
// The underlying stream.
protected volatile OutputStream out;
/**
* Creates a <code>DigestOutputStream</code> with stream <code>s</code>
* to be checked with using <code>algorithm</code>.
* <p>
* If <code>algorithm</code> is not supported then
* <code>NoSuchAlgorithm</code> is thrown.
* <p>
* See {linkplain sun.security.provider.StandaloneMessageDigest} for an
* implementation-specific list of supported algorithms.
*
* @throws NoSuchAlgorithm if <code>algorithm</code> is not supported
* @see sun.security.provider.StandaloneMessageDigest
*/
/**
* Creates an output stream filter built on top of
* underlying output stream <code>out</code> for checking with
* algorithm <code>algorithm</code>.
* <p>
* If <code>algorithm</code> is not supported then
* <code>NoSuchAlgorithm</code> is thrown.
* <p>
* See {linkplain sun.security.provider.StandaloneMessageDigest} for an
* implementation-specific list of supported algorithms.
*
* @param out the underlying output stream to be assigned to
* the field <tt>this.out</tt> for later use, or
* <code>null</code> if this instance is to be
* created without an underlying stream.
* @param algorithm the check algorithm to use.
* @throws NoSuchAlgorithm if <code>algorithm</code> is not supported
* @see sun.security.provider.StandaloneMessageDigest
* @see DigestInputStream(InputStream, String)
*/
public DigestOutputStream(OutputStream out, String algorithm) throws NoSuchAlgorithmException {
super(out);
initDigest(algorithm);
this.out = out;
}
/**
* Creates an output stream filter built on top of
* underlying output stream <code>out</code> for the default checking
* algorithm.
* <p>
* This implemention provides "SHA-1" as the default checking algorithm.
*
* @param out the underlying output stream to be assigned to
* the field <tt>this.out</tt> for later use, or
* <code>null</code> if this instance is to be
* created without an underlying stream.
* @see DigestInputStream(InputStream)
*/
public DigestOutputStream(OutputStream out) {
super(out);
try {
initDigest(DEFAULT_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
// Impossible to get here, but stranger things have happened...
throw new RuntimeException("DigestOutputStream() unknown algorithm");
}
// superstition from a test failure this.out = out;
}
/**
* Writes a byte specified by <code>v</code> to this stream
* and updates the check information.
*
*
* @param v the byte to be written.
* @throws IOException if an I/O error occurs.
*/
public void write(int v) throws IOException {
super.write(v);
// TODO Could create this array once
byte[] b = new byte[] {(byte) (v & 0xff)};
smd.update(b,0,1);
}
/**
* Writes the bytes in array <code>data</code>
* to this stream and updates the check information.
*
* @param data the data.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if <code>data</code> is <code>null</code>
*/
public void write(byte[] data) throws IOException {
write(data,0,data.length);
}
/**
* Writes a sub array as a sequence of bytes to this output stream and
* updates the check information.
* @param data the data to be written
* @param ofs the start offset in the data
* @param len the number of bytes that are written
* @throws IOException If an I/O error has occurred.
* @throws NullPointerException if <code>data</code> is <code>null</code>
* @throws IndexOutOfBoundsException If <code>ofs</code> is negative,
* <code>len</code> is negative, or <code>len</code> is greater than
* <code>b.length - ofs</code>
*/
public void write(byte[] data, int ofs, int len) throws IOException {
if (debug) {
System.out.print("DigestOutputStream.write: ");
for (int i=ofs; i<(len - ofs); i++) {
System.out.format("%02X",data[i]);
}
System.out.println();
}
if (data == null) {
throw new NullPointerException("null array in DigestOutputStream.write");
} else if (ofs < 0 || len < 0 || len > data.length - ofs) {
throw new IndexOutOfBoundsException();
}
//super.write(data,ofs,len);
// WATCH OUT: FilterOutputStream does a byte at a time write(byte)
// TODO: Will this work all the time, or is there another caveat
// to publish
out.write(data,ofs,len);
if (debug) {
System.out.println("DigestOutputStream.write before");
}
smd.update(data,ofs,len);
if (debug) {
System.out.println("DigestOutputStream.write after");
}
}
/**
* Closes this file output stream and releases any system resources
* associated with this stream and makes the check value for the stream
* available via <code>getCheckValue</code>. This file output stream may
* no longer be used for writing bytes.
*
* @throws IOException if an I/O error occurs.
* @see getCheckValue
*/
public void close() throws IOException {
super.close();
}
/**
* Return the check value computed for the stream and reset the state of
* check value generation.
*
* @return the check value bytes
*/
public byte[] getCheckValue() {
byte[] b = smd.digest();
if (debug) {
System.out.print("DigestOutputStream.getCheckValue: ");
for (int i=0; i<b.length; i++) {
System.out.format("%02X",b[i]);
}
System.out.println();
}
smd.reset();
return b;
}
/**
* Flushes this output stream.
*
* @throws IOException if an I/O error occurs.
* @see java.io.FilterOutputStream#flush()
*/
public void flush() throws IOException {
super.flush();
}
/**
* Compares two digests for equality. Does a simple byte compare.
*
* @param digesta one of the digests to compare.
*
* @param digestb the other digest to compare.
*
* @return true if the digests are equal, false otherwise.
*/
// public static boolean isEqual(byte digesta[], byte digestb[]) {
// return StandaloneMessageDigest.isEqual(digesta, digestb);
// }
}