/*

* Copyright (c) 2006-2010 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 FILES

#include "CTSecurityDialogsAO.h"

#include "CTSecurityDialogNotifier.h"

#include "CTPinQueryDialog.h"

#include "CTSignTextDialog.h"

#include "CTSelectCertificateDialog.h"

#include "CTQueryDialog.h"

#include "CTPinPinQueryDialog.h"

#include "CTUntrustedCertQuery.h"

#include "CTInvalidCertNote.h"

#include <PKIDlg.h>

#include <badesca.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <unifiedcertstore.h>

#include <unifiedkeystore.h>

#include <mctkeystore.h>

#include <cctcertinfo.h>

#include <DocumentHandler.h>

#include <apmstd.h>

#include <DigSigningNote.h>

//#include <certmanui.rsg>

#include <X509CertNameParser.h>

#include <x509cert.h>

#include <x500dn.h>

#include <hash.h>

#include <x509certext.h>

#include <TrustedSitesStore.h>

#include <mctwritablecertstore.h>

#include "SecQueryUi.h"                   // needed for password dialog

#include <hbdevicemessageboxsymbian.h>    // needed for Note dialogs    

#include <hbdevicenotificationdialogsymbian.h>

// LOCAL CONSTANTS AND MACROS

const TInt KCertArrayGranularity = 3;

const TInt KMaxLengthTextDetailsBody = 5000;

// CertLabel, Issuer, Owner max visible length

const TInt KMaxLengthTextCertLabelVisible = 200;

// "dd/mm/yyyy0"

const TInt KMaxLengthTextDateString = 20;

// Maximum length of a certificate

const TInt KMaxCertificateLength = 5000;

// Maximum length of key store password

const TInt KMaxKeystorePwLength = 6;

const TInt KMinImportKeyPwLen = 1;

const TInt KMaxCommonNameLength = 64;

const TUid KTrustedServerTokenUid = { 0x101FB66F };

const TUid KDeviceCertStoreTokenUid = { 0x101FB668 };

_LIT( KBlockSeparator, " " );

_LIT( KEnter, "\n" );

_LIT( KEnterEnter, "\n\n" );

_LIT( KKeyStoreEnterPwLabel, "Key store passphrase" );

_LIT( KKeyStoreCreatePwLabel, "New key store passphrase" );

_LIT( KKeyStoreImportKeyLabel, "Passphrase of the imported key file" );

_LIT( KKeyStoreExportKeyLabel, "Passphrase of the exported key file" );

_LIT( KPKCS12TokenLabel, "PKCS12");

// TODO: replace with OST tracing

#ifdef _DEBUG

#include <e32debug.h>

#define TRACE(x)        RDebug::Printf(x)

#define TRACE1(x,y)     RDebug::Printf(x,y)

#else

#define TRACE(x)

#define TRACE1(x,y)

#endif

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

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

// CCTSecurityDialogsAO::CCTSecurityDialogsAO

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCTSecurityDialogsAO::CCTSecurityDialogsAO( CCTSecurityDialogNotifier* aNotifier,

        TBool& aDeleted ) :

    CActive( EPriorityStandard ), iNotifier( aNotifier ),

    iNextStep( EOperationCompleted ), iTrustedSiteCertStore( 0 ),

    iHandleIndex( -1 ), iCertPtr( 0, 0 ), iDeleted( aDeleted )

    {

    CActiveScheduler::Add( this );

    }

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

// CCTSecurityDialogsAO::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCTSecurityDialogsAO::ConstructL()

    {

    iDeleted = EFalse;

    }

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

// CCTSecurityDialogsAO::NewL

// Two-phased constructor.

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

//

CCTSecurityDialogsAO* CCTSecurityDialogsAO::NewL( CCTSecurityDialogNotifier* aNotifier,

        TBool& aDeleted )

    {

    CCTSecurityDialogsAO* self = new( ELeave ) CCTSecurityDialogsAO( aNotifier, aDeleted );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCTSecurityDialogsAO::~CCTSecurityDialogsAO

// Destructor

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

//

CCTSecurityDialogsAO::~CCTSecurityDialogsAO()

    {

    Cancel();

    delete iText;

    delete iFilter;

    iCertHandleList.Close();

    if ( iCertArray )

        {

        //iCertArray->Reset(); // Should we reset this?

        //delete iCertArray;

        }

    iCertInfos.Close();

    if ( iCertInfo )

        {

        iCertInfo->Release(); // Should we release this?

        }

    iKeyInfos.Close();

    if ( iKeyInfo )

        {

        iKeyInfo->Release(); // Should we release this?

        }

    iServerCerts.ResetAndDestroy();

    delete iCertBuf;

    delete iServerName;

    delete iCertLabel;

    delete iKeyStore;

    delete iCertStore;

    iFs.Close();

    iDeleted = ETrue;

    }

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

// CCTSecurityDialogsAO::StartLD()

// Handles all the operations calls appropriate handler functionq

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

//

void CCTSecurityDialogsAO::StartLD(

    const TDesC8& aBuffer,

    TInt aReplySlot,

    const RMessagePtr2& aMessage )

    {

    iOperation = *reinterpret_cast<const TInt *>( aBuffer.Ptr() ) & KSecurityDialogOperationMask;

    iRetry = *reinterpret_cast<const TInt *>( aBuffer.Ptr() ) & EPINValueIncorrect;

    iReplySlot = aReplySlot;

    iMessagePtr = aMessage;

    WIMSECURITYDIALOGS_WRITE_FORMAT( "CCTSecurityDialogsAO::StartLD iOperation=%d", iOperation );

    TRACE1( "CCTSecurityDialogsAO::StartLD iOperation=%d", iOperation );

    MapTlsProviderOperation( iOperation );

    switch ( iOperation )

        {

        case EEnablePIN:  // flow thru

        case EDisablePIN: // flow thru

        case EEnterPIN:

        case EChangePIN:

            {

            TPINInput PINInput = reinterpret_cast<const TPINInput&>( *aBuffer.Ptr() );

            iPIN = PINInput.iPIN;

            DoHandlePinOperationL();

            iStatus = KRequestPending;

            SetActive();

            break;

            }

        case EUnblockPIN:

            {

            TUnblockPINInput unblockPINInput = reinterpret_cast<const TUnblockPINInput&>( *aBuffer.Ptr() );

            iPIN = unblockPINInput.iPIN;

            iUnblockPIN = unblockPINInput.iUnblockPIN;

            DoHandleUnblockPinOperationL();

            iStatus = KRequestPending;

            SetActive();

            break;

            }

        case EPINBlocked:

            {

            TPINInput PINInput = reinterpret_cast<const TPINInput&>( *aBuffer.Ptr() );

            iPIN = PINInput.iPIN;

            DoHandleMessageL( EErrorPinCodeBlocked, iPIN.iPINLabel, iPIN.iTokenLabel, 0, 0 );

            iMessagePtr.Complete( KErrNone );

            break;

            }

        case ETotalBlocked:

            {

            TPINInput PINInput = reinterpret_cast<const TPINInput&>( *aBuffer.Ptr() );

            iPIN = PINInput.iPIN;

            DoHandleMessageL( EErrorPukCodeBlocked, iPIN.iPINLabel, iPIN.iTokenLabel, 0, 0 );

            iMessagePtr.Complete( KErrNone );

            break;

            }

        case ESignText:

        case EUserAuthenticationText:

        case EUserAuthentication:

            {

            iSignInput = reinterpret_cast<const TSignInput&>( *aBuffer.Ptr() );

            DoHandleSignTextL( aBuffer );

            break;

            }

        case ECreateCSR:

            {

            DoHandleCSRL( aBuffer.Mid( sizeof(TInt) ) );

            break;

            }

        case EDeleteCert:

        case ECertDetails:

            {

            DoHandleCertDetailsL( aBuffer.Mid( sizeof(TInt) ) );

            break;

            }

        case ESaveCert:

            {

            DoHandleSaveCertL( aBuffer );

            break;

            }

        case EUnblockPINInClear:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        case EPinCodeBlockedInfo:

            {

            TPtrC8 pinLabelPtr = aBuffer.Mid( sizeof(TInt) + 1 );

            TPINLabel pinLabel;

            pinLabel.Copy( pinLabelPtr );

            HBufC* text = iNotifier->LoadResourceStringLC( iOperation, pinLabel );

            CCTSignTextDialog::RunDlgLD( R_WIM_UNBLOCK_INFO_DIALOG, *text, iStatus, iRetValue );

            CleanupStack::PopAndDestroy( text );

            iStatus = KRequestPending;

            SetActive();

            break;

            }

        case EServerAuthenticationFailure:

            {

            DoHandleServerAuthFailL( aBuffer );

            break;

            }

        case MPKIDialog::ESignatureRequested:

            {

            DoHandleMessageL( EInfoSignTextRequested, KNullDesC, KNullDesC, 1, KMaxTInt );

            iRetValue = ETrue;

            HandleResponseAndCompleteL();

            break;

            }

        case MPKIDialog::ESignatureDone:

            {

            DoHandleMessageL( EInfoSignTextDone, KNullDesC, KNullDesC, 1, KMaxTInt );

            iRetValue = ETrue;

            HandleResponseAndCompleteL();

            break;

            }

        case MPKIDialog::ESigningCancelled:

            {

            DoHandleMessageL( EInfoSignTextCancelled, KNullDesC, KNullDesC, 1, KMaxTInt );

            iRetValue = ETrue;

            HandleResponseAndCompleteL();

            break;

            }

        case MPKIDialog::ENoMatchCert:

            {

            DoHandleMessageL( ENoMatchingPersonalCert, KNullDesC, KNullDesC, 1, KMaxTInt );

            break;

            }

        case MPKIDialog::ENoSecurityModule:

            {

            DoHandleMessageL( EErrorWimNotAvailable, KNullDesC, KNullDesC, 1, KMaxTInt );

            iRetValue = ETrue;

            HandleResponseAndCompleteL();

            break;

            }

        case MPKIDialog::EInternalError:

            {

            DoHandleMessageL( EErrorInternal, KNullDesC, KNullDesC, 1, KMaxTInt );

            iRetValue = ETrue;

            HandleResponseAndCompleteL();

            break;

            }

        case ESaveReceipt:

            {

            SaveReceiptL( aBuffer.Mid( sizeof(TInt) ) );

            break;

            }

        default:

            User::Panic( _L("CTestSecDlgNotifier"), 0 );

            break;

        }

    // Note that CCTSecurityDialogsAO::StartLD() must complete the given message and

    // delete itself when ready. However, there may be several steps before it can be

    // deleted. CCTSecurityDialogsAO::HandleResponseAndCompleteL() completes the given

    // message and deletes CCTSecurityDialogsAO object. Hence, every operation handling

    // function called above must call HandleResponseAndCompleteL() when it is ready.

    }

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

// CCTSecurityDialogsAO::DoHandleServerAuthFailL(const TDesC8& aBuffer)

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

//

void CCTSecurityDialogsAO::DoHandleServerAuthFailL( const TDesC8& aBuffer )

    {

    TRACE( "CCTSecurityDialogsAO::DoHandleServerAuthFailL" );

    CServerAuthenticationFailureInput* srvAuthFail =

        CServerAuthenticationFailureInput::NewLC( aBuffer );

    TPtrC8 cert;

    TPtrC8 serverName;

    srvAuthFail->GetEncodedCert( cert );

    srvAuthFail->GetServerName( serverName );

    iAuthFailReason = srvAuthFail->FailureReason();

    CleanupStack::PopAndDestroy( srvAuthFail );

    iServerName = HBufC::NewL( serverName.Length() );

    iServerName->Des().Copy( serverName );

    iCertLabel = NULL;

    // Site will be checked later. For now it is not trusted

    iTrustedSite = EFalse;

    CX509Certificate* serverCert = CX509Certificate::NewLC( cert );

    const CX500DistinguishedName& dName = serverCert->SubjectName();

    HBufC* commonName = dName.ExtractFieldL( KX520CommonName );

    CleanupStack::PushL( commonName );

    if( commonName != NULL )

        {

        // Check the length of CN. RFC 3280 states

        // that max length of CN is 64.

        if( commonName->Length() <= KMaxCommonNameLength )

            {

            iCertLabel = HBufC::NewL( commonName->Length() );

            iCertLabel->Des().Append( commonName->Des() );

            }

        }

    CleanupStack::PopAndDestroy( commonName );

    if( iCertLabel == NULL )

        {

        // No or invalid commonName. Use domain name as label.

        iCertLabel = HBufC::NewL( iServerName->Length() );

        iCertLabel->Des().Append( iServerName->Des() );

        }

    CleanupStack::PopAndDestroy( serverCert );

    iCertBuf = HBufC8::NewL( cert.Length() );

    *iCertBuf = cert;

    InitCertStoreL();

    }

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

// CCTSecurityDialogsAO::DoHandleCertDetailsL(const TDesC8& aBuffer)

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

//

void CCTSecurityDialogsAO::DoHandleCertDetailsL( const TDesC8& aBuffer )

    {

    TCTTokenObjectHandle tokenHandle =

        reinterpret_cast<const TCTTokenObjectHandle&>( *aBuffer.Ptr() );

    iTokenHandle.iTokenHandle.iTokenTypeUid = tokenHandle.iTokenHandle.iTokenTypeUid;

    iTokenHandle.iTokenHandle.iTokenId = tokenHandle.iTokenHandle.iTokenId;

    iTokenHandle.iObjectId = tokenHandle.iObjectId;

    InitCertStoreL();

    }

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

// CCTSecurityDialogsAO::DoHandleSaveCertL(const TDesC8& aBuffer)

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

//

void CCTSecurityDialogsAO::DoHandleSaveCertL( const TDesC8& aBuffer )

    {

    TSaveCertInput saveCertInput =

        reinterpret_cast<const TSaveCertInput&>( *aBuffer.Ptr() );

    TInt start = sizeof( TSaveCertInput );

    delete iCertBuf;

    iCertBuf = NULL;

    iCertBuf = HBufC8::NewL( saveCertInput.iDataSize );

    const TUint8* certPtr = reinterpret_cast<const TUint8*>( aBuffer.Mid(start).Ptr() );

    iCertBuf->Des().Append( certPtr, saveCertInput.iDataSize );

    ShowCertDialogL();

    }

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

// CCTSecurityDialogsAO::DoHandleCSRL(const TDesC8& aBuffer)

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

//

void CCTSecurityDialogsAO::DoHandleCSRL( const TDesC8& aBuffer )

    {

    WIMSECURITYDIALOGS_ENTERFN("CCTSecurityDialogsAO::DoHandleCSRL");

    TInt length = reinterpret_cast<const TInt&>( *aBuffer.Ptr() );

    TInt start = sizeof( TInt ) + 1;

    iText = HBufC::NewL( length );

    iText->Des().Copy( aBuffer.Mid( start, length ) );

    start = start + length;

    const TUint8* bufferPtr = aBuffer.Ptr();

    bufferPtr += start;

    TCTTokenObjectHandle tokenHandle;

    TCTTokenObjectHandle* tokenHandlePtr = &tokenHandle;

    TUint8* copyPtr = reinterpret_cast< TUint8* >( tokenHandlePtr );

    for( TInt i = 0; i < 12; i++ )

        {

        copyPtr[ i ] = bufferPtr[ i ];

        }

    iTokenHandle.iTokenHandle.iTokenTypeUid = tokenHandle.iTokenHandle.iTokenTypeUid;

    iTokenHandle.iTokenHandle.iTokenId = tokenHandle.iTokenHandle.iTokenId;

    iTokenHandle.iObjectId = tokenHandle.iObjectId;

    InitKeyStoreL();

    iNextStep = EGetKeyInfoByHandle;

    WIMSECURITYDIALOGS_LEAVEFN("CCTSecurityDialogsAO::DoHandleCSRL");

    }

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

// CCTSecurityDialogsAO::DoHandleSignTextL()

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

//

void CCTSecurityDialogsAO::DoHandleSignTextL( const TDesC8& aBuffer )

    {

    TInt arraySize = sizeof( TCTTokenObjectHandle ) * iSignInput.iCertHandleArrayTotal;

    TInt start = sizeof( TSignInput );

    TInt end = start + arraySize;

    for (; start < end; start+=sizeof( TCTTokenObjectHandle ))

        {

        TCTTokenObjectHandle handle =

            reinterpret_cast<const TCTTokenObjectHandle&>(*aBuffer.Mid(start).Ptr());

        User::LeaveIfError( iCertHandleList.Append( handle ) );

        }

    start = end;

    HBufC* textToSign = NULL;

    if ( iOperation != EUserAuthentication )

        {

        textToSign = HBufC::NewLC( iSignInput.iVariableDataSize / 2 ); // 8 bit -> 16 bit descriptor

        //textToSign->Des().Copy(aBuffer.Mid(start));

        const TUint16* textToSignPtr = reinterpret_cast<const TUint16*>( aBuffer.Mid(start).Ptr() );

        textToSign->Des().Append( textToSignPtr, (iSignInput.iVariableDataSize / 2) );

        }

    if ( iCertHandleList.Count() > 0 )

        {

        iNextStep = EOperationSignTextShown;

        }

    else

        {

        iNextStep = EOperationCompleted;

        iCertHandleList.Close();

        }

    switch( iOperation )

        {

        case EUserAuthenticationText:

            {

            CCTSignTextDialog::RunDlgLD( R_WIM_USERAUTHTEXT_DIALOG,

                *textToSign, iStatus, iRetValue );

            break;

            }

        case EUserAuthentication:

            {

            DoHandleMessageL( EUserAuthentication, KNullDesC, KNullDesC, 1, KMaxTInt );

            break;

            }

        case ESignText:

            {

            CCTSignTextDialog::RunDlgLD( R_WIM_SIGNTEXT_DIALOG,*textToSign, iStatus, iRetValue );

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse,