/*
* Copyright (c) 2005-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:  Implementation of CMmapMemoryNode
*
*/



//  INCLUDES
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/errno.h>
#include <fcntl.h>
#include <liblogger.h>
#include "mmapmemorynode.h"
#include "sysreent.h"



// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CMmapMemoryNode::CMmapMemoryNode
// C++ default constructor.
// -----------------------------------------------------------------------------
// 
CMmapMemoryNode::CMmapMemoryNode() 		
	{   
	iMapMem.fd = -1;
	iMapMem.offset = 0;
    iMapMem.len = 0;
    iMapMem.flags = 0;
    iMapMem.memid = 0;
    iMapMem.addr = (NULL); 
    iMapMem.fdescaddr = (NULL) ; 
    iMapMem.maplen = 0; 
    }
    
// -----------------------------------------------------------------------------
// CMmapMemoryNode::~CMmapMemoryNode
// C++ default destructor.
// -----------------------------------------------------------------------------
// 
CMmapMemoryNode::~CMmapMemoryNode()
	{
    shmid_ds buf = 
    	{
    	{ 0,0,0,0,0,0,0	},
    	0,0,0,0,0,0,0,0	
    	};
    // call shmdt and shmctl  
	int aErrno = 0;
	if(!_shmdt_r(&aErrno, iMapMem.addr))
		{
		if(!_shmctl_r(&aErrno,iMapMem.memid, IPC_RMID, &buf))
			{
			/*done*/
			}
		}
	}
    
// -----------------------------------------------------------------------------
// CMmapMemoryNode::NewL
// 1st phase Constructor
// -----------------------------------------------------------------------------
// 
CMmapMemoryNode* CMmapMemoryNode::NewL(size_t len, int flag, int shmflg, \
									   int fildes, off_t offset, int& anErrno, size_t maplen)
	{
    CMmapMemoryNode* self = new (ELeave) CMmapMemoryNode;
    CleanupStack::PushL(self);
    if(-1 == self->ConstructL(len, flag, shmflg, fildes, offset, anErrno, maplen))
    	{
    	CleanupStack::Pop(self);
    	self->iMapMem.addr = ((void *)-1);
    	return self;
    	}
    CleanupStack::Pop(self);      
    return self;
	}
    
// -----------------------------------------------------------------------------
// CMmapMemoryNode::NewL
// 2nd phase constructor
// -----------------------------------------------------------------------------
// 
int CMmapMemoryNode::ConstructL(size_t len, int flag, int shmflg, int fildes, \
								 off_t offset, int& anErrno, size_t maplen)
{	
	int lshmid;	
	void* lmapaddr;	
	int readlen;
	int retval = -1;
	off_t cache;
	
    TInt aErrno = 0;
    /* Using shared memory to allocate memory for required length */
	if((lshmid = _shmget_r(&aErrno,IPC_PRIVATE, len, shmflg)) > 0)	
		{	
		lmapaddr = _shmat_r(&aErrno,lshmid, (void*)NULL, shmflg);
		if((KErrNone == aErrno) && (-1 != (int)lmapaddr))
			{
			/*cache the current file position before seeking to new position*/
			cache = _lseek_r(&aErrno, fildes, 0, SEEK_CUR);
			/*Seek in the file to required offset */
			if(offset == _lseek_r(&aErrno,fildes, offset, SEEK_SET))
				{
				//Zero fill the memory
				memset(lmapaddr, 0, len);
				/*Read the contents of the file to memory */
			readlen = _read_r(&aErrno,fildes, (char*)lmapaddr, maplen);
				//TODO: To take care if EOF is hit while reading, i.e readlen == 0
				if(readlen <= len)
					{
					iMapMem.fd = fildes;
					iMapMem.offset = offset;
					iMapMem.len = len;
					iMapMem.flags = flag;
					iMapMem.memid = lshmid;
					iMapMem.addr = lmapaddr;
					iMapMem.maplen = maplen;
					retval = 0;
					}
				else if(-1 == readlen)
					{
					anErrno = ENXIO;
					retval = -1;
					}
				/*Now seek back to the original position*/
				_lseek_r(&aErrno, fildes, cache, SEEK_SET);
				}
			else
				{
				anErrno = ENXIO;
				retval = -1;
				}
			}
		else
			{
			anErrno = EMFILE;
			retval = -1;
			}		
		if(-1 == retval)
  			{
			/*Remove the newly created shared memory*/
			Backend()->iIpcS.shmctl(lshmid, IPC_RMID, NULL,aErrno);
			}
		}
	else
		{
		anErrno = EMFILE;
		retval = -1;
		}            
		                
    return retval;            
	}

