/*

* 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 <e32std.h>

#include <memory>

#include <javausermessages.rsg>

#include <stringresourcereader.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <securitydefs.h>

#else

#include <securitydefs.h>

#include <securitydefsconst.h>

#endif

#include "javacertstoreimpl.h"

#include "javacertstoretoken.h"

#include "logger.h"

#include "javasymbianoslayer.h"

#include "comms.h"

#include "javacertstoretoken.h"

#include "javacommonutils.h"

#include "s60commonutils.h"

#include "securitycommsmessagedefs.h"

//_LIT(KMIDP2TrustRoot, "J2ME MIDP2 Trust Root");

_LIT(KMIDP2TrustRoot, "Java Trust Root");

_LIT(KJavaUserMessagesResourceFileName, "javausermessages.rsc");

//_LIT( KRuntimeSecPolicyResourceFileName, "z:midp2runtimesecuritypolicy.rsc" );

//const TUid KCertManUIViewTrustJavaInstallingId = { 0x101F9B28 };

//const TUid KCertManUIViewTrustJavaInstallingId = { KMidletInstallApplicabilityUi };

using namespace java::security;

using namespace java::comms;

/**

 *

 */

CJavaCertStoreImpl::CJavaCertStoreImpl(CJavaCertStoreToken& aToken)

{

}

/**

 *

 */

CJavaCertStoreImpl::~CJavaCertStoreImpl()

{

    if (IsActive())

    {

        Cancel();

    }

    mComms.unregisterDefaultListener(this);

    mComms.disconnect();

    mCertsData.ResetAndDestroy();

    mUiThread.Close();

}

/**

 *

 */

CJavaCertStoreImpl* CJavaCertStoreImpl::NewL(CJavaCertStoreToken& aToken)

{

    CJavaCertStoreImpl* impl = new(ELeave) CJavaCertStoreImpl(aToken);

    CleanupStack::PushL(impl);

    impl->ConstructL();

    CleanupStack::Pop(impl);

    return impl;

}

/**

 *

 */

void CJavaCertStoreImpl::ConstructL()

{

    CActiveScheduler::Add(this);

    int err = mComms.registerDefaultListener(this);

    if (0 != err)

    {

        std::string errTxt("Registering comms listener failed: ");

        errTxt.append(java::util::JavaCommonUtils::intToString(err));

        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

        User::Leave(KErrCouldNotConnect);

    }

    err = mComms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

    if (0 != err)

    {

        std::string errTxt("Comms connection failed: ");

        errTxt.append(java::util::JavaCommonUtils::intToString(err));

        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

        User::Leave(KErrCouldNotConnect);

    }

    err = mUiThread.Open(RThread().Id());

    if (KErrNone != err)

    {

        std::string errTxt("Initialization of thread failed: ");

        errTxt.append(java::util::JavaCommonUtils::intToString(err));

        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

        User::Leave(err);

    }

}

/**

 *

 */

MCTToken& CJavaCertStoreImpl::Token()

{

    return mToken;

}

/**

 *

 */

void CJavaCertStoreImpl::processMessage(java::comms::CommsMessage& aMessage)

{

    //Request has been cancelled if it is not active anymore.

    if (!IsActive())

        return;

    mReceivedCommsMsg = aMessage;

    //ActiveScheduler calls RunL() operation after request has been completed.

    TRequestStatus* stat = &iStatus;

    mUiThread.RequestComplete(stat,KErrNone);

}

/**

 *

 */

void CJavaCertStoreImpl::RunL()

{

    TInt status = iStatus.Int();

    switch (mState)

    {

    case EListing:

        mState = EInitial;

        //In current implementation status cannot be any than KErrNone

        //in this state.

        if (KErrNone == status)

        {

            FillCertificateInfos(*mClientList);

        }

        break;

    case EPreDisabling:

        SendDisableMsg(status);

        return;

    case EPreDeleting:

        SendDeleteMsg(status);

        return;

    default:

        //Do nothing.

        break;

    }

    User::RequestComplete(mClientStatus,status);

}

