1 /*

     2 * Copyright (c) 2004-2009 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 the License "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 <c32comm.h>

    20 

    21 #if defined (__WINS__)

    22 #define PDD_NAME		_L("ECDRV")

    23 #else

    24 #define PDD_NAME		_L("EUART1")

    25 #define PDD2_NAME		_L("EUART2")

    26 #define PDD3_NAME		_L("EUART3")

    27 #define PDD4_NAME		_L("EUART4")

    28 #endif

    29 

    30 #define LDD_NAME		_L("ECOMM")

    31 

    32 /**

    33  * @file tRevocationServer.cpp

    34  *

    35  * server implementation

    36  */

    37 

    38 #include "trevocationServer.h"

    39 #include "trevocationStep.h"

    40 

    41 _LIT(KServerName,"tRevocation");

    42 

    43 /**

    44  * Called inside the MainL() function to create and start the CTestServer 

    45  * derived server.

    46  * @return Instance of the test server

    47  */

    48 CTRevocationServer* CTRevocationServer::NewL()

    49 	{

    50 	CTRevocationServer * server = new (ELeave) CTRevocationServer();

    51 	CleanupStack::PushL(server);

    52 	

    53 	// Either use a StartL or ConstructL, the latter will permit Server Logging.

    54 

    55 	//server->StartL(KServerName); 

    56 	server->ConstructL(KServerName);

    57 	CleanupStack::Pop(server);

    58 	return server;

    59 	}

    60 

    61 static void InitCommsL()

    62     {

    63     TInt ret = User::LoadPhysicalDevice(PDD_NAME);

    64     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    65 

    66 #ifndef __WINS__

    67     ret = User::LoadPhysicalDevice(PDD2_NAME);

    68     ret = User::LoadPhysicalDevice(PDD3_NAME);

    69     ret = User::LoadPhysicalDevice(PDD4_NAME);

    70 #endif

    71 

    72     ret = User::LoadLogicalDevice(LDD_NAME);

    73     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    74     ret = StartC32();

    75     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    76 	}

    77 

    78 LOCAL_C void MainL()

    79 	{

    80 	// Leave the hooks in for platform security

    81 #if (defined __DATA_CAGING__)

    82 	RProcess().DataCaging(RProcess::EDataCagingOn);

    83 	RProcess().SecureApi(RProcess::ESecureApiOn);

    84 #endif

    85 	InitCommsL();

    86 	CActiveScheduler* sched=NULL;

    87 	sched=new(ELeave) CActiveScheduler;

    88 	CleanupStack::PushL(sched);

    89 	CActiveScheduler::Install(sched);

    90 	CTRevocationServer* server = NULL;

    91 	// Create the CTestServer derived server

    92 	TRAPD(err,server = CTRevocationServer::NewL());

    93 	if(!err)

    94 		{

    95 		RProcess::Rendezvous(KErrNone);

    96 		sched->Start();

    97 		}

    98 	CleanupStack::Pop(sched);

    99 	delete server;

   100 	delete sched;

   101 	}

   102 

   103 GLDEF_C TInt E32Main()

   104 	{

   105 	CTrapCleanup* cleanup = CTrapCleanup::New();

   106 	if(cleanup == NULL)

   107 		{

   108 		return KErrNoMemory;

   109 		}

   110 	TRAP_IGNORE(MainL());	

   111 	delete cleanup;

   112 	return KErrNone;

   113     }

   114 

   115 CTestStep* CTRevocationServer::CreateTestStep(const TDesC& aStepName)

   116 	{

   117 	CTestStep* testStep = NULL;

   118 

   119 	if(aStepName == KTStepInstall)

   120 		{

   121 		testStep = new CTStepInstall();

   122 		}

   123 	else if(aStepName == KTStepUninstall)

   124 		{

   125 		testStep = new CTStepUninstall();

   126 		}

   127 	else if(aStepName == KTStepBackup)

   128 		{

   129 		testStep = new CTStepBackup();

   130 		}

   131 	else if(aStepName == KTStepRestore)

   132 		{

   133 		testStep = new CTStepRestore();

   134 		}

   135 	else if(aStepName == KTStepRestoreNoCommit)

   136 		{

   137 		testStep = new CTStepRestoreNoCommit();

   138 		}

   139 	else if(aStepName == KTStepRestoreCorruptController)

   140 		{

   141 		testStep = new CTStepRestoreCorruptController();

   142 		}

   143 	else if(aStepName == KTStepRestoreExtraExecutable)

   144 		{

   145 		testStep = new CTStepRestoreExtraExecutable();

   146 		}

   147 	else if(aStepName == KTStepCheckPresent)

   148 		{

   149 		testStep = new CTStepCheckPresent();

   150 		}

   151 	else if(aStepName == KTStepCheckAbsent)

   152 		{

   153 		testStep = new CTStepCheckAbsent();

   154 		}

   155 	else if(aStepName == KTStepClean)

   156 		{

   157 		testStep = new CTStepClean();

   158 		}

   159 	else if(aStepName == KTStepPirCheck)

   160 		{

   161 		testStep = new CTStepPirCheck();

   162 		}

   163 	else if(aStepName == KTStepSisRegCheck)

   164 		{

   165 		testStep = new CTStepSisRegCheck();

   166 		}

   167 	return testStep;

   168 	}