1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implementation of DevandTruSrvCertStoreEntryList

    15 *

    16 */

    17 

    18 

    19 

    20 #include "DevandTruSrvCertStoreEntryList.h"

    21 #include "DevandTruSrvCertStoreEntry.h"

    22 #include "DevTokenDataTypes.h"

    23 #include "DevTokenUtil.h"

    24 

    25 

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

    27 

    28 //CDevandTruSrvCertStoreEntryList

    29 

    30 // ---------------------------------------------------------------------------

    31 // CDevandTruSrvCertStoreEntryList::NewLC()

    32 // ---------------------------------------------------------------------------

    33 //

    34 CDevandTruSrvCertStoreEntryList* CDevandTruSrvCertStoreEntryList::NewLC()

    35     {

    36     CDevandTruSrvCertStoreEntryList* self = new(ELeave) CDevandTruSrvCertStoreEntryList();

    37     CleanupStack::PushL(self);

    38     return self;

    39     }

    40 

    41 

    42 // ---------------------------------------------------------------------------

    43 // CDevandTruSrvCertStoreEntryList::NewL()

    44 // ---------------------------------------------------------------------------

    45 //

    46 CDevandTruSrvCertStoreEntryList* CDevandTruSrvCertStoreEntryList::NewL(RReadStream& aStream)

    47     {

    48     CDevandTruSrvCertStoreEntryList* self = new(ELeave) CDevandTruSrvCertStoreEntryList();

    49     CleanupStack::PushL(self);

    50     self->InternalizeL(aStream);

    51     CleanupStack::Pop();

    52     return self;

    53     }

    54 

    55 

    56 // ---------------------------------------------------------------------------

    57 // CDevandTruSrvCertStoreEntryList::CDevandTruSrvCertStoreEntryList()

    58 // ---------------------------------------------------------------------------

    59 //

    60 CDevandTruSrvCertStoreEntryList::CDevandTruSrvCertStoreEntryList()

    61     {

    62     }

    63 

    64 

    65 // ---------------------------------------------------------------------------

    66 // CDevandTruSrvCertStoreEntryList::~CDevandTruSrvCertStoreEntryList()

    67 // ---------------------------------------------------------------------------

    68 //

    69 CDevandTruSrvCertStoreEntryList::~CDevandTruSrvCertStoreEntryList()

    70     {

    71     iEntries.ResetAndDestroy();

    72     iEntries.Close();

    73     }

    74 

    75 

    76 // ---------------------------------------------------------------------------

    77 // CDevandTruSrvCertStoreEntryList::ExternalizeL()

    78 // ---------------------------------------------------------------------------

    79 //

    80 void CDevandTruSrvCertStoreEntryList::ExternalizeL(RWriteStream& aStream) const

    81     {

    82     TInt count = iEntries.Count();

    83     aStream.WriteInt32L(count);

    84     for (TInt i = 0 ; i < count ; ++i)

    85         {

    86         aStream << *iEntries[i];

    87         }

    88     }

    89 

    90 

    91 // ---------------------------------------------------------------------------

    92 // CDevandTruSrvCertStoreEntryList::InternalizeL()

    93 // ---------------------------------------------------------------------------

    94 //

    95 void CDevandTruSrvCertStoreEntryList::InternalizeL(RReadStream& aStream)

    96     {

    97     TInt count = aStream.ReadInt32L();

    98 

    99     for (TInt i = 0 ; i < count ; ++i)

   100         {

   101         CDevandTruSrvCertStoreEntry* entry = CDevandTruSrvCertStoreEntry::NewLC(aStream);

   102 

   103         // Check certificate id is unique

   104         TInt handle = entry->CertInfo().CertificateId();

   105         if (IndexForHandle(handle) != KErrNotFound)

   106             {

   107             User::Leave(KErrCorrupt);

   108             }

   109 

   110         AppendL(entry);

   111         CleanupStack::Pop(entry);   

   112         }

   113     }

   114 

   115 

   116 // ---------------------------------------------------------------------------

   117 // CDevandTruSrvCertStoreEntryList::Count()

   118 // ---------------------------------------------------------------------------

   119 //

   120 TInt CDevandTruSrvCertStoreEntryList::Count() const

   121     {

   122     return iEntries.Count();

   123     }

   124 

   125 

   126 // ---------------------------------------------------------------------------

   127 // CDevandTruSrvCertStoreEntryList::AppendL()

   128 // ---------------------------------------------------------------------------

   129 //

   130 TInt CDevandTruSrvCertStoreEntryList::AppendL(CDevandTruSrvCertStoreEntry* aCertInfo)

   131     {

   132     assert(aCertInfo, EPanicCertStoreEntryListAppendArguments);

   133     User::LeaveIfError(iEntries.Append(aCertInfo));

   134     return iEntries.Count() - 1;

   135     }

   136 

   137 

   138 // ---------------------------------------------------------------------------

   139 // CDevandTruSrvCertStoreEntryList::Remove()

   140 // ---------------------------------------------------------------------------

   141 //

   142 CDevandTruSrvCertStoreEntry* CDevandTruSrvCertStoreEntryList::Remove(TInt aIndex)

   143     {

   144     CDevandTruSrvCertStoreEntry* entry = iEntries[aIndex];

   145     iEntries.Remove(aIndex);

   146     return entry;

   147     }

   148 

   149 

   150 // ---------------------------------------------------------------------------

   151 // CDevandTruSrvCertStoreEntryList::Replace()

   152 // ---------------------------------------------------------------------------

   153 //

   154 CDevandTruSrvCertStoreEntry* CDevandTruSrvCertStoreEntryList::Replace(TInt aIndex, CDevandTruSrvCertStoreEntry* aNewEntry)

   155     {

   156     assert(aNewEntry, EPanicCertStoreEntryListReplaceArguments);

   157     CDevandTruSrvCertStoreEntry* entry = iEntries[aIndex];

   158     iEntries[aIndex] = aNewEntry;

   159     return entry;

   160     }

   161 

   162 

   163 // ---------------------------------------------------------------------------

   164 // CDevandTruSrvCertStoreEntryList::IndexForHandle()

   165 // ---------------------------------------------------------------------------

   166 //

   167 TInt CDevandTruSrvCertStoreEntryList::IndexForHandle(TInt aHandle) const

   168     {

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

   170         {

   171         CDevandTruSrvCertStoreEntry* entry = iEntries[i];

   172         if (entry->CertInfo().Reference() == aHandle)

   173             {

   174             return i;

   175             }

   176         }

   177 

   178     return KErrNotFound;

   179     }

   180 

   181 

   182 // ---------------------------------------------------------------------------

   183 // CDevandTruSrvCertStoreEntryList::LabelExists()

   184 // ---------------------------------------------------------------------------

   185 //

   186 TBool CDevandTruSrvCertStoreEntryList::LabelExists(const TDesC& aLabel) const

   187     {

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

   189         {

   190         CDevandTruSrvCertStoreEntry* entry = iEntries[i];

   191         if (entry->CertInfo().Label() == aLabel)

   192             {

   193             return ETrue;

   194             }

   195         }

   196 

   197     return EFalse;

   198     }

   199 

   200 

   201 // ---------------------------------------------------------------------------

   202 // CDevandTruSrvCertStoreEntryList::GetByIndex()

   203 // ---------------------------------------------------------------------------

   204 //

   205 const CDevandTruSrvCertStoreEntry& CDevandTruSrvCertStoreEntryList::GetByIndex(

   206     TInt aIndex) const

   207     {

   208     return *iEntries[aIndex];

   209     }

   210 

   211 

   212 // ---------------------------------------------------------------------------

   213 // CDevandTruSrvCertStoreEntryList::GetByHandleL()

   214 // ---------------------------------------------------------------------------

   215 //

   216 const CDevandTruSrvCertStoreEntry& CDevandTruSrvCertStoreEntryList::GetByHandleL(

   217     TInt aHandle) const

   218     {

   219     TInt index = IndexForHandle(aHandle);

   220     User::LeaveIfError(index);

   221     return GetByIndex(index);

   222     }

   223 

   224 

   225 // ---------------------------------------------------------------------------

   226 // CDevandTruSrvCertStoreEntryList::NextFreeHandle()

   227 // ---------------------------------------------------------------------------

   228 //

   229 TInt CDevandTruSrvCertStoreEntryList::NextFreeHandle() const 

   230     {

   231     TInt count = iEntries.Count();

   232     TInt maxHandle = -1;

   233     for (TInt i = 0; i < count; i++)

   234         {

   235         CDevandTruSrvCertStoreEntry* entry = iEntries[i];

   236         if (entry->CertInfo().Reference() > maxHandle)

   237             {

   238             maxHandle = entry->CertInfo().Reference();

   239             }

   240         }

   241 

   242     return maxHandle + 1;

   243     }

   244 

   245 //EOF

   246