1 /*

     2 * Copyright (c) 2010 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:

    15 *

    16 */

    17 

    18 

    19 #include <centralrepository.h>

    20 #include <SWInstallerInternalCRKeys.h>

    21 

    22 #include "security.h"

    23 #include "logger.h"

    24 #include "javastoragenames.h"

    25 #include "securitystoragedatadefs.h"

    26 

    27 using namespace java::storage;

    28 using namespace std;

    29 

    30 _LIT(KS60SecurityPolicy,  "s60");

    31 _LIT(KMSASecurityPolicy,  "msa");

    32 _LIT(KATTSecurityPolicy,  "att");

    33 // Java Security Policy Central Repository UID

    34 static const TUid KCRUidJavaSecurity = { 0x2001B289 };

    35 // IDs for security folder and file keys

    36 static const TUint32 KPolicy = 0x03;

    37 static const TUint32 KSecurityWarnings = 0x04;

    38 

    39 const int S60_SECURITY_POLICY_ID = 1;

    40 const int MSA_SECURITY_POLICY_ID = 2;

    41 const int ATT_SECURITY_POLICY_ID = 3;

    42 

    43 

    44 Security::Security()

    45 {

    46     try

    47     {

    48         iStorage.reset(JavaStorage::createInstance());

    49         iStorage->open();

    50     }

    51     catch (JavaStorageException& e)

    52     {

    53         ELOG1(EUtils, "open storage connection failed, %s",  e.toString().c_str());

    54     }

    55 }

    56 

    57 Security::~Security()

    58 {

    59 }

    60 

    61 std::wstring Security::getSecurityWarningsMode()

    62 {

    63     try

    64     {

    65         JavaStorageApplicationEntry_t query;

    66         JavaStorageApplicationList_t queryResult;

    67         JavaStorageEntry attr;

    68         attr.setEntry(ID, L"");

    69         query.insert(attr);

    70         attr.setEntry(SECURITY_WARNINGS, L"");

    71         query.insert(attr);

    72         iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult);

    73         JavaStorageApplicationList_t::const_iterator iterator;

    74         JavaStorageApplicationList_t domainQueryResult;

    75         for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++)

    76         {

    77             std::wstring securityWarnings = L"";

    78             JavaStorageApplicationEntry_t entry = (*iterator);

    79             findColumn(entry, SECURITY_WARNINGS, securityWarnings);

    80             if (securityWarnings == SECURITY_WARNINGS_USER_DEFINED_MODE)

    81             {

    82                 // make them all USER

    83                 setSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE);

    84                 return SECURITY_WARNINGS_USER_DEFINED_MODE;

    85             }

    86         }

    87     }

    88     catch (JavaStorageException& aJse)

    89     {

    90     }

    91     // one more check: central repository

    92     std::wstring securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

    93     TRAP_IGNORE

    94     (

    95         CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

    96         TInt warningsMode;

    97         User::LeaveIfError(repository->Get(KSecurityWarnings, warningsMode));

    98         switch (warningsMode)

    99         {

   100         case 1:

   101             securityWarningsMode = SECURITY_WARNINGS_USER_DEFINED_MODE;

   102             break;

   103         case 2:

   104             securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

   105             break;

   106         }

   107         CleanupStack::PopAndDestroy(repository);

   108     );

   109     return securityWarningsMode;

   110 }

   111 

   112 void Security::setSecurityWarningsMode(const std::wstring& aSecurityWarningsMode)

   113 {

   114     try

   115     {

   116         JavaStorageApplicationEntry_t query;

   117         JavaStorageApplicationList_t queryResult;

   118         JavaStorageEntry attr;

   119         attr.setEntry(ID, L"");

   120         query.insert(attr);

   121         iStorage->search(MIDP_PACKAGE_TABLE, query, queryResult);

   122         JavaStorageApplicationList_t::const_iterator iterator;

   123         JavaStorageApplicationList_t domainQueryResult;

   124         for (iterator = queryResult.begin(); iterator != queryResult.end(); iterator++)

   125         {

   126             std::wstring uid = L"";

   127             JavaStorageApplicationEntry_t entry = (*iterator);

   128             findColumn(entry, ID, uid);

   129             JavaStorageApplicationEntry_t oldEntry;

   130             JavaStorageEntry oldAttr;

   131             oldAttr.setEntry(ID, uid);

   132             oldEntry.insert(oldAttr);

   133             attr.setEntry(SECURITY_WARNINGS, aSecurityWarningsMode);

   134             entry.clear();

   135             entry.insert(attr);

   136             iStorage->update(MIDP_PACKAGE_TABLE, entry, oldEntry);

   137         }

   138     }

   139     catch (JavaStorageException& aJse)

   140     {

   141     }

   142     // set the cenRep key as well

   143     TRAP_IGNORE

   144     (

   145         CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

   146         if (aSecurityWarningsMode == SECURITY_WARNINGS_USER_DEFINED_MODE)

   147         {

   148             repository->Set(KSecurityWarnings, 1);

   149         }

   150         else

   151         {

   152             repository->Set(KSecurityWarnings, 2);

   153         }

   154         CleanupStack::PopAndDestroy(repository);

   155     );

   156 }

   157 

   158 void Security::findColumn(const JavaStorageApplicationEntry_t& aEntry,

   159                            const wstring& aColName, wstring& aColValue)

   160 {

   161     JavaStorageEntry findPattern;

   162     findPattern.setEntry(aColName, L"");

   163     JavaStorageApplicationEntry_t::const_iterator findIterator =

   164         aEntry.find(findPattern);

   165     if (findIterator != aEntry.end())

   166     {

   167         aColValue = findIterator->entryValue();

   168     }

   169 }

   170 

   171 int Security::getSecurityPolicy()

   172 {

   173     int securityPolicyId = S60_SECURITY_POLICY_ID;

   174     TRAP_IGNORE

   175     (

   176         CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

   177         HBufC* buf = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);

   178         TPtr policy(buf->Des());

   179         User::LeaveIfError(repository->Get(KPolicy, policy));

   180         if (policy.Compare(KS60SecurityPolicy) == 0)

   181         {

   182             securityPolicyId = S60_SECURITY_POLICY_ID;

   183         }

   184         else if (policy.Compare(KMSASecurityPolicy) == 0)

   185         {

   186             securityPolicyId = MSA_SECURITY_POLICY_ID;

   187         }

   188         else if (policy.Compare(KATTSecurityPolicy) == 0)

   189         {

   190             securityPolicyId = ATT_SECURITY_POLICY_ID;

   191         }

   192         CleanupStack::PopAndDestroy(buf);

   193         CleanupStack::PopAndDestroy(repository);

   194     );

   195     return securityPolicyId;

   196 

   197 }

   198 

   199 void Security::setSecurityPolicy(int aSecurityPolicyId)

   200 {

   201     TRAP_IGNORE

   202     (

   203         CRepository* repository = CRepository::NewLC(KCRUidJavaSecurity);

   204         switch (aSecurityPolicyId)

   205         {

   206         case S60_SECURITY_POLICY_ID:

   207             User::LeaveIfError(repository->Set(KPolicy, KS60SecurityPolicy));

   208             break;

   209         case MSA_SECURITY_POLICY_ID:

   210             User::LeaveIfError(repository->Set(KPolicy, KMSASecurityPolicy));

   211             break;

   212         case ATT_SECURITY_POLICY_ID:

   213             User::LeaveIfError(repository->Set(KPolicy, KATTSecurityPolicy));

   214             break;

   215         }

   216     CleanupStack::PopAndDestroy(repository);

   217     );

   218 }

   219 

   220