FCL/sf/mw/appinstall: comparison secureswitools/swisistools/source/interpretsislib/installer.cpp

equal deleted inserted replaced

-:ae54820ef82c
+:245df5276b97
 #include "adornedutilities.h"
 // Constants
 const char KRomDriveLetter = 'z';
 const TUint32 KSwiDaemonUid = 0x10202DCE;
+#ifndef __TOOLS2_LINUX__
 const std::wstring KSysBinPath = L"\\sys\\bin\\";
+#else
+const std::wstring KSysBinPath = L"/sys/bin/";
+#endif
 TInt CheckWildCard(TInt aVal, TInt aReplace)
 {
 	return
 		aVal == -1
 	{
 		std::wstring shortName(curr->iFileName);
 		// Ensure formatting is correct
 		if ( StringUtils::IsLastCharacter( shortName, KDirectorySeparator[ 0 ] ) ||
+			 #ifndef __TOOLS2_LINUX__
 StringUtils::IsLastCharacter( shortName, L'/' ) )
+#else
+			 StringUtils::IsLastCharacter( shortName, L'\\' ) )
+			 #endif
 		{
 			shortName.erase(shortName.length()-1,1);
 		}
 		if ( IsDirectory(shortName) )
 					result =  FILE_ERROR;
 				}
 			catch  (InterpretSisError& e)
 				{
 				LERROR(L"Failed installing " << (curr->iFileName));
-				LERROR(L"\t" << Utf8ToUcs2(e.what()));
+				LERROR(L"\t" << string2wstring(e.what()));
 				curr = sisFiles.erase(curr);
 				if (result == 0)
 					result =  e.GetErrorCode();
 				}
 	}
 	catch  (InterpretSisError& e)
 	{
 		RestoreAll(file, installable, iBackupFlag);
-		LERROR(L"\t" << Utf8ToUcs2(e.what()));
+		LERROR(L"\t" << string2wstring(e.what()));
 		int result =  e.GetErrorCode();
 		return result;
 	}
 	catch  (...)
 	}
 	if (installType == CSISInfo::EInstAugmentation)
 	{
 		// Clean up the installed files from the specified SP package and the SisRegistry Entry
-		iRegistry.RemoveEntry(uid, aSis.GetPackageName(), aSis.GetVendorName());
+		iRegistry.RemoveEntry(uid, aSis.GetPackageName().c_str(), aSis.GetVendorName().c_str());
 	}
 	// Regenerate the ROM stub registry entries for eclipsing check later.
 	iRegistry.GenerateStubRegistry();
 }
 		{
 			std::string BackupDb(DbPath);
 			BackupDb.append("_backup");
 		 	err=FileCopyA(DbPath.c_str(),BackupDb.c_str(),0);
-			if (err == 0)
+			if (err != 0)
 				LERROR(L"Failed to Backup Database scr.db ");
 		}
 		// Backup all installed files for this Uid's packages and all the SisRegistry Entries
 		InstallableFiles::const_iterator filedesIter;
 		{
 			std::wstring itargetLocalFile = (*filedesIter)->GetLocalTarget();
 			if (FileExists(itargetLocalFile))
 			{
 				std::wstring itargetBackupFile = (*filedesIter)->GetLocalTarget();
-				itargetBackupFile.append(L"_backup");
+				std::wstring temp = itargetBackupFile.c_str();
+				temp.append(L"_backup");
+				itargetBackupFile = temp;
 				int pos =0;
-				if((pos = itargetBackupFile.find(L"\\sys\\bin\\", 0)) != std::wstring::npos)
+				#ifdef __LINUX__
+				std::wstring sysBin = L"/sys/bin/";
+				#else
+				std::wstring sysBin = L"\\sys\\bin\\";
+				#endif
+				if((pos = itargetBackupFile.find(sysBin, 0)) != std::wstring::npos)
 				{
 					BackupHashForFile(itargetLocalFile, iParamList.SystemDriveLetter(), iParamList.SystemDrivePath());
 				}
 				std::string iLocalFile = wstring2string(itargetLocalFile);
 				std::string iBackupFile = wstring2string(itargetBackupFile);
 				err=FileCopyA(iLocalFile.c_str(),iBackupFile.c_str(),0);
-				if (err == 0)
+				if (err != 0)
 					LERROR(L"Failed to Backup installable file ");
 			}
 		}
 	}
 }
 		for(filedesIter = aInstallable.begin() ; filedesIter != aInstallable.end(); ++filedesIter)
 		{
 		    itargetLocalFile = (*filedesIter)->GetLocalTarget();
 			itargetBackupFile = (*filedesIter)->GetLocalTarget();
-			itargetBackupFile.append(L"_backup");
+			std::wstring temp = itargetBackupFile.c_str();
+			temp.append(L"_backup");
+			itargetBackupFile = temp;
 			if (FileExists(itargetBackupFile))
 			{
 				RemoveFile(itargetBackupFile);
 				RemoveHashForFile(itargetBackupFile, iParamList.SystemDriveLetter(), iParamList.SystemDrivePath());
 			std::wstring itargetBackupFile = (*filedesIter)->GetLocalTarget();
 			itargetBackupFile.append(L"_backup");
 			if (FileExists(itargetBackupFile))
 			{
 				int pos =0;
-				if((pos = itargetBackupFile.find(L"\\sys\\bin\\", 0)) != std::wstring::npos)
+				#ifdef __LINUX__
+				std::wstring sysBin = L"/sys/bin/";
+				#else
+				std::wstring sysBin = L"\\sys\\bin\\";
+				#endif
+				if((pos = itargetBackupFile.find(sysBin, 0)) != std::wstring::npos)
 				{
 					RestoreHashForFile(itargetLocalFile, iParamList.SystemDriveLetter(), iParamList.SystemDrivePath());
 				}
 				std::string iLocalFile = wstring2string(itargetLocalFile);
 				std::string iBackupFile = wstring2string(itargetBackupFile);
 				int err = FileMoveA(iBackupFile.c_str(),iLocalFile.c_str());
+				if (err != 0)
-				if (err == 0)
 					LERROR(L"Failed to Restore file ");
 			}
 		}
 	}
 }
 			LINFO(L"Skipping file with empty destination filename");
 }
 else
 {
 			// Unicode characters can not be displayed on DOS prompt
-			std::string temporary = Ucs2ToUtf8(target);
+			std::string temporary = wstring2string(target);
-			std::wstring targetDisplay = Utf8ToUcs2( temporary );
+			std::wstring targetDisplay = string2wstring( temporary );
 		    LINFO(L"Installing file: " << targetDisplay);
 std::wstring targetDirectory = localTarget.substr( 0, localTarget.rfind( KDirectorySeparator ) );
 			const unsigned char* buffer = NULL;
 			TUint32 len;
 			if (aFile->IsExecutable() && !fileNullOption)
 			{
 				// register the hash
 				std::wstring basename = localTarget.substr( localTarget.rfind( KDirectorySeparator ) + 1 );
-				std::wstring hashdir = iSystemDrivePath + L"\\sys\\hash\\";
+				#ifndef __TOOLS2_LINUX__
+				// Remove the null character at the end and.
+				std::wstring tempStr = iSystemDrivePath.c_str();
+				std::wstring hashdir =  tempStr + L"\\sys\\hash\\";
 				std::wstring reghashdir = L"$:\\sys\\hash\\";
+				#else
+				std::wstring hashdir = iSystemDrivePath + L"/sys/hash/";
+				std::wstring reghashdir = L"$:/sys/hash/";
+				#endif
 				if ( !MakeDir( hashdir ) )
 				{
 					throw InterpretSisError(L"Directory Creation Error - "+hashdir,
 													DIRECTORY_CREATION_ERROR);
 				}
 				// hash file is always created on the system drive
 				reghashdir[0] = iSystemDrive;
 				LINFO(L"\tCreating hash: " << reghashdir << basename);
 				std::wstring hash = hashdir + basename;
 				HANDLE hFile = MakeSISOpenFile(hash.c_str(), GENERIC_WRITE, CREATE_ALWAYS);
 				if( INVALID_HANDLE_VALUE == hFile )
 				{
 					throw InterpretSisError(L"FileOpenError - " + hashdir + basename, FILE_ERROR);
 	FindAllAdornedVariants(searchNameWild, KSysBinPath, aAdornedFileNamesFound, driveMap);
 	// find all adorned variants in the ROM/ROFS logs
 	if (iParamList.IsFlagSet(CParameterList::EFlagsRomRofsLogFilesSet))
 	{
+	#ifndef __TOOLS2_LINUX__
 		std::wstring romSearchNameWild = L"z:\\sys\\bin\\";
+	#else
+		std::wstring romSearchNameWild = L"z:/sys/bin/";
+	#endif
 		romSearchNameWild.append(searchNameWild);
 		iRomManager.FindAllAdornedVariants(romSearchNameWild, aAdornedFileNamesFound);
 	}
 }
 		}
 		else if (disk == 'z') // case (2)
 		{
 			// we are eclipsing a ROM file, check if this is authorised:
 			// see implementation of IsEclipsable()
+			#ifndef __TOOLS2_LINUX__
 			if (!IsEclipsable(searchNameUnadorned, aSUFlag))
+			#else
+			if (!IsEclipsable(searchNameUnadorned, aSUFlag, localDir))
+			#endif
 			{
 				result = false;
 				break;
 			}
 		}
 		// now check to see whether the unadorned or the adorned filename found on
 		// this drive should be added to iEclipsableOverwriteFiles.
 		if (processEclipsingSuspectsFoundOnThisDrive && unadornedFound)
 		{
-			iEclipsableOverwriteFiles.push_back(searchNameUnadorned);
+			iEclipsableOverwriteFiles.push_back(searchNameUnadorned.c_str());
 		}
 		if (processEclipsingSuspectsFoundOnThisDrive && adornedFound)
 		{
 			nrOfAdornedFilenamesFound = adornedFileNamesFound.size();
 			{
 				std::wstring adornedFile = *index;
 				int drive = tolower(adornedFile[0]);
 				if (drive == disk)
 				{
-					iEclipsableOverwriteFiles.push_back(adornedFile);
+					iEclipsableOverwriteFiles.push_back(adornedFile.c_str());
 				}
 			}
 		}
 	}
 	// end of loop
 and we have z:\sys\bin\A.dll as an eclipsable file or any z:\sys\bin\A{????????}.dll
 then we are allowed to eclipse.
 @param aRomFile fully qualified filename in ROM that is to be checked for eclipising (i.e: z:\sys\bin\some.dll)
 @param aSUFlag specifies if the installing SIS file has been signed by a SU certificate
 */
