/*

* Copyright (c) 2002-2005 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 <s32mem.h>

#include <s32file.h>

#include <sysutil.h>

#include <SenBaseFragment.h>

#include <SenXmlUtils.h>

#include "msenidentitymanager.h"

#include "msenidentity.h"

#include "senbaseidentitymanager.h"

#include "sensecuritymechanismobserver.h"

#include "senlogger.h"

#include "sensecuritymechanism.h"  // internal  Framework\inc - ECOM interface

#include "senservicemanagerdefines.h" // KMaxTicks (1209600000)

                                      // 1 tick = 1 millisec

                                      // 86400 sec = 1 day

                                      // 86400*1000 millisec = 1 day

                                      // 86400*14*1000 = 1209600000 millisec = 2 weeks

#include "sendebug.h" // internal Utils\inc - filelogging MACROs

#include "sennotplugindlg.h" // internal NotifierPlugin\inc, KSenNotifierPluginUID

#include "senserviceinvocationframework.h"  // internal Framework\inc (framework event codes)

#ifndef __WINS__ // only required in release builds

// For reading IMEI. NOTE: not found from Series 60 2.1 public SDK

//Since plpvariant.h is depricated in TB9.2 from wk48 2009 on words.

//provided alternative solution  

//#include <plpvariant.h>

#endif

#include<SenBaseAttribute.h>

namespace

    {

    //_LIT8(KSenBaseIdentityManagerPanic, "SenBaseIdentityManager");

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

    _LIT(KIdentityFile, "C:\\system\\data\\senidentities.xml");

#else

    _LIT(KIdentityFile, "senidentities.xml");

#endif

    _LIT8(KSpace, " ");

    _LIT8(KUserName, "User");

    _LIT8(KUsersStart, "<Users><User>");

    _LIT8(KUsersEnd, "</User></Users>");

    _LIT8(KIdentityProvider, "IdentityProvider");

    _LIT8(KTouch, "touch");

    const TInt KFLATBUF_SIZE = 128;

    }

EXPORT_C CSenBaseIdentityManager* CSenBaseIdentityManager::NewL(

                                            MSenCoreServiceManager& aManager)

    {

    CSenBaseIdentityManager* pNew = NewLC(aManager);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenBaseIdentityManager* CSenBaseIdentityManager::NewLC(

                                            MSenCoreServiceManager& aManager)

    {

    CSenBaseIdentityManager* pNew =

                        new (ELeave) CSenBaseIdentityManager(aManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenBaseIdentityManager::CSenBaseIdentityManager(

                                            MSenCoreServiceManager& aManager)

:   iIdentity(NULL),

    iProvider(NULL),

    iManager(aManager),

    iConfigReadonly(EFalse),

    iLog((RFileLogger*)aManager.Log()),

    iObserver(NULL),

    ipMechanicsNames(NULL),

    ipDeviceID(NULL),

    iShowPasswordDialog(EFalse)

    {

    }

EXPORT_C CSenBaseIdentityManager::~CSenBaseIdentityManager()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::~CSenBaseIdentityManager");        

    iEcomInfoArray.ResetAndDestroy();

    iSechMechNames.ResetAndDestroy();

    iSechMechCues.ResetAndDestroy();

    delete ipMechanicsNames;

    delete iObserver;

    delete iProvider;

    delete ipDeviceID;

    }

void CSenBaseIdentityManager::ConstructL()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::ConstructL - Version 2 [2006-05-09]");        

    BaseConstructL(KIdentityElementLocalName);

    delete ipDeviceID;

    ipDeviceID=NULL;

    #ifndef __WINS__

	//Since plpvariant.h is depricated in TB9.2 from wk48 2009 on words.

	//provided alternative solution  

    /*

    // This only works on target machine

    TPlpVariantMachineId imei;

    PlpVariant::GetMachineIdL(imei);

    ipDeviceID = SenXmlUtils::ToUtf8LC(imei);

    CleanupStack::Pop(); // ipDeviceID

	*/

	TPtrC8 imei ;

	imei.Set(iManager.IMEI());

	ipDeviceID = imei.AllocL();

    #else

    // Return a fake IMEI when working on emulator

    _LIT8(KEmulatorImei, "012345678901234");

    ipDeviceID = KEmulatorImei().AllocL();

    #endif

    // Device ID is now resolved, fake or not

    TPtr8 imeiTPtr = ipDeviceID->Des();

    iIdentity = CSenBaseIdentity::NewL(imeiTPtr);

    HBufC* file = KIdentityFile().AllocL();

    CleanupStack::PushL(file);

    LoadFromL(*file, *iManager.XMLReader());

    // ValidateDefaultIdentity()

    ReloadSenSecurityMechanismsL();

    iObserver = CSenSenSecurityMechanismObserver::NewL(*this);

    iObserver->Start();

    CleanupStack::PopAndDestroy(); // file

    }

RFileLogger* CSenBaseIdentityManager::Log()

    {

    return iLog;

    }

