/*
* Copyright (c) 2009 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:
*
*/
#include "trustrootpolicy.h"
#include <openssl/x509.h>
#include <openssl/x509v3.h>
#include <openssl/bio.h>
#include "javasymbianoslayer.h"

_LIT(KLegacyCertsPath,           "z:\\private\\10203636\\security\\trustroots\\device\\certificates\\");
_LIT(KOmjCertsPath,              "c:\\private\\200211dc\\security\\trustroots\\device\\certificates\\");
_LIT8(KOmjCertsPath8,              "c:\\private\\200211dc\\security\\trustroots\\device\\certificates\\");
_LIT(KOmjCertsTmpPath,              "c:\\private\\200211dc\\security\\trustroots\\device\\certificates\\tmp\\");
_LIT8(KOmjCertsTmpPath8,              "c:\\private\\200211dc\\security\\trustroots\\device\\certificates\\tmp\\");
_LIT(KLegacyTrustRootPolicyPath, "z:\\private\\10203636\\security\\midp2_trp.xml");
_LIT(KLegacyCertsStatesPath,    "c:\\private\\10203636\\security\\trustroots\\device\\state\\");
_LIT(KOmjCertsStatesPath,       "c:\\private\\200211dc\\security\\trustroots\\device\\state\\");

static bool CertsCopyNeeded()
{
    _LIT(KSystemAmsSid, "10203636");
    return (KOmjCertsPath().Find(KSystemAmsSid) == -1);
}

static void MoveFileL(const TDesC& oldPath, const TDesC& newPath, RFs& fsSession)
{
    CFileMan* fileMan = CFileMan::NewL(fsSession);
    CleanupStack::PushL(fileMan);
    fileMan->Move(oldPath, newPath);
    CleanupStack::PopAndDestroy();
}

static void RemoveDirL(const TDesC& dirName, RFs& fsSession)
{
    CFileMan* fileMan = CFileMan::NewL(fsSession);
    CleanupStack::PushL(fileMan);
    fileMan->RmDir(dirName);
    CleanupStack::PopAndDestroy();
}

static string GetDomainName(string domainId)
{
    string domainName = "";
    if (domainId == "*MFD*"
            || domainId == "*MFDU*")
    {
        domainName = "Manufacturer";
    }
    else if (domainId == "*OPD*"
             || domainId == "*OPDU*"
             || domainId == "*ODOPDU*"
             || domainId == "*ODOPD*")
    {
        domainName = "Operator";
    }
    else if (domainId == "*TTPD*")
    {
        domainName = "IdentifiedThirdParty";
    }
    return domainName;
}

static string GetDomainCategory(string domainId)
{
    string domainCategory = "";
    if (domainId == "*MFD*"
            || domainId == "*MFDU*")
    {
        domainCategory = "MFD";
    }
    else if (domainId == "*OPD*"
             || domainId == "*ODOPD*"
             || domainId == "*OPDU*"
             || domainId == "*ODOPDU*")
    {
        domainCategory = "OPD";
    }
    else if (domainId == "*TTPD*")
    {
        domainCategory = "ITPD";
    }
    return domainCategory;
}

static string GetHash(string trustRootPath)
{
    /* The length of the MD5 digest (32 digit hexadecimal number) */
    const int MD5_DIGEST_LEN = 8;
    char trustRootHash[MD5_DIGEST_LEN + 1];
    trustRootHash[0] = '\0';

    FILE* trustRootDataFile = fopen(trustRootPath.c_str(), "r");
    if (trustRootDataFile != NULL)
    {
        if (fseek(trustRootDataFile, 0L, SEEK_END) == 0)
        {
            long  trustRootDataLen = ftell(trustRootDataFile);
            if (trustRootDataLen > 0)
            {
                if (fseek(trustRootDataFile, 0L, SEEK_SET) == 0)
                {
                    char* trustRootData = new char[trustRootDataLen];
                    if (trustRootData != NULL)
                    {
                        fread(trustRootData, sizeof(char), trustRootDataLen, trustRootDataFile);
                        if (!ferror(trustRootDataFile))
                        {
                            BIO*  bio = BIO_new_mem_buf((void *) trustRootData, trustRootDataLen);
                            if ((bio))
                            {
                                BIO_set_close(bio, BIO_CLOSE);
                                X509* trustRootCert = d2i_X509_bio(bio,NULL);
                                if (trustRootCert != NULL)
                                {
                                    sprintf(trustRootHash,"%08lX",X509_issuer_name_hash(trustRootCert));
                                    trustRootHash[MD5_DIGEST_LEN] = '\0';
                                    delete trustRootCert;
                                    trustRootCert = NULL;
                                }
                            }
                            BIO_free(bio);
                        }
                        delete[] trustRootData;
                    }
                }
            }
        }
        fclose(trustRootDataFile);
    }
    return string(trustRootHash);
}

