/*
* Copyright (c) 2006 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: Base64 encoder/decoder
*
*/



#include <eikenv.h>
#include "base64.h"

////////////////////////////////////////////////////////////////////////////////////////
//	Constructor
////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C TBase64Codec::TBase64Codec()
{
	// Initialize base64
	InitBase64();
}

////////////////////////////////////////////////////////////////////////////////////////
//	Initialize decoding array
////////////////////////////////////////////////////////////////////////////////////////
void TBase64Codec::InitBase64(void)
{
	TUint8 i;
	Mem::Fill(iD64, sizeof(iD64), B64_IGN);
	for (i=0;i<sizeof(Kb64);i++)
	{
		iD64[Kb64[i]]=i;
	}
	iD64[B64_NOP_CHR]=B64_NOP_VAL;
}

////////////////////////////////////////////////////////////////////////////////////////
//	Base64 encoding function using buffers allocated by the caller
////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C TInt TBase64Codec::Base64Encode(const TDesC8 &aRawData, const TDes8 &aEncodedData)
{
	TInt i;
	TInt j;
	TInt datalen;
	TUint8 block[3];
	const TUint8 *fromPtr;
	TUint8 *toPtr;
	TUint count = 0;
	TInt lengthIncludingLinebreaks;
	TInt lengthWithoutLinebreaks;


	i=0;
	fromPtr = aRawData.Ptr();
	toPtr = CONST_CAST(TUint8*, aEncodedData.Ptr());
	datalen = aRawData.Size();
	lengthWithoutLinebreaks = ((datalen + 3)/ 3) * 4;
	lengthIncludingLinebreaks = lengthWithoutLinebreaks + (lengthWithoutLinebreaks) / MAXLINELEN - ((lengthWithoutLinebreaks % MAXLINELEN)?0:1); 
	if(aEncodedData.MaxLength() < lengthIncludingLinebreaks)
		return KErrArgument;

	for (j=0;j<datalen;j+=3)
	{
		/* 11111100>>2 */
		/* 00000011<<4 + 11110000>>4 */
		/*               00001111<<2 + 11000000>>6 */
		/*                             00111111    */
		Mem::FillZ(block, 3);
		Mem::Copy(block, &fromPtr[j], datalen-j<3?datalen-j:3);
		toPtr[i++] = Kb64[(block[0]&0xfc)>>2]; 
		toPtr[i++] = Kb64[((block[0]&0x03)<<4)+(block[1]>>4)];
		if (datalen-j>1)
		{
			toPtr[i++] = Kb64[((block[1]&0x0f)<<2)+(block[2]>>6)]; 
		}
		else
		{
			toPtr[i++] = B64_NOP_CHR;
		}
		if (datalen-j>2)
		{
			toPtr[i++]=Kb64[block[2]&0x3f]; 
		}
		else
		{
			toPtr[i++] = B64_NOP_CHR;
		}
		count += 4;
		// Add linebreaks every 76th characters
		// Don't add it after the last full length line
		if(count >= MAXLINELEN && j < datalen - 3)
		{
			toPtr[i++] = B64_LINEBREAK;
			count = 0;
		}
	}
	
	CONST_CAST(TDes8 &, aEncodedData).SetLength(i);
	return KErrNone;
}

////////////////////////////////////////////////////////////////////////////////////////
//	Base64 decoding function using buffers allocated by the caller
////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C TInt TBase64Codec::Base64Decode(const TDesC8 &aEncodedData, const TDes8 &aDecodedData)
{
	TInt i;
	TInt j;
	TInt k;
	TInt blocklen;
	TInt datalen;
	const TUint8 *fromPtr;
	TUint8 *toPtr;
	
	TUint8 c = 0;
	TUint8 block[4];

	InitBase64();
	
	i=0;
	j=0;
	fromPtr = aEncodedData.Ptr();
	toPtr = CONST_CAST(TUint8*, aDecodedData.Ptr());
	datalen = aEncodedData.Size();
	if(aDecodedData.MaxLength() < (datalen / 4) * 3)
		return KErrArgument;
	
	while ((datalen > 0) && (j <= datalen))
	{
		blocklen=0;
		Mem::Fill(block,'\0',sizeof(block));
		for (k=0;k<4;k++) /* skip non base64 characters */
		{
			while (j++ <= datalen && (c=iD64[*fromPtr++])==B64_IGN) {;}
			if (j<=datalen)
			{
				block[k]=c;
				if (c!=B64_NOP_VAL)
				{
					blocklen++;
				}
				else
				{
					block[k]=0;
				}
			}
			else
			{
				block[k]=0;
			}
		}
		if (blocklen)
		{
			toPtr[i+0] = STATIC_CAST(TUint8, (block[0]<<2) + (block[1]>>4));

			if(blocklen > 1)
				toPtr[i+1] = STATIC_CAST(TUint8, ((block[1]&0x0f)<<4) + (block[2]>>2));

			if(blocklen > 2)
				toPtr[i+2] = STATIC_CAST(TUint8, ((block[2]&0x03)<<6) + (block[3]));

			i+=blocklen-1;
		}
	}
	CONST_CAST(TDes8 &, aDecodedData).SetLength(i);
	return KErrNone;
}

////////////////////////////////////////////////////////////////////////////////////////
//	Base64 encoding function, buffer allocated by the function and returned to the caller
////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C HBufC8* TBase64Codec::Base64EncodeLC(const TDesC8 &aRawData)
{
	HBufC8 *outBuf = NULL;
	TInt rCode;
	TUint lengthIncludingLinebreaks;
	TUint lengthWithoutLinebreaks;

	lengthWithoutLinebreaks =((aRawData.Length() + 3)/ 3) * 4;
	lengthIncludingLinebreaks = lengthWithoutLinebreaks + (lengthWithoutLinebreaks) / MAXLINELEN - ((lengthWithoutLinebreaks % MAXLINELEN)?0:1); 
	outBuf = HBufC8::NewLC(lengthIncludingLinebreaks);
	TPtr8 outDes = outBuf->Des();
	rCode = Base64Encode(aRawData, outDes);
	if(rCode != KErrNone)
	{
		CleanupStack::Pop();
		delete outBuf;
		outBuf = NULL;
	}
	return (outBuf);
}

////////////////////////////////////////////////////////////////////////////////////////
//	Base64 decoding function, buffer allocated by the function and returned to the caller
////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C HBufC8* TBase64Codec::Base64DecodeLC(const TDesC8 &aEncodedData)
{
	HBufC8 *outBuf = NULL;
	TInt rCode;
	
	outBuf = HBufC8::NewLC(((aEncodedData.Length() / 4) * 3));
	TPtr8 outDes = outBuf->Des();
	rCode = Base64Decode(aEncodedData, outDes);
	if(rCode != KErrNone)
	{
		CleanupStack::Pop();
		delete outBuf;
		outBuf = NULL;
	}
	return (outBuf);
}