/*
* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: This class implements the base64 en/decoding.
*
*/
#include <e32base.h>
#include "base64.h"
/* 6 LOCAL DEFINITIONS */
/* 6.1 Local include files */
/* 6.2 Local constants */
LOCAL_C const TUint8 pBase64[] =
{
0x3e, 0x7f, 0x7f, 0x7f, 0x3f, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x7f,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x1a, 0x1b,
0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33
};
/* 6.3 Local macros */
#define b64blocks(l) (((l) + 2) / 3 * 4)
/* #define b64octets(l) ((l) / 4 * 3) */
/* 6.4 Local data types */
/* 6.5 Local data structures */
/* 6.6 Local function prototypes */
LOCAL_C TInt b64valid(TUint8 *);
/* 7 MODULE CODE */
/* ========================================================================= */
/* 7.2 */
/* Functional description
*
* This function does base64 decoding. As the outputted buffer is always 33% shorter than
* the input buffer, the caller may want to reallocate the buffer after calling this function.
*
* Parameters
*
* Pointer to source containing data to decode
*
source
*
* Length of source buffer
*
length
*
* pointer to the destination buffer
* Note: the user must allocate memory for this buffer that its length at least can not be shorter than
* the length of source. The user also can use same buffer for both source and destination.
*
destination
*
* length of the buffer allocated
*
destination_length
*
* Return values
*
* byte 0 if OK else > 0
*/
/* ---------------------------------------------------------------------- */
TInt b64decode(TUint8 *source, TUint32 length, TUint8 *destination, TUint32 *destination_length)
{
/* Data structures */
/* Code */
TUint8 *buf/*, *pbuf*/; /* Decoding buffer pointers. */
register TUint32 x = 0; /* General purpose integers. */
TUint32 buf_index = 0; /* current index in destination buffer */
/* buffer to avoid allocating wholly new buffer for output */
TUint8 localBuffer[4] = {0,0,0,0};
TUint8* pLocalBufferOutPointer = 0;
register TUint32 i = 0;
TUint32 num;
TUint8 c = 0; /* Character to decode. */
TUint8 localBufferIndex = 0;
/* int32 buf_length = 0; */ /* new length of destination buf */
const TUint8 pad = 0x3d; /* '=' */
if(!source || length == 0 || !destination || !destination_length)
{
return KErrArgument;
}
/* Collating sequence independant "===". */
/* Calculate the amount of '=' in the end of the source */
for(x=0, buf=source + (length-1); *buf == pad; buf --)
{
x++;
}
/* max allow 3 "===" in the end of content */
if (x > 3)
{
return KErrArgument;
}
/* Save the encoded string pointer. */
// pbuf = destination;
/* save address for first output block */
pLocalBufferOutPointer = destination;
x = 0; /* Initialize index. */
localBufferIndex = 0;
Mem::Copy(localBuffer, source, 4);
for (i = length; i != 0; i-- ) /* Decode every byte of the base 64 string */
{
/* c = *pbuf++; */
c = localBuffer[localBufferIndex++];
if(localBufferIndex == 4)
{
localBufferIndex = 0;
source = source + 4;
/* INPUT: copy next input block to local buffer */
num = i > 4 ? 4 : i - 1;
if(num > 0)
{
Mem::Copy(localBuffer, source, num);
}
}
/* Ignore "=". */
if (c == pad)
{
break; /* this must be the end of the buffer, or else ve have a invalid character */
}
if (c == '\n' || c == '\r' || c == '\t') /* ignore linefeed tab and cr */
{
continue;
}
/* Valid Base64 Index? */
if (!b64valid(&c))
{
/* b64free(buf); */
return KErrArgument;
}
/* Decode 4 byte words into 3 byte octets.*/
switch(x % 4)
{
case 0: /* Byte 0 of word.*/
pLocalBufferOutPointer[buf_index] = (TInt8)(c << 2);
break;
case 1: /* Byte 1 of word. */
pLocalBufferOutPointer[buf_index] |= c >> 4;
buf_index ++;
pLocalBufferOutPointer[buf_index] = (TInt8)( (c & 0x0f) << 4 );
break;
case 2: /* Byte 2 of word. */
pLocalBufferOutPointer[buf_index] |= c >> 2;
buf_index ++;
pLocalBufferOutPointer[buf_index] = (TInt8)( (c & 0x03) << 6 );
break;
case 3: /* Byte 3 of word. */
pLocalBufferOutPointer[buf_index] |= c;
buf_index ++;
break;
default: /* useless, just to depress warnings */
break;
}
x++; /* Increment word byte. */
} /* while */
/* make sure that there is zero at the end of the buffer
though buf[buf_index] shoule be zero after decoding
*/
/* pbuf[buf_index+1] = 0; */
/*buf[buf_index+1]=0*/
/* don't return the size of the buffer (buf_length), but the data size we put in (buf_index)*/
*destination_length = buf_index;
return KErrNone;
}
/* 7.3 */
/* Functional description
*
* This function validates the character according to the base64 rules,
* and changes it to the corresponding value in the table.
*
* Parameters
*
* Pointer to character to validate
*
c
*
* Return values
*
* TRUE if character is valid else FALSE.
*/
/* ---------------------------------------------------------------------- */
LOCAL_C TInt b64valid(TUint8 *c)
{
/* Data structures */
/* Code */
/* If not within the range of the table, return false. */
if ((*c < 0x2b) || (*c > 0x7a))
{
return 0;
}
/* If it falls within one of the gaps, return false. */
if ((*c = pBase64[*c - 0x2b]) == 0x7f)
{
return 0;
}
return 1; /* Otherwise, return true. */
}
/* 7.4 */
/* Functional description
*
* This function allocates a buffer in the size of the parameter.
*
* Parameters
*
* Size of buffer to allocate
*
length
*
* Return values
*
* pointer to buffer
*/
/* ---------------------------------------------------------------------- */
#ifdef BUILD_BASE64_ENCODE
LOCAL TUint8 *b64buffer(TUint32 length)
{
/* Data structures */
/* Code */
TUint8 *buf; /* buffer pointers. */
if (!length) /* dont allow buf size 0 */
{
return NULL;
}
buf = (TUint8 *) DRM_BLOCK_ALLOC(length);
return buf; /* Return the pointer or null. */
}
#endif /* #ifdef BUILD_BASE64_ENCODE */
/* End of File */