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:  JavaCap

    15 *

    16 */

    17 

    18 

    19 #include "comms.h"

    20 #include "rtcmessages.h"

    21 #include "coremessages.h"

    22 

    23 #include "logger.h"

    24 

    25 #include "javacap.h"

    26 #include "javacap.hrh"

    27 

    28 #include "javainifileutils.h"

    29 

    30 #include <centralrepository.h>

    31 #include <SWInstallerInternalCRKeys.h>

    32 

    33 #include "javastoragenames.h"                   // Storage constants.

    34 #include "securitystoragedatadefs.h"

    35 

    36 #include <javacap.rsg>

    37 

    38 _LIT(KJavaCapYes, "Yes");

    39 _LIT(KJavaCapNo,  "No");

    40 _LIT(KUserSecurityMode,  "User");

    41 _LIT(KNormalSecurityMode,  "Default");

    42 _LIT(KS60SecurityPolicyName,  "S60");

    43 _LIT(KMSASecurityPolicyName,  "MSA");

    44 _LIT(KATTSecurityPolicyName,  "AT&T");

    45 _LIT(KS60SecurityPolicy,  "s60");

    46 _LIT(KMSASecurityPolicy,  "msa");

    47 _LIT(KATTSecurityPolicy,  "att");

    48 // Java Security Policy Central Repository UID

    49 static const TUid KCRUidJavaSecurity = { 0x2001B289 };

    50 // IDs for security folder and file keys

    51 static const TUint32 KPolicy = 0x03;

    52 static const TUint32 KSecurityWarnings = 0x04;

    53 const int KS60SecurityPolicyId = 1;

    54 const int KMSASecurityPolicyId = 2;

    55 const int KATTSecurityPolicyId = 3;

    56 

    57 using namespace java::storage;

    58 using namespace std;

    59 using namespace java::util;

    60 using namespace java::comms;

    61 using namespace java::captain;

    62 

    63 void CJavaCaptainContainer::ConstructL(const TRect& aRect)

    64 {

    65     JELOG2(EJavaCaptain);

    66     mCaptainRunning = true;

    67     mPrewarmEnabled = false;

    68 #if defined(RD_JAVA_PREWARM) && !defined (__WINS__)

    69     mPrewarmEnabled = true;

    70 #endif // RD_JAVA_PREWARM

    71     mPrewarmUiEnabled = false;

    72     mDebugEnabled = false;

    73     mRedirectEnabled = false;

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

    75     try

    76     {

    77         iStorage->open();

    78     }

    79     catch (JavaStorageException& aJse)

    80     {

    81         User::Leave(aJse.mStatus);

    82     }

    83     mUserSecurityModeEnabled = (GetSecurityWarningsMode() == SECURITY_WARNINGS_USER_DEFINED_MODE);

    84     mSecurityPolicyId = GetSecurityPolicy();

    85     mHeader = _L("Java states:");

    86     updateStates();

    87     CreateWindowL();

    88     SetRect(aRect);

    89     ActivateL();

    90     mRedirector.reset(new LogRedirector());

    91 }

    92 

    93 CJavaCaptainContainer::~CJavaCaptainContainer()

    94 {

    95     JELOG2(EJavaCaptain);

    96 }

    97 

    98 void CJavaCaptainContainer::Draw(const TRect& /*aRect*/) const

    99 {

   100     JELOG2(EJavaCaptain);

   101     CWindowGc& gc = SystemGc();

   102     gc.Clear();

   103 

   104     const CFont* usedFont = CEikonEnv::Static()->NormalFont();

   105     gc.UseFont(usedFont);

   106 

   107     gc.DrawText(mHeader,TPoint(10,20));

   108     int pos = 50;

   109     gc.DrawText(mCaptainState,TPoint(20,pos));

   110     int gap = 25;

   111     pos += gap;

   112     gc.DrawText(mPrewarmState,TPoint(20,pos));

   113     pos += gap;

   114     gc.DrawText(mPrewarmUiState,TPoint(20,pos));

   115     pos += gap;

   116     gc.DrawText(mDebugState,TPoint(20,pos));

   117     pos += gap;

   118     gc.DrawText(mSecurityMode,TPoint(20,pos));

   119     pos += gap;

   120     gc.DrawText(mSecurityPolicy,TPoint(20,pos));

   121     pos += gap;

   122     gc.DrawText(mRedirectState,TPoint(20,pos));

   123 

   124     gc.DiscardFont();

   125 }

   126 

   127 void CJavaCaptainContainer::updateStates()

   128 {

   129 

   130     int propertyVal = java::util::JavaIniFileUtils::getProperty(java::util::UI_PREWARM);

   131     if (propertyVal != -1)

   132     {

   133         mPrewarmUiEnabled = propertyVal;

   134     }

   135 

   136     mCaptainState = _L("Captain running:               ");

   137     if (mCaptainRunning)

   138     {

   139         mCaptainState.Append(KJavaCapYes);

   140     }

   141     else

   142     {

   143         mCaptainState.Append(KJavaCapNo);

   144     }

   145 

   146     mPrewarmState = _L("Prewarm enabled:           ");

   147     if (mPrewarmEnabled)

   148     {

   149         mPrewarmState.Append(KJavaCapYes);

   150     }

   151     else

   152     {

   153         mPrewarmState.Append(KJavaCapNo);

   154     }

   155 

   156     mPrewarmUiState = _L("Prewarm UI enabled:      ");

   157     if (mPrewarmUiEnabled)

   158     {

   159         mPrewarmUiState.Append(KJavaCapYes);

   160     }

   161     else

   162     {

   163         mPrewarmUiState.Append(KJavaCapNo);

   164     }

   165 

   166     mDebugState = _L("Java Debug enabled:      ");

   167     if (mDebugEnabled)

   168     {

   169         mDebugState.Append(KJavaCapYes);

   170     }

   171     else

   172     {

   173         mDebugState.Append(KJavaCapNo);

   174     }

   175 

   176     mSecurityMode = _L("Security warnings:      ");

   177     if (mUserSecurityModeEnabled)

   178     {

   179         mSecurityMode.Append(KUserSecurityMode);

   180     }

   181     else

   182     {

   183         mSecurityMode.Append(KNormalSecurityMode);

   184     }

   185 

   186     mSecurityPolicy = _L("Security policy:      ");

   187     switch (mSecurityPolicyId)

   188     {

   189     case KS60SecurityPolicyId:

   190         mSecurityPolicy.Append(KS60SecurityPolicyName);

   191         break;

   192     case KMSASecurityPolicyId:

   193         mSecurityPolicy.Append(KMSASecurityPolicyName);

   194         break;

   195     case KATTSecurityPolicyId:

   196         mSecurityPolicy.Append(KATTSecurityPolicyName);

   197         break;

   198     default:

   199         mSecurityPolicy.Append(KS60SecurityPolicyName);

   200     }

   201 

   202     mRedirectState = _L("Redirect logs:                   ");

   203     if (mRedirectEnabled)

   204     {

   205         mRedirectState.Append(KJavaCapYes);

   206     }

   207     else

   208     {

   209         mRedirectState.Append(KJavaCapNo);

   210     }

   211 

   212     DrawDeferred();

   213 }

   214 

   215 void CJavaCaptainContainer::setCaptainState(bool running)

   216 {

   217     mCaptainRunning = running;

   218     updateStates();

   219 }

   220 

   221 

   222 

   223 #include "commsmessage.h"

   224 #include "commsclientendpoint.h"

   225 

   226 void CJavaCaptainContainer::handleStateChangeCmd(int cmd)

   227 {

   228     switch (cmd)

   229     {

   230 

   231     case ETogglePrewarmEnable:

   232     {

   233         mPrewarmEnabled = !mPrewarmEnabled;

   234         CommsMessage message;

   235         message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C);

   236         if (mPrewarmEnabled)

   237         {

   238             message.setMessageId(CORE_MSG_ID_START_PREWARM);

   239         }

   240         else

   241         {

   242             message.setMessageId(CORE_MSG_ID_STOP_PREWARM);

   243         }

   244         CommsClientEndpoint comms;

   245         comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

   246         comms.send(message);

   247         comms.disconnect();

   248         break;

   249     }

   250     case ETogglePrewarmUiEnable:

   251         mPrewarmUiEnabled = !mPrewarmUiEnabled;

   252         java::util::JavaIniFileUtils::setProperty(java::util::UI_PREWARM, mPrewarmUiEnabled);

   253         break;

   254 

   255     case EDebugMode:

   256     {

   257         mDebugEnabled = !mDebugEnabled;

   258 

   259         CommsMessage message;

   260         std::wstring vmArgs = L"";

   261         if (mDebugEnabled)

   262         {

   263             vmArgs = L"-Xrunjdwp:server=y,address=localhost:8000";

   264         }

   265         setSetExtraArguments(message, vmArgs, L"");

   266 

   267         CommsClientEndpoint comms;

   268         comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

   269         comms.send(message);

   270         comms.disconnect();

   271     }

   272     break;

   273 

   274     case ESecurityMode:

   275     {

   276         mUserSecurityModeEnabled = !mUserSecurityModeEnabled;

   277 

   278         if (mUserSecurityModeEnabled)

   279         {

   280             SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE);

   281         }

   282         else

   283         {

   284             SetSecurityWarningsMode(SECURITY_WARNINGS_DEFAULT_MODE);

   285         }

   286     }

   287     break;

   288     case ES60SecurityPolicy:

   289         mSecurityPolicyId = KS60SecurityPolicyId;

   290         SetSecurityPolicy(mSecurityPolicyId);

   291         break;

   292     case EMSASecurityPolicy:

   293         mSecurityPolicyId = KMSASecurityPolicyId;

   294         SetSecurityPolicy(mSecurityPolicyId);

   295         break;

   296     case EATTSecurityPolicy:

   297         mSecurityPolicyId = KATTSecurityPolicyId;

   298         SetSecurityPolicy(mSecurityPolicyId);

   299         break;

   300 

   301     case ERedirectMode:

   302         mRedirectEnabled = !mRedirectEnabled;

   303         if (mRedirectEnabled)

   304         {

   305             mRedirector->start();

   306         }

   307         else

   308         {

   309             mRedirector->stop();

   310         }

   311         break;

   312 

   313     default:

   314         break;

   315     }

   316     updateStates();

   317 }

   318 

   319 std::wstring CJavaCaptainContainer::GetSecurityWarningsMode()

   320 {

   321     try

   322     {

   323         JavaStorageApplicationEntry_t query;

   324         JavaStorageApplicationList_t queryResult;

   325         JavaStorageEntry attr;

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

   327         query.insert(attr);

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

   329         query.insert(attr);

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

   331         JavaStorageApplicationList_t::const_iterator iterator;

   332         JavaStorageApplicationList_t domainQueryResult;

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

   334         {

   335             std::wstring securityWarnings = L"";

   336             JavaStorageApplicationEntry_t entry = (*iterator);

   337             findColumn(entry, SECURITY_WARNINGS, securityWarnings);

   338             if (securityWarnings == SECURITY_WARNINGS_USER_DEFINED_MODE)

   339             {

   340                 // make them all USER

   341                 SetSecurityWarningsMode(SECURITY_WARNINGS_USER_DEFINED_MODE);

   342                 return SECURITY_WARNINGS_USER_DEFINED_MODE;

   343             }

   344         }

   345     }

   346     catch (JavaStorageException& aJse)

   347     {

   348     }

   349     // one mroe check: central repository

   350     std::wstring securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

   351     TRAP_IGNORE(

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

   353         TInt warningsMode;

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

   355         switch (warningsMode)

   356 {

   357 case 1:

   358     securityWarningsMode = SECURITY_WARNINGS_USER_DEFINED_MODE;

   359     break;

   360 case 2:

   361     securityWarningsMode = SECURITY_WARNINGS_DEFAULT_MODE;

   362     break;

   363 }

   364 CleanupStack::PopAndDestroy(repository););

   365     return securityWarningsMode;

   366 }

   367 

   368 void CJavaCaptainContainer::SetSecurityWarningsMode(const std::wstring& aSecurityWarningsMode)

   369 {

   370     try

   371     {

   372         JavaStorageApplicationEntry_t query;

   373         JavaStorageApplicationList_t queryResult;

   374         JavaStorageEntry attr;

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

   376         query.insert(attr);

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

   378         JavaStorageApplicationList_t::const_iterator iterator;

   379         JavaStorageApplicationList_t domainQueryResult;

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

   381         {

   382             std::wstring uid = L"";

   383             JavaStorageApplicationEntry_t entry = (*iterator);

   384             findColumn(entry, ID, uid);

   385             JavaStorageApplicationEntry_t oldEntry;

   386             JavaStorageEntry oldAttr;

   387             oldAttr.setEntry(ID, uid);

   388             oldEntry.insert(oldAttr);

   389             attr.setEntry(SECURITY_WARNINGS, aSecurityWarningsMode);

   390             entry.clear();

   391             entry.insert(attr);

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

   393         }

   394     }

   395     catch (JavaStorageException& aJse)

   396     {

   397     }

   398     // set the cenRep key as well

   399     TRAP_IGNORE(

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

   401         if (aSecurityWarningsMode == SECURITY_WARNINGS_USER_DEFINED_MODE)

   402 {

   403     repository->Set(KSecurityWarnings, 1);

   404     }

   405     else

   406     {

   407         repository->Set(KSecurityWarnings, 2);

   408     }

   409     CleanupStack::PopAndDestroy(repository);

   410     );

   411 }

   412 

   413 void  CJavaCaptainContainer::findColumn(const JavaStorageApplicationEntry_t& aEntry,

   414                                         const wstring& aColName, wstring& aColValue)

   415 {

   416     JavaStorageEntry findPattern;

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

   418     JavaStorageApplicationEntry_t::const_iterator findIterator =

   419         aEntry.find(findPattern);

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

   421     {

   422         aColValue = findIterator->entryValue();

   423     }

   424 }

   425 

   426 

   427 int CJavaCaptainContainer::GetSecurityPolicy()

   428 {

   429     int securityPolicyId =KS60SecurityPolicyId;

   430     TRAP_IGNORE(

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

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

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

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

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

   436 {

   437     securityPolicyId = KS60SecurityPolicyId;

   438 }

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

   440 {

   441     securityPolicyId = KMSASecurityPolicyId;

   442 }

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

   444 {

   445     securityPolicyId = KATTSecurityPolicyId;

   446 }

   447 CleanupStack::PopAndDestroy(buf);

   448 CleanupStack::PopAndDestroy(repository););

   449     return securityPolicyId;

   450 }

   451 

   452 void CJavaCaptainContainer::SetSecurityPolicy(int aSecurityPolicyId)

   453 {

   454     TRAP_IGNORE(

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

   456         switch (aSecurityPolicyId)

   457 {

   458 case KS60SecurityPolicyId:

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

   460         break;

   461     case KMSASecurityPolicyId:

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

   463         break;

   464     case KATTSecurityPolicyId:

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

   466         break;

   467     }

   468     CleanupStack::PopAndDestroy(repository););

   469 }

   470 

   471 //

   472 // CJavaCaptainAppUi

   473 //

   474 CJavaCaptainAppUi::~CJavaCaptainAppUi()

   475 {

   476     JELOG2(EJavaCaptain);

   477     RemoveFromStack(iAppView);

   478     delete iAppView;

   479     delete mPeriodic;

   480 }

   481 

   482 void CJavaCaptainAppUi::ConstructL()

   483 {

   484     JELOG2(EJavaCaptain);

   485     BaseConstructL();

   486     iAppView=new(ELeave) CJavaCaptainContainer;

   487     iAppView->SetMopParent(this);

   488     iAppView->ConstructL(ClientRect());

   489 

   490     iCoeEnv->RootWin().EnableFocusChangeEvents();

   491     mPeriodic=CPeriodic::NewL(CActive::EPriorityStandard);

   492 

   493     AddToStackL(iAppView);

   494 

   495 }

   496 

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

   498 

   499 void senMsgToSplash(int id)

   500 {

   501     CommsMessage message;

   502     message.setModuleId(1);

   503     message.setMessageId(id);

   504     CommsClientEndpoint comms;

   505     comms.connect(10900);

   506     comms.send(message);

   507     comms.disconnect();

   508 }

   509 

   510 TInt CJavaCaptainAppUi::tick(TAny* appUi)

   511 {

   512     CJavaCaptainAppUi* app = static_cast<CJavaCaptainAppUi*>(appUi);

   513 //    ELOG1(EJavaCaptain,"mActive: %d", app->mActive);

   514     if (app->mActive)

   515     {

   516         senMsgToSplash(1);

   517     }

   518     else

   519     {

   520         senMsgToSplash(2);

   521     }

   522     app->mActive = !app->mActive;

   523     return 0;

   524 }

   525 

   526 void CJavaCaptainAppUi::HandleCommandL(TInt aCommand)

   527 {

   528     JELOG2(EJavaCaptain);

   529 

   530     switch (aCommand)

   531     {

   532     case EAknSoftkeyExit:

   533     case EEikCmdExit:

   534         Exit();

   535         break;

   536     case ECaptainStart:

   537     {

   538         RProcess proc;

   539         int st = proc.Create(KExecutableName, KExecutableName);

   540         if (st == KErrNone)

   541         {

   542             proc.Resume();

   543             iAppView->setCaptainState(true);

   544         }

   545         proc.Close();

   546     }

   547     break;

   548 

   549     case ECaptainStop:

   550     {

   551         CommsMessage message;

   552         message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C);

   553         message.setMessageId(CORE_MSG_ID_STOP_JAVACAPTAIN);

   554         CommsClientEndpoint comms;

   555         comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

   556         comms.send(message);

   557         comms.disconnect();

   558         iAppView->setCaptainState(false);

   559     }

   560     break;

   561 

   562     case EThreadDump:

   563     {

   564         CommsMessage message;

   565         message.setModuleId(PLUGIN_ID_JAVACAPTAIN_CORE_C);

   566         message.setMessageId(CORE_MSG_ID_DO_THREAD_DUMP);

   567         CommsClientEndpoint comms;

   568         comms.connect(IPC_ADDRESS_JAVA_CAPTAIN_C);

   569         comms.send(message);

   570         comms.disconnect();

   571     }

   572     break;

   573 

   574     case ETogglePrewarmEnable:

   575     case ETogglePrewarmUiEnable:

   576     case EDebugMode:

   577     case ESecurityMode:

   578     case ES60SecurityPolicy:

   579     case EMSASecurityPolicy:

   580     case EATTSecurityPolicy:

   581     case ERedirectMode:

   582         iAppView->handleStateChangeCmd(aCommand);

   583         break;

   584 

   585     default:

   586         Exit();

   587         break;

   588     }

   589 }

   590 

   591 CEikAppUi* CJavaCaptainEikDocument::CreateAppUiL()

   592 {

   593     JELOG2(EJavaCaptain);

   594     return(new(ELeave) CJavaCaptainAppUi);

   595 }

   596 

   597 void CJavaCaptainEikDocument::ConstructL()

   598 {

   599     JELOG2(EJavaCaptain);

   600 }

   601 

   602 TUid CJavaCaptainApplication::AppDllUid() const

   603 {

   604     JELOG2(EJavaCaptain);

   605     return KUidJavaCaptain;

   606 }

   607 

   608 CApaDocument* CJavaCaptainApplication::CreateDocumentL()

   609 {

   610     JELOG2(EJavaCaptain);

   611     CJavaCaptainEikDocument* document=new(ELeave) CJavaCaptainEikDocument(*this);

   612     CleanupStack::PushL(document);

   613     document->ConstructL();

   614     CleanupStack::Pop();

   615     return(document);

   616 }

   617 

   618 #include <eikstart.h>

   619 

   620 LOCAL_C CApaApplication* NewApplication()

   621 {

   622     JELOG2(EJavaCaptain);

   623     return new CJavaCaptainApplication;

   624 }

   625 

   626 

   627 GLDEF_C TInt E32Main()

   628 {

   629     JELOG2(EJavaCaptain);

   630     return EikStart::RunApplication(NewApplication);

   631 }

   632 

   633 

   634 #include <fcntl.h>

   635 #include <sys/types.h>

   636 #include <unistd.h>

   637 

   638 LogRedirector::LogRedirector() : mFd(-1)

   639 {

   640     iJavaDiagnostic.reset(JavaDiagnostic::createInstance());

   641 }

   642 

   643 LogRedirector::~LogRedirector()

   644 {

   645 }

   646 

   647 void LogRedirector::start()

   648 {

   649     iJavaDiagnostic->setDiagnosticListener(*this);

   650     mFd = open("c:\\data\\javaredirect.log", O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);

   651 }

   652 

   653 void LogRedirector::stop()

   654 {

   655     iJavaDiagnostic->removeDiagnosticListener();

   656     close(mFd);

   657     mFd = -1;

   658 }

   659 

   660 void LogRedirector::systemOut(const TDesC8& aData)

   661 {

   662     write(aData);

   663 }

   664 

   665 void LogRedirector::systemErr(const TDesC8& aData)

   666 {

   667     write(aData);

   668 }

   669 

   670 void LogRedirector::log(const TDesC8& aData)

   671 {

   672     write(aData);

   673 }

   674 

   675 void LogRedirector::write(const TDesC8& aData)

   676 {

   677     if (mFd > 0)

   678     {

   679         ::write(mFd, (const char*)aData.Ptr(), aData.Size());

   680     }

   681 };

   682 

   683 

   684 

   685 // End of File