/*

* Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

/**

 @file 

 @internalComponent

 @released

*/

#include <iostream>

#include <fstream>

#include <string>

#include <iomanip>

#include <openssl/rsa.h>

#include <openssl/dsa.h>

#include <openssl/evp.h>

#include <openssl/objects.h>

#include <openssl/x509v3.h>

#include <openssl/sha.h>

#include <openssl/pem.h>

#include <openssl/x509.h>

#include <openssl/err.h>

#include <openssl/pem.h>

#include <openssl/evp.h>

#include <openssl/err.h>

#include <openssl/ssl.h>

#include <openssl/bio.h>

#include "utility_interface.h"

#include "siscertificatechain.h"

#include "certchaindata.h"

#include "exception.h"

#include "utility.h"

#include "certificateinfo.h"

CSisCertificateChain::CSisCertificateChain (CCertChainData& aSisCertChain): iSisCertChain(aSisCertChain) 

	{

	ConstructL();

	}

void CSisCertificateChain::ConstructL()

	{

	CSISFieldRoot::TFieldSize offset = 0;

	X509* x509 = GetX509 (offset);

	while(x509 != NULL)

		{

		CCertificateInfo* certInfo = new CCertificateInfo(x509);

		iCertificateList.push_back(certInfo);

		x509 = GetX509 (offset);

		}

	}

CSisCertificateChain::~CSisCertificateChain()

	{

	for(int i = 0; i < iCertificateList.size(); ++i)

		{

		delete iCertificateList[i];

		}

	iCertificateList.clear();

	}

X509* BlobToX509 (const CSISBlob& aBlob, CSISFieldRoot::TFieldSize& aOffset)

	{

	assert (aBlob.Size ());

	assert (aBlob.Size () < 0X7FFFFFFF);	// openssl limits

	X509* x509 = NULL;

	unsigned char* was = const_cast <unsigned char*> (aBlob.Data ());

	unsigned char* ptr = was;

	assert (ptr);

	ptr += aOffset;

	if (! d2i_X509 (&x509, &ptr, static_cast <int> (aBlob.Size ())))

		{

		throw CSISException (CSISException::ECrypto, "invalid certificate chain");

		}

	aOffset = (ptr - was);

	assert (x509);

	return x509;

	}

void X509ToBlob (CSISBlob& aBlob, X509* aX509)

	{

	TUint8* buffer = NULL;

	int size = i2d_X509 (aX509, &buffer);

	if ((size <= 0) || (buffer == NULL))

		{

		throw CSISException (CSISException::ECrypto, "invalid X509");

		}

	try

		{

		aBlob.Assign (buffer, static_cast <CSISFieldRoot::TFieldSize> (size));

		}

	catch (...)

		{

		OPENSSL_free (buffer);

		throw;

		}

	OPENSSL_free (buffer);

	}

void X509ToBlobAppend (CSISBlob& aBlob, X509* aX509)

	{

	TUint8* buffer = NULL;

	int size = i2d_X509 (aX509, &buffer);

	if ((size <= 0) || (buffer == NULL))

		{

		throw CSISException (CSISException::ECrypto, "invalid X509");

		}

	try

		{

#ifndef X509_CHAIN_ORDER_ROOT_FIRST

		aBlob.Append (buffer, static_cast <CSISFieldRoot::TFieldSize> (size));

#else

		aBlob.Prepend (buffer, static_cast <CSISFieldRoot::TFieldSize> (size));

#endif /* X509_CHAIN_ORDER_ROOT_FIRST */

		}

	catch (...)

		{

		OPENSSL_free (buffer);

		throw;

		}

	OPENSSL_free (buffer);

	}

void CSisCertificateChain::LoadText (const std::wstring& aName)

	{	

		char *fName = NULL;	

		std::ifstream certFile;

		std::string line;

		std::string buffer;

		certFile.rdbuf()->open(wstring2string (aName).c_str (), std::ios::in);

		if (!certFile.is_open())

			{

			if((fName = Copy2TmpFile(aName.c_str(), CERTFILE)) != NULL)

				{

				certFile.rdbuf()->open(fName, std::ios::in);

				}

			}

		//check if file is successfully opened.

		if(certFile.is_open())

			{

			//reads the file (pem certificate) into the buffer ignoring empty lines.

			while(!certFile.eof())

				{

				getline(certFile,line);

				//ignore blank lines.

				if(line.length())

					{

					buffer.append(line);

					buffer.append("\n");

					}

				}

			certFile.rdbuf()->close();

			}

		else

			{

			CSISException::ThrowIf (1, CSISException::EFileProblem, std::wstring (L"cannot open ") + aName);

			}

		if(fName != NULL)

		{

			DeleteFileA(fName);

			delete fName;

		}

		X509* x509 = NULL;

		BIO* mem = NULL;

		try

			{

			ERR_clear_error();

			//creates a memory BIO and writes the buffer data into it.

			mem = BIO_new(BIO_s_mem());

			BIO_puts(mem , buffer.c_str());

			while(PEM_read_bio_X509 (mem , &x509 ,0 ,NULL) != NULL)

				{

				X509ToBlobAppend (const_cast<CSISBlob&>(iSisCertChain.CertificateData()), x509);

				X509_free (x509);

				x509 = NULL;

				}

			BIO_free(mem); mem = NULL;

			if(iSisCertChain.CertificateData().Size() == 0)

				throw 0;

			}

		catch (...)

			{

			if (certFile.rdbuf()->is_open())

			{

			certFile.rdbuf()->close();

			}

			if (x509)

				{

				X509_free (x509);

				}

			if(mem)

				{

				BIO_free(mem);

				}

			iSisCertChain.CertificateData().Dispose ();

			throw CSISException (CSISException::ECrypto, std::wstring (L"Cannot read ") + aName);

			}

	}

void CSisCertificateChain::LoadBinary (const std::wstring& aName)

	{

	try

		{

		iSisCertChain.CertificateData().Load (aName);

		}

	catch (...)

		{

		throw CSISException (CSISException::ECrypto, aName + std::wstring (L" is invalid"));

		}

	}

void CSisCertificateChain::Load (const std::wstring& aName)

	{

	try

		{

		LoadText (aName);

		return;

		}

	catch (...)

		{

		try

			{

			LoadBinary (aName);

			return;

			}

		catch (...)

			{

			}

		throw;

		}

	}

X509* CSisCertificateChain::GetX509 (CSISFieldRoot::TFieldSize& aOffset) const

	{

	if (aOffset >= iSisCertChain.CertificateData().Size ())

		{

		return NULL;

		}

	return BlobToX509 (iSisCertChain.CertificateData(), aOffset);

	}

X509* CSisCertificateChain::GetBottomX509 () const

	{

	CSISFieldRoot::TFieldSize offset = 0;

	X509* reply = GetX509(offset);

	return reply;

	}

void CSisCertificateChain::ExtractCertificateChain (std::string& aCertFileName)

{

	ERR_clear_error();

	CSISFieldRoot::TFieldSize offset = 0;

	for(int i = 0; i < iCertificateList.size(); ++i)

		{

		iCertificateList[i]->ExtractCertificate(aCertFileName);

		}

	}