diff -r c742e1129640 -r aa33c2cb9a50 applicationmanagement/server/src/amstorage.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applicationmanagement/server/src/amstorage.cpp	Tue Jul 06 14:06:19 2010 +0300
@@ -0,0 +1,643 @@
+/*
+ * Copyright (c) 2000 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 applicationmanagement components
+ *
+ */
+
+
+#include <centralrepository.h>
+#include <s32mem.h>
+#include <s32file.h>
+#include <e32des8.h>
+#ifndef __SERIES60_30__
+#include "AMAppHideUtil.h"
+#endif
+#include "debug.h"
+#include "amprivateCRKeys.h"
+#include "amstorage.h"
+#include "AMDeploymentComponent.h"
+
+using namespace NApplicationManagement;
+
+// CONSTANTS
+
+
+/***************************************************
+ // RComponentIdArray
+ ***************************************************/
+
+void RComponentIdArray::SetListL(const TDesC8& aChilds)
+    {
+#ifdef _DEBUG
+    HBufC *b = HBufC::NewLC(aChilds.Length() );
+    TPtr p(b->Des() );
+    p.Copy(aChilds);
+    RDEBUG_2( "RComponentIdArray::SetListL: Setting list from: '%S'", &p);
+    CleanupStack::PopAndDestroy(b);
+#endif
+
+    RDesReadStream buf(aChilds);
+    //TInt size( buf.Source()->TellL( MStreamBuf::ERead ).SizeL() );
+    TInt left(aChilds.Length() );
+    const TInt KSize(sizeof(TUint32));
+    while (left > 0)
+        {
+        TUint32 val(buf.ReadUint32L() );
+#ifdef _DEBUG
+        RDEBUG_2( "RComponentIdArray::SetListL: Appending id: '%d'", val);
+#endif
+        Append(val);
+        left -= KSize;
+        }
+    buf.Close();
+    }
+
+void RComponentIdArray::RemoveByValue(TUint32 aValue)
+    {
+    TInt ind(Find(aValue) );
+    Remove(ind);
+    }
+
+void RComponentIdArray::GetListLC(HBufC8 *&aChilds, TInt &aLength)
+    {
+    ASSERT( aChilds == NULL );
+    TInt c(Count() );
+    if (c > 0)
+        {
+        aLength = c * sizeof(TUint32);
+        aChilds = HBufC8::NewLC(aLength);
+        TPtr8 p(aChilds->Des() );
+        RDesWriteStream stream(p);
+        CleanupClosePushL(stream);
+        TInt i( 0);
+        do
+            {
+            stream.WriteUint32L(operator[](i) );
+            }
+        while ( ++i < c);
+        stream.CommitL();
+        CleanupStack::PopAndDestroy( &stream);
+        }
+    else
+        {
+        aChilds = KNullDesC8().AllocLC();
+        aLength = 0;
+        }
+    }
+
+/*	
+ void TCertInfoPckg::ExternalizeL(RWriteStream& aStream) const
+ {
+ aStream << iId;
+ TPckgBuf<TCertInfo>::ExternalizeL( aStream );
+ }
+
+ void TCertInfoPckg::InternalizeL(RReadStream& aStream)
+ {
+ 
+ }
+ */
+
+void RCertArray::ExternalizeL(RWriteStream& aStream) const
+    {
+    TInt c(Count() );
+    aStream.WriteInt32L(c);
+    for (TInt i( 0); i < c; i++)
+        {
+        aStream.WriteInt32L(i);
+        aStream << (*(operator[](i)));
+        }
+    }
+
+void RCertArray::InternalizeL(RReadStream& aStream)
+    {
+    TInt c(aStream.ReadInt32L() );
+    for (TInt i( 0); i < c; i++)
+        {
+        TCertInfoPckg *pkg = new ( ELeave ) TCertInfoPckg;
+        RDEBUG_2( "RCertArray::InternalizeL - allocated TCertInfoPckg 0x%X", reinterpret_cast<TUint>( pkg ) );
+        CleanupStack::PushL(pkg);
+        TInt idx(aStream.ReadInt32L() );
+        aStream >> (*pkg);
+        Append(pkg);
+        CleanupStack::Pop(pkg);
+        }
+    }
+
+TInt RCertArray::FindByValue(const TCertInfoPckg &aPckg)
+    {
+    TInt c(Count() );
+    for (TInt i( 0); i < c; i++)
+        {
+        if (operator[](i)->Compare(aPckg) == 0)
+            {
+            return i;
+            }
+        }
+    return KErrNotFound;
+    }
+
+/***************************************************
+ // CDeliveryComponentStorage
+ ***************************************************/
+
+CDeliveryComponentStorage::CDeliveryComponentStorage()
+    {
+
+    }
+
+void CDeliveryComponentStorage::ConstructL()
+    {
+#ifndef __SERIES60_30__
+    iHidder = CAMAppHideUtil::NewL();
+#endif
+    LoadCertsL();
+    TRAPD( erx, iRepository = CRepository::NewL ( KCRUidPrivateApplicationManagementKeys ) )
+    ;
+    if (erx != KErrNone)
+        {
+        RDEBUG_2( "CDeliveryComponentStorage::ConstructL() ERROR CentRep not initialized: Check deployment! %d", erx );
+        User::Leave(erx);
+        }
+    TInt err(iRepository->Get(KNextIdKey, iNextId) );
+    if (err == KErrNotFound)
+        {
+        iNextId = KMinIdValue;
+        User::LeaveIfError(iRepository->Create(KNextIdKey, iNextId) );
+        }
+    else
+        {
+        User::LeaveIfError(err);
+        }
+    LoadComponentsL();
+    }
+
+void CDeliveryComponentStorage::LoadCertsL()
+    {
+    RFs fs;
+    User::LeaveIfError(fs.Connect() );
+    CleanupClosePushL(fs);
+    TInt e(fs.CreatePrivatePath(KDefaultDrive) );
+
+    User::LeaveIfError(e);
+    TBuf<64> privatePath;
+    User::LeaveIfError(fs.PrivatePath(privatePath) );
+
+    TInt privPathLength(privatePath.Length() );
+    _LIT( KCertFile, "amcerts.dat");
+    HBufC *afile = HBufC::NewLC(privPathLength + KCertFile().Length());
+    *afile = privatePath;
+    afile->Des().Append(KCertFile);
+    RFileReadStream certFile;
+    TInt err(certFile.Open(fs, *afile, EFileRead) );
+    if (err == KErrNone)
+        {
+        CleanupClosePushL(certFile);
+        iCertificates.InternalizeL(certFile);
+        CleanupStack::PopAndDestroy( &certFile);
+        }
+    else
+        if (err == KErrNotFound)
+            {
+
+            }
+        else
+            {
+            User::Leave(err);
+            }
+    CleanupStack::PopAndDestroy(afile);
+    CleanupStack::PopAndDestroy( &fs);
+    }
+
+CDeliveryComponentStorage* CDeliveryComponentStorage::NewLC()
+    {
+    CDeliveryComponentStorage *self = new ( ELeave ) CDeliveryComponentStorage( );
+    CleanupStack::PushL(self) ;
+    self->ConstructL() ;
+    return self;
+    }
+
+CDeliveryComponentStorage* CDeliveryComponentStorage::NewL()
+    {
+    CDeliveryComponentStorage *self = NewLC();
+    CleanupStack::Pop(self) ;
+    return self;
+    }
+
+TInt CDeliveryComponentStorage::NextKey()
+    {
+    TInt oldNext(iNextId++);
+    iRepository->Set(KNextIdKey, iNextId);
+    return oldNext;
+    }
+
+CDeliveryComponentStorage::~CDeliveryComponentStorage()
+    {
+    RDEBUG_3( "CDeliveryComponentStorage::~CDeliveryComponentStorage 0x%X - 0x%X", reinterpret_cast<TUint>(this),
+            reinterpret_cast<TUint>(this)+sizeof( CDeliveryComponentStorage ) );
+    delete iRepository;
+    iRepository = NULL;
+    iComponents.ResetAndDestroy();
+    iComponentIds.Close();
+    TRAPD( err,CloseCertificatesL() )
+    ;
+    if (err != KErrNone)
+        {
+        RDEBUG_2( "CDeliveryComponentStorage::~CDeliveryComponentStorage: ERROR Failed to close certificate storage properly: %d", err);
+        }
+#ifndef __SERIES60_30__
+    delete iHidder;
+    iHidder = NULL;
+#endif
+    }
+
+void CDeliveryComponentStorage::CloseCertificatesL()
+    {
+    RFs fs;
+    User::LeaveIfError(fs.Connect() );
+    CleanupClosePushL(fs);
+    TInt e(fs.CreatePrivatePath(KDefaultDrive) );
+
+    User::LeaveIfError(e);
+    TBuf<64> privatePath;
+    User::LeaveIfError(fs.PrivatePath(privatePath) );
+
+    TInt privPathLength(privatePath.Length() );
+    _LIT( KCertFile, "amcerts.dat");
+    HBufC *afile = HBufC::NewLC(privPathLength + KCertFile().Length());
+    *afile = privatePath;
+    afile->Des().Append(KCertFile);
+    RFileWriteStream certFile;
+
+    TInt err(certFile.Replace(fs, *afile, EFileWrite) );
+    if (err == KErrNone)
+        {
+        CleanupClosePushL(certFile);
+        iCertificates.ExternalizeL(certFile);
+        CleanupStack::PopAndDestroy( &certFile);
+        }
+    else
+        if (err == KErrNotFound)
+            {
+
+            }
+        else
+            {
+            User::Leave(err);
+            }
+    CleanupStack::PopAndDestroy(afile);
+    CleanupStack::PopAndDestroy( &fs);
+    iCertificates.ResetAndDestroy();
+    }
+
+const RComponentIdArray &CDeliveryComponentStorage::GetComponentIds() const
+    {
+    return iComponentIds;
+    }
+
+void CDeliveryComponentStorage::GetStateChangeComponentIdsL(
+        RComponentIdArray &aArray)
+    {
+    RDEBUG_2( "CDeliveryComponentStorage::GetStateChangeComponentIdsL %d dcs", iComponentIds.Count());
+    aArray.Reset();
+    TInt c(iComponentIds.Count() );
+    for (TInt i( 0); i < c; i++)
+        {
+        CDeploymentComponent &compo = ComponentL(iComponentIds[i]);
+        if (compo.OldState() != EDCSNone)
+            {
+            aArray.Append(iComponentIds[i]);
+            }
+        }
+    RDEBUG( "CDeliveryComponentStorage::GetStateChangeComponentIdsL end");
+    }
+
+void CDeliveryComponentStorage::StateChangedL(TUint32 aInternalId)
+    {
+    RDEBUG_2( "CDeliveryComponentStorage::StateChangedL id %d", aInternalId);
+    CDeploymentComponent &compo = ComponentL(aInternalId);
+    compo.StateChangeComplete();
+    UpdateL(compo);
+    }
+
+void CDeliveryComponentStorage::LoadComponentsL()
+    {
+    TInt length( 0);
+    TInt err(iRepository->Get(KIdListLengthKey, length) );
+    if (err == KErrNotFound)
+        {
+        length = 0;
+        User::LeaveIfError(iRepository->Create(KIdListLengthKey, length) );
+        }
+    else
+        {
+        User::LeaveIfError(err);
+        }
+    HBufC8 *listbuf = HBufC8::NewLC(length) ;
+    TPtr8 ptr(listbuf->Des() );
+    err = iRepository->Get(KIdListKey, ptr) ;
+    if (err == KErrNotFound)
+        {
+        err = iRepository->Create(KIdListKey, KNullDesC8);
+        }
+    else
+        {
+
+        }
+    User::LeaveIfError(err);
+    TRAPD(code, iComponentIds.SetListL( ptr ))
+    ;
+    if (code != KErrEof)
+        {
+        User::LeaveIfError(code);
+        }
+
+    CleanupStack::PopAndDestroy(listbuf);
+#ifndef __SERIES60_30__
+    TInt i(iComponentIds.Count() );
+    //iHidder->Reset();
+    while ( --i >= 0)
+        {
+        CDeploymentComponent &comp = ComponentL(iComponentIds[i]);
+        if (comp.State() == EDCSInactive)
+            {
+            iHidder->AddUidL(comp.Uid());
+            }
+        else
+            if (comp.State() == EDCSActive)
+                {
+                iHidder->RemoveUidL(comp.Uid() );
+                }
+        }
+    iHidder->PersistUidsL();
+#endif
+
+    }
+
+CDeploymentComponent *CDeliveryComponentStorage::NewComponentL(
+        const TDeploymentComponentState &aState, const TDCUserId &aUserId,
+        const TCertInfo *aCertInfo/* = NULL */)
+    {
+    CDeploymentComponent *newc = CDeploymentComponent::NewLC(NextKey(),
+            aUserId);
+    if (aCertInfo != NULL)
+        {
+        TCertInfoPckg *p = new( ELeave ) TCertInfoPckg(*aCertInfo);
+        RDEBUG_2( "CDeliveryComponentStorage::NewComponentL - allocated TCertInfoPckg 0x%X", reinterpret_cast<TUint>( p ) );
+
+        TInt idx(iCertificates.FindByValue(*p) );
+        if (idx == KErrNotFound)
+            {
+            RDEBUG_2( "CDeliveryComponentStorage::NewComponentL - TCertInfoPckg NOT found 0x%X", reinterpret_cast<TUint>( p ) );
+            iCertificates.Append(p);
+            idx = iCertificates.Count() - 1;
+            }
+        else
+            {
+            RDEBUG_2( "CDeliveryComponentStorage::NewComponentL - TCertInfoPckg found at %d, deleting temporary", idx );
+            delete p;
+            p = NULL;
+            }
+        if (idx >= 0)
+            {
+            RDEBUG_2( "CDeliveryComponentStorage::NewComponentL - TCertInfoPckg found 0x%X", reinterpret_cast<TUint>( p ) );
+            newc->SetOwner(idx);
+            }
+        else
+            {
+            RDEBUG_3( "CDeliveryComponentStorage::NewComponentL - WARNING Could not add certificate 0x%X: %d", reinterpret_cast<TUint>( p ), idx );
+
+            }
+        }
+    newc->SetState(aState);
+    newc->SetStatusNode(EIdle);
+    UpdateL( *newc);
+    iComponents.Append(newc);
+    iComponentIds.Append(newc->InternalId() );
+RDEBUG_2( "CDeliveryComponentStorage::NewComponentL -Internal ID is  %d, ", newc->InternalId() );
+    PersistStateL();
+    CleanupStack::Pop(newc);
+    return newc;
+    }
+
+void CDeliveryComponentStorage::UpdateL(
+        const CDeploymentComponent &aComponent)
+    {
+    aComponent.PersistL( *iRepository) ;
+
+#ifndef __SERIES60_30__
+    if (aComponent.State() == EDCSInactive)
+        {
+        iHidder->AddUidL(aComponent.Uid(), ETrue);
+        }
+    else
+        {
+        iHidder->RemoveUidL(aComponent.Uid(), ETrue);
+        }
+#endif
+    }
+
+void CDeliveryComponentStorage::PersistStateL()
+    {
+    TInt length( 0);
+    HBufC8 *buf= NULL;
+    iComponentIds.GetListLC(buf, length);
+    User::LeaveIfError(iRepository->Set(KIdListLengthKey, length) );
+    User::LeaveIfError(iRepository->Set(KIdListKey, *buf) );
+    CleanupStack::PopAndDestroy(buf);
+    }
+
+void CDeliveryComponentStorage::RemoveL(TUint32 aInternalId)
+    {
+    RDEBUG_2("CDeliveryComponentStorage::RemoveL - Remove id: (%d)", aInternalId );
+    TInt count(iComponents.Count() );
+    for (TInt i( 0); i < count; i++)
+        {
+        CDeploymentComponent *el = iComponents[i];
+        if (aInternalId == el->iInternalId)
+            {
+#ifndef __SERIES60_30__
+            iHidder->RemoveUidL(el->Uid(), ETrue);
+#endif
+            iComponents.Remove(i);
+            iComponentIds.RemoveByValue(aInternalId);
+            el->DestroyL( *iRepository);
+            delete el;
+            RDEBUG_2("CDeliveryComponentStorage::RemoveL - Removed id: (%d)", aInternalId );
+            PersistStateL();
+            break;
+            }
+        }
+    }
+
+CDeploymentComponent &CDeliveryComponentStorage::ComponentL(
+        TUint32 aInternalId)
+    {
+    CDeploymentComponent *resp= NULL;
+    TInt count(iComponents.Count() );
+    for (TInt i( 0); i < count; i++)
+        {
+        CDeploymentComponent *el = iComponents[i];
+        if (aInternalId == el->iInternalId)
+            {
+            resp = el;
+            break;
+            }
+        }
+    if (resp == NULL)
+        {
+        TBuf8< NCentralRepositoryConstants::KMaxBinaryLength> buf;
+        TInt err(iRepository->Get(aInternalId, buf) );
+        User::LeaveIfError(err) ;
+        resp = LoadComponentL(aInternalId, buf) ;
+        iComponents.Append(resp);
+        }
+    if (resp == NULL)
+        {
+        User::Leave(KErrNotFound);
+        }
+    return *resp;
+    }
+
+CDeploymentComponent *CDeliveryComponentStorage::LoadComponentL(
+        TInt aInternalId, const TDesC8 &aBuffer) const
+    {
+    CDeploymentComponent *res = CDeploymentComponent::LoadL(aInternalId,
+            aBuffer);
+#ifdef _DEBUG
+    if (res)
+        {
+        RDEBUG8_4( "CDeliveryComponentStorage::LoadComponentL - loaded component state %d, internalid %d, and userid: %S", res->State(), res->InternalId(),&res->UserId() );
+        }
+    else
+        {
+        RDEBUG( "CDeliveryComponentStorage::LoadComponentL - WARNING failed to load component" );
+        }
+#endif
+    return res;
+    }
+void CDeliveryComponentStorage::CheckForDuplicateNodesInDeployedL(
+        CDeploymentComponent &aComponent)
+    {
+    TInt CompIdsCount(iComponentIds.Count() );
+    RDEBUG8_2("CheckForDuplicateNodesInDeployedL: CompIdsCount-> (%d)", CompIdsCount );
+    RDEBUG8_2("CheckForDuplicateNodesInDeployedL: aComponent UserID is %S", &(aComponent.UserId()));
+    for (TInt i( 0); i < CompIdsCount; i++)
+        {
+        CDeploymentComponent &compo = ComponentL(iComponentIds[i]);
+        RDEBUG8_2("CheckForDuplicateNodesInDeployedL: compo UserID is %S", &(compo.UserId()));
+        if (&aComponent != &compo)
+        {
+        if (((compo.State()== EDCSActive) || (compo.State()== EDCSInactive))
+                &&(compo.UserId() == aComponent.UserId()))
+            {
+            (aComponent.iUserId).Append(*IntToDes8LC(aComponent.iInternalId));
+            CleanupStack::PopAndDestroy();
+            break;
+            }
+          }
+        }
+    }
+
+HBufC8* CDeliveryComponentStorage::IntToDes8LC(const TInt aLuid)
+    {
+    HBufC8* buf = HBufC8::NewLC( 10); //10 = max length of 32bit integer
+    TPtr8 ptrBuf = buf->Des();
+    ptrBuf.Num(aLuid);
+    return buf;
+    }
+
+void CDeliveryComponentStorage::InstalledL(CDeploymentComponent &aComponent)
+    {
+    CheckForDuplicateNodesInDeployedL(aComponent);
+    aComponent.SetState(EDCSActive);
+    // set state to IDLE 
+    aComponent.SetStatusNode(EIdle);
+    UpdateL(aComponent);
+    }
+
+void CDeliveryComponentStorage::DeactivateL(CDeploymentComponent &aComponent)
+    {
+    /* :
+     * set state to InActivate in progress
+     * use TRAP instead of leaving.
+     */
+    aComponent.SetStatusNode(EDeployed_DeactivateProgress);
+    //User::LeaveIfError(aComponent.SetState(EDCSInactive) );
+    TInt err = aComponent.SetState(EDCSInactive);
+    if (err == KErrNone)
+        {
+        TRAP(err,UpdateL(aComponent));
+        }
+    //UpdateL(aComponent);
+    /*:
+     * if error set state to InActivate failed or else set to Idle
+     * call userleaveiferror()
+     */
+    if (err == KErrNone)
+        {
+        aComponent.SetStatusNode(EIdle);
+        }
+    else
+        {
+        aComponent.SetStatusNode(EDeployed_DeactivateFailed);
+        }
+    User::LeaveIfError(err);
+    }
+
+void CDeliveryComponentStorage::SetDeploymentComponentState(CDeploymentComponent &aComponent,TDeploymentComponentState aState)
+    {
+    aComponent.SetState( aState );
+    TRAP_IGNORE(UpdateL( aComponent ));    
+    }
+
+void CDeliveryComponentStorage::ActivateL(CDeploymentComponent &aComponent)
+    {
+    /* :
+     * set state to Activate in progress
+     * use TRAP instead of leaving.
+     */
+    aComponent.SetStatusNode(EDeployed_ActivateProgress);
+    TInt err = aComponent.SetState(EDCSActive);
+    //UpdateL( aComponent );
+    if (err == KErrNone)
+        {
+        TRAP(err,UpdateL(aComponent));
+        }
+    /*:
+     * if error set state to InActivate failed or else set to Idle
+     * call userleaveiferror()
+     */
+    if (err == KErrNone)
+        {
+        aComponent.SetStatusNode(EIdle);
+        }
+    else
+        {
+        aComponent.SetStatusNode(EDeployed_ActivateFailed);
+        }
+    User::LeaveIfError(err);
+    }
+
+/*void CDeliveryComponentStorage::UninstalledL( CDeploymentComponent &aComponent )
+ {
+ aComponent.SetState( EDCSInactive );
+ UpdateL( aComponent );
+ }
+ 
+ void CDeliveryComponentStorage::ResetL()
+ {
+ }
+ */
+//  End of File