348 lines
15 KiB
Java
348 lines
15 KiB
Java
/*
|
|
Yaaic - Yet Another Android IRC Client
|
|
|
|
Copyright 2009-2013 Sebastian Kaspari
|
|
|
|
This file is part of Yaaic.
|
|
|
|
Yaaic 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Yaaic 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 Yaaic. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.yaaic.tools;
|
|
|
|
/**
|
|
* Encode bytes to Base64 notation.
|
|
*
|
|
* Modified/Shrinked version of the Base64 implementation
|
|
* by Robert Harder (http://iharder.net/base64) [Public Domain].
|
|
*
|
|
* @author Robert Harder
|
|
* @author rob@iharder.net
|
|
*/
|
|
public abstract class Base64
|
|
{
|
|
/** No options specified. Value is zero. */
|
|
private final static int NO_OPTIONS = 0;
|
|
|
|
/** Do break lines when encoding. Value is 8. */
|
|
private final static int DO_BREAK_LINES = 8;
|
|
|
|
/**
|
|
* Encode using Base64-like encoding that is URL- and Filename-safe as described
|
|
* in Section 4 of RFC3548:
|
|
* <a href="http://www.faqs.org/rfcs/rfc3548.html">http://www.faqs.org/rfcs/rfc3548.html</a>.
|
|
* It is important to note that data encoded this way is <em>not</em> officially valid Base64,
|
|
* or at the very least should not be called Base64 without also specifying that is
|
|
* was encoded using the URL- and Filename-safe dialect.
|
|
*/
|
|
private final static int URL_SAFE = 16;
|
|
|
|
/**
|
|
* Encode using the special "ordered" dialect of Base64 described here:
|
|
* <a href="http://www.faqs.org/qa/rfcc-1940.html">http://www.faqs.org/qa/rfcc-1940.html</a>.
|
|
*/
|
|
private final static int ORDERED = 32;
|
|
|
|
/** Maximum line length (76) of Base64 output. */
|
|
private final static int MAX_LINE_LENGTH = 76;
|
|
|
|
/** The equals sign (=) as a byte. */
|
|
private final static byte EQUALS_SIGN = (byte)'=';
|
|
|
|
/** The new line character (\n) as a byte. */
|
|
private final static byte NEW_LINE = (byte)'\n';
|
|
|
|
/** Preferred encoding. */
|
|
private final static String PREFERRED_ENCODING = "US-ASCII";
|
|
|
|
/** The 64 valid Base64 values. */
|
|
/* Host platform me be something funny like EBCDIC, so we hardcode these values. */
|
|
private final static byte[] _STANDARD_ALPHABET = {
|
|
(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
|
|
(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
|
|
(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
|
|
(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
|
|
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
|
|
(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
|
|
(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
|
|
(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
|
|
(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
|
|
(byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/'
|
|
};
|
|
|
|
/**
|
|
* Used in the URL- and Filename-safe dialect described in Section 4 of RFC3548:
|
|
* <a href="http://www.faqs.org/rfcs/rfc3548.html">http://www.faqs.org/rfcs/rfc3548.html</a>.
|
|
* Notice that the last two bytes become "hyphen" and "underscore" instead of "plus" and "slash."
|
|
*/
|
|
private final static byte[] _URL_SAFE_ALPHABET = {
|
|
(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
|
|
(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
|
|
(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
|
|
(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
|
|
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
|
|
(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
|
|
(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
|
|
(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
|
|
(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
|
|
(byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'-', (byte)'_'
|
|
};
|
|
|
|
/**
|
|
* I don't get the point of this technique, but someone requested it,
|
|
* and it is described here:
|
|
* <a href="http://www.faqs.org/qa/rfcc-1940.html">http://www.faqs.org/qa/rfcc-1940.html</a>.
|
|
*/
|
|
private final static byte[] _ORDERED_ALPHABET = {
|
|
(byte)'-',
|
|
(byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4',
|
|
(byte)'5', (byte)'6', (byte)'7', (byte)'8', (byte)'9',
|
|
(byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
|
|
(byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
|
|
(byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
|
|
(byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
|
|
(byte)'_',
|
|
(byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
|
|
(byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
|
|
(byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
|
|
(byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z'
|
|
};
|
|
|
|
/**
|
|
* Returns one of the _SOMETHING_ALPHABET byte arrays depending on
|
|
* the options specified.
|
|
* It's possible, though silly, to specify ORDERED <b>and</b> URLSAFE
|
|
* in which case one of them will be picked, though there is
|
|
* no guarantee as to which one will be picked.
|
|
*/
|
|
private final static byte[] getAlphabet( int options ) {
|
|
if ((options & URL_SAFE) == URL_SAFE) {
|
|
return _URL_SAFE_ALPHABET;
|
|
} else if ((options & ORDERED) == ORDERED) {
|
|
return _ORDERED_ALPHABET;
|
|
} else {
|
|
return _STANDARD_ALPHABET;
|
|
}
|
|
} // end getAlphabet
|
|
|
|
/**
|
|
* <p>Encodes up to three bytes of the array <var>source</var>
|
|
* and writes the resulting four Base64 bytes to <var>destination</var>.
|
|
* The source and destination arrays can be manipulated
|
|
* anywhere along their length by specifying
|
|
* <var>srcOffset</var> and <var>destOffset</var>.
|
|
* This method does not check to make sure your arrays
|
|
* are large enough to accomodate <var>srcOffset</var> + 3 for
|
|
* the <var>source</var> array or <var>destOffset</var> + 4 for
|
|
* the <var>destination</var> array.
|
|
* The actual number of significant bytes in your array is
|
|
* given by <var>numSigBytes</var>.</p>
|
|
* <p>This is the lowest level of the encoding methods with
|
|
* all possible parameters.</p>
|
|
*
|
|
* @param source the array to convert
|
|
* @param srcOffset the index where conversion begins
|
|
* @param numSigBytes the number of significant bytes in your array
|
|
* @param destination the array to hold the conversion
|
|
* @param destOffset the index where output will be put
|
|
* @return the <var>destination</var> array
|
|
* @since 1.3
|
|
*/
|
|
private static byte[] encode3to4(
|
|
byte[] source, int srcOffset, int numSigBytes,
|
|
byte[] destination, int destOffset, int options ) {
|
|
|
|
byte[] ALPHABET = getAlphabet( options );
|
|
|
|
// 1 2 3
|
|
// 01234567890123456789012345678901 Bit position
|
|
// --------000000001111111122222222 Array position from threeBytes
|
|
// --------| || || || | Six bit groups to index ALPHABET
|
|
// >>18 >>12 >> 6 >> 0 Right shift necessary
|
|
// 0x3f 0x3f 0x3f Additional AND
|
|
|
|
// Create buffer with zero-padding if there are only one or two
|
|
// significant bytes passed in the array.
|
|
// We have to shift left 24 in order to flush out the 1's that appear
|
|
// when Java treats a value as negative that is cast from a byte to an int.
|
|
int inBuff = ( numSigBytes > 0 ? ((source[ srcOffset ] << 24) >>> 8) : 0 )
|
|
| ( numSigBytes > 1 ? ((source[ srcOffset + 1 ] << 24) >>> 16) : 0 )
|
|
| ( numSigBytes > 2 ? ((source[ srcOffset + 2 ] << 24) >>> 24) : 0 );
|
|
|
|
switch( numSigBytes )
|
|
{
|
|
case 3:
|
|
destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
|
|
destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
|
|
destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];
|
|
destination[ destOffset + 3 ] = ALPHABET[ (inBuff ) & 0x3f ];
|
|
return destination;
|
|
|
|
case 2:
|
|
destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
|
|
destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
|
|
destination[ destOffset + 2 ] = ALPHABET[ (inBuff >>> 6) & 0x3f ];
|
|
destination[ destOffset + 3 ] = EQUALS_SIGN;
|
|
return destination;
|
|
|
|
case 1:
|
|
destination[ destOffset ] = ALPHABET[ (inBuff >>> 18) ];
|
|
destination[ destOffset + 1 ] = ALPHABET[ (inBuff >>> 12) & 0x3f ];
|
|
destination[ destOffset + 2 ] = EQUALS_SIGN;
|
|
destination[ destOffset + 3 ] = EQUALS_SIGN;
|
|
return destination;
|
|
|
|
default:
|
|
return destination;
|
|
} // end switch
|
|
} // end encode3to4
|
|
|
|
/**
|
|
* Encodes a byte array into Base64 notation.
|
|
* Does not GZip-compress data.
|
|
*
|
|
* @param source The data to convert
|
|
* @return The data in Base64-encoded form
|
|
* @throws NullPointerException if source array is null
|
|
* @since 1.4
|
|
*/
|
|
public static String encodeBytes( byte[] source ) {
|
|
// Since we're not going to have the GZIP encoding turned on,
|
|
// we're not going to have an java.io.IOException thrown, so
|
|
// we should not force the user to have to catch it.
|
|
String encoded = null;
|
|
try {
|
|
encoded = encodeBytes(source, 0, source.length, NO_OPTIONS);
|
|
} catch (java.io.IOException ex) {
|
|
assert false : ex.getMessage();
|
|
} // end catch
|
|
assert encoded != null;
|
|
return encoded;
|
|
}
|
|
|
|
/**
|
|
* Encodes a byte array into Base64 notation.
|
|
*
|
|
* @param source The data to convert
|
|
* @param off Offset in array where conversion should begin
|
|
* @param len Length of data to convert
|
|
* @param options Specified options
|
|
* @return The Base64-encoded data as a String
|
|
* @see Base64#GZIP
|
|
* @see Base64#DO_BREAK_LINES
|
|
* @throws java.io.IOException if there is an error
|
|
* @throws NullPointerException if source array is null
|
|
* @throws IllegalArgumentException if source array, offset, or length are invalid
|
|
* @since 2.0
|
|
*/
|
|
public static String encodeBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {
|
|
byte[] encoded = encodeBytesToBytes( source, off, len, options );
|
|
|
|
// Return value according to relevant encoding.
|
|
try {
|
|
return new String( encoded, PREFERRED_ENCODING );
|
|
} // end try
|
|
catch (java.io.UnsupportedEncodingException uue) {
|
|
return new String( encoded );
|
|
} // end catch
|
|
}
|
|
|
|
/**
|
|
* Similar to {@link #encodeBytes(byte[], int, int, int)} but returns
|
|
* a byte array instead of instantiating a String. This is more efficient
|
|
* if you're working with I/O streams and have large data sets to encode.
|
|
*
|
|
*
|
|
* @param source The data to convert
|
|
* @param off Offset in array where conversion should begin
|
|
* @param len Length of data to convert
|
|
* @param options Specified options
|
|
* @return The Base64-encoded data as a String
|
|
* @see Base64#GZIP
|
|
* @see Base64#DO_BREAK_LINES
|
|
* @throws java.io.IOException if there is an error
|
|
* @throws NullPointerException if source array is null
|
|
* @throws IllegalArgumentException if source array, offset, or length are invalid
|
|
* @since 2.3.1
|
|
*/
|
|
public static byte[] encodeBytesToBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {
|
|
|
|
if( source == null ){
|
|
throw new NullPointerException( "Cannot serialize a null array." );
|
|
} // end if: null
|
|
|
|
if( off < 0 ){
|
|
throw new IllegalArgumentException( "Cannot have negative offset: " + off );
|
|
} // end if: off < 0
|
|
|
|
if( len < 0 ){
|
|
throw new IllegalArgumentException( "Cannot have length offset: " + len );
|
|
} // end if: len < 0
|
|
|
|
if( off + len > source.length ){
|
|
throw new IllegalArgumentException(
|
|
String.format( "Cannot have offset of %d and length of %d with array of length %d", off,len,source.length));
|
|
} // end if: off < 0
|
|
|
|
boolean breakLines = (options & DO_BREAK_LINES) != 0;
|
|
|
|
//int len43 = len * 4 / 3;
|
|
//byte[] outBuff = new byte[ ( len43 ) // Main 4:3
|
|
// + ( (len % 3) > 0 ? 4 : 0 ) // Account for padding
|
|
// + (breakLines ? ( len43 / MAX_LINE_LENGTH ) : 0) ]; // New lines
|
|
// Try to determine more precisely how big the array needs to be.
|
|
// If we get it right, we don't have to do an array copy, and
|
|
// we save a bunch of memory.
|
|
int encLen = ( len / 3 ) * 4 + ( len % 3 > 0 ? 4 : 0 ); // Bytes needed for actual encoding
|
|
if( breakLines ){
|
|
encLen += encLen / MAX_LINE_LENGTH; // Plus extra newline characters
|
|
}
|
|
byte[] outBuff = new byte[ encLen ];
|
|
|
|
int d = 0;
|
|
int e = 0;
|
|
int len2 = len - 2;
|
|
int lineLength = 0;
|
|
for( ; d < len2; d+=3, e+=4 ) {
|
|
encode3to4( source, d+off, 3, outBuff, e, options );
|
|
|
|
lineLength += 4;
|
|
if( breakLines && lineLength >= MAX_LINE_LENGTH )
|
|
{
|
|
outBuff[e+4] = NEW_LINE;
|
|
e++;
|
|
lineLength = 0;
|
|
} // end if: end of line
|
|
} // en dfor: each piece of array
|
|
|
|
if( d < len ) {
|
|
encode3to4( source, d+off, len - d, outBuff, e, options );
|
|
e += 4;
|
|
} // end if: some padding needed
|
|
|
|
// Only resize array if we didn't guess it right.
|
|
if( e <= outBuff.length - 1 ){
|
|
// If breaking lines and the last byte falls right at
|
|
// the line length (76 bytes per line), there will be
|
|
// one extra byte, and the array will need to be resized.
|
|
// Not too bad of an estimate on array size, I'd say.
|
|
byte[] finalOut = new byte[e];
|
|
System.arraycopy(outBuff,0, finalOut,0,e);
|
|
//System.err.println("Having to resize array from " + outBuff.length + " to " + e );
|
|
return finalOut;
|
|
} else {
|
|
//System.err.println("No need to resize array.");
|
|
return outBuff;
|
|
}
|
|
}
|
|
} |