Base64 Character encoder as specified in RFC1113
/*
* 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.
*/
/* $Id: Base64EncodeStream.java 447277 2006-09-18 06:19:34Z jeremias $ */
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
/**
* This class implements a Base64 Character encoder as specified in RFC1113.
* Unlike some other encoding schemes there is nothing in this encoding
* that indicates where a buffer starts or ends.
*
* This means that the encoded text will simply start with the first line
* of encoded text and end with the last line of encoded text.
*
* @author <a href="mailto:deweese@apache.org">Thomas DeWeese</a>
* @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
* @author Chuck McManis
* @version $Id: Base64EncodeStream.java 447277 2006-09-18 06:19:34Z jeremias $
*/
public class Base64EncodeStream extends OutputStream {
/** This array maps the 6 bit values to their characters */
private final static byte pem_array[] = {
// 0 1 2 3 4 5 6 7
'A','B','C','D','E','F','G','H', // 0
'I','J','K','L','M','N','O','P', // 1
'Q','R','S','T','U','V','W','X', // 2
'Y','Z','a','b','c','d','e','f', // 3
'g','h','i','j','k','l','m','n', // 4
'o','p','q','r','s','t','u','v', // 5
'w','x','y','z','0','1','2','3', // 6
'4','5','6','7','8','9','+','/' // 7
};
byte [] atom = new byte[3];
int atomLen = 0;
byte [] encodeBuf = new byte[4];
int lineLen = 0;
PrintStream out;
boolean closeOutOnClose;
public Base64EncodeStream(OutputStream out) {
this.out = new PrintStream(out);
closeOutOnClose = true;
}
public Base64EncodeStream(OutputStream out, boolean closeOutOnClose) {
this.out = new PrintStream(out);
this.closeOutOnClose = closeOutOnClose;
}
public void close () throws IOException {
if (out != null) {
encodeAtom();
out.flush();
if (closeOutOnClose)
out.close();
out=null;
}
}
/**
* This can't really flush out output since that may generate
* '=' chars which would indicate the end of the stream.
* Instead we flush out. You can only be sure all output is
* writen by closing this stream.
*/
public void flush() throws IOException {
out.flush();
}
public void write(int b) throws IOException {
atom[atomLen++] = (byte)b;
if (atomLen == 3)
encodeAtom();
}
public void write(byte []data) throws IOException {
encodeFromArray(data, 0, data.length);
}
public void write(byte [] data, int off, int len) throws IOException {
encodeFromArray(data, off, len);
}
/**
* enocodeAtom - Take three bytes of input and encode it as 4
* printable characters. Note that if the length in len is less
* than three is encodes either one or two '=' signs to indicate
* padding characters.
*/
void encodeAtom() throws IOException {
byte a, b, c;
switch (atomLen) {
case 0: return;
case 1:
a = atom[0];
encodeBuf[0] = pem_array[((a >>> 2) & 0x3F)];
encodeBuf[1] = pem_array[((a << 4) & 0x30)];
encodeBuf[2] = encodeBuf[3] = '=';
break;
case 2:
a = atom[0];
b = atom[1];
encodeBuf[0] = pem_array[((a >>> 2) & 0x3F)];
encodeBuf[1] = pem_array[(((a << 4) & 0x30) | ((b >>> 4) & 0x0F))];
encodeBuf[2] = pem_array[((b << 2) & 0x3C)];
encodeBuf[3] = '=';
break;
default:
a = atom[0];
b = atom[1];
c = atom[2];
encodeBuf[0] = pem_array[((a >>> 2) & 0x3F)];
encodeBuf[1] = pem_array[(((a << 4) & 0x30) | ((b >>> 4) & 0x0F))];
encodeBuf[2] = pem_array[(((b << 2) & 0x3C) | ((c >>> 6) & 0x03))];
encodeBuf[3] = pem_array[c & 0x3F];
}
if (lineLen == 64) {
out.println();
lineLen = 0;
}
out.write(encodeBuf);
lineLen += 4;
atomLen = 0;
}
/**
* enocodeAtom - Take three bytes of input and encode it as 4
* printable characters. Note that if the length in len is less
* than three is encodes either one or two '=' signs to indicate
* padding characters.
*/
void encodeFromArray(byte[] data, int offset, int len)
throws IOException{
byte a, b, c;
if (len == 0)
return;
// System.out.println("atomLen: " + atomLen +
// " len: " + len +
// " offset: " + offset);
if (atomLen != 0) {
switch(atomLen) {
case 1:
atom[1] = data[offset++]; len--; atomLen++;
if (len == 0) return;
atom[2] = data[offset++]; len--; atomLen++;
break;
case 2:
atom[2] = data[offset++]; len--; atomLen++;
break;
default:
}
encodeAtom();
}
while (len >=3) {
a = data[offset++];
b = data[offset++];
c = data[offset++];
encodeBuf[0] = pem_array[((a >>> 2) & 0x3F)];
encodeBuf[1] = pem_array[(((a << 4) & 0x30) | ((b >>> 4) & 0x0F))];
encodeBuf[2] = pem_array[(((b << 2) & 0x3C) | ((c >>> 6) & 0x03))];
encodeBuf[3] = pem_array[c & 0x3F];
out.write(encodeBuf);
lineLen += 4;
if (lineLen == 64) {
out.println();
lineLen = 0;
}
len -=3;
}
switch (len) {
case 1:
atom[0] = data[offset];
break;
case 2:
atom[0] = data[offset];
atom[1] = data[offset+1];
break;
default:
}
atomLen = len;
}
}