upstream/oracle/userland-gate: comparison components/visual-panels/core/src/java/util/com/oracle/solaris/vp/util/misc/Base64Util.java

equal deleted inserted replaced

-:c6aad84d2493
+:0944d8c0158b
+/*
+* CDDL HEADER START
+*
+* The contents of this file are subject to the terms of the
+* Common Development and Distribution License (the "License").
+* You may not use this file except in compliance with the License.
+*
+* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+* or http://www.opensolaris.org/os/licensing.
+* See the License for the specific language governing permissions
+* and limitations under the License.
+*
+* When distributing Covered Code, include this CDDL HEADER in each
+* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+* If applicable, add the following below this CDDL HEADER, with the
+* fields enclosed by brackets "[]" replaced with your own identifying
+* information: Portions Copyright [yyyy] [name of copyright owner]
+*
+* CDDL HEADER END
+*/
+/*
+* Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+*/
+package com.oracle.solaris.vp.util.misc;
+import java.io.*;
+public class Base64Util {
+//
+// Inner classes
+//
+@SuppressWarnings({"serial"})
+public static class Base64Exception extends IOException {
+	public Base64Exception(String message) {
+	    super(message);
+	}
+}
+/**
+* Utility class provided for callers who wish to enforce a maximum
+* line length for their Base64-encoded output.
+*/
+public static class WrappingWriter extends FilterWriter {
+	private static final String NEWLINE =
+	    System.getProperty("line.separator");
+	private int column_ = 0;
+	private int max_ = 76;
+	/**
+	 * Creates a new WrappingWriter which writes line-wrapped
+	 * output to {@code out} using the default width (76
+	 * characters).
+	 *
+	 * @param out the {@code Writer} to which output should be sent
+	 */
+	public WrappingWriter(Writer out)
+	{
+	    super(out);
+	}
+	/**
+	 * Creates a new WrappingWriter which writes line-wrapped
+	 * output to {@code out} using the specified width.
+	 *
+	 * @param out the {@code Writer} to which output should be sent
+	 * @param max the maximum number of characters per line
+	 */
+	public WrappingWriter(Writer out, int max)
+	{
+	    super(out);
+	    max_ = max;
+	}
+	@Override
+	public void write(int c) throws IOException
+	{
+	    if (++column_ > max_) {
+		column_ = 1;
+		out.write(NEWLINE);
+	    }
+	    out.write(c);
+	}
+	@Override
+	public void flush() throws IOException
+	{
+	    if (column_ != 0)
+		out.write(NEWLINE);
+	    column_ = 0;
+	    out.flush();
+	}
+	/*
+	 * We currently only use write(int), so we don't need to
+	 * redefine any other methods.
+	 */
+}
+//
+// Static data
+//
+private static final char ENCODE[] = {
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '+', '/'
+};
+private static final byte DECODE[] = new byte[256];
+static {
+	for (int i = 0; i < DECODE.length; i++) {
+	    DECODE[i] = (byte)-1;
+	}
+	for (int i = 0; i < ENCODE.length; i++) {
+	    DECODE[ENCODE[i]] = (byte)i;
+	}
+}
+private static final char CHAR_PAD = '=';
+//
+// Static methods
+//
+/**
+* Decodes the base64-encoded data on the given {@code InputStream} to the
+* given {@code OutputStream}.
+*
+* @exception   Base64Exception
+*		    if the given {@code InputStream} has invalid or insufficient
+*		    data
+*
+* @exception   IOException
+*		    if an I/O error ocurrs
+*/
+public static void decode(InputStream in, OutputStream out)
+	throws IOException {
+	// Total number of bytes read
+	int count = 0;
+	OUTER: while (true) {
+	    int pad = 0;
+	    int atom = 0;
+	    // Read in 4 characters (6 significant bits each)
+	    for (int i = 0; i < 4; i++) {
+		int b = in.read();
+		if (b == -1) {
+		    if (i == 0) {
+			break OUTER;
+		    }
+		    if (pad != 0) {
+			throw new Base64Exception(String.format(
+			    "expected '%c' at position %d, found EOS", CHAR_PAD,
+			    count));
+		    } else {
+			throw new Base64Exception(String.format(
+			    "unexpected EOS at position %d", count));
+		    }
+		// Ignore whitespace
+		} else if (Character.isWhitespace((char)b)) {
+		    i--;
+		    continue;
+		}
+		atom <<= 6;
+		if (b == CHAR_PAD) {
+		    // Pad chars can only be the 3rd or 4th char in the set
+		    if (i < 2) {
+			throw new Base64Exception(String.format(
+			    "invalid char at position %d: %s", count,
+			    getCharDescription((char)b)));
+		    }
+		    pad++;
+		} else if (pad != 0) {
+		    throw new Base64Exception(String.format(
+			"invalid char at position %d: %s (expected %s)", count,
+			getCharDescription((char)b),
+			getCharDescription(CHAR_PAD)));
+		} else {
+		    // InputStream.read guarantees -1 <= b <= 255
+		    int index = DECODE[b];
+		    if (index < 0 || index > 63) {
+			throw new Base64Exception(String.format(
+			    "invalid char at position %d: %s", count,
+			    getCharDescription((char)b)));
+		    }
+		    atom |= index;
+		}
+		count++;
+	    }
+	    // Output 3 8-bit bytes
+	    for (int i = 0; i < 3 - pad; i++) {
+		out.write((byte)((atom & 0x00FF0000) >>> 16));
+		atom <<= 8;
+	    }
+	}
+	out.flush();
+}
+public static byte[] decode(InputStream in)
+	throws IOException {
+	ByteArrayOutputStream out = new ByteArrayOutputStream();
+	decode(in, out);
+	return out.toByteArray();
+}
+public static void decode(String in, OutputStream out)
+	throws IOException {
+	ByteArrayInputStream bin =
+	    new ByteArrayInputStream(in.getBytes());
+	decode(bin, out);
+}
+public static byte[] decode(String in)
+	throws IOException {
+	ByteArrayOutputStream out = new ByteArrayOutputStream();
+	decode(in, out);
+	return out.toByteArray();
+}
+/**
+* Encodes the data on the given {@code InputStream} as base64 and writes it
+* to the given {@code Writer}.
+*
+* @exception   IOException
+*		    if an I/O error ocurrs
+*/
+public static void encode(InputStream in, Writer out)
+	throws IOException {
+	OUTER: while (true) {
+	    int pad = 0;
+	    int atom = 0;
+	    // Read in 3 8-bit bytes
+	    for (int i = 0; i < 3; i++) {
+		int b = in.read();
+		if (b == -1) {
+		    if (i == 0) {
+			break OUTER;
+		    }
+		    pad++;
+		} else {
+		    atom |= b;
+		}
+		atom <<= 8;
+	    }
+	    // Output 4 6-bit characters...
+	    for (int i = 0; i < 4 - pad; i++) {
+		int index = (atom & 0xFC000000) >>> 26;
+		out.write(ENCODE[index]);
+		atom <<= 6;
+	    }
+	    // ...plus any padding if 3 bytes couldn't be read
+	    for (int i = 0; i < pad; i++) {
+		out.write(CHAR_PAD);
+	    }
+	}
+	out.flush();
+}
+public static void encode(byte[] buffer, int offset, int len,
+	Writer out) throws IOException {
+	ByteArrayInputStream in =
+	    new ByteArrayInputStream(buffer, offset, len);
+	encode(in, out);
+}
+public static void encode(byte[] buffer, Writer out)
+	throws IOException {
+	encode(buffer, 0, buffer.length, out);
+}
+public static void encode(String s, Writer out)
+	throws IOException {
+	encode(s.getBytes(), out);
+}
+public static String encode(byte[] buffer, int offset, int len) {
+	StringWriter out = new StringWriter();
+	try {
+	    encode(buffer, offset, len, out);
+	    return out.toString();
+	} catch (IOException e) {
+	    // Not likely -- output is from a byte array to a String
+	}
+	return null;
+}
+public static String encode(byte[] buffer) {
+	return encode(buffer, 0, buffer.length);
+}
+public static String encode(String s) {
+	return encode(s.getBytes());
+}
+//
+// Private static methods
+//
+private static String getCharDescription(char c) {
+	String desc = "";
+	if (TextUtil.isPrintable(c)) {
+	    desc = String.format("'%c',", c);
+	}
+	desc += String.format("%d,0x%02x", (int)c, (int)c);
+	return desc;
+}
+}