/*

* 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 <string>

#include <fstream>

#include <openssl/err.h>

#include "parameter.h"

#include "siscontents.h"

#include "utility_interface.h"

#include "siscontroller.h"

#include "signsis.h"

#include "certificateinfo.h"

#include "sissignaturecertificatechain.h"

const char* KMonthString[]=

	{

	"Jan",

	"Feb",

	"Mar",

	"Apr",

	"May",

	"Jun",

	"Jul",

	"Aug",

	"Sep",

	"Oct",

	"Nov",

	"Dec"

	};

void DeletePEMFiles(std::string& aDirectorypath)

	{

	int certNumber = 1;

	char intChain[2];

	while(true)

		{

		std::string dirPath = aDirectorypath;

		itoa(certNumber,intChain,10);

		dirPath.append("/cert");

		dirPath.append(intChain) ;

		dirPath.append(".pem");

		if(remove(dirPath.c_str())==-1)

			{

			if(RemoveDirectoryA(dirPath.c_str()))

				{

				std::cout << "Cannot delete directory" << std::endl;

				}

			break;

			}

		certNumber++;

		}

	}

inline void PrintWithIndent(std::ostream& aStream, const std::string& aString, int aIndent)

	{

	aStream.width(aIndent);

	aStream << "";

	aStream << aString;

	}

inline void PrintWithIndent(std::wostream& aStream, const std::wstring& aString, int aIndent)

	{

	aStream.width(aIndent);

	aStream << L"";

	aStream << aString;

	}

void PrintExtensions(const std::vector<TExtension>& aExtensions, int aIndent)

	{

	if(aExtensions.size() > 0)

		{

		PrintWithIndent(std::cout, "X509v3 extensions:", aIndent);

		}

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

		{

		std::cout << std::endl;

		PrintWithIndent(std::cout, aExtensions[i].iExtensionName, aIndent+4); 

		std::cout << ": ";

		std::cout << (aExtensions[i].iIsCritical? "critical":"") << std::endl;

		if(aExtensions[i].iValue != "")

			{

			PrintWithIndent(std::cout, aExtensions[i].iValue, aIndent+4);

			std::cout << std::endl;  

			}

		else

			{

			for(int j = 0; j < aExtensions[i].iValueList.size(); ++j)

				{

				if(0 != j)

					{

					if(aExtensions[i].iIsMultiLine)

						{

						std::cout << std::endl;

						PrintWithIndent(std::cout, "", aIndent+4); 

						}

					else

						std::cout << ", ";

					}

				else

					{

					PrintWithIndent(std::cout, "", aIndent+4);

					}

				std::cout << aExtensions[i].iValueList[j].iName;

				if(aExtensions[i].iValueList[j].iName != "" && aExtensions[i].iValueList[j].iValue != "")

					{

					std::cout << ":";

					}

				std::cout << aExtensions[i].iValueList[j].iValue;

				}

			}

		std::cout << ((aExtensions[i].iIsMultiLine)? "\n": "") ;

		}

	}

void PrintDateTime(const CSISDateTime& aDateTime)

	{

	int year 	= aDateTime.Date().Year();

	int month 	= aDateTime.Date().Month();

	int day		= aDateTime.Date().Day();

	int hours 	= aDateTime.Time().Hours();

	int mins 	= aDateTime.Time().Minutes();

	int secs 	= aDateTime.Time().Seconds();

	printf("%s %d %02d:%02d:%02d %d GMT", KMonthString[month], day, hours, mins, secs, year);

	}

inline std::ostream& operator << (std::ostream& aStream, const CSISDate& aDate)

	{

	aStream << (int)aDate.Day() << "/" << (int)aDate.Month()+1 << "/" << (int)aDate.Year();

	return aStream; 

	}

void PrintCertificateInfo(CCertificateInfo* aCertInfo)

	{

	std::wcout << L"Issued by : " << aCertInfo->IssuerName(false) << "." << std::endl;

	std::wcout << L"Issued to : " << aCertInfo->SubjectName(false) << "." << std::endl;

	std::cout << "Valid from " << aCertInfo->ValidFrom().Date() << " to " <<  aCertInfo->ValidTo().Date() << std::endl;

	}

void PrintCertificateDetails(CCertificateInfo* aCertInfo)

	{

	std::cout << "Certificate: " << std::endl;

	PrintWithIndent(std::cout, "Data:", 4);

	std::cout << std::endl;

	int version = aCertInfo->Version();

	PrintWithIndent(std::cout, "Version: ", 8);

	std::cout << version+1 << "(0x" << version << ")" << std::endl;

	PrintWithIndent(std::cout, "Serial Number: ", 8);

	std::cout << aCertInfo->SerialNumber();

	std::cout << std::endl;

	PrintWithIndent(std::cout, "Signature Algorithm: ", 8);

	std::cout << aCertInfo->SignatureAlgo() << std::endl;

	PrintWithIndent(std::wcout, L"Issuer: ", 8);

	std::wcout << aCertInfo->IssuerName(true) << std::endl;

	PrintWithIndent(std::cout, "Validity", 8);

	std::cout << std::endl;

	PrintWithIndent(std::cout, "Not Before: ", 12);

	PrintDateTime(aCertInfo->ValidFrom());

	std::cout << std::endl;

	PrintWithIndent(std::cout, "Not After : ", 12);

	PrintDateTime(aCertInfo->ValidTo());

	std::cout << std::endl;

	PrintWithIndent(std::wcout, L"Subject: ", 8);

	std::wcout << aCertInfo->SubjectName(true) << std::endl;

	PrintWithIndent(std::cout, "Subject Public Key Info:", 8);

	std::cout << std::endl;

	PrintWithIndent(std::cout, "Public Key Algorithm: ", 12);

	std::cout << aCertInfo->PublicKeyAlgo() << std::endl;

	aCertInfo->PrintPublicKey(std::cout, 16);

	const std::vector<TExtension>& extList = aCertInfo->Extensions();

	PrintExtensions(extList, 8);

	aCertInfo->PrintSignature(std::cout, 12);

	}

void ReportSignatures(const CSISController& aController, bool aExtractCerts = false)

	{

	int signatureCount = aController.SignatureCount();

	if(0 == signatureCount)

		{

		std::cout << "No primary signatures." << std::endl;

		return;

		}

	std::string directoryPath = "Chain";

	if(aExtractCerts)

		{

		DeletePEMFiles(directoryPath);

		CreateDirectoryA(directoryPath.c_str(),NULL);

		}

	std::cout << std::endl << "Primary:" << std::endl;

	for(int i = 0; i < signatureCount; ++i)

		{

		CSignatureCertChainData& sigdata = const_cast<CSignatureCertChainData&>(aController.SignatureCertChain(i));

		CSisSignatureCertificateChain certChain(sigdata);

		const std::vector<CCertificateInfo*>& certList = certChain.CertChain();

		for(int j = 0; j < certList.size(); ++j)

			{

			if(aExtractCerts)

				{

				PrintCertificateDetails(certList[j]);

				}

			else

				{

				PrintCertificateInfo(certList[j]);

				std::cout << std::endl;

				}

			}

		if(aExtractCerts)

			{

			char intChain[2];

			itoa(i+1,intChain,10);

			std::string certFullPath = directoryPath + "/cert";

			certFullPath = certFullPath + intChain;

			certFullPath = certFullPath + ".pem";

			certChain.ExtractCertificateChain(certFullPath);

			}

		}

	}

int main(int argc, char *argv[])

	{

    wchar_t **argv1 = CommandLineArgs(argc,argv);

	CParameter parameter;

	if (! parameter.CommandLine (argc, argv1))

		{

		return 4;

		}

	if (parameter.Sis().empty())

		{

		cleanup(argc,argv1);

		return 0;

		}

	ERR_load_crypto_strings ();

	OpenSSL_add_all_algorithms ();

	OpenSSL_add_all_ciphers ();

	OpenSSL_add_all_digests ();

	int retValue = 0;

	try

		{

		bool isSisFile = CSISContents::IsSisFile(parameter.Sis ());

		if(isSisFile)

			{

			CSISContents content;

			content.Load (parameter.Sis ());

			CSignSis signsis(parameter.Sis ());

			if (parameter.Sign ())

				{

				if (parameter.Verbose ())

					{

					std::cout << "Signing" << std::endl;

					}

				signsis.SignSis(parameter.Output (), parameter.Certificate(), parameter.Key(), parameter.PassPhrase(), parameter.Algorithm());

				}

			if (parameter.Unsign ())

				{

				if (parameter.Verbose ())

					{

					std::cout << "Removing signature" << std::endl;

					}

				signsis.RemoveSignature (parameter.Output ());

				}

			if (parameter.Report() || parameter.ExtractCert())

				{

				ReportSignatures(content.Controller(), parameter.ExtractCert());

				}

			if (parameter.Dump ())

				{

				content.Dump (std::cout, 0);

				}

			}

		else

			{

			if (parameter.Report ()||parameter.ExtractCert())

				{

				std::cout<<"Reporting Stub Sis Controller"<<std::endl;

				CSISController ctrl;

				ctrl.Load (parameter.Sis ());

				ReportSignatures(ctrl, parameter.ExtractCert());

				}

			}

		}

	catch(const CSISException& oops)

		{

		std::wcout << oops.widewhat () << std::endl;

		retValue = 1;

		}

	catch (...)

		{

		std::wcout << L"Unexpected error." << std::endl;

		retValue = 1;

		}

	EVP_cleanup ();

	ERR_free_strings ();

	// cleanup the memory

	cleanup(argc,argv1);

	return retValue;

	}