// 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 the License "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:
//




#ifndef __DPIPE_H__
#define __DPIPE_H__

#define _TEST__

#if !defined(__KERNEL_H__)
#include <kernel/kernel.h>
#endif

#include <rpipe.h>

const TInt  KIdBase		= 0x0;

class DPipe;

class DPipeDevice : public DLogicalDevice
/**
The factory class is derived from Dlogical device. The user side calls 
User::LoadLogicalDevice() to load the LDD dll and create the LDD 
factory object in the kernel heap.
@internalTechnology
*/
{
public:
	/**
	 Set the version number
	 */
    DPipeDevice();

    ~DPipeDevice();

    // Inherited from DLogicalDevice
	/**
	 Second stage constructor and at least set a name for the 
	 driver object.
	 */
    virtual TInt Install();


    virtual void GetCaps(TDes8& aDes) const;

	/**
	 Called by the Kernel's Device driver framework to create a logical
	 Channel. This called in the context of the user thread. which requested
	 the creation of the logical channel.It checks if maximum pipe creation 
	 has reached before creating a new Kernel pipe object.
	 @param aChannel Set to point to the created logical channel

	 @return KErrNone if successful, otherwise system wide error codes.
	 */
    virtual TInt Create(DLogicalChannelBase*& aChannel);

	
	/**
	 Called by the Logical channel instance to create DPipe  and
	 associate itself.
	 */
	TInt  CreatePipe(const TDesC& aName, TInt aSize, DPipe*& aPipe, TAny* aCapCheck = NULL);

	DPipe* CreatePipe(TInt aSize);
	
	DPipe* FindNamedPipe(const TDesC* aName);

	DPipe* FindUnnamedPipe(const TInt aId);

	TInt Destroy(const TDesC* aName);

	TInt Close(TInt aId);
	
	
	inline DMutex& Mutex()
		{
		return *iMutex;
		}

	inline void Wait()
		{
		Kern::MutexWait(*iMutex);
		}
	
	inline void Signal()
		{
		Kern::MutexSignal(*iMutex);
		}
  
 private:
 	TInt GenerateId();
	
	TInt AddPipe(DPipe* aObj);
	
    void RemovePipe(DPipe** aObj);
    
    
private:
	 //! Represents the Data in a pipe.
	DPipe **iDpipes;
	
	DMutex *iMutex;	
	
	TInt iAllocated;
	
	TInt iCount;
	
    TInt iIdindex;

};



class DPipeChannel : public DLogicalChannelBase
/**
DPipe Channel provides the Kernel interface to the DPipe. The request from the RPipe handler 
in the context of user thread, is transfered to DPipeChannel class. This is the interface 
between the DPipe kernel object and the user request through RPipe handler. 

@internalTechnology
*/
	{
public:
     DPipeChannel();
     virtual ~DPipeChannel();

    // inherited from DObject 
    virtual TInt RequestUserHandle (DThread* aThread, TOwnerType aType);

    // inherited from DLogicalChannelBase
    virtual TInt DoCreate (TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
	
	
private:

    // The user request is mapped 
    TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);
    
    TInt DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1,    
    TAny* a2);

    // This function will be called under DoControl()
    TInt PipeCreate(TAny* a1,  TAny* a2);
	
    TInt PipeCreate(TInt aSize);
	
    TInt PipeOpen(const TDesC* aName, RPipe::TChannelType aType);
    
    TInt PipeOpen (const TInt aId);
    
    TInt OpenOnReader(const TDesC* aName);
    
    TInt PipeDestroy(const TDesC* aName);

    TInt Read (TAny* aBuff, TInt aSize);

    TInt Write (TAny* aBuff, TInt aSize);
    
    TInt Size();

    TInt CloseHandle();
    
    TBool CheckCap();
    
    // Registration of the Asynchronous request
    TInt NotifySpaceAvailable (TInt aSize, TRequestStatus* aStat, TBool aAllowDisconnected);

    TInt NotifyDataAvailable (TRequestStatus* aStat, TBool aAllowDisconnected);

    TInt WaitNotification (TRequestStatus* aStat, TAny* aName , TInt aChoice);

   void Flush();
	
	TBool ValidCancellation(TInt aReqType);
public:

	void CancelRequest (TInt aReqType);
	
	void DoRequestCallback();
	
private:
	/////// Accessed within pipe mutex ///////
	
	DThread *iRequestThread; ///< The thread awaiting notification.
	TClientRequest* iClientRequest;

	//Allows us to tell if a request cancellation is valid
	TInt iRequestType; ///< Access within Pipe Mutex
	
	//////////////////////////////////////////


	// Reference to  the DPipe
	DPipe* iData;
	
	//Effectively constant
	RPipe::TChannelType iChannelType;
};



