--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omadrm/drmengine/dm/src/b64.cpp Thu Dec 17 08:52:27 2009 +0200
@@ -0,0 +1,307 @@
+/*
+* 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 */
+