void CSenBaseIdentityManager::LoadFromL(TDesC& aFile,

                                                 CSenXmlReader& aReader)

    {

    RFs fss;

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

    CleanupClosePushL(fss);

    aReader.SetContentHandler(*this);

    SetReader(aReader);

    TInt leaveCode(KErrNone);

#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )

    TBuf<KMaxPath> file;

    fss.CreatePrivatePath(EDriveC);

    fss.PrivatePath(file);

    file.Append(aFile);

    TRAP(leaveCode, aReader.ParseL(fss, file));

#else

    TRAP(leaveCode, aReader.ParseL(fss, aFile));

#endif

#ifdef _SENDEBUG

    if(leaveCode == KErrNotFound)

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- The senidentities.xml does not exist!");

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- New file will be generated.");

        }

    else if(leaveCode != KErrNone)

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("- Parsing of senidentities.xml leaved: %d"), leaveCode));

        }   

    else

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Identity database (senidentities.xml) successfully read.");

        }

#else

    leaveCode=0; // this is a decision: we are not interested 

                 // of invalid input in read/parse phase

#endif

    WriteDatabase(); // Always validate by saving

    CleanupStack::PopAndDestroy(); // fss

    }

EXPORT_C TInt CSenBaseIdentityManager::WriteDatabase()

    {

    TInt retVal(KErrNone);

    TRAP(retVal, WriteConfigurationToL(KIdentityFile));

    return retVal;

    }

void CSenBaseIdentityManager::StartElementL(

                                          const TDesC8& aNsUri,

                                          const TDesC8& aLocalName,

                                          const TDesC8& aQName,

                                          const RAttributeArray& aAttributes

                                                  )

    {

    if (aLocalName ==  KIdentityElementLocalName)

        {

        delete iIdentity;   // there can be only one at the moment

        iIdentity = NULL;

        TPtr8 imei = ipDeviceID->Des();

        iIdentity = CSenBaseIdentity::NewL(imei);

        iIdentity->SetAttributesL(aAttributes);

        iIdentity->SetReader(*Reader());

        DelegateParsingL(*iIdentity);

        }

//  else if (aLocalName == KUsers)

//      {

//      }

    else

        {

        CSenBaseFragment::StartElementL(aNsUri, 

                                    aLocalName, aQName, aAttributes);

        }

    }

MSenIdentity& CSenBaseIdentityManager::IdentityL()

    {

    return (MSenIdentity&)*iIdentity;

    }