#ifdef __SYMBIAN_COMPILE_UNUSED__
// -----------------------------------------------------------------------------
// CMmapMemoryNode::MapLength
// Observer for length
// -----------------------------------------------------------------------------
// 
size_t CMmapMemoryNode::MapLength()
	{
    return iMapMem.len;
	}
    
// -----------------------------------------------------------------------------
// CMmapMemoryNode::MapFileOffset
// Observer for file offset
// -----------------------------------------------------------------------------
// 
off_t CMmapMemoryNode::MapFileOffset()
	{
    return iMapMem.offset;
	}
#endif    
    
// -----------------------------------------------------------------------------
// CMmapMemoryNode::LinkOffset
// Determine message data member link offset for single queue
// -----------------------------------------------------------------------------
// 
TInt CMmapMemoryNode::LinkOffset()
	{
    return _FOFF(CMmapMemoryNode, iLink);
	}

// -----------------------------------------------------------------------------
// CMmapMemoryNode::MappedAddress
// return pointer to mapped memory.
// -----------------------------------------------------------------------------
// 
TAny* CMmapMemoryNode::MappedAddress()
	{
    return iMapMem.addr;
	}

// -----------------------------------------------------------------------------
// CMmapMemoryNode::GetMemInfo
// return mapped memory info i.e struct MappedMemory.
// -----------------------------------------------------------------------------
// 
struct MappedMemory CMmapMemoryNode::GetMemInfo()
	{
    return iMapMem;
	}

// -----------------------------------------------------------------------------
// CMmapMemoryNode::SetFdescAddress
// store fdescbase address.
// -----------------------------------------------------------------------------
// 
void CMmapMemoryNode::SetFdescAddress(void* aAddr)
	{
    iMapMem.fdescaddr = aAddr;
	}

// -----------------------------------------------------------------------------
// CMmapMemoryNode::SyncMemory
// Sync the mapped memory into the underlying file.
// -----------------------------------------------------------------------------
//

int CMmapMemoryNode::SyncMemory(int len, int syncflag, int& anErrno)
	{
	int retval = -1;
	int flags;
	off_t cache;
	int aErrno = 0;
	long anArg = 0L;
    flags = _fcntl_r(&aErrno, iMapMem.fd, F_GETFL, anArg);   
    if(MS_INVALIDATE == syncflag)
    	{
    	/* Make sure the file is open atleast in read-only mode */
    	if(-1 != flags && (O_RDWR == (flags & O_ACCMODE) || O_RDONLY == (flags & O_ACCMODE)))
    		{
    		/*cache the current location before we seek to a new position*/
    		cache = _lseek_r(&aErrno, iMapMem.fd, 0, SEEK_CUR);
    		if(iMapMem.offset == _lseek_r(&aErrno,iMapMem.fd, iMapMem.offset, SEEK_SET))
				{
				int readlen = _read_r(&aErrno,iMapMem.fd, (char*)iMapMem.addr, len);
				if(-1 == readlen)
					{
					anErrno = aErrno;
					}
				else if(len >= readlen)
					{
					retval = 0;
					}			
				/*Now seek back to the original position*/
				_lseek_r(&aErrno, iMapMem.fd, cache, SEEK_SET);
				}
			else
				{
				anErrno = ENOMEM;
				}
    		
    		}
    	}
	else if(-1 != flags && (O_RDWR == (flags & O_ACCMODE) || O_WRONLY == (flags & O_ACCMODE)))
		{
		/*cache the current location before we seek to a new position*/
    	cache = _lseek_r(&aErrno, iMapMem.fd, 0, SEEK_CUR);
    		if(iMapMem.offset == _lseek_r(&aErrno,iMapMem.fd, iMapMem.offset, SEEK_SET))	
			{
			//sync/async capability, both are treated the same way
			if((MS_ASYNC == syncflag) || (MS_SYNC == syncflag))
				{							
				int writelen = _write_r(&aErrno,iMapMem.fd, (char*)iMapMem.addr, len);
				if(-1 == writelen)
					{
					anErrno = aErrno;
					}
				else if(len >= writelen)
					{
					retval = 0;
					}
				}
			else
				{
				anErrno = EINVAL;
				}
			/*Now seek back to the original position*/
			_lseek_r(&aErrno, iMapMem.fd, cache, SEEK_SET);
			}
		else
			{
			anErrno = ENOMEM;
			}
		}
	else
		{
		anErrno = ENOMEM;
		}
            
	return retval;            
	}
    
// End of File