1 /*

     2 * Copyright (c) 2007-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 <f32file.h>

    20 #include <e32property.h>

    21 #include <swi/pkgremovererrors.h>

    22 #include <swi/swispubsubdefs.h>

    23 #include "sishelper.h"

    24 #include "log.h"

    25 #include "installclientserver.h"

    26 #include <swi/pkgremover.h>

    27 #include <connect/sbdefs.h>

    28 

    29 // Maximum buffer size

    30 const TInt KMaxBufferSize = 1024;

    31 

    32 namespace Swi

    33 {

    34 

    35 // Forward declarations

    36 TInt StartSisHelper(RThread& aServer);

    37 TInt SisHelperThreadFunction(TAny* );

    38 void StopSisHelper(TAny* aServer);

    39 TBool IsSWISBusy();

    40 TInt StartSwi();

    41 TInt FilterErrors(TInt aError);

    42 

    43 /*static*/

    44 EXPORT_C void UninstalledSisPackages::ListL(TDriveNumber aDrive, RPointerArray<CUninstalledPackageEntry>& aPackageList)

    45 	{

    46 	aPackageList.ResetAndDestroy();

    47 

    48 	// Check if SWIS is busy

    49 	if (IsSWISBusy())

    50 		{

    51 		User::Leave(KErrServerBusy);

    52 		}

    53 

    54 	RThread server;

    55 

    56 	// Ensure SisHelper is stopped in the event of a leave

    57 	CleanupStack::PushL(TCleanupItem(StopSisHelper, &server));

    58 	User::LeaveIfError(StartSisHelper(server));

    59 

    60 	// Connect to SWIS and issue request

    61 	RUninstalledPkgsSession uninstalledPkgSession;

    62 	User::LeaveIfError(uninstalledPkgSession.Connect());

    63 	CleanupClosePushL(uninstalledPkgSession);

    64 

    65 	HBufC8* output = HBufC8::NewLC(KMaxBufferSize);

    66 	

    67 	TPtr8 pOutput(output->Des());

    68 	TInt result = uninstalledPkgSession.RequestUnInstalledPkgsList(TIpcArgs(aDrive, &pOutput));

    69 

    70 	if (result == KErrOverflow)

    71 		{

    72 		TInt sizeNeeded = 0;

    73 		TPckg<TInt> sizeNeededPackage(sizeNeeded);

    74 		sizeNeededPackage.Copy(*output);

    75 

    76 		// Shutdown 

    77 		CleanupStack::PopAndDestroy(3, &server); //InstallServer , SisHelper and output

    78 

    79 		// Check if SWIS is busy

    80 		if (IsSWISBusy())

    81 			{

    82 			User::Leave(KErrServerBusy);

    83 			}

    84 

    85 		// Restart sishelper and ReConnect to SWIS to issue request

    86 		// Ensure SisHelper is stopped in the event of a leave

    87 		CleanupStack::PushL(TCleanupItem(StopSisHelper, &server));

    88 		User::LeaveIfError(StartSisHelper(server));

    89 		User::LeaveIfError(uninstalledPkgSession.Connect());

    90 		CleanupClosePushL(uninstalledPkgSession);

    91 

    92 		// Re-allocate buffer

    93 		output = HBufC8::NewLC(sizeNeeded);

    94 		pOutput.Set(output->Des());

    95 	

    96 		result = uninstalledPkgSession.RequestUnInstalledPkgsList(TIpcArgs(aDrive, &pOutput));

    97 		}

    98 	User::LeaveIfError(FilterErrors(result));

    99 

   100 	// Internalise the pointer array  

   101 	RDesReadStream readStream(pOutput);

   102 	CleanupClosePushL(readStream);

   103 

   104 	// read in the attribute values from the buffer

   105 	TInt count = readStream.ReadInt32L();

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

   107 		{

   108 		TInt uidValue = readStream.ReadInt32L();

   109 		TUid uid = TUid::Uid(uidValue);

   110 		

   111 		// Read the package name

   112 		TInt size = readStream.ReadInt32L();

   113 		HBufC* pName = HBufC::NewLC(size);

   114 		TPtr pPtr(pName->Des());

   115 		readStream.ReadL(pPtr, size);

   116 					

   117 		// Read the vendor name

   118 		size = readStream.ReadInt32L();

   119 		HBufC* vName = HBufC::NewLC(size);

   120 		TPtr vPtr(vName->Des());

   121 		readStream.ReadL(vPtr, size);

   122 		

   123 		TInt major = readStream.ReadInt32L();

   124 		TInt minor = readStream.ReadInt32L();

   125 		TInt build = readStream.ReadInt32L();

   126 		TVersion version(major,minor,build);

   127 		

   128 		// Read the package type

   129 		CUninstalledPackageEntry::TPackageType pkgType = CUninstalledPackageEntry::TPackageType(readStream.ReadInt32L());

   130 

   131 		// Read the file name

   132 		size = readStream.ReadInt32L();

   133 		HBufC* fName = HBufC::NewLC(size);

   134 		TPtr fPtr(fName->Des());

   135 		readStream.ReadL(fPtr, size);

   136 

   137 		// Read the associated stub file 

   138 		size = readStream.ReadInt32L();

   139 		HBufC* aName = HBufC::NewLC(size);

   140 		TPtr aPtr(aName->Des());

   141 		readStream.ReadL(aPtr, size);

   142 		

   143 		CUninstalledPackageEntry* PkgEntry = CUninstalledPackageEntry::NewLC(uid,

   144 		*pName, *vName, version, pkgType, *fName, *aName);

   145 		aPackageList.AppendL(PkgEntry);

   146 		CleanupStack::Pop(PkgEntry); 			// PkgEntry

   147 		CleanupStack::PopAndDestroy(4, pName); 	// aName, fName, vName, pName

   148 		}

   149 	CleanupStack::PopAndDestroy(2, output); 	// readStream, output

   150 

   151 	// Shutdown InstallServer and SisHelper

   152 	CleanupStack::PopAndDestroy(2, &server);

   153 	}

   154 

   155 /*static*/

   156 EXPORT_C void UninstalledSisPackages::RemoveL(const CUninstalledPackageEntry& aPackage)

   157 	{

   158 	// Check if SWIS is busy

   159 	if (IsSWISBusy())

   160 		{

   161 		User::Leave(KErrServerBusy);

   162 		}

   163 

   164 	// Get the filename

   165 	RThread server;

   166 	// Ensure SisHelper is stopped in the event of a leave

   167 	CleanupStack::PushL(TCleanupItem(StopSisHelper, &server));

   168 	User::LeaveIfError(StartSisHelper(server));

   169 

   170 	// Connect to SWIS and issue request

   171 	RUninstalledPkgsSession uninstalledPkgSession;

   172 	User::LeaveIfError(uninstalledPkgSession.Connect());

   173 	CleanupClosePushL(uninstalledPkgSession);

   174 	TIpcArgs args;

   175 	args.Set(0, &aPackage.PackageFile());

   176 	args.Set(1, &aPackage.AssociatedStubSisFile());

   177 	User::LeaveIfError(FilterErrors(uninstalledPkgSession.RemoveUnInstalledPkg(args)));

   178 

   179 	// Shutdown InstallServer and SisHelper

   180 	CleanupStack::PopAndDestroy(2, &server);

   181 	}

   182 

   183 CUninstalledPackageEntry* CUninstalledPackageEntry::NewLC(const TUid& aUid, const TDesC& aPackageName,

   184 		const TDesC& aVendorName, const TVersion& aVersion, const TPackageType aPackageType,

   185 		const TDesC& aPackageFile, const TDesC& aAssocStubSisFile)

   186  	{

   187  	CUninstalledPackageEntry* self = new(ELeave) CUninstalledPackageEntry();

   188  	CleanupStack::PushL(self);

   189  	self->ConstructL(aUid, aPackageName, aVendorName, aVersion, aPackageType, aPackageFile, aAssocStubSisFile);

   190  	return self;

   191  	}

   192 

   193 CUninstalledPackageEntry::CUninstalledPackageEntry()

   194 	{

   195 	}

   196 

   197 CUninstalledPackageEntry::~CUninstalledPackageEntry()

   198 	{

   199 	delete iVendorName;

   200 	delete iPackageName;

   201 	delete iPackageFile;

   202 	delete iAssocStubSisFile;

   203 	}

   204 

   205 // Constructs the objects using the property values

   206 void CUninstalledPackageEntry::ConstructL(const TUid& aUid, const TDesC& aPackageName,

   207 		const TDesC& aVendorName, const TVersion& aVersion, const TPackageType aPackageType, 

   208 		const TDesC& aPackageFile, const TDesC& aAssocStubSisFile)

   209 	{

   210 	iUid = aUid;

   211 	iPackageName = aPackageName.AllocL();

   212 	iVendorName = aVendorName.AllocL();

   213 	iVersion = aVersion;

   214 	iType = aPackageType;

   215 	iPackageFile = aPackageFile.AllocL();

   216 	iAssocStubSisFile = aAssocStubSisFile.AllocL();	

   217 	}

   218 

   219 // Get methods

   220 EXPORT_C const TUid& CUninstalledPackageEntry::Uid() const

   221 	{

   222 	return iUid;

   223 	}

   224 

   225 EXPORT_C const TDesC& CUninstalledPackageEntry::Name() const

   226 	{

   227 	return *iPackageName;

   228 	}

   229 

   230 EXPORT_C const TDesC& CUninstalledPackageEntry::Vendor() const

   231 	{

   232 	return *iVendorName;

   233 	}

   234 

   235 EXPORT_C const TVersion& CUninstalledPackageEntry::Version() const

   236 	{

   237 	return iVersion;

   238 	}

   239 

   240 EXPORT_C const CUninstalledPackageEntry::TPackageType& CUninstalledPackageEntry::PackageType() const

   241 	{

   242 	return iType;

   243 	}

   244 

   245 const TDesC& CUninstalledPackageEntry::PackageFile() const

   246 	{

   247 	return *iPackageFile;

   248 	}

   249 

   250 const TDesC& CUninstalledPackageEntry::AssociatedStubSisFile() const

   251 	{

   252 	return *iAssocStubSisFile;

   253 	}

   254 

   255 // Client-side session implementation

   256 TInt RUninstalledPkgsSession::Connect()

   257 	{

   258 	TInt retry = 2;

   259 	for(;;)

   260 		{

   261 		TInt err = CreateSession(Swi::KInstallServerName, 

   262 		    TVersion(KInstallServerVersionMajor, KInstallServerVersionMinor, KInstallServerVersionBuild));

   263 		if (err != KErrNotFound && err != KErrServerTerminated)

   264 			{

   265 			return err;

   266 			}

   267 		if (--retry == 0)

   268 			{

   269 			return err;

   270 			}

   271 		err = StartSwi();

   272 		if (err != KErrNone && err != KErrAlreadyExists)

   273 			{

   274 			return err;

   275 			}

   276 		}

   277 	}

   278 

   279 void RUninstalledPkgsSession::Close()

   280 	{

   281 	RSessionBase::Close();

   282 	}

   283 

   284 TInt RUninstalledPkgsSession::RequestUnInstalledPkgsList(const TIpcArgs& aArgs)

   285 	{

   286 	return SendReceive(Swi::EListUnInstalledPkgs, aArgs);

   287 	}

   288 

   289 TInt RUninstalledPkgsSession::RemoveUnInstalledPkg(const TIpcArgs& aArgs)

   290 	{

   291 	return SendReceive(Swi::ERemoveUnInstalledPkg, aArgs);

   292 	}

   293 

   294 // Starts SISHelper in a new thread

   295 TInt StartSisHelper(RThread& aServer)

   296 	{

   297 	// We might be trying to restart a server, in which case we could

   298 	// get a thread name clash. We could make the name unique/random,

   299 	// but the server name would still clash...

   300 

   301 	const TInt KSisHelperServerStackSize = 0x2000;

   302 	TInt err = KErrNone;

   303 	for (TInt retry = 0; retry < 2; ++retry)

   304 		{

   305 		err = aServer.Create(KSisHelperServerName, SisHelperThreadFunction, 

   306 					   		KSisHelperServerStackSize, NULL, NULL, EOwnerThread);

   307 

   308 		if (err == KErrAlreadyExists || err == KErrInUse)

   309 			{

   310 			User::After(80000);

   311 			}

   312 		else

   313 			{

   314 			break;

   315 			}

   316 		}

   317 

   318 	if ((err == KErrAlreadyExists) || (err == KErrInUse))

   319 		{

   320 		return KErrServerBusy;

   321 		}

   322 

   323 	if (err != KErrNone)

   324 		{

   325 		return err;

   326 		}

   327 

   328 	// The following code is the same whether the server runs in a new thread 

   329 	// or process

   330 	TRequestStatus stat;

   331 	aServer.Rendezvous(stat);

   332 	if (stat != KRequestPending)

   333 		{

   334 		aServer.Kill(0); // abort startup

   335 		}

   336 	else

   337 		{

   338 		aServer.Resume(); // logon OK, start the server

   339 		}

   340 

   341 	User::WaitForRequest(stat); // wait for start or death

   342 

   343 	// we can't use the 'exit reason' if the server panicked as this is the 

   344 	// panic 'reason' and may be 0 which cannot be distinguished from KErrNone

   345 	err = (aServer.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

   346 	//We don't close aServer here. If asynchlauncher called, it will be closed

   347 	//in the RunL() method of uissclienthandler to make sure that SISHelper has been 

   348 	//disconnected by SWISInstaller. Otherwise, just after this function call.

   349 	return err;

   350 	}

   351 

   352 // Stops SISHelper

   353 void StopSisHelper(TAny* aServer)

   354 	{

   355 	RThread* rServer = static_cast<RThread*> (aServer);

   356 	if(rServer->Handle() > 0)

   357 		{

   358 		TRequestStatus reqStatus;

   359 		rServer->Logon(reqStatus);

   360 		User::WaitForRequest(reqStatus);

   361 		rServer->Close();

   362 		}

   363 	}

   364 

   365 // Entry point for the thread the SISHelper runs in

   366 TInt SisHelperThreadFunction(TAny* )

   367 	{

   368 	CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

   369 	if (!cleanup)

   370 		{

   371 		return KErrNoMemory;

   372 		}

   373 		

   374 	CActiveScheduler* scheduler = new CActiveScheduler;

   375 	if (!scheduler)

   376 		{

   377 		delete cleanup;

   378 		return KErrNoMemory;

   379 		}

   380 

   381 	DEBUG_PRINTF(_L8("Sis Helper - Starting Server"));

   382 

   383 	CActiveScheduler::Install(scheduler);

   384 

   385 	TSisHelperStartParams params;

   386 	CSisHelperServer* server = static_cast<CSisHelperServer*>(NULL);

   387 	TRAPD(err, server = CSisHelperServer::NewL(params));

   388 

   389 	if (err == KErrNone)

   390 		{

   391 		// only continue launching the server if no error

   392 		RThread::Rendezvous(KErrNone);

   393 		scheduler->Start();

   394 		}

   395 

   396 	DEBUG_PRINTF(_L8("Sis Helper - Stopping Server"));

   397 

   398 	CActiveScheduler::Install(NULL);

   399 	delete server;

   400 	delete scheduler;

   401 	delete cleanup; // destroy clean-up stack

   402 

   403 	return err;

   404 	}

   405 

   406 // Starts SWIS in a new process

   407 TInt StartSwi()

   408 	{

   409 	const TUidType serverUid(KNullUid, KNullUid, Swi::KInstallServerUid3);

   410 	RProcess server;

   411 

   412 	TInt err = server.Create(Swi::KInstallServerImage, KNullDesC, serverUid);

   413 	if (err != KErrNone)

   414 		{

   415 		return err;

   416 		}

   417 	TRequestStatus stat;

   418 	server.Rendezvous(stat);

   419 	if (stat != KRequestPending)

   420 		{

   421 		server.Kill(0); // abort startup

   422 		}

   423 	else

   424 		{

   425 		server.Resume(); // logon OK, start the server

   426 		}

   427 

   428 	User::WaitForRequest(stat); // wait for start or death

   429 

   430 	// We can't use the 'exit reason' if the server panicked as this is the

   431 	// panic 'reason' and may be 0 which cannot be distinguished from KErrNone.

   432 	err = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

   433 	server.Close();

   434 	return err;

   435 	}

   436 

   437 TBool IsSWISBusy()

   438 	{

   439 	// Check for Install/Uninstall operation

   440 	TInt property = 0;

   441 	TInt err = RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property);

   442 	if ((err != KErrNotFound) && ((property & KSwisOperationMask) != ESwisNone))

   443 		{

   444 		return ETrue;

   445 		}

   446 	return EFalse;

   447 	}

   448 

   449 // Filter the error codes returned by the List and Remove API

   450 TInt FilterErrors(TInt aError)

   451 	{

   452 	TInt outError = aError;

   453 	// If the error is in SWI range (publishedPartner) then return a publishedAll equivalent

   454 	// for some of them

   455 	if (aError > KErrNotRemovable && aError <= KErrSISFieldIdMissing)	// Range is -10280 to -10100

   456 		{

   457 		outError = KErrPackageFileCorrupt;

   458 		}

   459 

   460 	return outError;

   461 	}

   462 

   463 } // namespace Swi