source: icXML/icXML-devel/src/xercesc/util/Base64.cpp @ 2732

Last change on this file since 2732 was 2722, checked in by cameron, 7 years ago

Original Xerces files with import mods for icxercesc

File size: 21.5 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18// ---------------------------------------------------------------------------
19//  Includes
20// ---------------------------------------------------------------------------
21#include <xercesc/util/Base64.hpp>
22#include <icxercesc/util/XMLString.hpp>
23#include <xercesc/util/Janitor.hpp>
24#include <icxercesc/internal/XMLReader.hpp>
25#include <xercesc/framework/MemoryManager.hpp>
26
27XERCES_CPP_NAMESPACE_BEGIN
28
29// ---------------------------------------------------------------------------
30//  constants
31// ---------------------------------------------------------------------------
32static const int BASELENGTH = 255;
33static const int FOURBYTE   = 4;
34
35// ---------------------------------------------------------------------------
36//  class data member
37// ---------------------------------------------------------------------------
38
39// the base64 alphabet according to definition in RFC 2045
40const XMLByte Base64::base64Alphabet[] = {
41    chLatin_A, chLatin_B, chLatin_C, chLatin_D, chLatin_E,
42    chLatin_F, chLatin_G, chLatin_H, chLatin_I, chLatin_J,
43    chLatin_K, chLatin_L, chLatin_M, chLatin_N, chLatin_O,
44    chLatin_P, chLatin_Q, chLatin_R, chLatin_S, chLatin_T,
45    chLatin_U, chLatin_V, chLatin_W, chLatin_X, chLatin_Y, chLatin_Z,
46    chLatin_a, chLatin_b, chLatin_c, chLatin_d, chLatin_e,
47    chLatin_f, chLatin_g, chLatin_h, chLatin_i, chLatin_j,
48    chLatin_k, chLatin_l, chLatin_m, chLatin_n, chLatin_o,
49    chLatin_p, chLatin_q, chLatin_r, chLatin_s, chLatin_t,
50    chLatin_u, chLatin_v, chLatin_w, chLatin_x, chLatin_y, chLatin_z,
51    chDigit_0, chDigit_1, chDigit_2, chDigit_3, chDigit_4,
52    chDigit_5, chDigit_6, chDigit_7, chDigit_8, chDigit_9,
53    chPlus, chForwardSlash, chNull
54};
55
56// This is an inverse table for base64 decoding.  So, if
57// base64Alphabet[17] = 'R', then base64Inverse['R'] = 17.
58//
59// For characters not in base64Alphabet then
60// base64Inverse[ch] = 0xFF.
61const XMLByte Base64::base64Inverse[BASELENGTH] =
62{
63    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
64    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
65    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0x3F,
66    0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
67    0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
68    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
69    0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
70    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
71    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
72    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
73    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
74    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
75    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
76    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
77    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
78    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
79};
80
81const XMLByte Base64::base64Padding = chEqual;
82
83/***
84 *
85 * Memory Management Issue:
86 *
87 * . For memory allocated for result returned to caller (external memory),
88 *   the plugged memory manager is used if it is provided, otherwise global
89 *   new used to retain the pre-memory-manager behaviour.
90 *
91 * . For memory allocated for temperary buffer (internal memory),
92 *   XMLPlatformUtils::fgMemoryManager is used.
93 *
94 */
95
96static void* getExternalMemory(  MemoryManager* const allocator
97                               , XMLSize_t const   sizeToAllocate)
98{
99   return allocator ? allocator->allocate(sizeToAllocate)
100       : ::operator new(sizeToAllocate);
101}
102
103/***
104 * internal memory is deallocated by janitorArray
105 */ 
106static void returnExternalMemory(  MemoryManager* const allocator
107                                 , void*                buffer)
108{
109    allocator ? allocator->deallocate(buffer)
110        : ::operator delete(buffer);
111}
112
113/**
114 *     E2-9
115 *
116 *     Canonical-base64Binary ::= (B64line* B64lastline)?
117 *
118 *      B64line ::= B64x15 B64x15 B64x15 B64x15 B64x15 B64 #xA
119 *                  76 Base64 characters followed by newline
120 *
121 *      B64x15  ::= B64 B64 B64 B64 B64
122 *                  B64 B64 B64 B64 B64
123 *                  B64 B64 B64 B64 B64
124 *
125 *      B64lastline ::= B64x4? B64x4? B64x4? B64x4?
126 *                      B64x4? B64x4? B64x4? B64x4?
127 *                      B64x4? B64x4? B64x4? B64x4?
128 *                      B64x4? B64x4? B64x4? B64x4?
129 *                      B64x4? B64x4?
130 *                      (B64x4 | (B64 B64 B16 '=') | (B64 B04 '=='))
131 *                      #xA
132 *
133 *      B64x4   ::= B64 B64 B64 B64
134 *      B04     ::= [AQgw]
135 *      B16     ::= [AEIMQUYcgkosw048]
136*/
137
138// number of quadruplets per one line ( must be >1 and <19 )
139const unsigned int Base64::quadsPerLine = 15;
140
141XMLByte* Base64::encode(const XMLByte* const inputData
142                      , const XMLSize_t      inputLength
143                      , XMLSize_t*           outputLength                     
144                      , MemoryManager* const memMgr)
145{
146    if (!inputData || !outputLength)
147        return 0;
148
149    int quadrupletCount = ( (int)inputLength + 2 ) / 3;
150    if (quadrupletCount == 0)
151        return 0;
152
153    // number of rows in encoded stream ( including the last one )
154    int lineCount = ( quadrupletCount + quadsPerLine-1 ) / quadsPerLine;
155
156    //
157    // convert the triplet(s) to quadruplet(s)
158    //
159    XMLByte  b1, b2, b3, b4;  // base64 binary codes ( 0..63 )
160
161    XMLSize_t inputIndex = 0;
162    XMLSize_t outputIndex = 0;
163    XMLByte *encodedData = (XMLByte*) getExternalMemory(memMgr, (quadrupletCount*FOURBYTE+lineCount+1) * sizeof(XMLByte));
164
165    //
166    // Process all quadruplet(s) except the last
167    //
168    int quad = 1;
169    for (; quad <= quadrupletCount-1; quad++ )
170    {
171        // read triplet from the input stream
172        split1stOctet( inputData[ inputIndex++ ], b1, b2 );
173        split2ndOctet( inputData[ inputIndex++ ], b2, b3 );
174        split3rdOctet( inputData[ inputIndex++ ], b3, b4 );
175
176        // write quadruplet to the output stream
177        encodedData[ outputIndex++ ] = base64Alphabet[ b1 ];
178        encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
179        encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
180        encodedData[ outputIndex++ ] = base64Alphabet[ b4 ];
181
182        if (( quad % quadsPerLine ) == 0 )
183            encodedData[ outputIndex++ ] = chLF;
184    }
185
186    //
187    // process the last Quadruplet
188    //
189    // first octet is present always, process it
190    split1stOctet( inputData[ inputIndex++ ], b1, b2 );
191    encodedData[ outputIndex++ ] = base64Alphabet[ b1 ];
192
193    if( inputIndex < inputLength )
194    {
195        // second octet is present, process it
196        split2ndOctet( inputData[ inputIndex++ ], b2, b3 );
197        encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
198
199        if( inputIndex < inputLength )
200        {
201            // third octet present, process it
202            // no PAD e.g. 3cQl
203            split3rdOctet( inputData[ inputIndex++ ], b3, b4 );
204            encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
205            encodedData[ outputIndex++ ] = base64Alphabet[ b4 ];
206        }
207        else
208        {
209            // third octet not present
210            // one PAD e.g. 3cQ=
211            encodedData[ outputIndex++ ] = base64Alphabet[ b3 ];
212            encodedData[ outputIndex++ ] = base64Padding;
213        }
214    }
215    else
216    {
217        // second octet not present
218        // two PADs e.g. 3c==
219        encodedData[ outputIndex++ ] = base64Alphabet[ b2 ];
220        encodedData[ outputIndex++ ] = base64Padding;
221        encodedData[ outputIndex++ ] = base64Padding;
222    }
223
224    // write out end of the last line
225    encodedData[ outputIndex++ ] = chLF;
226    // write out end of string
227    encodedData[ outputIndex ] = 0;
228
229    *outputLength = outputIndex;
230
231    return encodedData;
232}
233
234//
235// delete the buffer allocated by decode() if
236// decoding is successfully done.
237//
238// In previous version, we use XMLString::strLen(decodedData)
239// to get the length, this will fail for test case containing
240// consequtive "A", such "AAFF", or "ab56AA56". Instead of
241// returning 3/6, we have 0 and 3, indicating that "AA", after
242// decoded, is interpreted as <null> by the strLen().
243//
244// Since decode() has track of length of the decoded data, we
245// will get this length from decode(), instead of strLen().
246//
247int Base64::getDataLength(const XMLCh*         const inputData
248                        ,       MemoryManager* const manager
249                        ,       Conformance          conform )
250
251{
252    XMLSize_t retLen = 0;
253    XMLByte* decodedData = decodeToXMLByte(inputData, &retLen, manager, conform);
254
255    if ( !decodedData )
256        return -1;
257    else
258    {
259        returnExternalMemory(manager, decodedData);
260        return (int)retLen;
261    }
262}
263
264XMLByte* Base64::decode(const XMLByte*       const  inputData
265                      ,       XMLSize_t*            decodedLength
266                      ,       MemoryManager* const  memMgr
267                      ,       Conformance           conform )
268{
269    XMLByte* canRepInByte = 0;
270    XMLByte* retStr = decode(
271                              inputData
272                            , decodedLength
273                            , canRepInByte
274                            , memMgr
275                            , conform);
276
277    /***
278     * Release the canRepData
279     */ 
280    if (retStr)
281        returnExternalMemory(memMgr, canRepInByte);
282
283    return retStr;
284}
285
286
287XMLByte* Base64::decodeToXMLByte(const XMLCh*         const   inputData
288                                ,      XMLSize_t*             decodedLen
289                                ,      MemoryManager* const   memMgr
290                                ,      Conformance            conform )
291{
292    if (!inputData || !*inputData)
293        return 0;
294
295    /***
296     *  Move input data to a XMLByte buffer
297     */
298    XMLSize_t srcLen = XMLString::stringLen(inputData);
299    XMLByte *dataInByte = (XMLByte*) getExternalMemory(memMgr, (srcLen+1) * sizeof(XMLByte));
300    ArrayJanitor<XMLByte> janFill(dataInByte, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
301
302    for (XMLSize_t i = 0; i < srcLen; i++)
303        dataInByte[i] = (XMLByte)inputData[i];
304
305    dataInByte[srcLen] = 0;
306
307    /***
308     * Forward to the actual decoding method to do the decoding
309     */
310    *decodedLen = 0;
311    return decode(dataInByte, decodedLen, memMgr, conform);
312}
313
314/***
315* E2-54
316*
317* Canonical-base64Binary ::= (B64 B64 B64 B64)*((B64 B64 B16 '=')|(B64 B04 '=='))?
318* B04                    ::= [AQgw]
319* B16                    ::= [AEIMQUYcgkosw048]
320* B64                    ::= [A-Za-z0-9+/]
321*
322***/
323XMLCh* Base64::getCanonicalRepresentation(const XMLCh*         const   inputData
324                                        ,       MemoryManager* const   memMgr
325                                        ,       Conformance            conform)
326   
327{
328    if (!inputData || !*inputData) 
329        return 0;
330
331    /***
332     *  Move input data to a XMLByte buffer
333     */
334    XMLSize_t srcLen = XMLString::stringLen(inputData);
335    XMLByte *dataInByte = (XMLByte*) getExternalMemory(memMgr, (srcLen+1) * sizeof(XMLByte));
336    ArrayJanitor<XMLByte> janFill(dataInByte, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
337
338    for (XMLSize_t i = 0; i < srcLen; i++)
339        dataInByte[i] = (XMLByte)inputData[i];
340
341    dataInByte[srcLen] = 0;
342
343    /***
344     * Forward to the actual decoding method to do the decoding
345     */
346    XMLSize_t decodedLength = 0;
347    XMLByte*     canRepInByte = 0;
348    XMLByte*     retStr = decode(
349                              dataInByte
350                            , &decodedLength
351                            , canRepInByte
352                            , memMgr
353                            , conform);
354
355    if (!retStr)
356        return 0;
357
358    /***
359     * Move canonical representation to a XMLCh buffer to return
360     */
361    XMLSize_t canRepLen = XMLString::stringLen((char*)canRepInByte);
362    XMLCh *canRepData = (XMLCh*) getExternalMemory(memMgr, (canRepLen + 1) * sizeof(XMLCh));
363               
364    for (XMLSize_t j = 0; j < canRepLen; j++)
365        canRepData[j] = (XMLCh)canRepInByte[j];
366
367    canRepData[canRepLen] = 0;
368
369    /***
370     * Release the memory allocated in the actual decoding method
371     */ 
372    returnExternalMemory(memMgr, retStr);
373    returnExternalMemory(memMgr, canRepInByte);
374
375    return canRepData;
376}
377// -----------------------------------------------------------------------
378//  Helper methods
379// -----------------------------------------------------------------------
380
381//
382// return 0(null) if invalid data found.
383// return the buffer containning decoded data otherwise
384// the caller is responsible for the de-allocation of the
385// buffer returned.
386//
387// temporary data, rawInputData, is ALWAYS released by this function.
388//
389
390/***
391 *     E2-9
392 *
393 *     Base64Binary ::= S? B64quartet* B64final?
394 *
395 *     B64quartet   ::= B64 S? B64 S? B64 S? B64 S?
396 *
397 *     B64final     ::= B64 S? B04 S? '=' S? '=' S?
398 *                    | B64 S? B64 S? B16 S? '=' S?
399 *
400 *     B04          ::= [AQgw]
401 *     B16          ::= [AEIMQUYcgkosw048]
402 *     B64          ::= [A-Za-z0-9+/]
403 *
404 *
405 *     E2-54
406 *
407 *     Base64Binary  ::=  ((B64S B64S B64S B64S)*
408 *                         ((B64S B64S B64S B64) |
409 *                          (B64S B64S B16S '=') |
410 *                          (B64S B04S '=' #x20? '=')))?
411 *
412 *     B64S         ::= B64 #x20?
413 *     B16S         ::= B16 #x20?
414 *     B04S         ::= B04 #x20?
415 *
416 *
417 *     Note that this grammar requires the number of non-whitespace characters
418 *     in the lexical form to be a multiple of four, and for equals signs to
419 *     appear only at the end of the lexical form; strings which do not meet these
420 *     constraints are not legal lexical forms of base64Binary because they
421 *     cannot successfully be decoded by base64 decoders.
422 *
423 *     Note:
424 *     The above definition of the lexical space is more restrictive than that given
425 *     in [RFC 2045] as regards whitespace -- this is not an issue in practice. Any
426 *     string compatible with the RFC can occur in an element or attribute validated
427 *     by this type, because the whiteSpace facet of this type is fixed to collapse,
428 *     which means that all leading and trailing whitespace will be stripped, and all
429 *     internal whitespace collapsed to single space characters, before the above grammar
430 *     is enforced.
431 *
432*/
433
434XMLByte* Base64::decode (   const XMLByte*        const   inputData
435                          ,       XMLSize_t*              decodedLength
436                          ,       XMLByte*&               canRepData
437                          ,       MemoryManager*  const   memMgr
438                          ,       Conformance             conform
439                        )
440{
441    if ((!inputData) || (!*inputData))
442        return 0;
443   
444    //
445    // remove all XML whitespaces from the base64Data
446    //
447    XMLSize_t inputLength = XMLString::stringLen( (const char*)inputData );
448    XMLByte* rawInputData = (XMLByte*) getExternalMemory(memMgr, (inputLength+1) * sizeof(XMLByte));
449    ArrayJanitor<XMLByte> jan(rawInputData, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
450
451    XMLSize_t inputIndex = 0;
452    XMLSize_t rawInputLength = 0;
453    bool inWhiteSpace = false;
454
455    switch (conform)
456    {
457    case Conf_RFC2045:
458        while ( inputIndex < inputLength )
459        {
460            if (!XMLChar1_0::isWhitespace(inputData[inputIndex]))
461            {
462                rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
463            }
464            // RFC2045 does not explicitly forbid more than ONE whitespace
465            // before, in between, or after base64 octects.
466            // Besides, S? allows more than ONE whitespace as specified in the production
467            // [3]   S   ::=   (#x20 | #x9 | #xD | #xA)+
468            // therefore we do not detect multiple ws
469
470            inputIndex++;
471        }
472
473        break;
474    case Conf_Schema:
475        // no leading #x20
476        if (chSpace == inputData[inputIndex])
477            return 0;
478
479        while ( inputIndex < inputLength )
480        {
481            if (chSpace != inputData[inputIndex])
482            {
483                rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
484                inWhiteSpace = false;
485            }
486            else
487            {
488                if (inWhiteSpace)
489                    return 0; // more than 1 #x20 encountered
490                else
491                    inWhiteSpace = true;
492            }
493
494            inputIndex++;
495        }
496
497        // no trailing #x20
498        if (inWhiteSpace)
499            return 0;
500
501        break;
502
503    default:
504        break;
505    }
506
507    //now rawInputData contains canonical representation
508    //if the data is valid Base64
509    rawInputData[ rawInputLength ] = 0;
510
511    // the length of raw data should be divisible by four
512    if (( rawInputLength % FOURBYTE ) != 0 )
513        return 0;
514
515    int quadrupletCount = (int)rawInputLength / FOURBYTE;
516    if ( quadrupletCount == 0 )
517        return 0;
518
519    //
520    // convert the quadruplet(s) to triplet(s)
521    //
522    XMLByte  d1, d2, d3, d4;  // base64 characters
523    XMLByte  b1, b2, b3, b4;  // base64 binary codes ( 0..64 )
524
525    XMLSize_t rawInputIndex  = 0;
526    XMLSize_t outputIndex    = 0;
527    XMLByte *decodedData = (XMLByte*) getExternalMemory(memMgr, (quadrupletCount*3+1) * sizeof(XMLByte));
528
529    //
530    // Process all quadruplet(s) except the last
531    //
532    int quad = 1;
533    for (; quad <= quadrupletCount-1; quad++ )
534    {
535        // read quadruplet from the input stream
536        if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
537            !isData( (d2 = rawInputData[ rawInputIndex++ ]) ) ||
538            !isData( (d3 = rawInputData[ rawInputIndex++ ]) ) ||
539            !isData( (d4 = rawInputData[ rawInputIndex++ ]) ))
540        {
541            // if found "no data" just return NULL
542            returnExternalMemory(memMgr, decodedData);
543            return 0;
544        }
545
546        b1 = base64Inverse[ d1 ];
547        b2 = base64Inverse[ d2 ];
548        b3 = base64Inverse[ d3 ];
549        b4 = base64Inverse[ d4 ];
550
551        // write triplet to the output stream
552        decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
553        decodedData[ outputIndex++ ] = set2ndOctet(b2, b3);
554        decodedData[ outputIndex++ ] = set3rdOctet(b3, b4);
555    }
556
557    //
558    // process the last Quadruplet
559    //
560    // first two octets are present always, process them
561    if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
562        !isData( (d2 = rawInputData[ rawInputIndex++ ]) ))
563    {
564        // if found "no data" just return NULL
565        returnExternalMemory(memMgr, decodedData);
566        return 0;
567    }
568
569    b1 = base64Inverse[ d1 ];
570    b2 = base64Inverse[ d2 ];
571
572    // try to process last two octets
573    d3 = rawInputData[ rawInputIndex++ ];
574    d4 = rawInputData[ rawInputIndex++ ];
575
576    if (!isData( d3 ) || !isData( d4 ))
577    {
578        // check if last two are PAD characters
579        if (isPad( d3 ) && isPad( d4 ))
580        {
581            // two PAD e.g. 3c==
582            if ((b2 & 0xf) != 0) // last 4 bits should be zero
583            {
584                returnExternalMemory(memMgr, decodedData);
585                return 0;
586            }
587
588            decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
589        }
590        else if (!isPad( d3 ) && isPad( d4 ))
591        {
592            // one PAD e.g. 3cQ=
593            b3 = base64Inverse[ d3 ];
594            if (( b3 & 0x3 ) != 0 ) // last 2 bits should be zero
595            {
596                returnExternalMemory(memMgr, decodedData);
597                return 0;
598            }
599
600            decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
601            decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
602        }
603        else
604        {
605            // an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
606            returnExternalMemory(memMgr, decodedData);
607            return 0;
608        }
609    }
610    else
611    {
612        // no PAD e.g 3cQl
613        b3 = base64Inverse[ d3 ];
614        b4 = base64Inverse[ d4 ];
615        decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
616        decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
617        decodedData[ outputIndex++ ] = set3rdOctet( b3, b4 );
618    }
619
620    // write out the end of string
621    decodedData[ outputIndex ] = 0;
622    *decodedLength = outputIndex;
623
624    //allow the caller to have access to the canonical representation
625    jan.release(); 
626    canRepData = rawInputData;
627
628    return decodedData;
629}
630
631bool Base64::isData(const XMLByte& octet)
632{
633    return (base64Inverse[octet]!=(XMLByte)-1);
634}
635
636XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.