net.hasor.utils.io.input.Base64InputStream Maven / Gradle / Ivy
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
/*
* Copyright (c) 2004, Mikael Grev, MiG InfoCom AB. (base64 @ miginfocom . com)
* All rights reserved.
*/
package net.hasor.utils.io.input;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
/**
* A slight spin on the standard ByteArrayInputStream. This
* one accepts only a Base64 encoded String in the constructor argument
* which decodes into a byte[] to be read from by
* other stream.
*/
public class Base64InputStream extends InputStream {
private static final int[] IA = new int[256];
private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
static {
Arrays.fill(Base64InputStream.IA, -1);
for (int i = 0, iS = Base64InputStream.CA.length; i < iS; i++) {
Base64InputStream.IA[Base64InputStream.CA[i]] = i;
}
Base64InputStream.IA['='] = 0;
}
/**
* An array of bytes that was provided
* by the creator of the stream. Elements buf[0]
* through buf[count-1] are the
* only bytes that can ever be read from the
* stream; element buf[pos] is
* the next byte to be read.
*/
protected byte buf[];
/**
* The index of the next character to read from the input stream buffer.
* This value should always be nonnegative
* and not larger than the value of count.
* The next byte to be read from the input stream buffer
* will be buf[pos].
*/
protected int pos;
/**
* The currently marked position in the stream.
* ByteArrayInputStream objects are marked at position zero by
* default when constructed. They may be marked at another
* position within the buffer by the mark() method.
* The current buffer position is set to this point by the
* reset() method.
*
* If no mark has been set, then the value of mark is the offset
* passed to the constructor (or 0 if the offset was not supplied).
*
* @since JDK1.1
*/
protected int mark = 0;
/**
* The index one greater than the last valid character in the input
* stream buffer.
* This value should always be nonnegative
* and not larger than the length of buf.
* It is one greater than the position of
* the last byte within buf that
* can ever be read from the input stream buffer.
*/
protected int count;
/**
* Creates a Base64InputStream.
*
* @param encodedString the Base64 encoded String
*/
public Base64InputStream(final String encodedString) {
this.buf = this.decode(encodedString);
this.pos = 0;
this.count = this.buf.length;
}
/**
* Reads the next byte of data from this input stream. The value
* byte is returned as an int in the range
* 0 to 255. If no byte is available
* because the end of the stream has been reached, the value
* -1 is returned.
*
* This read method
* cannot block.
*
* @return the next byte of data, or -1 if the end of the
* stream has been reached.
*/
@Override
public int read() {
return this.pos < this.count ? this.buf[this.pos++] & 0xff : -1;
}
/**
* Reads up to len bytes of data into an array of bytes
* from this input stream.
* If pos equals count,
* then -1 is returned to indicate
* end of file. Otherwise, the number k
* of bytes read is equal to the smaller of
* len and count-pos.
* If k is positive, then bytes
* buf[pos] through buf[pos+k-1]
* are copied into b[off] through
* b[off+k-1] in the manner performed
* by System.arraycopy. The
* value k is added into pos
* and k is returned.
*
* This read method cannot block.
*
* @param b the buffer into which the data is read.
* @param off the start offset of the data.
* @param len the maximum number of bytes read.
*
* @return the total number of bytes read into the buffer, or
* -1 if there is no more data because the end of
* the stream has been reached.
*/
@Override
public int read(final byte b[], final int off, int len) {
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || off > b.length || len < 0 || off + len > b.length || off + len < 0) {
throw new IndexOutOfBoundsException();
}
if (this.pos >= this.count) {
return -1;
}
if (this.pos + len > this.count) {
len = this.count - this.pos;
}
if (len <= 0) {
return 0;
}
System.arraycopy(this.buf, this.pos, b, off, len);
this.pos += len;
return len;
}
/**
* Skips n bytes of input from this input stream. Fewer
* bytes might be skipped if the end of the input stream is reached.
* The actual number k
* of bytes to be skipped is equal to the smaller
* of n and count-pos.
* The value k is added into pos
* and k is returned.
*
* @param n the number of bytes to be skipped.
*
* @return the actual number of bytes skipped.
*/
@Override
public long skip(long n) {
if (this.pos + n > this.count) {
n = this.count - this.pos;
}
if (n < 0) {
return 0;
}
this.pos += n;
return n;
}
/**
* Returns the number of bytes that can be read from this input
* stream without blocking.
* The value returned is
* count - pos,
* which is the number of bytes remaining to be read from the input buffer.
*
* @return the number of bytes that can be read from the input stream
* without blocking.
*/
@Override
public int available() {
return this.count - this.pos;
}
/**
* Tests if this InputStream supports mark/reset. The
* markSupported method of ByteArrayInputStream
* always returns true.
*
* @since JDK1.1
*/
@Override
public boolean markSupported() {
return true;
}
/**
* Set the current marked position in the stream.
* ByteArrayInputStream objects are marked at position zero by
* default when constructed. They may be marked at another
* position within the buffer by this method.
*
* If no mark has been set, then the value of the mark is the
* offset passed to the constructor (or 0 if the offset was not
* supplied).
*
* Note: The readAheadLimit for this class
* has no meaning.
*
* @since JDK1.1
*/
@Override
public void mark(final int readAheadLimit) {
this.mark = this.pos;
}
/**
* Resets the buffer to the marked position. The marked position
* is 0 unless another position was marked or an offset was specified
* in the constructor.
*/
@Override
public void reset() {
this.pos = this.mark;
}
/**
* Closing a ByteArrayInputStream has no effect. The methods in
* this class can be called after the stream has been closed without
* generating an IOException.
*
*/
@Override
public void close() throws IOException {
}
/**
* Base64 decodes the source string. NOTE: This method doesn't
* consider line breaks
* @param source a Base64 encoded string
* @return the bytes of the decode process
*/
private byte[] decode(final String source) {
// Check special case
int sLen = source.length();
if (sLen == 0) {
return new byte[0];
}
int sIx = 0, eIx = sLen - 1; // Start and end index after trimming.
// Trim illegal chars from start
while (sIx < eIx && Base64InputStream.IA[source.charAt(sIx) & 0xff] < 0) {
sIx++;
}
// Trim illegal chars from end
while (eIx > 0 && Base64InputStream.IA[source.charAt(eIx) & 0xff] < 0) {
eIx--;
}
// get the padding count (=) (0, 1 or 2)
int pad = source.charAt(eIx) == '=' ? source.charAt(eIx - 1) == '=' ? 2 : 1 : 0; // Count '=' at end.
int cCnt = eIx - sIx + 1; // Content count including possible separators
int sepCnt = sLen > 76 ? (source.charAt(76) == '\r' ? cCnt / 78 : 0) << 1 : 0;
int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes
byte[] dArr = new byte[len]; // Preallocate byte[] of exact length
// Decode all but the last 0 - 2 bytes.
int d = 0;
for (int eLen = len / 3 * 3; d < eLen; ) {
// Assemble three bytes into an int from four "valid" characters.
int i = Base64InputStream.IA[source.charAt(sIx++)] << 18 | Base64InputStream.IA[source.charAt(sIx++)] << 12 | Base64InputStream.IA[source.charAt(sIx++)] << 6 | Base64InputStream.IA[source.charAt(sIx++)];
// Add the bytes
dArr[d++] = (byte) (i >> 16);
dArr[d++] = (byte) (i >> 8);
dArr[d++] = (byte) i;
}
if (d < len) {
// Decode last 1-3 bytes (incl '=') into 1-3 bytes
int i = 0;
for (int j = 0; sIx <= eIx - pad; j++) {
i |= Base64InputStream.IA[source.charAt(sIx++)] << 18 - j * 6;
}
for (int r = 16; d < len; r -= 8) {
dArr[d++] = (byte) (i >> r);
}
}
return dArr;
}
// Test Case: com.sun.faces.io.TestIO
} // END Base64InputStream
© 2015 - 2024 Weber Informatics LLC | Privacy Policy