| /* SaslInputStream.java -- |
| Copyright (C) 2003, 2006 Free Software Foundation, Inc. |
| |
| This file is a part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or (at |
| your option) any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 |
| USA |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package gnu.javax.crypto.sasl; |
| |
| import gnu.java.security.Configuration; |
| import gnu.java.security.util.Util; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InterruptedIOException; |
| import java.util.logging.Logger; |
| |
| import javax.security.sasl.Sasl; |
| import javax.security.sasl.SaslClient; |
| import javax.security.sasl.SaslServer; |
| |
| /** |
| * An input stream that uses either a {@link SaslClient} or a {@link SaslServer} |
| * to process the data through these entities' security layer filter(s). |
| */ |
| public class SaslInputStream |
| extends InputStream |
| { |
| private static final Logger log = Logger.getLogger(SaslInputStream.class.getName()); |
| private SaslClient client; |
| private SaslServer server; |
| private int maxRawSendSize; |
| private InputStream source; |
| private byte[] internalBuf; |
| |
| public SaslInputStream(SaslClient client, InputStream source) |
| throws IOException |
| { |
| super(); |
| |
| this.client = client; |
| String size = (String) client.getNegotiatedProperty(Sasl.RAW_SEND_SIZE); |
| maxRawSendSize = Integer.parseInt(size); |
| server = null; |
| this.source = source; |
| } |
| |
| public SaslInputStream(SaslServer server, InputStream source) |
| throws IOException |
| { |
| super(); |
| |
| this.server = server; |
| String size = (String) server.getNegotiatedProperty(Sasl.RAW_SEND_SIZE); |
| maxRawSendSize = Integer.parseInt(size); |
| client = null; |
| this.source = source; |
| } |
| |
| public int available() throws IOException |
| { |
| return (internalBuf == null) ? 0 : internalBuf.length; |
| } |
| |
| public void close() throws IOException |
| { |
| source.close(); |
| } |
| |
| /** |
| * Reads the next byte of data from the input stream. The value byte is |
| * returned as an <code>int</code> in the range <code>0</code> to |
| * <code>255</code>. If no byte is available because the end of the stream |
| * has been reached, the value <code>-1</code> is returned. This method |
| * blocks until input data is available, the end of the stream is detected, or |
| * an exception is thrown. |
| * <p> |
| * From a SASL mechanism provider's perspective, if a security layer has been |
| * negotiated, the underlying <i>source</i> is expected to contain SASL |
| * buffers, as defined in RFC 2222. Four octets in network byte order in the |
| * front of each buffer identify the length of the buffer. The provider is |
| * responsible for performing any integrity checking or other processing on |
| * the buffer before returning the data as a stream of octets. For example, |
| * the protocol driver's request for a single octet from the stream might; |
| * i.e. an invocation of this method, may result in an entire SASL buffer |
| * being read and processed before that single octet can be returned. |
| * |
| * @return the next byte of data, or <code>-1</code> if the end of the |
| * stream is reached. |
| * @throws IOException if an I/O error occurs. |
| */ |
| public int read() throws IOException |
| { |
| int result = -1; |
| if (internalBuf != null && internalBuf.length > 0) |
| { |
| result = internalBuf[0] & 0xFF; |
| if (internalBuf.length == 1) |
| internalBuf = new byte[0]; |
| else |
| { |
| byte[] tmp = new byte[internalBuf.length - 1]; |
| System.arraycopy(internalBuf, 1, tmp, 0, tmp.length); |
| internalBuf = tmp; |
| } |
| } |
| else |
| { |
| byte[] buf = new byte[1]; |
| int check = read(buf); |
| result = (check > 0) ? (buf[0] & 0xFF) : -1; |
| } |
| return result; |
| } |
| |
| /** |
| * Reads up to <code>len</code> bytes of data from the underlying <i>source</i> |
| * input stream into an array of bytes. An attempt is made to read as many as |
| * <code>len</code> bytes, but a smaller number may be read, possibly zero. |
| * The number of bytes actually read is returned as an integer. |
| * <p> |
| * This method blocks until input data is available, end of file is detected, |
| * or an exception is thrown. |
| * <p> |
| * If <code>b</code> is <code>null</code>, a {@link NullPointerException} |
| * is thrown. |
| * <p> |
| * If <code>off</code> is negative, or <code>len</code> is negative, or |
| * <code>off+len</code> is greater than the length of the array |
| * <code>b</code>, then an {@link IndexOutOfBoundsException} is thrown. |
| * <p> |
| * If <code>len</code> is zero, then no bytes are read and <code>0</code> |
| * is returned; otherwise, there is an attempt to read at least one byte. If |
| * no byte is available because the stream is at end of file, the value |
| * <code>-1</code> is returned; otherwise, at least one byte is read and |
| * stored into <code>b</code>. |
| * <p> |
| * The first byte read is stored into element <code>b[off]</code>, the next |
| * one into <code>b[off+1]</code>, and so on. The number of bytes read is, |
| * at most, equal to <code>len</code>. Let <code>k</code> be the number |
| * of bytes actually read; these bytes will be stored in elements |
| * <code>b[off]</code> through <code>b[off+k-1]</code>, leaving elements |
| * <code>b[off+k]</code> through <code>b[off+len-1]</code> unaffected. |
| * <p> |
| * In every case, elements <code>b[0]</code> through <code>b[off]</code> |
| * and elements <code>b[off+len]</code> through <code>b[b.length-1]</code> |
| * are unaffected. |
| * <p> |
| * If the first byte cannot be read for any reason other than end of file, |
| * then an {@link IOException} is thrown. In particular, an |
| * {@link IOException} is thrown if the input stream has been closed. |
| * <p> |
| * From the SASL mechanism provider's perspective, if a security layer has |
| * been negotiated, the underlying <i>source</i> is expected to contain SASL |
| * buffers, as defined in RFC 2222. Four octets in network byte order in the |
| * front of each buffer identify the length of the buffer. The provider is |
| * responsible for performing any integrity checking or other processing on |
| * the buffer before returning the data as a stream of octets. The protocol |
| * driver's request for a single octet from the stream might result in an |
| * entire SASL buffer being read and processed before that single octet can be |
| * returned. |
| * |
| * @param b the buffer into which the data is read. |
| * @param off the start offset in array <code>b</code> at which the data is |
| * wricodeen. |
| * @param len the maximum number of bytes to read. |
| * @return the total number of bytes read into the buffer, or <code>-1</code> |
| * if there is no more data because the end of the stream has been |
| * reached. |
| * @throws IOException if an I/O error occurs. |
| */ |
| public int read(byte[] b, int off, int len) throws IOException |
| { |
| if (Configuration.DEBUG) |
| log.entering(this.getClass().getName(), "read", new Object[] { |
| b, Integer.valueOf(off), Integer.valueOf(len) |
| }); |
| if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) |
| || ((off + len) < 0)) |
| throw new IndexOutOfBoundsException("off=" + off + ", len=" + len |
| + ", b.length=" + b.length); |
| if (len == 0) |
| { |
| if (Configuration.DEBUG) |
| log.exiting(this.getClass().getName(), "read", Integer.valueOf(0)); |
| return 0; |
| } |
| if (Configuration.DEBUG) |
| log.finer("Available: " + available()); |
| int result = 0; |
| if (internalBuf == null || internalBuf.length < 1) |
| try |
| { |
| internalBuf = readSaslBuffer(); |
| if (internalBuf == null) |
| { |
| if (Configuration.DEBUG) |
| { |
| log.finer("Underlying stream empty. Returning -1"); |
| log.exiting(this.getClass().getName(), "read", |
| Integer.valueOf(-1)); |
| } |
| return -1; |
| } |
| } |
| catch (InterruptedIOException x) |
| { |
| if (Configuration.DEBUG) |
| { |
| log.finer("Reading thread was interrupted. Returning -1"); |
| log.throwing(this.getClass().getName(), "read", x); |
| log.exiting(this.getClass().getName(), "read", |
| Integer.valueOf(-1)); |
| } |
| return -1; |
| } |
| if (len <= internalBuf.length) |
| { |
| result = len; |
| System.arraycopy(internalBuf, 0, b, off, len); |
| if (len == internalBuf.length) |
| internalBuf = null; |
| else |
| { |
| byte[] tmp = new byte[internalBuf.length - len]; |
| System.arraycopy(internalBuf, len, tmp, 0, tmp.length); |
| internalBuf = tmp; |
| } |
| } |
| else |
| { |
| // first copy the available bytes to b |
| result = internalBuf.length; |
| System.arraycopy(internalBuf, 0, b, off, result); |
| internalBuf = null; |
| off += result; |
| len -= result; |
| int remaining; // count of bytes remaining in buffer after an iteration |
| int delta; // count of bytes moved to b after an iteration |
| int datalen; |
| byte[] data; |
| while (len > 0) |
| // we need to read SASL buffers, as long as there are at least |
| // 4 bytes available at the source |
| if (source.available() > 3) |
| { |
| // process a buffer |
| data = readSaslBuffer(); |
| if (data == null) |
| { |
| if (Configuration.DEBUG) |
| log.finer("Underlying stream exhausted. Breaking..."); |
| break; |
| } |
| datalen = data.length; |
| // copy [part of] the result to b |
| remaining = (datalen <= len) ? 0 : datalen - len; |
| delta = datalen - remaining; |
| System.arraycopy(data, 0, b, off, delta); |
| if (remaining > 0) |
| { |
| internalBuf = new byte[remaining]; |
| System.arraycopy(data, delta, internalBuf, 0, remaining); |
| } |
| // update off, result and len |
| off += delta; |
| result += delta; |
| len -= delta; |
| } |
| else |
| { // nothing much we can do except return what we have |
| if (Configuration.DEBUG) |
| log.finer("Not enough bytes in source to read a buffer. Breaking..."); |
| break; |
| } |
| } |
| if (Configuration.DEBUG) |
| { |
| log.finer("Remaining: " |
| + (internalBuf == null ? 0 : internalBuf.length)); |
| log.exiting(this.getClass().getName(), "read()", String.valueOf(result)); |
| } |
| return result; |
| } |
| |
| /** |
| * Reads a SASL buffer from the underlying source if at least 4 bytes are |
| * available. |
| * |
| * @return the byte[] of decoded buffer contents, or null if the underlying |
| * source was exhausted. |
| * @throws IOException if an I/O exception occurs during the operation. |
| */ |
| private byte[] readSaslBuffer() throws IOException |
| { |
| if (Configuration.DEBUG) |
| log.entering(this.getClass().getName(), "readSaslBuffer()"); |
| int realLength; // check if we read as many bytes as we're supposed to |
| byte[] result = new byte[4]; |
| try |
| { |
| realLength = source.read(result); |
| if (realLength == -1) |
| { |
| if (Configuration.DEBUG) |
| log.exiting(this.getClass().getName(), "readSaslBuffer"); |
| return null; |
| } |
| } |
| catch (IOException x) |
| { |
| if (Configuration.DEBUG) |
| log.throwing(this.getClass().getName(), "readSaslBuffer", x); |
| throw x; |
| } |
| if (realLength != 4) |
| throw new IOException("Was expecting 4 but found " + realLength); |
| int bufferLength = result[0] << 24 |
| | (result[1] & 0xFF) << 16 |
| | (result[2] & 0xFF) << 8 |
| | (result[3] & 0xFF); |
| if (Configuration.DEBUG) |
| log.finer("SASL buffer size: " + bufferLength); |
| if (bufferLength > maxRawSendSize || bufferLength < 0) |
| throw new SaslEncodingException("SASL buffer (security layer) too long"); |
| |
| result = new byte[bufferLength]; |
| try |
| { |
| realLength = source.read(result); |
| } |
| catch (IOException x) |
| { |
| if (Configuration.DEBUG) |
| log.throwing(this.getClass().getName(), "readSaslBuffer", x); |
| throw x; |
| } |
| if (realLength != bufferLength) |
| throw new IOException("Was expecting " + bufferLength + " but found " |
| + realLength); |
| if (Configuration.DEBUG) |
| { |
| log.finer("Incoming buffer (before security) (hex): " |
| + Util.dumpString(result)); |
| log.finer("Incoming buffer (before security) (str): \"" |
| + new String(result) + "\""); |
| } |
| if (client != null) |
| result = client.unwrap(result, 0, realLength); |
| else |
| result = server.unwrap(result, 0, realLength); |
| if (Configuration.DEBUG) |
| { |
| log.finer("Incoming buffer (after security) (hex): " |
| + Util.dumpString(result)); |
| log.finer("Incoming buffer (after security) (str): \"" |
| + new String(result) + "\""); |
| log.exiting(this.getClass().getName(), "readSaslBuffer"); |
| } |
| return result; |
| } |
| } |
