/*

* ============================================================================

*  Name     : wapisecuritysettingsimpl.cpp 

*  Part of  : WAPI Security Settings UI

*

*  Description:

*      Implementation of class CWAPISecuritySettingsImpl.   

*      

*  Version: %version:  13.1.2 %

*

*  Copyright (C) 2008 Nokia Corporation.

*  This material, including documentation and any related 

*  computer programs, is protected by copyright controlled by 

*  Nokia Corporation. All rights are reserved. Copying, 

*  including reproducing, storing,  adapting or translating, any 

*  or all of this material requires the prior written consent of 

*  Nokia Corporation. This material also contains confidential 

*  information which may not be disclosed to others without the 

*  prior written consent of Nokia Corporation.

*

* ============================================================================

*/

// INCLUDE FILES

#include "wapisecuritysettingsimpl.h"

#include "wapisecuritysettingsuipanic.h"

#include "wapisecuritysettingsui.h"

#include <featmgr.h>

#include <cmdestinationext.h>

#include <cmmanagerext.h>

#include <wlancontainer.h>

// CONSTANT DECLARATIONS

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

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

// CWAPISecuritySettingsImpl::NewL

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

//

CWAPISecuritySettingsImpl* CWAPISecuritySettingsImpl::NewL()

    {

    CWAPISecuritySettingsImpl* settings = 

                                    new ( ELeave ) CWAPISecuritySettingsImpl();

    CleanupStack::PushL( settings );

    settings->ConstructL();

    CleanupStack::Pop( settings ); 

    return settings;    

    }

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

// CWAPISecuritySettingsImpl::CWAPISecuritySettingsImpl

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

//

CWAPISecuritySettingsImpl::CWAPISecuritySettingsImpl()

    {

    iUserCertInUse = KCertNone;

    iCACertInUse = KCertNone;

    iCertificatesLoaded = EFalse;

    }

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

// CWAPISecuritySettingsImpl::ConstructL

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

//

void CWAPISecuritySettingsImpl::ConstructL()

    {

    iCertificateStore =  CWapiCertificates::NewL(); 

    #if defined( _DEBUG ) || defined( DEBUG )

    RDebug::Print(_L("CWAPISecuritySettingsImpl::ConstructL, iCertificateStore created.") );

    #endif

    FeatureManager::InitializeLibL();

    }

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

// CWAPISecuritySettingsImpl::~CWAPISecuritySettingsImpl

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

//

CWAPISecuritySettingsImpl::~CWAPISecuritySettingsImpl()

    {

    if (iUserCertificates)

        {

        iUserCertificates->Close();

        delete iUserCertificates;

        }

    if (iUserCertificateData)

        {

        iUserCertificateData->Close();

        delete iUserCertificateData;

        }

    if (iCACertificates)

       {

       iCACertificates->Close();

       delete iCACertificates;

       }

    if (iCACertificateData)

        {

        iCACertificateData->Close();

        delete iCACertificateData;

        }

    delete iCertificateStore;

    FeatureManager::UnInitializeLib();

    }

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

// CWAPISecuritySettingsImpl::LoadL

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

//

