/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.codehaus.groovy.runtime;
import groovy.lang.StringWriterIOException;
import groovy.lang.Writable;
import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;
import java.io.IOException;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import static org.codehaus.groovy.runtime.EncodingGroovyMethodsSupport.TRANSLATE_TABLE;
import static org.codehaus.groovy.runtime.EncodingGroovyMethodsSupport.TRANSLATE_TABLE_URLSAFE;
/**
* This class defines all the encoding/decoding groovy methods which enhance
* the normal JDK classes when inside the Groovy environment.
* Static methods are used with the first parameter the destination class.
*/
public class EncodingGroovyMethods {
private static final char[] T_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();
private static final char[] T_TABLE_URLSAFE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=".toCharArray();
private static final String CHUNK_SEPARATOR = "\r\n";
/**
* Produce a Writable object which writes the Base64 encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 encoding and chunking see <code>RFC 4648</code>.
*
* @param data Byte array to be encoded
* @param chunked whether or not the Base64 encoded data should be MIME chunked
* @return object which will write the Base64 encoding of the byte array
* @since 1.5.1
*/
public static Writable encodeBase64(Byte[] data, final boolean chunked) {
return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), chunked);
}
/**
* Produce a Writable object which writes the Base64 encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 encoding and chunking see <code>RFC 4648</code>.
*
* @param data Byte array to be encoded
* @return object which will write the Base64 encoding of the byte array
* @since 1.0
*/
public static Writable encodeBase64(Byte[] data) {
return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), false);
}
/**
* Produce a Writable object which writes the Base64 encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 encoding and chunking see <code>RFC 4648</code>.
*
* @param data byte array to be encoded
* @param chunked whether or not the Base64 encoded data should be MIME chunked
* @return object which will write the Base64 encoding of the byte array
* @since 1.5.7
*/
public static Writable encodeBase64(final byte[] data, final boolean chunked) {
return encodeBase64(data, chunked, false, true);
}
private static Writable encodeBase64(final byte[] data, final boolean chunked, final boolean urlSafe, final boolean pad) {
return new Writable() {
public Writer writeTo(final Writer writer) throws IOException {
int charCount = 0;
final int dLimit = (data.length / 3) * 3;
final char[] table = urlSafe ? T_TABLE_URLSAFE : T_TABLE;
for (int dIndex = 0; dIndex != dLimit; dIndex += 3) {
int d = ((data[dIndex] & 0XFF) << 16) | ((data[dIndex + 1] & 0XFF) << 8) | (data[dIndex + 2] & 0XFF);
writer.write(table[d >> 18]);
writer.write(table[(d >> 12) & 0X3F]);
writer.write(table[(d >> 6) & 0X3F]);
writer.write(table[d & 0X3F]);
if (chunked && ++charCount == 19) {
writer.write(CHUNK_SEPARATOR);
charCount = 0;
}
}
if (dLimit != data.length) {
int d = (data[dLimit] & 0XFF) << 16;
if (dLimit + 1 != data.length) {
d |= (data[dLimit + 1] & 0XFF) << 8;
}
writer.write(table[d >> 18]);
writer.write(table[(d >> 12) & 0X3F]);
if (pad) {
writer.write((dLimit + 1 < data.length) ? table[(d >> 6) & 0X3F] : '=');
writer.write('=');
} else {
if (dLimit + 1 < data.length) {
writer.write(table[(d >> 6) & 0X3F]);
}
}
if (chunked && charCount != 0) {
writer.write(CHUNK_SEPARATOR);
}
}
return writer;
}
public String toString() {
StringWriter buffer = new StringWriter();
try {
writeTo(buffer);
} catch (IOException e) {
throw new StringWriterIOException(e);
}
return buffer.toString();
}
};
}
/**
* Produce a Writable object which writes the Base64 encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 encoding and chunking see <code>RFC 4648</code>.
*
* @param data byte array to be encoded
* @return object which will write the Base64 encoding of the byte array
* @since 1.0
*/
public static Writable encodeBase64(final byte[] data) {
return encodeBase64(data, false);
}
/**
* Produce a Writable object which writes the Base64 URL and Filename Safe encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 URL and Filename Safe encoding see <code>RFC 4648 - Section 5
* Base 64 Encoding with URL and Filename Safe Alphabet</code>.
* <p>
* The method omits padding and is equivalent to calling
* {@link org.codehaus.groovy.runtime.EncodingGroovyMethods#encodeBase64Url(Byte[], boolean)} with a
* value of {@code false}.
*
* @param data Byte array to be encoded
* @return object which will write the Base64 URL and Filename Safe encoding of the byte array
* @see org.codehaus.groovy.runtime.EncodingGroovyMethods#encodeBase64Url(Byte[], boolean)
* @since 2.5
*/
public static Writable encodeBase64Url(Byte[] data) {
return encodeBase64Url(data, false);
}
/**
* Produce a Writable object which writes the Base64 URL and Filename Safe encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 URL and Filename Safe encoding see <code>RFC 4648 - Section 5
* Base 64 Encoding with URL and Filename Safe Alphabet</code>.
*
* @param data Byte array to be encoded
* @param pad whether or not the encoded data should be padded
* @return object which will write the Base64 URL and Filename Safe encoding of the byte array
* @since 2.5
*/
public static Writable encodeBase64Url(Byte[] data, boolean pad) {
return encodeBase64Url(DefaultTypeTransformation.convertToByteArray(data), pad);
}
/**
* Produce a Writable object which writes the Base64 URL and Filename Safe encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 URL and Filename Safe encoding see <code>RFC 4648 - Section 5
* Base 64 Encoding with URL and Filename Safe Alphabet</code>.
* <p>
* The method omits padding and is equivalent to calling
* {@link org.codehaus.groovy.runtime.EncodingGroovyMethods#encodeBase64Url(byte[], boolean)} with a
* value of {@code false}.
*
* @param data Byte array to be encoded
* @return object which will write the Base64 URL and Filename Safe encoding of the byte array
* @see org.codehaus.groovy.runtime.EncodingGroovyMethods#encodeBase64Url(byte[], boolean)
* @since 2.5
*/
public static Writable encodeBase64Url(final byte[] data) {
return encodeBase64Url(data, false);
}
/**
* Produce a Writable object which writes the Base64 URL and Filename Safe encoding of the byte array.
* Calling toString() on the result returns the encoding as a String. For more
* information on Base64 URL and Filename Safe encoding see <code>RFC 4648 - Section 5
* Base 64 Encoding with URL and Filename Safe Alphabet</code>.
*
* @param data Byte array to be encoded
* @param pad whether or not the encoded data should be padded
* @return object which will write the Base64 URL and Filename Safe encoding of the byte array
* @since 2.5
*/
public static Writable encodeBase64Url(final byte[] data, final boolean pad) {
return encodeBase64(data, false, true, pad);
}
/**
* Decode the String from Base64 into a byte array.
*
* @param value the string to be decoded
* @return the decoded bytes as an array
* @since 1.0
*/
public static byte[] decodeBase64(String value) {
return decodeBase64(value, false);
}
/**
* Decodes a Base64 URL and Filename Safe encoded String into a byte array.
*
* @param value the string to be decoded
* @return the decoded bytes as an array
* @since 2.5
*/
public static byte[] decodeBase64Url(String value) {
return decodeBase64(value, true);
}
private static byte[] decodeBase64(String value, boolean urlSafe) {
int byteShift = 4;
int tmp = 0;
boolean done = false;
final StringBuilder buffer = new StringBuilder();
final byte[] table = urlSafe ? TRANSLATE_TABLE_URLSAFE : TRANSLATE_TABLE;
for (int i = 0; i != value.length(); i++) {
final char c = value.charAt(i);
final int sixBit = (c < 123) ? table[c] : 66;
if (sixBit < 64) {
if (done)
throw new RuntimeException("= character not at end of base64 value"); // TODO: change this exception type
tmp = (tmp << 6) | sixBit;
if (byteShift-- != 4) {
buffer.append((char) ((tmp >> (byteShift * 2)) & 0XFF));
}
} else if (sixBit == 64) {
byteShift--;
done = true;
} else if (sixBit == 66) {
// RFC 2045 says that I'm allowed to take the presence of
// these characters as evidence of data corruption
// So I will
throw new RuntimeException("bad character in base64 value"); // TODO: change this exception type
}
if (byteShift == 0) byteShift = 4;
}
try {
return buffer.toString().getBytes("ISO-8859-1");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("Base 64 decode produced byte values > 255"); // TODO: change this exception type
}
}
/**
* Produces a Writable that writes the hex encoding of the Byte[]. Calling
* toString() on this Writable returns the hex encoding as a String. The hex
* encoding includes two characters for each byte and all letters are lower case.
*
* @param data byte array to be encoded
* @return object which will write the hex encoding of the byte array
* @see Integer#toHexString(int)
*/
public static Writable encodeHex(final Byte[] data) {
return encodeHex(DefaultTypeTransformation.convertToByteArray(data));
}
/**
* Produces a Writable that writes the hex encoding of the byte[]. Calling
* toString() on this Writable returns the hex encoding as a String. The hex
* encoding includes two characters for each byte and all letters are lower case.
*
* @param data byte array to be encoded
* @return object which will write the hex encoding of the byte array
* @see Integer#toHexString(int)
*/
public static Writable encodeHex(final byte[] data) {
return new Writable() {
public Writer writeTo(Writer out) throws IOException {
for (int i = 0; i < data.length; i++) {
// convert byte into unsigned hex string
String hexString = Integer.toHexString(data[i] & 0xFF);
// add leading zero if the length of the string is one
if (hexString.length() < 2) {
out.write("0");
}
// write hex string to writer
out.write(hexString);
}
return out;
}
public String toString() {
StringWriter buffer = new StringWriter();
try {
writeTo(buffer);
} catch (IOException e) {
throw new StringWriterIOException(e);
}
return buffer.toString();
}
};
}
/**
* Decodes a hex string to a byte array. The hex string can contain either upper
* case or lower case letters.
*
* @param value string to be decoded
* @return decoded byte array
* @throws NumberFormatException If the string contains an odd number of characters
* or if the characters are not valid hexadecimal values.
*/
public static byte[] decodeHex(final String value) {
// if string length is odd then throw exception
if (value.length() % 2 != 0) {
throw new NumberFormatException("odd number of characters in hex string");
}
byte[] bytes = new byte[value.length() / 2];
for (int i = 0; i < value.length(); i += 2) {
bytes[i / 2] = (byte) Integer.parseInt(value.substring(i, i + 2), 16);
}
return bytes;
}
}