// Copyright (c) 2006-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:

 // Name        : ewsd.cpp

 // Part of     : ewsd library

 // Contains the definitions of the APIs of the emulator WSD library 

 //

 #ifdef __WINSCW__

 #include <e32std.h>

 #include <windows.h>

 // Constant declarations

 const TInt KMaxNumberOfProcesses = 100;

 const TInt KMaxNumberOfLibraries = 50;

 // Panic strings

 _LIT(KMutexGetFailure, "WSD mutex get failed");

 _LIT(KMutexReleaseFailure, "WSD mutex release failed");

 // Mutex name

 unsigned short KMutexName[] = 

 	{

 		'E', 'W', 'S', 'D', 'M', 'u', 't', 'e', 'x'

 	};

 // LOCAL STRUCTURE DECLARATIONS

 // Data structure to store the WSD info associated with a particular DLL

 struct TDllData

 	{

 	TUid  iLibraryUid;

 	TAny* iPtr;

 	};

 // Data structure to store the DLL information associated with a process

 struct TWsdNode

 	{

 	TProcessId  iPid;

 	TInt  		iFirstUnusedSlot;

 	struct TDllData iDllData[KMaxNumberOfLibraries];

 	};

 // WSD array variables

 struct TWsdNode WsdArray[KMaxNumberOfProcesses];

 TInt LastUsedProcessSlot = -1;

 // LOCAL FUNCTION DECLARATIONS

 LOCAL_C TInt CleanupDeadProcessSlots();

 LOCAL_C void StorePls(const TInt& aProcessSlot, const TInt& aLibrarySlot, TAny* aPls, const TUid& aLibraryUid);  

 // EXPORTED FUNCTION DEFINITIONS

 EXPORT_C TAny* CheckPls(const TUid& aLibraryUid)

 	{

 	TProcessId procId = RProcess().Id();

 	for (TInt i = 0; i <= LastUsedProcessSlot; ++i)

 		{

 		if (WsdArray[i].iPid == procId)

 			{

 			// This process has a slot in the WsdArray - now check

 			// whether its DLL array contains the specified library

 			TInt firstUnused = WsdArray[i].iFirstUnusedSlot;

 			for (TInt j = 0; j < firstUnused; ++j)	

 				{

 				if (aLibraryUid == WsdArray[i].iDllData[j].iLibraryUid)

 					{

 					// The specified library is present so return the PLS object

 					return WsdArray[i].iDllData[j].iPtr;

 					}

 				}

 			break;

 			}

 		}

 	// The PLS object hasn't yet been stored	

 	return NULL;

 	}

 EXPORT_C TInt SetPls(TAny* aPls, const TUid& aLibraryUid)   		 

 	{

 	TProcessId procId = RProcess().Id();

 	TInt slot = -1;

 	if (LastUsedProcessSlot >= 0)

 		{		

 		for (TInt i = 0; i <= LastUsedProcessSlot; ++i)

 			{

 			if (!WsdArray[i].iPid.Id())

 				{

 				if (slot == -1)

 					{

 					 slot = i;

 					}

 				continue;

 				}

 			else if (WsdArray[i].iPid == procId)	

 				{

 					// We are about to set the Pls of a new library for this process

 					TInt firstUnused = WsdArray[i].iFirstUnusedSlot;

 					if (KMaxNumberOfLibraries == firstUnused)

 						{

 						// The library array is full for this process

 						return KErrNoMemory;

 						}

 					else

 						{

 						// Store the PLS for the specified library

 						StorePls(i, firstUnused, aPls, aLibraryUid);

 						return KErrNone;

 						}

 				}

 			}

 		// The remainder of WsdArray is not used, so the process is

 		// not in it. If an empty slot hasn't yet been found then...			

 		if (slot == -1)

 			{

 			// ...  use the next unused slot in the array, if there is one

 			if (LastUsedProcessSlot < (KMaxNumberOfProcesses - 1))

 				{

 				slot = LastUsedProcessSlot + 1;

 				}

 			else

 				{

 				// ... the array is full (there are no empty slots). 

 				// Perform a clean up of the array to free any process slots that

 				// belong to dead processes to see if there is a slot that we can reuse

 				TInt slotToReuse = CleanupDeadProcessSlots();

 				if (slotToReuse == -1)

 					{

 					// There are no reusable slots in the process array

 					return KErrNoMemory;

 					}

 				slot = slotToReuse;

 				}

 			}

 		}

 	else

 		{

 		slot = 0;

 		}

 	// Store the PLS for the specified library	

 	StorePls(slot, 0, aPls, aLibraryUid);

 	// Store the process details too as this process is new to WsdArray

 	WsdArray[slot].iPid = procId;

 	// Update the LastUsedProcessSlot if necessary		    

 	if (slot > LastUsedProcessSlot)

 		{

 		 LastUsedProcessSlot = slot;

 		}

 	return KErrNone;

 	}

 EXPORT_C TAny* AllocatePls(const TInt& aSize)

 	{

 	return VirtualAlloc(NULL, 

 						aSize,

 						MEM_COMMIT | MEM_RESERVE,

 						PAGE_READWRITE);

 	}

 EXPORT_C TInt FreePls(TAny* aPls)

 	{

 	if (!VirtualFree(aPls, 0, MEM_RELEASE))

 		{

 		return KErrAccessDenied;

 		}

 	aPls = NULL;

 	return KErrNone;

 	}

 EXPORT_C TAny* ObtainPlsMutex()

 	{

 	// Get a handle to the mutex (the mutex will be created 

 	// if it doesn't already exist) and then wait to acquire 

 	// ownership of the mutex

 	HANDLE mutexHandle = CreateMutex(NULL, FALSE, KMutexName);

 	if ((!mutexHandle) || (WaitForSingleObject(mutexHandle, INFINITE) == WAIT_FAILED)) 

 		{

 		User::Panic(KMutexGetFailure, KErrAccessDenied);

 		}

 	return mutexHandle;

 	}

 EXPORT_C void ReleasePlsMutex(TAny* aMutexHandle)

 	{

 	if (!ReleaseMutex(aMutexHandle))

 		{

 		 User::Panic(KMutexReleaseFailure, KErrAccessDenied);

 		}

 	}

 // LOCAL FUNCTIONS DEFINITIONS

 /**  

 Iterates through the WSD array and frees each slot that belongs to a dead process

 (the stored data is reset and all associated PLS memory is freed).

 Returns the index of the first freed slot if at least one slot was freed,

 otherwise -1

 */

 LOCAL_C TInt CleanupDeadProcessSlots()

 	{

 	TInt firstReusableSlot = -1;

 	TUid nullUid = TUid::Null();

 	LastUsedProcessSlot = -1;

 	RProcess proc;

 	for (TInt i = 0; i < KMaxNumberOfProcesses; ++i)

 		{

 		if(proc.Open(WsdArray[i].iPid) == KErrNone)

 			{

 			if(proc.ExitType()==EExitPending)

 				{

 				LastUsedProcessSlot = i;

 				proc.Close();

 				continue;	

 				}

 			else

 				proc.Close();

 			}

 		// Process with the given name does not exist in

 		// the system, so the slot could be reused

 		WsdArray[i].iPid = 0;

 		// Free all of the PLS memory associated with this process

 		TInt firstUnused = WsdArray[i].iFirstUnusedSlot;

 		WsdArray[i].iFirstUnusedSlot = 0;

 		for (TInt j = 0; j < firstUnused; ++j)

 			{

 			FreePls(WsdArray[i].iDllData[j].iPtr);

 			WsdArray[i].iDllData[j].iLibraryUid = nullUid;

 			}

 		if (firstReusableSlot == -1)

 			{

 			// Set the slot to reuse

 			firstReusableSlot = i;

 			}

 		}

 	return firstReusableSlot;

 }	

 /**  

 Stores the specified PLS object and library TUid at the specified location in the WSD array.

 Takes as parameters the process slot to use in the WSD array, the slot to use in the library 

 array associated with the given process, the PLS object to be stored and the TUid of the 

 library DLL that the PLS object belongs to

 */

 LOCAL_C void StorePls(const TInt& aProcessSlot, const TInt& aLibrarySlot, TAny* aPls, const TUid& aLibraryUid)

 	{

 	 WsdArray[aProcessSlot].iDllData[aLibrarySlot].iPtr = aPls;

 	 WsdArray[aProcessSlot].iDllData[aLibrarySlot].iLibraryUid = aLibraryUid;

 	 ++WsdArray[aProcessSlot].iFirstUnusedSlot;	

 	}

 #endif // __WINSCW__