FCL/sf/mw/appinstall: comparison secureswitools/swisistools/source/rscparser/aplappinforeader.cpp

equal deleted inserted replaced

-:ae54820ef82c
+:245df5276b97
 #define REINTERPRET_CAST(type,exp) (reinterpret_cast<type>(exp))
 const TUint KResourceOffsetMask = 0xFFFFF000;
+#ifdef __LINUX__
+std::string KAppBinaryPathAndExtension("/sys/bin/.exe");
+#else
 std::string KAppBinaryPathAndExtension("\\sys\\bin\\.exe");
+#endif
 const TInt KAppRegistrationInfoResourceId = 1;
 // The 2nd UID that defines a resource file as being an application registration resource file.
 const TUid KUidAppRegistrationFile = {0x101F8021};
 /**
 @internalTechnology
 */
 std::string KAppResourceFileExtension(".rsc");
+#ifdef __LINUX__
+std::string KLitPathForUntrustedRegistrationResourceFiles("/private/10003a3f/import/apps/");
+#else
 std::string KLitPathForUntrustedRegistrationResourceFiles("\\private\\10003a3f\\import\\apps\\");
+#endif
 //
 // CAppInfoReader
 //
 Ptr16* CAppInfoReader::IconFileName()
 {
 	Ptr16* iconFileName = iIconFileName;
 	iIconFileName = NULL; // ownership transferred to caller
+	ConvertToPlatformSpecificPath(iconFileName->GetPtr(), iconFileName->GetLength());
 	return iconFileName;
 }
 TBool CAppInfoReader::NonMbmIconFile() const
 {
 		std::string folder;
 		std::string file;
 		size_t found;
 		std::string iLocalPath(iDrivePath);
-	  	found=localizeFileName.find_last_of("/\\");
+		#ifdef __LINUX__
+	  	found=localizeFileName.find_last_of("//");
+		#else
+		found=localizeFileName.find_last_of("/\\");
+		#endif
 	  	if(found)
 	  		folder = localizeFileName.substr(0,found);
 	  	else
-	  		folder.assign("\\");
+		{
+			#ifdef __LINUX__
+			folder.assign("/");
+			#else
+			folder.assign("\\");
+			#endif
+		}
 	  	file = localizeFileName.substr(found+1);
 		file.append(".");
 		iLocalPath.append(folder);
 		std::wstring iFilePath = string2wstring(iLocalPath);
 		std::wstring iFileName = string2wstring(file);
+		#ifdef __LINUX__
+		iLocalPath.append("/");
+		#else
 		iLocalPath.append("\\");
+		#endif
 		std::list<std::wstring> locDirs;
 		GetDirContents( iFilePath, locDirs );
 	 	std::list<std::wstring>::iterator curr = locDirs.begin();
 		for( curr = locDirs.begin(); curr != locDirs.end(); ++curr )
 			if (curr->find(iFileName,0) != std::wstring::npos)
 			{
 			    std::string fName;
 				std::string sAbsolutePath;
 				sAbsolutePath.assign(iLocalPath);
-			 	fName = Ucs2ToUtf8( *curr );
+			 	fName = wstring2string( *curr );
 			   	sAbsolutePath.append(fName);
 				//cout << sAbsolutePath<<endl;
 				std::string Locale;
 	aResourceReader.ReadUint32L(); // skip over LONG reserved_long
 	aResourceReader.ReadUint32L(); // skip over LLINK reserved_llink
 	// read LTEXT app_file
 	PtrC16* appFile = aResourceReader.ReadTPtrCL();
 	if(NULL==appFile)
 	{
-		std::string errMsg= "Failed : Invalid Resource File Name. Application File Name is Mendatory.";
+		std::string errMsg= "Failed : Invalid Resource File Name. Application File Name is Mandatory.";
 		throw CResourceFileException(errMsg);
 	}
+	ConvertToPlatformSpecificPath(appFile->iPtr, appFile->iMaxLength);
 	TInt err=0;
 	// this object gets used for 2 purposes: first to check that a ParsePtrC can be created over "appFile" without it panicking, and second to construct iAppBinaryFullName
 	err = FindWild(appFile); // do this before creating a TParsePtrC, since TParsePtrC's constructor panics if it fails (which would provide an easy way for malware to kill the Apparc server)
 		return NULL;
 	filename = new Ptr16(aIconFileName->iMaxLength);
 	if(NULL==filename || NULL == filename->GetPtr())
 	{
+		parsePtr.SetToNull();
 		std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";
 		throw CResourceFileException(errMsg);
 	}
 	filename->UpdateLength(aIconFileName->iMaxLength);
 	BufCpy(filename->GetPtr(),aIconFileName->iPtr,aIconFileName->iMaxLength);
 	localinfo->SetNumOfAppIcons(numOfIcons);
 	// read LTEXT icon_file
 	iIconFileName = NULL;
 	PtrC16* iconFile = resourceReader.ReadTPtrCL();
 	if(NULL != iconFile)
 	{
+		ConvertToPlatformSpecificPath(iconFile->iPtr, iconFile->iMaxLength);
 		Ptr16*	iconFileName = CreateFullIconFileNameL(iconFile);
 		if (iconFileName)
 		{
 			localinfo->SetIconFileName(iconFileName);
 				std::string file;
 				size_t found;
 				size_t find;
 				std::string iLocalPath(iDrivePath);
+				#ifdef __LINUX__
+				found=localizeFileName.find_last_of("//");
+				#else
 				found=localizeFileName.find_last_of("/\\");
+				#endif
 				if(found)
 					folder = localizeFileName.substr(0,found);
 				else
+				{
+					#ifdef __LINUX__
+					folder.assign("/");
+					#else
 					folder.assign("\\");
+					#endif
+				}
 				file = localizeFileName.substr(found+1);
 				file.append(".");
 				iLocalPath.append(folder);
 				std::wstring iFilePath = string2wstring(iLocalPath);
 				std::wstring iFileName = string2wstring(file);
+				#ifdef __LINUX__
+				iLocalPath.append("/");
+				#else
 				iLocalPath.append("\\");
+				#endif
 				std::list<std::wstring> locDirs;
 				GetDirContents( iFilePath, locDirs );
 				std::list<std::wstring>::iterator curr = locDirs.begin();
 					{
 						std::string fName;
 						std::string sAbsolutePath;
 						std::string Locale;
 						sAbsolutePath.assign(iLocalPath);
-						fName = Ucs2ToUtf8( *curr );
+						fName = wstring2string( *curr );
 						find=fName.rfind("backup");
 						if(find != string::npos)
 							continue;
 TInt CAppInfoReader::ReadNonLocalisableInfoL(RResourceReader& aResourceReader, TUint& aLocalisableResourceId)
 {
 	// read LTEXT localisable_resource_file
 	PtrC16*	localisableResourceFileName = aResourceReader.ReadTPtrCL();
 	if(NULL == localisableResourceFileName)
 	{
 		iLocalisableResourceFileName = NULL;
 	}
 	else
 	{
+		ConvertToPlatformSpecificPath(localisableResourceFileName->iPtr, localisableResourceFileName->iMaxLength);
 		if (localisableResourceFileName->iMaxLength > 0 )
 		{
 			ParsePtrC parsePtr(localisableResourceFileName);
 			if(parsePtr.IsValidName())
 			{
 				iLocalisableResourceFileName = NULL;
+				parsePtr.SetToNull();	//To Avoid double Delete in destructor.
 				std::string errMsg= "Failed : Invalid localisable Resource File Name";
 				throw CResourceFileException(errMsg);
 			}
 			std::string registrationFileDrive;
 			if( index != string::npos )
 				registrationFileDrive.assign(iRegistrationFileName, index-1, 2);
 			TInt err=0;
 			std::string sTemp = parsePtr.StrName();
 			err = FindWild(registrationFileDrive, KAppResourceFileExtension, sTemp);
 			if(err==1)
 			{
 				std::string errMsg= "Failed : Invalid drive for Registration File";
+				parsePtr.SetToNull();	//To Avoid double Delete in destructor.
 				throw CResourceFileException(errMsg);
 			}
 			iLocalisableResourceFileName = new Ptr16(parsePtr.FullName()->iMaxLength);
 			if(NULL==iLocalisableResourceFileName || NULL==iLocalisableResourceFileName->GetPtr())
 			{
 				std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";
+				parsePtr.SetToNull();	//To Avoid double Delete in destructor.
 				throw CResourceFileException(errMsg);
 			}
 			iLocalisableResourceFileName->UpdateLength(parsePtr.FullName()->iMaxLength);
 			BufCpy(iLocalisableResourceFileName->GetPtr(),parsePtr.FullName()->iPtr,parsePtr.FullName()->iMaxLength);
 	iCapability.iEmbeddability = static_cast<TAppCapability::TEmbeddability>(aResourceReader.ReadInt8L());
 	iCapability.iSupportsNewFile = aResourceReader.ReadInt8L();
 	iCapability.iLaunchInBackground = aResourceReader.ReadInt8L();
 	PtrC16* iTemp = aResourceReader.ReadTPtrCL();
 	if(NULL==iTemp || NULL==iTemp->iPtr)
 		iCapability.iGroupName = NULL;
 	else
 	{
 		iCapability.iGroupName = new Ptr16(iTemp->iMaxLength);
 		}
 	}
 	for (TInt i=0; i < fileOwnershipArraySize; i++)
 	{
 		PtrC16* fileNamePtr_temp = aResourceReader.ReadTPtrCL();
 		if(NULL != fileNamePtr_temp)
 		{
+			ConvertToPlatformSpecificPath(fileNamePtr_temp->iPtr, fileNamePtr_temp->iMaxLength);
 			Ptr16* fileNamePtr = new Ptr16(fileNamePtr_temp->iMaxLength);
 			if(NULL==fileNamePtr || NULL==fileNamePtr->GetPtr())
 			{
 				std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";
 				throw CResourceFileException(errMsg);
 			}
 			fileNamePtr->UpdateLength(fileNamePtr_temp->iMaxLength);
 			BufCpy(fileNamePtr->GetPtr(),fileNamePtr_temp->iPtr,fileNamePtr_temp->iMaxLength);
 			iOwnedFileArray->push_back(fileNamePtr);
 		}
 		else
 		{
 			Ptr16* fileNamePtr = NULL;
 }
 }
 	    }
 		PtrC8* dataTypePtr  = aResourceReader.ReadTPtrC8L();
 		if(NULL != dataTypePtr)
 		{
 			TDataType* dataType = new TDataType(dataTypePtr);
 			if(NULL==dataType)
 			{

changeset 60	245df5276b97
parent 33	8110bf1194d1
child 75	2d2d25361590