class DPipe:public DBase
/**
This class represent the actual Kernel side Pipe. An instance of this class is constructed 
when ever user creates a named/un-named pipe through the methods provided by user handler RPipe. 
The owner of a DPipe instance is the DPipeDevice factory object and associates this DPipe 
instance to the appropriate DPipeChannel instance. Each DPipe object is associated with two 
DPipeChannel instances for read and writes operation

@internalTechnology
*/
{
	friend class DPipeChannel;
	friend class DPipeDevice;
public:
	
	virtual ~DPipe();

	// Creates a Named pipe
	static DPipe* CreatePipe(const TDesC& aName, TInt aSize, TAny* aPolicy = NULL);

	// check if the name referring  to a created pipe is valid.
	TBool MatchName(const TDesC* aName);

	// Check if the id referring to a created pipe is valid.
	TBool MatchId(const TInt aId);


	// Check if Buffer is Empty
	TInt IsBufferEmpty();

	// Write to Buffer
	TInt Write(TAny* aBuf, TInt aSize);

	// Read to Buffer
	TInt Read(TAny* aBuf, TInt aSize);
	
	void SetReadEnd(DPipeChannel * aChannel);
	
	void SetWriteEnd(DPipeChannel * aChannel);


	// Registering Notification from client thread
	TInt RegisterSpaceAvailableNotification(TInt aSize);
	
	TInt RegisterDataAvailableNotification();
	
	TInt RegisterWaitNotification(TInt aChoice);	

	//! Cancellation methods
	void CancelSpaceAvailable();
	
	void CancelDataAvailable();
	
	void CancelWaitNotifier();
	
	TInt CloseReadEnd();
	
	TInt CloseWriteEnd();
	
	void CloseAll();

	TBool IsNamedPipe();
	
	TBool IsPipeClosed();
	
	TBool IsReadEndOpened();
	
	TBool IsWriteEndOpened();
	
	TInt OpenId();
	
	TInt Size();
	
	void SetId(TInt aId);
	
	void FlushPipe();
	
	TInt AvailableDataCount();
	
	inline TSecurityPolicy* GetCap(){ return &iPolicy;}

	
private:
	TInt ConstructPipe(const TDesC& aName, TInt aSize,TAny* aPolicy = NULL);
	
	inline void Wait()
		{
		Kern::MutexWait(*iPipeMutex);
		DATAPAGING_TEST(Kern::SetRealtimeState(ERealtimeStateOn);)
		}
	
	inline void Signal()
		{
		DATAPAGING_TEST(Kern::SetRealtimeState(ERealtimeStateOff);)
		Kern::MutexSignal(*iPipeMutex);
		}

	void MaybeCompleteSpaceNotification();

	inline DMutex& Mutex()
		{
		return *iPipeMutex;
		}

private:

	//! constructor
	DPipeChannel *iReadChannel;
	
	DPipeChannel *iWriteChannel;
	
	TKName iName;  //! TBuf<KMaxKernelName> TKName
	
	TInt iID;	

	//! Members for Ring buffer
	TInt iSize;
	
	TBool iFull;
	
	TUint8 *iBuffer;
	
	TInt iWritePointer;
	
	TInt iReadPointer;

	//! Signify the presence of read and write channel
	
	TBool iSpaceAvailableRequest;
	
	TBool iDataAvailableRequest;
	
	TBool iWaitRequest;
	
	TInt  iSpaceAvailableSize;
	
	DMutex *iPipeMutex;
	DMutex *iReadMutex;
	DMutex *iWriteMutex;

	
	TSecurityPolicy iPolicy;
	
};

/**
Acquire the given lock on construction and release
on destruction.
@internalTechnology
*/
template<typename T>
class TAutoWait
	{
public:
	inline TAutoWait(T& aLock)
		:iLock(aLock)
		{
		Wait();
		}

	inline ~TAutoWait()
		{
		Signal();
		}


private:
	TAutoWait(TAutoWait&);
	TAutoWait& operator= (TAutoWait&);

	//disallow allocating on the heap since
	//this won't do what we want
	void* operator new(TUint aSize);

	inline void Wait();
	inline void Signal();

	T& iLock;
	};

template<>
void TAutoWait<DMutex>::Wait()
	{
	NKern::ThreadEnterCS();
	Kern::MutexWait(iLock);
	}

template<>
void TAutoWait<DMutex>::Signal()
	{
	Kern::MutexSignal(iLock);
	NKern::ThreadLeaveCS();
	}

#endif