TInt CSenBaseIdentityManager::UserNameL(HBufC8*& aUserName)

    {

    delete aUserName;

    aUserName = NULL;

    aUserName = KUserName().AllocL();

    return KErrNone;

    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL()

    {

    return IdentityL().IdentityProviderL();

    }

const RPointerArray<CSenIdentityProvider>& CSenBaseIdentityManager::IdentityProvidersL()

    {

    return IdentityL().IdentityProvidersL();

    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(

                            MSenServiceDescription& aServiceDescription )

    {

    return IdentityL().IdentityProviderL( aServiceDescription );

    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(

                                                        const TDesC8& aURI )

    {

    return IdentityL().IdentityProviderL(aURI);

    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(

                                                const CDesC8Array& aIdpList,

                                                TBool aStrict)

    {

    return IdentityL().IdentityProviderL(aIdpList,aStrict);

    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(

                                MSenServiceDescription& aServiceDescription,

                                const CDesC8Array& aIdpList,

                                TBool aStrict)

    {

    return IdentityL().IdentityProviderL(aServiceDescription,aIdpList,aStrict);

    }

// Takes ownership of given IdentityProvider(!)

TInt CSenBaseIdentityManager::RegisterIdentityProviderL( CSenIdentityProvider* apIdp )

    {

    if(!apIdp)

        {

        return KErrArgument; // NULL given!

        }

    CleanupStack::PushL(apIdp);

    // try to register into default identity

    // null check done, above

    TInt retVal = IdentityL().RegisterIdentityProviderL(apIdp);

    CleanupStack::Pop(); // apIdp, ownership elsewhere

    // check success:

    if ( retVal == KErrNone)

        {

        // ownership taken, pop from stack:

        // try to serialize owned object

        TInt notifyLeaveCode(KErrNone);

        TRAP(notifyLeaveCode, iManager.NotifyFrameworksL(KSenEventRegisterIdentityProvider, apIdp));

        if ( WriteDatabase() != KErrNone)

            {

            retVal = KErrWrite;

            }

        }

    return retVal;

    }

TInt CSenBaseIdentityManager::UnregisterIdentityProviderL( CSenIdentityProvider& aIdp )

    {

    TInt retVal = IdentityL().UnregisterIdentityProviderL( aIdp );

    if ( retVal == KErrNone )

        {

        TInt notifyLeaveCode(KErrNone);

        TRAP(notifyLeaveCode, iManager.NotifyFrameworksL(KSenEventUnregisterIdentityProvider, &aIdp));

//      if (KErrNone != WriteDatabase() )

//          {

//          retVal = EFalse;

//          }

        retVal = WriteDatabase();

        }

    return retVal;

    }

TBool CSenBaseIdentityManager::AssociateServiceL( const TDesC8& aServiceID,

                                                  const TDesC8& aProviderID )

    {

    TBool retVal = IdentityL().AssociateServiceL(aServiceID, aProviderID);

    if (retVal)

        {

        if (KErrNone != WriteDatabase())

            {

            retVal = EFalse;

            }

        }

    return retVal;

    }

TBool CSenBaseIdentityManager::DissociateServiceL(

                                                   const TDesC8& aServiceID,

                                                   const TDesC8& aProviderID )

    {

    TBool retVal = IdentityL().DissociateServiceL(aServiceID, aProviderID);

    if (retVal)

        {

        if (KErrNone != WriteDatabase())

            {

            retVal = EFalse;

            }

        }

    return retVal;

    }

TInt CSenBaseIdentityManager::IdentitiesL(

                                            CDesC8Array& /* aIdentitiesList */)

    {

    return KErrNotSupported; // not yet supported.

    }

// NOTE! This code does not do as documentation states.

// Only second line text is shown and

// "Ok" button on the left side.

// return the value of button pressed (OK or CANCEL)

TInt CSenBaseIdentityManager::YesNoQueryL(const TDesC& aLine1,

                                          const TDesC& aLine2,

                                          const TDesC& aButton1,

                                          const TDesC& aButton2)

    {

    RNotifier notifier;

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

    CleanupClosePushL(notifier);

    TRequestStatus status;

    TInt buttonVal = -1;

    // NOTE! This code does not do as documentation states.

    // Only second line text is shown and

    // "Ok" button on the left side.

//    notifier.Notify(_L("Line 1 text"), _L("Line2 text"),

//        _L("B1Txt"), _L("B2Txt"), buttonVal, status);

    notifier.Notify(aLine1,

                    aLine2,

                    aButton1,

                    aButton2,

                    buttonVal,

                    status);

    User::WaitForRequest(status);

    CleanupStack::PopAndDestroy(); // Close notifier

#ifdef _SENDEBUG

    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("User pressed button (%d)"), buttonVal));

#endif

    return buttonVal;

    }

TBool CSenBaseIdentityManager::AllowSavePasswordL()

    {

    TBool retVal = EFalse;

    RNotifier notifier;

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

    CleanupClosePushL(notifier);

    TPckgBuf<TAskSaveDlgRequest>* request = new(ELeave)TPckgBuf<TAskSaveDlgRequest>();

    CleanupStack::PushL(request);

    TPckgBuf<TAskSaveDlgResponse>* response = new(ELeave)TPckgBuf<TAskSaveDlgResponse>();

    CleanupStack::PushL(response);

    TRequestStatus reqStatus;

    notifier.StartNotifierAndGetResponse(reqStatus, KSenNotifierPluginUID, *request, *response);

    User::WaitForRequest(reqStatus);

    notifier.Close();

    if(reqStatus.Int() == KErrNone)

        {

        if((*response)().OkButtonPressed())

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed OK Button to allow password saving")));

            retVal = ETrue;

            }

#ifdef _SENDEBUG

        else

            {

            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed Cancel Button to deny password saving")));

            }

#endif

        }

#ifdef _SENDEBUG

    else if(reqStatus.Int() == KErrNotFound)

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Notifier plug-in for 'Save WS data?' -dialog was not found")));

        }

    else

        {

        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("'Save WS data?' -dialog returned an error: %d"), 

                                                        reqStatus.Int()));

        }

#endif

    CleanupStack::PopAndDestroy(2); // request, response;

    //CleanupStack::PopAndDestroy(); // close the notifier

    CleanupStack::Pop(); // notifier

    return retVal;

    }

TInt CSenBaseIdentityManager::AuthenticationForL(

                            CSenIdentityProvider& aProvider, 

                            TPckgBuf<TSenAuthentication>& aResponse)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::AuthenticationForL");

    TPtrC8 user = aProvider.AuthzID();

    if (user == KNullDesC8)

        {

        user.Set(aProvider.AdvisoryAuthnID());

        }

    if (!iShowPasswordDialog)

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Not allowed to show password dialog");

        HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password());

        TPtrC8 decodedPassword = pDecodedPassword->Des();

        aResponse().iUsername.Append((const TUint8*)user.Ptr(), user.Size());

        aResponse().iPassword.Append((const TUint8*)decodedPassword.Ptr(), 

                                        decodedPassword.Size());

        CleanupStack::PopAndDestroy(); // delete pDecodedPassword

        return KErrNone;

        }

    RNotifier notifier;

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

    CleanupClosePushL(notifier);

    TPckgBuf<TAuthenticationDlgRequest>* request = 

                            new(ELeave)TPckgBuf<TAuthenticationDlgRequest>();

    CleanupStack::PushL(request);

    // convert username to unicode

    HBufC* pUserAsUnicode = SenXmlUtils::ToUnicodeLC(user); // push

    TPtrC username = pUserAsUnicode->Des();