+#ifndef __TOOLS2_LINUX__
 bool Installer::IsEclipsable(std::wstring& aRomFile, bool aSUFlag)
+#else
+bool Installer::IsEclipsable(std::wstring& aRomFile, bool aSUFlag, const std::wstring& aDrivePath)
+#endif
 {
 	// SA/SP/PU sis + RU flag + signed by SU root cert is allowed
 	if (aSUFlag)
 		return true;
 			isEclipsable = true;
 			break;
 		}
 		else if (goesToSysBin) // case 2
 		{
+			#ifndef __TOOLS2_LINUX__
 			if (IsAdornedVariationOf(eclipsableRomFile,aRomFile))
+			#else
+			if (IsAdornedVariationOf(eclipsableRomFile,aRomFile,aDrivePath))
+			#endif
 			{
 				isEclipsable = true;
 				break;
 			}
 		}
 	if (owningUid == 0)
 	{
 		// do not display a warning if the installing file is a PA. The user
 		// needs to copy the installing files to the installing directory
 		// prior to installing the SIS file.
-		std::string tempTarget = Ucs2ToUtf8(aTarget);
+		std::string tempTarget = wstring2string(aTarget);
-	  	std::wstring targetDisplay = Utf8ToUcs2( tempTarget );
+	  	std::wstring targetDisplay = string2wstring( tempTarget );
 		if (aFile.GetInstallType() == CSISInfo::EInstPreInstalledApp)
 		{
 			LINFO(targetDisplay << L" found for PA installation");
 		}
 		else
 	{
 		// SP can not overwrite a file in the base pkg
 		if (isSp)
 		{
 			std::wostringstream os;
-			os << aTarget << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"" << std::endl;
+			os << aTarget.c_str() << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"" << std::endl;
 			iProblemFiles.append(os.str());
 			iError = ECLIPSING_VIOLATION;
 		}
 	}
 	else
 		// PU/SA can not overwrite a file belonging to a different base pkg unless it has been signed by
 		// a SU cert
 		if (isSp || (!aSUFlag && (isPu || isSa)))
 		{
 			std::wostringstream os;
-			os << aTarget << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"" << std::endl;
+			os << aTarget.c_str() << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"" << std::endl;
 			iProblemFiles.append(os.str());
 			iError = ECLIPSING_VIOLATION;
 		}
 		else
 		{
-			LWARN(aTarget << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"");
+		    LWARN(aTarget.c_str() << L" overwrites file from base package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"");
 		}
 	}
 }
 void Installer::WarnEclipseOverWrite(const SisFile& aFile)
 		for ( ; curr != end; ++curr)
 		{
 			std::wstring eclipseFile(*curr);
 			TUint32 owningUid = 0;
-			const SisRegistryObject* owningObj = iRegistry.OwningPackage(eclipseFile, owningUid);
+			const SisRegistryObject* owningObj = iRegistry.OwningPackage(eclipseFile.c_str(), owningUid);
 			// always allow orphaned file overwriting
 			if (owningUid == 0)
 			{
-				LWARN(eclipseFile << L" eclipses orphaned file.");
+			    LWARN(eclipseFile.c_str() << L" eclipses orphaned file.");
 			}
 			else
 			{
 				// SP/PU can not overwrite a file belonging to a different base pkg or
 				// SP/PU can not eclipse a base package which is not in the ROM.
 				std::wostringstream os;
-				os << eclipseFile << L" eclipses file from package 0x" << std::hex << owningUid << L" \"" << owningObj->GetPackageName() << L"\"" << std::endl;
+				os << eclipseFile.c_str() << L" eclipses file from package 0x"  << std::hex << owningUid << L" \"" << owningObj->GetPackageName().c_str() << L"\""<< std::endl;
 				iProblemFiles.append(os.str());
 				iError = ECLIPSING_VIOLATION;
 				continue;
 			}
 		}
 	iError = SUCCESS;
 	Sids sids;
 	GetSidsFromInstallable(aFiles, sids);