/**

 *

 */

void CJavaCertStoreImpl::DoCancel()

{

    if (IsActive() && mClientStatus)

    {

        User::RequestComplete(mClientStatus,KErrCancel);

    }

}

/**

 *

 */

TInt CJavaCertStoreImpl::RunError(TInt /*aError*/)

{

    return KErrNone;

}

/**

 *

 */

void CJavaCertStoreImpl::Add(const TDesC& /*aLabel*/, TCertificateFormat,

                             TCertificateOwnerType,

                             const TKeyIdentifier* /*aSubjectKeyId*/,

                             const TKeyIdentifier* /*aIssuerKeyId*/,

                             const TDesC8& /*aCert*/, TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    User::RequestComplete(pRequestStatus,KErrNotSupported);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelAdd()

{

}

/**

 *

 */

void CJavaCertStoreImpl::Remove(const CCTCertInfo& aCertInfo,TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

    if (!flag)

    {

        return;

    }

    CJavaCertData* certData = 0;

    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

    if (!flag)

    {

        return;

    }

    if (!certData->mCanDelete)

    {

        User::RequestComplete(pRequestStatus,KErrArgument);

        return;

    }

    mState = EPreDeleting;

    mTempCertData = certData;

    HandleDeleteDisableQuery(aStatus, false /* disableCertQuery */);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelRemove()

{

}

/**

 *

 */

void CJavaCertStoreImpl::SetApplicability(const CCTCertInfo& aCertInfo,

        const RArray<TUid>& aApplications,

        TRequestStatus &aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

    if (!flag)

    {

        return;

    }

    TState state = EPreDisabling;

    for (TInt i = 0; i < aApplications.Count(); i++)

    {

        if (KMidletInstallApplicabilityUid == aApplications[i])

        {

            state = EPreEnabling;

            break;

        }

    }

    CJavaCertData* certData = 0;

    //GetCertDataObj() operation checks whether cert is deleted.

    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

    if (!flag)

    {

        return;

    }

    if ((EPreDisabling == state) && (!certData->mCanDisable))

    {

        User::RequestComplete(pRequestStatus,KErrArgument);

        return;

    }

    if (EPreDisabling == state)

    {

//RD_JAVA_S60_RELEASE_5_0_IAD flag is needed because otherwise "disable cert" confirmation

//prompt is shown twice. First time by unicertstore plugin of legacy java and second

//time by unicertstore plugin of OMJ.

#ifdef RD_JAVA_S60_RELEASE_5_0_IAD

        HandleSendingEnableDisableMsg(pRequestStatus,EPreDisabling,*certData);

#else

        mState = state;

        mTempCertData = certData;

        HandleDeleteDisableQuery(aStatus, true /* disableCertQuery */);

#endif

        return;

    }

    HandleSendingEnableDisableMsg(pRequestStatus,EPreEnabling,*certData);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelSetApplicability()

{

}

/**

 *

 */

void CJavaCertStoreImpl::SetTrust(const CCTCertInfo& aCertInfo, TBool aTrusted,

                                  TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    TBool flag = CheckCapability(ECapabilityWriteDeviceData,pRequestStatus);

    if (!flag)

    {

        return;

    }

    CJavaCertData* certData = 0;

    flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

    if (!flag)

    {

        return;

    }

    if (!aTrusted)

    {

        User::RequestComplete(pRequestStatus,KErrArgument);

        return;

    }

    User::RequestComplete(pRequestStatus,KErrNone);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelSetTrust()

{

}

/**

 *

 */

void CJavaCertStoreImpl::List(RMPointerArray<CCTCertInfo>& aCerts,

                              const CCertAttributeFilter& aFilter,

                              TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    if (IsActive())

    {

        User::RequestComplete(pRequestStatus,KErrInUse);

        return;

    }

    TBool validRequest = validateCertAttrFilter(aFilter);

    if (!validRequest)

    {

        LOG(EJavaSecurity, EInfo, "No certificates matching the filter supplied");

        User::RequestComplete(pRequestStatus,KErrNone);

        return;

    }

    if (0 < mCertsData.Count())

    {

        TRAPD(err,FillCertInfoFromCacheL(aCerts));

        User::RequestComplete(pRequestStatus,err);

        return;

    }

    mClientStatus = &aStatus;

    mClientList = &aCerts;

    iStatus = KRequestPending;

    SetActive();

    CommsMessage commsMsg;

    commsMsg.setReceiver(IPC_ADDRESS_JAVA_CAPTAIN_C);

    commsMsg.setSender(IPC_ADDRESS_JAVA_CAPTAIN_C);

    commsMsg.setModuleId(PLUGIN_ID_JAVA_CERT_STORE_EXTENSION_C);

    commsMsg.setMessageId(JAVA_CERT_STORE_MSG_ID_REQUEST);

    commsMsg << JAVA_CERT_STORE_OPERATION_QUERY_CERTS;

    commsMsg << JAVA_CERT_STORE_QUERY_ID_FULL_DETAILS;

    commsMsg << JAVA_CERT_STORE_FILTER_ID_STATE

    << (JAVA_CERT_STORE_STATE_ENABLED | JAVA_CERT_STORE_STATE_DISABLED);

    int err = mComms.send(commsMsg);

    if (0 != err)

    {

        std::string errTxt("Sending a comms request failed: ");

        errTxt.append(java::util::JavaCommonUtils::intToString(err));

        ELOG1(EJavaSecurity, "ERROR!!! %s",errTxt.c_str());

        User::RequestComplete(mClientStatus, KErrCommsBreak);

    }

    mState = EListing;

}

/**

 *

 */

void CJavaCertStoreImpl::CancelList()

{

    if (IsActive())

    {

        Cancel();

    }

}

/**

 *

 */

void CJavaCertStoreImpl::GetCert(CCTCertInfo*& aCertInfo,

                                 const TCTTokenObjectHandle& aHandle,

                                 TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    TInt index = GetIndexToCertData(aHandle);

    if (-1 == index)

    {

        User::RequestComplete(pRequestStatus,KErrArgument);

        return;

    }

    CJavaCertData* certData = mCertsData[index];

    TRAPD(err,

          aCertInfo = CCTCertInfo::NewL(KMIDP2TrustRoot,EX509Certificate,

                                        ECACertificate,certData->mSizeOfCert,

                                        NULL,NULL,Token(),index,certData->mCanDelete);

         ); // TRAPD

    User::RequestComplete(pRequestStatus,err);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelGetCert()

{

}

/**

 *

 */

void CJavaCertStoreImpl::Applications(const CCTCertInfo& aCertInfo,RArray<TUid>& aApplications,

                                      TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    //GetIndexToCertData() operation checks deleted case.

    CJavaCertData* certData = 0;

    TBool flag = GetCertDataObj(aCertInfo,pRequestStatus,certData);

    if (!flag)

    {

        return;

    }

    TInt err = KErrNone;

    if (!certData->mIsDisabled)

    {

        err = aApplications.Append(KMidletInstallApplicabilityUid);

    }

    User::RequestComplete(pRequestStatus, err);

}

/**

 *

 */

void CJavaCertStoreImpl::CancelApplications()

{

}

/**

 *

 */

void CJavaCertStoreImpl::IsApplicable(const CCTCertInfo& aCertInfo,TUid aApplication,

                                      TBool& aIsApplicable,TRequestStatus& aStatus)

{

    aStatus = KRequestPending;

    TRequestStatus* pRequestStatus = &aStatus;

    if (KMidletInstallApplicabilityUid != aApplication)