Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.apache.catalina.util;
 
This class provides encode/decode for RFC 2045 Base64 as defined by RFC 2045, N. Freed and N. Borenstein. RFC 2045: Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies. Reference 1996

Author(s):
Jeffrey Rodriguez
Version:
$Id: Base64.java 515 2008-03-17 21:02:23Z jfrederic.clere@jboss.com $
 
 public final class  Base64
 {
     static private final int  BASELENGTH         = 255;
     static private final int  LOOKUPLENGTH       = 64;
     static private final int  TWENTYFOURBITGROUP = 24;
     static private final int  EIGHTBIT           = 8;
     static private final int  SIXTEENBIT         = 16;
     static private final int  SIXBIT             = 6;
     static private final int  FOURBYTE           = 4;
     static private final int  SIGN               = -128;
     static private final byte PAD                = (byte'=';
     static private byte [] base64Alphabet       = new byte[];
     static private byte [] lookUpBase64Alphabet = new byte[];
     //static private final Log log = LogSource.getInstance("org.apache.commons.util.Base64");
 
     static
     {
         for (int i = 0; i < i++ )
         {
             [i] = -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'/';
     }
 
     public static boolean isBase64String isValidString )
     {
         return isArrayByteBase64(isValidString.getBytes());
     }
 
     public static boolean isBase64byte octect )
     {
         //shall we ignore white space? JEFF??
         return (octect ==  || [octect] != -1);
     }
 
     public static boolean isArrayByteBase64byte[] arrayOctect )
     {
         int length = arrayOctect.length;
         if (length == 0)
         {
             // shouldn't a 0 length array be valid base64 data?
            // return false;
            return true;
        }
        for (int i=0; i < lengthi++)
        {
            if ( !Base64.isBase64(arrayOctect[i]) )
                return false;
        }
        return true;
    }

    
Encodes hex octects into Base64.

Parameters:
binaryData Array containing binary data to encode.
Returns:
Base64-encoded data.
    public static byte[] encodebyte[] binaryData )
    {
        int      lengthDataBits    = binaryData.length*;
        int      fewerThan24bits   = lengthDataBits%;
        int      numberTriplets    = lengthDataBits/;
        byte     encodedData[]     = null;
        if (fewerThan24bits != 0)
        {
            //data not divisible by 24 bit
            encodedData = new byte[ (numberTriplets + 1 ) * 4 ];
        }
        else
        {
            // 16 or 8 bit
            encodedData = new bytenumberTriplets * 4 ];
        }
        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
        int encodedIndex = 0;
        int dataIndex   = 0;
        int i           = 0;
        //log.debug("number of triplets = " + numberTriplets);
        for ( i = 0; i<numberTripletsi++ )
        {
            dataIndex = i*3;
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            b3 = binaryData[dataIndex + 2];
            //log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3);
            l  = (byte)(b2 & 0x0f);
            k  = (byte)(b1 & 0x03);
            encodedIndex = i * 4;
            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 ];
            //log.debug( "val2 = " + val2 );
            //log.debug( "k4   = " + (k<<4) );
            //log.debug(  "vak  = " + (val2 | (k<<4)) );
            encodedData[encodedIndex+1] =
                val2 | ( k<<4 )];
            encodedData[encodedIndex+2] =
                [ (l <<2 ) | val3 ];
            encodedData[encodedIndex+3] = b3 & 0x3f ];
        }
        // form integral number of 6-bit groups
        dataIndex    = i*3;
        encodedIndex = i*4;
        if (fewerThan24bits ==  )
        {
            b1 = binaryData[dataIndex];
            k = (byte) ( b1 &0x03 );
            //log.debug("b1=" + b1);
            //log.debug("b1<<2 = " + (b1>>2) );
            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 encodedData;
    }

    
Decodes Base64 data into octects

Parameters:
base64DataBC Byte array containing Base64 data
decodedDataCC The decoded data chars
    public static void decodeByteChunk base64DataBCCharChunk decodedDataCC)
    {
        int start = base64DataBC.getStart();
        int end = base64DataBC.getEnd();
        byte[] base64Data = base64DataBC.getBuffer();
        
        decodedDataCC.recycle();
        
        // handle the edge case, so we don't have to worry about it later
        if(end - start == 0) { return; }
        int      numberQuadruple    = (end - start)/;
        byte     b1=0,b2=0,b3=0, b4=0, marker0=0, marker1=0;
        // Throw away anything not in base64Data
        int encodedIndex = 0;
        int dataIndex = start;
        char[] decodedData = null;
        
        {
            // this sizes the output array properly - rlw
            int lastData = end - start;
            // ignore the '=' padding
            while (base64Data[start+lastData-1] == )
            {
                if (--lastData == 0)
                {
                    return;
                }
            }
            decodedDataCC.allocate(lastData - numberQuadruple, -1);
            decodedDataCC.setEnd(lastData - numberQuadruple);
            decodedData = decodedDataCC.getBuffer();
        }
        for (int i = 0; i < numberQuadruplei++)
        {
            dataIndex = start + i * 4;
            marker0   = base64Data[dataIndex + 2];
            marker1   = base64Data[dataIndex + 3];
            b1 = [base64Data[dataIndex]];
            b2 = [base64Data[dataIndex +1]];
            if (marker0 !=  && marker1 != )
            {
                //No PAD e.g 3cQl
                b3 = marker0 ];
                b4 = marker1 ];
                decodedData[encodedIndex]   = (char) ((  b1 <<2 | b2>>4 ) & 0xff);
                decodedData[encodedIndex + 1] =
                    (char) ((((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ) & 0xff);
                decodedData[encodedIndex + 2] = (char) (( b3<<6 | b4 ) & 0xff);
            }
            else if (marker0 == )
            {
                //Two PAD e.g. 3c[Pad][Pad]
                decodedData[encodedIndex]   = (char) ((  b1 <<2 | b2>>4 ) & 0xff);
            }
            else if (marker1 == )
            {
                //One PAD e.g. 3cQ[Pad]
                b3 = marker0 ];
                decodedData[encodedIndex]   = (char) ((  b1 <<2 | b2>>4 ) & 0xff);
                decodedData[encodedIndex + 1] =
                    (char) ((((b2 & 0xf)<<4 ) |( (b3>>2) & 0xf) ) & 0xff);
            }
            encodedIndex += 3;
        }
    }
New to GrepCode? Check out our FAQ X