+	#ifndef __TOOLS2_LINUX__
 	const std::wstring privatePath = L":\\private\\";
 	const std::wstring sysPath = L":\\sys\\";
 	const std::wstring sysBinPath = L":\\sys\\bin\\";
 	const std::wstring resourcePath = L":\\resource\\";
+	#else
+	const std::wstring privatePath = L":/private/";
+	const std::wstring sysPath = L":/sys/";
+	const std::wstring sysBinPath = L":/sys/bin/";
+	const std::wstring resourcePath = L":/resource/";
+	#endif
 	const std::wstring exeType = L".exe";
 int num_of_files = aFiles.size();
 	TUint32 pkgUid = aFile.GetPackageUid();
 	TUint32 installType = aFile.GetInstallType();
 	{
 		const InstallableFile* file = aFiles[ ii ];
 const CSISFileDescription* sisDescription = file->FileDescription();
 		// file to be installed
-		std::wstring target( file->GetTarget() );
+		std::wstring target( file->GetTarget().c_str() );
 		if (sisDescription->Operation() == CSISFileDescription::EOpText)
 			break;
 		if (sisDescription->Operation() == CSISFileDescription::EOpNull)
 			{
 			// a FN file can not remove a file from \sys or \resource
 			if ((target.find(sysPath,0) != std::wstring::npos) || (target.find(resourcePath,0) != std::wstring::npos))
 				{
 				// eclipsing problem
 				std::wostringstream os;
-				os << L"FN file \"" << target << L"\" can not remove a file from \\sys or \\resource" << std::endl;
+				os << L"FN file \"" << target.c_str() << L"\" can not remove a file from \\sys or \\resource" << std::endl;
 				iProblemFiles.append(os.str());
 				iError = DATA_CAGE_VIOLATION;
 				continue;
 				}
 			}
 else
 {
-			std::wstring realTarget(file->GetLocalTarget());
+			std::wstring realTarget(file->GetLocalTarget().c_str());
 		    std::wstring romTarget(target);
 			romTarget[0] = KRomDriveLetter;
 			// check to see if we are legally allowed to eclipse a ROM file
 			{
 				if (!ValidEclipse(aFile, target, *file, suFlag))
 				{
 					// eclipsing problem
 					std::wostringstream os;
-					os << target << L" eclipses file from ROM" << std::endl;
+					os << target.c_str() << L" eclipses file from ROM" << std::endl;
 					iProblemFiles.append(os.str());
 					iError = ECLIPSING_VIOLATION;
 					continue;
 				}
 			}
 						// this package is trying to write to a SID's private directory
 						// which does not belong to this package
 						const int KUidStringLength = 8;
 						std::wstring importPath = privatePath;
+						#ifndef __TOOLS2_LINUX__
 						importPath.append( uidStr.str() + L"\\import" );
+						#else
+						importPath.append( uidStr.str() + L"/import" );
+						#endif
 						if ((target.find(importPath,0) == std::wstring::npos) && !suFlag)
 						{
 							// only SA with RU + SU and PU with RU + SU flag can override other private directory
 							std::wostringstream os;
-							os << target << L" cannot be written to a private directory which "
+							os << target.c_str() << L" cannot be written to a private directory which "
 								<< L"does not belong to any exe in this package" << std::endl;
 							iProblemFiles.append(os.str());
 							iError = DATA_CAGE_VIOLATION;
 							continue;
 						}
 					if (!allowSidEclipse)
 					{
 						std::wostringstream os;
-						os << L"The existing file " << owningSidFile << L" already has the SID 0x" << std::hex << sid
+						os << L"The existing file " << owningSidFile.c_str() << L" already has the SID 0x" << std::hex << sid
-						   << std::dec << L", cannot install " << target << std::endl;
+						   << std::dec << L", cannot install " << target.c_str() << std::endl;
 						iProblemFiles.append(os.str());
 						iError = DUPLICATE_SID;
 						continue;
 					}
 				}
 							sisController->InstallBlock().GetFileList(fileDesList);
 							for(TFileDescListConstIter iter = fileDesList.begin(); iter != fileDesList.end(); ++iter)
 							{
 								const CSISFileDescription* fD = *iter;
-								std::wstring romStubTarget(fD->Target().GetString());
+								std::wstring romStubTarget(fD->Target().GetString().c_str());
 								if (StringUtils::WildcardCompare(romStubTarget,romFileWithDuplicateSid))
 								{
 									ownedByRomStub = true;
 									break;
 					if (!allowSidEclipse && !ownedByRomStub)
 					{
 						std::wostringstream os;
 						os << L"A ROM file already has the SID 0x" << std::hex << file->Sid()
-						   << std::dec << L", cannot install " << target << std::endl;
+						   << std::dec << L", cannot install " << target.c_str() << std::endl;
 						iProblemFiles.append(os.str());
 						iError = DUPLICATE_SID;
 						continue;
 					}
 				}
 		    }
 		    else if (realTarget.find(sysBinPath) != std::wstring::npos)
 		    {
 				std::wostringstream os;
-				os << target << L" cannot be installed to a data caged area" << std::endl;
+				os << target.c_str() << L" cannot be installed to a data caged area" << std::endl;
 				iProblemFiles.append(os.str());
 				iError = DATA_CAGE_VIOLATION;
 				continue;
 		    }
 }
 	iEclipsableOverwriteFiles.clear();
 	iEclipsableRomFiles.clear();
 	if (!iProblemFiles.empty())
 	{
-		std::string x;
+		std::string x = wstring2string(iProblemFiles);
-		throw InvalidSis("", Ucs2ToUtf8(iProblemFiles,x), iError);
+		throw InvalidSis("", x, iError);
 	}
 }
 void Installer::SetupExpressionEnvironment(const SisFile& aFile, const SisRegistry& aSisRegistry, RomManager& aRomManager )
 {
 void Installer::CreateStubSisFile(const InstallSISFile& aInstallSISFile, SisFile& aSis)
 {
 	int targetDrive = aInstallSISFile.iTargetDrive;
 	std::wstring drivePath = iConfigManager.GetLocalDrivePath(targetDrive);
+	#ifndef __TOOLS2_LINUX__
 	drivePath.append(L"\\private\\");
+	#else
+	drivePath.append(L"/private/");
+	#endif
 	// build SwiDaemon Pathname
 	std::wstring ctrl = StringUtils::MakePathFromSID(drivePath, KSwiDaemonUid);
 	if ( !MakeDir( ctrl ) )
 	std::wstringstream s;
 	s << std::hex << aSis.GetPackageUid();
 	ctrl.append(s.str());
 	switch(aSis.GetInstallType())
 {
 	case CSISInfo::EInstInstallation:
 	case CSISInfo::EInstPreInstalledApp:

changeset 60	245df5276b97
parent 42	d17dc5398051
child 75	2d2d25361590