1 /*

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

    15  *

    16 */

    17 

    18 

    19 #include "logger.h"

    20 

    21 #include "systemamstrader.h"

    22 

    23 _LIT(KExecutableName, "javacaptain.exe");

    24 _LIT(KIadArg, "iad");

    25 

    26 using namespace java::security::legacysupport;

    27 

    28 CSystemAMSTrader::CSystemAMSTrader(TBool aIadStart) :

    29         mIadStart(aIadStart)

    30 {

    31     JELOG2(EJavaSystemAMS);

    32 }

    33 

    34 CSystemAMSTrader::~CSystemAMSTrader()

    35 {

    36     JELOG2(EJavaSystemAMS);

    37     delete mCertificatesManager;

    38     mCertificatesManager = NULL;

    39 }

    40 

    41 void CSystemAMSTrader::StartL(TBool aIadStart)

    42 {

    43     JELOG2(EJavaSystemAMS);

    44 

    45     CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

    46 

    47     CleanupStack::PushL(scheduler);

    48     CActiveScheduler::Install(scheduler);

    49 

    50     CSystemAMSTrader* trader = new(ELeave) CSystemAMSTrader(aIadStart);

    51     CleanupStack::PushL(trader);

    52     trader->ConstructL();

    53     CleanupStack::Pop(trader);

    54 

    55     CActiveScheduler::Start();

    56     CleanupStack::PopAndDestroy(scheduler);

    57 }

    58 

    59 

    60 void CSystemAMSTrader::ConstructL(void)

    61 {

    62     int st;

    63     RProcess proc;

    64 

    65     if (mIadStart)

    66     {

    67         st = proc.Create(KExecutableName, KIadArg);

    68     }

    69     else

    70     {

    71         st = proc.Create(KExecutableName, KExecutableName);

    72     }

    73     if (st == KErrNone)

    74     {

    75         proc.Resume();

    76         proc.Close();

    77     }

    78 

    79     RProcess::Rendezvous(st);

    80 

    81     mPublicServer = new(ELeave) CLegacyServer(SERVER_ID_PUBLIC_C, this);

    82     mPublicServer->StartL();

    83 

    84     mSecurityAdminServer = new(ELeave) CLegacyServer(

    85         SERVER_ID_SECURITY_ADMIN_C, this);

    86     mSecurityAdminServer->StartL();

    87 

    88     mCertificatesManager = CertificatesManager::NewL();

    89 }

    90 

    91 void CSystemAMSTrader::HandleMessageL(const int serverId,

    92                                       const RMessage2& aMessage) const

    93 {

    94     JELOG2(EJavaSystemAMS);

    95 

    96     switch (serverId)

    97     {

    98     case SERVER_ID_PUBLIC_C:

    99         handlePublicServerRequests(aMessage);

   100         break;

   101     case SERVER_ID_SECURITY_ADMIN_C:

   102         handleSecurityAdminRequestsL(aMessage);

   103         break;

   104     }

   105 }

   106 

   107 void CSystemAMSTrader::handlePublicServerRequests(const RMessage2& aMessage) const

   108 {

   109     JELOG2(EJavaSystemAMS);

   110     // CanConnect

   111     aMessage.Complete(KErrNone);

   112 }

   113 

   114 void CSystemAMSTrader::handleSecurityAdminRequestsL(const RMessage2& aMessage) const

   115 {

   116     JELOG2(EJavaSystemAMS);

   117     TInt ret = KErrNone;

   118     HBufC* name = NULL;

   119     TPtr namePtr(0, 0);

   120     TPckgBuf<TUint32> trustRootCount(0);

   121     switch (aMessage.Function())

   122     {

   123     case 1: // ETrustRootCount - in: protection domain name; out: count trust root info[]

   124         LOG(EJavaSystemAMS, EInfo, "ETrustRootCount");

   125         name    = HBufC::NewLC(aMessage.GetDesLengthL(0));

   126         namePtr.Set(name->Des());

   127         aMessage.ReadL(0, namePtr);

   128         trustRootCount = TPckgBuf<TUint32>(mCertificatesManager->TrustRootCount(namePtr));

   129         aMessage.WriteL(1, trustRootCount);

   130         CleanupStack::PopAndDestroy(name);

   131         break;

   132 

   133     case 2: // ETrustRootInfo - in: protection domain name; out:

   134         LOG(EJavaSystemAMS, EInfo, "ETrustRootInfo");

   135         name    = HBufC::NewLC(aMessage.GetDesLengthL(0));

   136         namePtr.Set(name->Des());

   137         aMessage.ReadL(0, namePtr);

   138         aMessage.WriteL(1, mCertificatesManager->TrustRootInfo(namePtr));

   139         CleanupStack::PopAndDestroy(name);

   140         break;

   141 

   142     case 3: // ETrustRootInfoCertificate - in: trust root id; out: encoded certificate

   143         LOG(EJavaSystemAMS, EInfo, "ETrustRootInfoCertificate");

   144         TRAP(ret, aMessage.WriteL(1, mCertificatesManager->TrustRootInfoCertificateL(aMessage.Int0())));

   145         break;

   146 

   147     case 4: // EDeleteTrustRoot - in: trust root id

   148         LOG(EJavaSystemAMS, EInfo, "EDeleteTrustRoot");

   149         TRAP(ret, mCertificatesManager->DeleteTrustRootL(aMessage.Int0()));

   150         break;

   151 

   152     case 5: // EDisableTrustRoot - in: trust root id

   153         LOG(EJavaSystemAMS, EInfo, "EDisableTrustRoot");

   154         TRAP(ret, mCertificatesManager->DisableTrustRootL(aMessage.Int0()));

   155         break;

   156 

   157     case 6: // EEnableTrustRoot - in: trust root id

   158         LOG(EJavaSystemAMS, EInfo, "EEnableTrustRoot");

   159         TRAP(ret, mCertificatesManager->EnableTrustRootL(aMessage.Int0()));

   160         break;

   161     }

   162 

   163     aMessage.Complete(ret);

   164 }