static void CopyFilesL(const TDesC& aSource, const TDesC& aDest, RFs& fsSession)
{
    // Create file management object
    CFileMan* fileMan = CFileMan::NewL(fsSession);
    CleanupStack::PushL(fileMan);

    // Do copy (here synchronously)
    fileMan->Copy(aSource, aDest, CFileMan::EOverWrite|CFileMan::ERecurse);
    // clear the read-only attribute
    _LIT(KWildCards,"*");
    HBufC* newDir = HBufC::NewLC(aDest.Length() + 1);
    TPtr ptr = newDir->Des();
    ptr.Copy(aDest);
    ptr.Append(KWildCards);
    fileMan->Attribs(ptr,KEntryAttNormal, KEntryAttReadOnly, TTime(0),CFileMan::ERecurse);
    CleanupStack::PopAndDestroy(newDir);

    // Clean up
    CleanupStack::PopAndDestroy();
}

static void HandleTrustRootsL(const std::vector<TrustRoot>& aConfiguredTrustRoots, RFs& fsSession)
{
    string path((const char *)KOmjCertsPath8().Ptr(), KOmjCertsPath8().Length());
    string tmpPath;
    if (!CertsCopyNeeded())
    {
        tmpPath = path;
    }
    else
    {
        tmpPath = string((const char *)KOmjCertsTmpPath8().Ptr(), KOmjCertsTmpPath8().Length());
    }
    for (int i=0; i<aConfiguredTrustRoots.size(); i++)
    {
        TrustRoot trustRoot = aConfiguredTrustRoots[i];

        // check if the corresponding certificate exists
        string tmpBaseName = tmpPath + trustRoot.iName;
        string trustRootName = tmpBaseName + ".cer";
        string rootName = trustRoot.iName + ".cer";
        FILE* trustRootFile = fopen(trustRootName.c_str(), "r");
        if (trustRootFile == NULL)
        {
            trustRootName.clear();
            trustRootName = tmpBaseName + ".der";
            trustRootFile = fopen(trustRootName.c_str(), "r");
        }
        if (trustRootFile != NULL)
        {
            fclose(trustRootFile);
            string domainName = GetDomainName(trustRoot.iDomain);
            if (domainName == "")
            {
                continue;
            }
            string domainCategory = GetDomainCategory(trustRoot.iDomain);
            if (domainCategory == "")
            {
                continue;
            }
            string hash = GetHash(trustRootName);
            if (hash == "")
            {
                continue;
            }
            // generate the metadata
            string baseName = path + trustRoot.iName;
            FILE * metadataFile = fopen((baseName + ".metadata").c_str(), "w+");
            if (metadataFile != NULL)
            {
                // copy the cert from tmp
                if (CertsCopyNeeded())
                {
                    HBufC* tmp = stringToDes(trustRootName.c_str());
                    CleanupStack::PushL(tmp);
                    TPtr ptr = tmp->Des();
                    MoveFileL(ptr, KOmjCertsPath, fsSession);
                    CleanupStack::PopAndDestroy(tmp);
                }

                // generate the metadatafile
                fprintf(metadataFile, "name=%s\n", domainName.c_str());
                fprintf(metadataFile, "category=%s\n", domainCategory.c_str());
                fprintf(metadataFile, "removable=%d\n", (trustRoot.iCanDelete == true));
                fprintf(metadataFile, "disablable=%d\n", (trustRoot.iCanDisable == true));
                fprintf(metadataFile, "hash=%s\n", hash.c_str());
                fclose(metadataFile);
            }
        }
    }
}


static void ConvertTrustRootPolicyL(RFs& fsSession)
{
    // read the trust root info
    CTrustRootPolicy* trustRootPolicy = CTrustRootPolicy::NewL();
    CleanupStack::PushL(trustRootPolicy);
    std::vector<TrustRoot> trustRoots;
    trustRootPolicy->ReadFromFileL(KLegacyTrustRootPolicyPath, trustRoots);
    CleanupStack::PopAndDestroy(trustRootPolicy);

    // generate trust roots metadata
    HandleTrustRootsL(trustRoots, fsSession);
}

static void CleanupL(RFs& fsSession)
{
    if (!CertsCopyNeeded())
    {
        return;
    }
    // delete the tmp directory (together with the leftovers = certificates without metadata)
    RemoveDirL(KOmjCertsTmpPath, fsSession);
}

static void CopyCertsL(RFs& fsSession)
{
    if (!CertsCopyNeeded())
    {
        return;
    }

    // copy all the files from KLegacyCertsPath to KOmjCertsPath
    CopyFilesL(KLegacyCertsPath, KOmjCertsTmpPath, fsSession);
    // copy all the files from KLegacyCertsStatesPath to KOmjCertsStatesPath
    CopyFilesL(KLegacyCertsStatesPath, KOmjCertsStatesPath, fsSession);
}

static void DoL()
{
    // open file server session
    RFs fsSession;
    User::LeaveIfError(fsSession.Connect());

    // copy the certs and state infos from legacy to omj
    CopyCertsL(fsSession);

    // convert the trust root policy from KLegacyTrustRootPolicyPath to KOmjCertsPath
    ConvertTrustRootPolicyL(fsSession);

    // cleanup
    CleanupL(fsSession);

    // close file server session
    fsSession.Close();
}

TInt E32Main()
{
    //__UHEAP_MARK;
    CTrapCleanup* cleanupStack = CTrapCleanup::New();
    TRAPD(error, DoL());
    delete cleanupStack;
    //__UHEAP_MARKEND;
    return error;
}