// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // Initialise / Persist HAL Implementation of HALSettings

 // 

 //

 /**

  @file

  @internalComponent

 */

 #include "halfiles.h"

 #include "halpatchdata.h"

 #include "haldebug.h"

 /**

 Constructor of THalFileHeader class

 @param aMachineUid Machine Uid

 @param aTypePrefix header 'h' 'a' 'l' and version no.

 */

 THalFileHeader::THalFileHeader(TUint32 aMachineUid, TUint32 aTypePrefix)

 : iMachineUid (aMachineUid), iTypePrefix(aTypePrefix){}

 /**

 Validate header of the hal.dat file.

 @return KErrNone if successful otherwise KErrCorrupt.

 */

 TInt THalFileHeader::ValidateHeader() 

 	{

 	TInt result;

 	TInt machineUID;

 	result = HAL::Get(HAL::EMachineUid,machineUID);	

 	if (result != KErrNone)

 		return result;	

 	if(iTypePrefix != typePrefix && machineUID != iMachineUid)

 		return KErrCorrupt;

 	return result;

 	}

 /**

 Get the path (drive & folder path) of the HAL data file.

 @param aPathName On completion this will contain the result.

 */	

 static void GetSystemDrivePath(THalFileName& aPathName)

 	{

 	aPathName.Copy(KHalFilePath);

 	aPathName[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());

 	}

 /**

 Initialise the HAL.

 Read the saved HAL file - containing a series of saved HAL attributes. If present, initialise

 each attribute saved.

 @return KErrNone if successful, otherwise any system wide error code.

 */

 TInt InitialiseHAL()

 	{

     __HS_TRACE("HalSettings: InitialiseHAL");

 	//File server to open the HAL.DAT file

 	RFs fs;

 	TInt result = fs.Connect(); 

 	if (result != KErrNone)

 		{

 		return result;

 		}

 	//Get the system drive path

 	THalFileName halFileName;

 	GetSystemDrivePath(halFileName);

 	halFileName.Append(KHalFileName);

 	//Open the hal.dat file with EFileShare Exclusive mode to read HAL attributes

 	RFile file;

 	result = file.Open(fs,halFileName,EFileRead | EFileShareExclusive);

 	if (result != KErrNone)

 		{

 		fs.Close();

 		return result;		

 		}

 	//Checking the file integrity (total size should always be multiples of 8) 	

 	TInt size=0;

 	result = file.Size(size);

 	if (result != KErrNone || size <= sizeof(THalFileHeader) || (size&7) != 0)

 		{

 		file.Close();

 		fs.Close();

 		return KErrCorrupt;	

 		}

 	//Check to see that the filesize of HAL.DAT is not greater than if it contained entries for the max number of attributes

 	TInt maxDevices = 1;

 	HAL::Get(HALData::EDisplayNumberOfScreens,maxDevices);

 	TInt maxSize = (maxDevices * (TInt)HALData::ENumHalAttributes * (sizeof(HALData::TAttribute) + sizeof(TInt)) + sizeof(THalFileHeader));

 	if (size > maxSize)

 		//devices * number of attributes * (attribute + value) + header

 		{

 		file.Close();

 		fs.Close();

 		return KErrCorrupt;

 		}

 	//Allocate a buffer to read all HAL.DAT file

 	TInt* pBuf=(TInt*)User::Alloc(size);

 	if (!pBuf)

 		{

 		file.Close();

 		fs.Close();

 		return  KErrNoMemory;		

 		}

 	TPtr8 bptr((TUint8*)pBuf,size);

 	//Read HAL.DAT to the allocated buffer	

 	result = file.Read(bptr);

 	if ( result == KErrNone)

 		{

 		const TInt* pD = pBuf;

 		const TInt* pE = pD + size/sizeof(TInt);

 		THalFileHeader header (*pD, *(pD+1));

 		pD += 2; //first 8 bytes are header  

 		//Checking the validity of the file header and if valid set all HAL attributes

 		if ((result = header.ValidateHeader()) == KErrNone)

 			{

 			while (pD < pE)

 				{

 				TInt attrib = *pD++;

 				//the top 8 bits contain the device number

 				HAL::Set(((TUint)attrib)>>24, (HAL::TAttribute)(attrib & 0xFFFFFF), *pD++);

 				}

 			}

 		}

 	User::Free(pBuf);

 	file.Close();

 	fs.Close();

 	return(result);	

 	}

 /**

 Persist the HAL.

 Gets all HAL attributes, and their properties 

 then save attributes (which are meaningful and modifiable on this device) to hal.dat

 @return KErrNone if successful, otherwise any system wide error code.

 */

 TInt PersistHAL()

 	{

     __HS_TRACE("HalSettings: PersistHAL");

 	const TInt KHalProperties=HAL::EEntryDynamic|HAL::EEntryValid;

 	//Get all HAL attributes

 	HAL::SEntry* pE;

 	TInt nEntries;

 	TInt result = HAL::GetAll(nEntries, pE);

 	if ( result != KErrNone )

 		{

 		return result;

 		}

 	const HAL::SEntry* pS=pE;

 	const HAL::SEntry* pEnd=pS + nEntries;

 	TInt* pD = (TInt*)pE;

     __HS_TRACE1("HalSettings: ENumHalAttributes == %d", HALData::ENumHalAttributes );

     __HS_TRACE1("HalSettings: KHalPenStatePersistenceDisabled == %d", KHalPenStatePersistenceDisabled );

 	for (TInt s = 0; pS<pEnd; ++pS, ++s)

 		{

 		__HS_TRACE3("HalSettings: Attr: %d; Prop: %x; Value: %x", s, pS->iProperties, pS->iValue );

 		if ((s%HAL::ENumHalAttributes) == HALData::EDisplayMemoryHandle)

 		    {		    

 		    if( pS->iValue >= KErrNone )

 		        {

 		        RHandleBase handle;

 		        handle.SetHandle(pS->iValue);

 		        handle.Close();

 				// We will not persisit the closed handle

 				continue;

 		        }

 		    }

 		// HAL::GetAll() will return all HAL attributes 

 		// But only need to save the attribute value which are valid and dynamic

 		if ((pS->iProperties & KHalProperties) != KHalProperties)

 			continue;

 		// Do NOT save the EDisplayState as this could be off when system 

 		// shutdown and then when system startup occurs the display will never 

 		// be turned on

 		if ((s%HAL::ENumHalAttributes) == HALData::EDisplayState)

             continue;

 		// Do NOT save the EPenState as if this is 0 on save it could disable 

 		// the touch screen on a reboot of the device on some platforms.

 		if ((KHalPenStatePersistenceDisabled==1) && 

 			(s%HAL::ENumHalAttributes) == HALData::EPenState )

             continue;

 		// At this point we know this atribute must be saved to persitent store

 		__HS_TRACE1("HalSettings: Attribute %d saved", s%HAL::ENumHalAttributes);

 		TInt v=pS->iValue;		

 		if((KHalNonSecureOffsetPersistenceDisabled == 1) &&

 		   (s%HAL::ENumHalAttributes) == HALData::ETimeNonSecureOffset)

 		   {

 		   // If product so wants, save the nonsecure offset always as zero (so during boot user time == secure time)

 		   v = 0;

 		   }

 		//top 8 bits are used to store device number next 3 is for the Hal attributes ENum value

 		*pD++=((s/HAL::ENumHalAttributes)<<24) + (s%HAL::ENumHalAttributes);

 		*pD++=v;

 		}

 	TUint nSaved=(pD-(TInt*)pE)>>1;

 	RFs fs;

 	//coverity[cleanup_stack]

 	/* pE is just a local pointer here and goes out of scope after the execution of the function

 	* This error is possibly thrown due to pE not made NULL in GetAll( ) but ,it should not be an issue here

 	* as Connect() is not a leaving function

 	*/

 	result=fs.Connect(); //

 	if ( result != KErrNone )

 		{

 		User::Free(pE);

 		return result;	

 		}

 	THalFileName halFile;

 	GetSystemDrivePath(halFile);

 	// Ensure directory \private\SID exists in target drive

 	result = fs.MkDirAll(halFile);

 	if (result != KErrNone )

 		if(result != KErrAlreadyExists )

 			{

 			//coverity[cleanup_stack]

 			// Close() is not a leaving function

 			fs.Close();

 			User::Free(pE);

 			return 	result;

 			}

 	TInt muid=0;

 	// Gets the machine's unique ID

 	result=HAL::Get(HAL::EMachineUid, muid);

 	if ( result != KErrNone )

 		{

 		//coverity[cleanup_stack]

 		// Close() is not a leaving function

 		fs.Close();

 		User::Free(pE);

 		return 	result;	

 		}

 	//Allocating a buffer with size of header and data (HAL attributes)	

 	RBuf8 buf;

 	result = buf.ReAlloc(sizeof(THalFileHeader) + (nSaved*8));

 	if(result != KErrNone)

 		{

 		//coverity[cleanup_stack]

 		// Close() is not a leaving function

 		fs.Close();

 		User::Free(pE);

 		return 	result;		

 		}

 	//Appending header and hal attributes to the allocated buffer		

 	THalFileHeader header (muid,typePrefix);

 	buf.Append((const TUint8*)&header,sizeof(THalFileHeader));

 	buf.Append((const TUint8*)pE, nSaved*8);

 	User::Free(pE);

 	//Saving HAL setting to a temp file after that rename it to HAL.DAT

 	RFile file;

 	TFileName  tempFile;

 	result = file.Temp(fs,halFile,tempFile,EFileWrite|EFileShareExclusive);

 	if ( result == KErrNone )

 		{

 		result = file.Write(buf);

 		if ( result == KErrNone )

 			{

 			halFile.Append(KHalFileName); 

 			fs.Delete(halFile); // ignore if error 

 			result = file.Rename(halFile);

 			}

 		file.Close();	

 		}	

 	buf.Close();

 	fs.Close();

 	return result;

 	}

 /**

 HAL Settings Manager.

 Manages the request for initialise and persist hal settings through command line

 For initialise it checks SID of the process send the request and command line parameter.

 If the SID = SID of EStart and command line is "INITIALISE" it initialise hal settings.

 For persistence it only checks the command line = "PERSIST"

 @return KErrNone if successful, otherwise any system wide error code.

 */

 TInt HALSettingsManager()

 	{

 	const TInt KMaxArgumentLength = 10;

 	const TInt KEStartSID = 0x10272C04; //SID of EStart

 	_LIT(KHalInitialise,"INITIALISE");

 	_LIT(KHalPersist,"PERSIST");

 	if (User::CommandLineLength() >  KMaxArgumentLength)

 		return KErrArgument;

 	TBuf<KMaxArgumentLength> args;

 	User::CommandLine(args);

 	TInt result;

 	//Initialise or Persist HAL depending on command line arguments

 	if (args.CompareF(KHalInitialise) == 0)

 		{

 		if(User::CreatorSecureId() != KEStartSID)

 				return KErrPermissionDenied;	

 		result = InitialiseHAL();	

 		}

 	else if (args.CompareF(KHalPersist) == 0)

 		{

 		result = PersistHAL();

 		}

 	else

 		{

 		return KErrArgument;

 		}

 	return result;

 	}