Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program 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 Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.util;
 
 
 
 public class Base64 {
    
true create base64
 
     private final boolean encoder;
     private final byte[] srcBuffer;
     private final byte[] destBuffer;
     
     public Base64(boolean encoder) {
         this(encoder, 1024);
     }
 
     public Base64(boolean encoderint bufferSizeBase) {
         int bufferSize;
         
         if (bufferSizeBase < 1) {
             throw new IllegalArgumentException("" + bufferSizeBase);
         }
         bufferSize = bufferSizeBase * ;
         this. = encoder;
         if (encoder) {
             this. = new byte[bufferSize];
             this. = new byte[toInt(encodedLength(bufferSize))];
         } else {
             this. = new byte[toInt(encodedLength(bufferSize))];
             this. = new byte[bufferSize];
         }
     }
 
     private static int toInt(long l) {
         int i;
         
         i = (intl;
         if (i != l) {
             throw new IllegalArgumentException("" + l);
         }
         return i;
     }
     
     public String run(String str) {
         try {
             return run(str.);
         } catch (UnsupportedEncodingException e) {
             throw new IllegalStateException(e);
         }
     }
 
     public String run(String strString encodingthrows UnsupportedEncodingException {
         return new String(run(str.getBytes(encoding)), encoding);
     }
     
     public byte[] run(byte ... bytes) {
         return run(bytes, 0, bytes.length);
     }
     
     public byte[] run(byte[] bytesint ofsint len) {
         ByteArrayOutputStream dest;
         
         dest = new ByteArrayOutputStream();
         try {
             run(new ByteArrayInputStream(bytesofslen), dest);
         } catch (IOException e) {
             throw new IllegalStateException(e);
         }
         return dest.toByteArray();
     }
     
     public long run(InputStream srcOutputStream destthrows IOException {
         return run(srcdest.);
     }
    
    

Returns:
number of bytes actually written
 
     public long run(InputStream srcOutputStream destlong maxSrcLengththrows IOException {
        int srcCount;
        int destCount;
        long destLength// toal length
        long remaining;
        
        destLength = 0;
        remaining = maxSrcLength;
        while (true) {
            srcCount = read(src, (int) Math.min(.remaining));
            if (srcCount == 0) {
                break;
            }
            destCount = encode(srcCount) : decode(srcCount);
            dest.write(, 0, destCount);
            destLength += destCount;
            remaining -= srcCount;
        }
        return destLength;
    }
    //--
    
    
Make sure the buffer is filled as much as possible, even if the input stream delivers smaller chunks

Returns:
number of bytes actually read
    public static int read(InputStream srcbyte[] destint lenthrows IOException {
        int ofs;
        int count;
        
        for (ofs = 0; ofs < lenofs += count) {
            count = src.read(destofslen - ofs);
            if (count <= 0) {
                break;
            }
        }
        return ofs;
    }
    
    //--
    public static long encodedLength(long decodedLength) {
        long bits = decodedLength * ;
        long triplets = bits / ;
        if (bits %  != 0) {
            return (triplets + 1) * 4;
        } else {
            return triplets * 4;
        }
    }
    
    //-- 
    //  The following is copied from commons-codec-1.3. Modifications: 
    //  o removed chunking support
    //  o removed interfaces
    //  o reduced memory consumption

    
The base length.
    private static final int BASELENGTH = 255;

    
Lookup length.
    private static final int LOOKUPLENGTH = 64;

    
Used to calculate the number of bits in a byte.
    private static final int EIGHTBIT = 8;

    
Used when encoding something which has fewer than 24 bits.
    private static final int SIXTEENBIT = 16;

    
Used to determine how many bits data contains.
    private static final int TWENTYFOURBITGROUP = 24;


    
Used to test the sign of a byte.
    private static final int SIGN = -128;
    
    
Byte used to pad output.
    private static final byte PAD = (byte'=';
    
    private static final int TRIPPLET_BYTES =  / ;
    
    // Create arrays to hold the base64 characters and a 
    // lookup for base64 chars
    private static final byte[] base64Alphabet = new byte[];
    private static final byte[] lookUpBase64Alphabet = new byte[];
    // Populating the lookup and character arrays
    static {
        for (int i = 0; i < i++) {
            [i] = (byte) -1;
        }
        for (int i = 'Z'i >= 'A'i--) {
            [i] = (byte) (i - 'A');
        }
        for (int i = 'z'i >= 'a'i--) {
            [i] = (byte) (i - 'a' + 26);
        }
        for (int i = '9'i >= '0'i--) {
            [i] = (byte) (i - '0' + 52);
        }
        ['+'] = 62;
        ['/'] = 63;
        for (int i = 0; i <= 25; i++) {
            [i] = (byte) ('A' + i);
        }
        for (int i = 26, j = 0; i <= 51; i++, j++) {
            [i] = (byte) ('a' + j);
        }
        for (int i = 52, j = 0; i <= 61; i++, j++) {
            [i] = (byte) ('0' + j);
        }
        [62] = (byte'+';
        [63] = (byte'/';
    }
    private static boolean isBase64(byte octect) {
        return octect ==  || [octect] != -1;
    }

    
Encodes binary data using the base64 algorithm, no chunking.

Parameters:
binaryData Array containing binary data to encode.
binaryDataLength number of bytes in binaryData.
encodedData Array receiving encoded data.
Returns:
encoded data length
    public static int encode(byte[] binaryDataint binaryDataLengthbyte[] encodedData) {
        int lengthDataBits = binaryDataLength * ;
        int fewerThan24bits = lengthDataBits % ;
        int numberTriplets = lengthDataBits / ;
        int encodedDataLength;
        if (fewerThan24bits != 0) {
            //data not divisible by 24 bit
            encodedDataLength = (numberTriplets + 1) * 4;
        } else {
            // 16 or 8 bit
            encodedDataLength = numberTriplets * 4;
        }
        if (encodedDataLength > encodedData.length) {
            throw new IllegalArgumentException(encodedDataLength + ">" + encodedData.length);
        }
        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        int i;
        for (i = 0; i < numberTripletsi++) {
            dataIndex = i * 3;
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            b3 = binaryData[dataIndex + 2];
            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);
            byte val1 =
                ((b1 & ) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 =
                ((b2 & ) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
            byte val3 =
                ((b3 & ) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
            encodedData[encodedIndex] = [val1];
            encodedData[encodedIndex + 1] = [val2 | (k << 4)];
            encodedData[encodedIndex + 2] = [(l << 2) | val3];
            encodedData[encodedIndex + 3] = [b3 & 0x3f];
            encodedIndex += 4;
        }
        // form integral number of 6-bit groups
        dataIndex = i * 3;
        if (fewerThan24bits == ) {
            b1 = binaryData[dataIndex];
            k = (byte) (b1 & 0x03);
            byte val1 =
                ((b1 & ) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            encodedData[encodedIndex] = [val1];
            encodedData[encodedIndex + 1] = [k << 4];
            encodedData[encodedIndex + 2] = ;
            encodedData[encodedIndex + 3] = ;
        } else if (fewerThan24bits == ) {
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);
            byte val1 = ((b1 & ) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & ) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
            encodedData[encodedIndex] = [val1];
            encodedData[encodedIndex + 1] = [val2 | (k << 4)];
            encodedData[encodedIndex + 2] = [l << 2];
            encodedData[encodedIndex + 3] = ;
        }
        return encodedDataLength;
    }

    
Decodes Base64 data into octects

Parameters:
encoded Byte array containing Base64 data
encodedLength number of bytes in base64Data
binary Array containing decoded data.
Returns:
binary data length
    public static int decode(byte[] encodedint encodedLengthbyte[] binary) {
        byte b1b2b3b4marker0marker1;
        int binaryIndex;
        int encodedIndex;
        
        encodedLength = discardNonBase64(encodedencodedLength);
        encodedIndex = 0;
        binaryIndex = 0;
        while (encodedIndex < encodedLength) {
            b1 = [encoded[encodedIndex++]];
            b2 = [encoded[encodedIndex++]];
            marker0 = encoded[encodedIndex++];
            marker1 = encoded[encodedIndex++];
            if (marker0 == ) {
                // two PAD e.g. 3c[Pad][Pad]
                if (marker1 != ) {
                    throw new IllegalArgumentException();
                }
                binary[binaryIndex] = (byte) (b1 << 2 | b2 >> 4);
                binaryIndex += 1;
                if (encodedIndex != encodedLength) {
                    throw new IllegalStateException();
                }
            } else if (marker1 == ) {
                // one PAD e.g. 3cQ[Pad]
                b3 = [marker0];
            
                binary[binaryIndex] = (byte) (b1 << 2 | b2 >> 4);
                binary[binaryIndex + 1] =
                (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                binaryIndex += 2;
                if (encodedIndex != encodedLength) {
                    throw new IllegalStateException();
                }
            } else {
                // no PAD e.g 3cQl
                b3 = [marker0];
                b4 = [marker1];
                
                binary[binaryIndex] = (byte) (b1 << 2 | b2 >> 4);
                binary[binaryIndex + 1] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                binary[binaryIndex + 2] = (byte) (b3 << 6 | b4);
                binaryIndex += 3;
            } 
        }
        return binaryIndex;
    }
    
    
Discards any characters outside of the base64 alphabet, per the requirements on page 25 of RFC 2045 - "Any characters outside of the base64 alphabet are to be ignored in base64 encoded data."

Parameters:
data The base-64 encoded data to groom
Returns:
number of bytes in groomed data.
    static int discardNonBase64(byte[] dataint length) {
        int dest = 0;
        for (int i = 0; i < lengthi++) {
            if (isBase64(data[i])) {
                data[dest++] = data[i];
            }
        }
        return dest;
    }
New to GrepCode? Check out our FAQ X