Find Usages Diff Raw Download HTML Widget
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. 
18
 
19
 
20
 package org.apache.cxf.common.util;

Base64Utility - this static class provides useful base64 encoding utilities.

Author(s):
Darach Ennis
Craig Ryan
28
 
29
 
30
 // Java imports
33
 import java.io.Writer;
35
 
This class converts to/from base64. The alternative conversions include: encode: byte[] into String byte[] into char[] byte[] into OutStream byte[] into Writer decode: char[] into byte[] String into byte[] char[] into OutStream String into OutStream 
54
 
55
 public final class Base64Utility {
56
     
57
     private static final Logger LOG = LogUtils.getL7dLogger(Base64Utility.class);
58
 
59
     
60
     // base 64 character set
61
     //
62
     private static final char[] BCS = {
63
         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
64
         'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 
65
         'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 
66
         'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 
67
         'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 
68
         'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', 
69
         '8', '9', '+', '/'
70
     };
71
 
72
     // base 64 wadding
73
     private static final char PAD = '=';
74
 
75
     // size of base 64 decode table
76
     private static final int BDTSIZE = 128;
77
 
78
     // base 64 decode table  
79
     private static final byte[] BDT = new byte[128];
80
 
81
     
82
     private static final int PAD_SIZE0 = 1;
83
     private static final int PAD_SIZE4 = 2;
84
     private static final int PAD_SIZE8 = 3;
85
     
86
     // class static intializer for building decode table
87
     static {
88
         for (int i = 0;  i < ;  i++) {
89
             [i] = .;
90
         }
91
 
92
         for (int i = 0;  i < .;  i++) {
93
             [[i]] = (byte)i;
94
         }
95
     }
96
     
97
     
98
     private Base64Utility() {
99
         //utility class, never constructed
100
    }
    
    
The decode_chunk routine decodes a chunk of data into its native encoding. base64 encodes each 3 octets of data into 4 characters from a limited 64 character set. The 3 octets are joined to form 24 bits which are then split into 4 x 6bit values. Each 6 bit value is then used as an index into the 64 character table of base64 chars. If the total data length is not a 3 octet multiple the '=' char is used as padding for the final 4 char group, either 1 octet + '==' or 2 octets + '='.

Parameters:
id The input data to be processed
o The offset from which to begin processing
l The length (bound) at which processing is to end
Returns:
The decoded data
Throws:
Base64Exception Thrown is processing fails due to formatting exceptions in the encoded data
121
    public static byte[] decodeChunk(char[] id,
122
                                     int o,
123
                                     int l) 
124
        throws Base64Exception {
125
        
126
        // Keep it simple - must be >= 4. Unpadded
127
        // base64 data contain < 3 octets is invalid.
128
        //
129
        if ((l - o) < 4) {
130
            return null;
131
        }
133
        char[] ib = new char[4];
134
        int ibcount = 0;
136
        // cryan. Calc the num of octets. Each 4 chars of base64 chars
137
        // (representing 24 bits) encodes 3 octets. 
138
        //
139
        int octetCount = 3 * (l / 4);
141
        // Final 4 chars may contain 3 octets or padded to contain
142
        // 1 or 2 octets.
143
        //
144
        if (id[l - 1] == ) {
145
            // TT== means last 4 chars encode 8 bits (ie subtract 2)
146
            // TTT= means last 4 chars encode 16 bits (ie subtract 1)
147
            octetCount -= (id[l - 2] == ) ? 2 : 1;
148
        }
150
        byte[] ob = new byte[octetCount];
151
        int obcount = 0;
153
        for (int i = o;  i < o + l && i < id.length;  i++) {
154
            if (id[i] == 
155
                || id[i] < .
156
                && [id[i]] != .) {
157
                
158
                ib[ibcount++] = id[i];
160
                // Decode each 4 char sequence.
161
                //
162
                if (ibcount == ib.length) {
163
                    ibcount = 0;
164
                    obcount += processEncodeme(ib, ob, obcount);
165
                }
166
            }
167
        }
168
        
169
        if (obcount != ob.length) {
170
            byte []tmp = new byte[obcount];
171
            System.arraycopy(ob, 0, tmp, 0, obcount);
172
            ob = tmp;
173
        }
175
        return ob;
176
    }
178
    public static byte[] decode(String id) throws Base64Exception {
179
        char[] cd = id.toCharArray();
180
        return decodeChunk(cd, 0, cd.length);
181
    }
183
    public static void decode(char[] id,
184
                             int o,
185
                             int l,
186
                             OutputStream ostream) 
187
        throws Base64Exception {
189
        try {
190
            ostream.write(decodeChunk(id, o, l));
191
        } catch (IOException e) {
192
            // convert exception to Base64Exception
193
            throw new Base64Exception(new Message("BASE64_RUNTIME_EXCEPTION", ), e);
194
        }
195
    }
197
    public static void decode(String id,
198
                              OutputStream ostream) 
199
        throws Base64Exception {
200
        
201
        try {
202
            char[] cd = id.toCharArray();
203
            ostream.write(decodeChunk(cd, 0, cd.length));
204
        } catch (IOException e) {
205
            throw new Base64Exception(new Message("BASE64_DECODE_IOEXCEPTION", ), e);
206
        }
207
    }
209
    // Returns base64 representation of specified byte array.
210
    //
211
    public static String encode(byte[] id) {
212
        char[] cd = encodeChunk(id, 0, id.length);
213
        return new String(cd, 0, cd.length);
214
    }
216
    // Returns base64 representation of specified byte array.
217
    //
218
    public static char[] encodeChunk(byte[] id,
219
                                     int o,
220
                                     int l) {
221
        if (l <= 0) {
222
            return null;
223
        }
225
        char[] out;
227
        // If not a multiple of 3 octets then a final padded 4 char
228
        // slot is needed.
229
        //
230
        if ((l - o) % 3 == 0) {
231
            out = new char[l / 3 * 4];
232
        } else {
233
            out = new char[l / 3 * 4 + 4];
234
        }
236
        int rindex = o;
237
        int windex = 0;
238
        int rest = l - o;
240
        while (rest >= 3) {
241
            int i = ((id[rindex] & 0xff) << 16)
242
                    + ((id[rindex + 1] & 0xff) << 8)
243
                    + (id[rindex + 2] & 0xff);
245
            out[windex++] = [i >> 18];
246
            out[windex++] = [(i >> 12) & 0x3f];
247
            out[windex++] = [(i >> 6) & 0x3f];
248
            out[windex++] = [i & 0x3f];
249
            rindex += 3;
250
            rest -= 3;
251
        }
253
        if (rest == 1) {
254
            int i = id[rindex] & 0xff;
255
            out[windex++] = [i >> 2];
256
            out[windex++] = [(i << 4) & 0x3f];
257
            out[windex++] = ;
258
            out[windex++] = ;
259
        } else if (rest == 2) {
260
            int i = ((id[rindex] & 0xff) << 8) + (id[rindex + 1] & 0xff);
261
            out[windex++] = [i >> 10];
262
            out[windex++] = [(i >> 4) & 0x3f];
263
            out[windex++] = [(i << 2) & 0x3f];
264
            out[windex++] = ;
265
        }
266
        return out;
267
    }
269
    //
270
    // Outputs base64 representation of the specified byte array 
271
    // to a byte stream.
272
    //
273
    public static void encodeChunk(byte[] id,
274
                                   int o,
275
                                   int l,
276
                                   OutputStream ostream) throws Base64Exception {
277
        try {
278
            ostream.write(new String(encodeChunk(id, o, l)).getBytes());
279
        } catch (IOException e) {
280
            throw new Base64Exception(new Message("BASE64_ENCODE_IOEXCEPTION", ), e);
281
        }
282
    }
285
    // Outputs base64 representation of the specified byte 
286
    // array to a character stream.
287
    //
288
    public static void encode(byte[] id,
289
                              int o,
290
                              int l,
291
                              Writer writer) throws Base64Exception {
292
        try {
293
            writer.write(encodeChunk(id, o, l));
294
        } catch (IOException e) {
295
            throw new Base64Exception(new Message("BASE64_ENCODE_WRITER_IOEXCEPTION", ), e);
296
        }
297
    }
300
    //---- Private static methods --------------------------------------
301

    
The process routine processes an atomic base64 unit of encoding (encodeme) into its native encoding. This class is used by decode routines to do the grunt work of decoding base64 encoded information

Parameters:
ib Input character buffer of encoded bytes
ob Output byte buffer of decoded bytes
p Pointer to the encodeme of interest
Returns:
The decoded encodeme
Throws:
Base64Exception Thrown is processing fails due to formatting exceptions in the encoded data
314
 
315
    private static int processEncodeme(char[] ib,
316
                                       byte[] ob,
317
                                       int p) 
318
        throws Base64Exception {
319
        
321
        int spad = ;        
322
        if (ib[3] == ) {
323
            spad = ;
324
        }
325
        if (ib[2] == ) {
326
            spad = ;
327
        }
329
        int b0 = [ib[0]];
330
        int b1 = [ib[1]];
331
        int b2 = [ib[2]];
332
        int b3 = [ib[3]];
334
        switch (spad) {
335
        case :
336
            ob[p] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
337
            return ;
338
        case :
339
            ob[p++] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
340
            ob[p] = (byte)(b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
341
            return ;
342
        case :
343
            ob[p++] = (byte)(b0 << 2 & 0xfc | b1 >> 4 & 0x3);
344
            ob[p++] = (byte)(b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
345
            ob[p] = (byte)(b2 << 6 & 0xc0 | b3 & 0x3f);
346
            return ;
347
        default:
348
            // We should never get here
349
            throw new IllegalStateException();
350
        } 
351
    } 
New to GrepCode? Check out our FAQ X