void CWAPISecuritySettingsImpl::LoadL( TUint32 aIapRecordId, CMDBSession& aSession )

    {

    CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

                            (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( aIapRecordId );

    iapRecord->LoadL( aSession );

    TUint32 wlanServiceId = iapRecord->iService;

    CleanupStack::PopAndDestroy(iapRecord);

    #if defined( _DEBUG ) || defined( DEBUG )

    RDebug::Print(_L("CWAPISecuritySettingsImpl::LoadL, aIapId = %d, wlanServiceId = %d"),

            aIapRecordId, wlanServiceId );

    #endif

    if ( wlanServiceId == KUidNone )

        {

        return;

        }

    // search for the record    

    CMDBGenericRecord* generic = static_cast<CMDBGenericRecord*>( 

                                          CCDRecordBase::RecordFactoryL( 0 ) );

    CleanupStack::PushL( generic );    

    generic->InitializeL( TPtrC( WLAN_SERVICE ), NULL );

    generic->LoadL( aSession );

    CMDBField<TUint32>* sidField = static_cast<CMDBField<TUint32>*>

                             ( generic->GetFieldByIdL( KCDTIdWlanServiceId ) );

    // prime with service id                

    *sidField = wlanServiceId;

    if (generic->FindL( aSession ))

        {

        // Get authentication

        CMDBField<TUint>* enableWpaPskField = static_cast<CMDBField<TUint>*>

                          ( generic->GetFieldByIdL( KCDTIdWlanEnableWpaPsk ) );

        iWapiAuth = (*enableWpaPskField == 0 ) ? EWapiAuthCert : EWapiAuthPSK;

        // Get preshared key format

        CMDBField<CWAPISecuritySettings::TWapiKeyFormat>* wapiPskFormat = static_cast<CMDBField<CWAPISecuritySettings::TWapiKeyFormat>*>

                       ( generic->GetFieldByIdL( KCDTIdWlanFormatKey1 ) );

        iWapiKeyFormat = *wapiPskFormat;

        // Get preshared key

        CMDBField<TDesC8>* wpaPskField = static_cast<CMDBField<TDesC8>*>

                       ( generic->GetFieldByIdL( KCDTIdWlanWpaPreSharedKey ) );

        iWapiPSKKey = *wpaPskField;

        iWapiPSKKeySet = IsValidPsk(iWapiPSKKey);

        }

    // Save aIapRecordId for later certificate loading.

    iWlanServiceId = wlanServiceId;

    CleanupStack::PopAndDestroy( generic );

    }

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

// CWAPISecuritySettingsImpl::SaveL

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

//

void CWAPISecuritySettingsImpl::SaveL( TUint32 aIapRecordId, CMDBSession& aSession  ) const

    {

    CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *>

                            (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( aIapRecordId );

    iapRecord->LoadL( aSession );

    TUint32 wlanServiceId = iapRecord->iService;

    CleanupStack::PopAndDestroy(iapRecord);   

    #if defined( _DEBUG ) || defined( DEBUG )

    RDebug::Print(_L("CWAPISecuritySettingsImpl::SaveL, iapRecordId = %d, wlanServiceId = %d"),

            aIapRecordId, wlanServiceId );

    #endif

    // Load WLAN service table

    // first get WLAN table id

    CMDBGenericRecord* generic = static_cast<CMDBGenericRecord*>

        ( CCDRecordBase::RecordFactoryL( 0 ) );

    CleanupStack::PushL( generic );    

    generic->InitializeL( TPtrC( WLAN_SERVICE ), NULL );

    generic->LoadL( aSession );

    TMDBElementId wlanTableId = generic->TableId();

    CMDBField<TUint32>* sidField = static_cast<CMDBField<TUint32>*>

                             ( generic->GetFieldByIdL( KCDTIdWlanServiceId ) );

    // prime with service id                

    *sidField = wlanServiceId;

    TBool found = generic->FindL( aSession);

    // If loading failed, WLAN service record will be 

    // created and StoreL()-d, otherwise, ModifyL()

    // Set WPA mode

    CMDBField<TUint>* enableWpaPskField = static_cast<CMDBField<TUint>*>

                          ( generic->GetFieldByIdL( KCDTIdWlanEnableWpaPsk ) );

    enableWpaPskField->SetL( iWapiAuth == EWapiAuthPSK ? 1 : 0 );

    if (iWapiAuth == EWapiAuthPSK)

        {

        if (iWapiPSKKeySet)

            {

            // Save PreShared Key format

            CMDBField<TUint>* keyFormat = static_cast<CMDBField<TUint>*>

                                ( generic->GetFieldByIdL( KCDTIdWlanFormatKey1 ) );

            keyFormat->SetL( iWapiKeyFormat );

            // Save PreShared Key

            CMDBField<TDesC8>* wapiPskField = static_cast<CMDBField<TDesC8>*>

                               ( generic->GetFieldByIdL( KCDTIdWlanWpaPreSharedKey ) );

            wapiPskField->SetL( iWapiPSKKey );

            // Save PreShared Key length

            CMDBField<TUint>* keyLengthField = static_cast<CMDBField<TUint>*>

                                ( generic->GetFieldByIdL( KCDTIdWlanWpaKeyLength ) );

            keyLengthField->SetL( iWapiPSKKey.Length() );

            }

        }

    // If certificates have not been loaded, i*CertInUse doesn't contain right values

    else if ( iCertificateStore && iCertificatesLoaded != EFalse)

        {

        #if defined( _DEBUG ) || defined( DEBUG )

        RDebug::Print(_L("Saving user cert index %d"), iUserCertInUse );

        RDebug::Print(_L("Saving CA cert index %d"), iCACertInUse );

        #endif  

        // "none" is communicated to wapicertificates as zero length identity

        TBuf8<KMaxIdentityLength> certNone;

        certNone.Zero();

        if (iUserCertInUse == KCertNone)

            {

            iCertificateStore->SetUserCertL( wlanServiceId, certNone);

            }

        else

            {

            iCertificateStore->SetUserCertL( wlanServiceId, (*iUserCertificateData)[iUserCertInUse]);

            }

        if (iCACertInUse == KCertNone)

            {

            iCertificateStore->SetCACertL( wlanServiceId, certNone);

            }

        else

            {

            iCertificateStore->SetCACertL( wlanServiceId, (*iCACertificateData)[iCACertInUse]);

            }

        }

    // Saving changes

    if ( !found )

        {

        // there wasn't any wlan service record, we have to create it now

        generic->SetRecordId( KCDNewRecordRequest );

        generic->StoreL( aSession );

        }

    else

        {

        // modify existing record

        generic->ModifyL( aSession );

        }

    CleanupStack::PopAndDestroy( generic );

    }

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

// CWAPISecuritySettingsImpl::SetPreSharedKeyL

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

//

void CWAPISecuritySettingsImpl::SetPreSharedKeyL( const CWAPISecuritySettings::TWapiKeyFormat aKeyFormat, const TDesC& aPreSharedKey )

    {

    HBufC8* buf8 = HBufC8::NewL( aPreSharedKey.Length() );

    TPtr8 pskPtr( buf8->Des() );

    pskPtr.Copy( aPreSharedKey ); 

    if ( !IsValidPsk( aKeyFormat, pskPtr ) )

        {

        delete buf8;

        User::Leave(KErrArgument);

        }

    SetAuthentication(EWapiAuthPSK);

    SetKeyFormat( aKeyFormat );

    SetWapiPSKKeyL( aPreSharedKey );

    delete buf8;

    }

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

// CWAPISecuritySettingsImpl::ResetCertificateStoreL

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

//

void CWAPISecuritySettingsImpl::ResetCertificateStoreL()

    {

    if ( iCertificateStore )

        {

        iCertificateStore->ResetCertificateStoreL();

        //Certificate store was reseted. Set certificates in use to "None" and

        //Close RARRAY's

        iUserCertInUse = KCertNone;

        iCACertInUse = KCertNone;

        // Reload certificate data: delete old and load new ones.

        if (iUserCertificates)

            {

            iUserCertificates->Close();

            delete iUserCertificates;

            iUserCertificates = NULL;

            }

        if (iUserCertificateData)

            {

            iUserCertificateData->Close();

            delete iUserCertificateData;

            iUserCertificateData = NULL;

            }

        if (iCACertificates)

            {

            iCACertificates->Close();

            delete iCACertificates;

            iCACertificates = NULL;

            }

        if (iCACertificateData)

            {

            iCACertificateData->Close();

            delete iCACertificateData;

            iCACertificateData = NULL;

            }

        iCertificateStore->GetAllCertificateLabelsL(

                &iUserCertificates, &iUserCertificateData,

                &iCACertificates, &iCACertificateData);

        }

    }

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

// CWAPISecuritySettingsImpl::LoadCertificatesL

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

//

void CWAPISecuritySettingsImpl::LoadCertificatesL()

    {

    #if defined( _DEBUG ) || defined( DEBUG )

    RDebug::Print(_L("LoadCertificatesL()"));

    #endif

    if ( iCertificateStore && iCertificatesLoaded == EFalse)

        {

        iCertificateStore->GetAllCertificateLabelsL(

                &iUserCertificates, &iUserCertificateData,

                &iCACertificates, &iCACertificateData);

        //Define local variables for certificate labels

        TBuf<KMaxLabelLength>               userCertLabel;

        TBuf<KMaxLabelLength>               CACertLabel;

        //Fetch configuration from EAPOL

        iCertificateStore->GetConfigurationL( 

                                    iWlanServiceId, CACertLabel, userCertLabel );

        #if defined( _DEBUG ) || defined( DEBUG )

        RDebug::Print(_L("CWAPISecuritySettingsImpl::LoadL, iWlanServiceId = %d"), iWlanServiceId );

        RDebug::Print(_L("CWAPISecuritySettingsImpl::LoadL, CACertLabel = %S"), &CACertLabel );

        RDebug::Print(_L("CWAPISecuritySettingsImpl::LoadL, userCertLabel = %S"), &userCertLabel );

        #endif

        //Fetch matching indexes

        iUserCertInUse = GetIndexByCertLabel(iUserCertificates, userCertLabel);

        iCACertInUse = GetIndexByCertLabel(iCACertificates, CACertLabel);

        #if defined( _DEBUG ) || defined( DEBUG )

        RDebug::Print(_L("iUserCertInUse = %d"), iUserCertInUse );

        RDebug::Print(_L("iCACertInUse = %d"), iCACertInUse );

        #endif

        // Don't load certificates again because it resets made configuration changes too.

        iCertificatesLoaded = ETrue;

        }

    }

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

// CWAPISecuritySettingsImpl::DeleteAPSpecificDataL

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

//

void CWAPISecuritySettingsImpl::DeleteAPSpecificDataL( const TInt aId )

    {

    if ( iCertificateStore )

        {

        iCertificateStore->DeleteAPSpecificDataL( aId );

        }

    }

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

// CWAPISecuritySettingsImpl::GetIndexByCertLabel

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

//

TInt CWAPISecuritySettingsImpl::GetIndexByCertLabel( 

                            RArray<TBuf<KMaxLabelLength> >* aCertificates, 

                            const TDesC& aCert )

    {

    if ( aCertificates )

        {

        for ( TInt i = 0; i < aCertificates->Count(); i++ )

            {

            if ( aCert.Compare((*aCertificates)[i])== 0 ) //Compare returns zero

                                                        //when result is matching

                {

                return i;

                }

            }

        }

    return KCertNone; // if certificate is not found return zero index

    }

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

// CWAPISecuritySettingsImpl::GetAuthentication

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

//

TWapiAuth CWAPISecuritySettingsImpl::GetAuthentication( )

    {

    return iWapiAuth;

    }

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

// CWAPISecuritySettingsImpl::SetAuthentication

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

//

void CWAPISecuritySettingsImpl::SetAuthentication( TWapiAuth aWapiAuth )

    {

    iWapiAuth = aWapiAuth;

    }

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

// CWAPISecuritySettingsImpl::GetKeyFormat

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

//

CWAPISecuritySettings::TWapiKeyFormat CWAPISecuritySettingsImpl::GetKeyFormat()

    {

    return iWapiKeyFormat;

    }

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

// CWAPISecuritySettingsImpl::SetKeyFormat

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

//

void CWAPISecuritySettingsImpl::SetKeyFormat( CWAPISecuritySettings::TWapiKeyFormat aWapiKeyFormat )

    {

    iWapiKeyFormat = aWapiKeyFormat;

    }

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

// CWAPISecuritySettingsImpl::GetWapiPSKKey

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

//

TBool CWAPISecuritySettingsImpl::hasWapiPSKKey()

    {

    return iWapiPSKKeySet;

    }

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

// CWAPISecuritySettingsImpl::SetWapiPSKKey

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

//

TInt CWAPISecuritySettingsImpl::SetWapiPSKKeyL( const TDesC& aWapiPSKKey )

    {

    TInt ret( KErrNone );

    #if defined( _DEBUG ) || defined( DEBUG )

    RDebug::Print(_L("CWAPISecuritySettingsImpl::SetWapiPSKKeyL te"));

    #endif

    HBufC8* buf8 = HBufC8::NewL( aWapiPSKKey.Length() );

    if ( buf8 )

        {

        TPtr8 pskPtr( buf8->Des() );

        pskPtr.Copy( aWapiPSKKey ); 

        if (IsValidPsk(pskPtr))

            {

            iWapiPSKKeySet = ETrue;

            iWapiPSKKey = pskPtr;

            iWapiAuth = EWapiAuthPSK;

            }

        else

            {

            ret = KErrArgument;

            }