/*

* 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:   Implementation of TrustedSitesStoreServer

*

*/

#include "TrustedSitesServer.h"

#include "TrustedSitesConduit.h"

#include "TrustedSitesSession.h"

#include "DevTokenCliServ.h"

#include "DevTokenUtil.h"

#include "DevTokenDataTypes.h"

#include "DevTokenServer.h"

#include "DevandTruSrvCertStoreServer.h"

#include <x509cert.h>

#include <ccertattributefilter.h>

#include <e32cmn.h>

#include <badesca.h>

_LIT(KTrustedSitesStoreFilename,"TrustedSitesStore.dat");

// Maximum length of SQL query clause

const TInt KMaxSQLLength = 256;

// API policing

_LIT_SECURITY_POLICY_C1(KReadSecurityPolicy, ECapabilityReadUserData);

_LIT_SECURITY_POLICY_C1(KWriteSecurityPolicy, ECapabilityWriteDeviceData);

// ======== MEMBER FUNCTIONS ========

//CTrustedSitesServer

// ---------------------------------------------------------------------------

// CTrustedSitesServer::NewL()

// ---------------------------------------------------------------------------

//

CTrustedSitesServer* CTrustedSitesServer::NewL( CDevTokenServer* aServer )

    {

    CTrustedSitesServer* self = new (ELeave) CTrustedSitesServer( aServer );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::CTrustedSitesServer()

// ---------------------------------------------------------------------------

//

CTrustedSitesServer::CTrustedSitesServer( CDevTokenServer* aServer ) :

    iServer ( aServer )

    {

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::ConstructL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::ConstructL()

    {

    iConduit = CTrustedSitesConduit::NewL(*this);

    User::LeaveIfError( iFs.Connect() );

    TBuf<KMaxFilenameLength> filename;

    FileUtils::MakePrivateFilenameL(iFs, KTrustedSitesStoreFilename, filename);

    TInt err = iDatabase.Open( iFs, filename );

    if ( err != KErrNone ) 

        {

        CreateDBL(); // Create DB

        User::LeaveIfError( iDatabase.Open( iFs, filename ) );

        }

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::CreateDBL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::CreateDBL()

    {

    RFs fsSession;

    User::LeaveIfError( fsSession.Connect() ); // Connect to file server

    CleanupClosePushL( fsSession );

    RDbNamedDatabase database;

    TBuf<KMaxFilenameLength> filename;

    FileUtils::MakePrivateFilenameL(fsSession, KTrustedSitesStoreFilename, filename);

    FileUtils::EnsurePathL(fsSession, filename);

    CleanupClosePushL( database );

    User::LeaveIfError( database.Create( fsSession, filename ) );

    // Create tables

    // Trusted sites table

    _LIT( KSQLCreateTable1, "CREATE TABLE Certificates (\

    CertID COUNTER NOT NULL,\

    CertHash CHAR(20) NOT NULL)");

    _LIT( KSQLCreateTable2, "CREATE TABLE TrustedSites (\

    CertID INTEGER,\

    SiteName VARCHAR(100) NOT NULL,\

    Forgiven INTEGER NOT NULL,\

    OutOfDate INTEGER NOT NULL,\

    ClientUID INTEGER NOT NULL )");                                      

    User::LeaveIfError( database.Execute( KSQLCreateTable1 ) );

    User::LeaveIfError( database.Execute( KSQLCreateTable2 ) );

    CleanupStack::PopAndDestroy( 2 ); // database, fsSession

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::~CTrustedSitesServer()

// ---------------------------------------------------------------------------

//

CTrustedSitesServer::~CTrustedSitesServer()

    {

    delete iConduit;

    iDatabase.Close();  // Close database

    iFs.Close();

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::CreateSessionL()

// ---------------------------------------------------------------------------

//

CTrustedSitesSession* CTrustedSitesServer::CreateSessionL()

    {

    return CTrustedSitesSession::NewL(*iConduit);

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::AddL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::AddL(const TDesC8& aCertHash, const TDesC& aSiteName, const RMessage2& aMessage )

    {

    // API policing

    if (!KWriteSecurityPolicy.CheckPolicy(aMessage))

        {

        User::Leave(KErrPermissionDenied);

        }

    TInt certID;

    GetCertIDL( aCertHash, certID ); // Get certificate ID

    if ( certID == KErrNotFound ) // Not found

        {

        iDatabase.Begin(); // Begin transaction

        TRAPD( err, DoAddCertL( aCertHash ));

        if ( err ) // Some error occurred

            {

            iDatabase.Rollback(); // Rollback changes

            User::Leave ( err );

            }

        else

            {

            iDatabase.Commit(); // Commit changes

            }

        GetCertIDL( aCertHash, certID );

        if( certID == KErrNotFound )

            {

            User::Leave( KErrNotFound );

            }

        iDatabase.Begin();

        TRAP( err, DoAddSiteNameL( certID, aSiteName ));

        if ( err ) // Some error occurred

            {

            iDatabase.Rollback(); // Rollback changes

            User::Leave ( err );

            }

        else

            {

            iDatabase.Commit(); // Commit changes

            }    

        }

    else

        {

        if(IsSiteAlreadyExistL( certID, aSiteName ))

            {

            return; 

            }

        else

            {

            iDatabase.Begin(); // Begin transaction

            TRAPD( err, DoAddSiteNameL( certID, aSiteName ));

            if ( err ) // Some error occurred

                {

                iDatabase.Rollback(); // Rollback changes

                User::Leave ( err );

                }

            else

                {

                iDatabase.Commit(); // Commit changes

                }

            return;   

            } 

        }  

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::AddL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::AddL(const TDesC8& aCertHash, const TDesC& aSiteName )

    {

    TInt certID;

    GetCertIDL( aCertHash, certID ); // Get certificate ID

    if ( certID == KErrNotFound ) // Not found

        {

        iDatabase.Begin(); // Begin transaction

        TRAPD( err, DoAddCertL( aCertHash ));

        if ( err ) // Some error occurred

            {

            iDatabase.Rollback(); // Rollback changes

            User::Leave ( err );

            }

        else

            {

            iDatabase.Commit(); // Commit changes

            }

        GetCertIDL( aCertHash, certID );

        if( certID == KErrNotFound )

            {

            User::Leave( KErrNotFound );

            }

        iDatabase.Begin();

        TRAP( err, DoAddSiteNameL( certID, aSiteName ));

        if ( err ) // Some error occurred

            {

            iDatabase.Rollback(); // Rollback changes

            User::Leave ( err );

            }

        else

            {

            iDatabase.Commit(); // Commit changes

            }    

        }

    else

        {

        if(IsSiteAlreadyExistL( certID, aSiteName ))

            {

            return; 

            }

        else

            {

            iDatabase.Begin(); // Begin transaction

            TRAPD( err, DoAddSiteNameL( certID, aSiteName ));

            if ( err ) // Some error occurred

                {

                iDatabase.Rollback(); // Rollback changes

                User::Leave ( err );

                }

            else

                {

                iDatabase.Commit(); // Commit changes

                }

            return;   

            } 

        }  

    }

// ---------------------------------------------------------------------------    

// CTrustedSitesServer::GetCertIDL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::GetCertIDL( const TDesC8& aCertHash, TInt& aCertID )

    {   

    _LIT( KSQLQuery, "SELECT CertID,\

    CertHash\

    FROM Certificates" );

    RDbView view;

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( KSQLQuery ) ) );

    CleanupClosePushL( view );

    // Get data

    TInt i = 0;

    while ( i == 0 && view.NextL() ) // Should find only one ID

        {

        view.GetL();

        if ( !view.ColDes8( 2 ).Compare( aCertHash ) )

            {

            aCertID = view.ColUint32( 1 );

            i++;

            }

        }

    if ( i == 0 ) // Not found any matching rows

        {

        aCertID = KErrNotFound;

        }

    CleanupStack::PopAndDestroy( 1 ); // view

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::DoAddSiteNameL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::DoAddSiteNameL(const TInt& aCertID, const TDesC& aSiteName )   

    {

    //insert the normal trusted site record,not for forgiven site

    TBuf<KMaxSQLLength> SQL;

    _LIT( KSQLInsert1,

    "INSERT INTO TrustedSites (CertID,SiteName,Forgiven,OutOfDate,ClientUID) VALUES (" );

    SQL.Copy(KSQLInsert1);

    SQL.AppendNum(aCertID);

    SQL.Append(_L(",'"));

    SQL.Append( aSiteName );

    SQL.Append(_L("',"));

    //not forgiven

    SQL.AppendNum(0);

    SQL.Append(_L(","));

    //not allowed out of date

    SQL.AppendNum(0); 

    //set the UID to -1 since in the normal case we don't need the information

    SQL.Append(_L(","));

    SQL.AppendNum(-1);

    SQL.Append(_L(")"));

    User::LeaveIfError( iDatabase.Execute( SQL ) );

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::DoAddCertL()

// ---------------------------------------------------------------------------

//

void CTrustedSitesServer::DoAddCertL( const TDesC8& aCertHash )

    {   

    RDbView view;

    _LIT( KSQLInsertCert, "SELECT CertHash\

    FROM Certificates" );

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( KSQLInsertCert ),

    TDbWindow::EUnlimited, RDbView::EInsertOnly ) );

    CleanupClosePushL( view );

    view.InsertL();

    view.SetColL( 1, aCertHash );

    view.PutL();

    CleanupStack::PopAndDestroy( 1 ); 

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::IsSiteAlreadyExistL()

// ---------------------------------------------------------------------------

//

TBool CTrustedSitesServer::IsSiteAlreadyExistL(const TInt& aCertID, const TDesC& aSiteName)

    {

    RDbView view;   

    _LIT( KSQLQuery, 

    "SELECT SiteName FROM TrustedSites WHERE certID = " );

    TBuf<KMaxSQLLength> SQLStatement;

    SQLStatement.Copy( KSQLQuery );

    SQLStatement.AppendNum( aCertID );

    TPtrC sqlStat( SQLStatement.PtrZ() );

    TInt err = view.Prepare( iDatabase, TDbQuery( sqlStat ), TDbWindow::EUnlimited );

    if ( err != KErrNone )

        {

        User::Leave( KErrArgument );

        }

    err = view.EvaluateAll();

    CleanupClosePushL( view );

    TBool alreadyExist = EFalse;

    // Get data

    while ( view.NextL() ) // Should find only one certificate

        {

        TRAPD(error, view.GetL());

        error = error;

        if(!aSiteName.Compare(view.ColDes( 1 )))

            {

            alreadyExist = ETrue;

            break;

            }

        }

    CleanupStack::PopAndDestroy( 1 ); 

    return alreadyExist;

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::IsOutOfDateAllowedForTheSiteL()

// ---------------------------------------------------------------------------

//

TBool CTrustedSitesServer::IsOutOfDateAllowedForTheSiteL( const TInt& aCertID, const TDesC& aSiteName )

    {

    RDbView view;   

    _LIT( KSQLQuery, 

    "SELECT SiteName,OutOfDate FROM TrustedSites WHERE certID = " );

    TBuf<KMaxSQLLength> SQLStatement;

    SQLStatement.Copy( KSQLQuery );

    SQLStatement.AppendNum( aCertID );

    TPtrC sqlStat( SQLStatement.PtrZ() );

    TInt err = view.Prepare( iDatabase, TDbQuery( sqlStat ), TDbWindow::EUnlimited );

    if ( err != KErrNone )

        {

        User::Leave( KErrArgument );

        }

    err = view.EvaluateAll();

    CleanupClosePushL( view );

    TBool outofdate = EFalse;

    // Get data

    while ( view.NextL() ) // Should find only one certificate

        {

        TRAPD(error, view.GetL());

        error = error;

        if ( (!aSiteName.Compare( view.ColDes( 1 ) ) ) && ( view.ColInt( 2 ) == 1 ) )

            {

            outofdate = ETrue;

            break;

            }

        }

    CleanupStack::PopAndDestroy( 1 ); //view

    return outofdate; 

    }

// ---------------------------------------------------------------------------

// CTrustedSitesServer::IsTrustedSiteL()

// ---------------------------------------------------------------------------

//

TBool CTrustedSitesServer::IsTrustedSiteL( const TDesC8& aCertHash, const TDesC& aSiteName, const TDesC8& aCert, const RMessage2& aMessage )

    {

    // API policing

    if (!KReadSecurityPolicy.CheckPolicy(aMessage))

        {

        User::Leave(KErrPermissionDenied);

        }

    //is it a forgiven site 

    if ( IsForgivenSiteAlreadyL( aSiteName ) )

        {

        // Insert the certificate into database

        DoOverWriteCertL( aSiteName, aCertHash );

        //check if the certificate is already existing

        CCertAttributeFilter* filter = CCertAttributeFilter::NewL();

        CleanupStack::PushL(filter);

        filter->SetOwnerType(EPeerCertificate);

        RPointerArray<CDevTokenCertInfo> certs;

        RMessage2 message;             

        iServer->CertStoreServerL().ListL( *filter,certs,message, ETrue  );            

        CleanupStack::PopAndDestroy(); //filter

        TBool exist = EFalse;

        if ( certs.Count() )

            {