sl@0: /*
sl@0: Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
sl@0: 
sl@0: Redistribution and use in source and binary forms, with or without 
sl@0: modification, are permitted provided that the following conditions are met:
sl@0: 
sl@0: * Redistributions of source code must retain the above copyright notice, this 
sl@0:   list of conditions and the following disclaimer.
sl@0: * Redistributions in binary form must reproduce the above copyright notice, 
sl@0:   this list of conditions and the following disclaimer in the documentation 
sl@0:   and/or other materials provided with the distribution.
sl@0: * Neither the name of Nokia Corporation nor the names of its contributors 
sl@0:   may be used to endorse or promote products derived from this software 
sl@0:   without specific prior written permission.
sl@0: 
sl@0: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
sl@0: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
sl@0: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
sl@0: DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
sl@0: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
sl@0: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
sl@0: SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
sl@0: CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
sl@0: OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
sl@0: OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
sl@0: 
sl@0: Description:  Contains the WSD solution
sl@0: */
sl@0: 
sl@0: 
sl@0: // INCLUDE FILES
sl@0: #ifndef EMULATOR
sl@0: #define EMULATOR (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__)))
sl@0: #endif
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include <stddef.h>
sl@0: #include <windows.h>
sl@0: 
sl@0: //definition of all WSD related funcitons 
sl@0: 
sl@0: #define MAX_NUMBER_OF_PROCESSES	100
sl@0: 
sl@0: struct TWsdArray
sl@0: {
sl@0: 	TUint 		iPid;
sl@0: 	TFullName 	iFullName;
sl@0: 	void* 		iPtr;
sl@0: };
sl@0: 
sl@0: #pragma data_seg(".wsd")
sl@0: TInt NumOfProcesses = 0;
sl@0: TInt MutexInitialized = 0;
sl@0: #pragma data_seg()
sl@0: 
sl@0: #pragma bss_seg(".wsd")
sl@0: struct TWsdArray wsdArray[MAX_NUMBER_OF_PROCESSES];
sl@0: #pragma bss_seg()
sl@0: 
sl@0: // This function frees up the used slots within the wsdArray
sl@0: // for use by other processes; internal to the implementation
sl@0: // that provides WSD support
sl@0: LOCAL_C TInt FindSlot();
sl@0: 
sl@0: void *Pls()
sl@0: {
sl@0: 	HANDLE mutexHandle = NULL;
sl@0: 	LPCTSTR p = (unsigned short *)"libcrypto_mutex";
sl@0: 	
sl@0: 	if(!MutexInitialized)
sl@0: 	{
sl@0: 		// Keep an unused handle to the mutex object to prevent
sl@0: 		// handle exhaustion
sl@0: 		CreateMutex(NULL, FALSE, p);
sl@0: 		MutexInitialized = 1;
sl@0: 	}
sl@0: 	
sl@0: 	if(mutexHandle = CreateMutex(NULL, FALSE, p))
sl@0:     {
sl@0: 	    DWORD dwWaitResult = WaitForSingleObject(mutexHandle, INFINITE);
sl@0: 	    switch (dwWaitResult) 
sl@0: 		{
sl@0: 		    // Cannot get mutex ownership due to time-out.
sl@0: 		    case WAIT_TIMEOUT: 
sl@0: 		        return NULL;
sl@0: 		
sl@0: 		    // Got ownership of the abandoned mutex object.
sl@0: 		    case WAIT_ABANDONED: 
sl@0: 		         return NULL; 
sl@0:    	    }
sl@0: 
sl@0: 		if(dwWaitResult == WAIT_OBJECT_0)
sl@0: 		{
sl@0: 			// Thread got the mutex ownership
sl@0: 			TProcessId procId = RProcess().Id();
sl@0: 			TFullName fullName = RProcess().FullName();
sl@0: 			TInt pid = *(TUint *)&procId;
sl@0: 			TInt slot = -1;
sl@0: 
sl@0: 			for(int i=0 ; i < MAX_NUMBER_OF_PROCESSES ; ++i )
sl@0: 			{
sl@0: 				if(!wsdArray[i].iPid)
sl@0: 				{
sl@0: 					if(slot == -1)
sl@0: 						slot = i;
sl@0: 					
sl@0: 					continue;
sl@0: 				}
sl@0: 				else if(wsdArray[i].iPid == pid)
sl@0: 				{
sl@0: 					ReleaseMutex(mutexHandle);
sl@0: 					CloseHandle(mutexHandle);
sl@0: 					return wsdArray[i].iPtr;
sl@0: 				}
sl@0: 			}
sl@0: 			
sl@0: 			// NEW PROCESS
sl@0: 			
sl@0: 			if(MAX_NUMBER_OF_PROCESSES == NumOfProcesses)
sl@0: 			{
sl@0: 				// Find out if one of the slots reserved for previous processes
sl@0: 				// could be reused.
sl@0: 				TInt returnValue = -1;
sl@0: 				returnValue = FindSlot();
sl@0: 				if(returnValue != -1)
sl@0: 				{
sl@0: 					slot = returnValue;
sl@0: 				}
sl@0: 				else
sl@0: 				{
sl@0: 					User::Panic(_L("Pls() Reached the naximum number for the processes"),KErrNoMemory);
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 			wsdArray[slot].iPid = pid;
sl@0: 			wsdArray[slot].iFullName = fullName;
sl@0: 			wsdArray[slot].iPtr = NULL;
sl@0: 			
sl@0: 			// Increment the count for the number of processes
sl@0: 			++NumOfProcesses;
sl@0: 			
sl@0: 			// Release the mutex
sl@0: 			ReleaseMutex(mutexHandle);
sl@0: 			CloseHandle(mutexHandle);
sl@0: 			return wsdArray[slot].iPtr;
sl@0: 		}
sl@0:     }
sl@0: }
sl@0: 
sl@0: LOCAL_C TInt FindSlot()
sl@0: {
sl@0: 	TInt slot = -1;
sl@0: 	TFullName fullName;
sl@0: 	TInt currentCount = 0;
sl@0: 	
sl@0: 	for(int i = 0 ; i < MAX_NUMBER_OF_PROCESSES ; ++i)
sl@0: 	{
sl@0: 		TFindProcess search(wsdArray[i].iFullName);
sl@0: 		if(search.Next(fullName) == KErrNone)
sl@0: 		{
sl@0: 			++currentCount;
sl@0: 			continue;
sl@0: 		}
sl@0: 		
sl@0: 		// Process with the given name does not exist in
sl@0: 		// the system. So the slot could be reused.
sl@0: 		wsdArray[i].iPid = 0;
sl@0: 
sl@0: 		// Free the VAS associated with this "process" (terminated)
sl@0: 		if(wsdArray[i].iPtr)
sl@0: 			{
sl@0: 			VirtualFree(wsdArray[i].iPtr, 0, MEM_RELEASE);
sl@0: 			}
sl@0: 		wsdArray[i].iPtr = NULL;
sl@0: 
sl@0: 		if(slot == -1)
sl@0: 		{
sl@0: 			// Update
sl@0: 			slot = i;
sl@0: 		}
sl@0: 	}
sl@0: 	NumOfProcesses = currentCount;
sl@0: 	return slot;
sl@0: }
sl@0: 
sl@0: TInt SetPls(void *aArg)
sl@0: {
sl@0: 	HANDLE mutexHandle = NULL;
sl@0: 
sl@0: 	LPCTSTR p = (unsigned short *)"libcrypto_mutex";
sl@0: 	
sl@0: 	if(!MutexInitialized)
sl@0: 	{
sl@0: 		// Keep an unused handle to the mutex object to prevent
sl@0: 		// handle exhaustion
sl@0: 		CreateMutex(NULL, FALSE, p);
sl@0: 		MutexInitialized = 1;
sl@0: 	}
sl@0: 	
sl@0: 	if(mutexHandle = CreateMutex(NULL, FALSE, p))
sl@0:     {
sl@0: 	    DWORD dwWaitResult = WaitForSingleObject(mutexHandle, INFINITE);
sl@0: 	    switch (dwWaitResult) 
sl@0: 		{
sl@0: 		    // Cannot get mutex ownership due to time-out.
sl@0: 		    case WAIT_TIMEOUT: 
sl@0: 		        return KErrNotFound;
sl@0: 		
sl@0: 		    // Got ownership of the abandoned mutex object.
sl@0: 		    case WAIT_ABANDONED: 
sl@0: 		         return KErrNotFound; 
sl@0:    	    }
sl@0: 
sl@0: 		if(dwWaitResult == WAIT_OBJECT_0)
sl@0: 		{
sl@0: 			// Thread got the mutex ownership
sl@0: 			TProcessId procId = RProcess().Id();
sl@0: 			TFullName fullName = RProcess().FullName();
sl@0: 			TInt pid = *(TUint *)&procId;
sl@0: 
sl@0: 			for(int i=0 ; i < MAX_NUMBER_OF_PROCESSES ; ++i )
sl@0: 			{
sl@0: 				if(wsdArray[i].iPid == pid)
sl@0: 				{
sl@0: 					wsdArray[i].iPtr = aArg;
sl@0: 					ReleaseMutex(mutexHandle);
sl@0: 					CloseHandle(mutexHandle);
sl@0: 					return KErrNone;
sl@0: 				}
sl@0: 			}
sl@0: 			
sl@0: 			ReleaseMutex(mutexHandle);
sl@0: 			CloseHandle(mutexHandle);
sl@0: 			return KErrNotFound;
sl@0: 		}
sl@0:     }
sl@0: }
sl@0: 
sl@0: void* AllocatePls(TInt aSize)
sl@0: {
sl@0: 	void *r = VirtualAlloc(NULL, 
sl@0: 						   aSize,
sl@0: 						   MEM_COMMIT | MEM_RESERVE,
sl@0: 						   PAGE_READWRITE);
sl@0: 	if(!r)
sl@0: 	{
sl@0: 		User::Panic(_L("AllocatePls() VIRTUALALLOC"),KErrNoMemory);
sl@0: 	}
sl@0: 	return r;
sl@0: }