// 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:
//
/**
@file rpipe.cpp
@internalTechnology
*/
#include <e32def.h>
#include <e32def_private.h>
#include "rpipe.h"
EXPORT_C TInt RPipe::Init()
/**
Static method to load the pipe device driver.
@param None
@return KErrNone If the pipe is successfully loaded, otherwise one of the
system wide error code.
*/
{
_LIT(KDriverLddFileName,"PIPELIB");
return User::LoadLogicalDevice(KDriverLddFileName);
}
EXPORT_C TInt RPipe::Create( TInt aSize, RPipe& aReader, RPipe& aWriter, TOwnerType aTypeR, TOwnerType aTypeW)
/**
Static method to create a new, unnamed pipe.
By default, any thread in the process can use the handle to access the Pipe. However,
specifying EOwnerThread as the second and fourth parameter to this function, means
that only the creating thread can use this handle to access the Pipe.
@param aReader Handle to the read end of the pipe. If the call is successful,
this handle will be opened for reading.
@param aWriter Handle to the write end of the pipe. If the call is successful,
this handle will be opened for writing.
@param aTypeR, aTypeW The type of the ownership of the handle to be created for the
read and write
@param aSize Size of the pipe to be created, in bytes.
@return KErrNone Pipe successfully created and the read and write handles opened,
KErrOverflow Maximum number of pipes has been reached.
KErrNoMemory Insufficient memory to create pipe
KErrArgument If the specified size is negative or zero
KErrInUse The current handle has already been opened.
otherwise one of the other system wide error codes
*/
{
TInt err = aReader.Create(aSize, aTypeR);
if (err != KErrNone )
return err;
else
{
err = aWriter.Open(aReader, aTypeW);
if(err!= KErrNone)
aReader.Close();
}
return err;
}
TInt RPipe::Create(TInt aSize, TOwnerType aType)
/**
Creates a Kernel side pipe and opens a handle for reading.
By default any thread in the process can use the handle to access to Read the Pipe.
However, specifying EOwnerThread as the second parameter to this function, means
that only the creating thread can use this handle to access the pipe.
@param aSize Size of the pipe to create, in bytes.
@param aType The type of the handle to be created for the reading
end of the pipe
@return KErrNone Pipe successfully created and handle opened for reading,
KErrInUse The current handle has already been opened.
KErrOverflow Maximum number of pipes has been reached.
KErrNoMemory Insufficient memory to create pipe
KErrArgument If the specified size is negative or zero
otherwise one of the other system wide error code
*/
{
// Check if the current handle is already opened for reading/writing
if ( iHandle && HandleType())
return KErrInUse;
if(aSize <= 0 )
return KErrArgument;
// Perform the capability check and create the channel
TInt err = DoCreate(Name(), VersionRequired(), KNullUnit, NULL, NULL, aType, ETrue);
if (err!= KErrNone)
return err;
// Create an un-named pipe with the specified size
err = DoControl(ECreateUnNamedPipe, (TAny*)&aSize);
if (err>0)
{
iSize = DoControl(ESize);
iHandleType = EReadChannel;
iPipeHandle = err;
err = KErrNone;
}
else
{
Close();
}
return err;
}
EXPORT_C TInt RPipe::Open(RMessagePtr2 aMessage, TInt aParam, TOwnerType aType)
/**
Opens a handle to pipe using a handle number sent by a client to a server.
This function is called by the server.
@param aMessage The message pointer.
@param aParam An index specifying which of the four message arguments contains the handle number.
@param aType An enumeration whose enumerators define the ownership of this logical channel handle.
If not explicitly specified, EOwnerProcess is taken as default.
@return KErrNone if successful;
KErrArgument if the value of aParam is outside the range 0-3;
KErrBadHandle if not a valid handle;
otherwise one of the other system-wide error codes.
*/
{
TInt err = RBusLogicalChannel::Open(aMessage, aParam, aType);
if (err)
{
return err;
}
err = DoControl(RPipe::EGetPipeInfo,&iHandleType,&iSize);
return err;
}
EXPORT_C TInt RPipe::Open(TInt aArgumentIndex, TOwnerType aType)
/**
Opens the handle to pipe which is passed by a process to child process using
RProcess.SetParameter function call. Pipe handle type remains same(i.e. if read handle is passed
by process then read handle will be open).
@param aArgumentIndex An index that identifies the slot in the process environment
data that contains the handle number. This is a value relative
to zero, i.e. 0 is the first item/slot. This can range from 0 to 15.
@param aType The type of the handle to be created for the read/write end
@return KErrNone Pipe successfully created,
otherwise of the other system wide error code.
*/
{
TInt err = RBusLogicalChannel::Open(aArgumentIndex,aType);
if (err)
{
return err;
}
err = DoControl(RPipe::EGetPipeInfo,&iHandleType,&iSize);
return err;
}
TInt RPipe::Open(const RPipe& aReader, TOwnerType aType)
/**
Opens a handle to write to a pipe. The pipe must have been created previously.
By default any thread in the process can use the handle to access to write to
the pipe. However, specifying EOwnerThread as the second parameter to this function,
means that only the opening thread can use this handle to write to the pipe.
@param aReader Handle to the reading end of the pipe.
@param aType The type of the handle to be created for the write end
@return KErrNone Pipe successfully created,
KErrInUse The current handle has already been opened
KErrAccessDenied The read handle is not open for reading
otherwise of the other system wide error code.
*/
{
// Check if the current handle is already opened for reading/writing
if ( iHandle && HandleType())
return KErrInUse;
// Check the read handle
if (aReader.HandleType() != EReadChannel)
return KErrAccessDenied;
// Perform the capability check and create the channel
TInt err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL, aType, ETrue);
if (err!= KErrNone)
return err;
// Obtained the handle number
TInt id = aReader.PipeHandle();
// Set the Write channel
err = DoControl(EOpenUnNamedPipe,(TAny*)&id);
if( err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EWriteChannel;
iPipeHandle = id;
}
else
{
Close();
}
return err;
}
// Methods to Support Named Pipe
EXPORT_C TInt RPipe::Define(const TDesC& aName, TInt aSize)
/**
Static method to create a new, named pipe of a given size. Calling this method
will create a new kernel object only. No user-side handles are created or opened.
@param aName Name to be assigned to the Kernel-side pipe object.
@param aSize Size of the pipe to create, in bytes.
@return KErrNone Pipe successfully created.
KErrBadName If the length of aName is greater than KMaxFileName
or Null
KErrOverflow Maximum number of pipes has been reached
KErrNoMemory Insufficient memory to create pipe.
KErrArgument if Size is negative
KErrAlreadyExist If a pipe with the specified name already exist.
otherwise one of the other system wide error code.
*/
{
// Code to check a valid Name field as per Symbian naming convention
TInt err = User::ValidateName(aName);
if(KErrNone!=err)
return err;
if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
return KErrBadName;
if(aSize <= 0)
return KErrArgument;
// Perform the capability check and create the channel
RPipe temp;
err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
if (err!= KErrNone)
return err;
// Define
TPipeInfoBuf aInfo;
aInfo().isize = aSize;
aInfo().iName.Copy(aName);
// Define the Named pipe
err = temp.DoControl(EDefineNamedPipe, (TAny*)&aInfo);
temp.Close();
return err;
}
EXPORT_C TInt RPipe::Define( const TDesC& aName, TInt aSize, const TSecurityPolicy& aPolicy)
/**
Static method to create a new, named pipe of a given size. Calling this method
will create a new kernel object only. No user-side handles are created or opened.
@param aName Name to be assigned to the Kernel-side pipe object.
@param aSize Size of the pipe to create, in bytes.
@return KErrNone Pipe successfully created.
KErrBadName If the length of aName is greater than KMaxFileName
or Null
KErrOverflow Maximum number of pipes has been reached
KErrNoMemory Insufficient memory to create pipe.
KErrArgument if Size is negative
KErrPermissionDenied Not sufficient capabiliites
KErrAlreadyExist If a pipe with the specified name already exist.
otherwise one of the other system wide error code.
*/
{
// Code to check a valid Name field as per Symbian naming convention
TInt err = User::ValidateName(aName);
if(KErrNone!=err)
return err;
if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
return KErrBadName;
if(aSize <= 0)
return KErrArgument;
// Perform the capability check and create the channel
RPipe temp;
err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
if (err!= KErrNone)
return err;
// Define
TPipeInfoBuf aInfo;
aInfo().isize = aSize;
aInfo().iName.Copy(aName);
err = temp.DoControl(EDefineNamedPipe, (TAny*)&aInfo, (TAny*)&aPolicy);
temp.Close();
return err;
}
EXPORT_C TInt RPipe::Destroy( const TDesC& aName)
/**
Static method to destroy a previously created named pipe. Any data not read from
the pipe will be discarded. This method will fail if there is any handles still
open on the pipe or the calling thread as insufficient capabilities.
@param aName Name of the Kernel-side pipe object to destroy
@return KErrNone Pipe successfully destroyed
KErrInUse The pipe still has one or more handle open to it
KErrPermissionDenied Not sufficient capabiliites
KErrNotFound If no kernel pipe exist with the specified name
otherwise one of the other system wide error code.
*/
{
// Code to check a valid Name field as per Symbian naming convention
TInt err = User::ValidateName(aName);
if(KErrNone!=err)
return err;
if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
return KErrBadName;
// Perform the capability check and create the channel
RPipe temp;
err = temp.DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
if (err!= KErrNone)
return err;
TBuf8<KMaxKernelName> name;
name.Copy(aName);
// Destroy
err = temp.DoControl(EDestroyNamedPipe, (TAny*)&name, NULL);
temp.Close();
return err;
}
EXPORT_C TInt RPipe::Open(const TDesC& aName, TMode aMode)
/**
Opens the pipe for the access mode specified. If the handle is opened to read or Write.
The handle is opened regardless of whether or not there is a open handle at the other end.
If the handle is opened as " Write but Fail On No Readers" the call will fail unless there
is atleast one handle open for reading at the other end.
@param aName Name of the kernel-side pipe object to destroy
@param aMode Access mode for the handle.
@return KErrNone Handle successfully opened.
KErrBadName If the length of aName is greater than KMaxFileName or Null
KErrInUse The pipe still has one or more handle open to it.
KErrPermissionDenied Not sufficient capabiliites
KErrNotFond If there is no kernel instance with the specified name
KErrNotReady Open Fails when no Readers is available while opening
With TMode = EOpenToWriteButFailOnNoReaders
otherwise one of the other system wide error code.
*/
{
// Check if the current handle is already opened for reading/writing
if ( iHandle && HandleType())
return KErrInUse;
TInt err = User::ValidateName(aName);
if(KErrNone!=err)
return err;
if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
return KErrBadName;
// Perform the capability check and create the channel
err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
if (err!= KErrNone)
return err;
TBuf8<KMaxKernelName> name;
name.Copy(aName);
if (aMode == EOpenToRead)
{
err = DoControl(EOpenToReadNamedPipe,(TAny*)&name);
if(err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EReadChannel;
}
else
Close();
}
else if(aMode == EOpenToWrite)
{
err = DoControl(EOpenToWriteNamedPipe, (TAny*)&name);
if(err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EWriteChannel;
}
else
Close();
}
else if (aMode == EOpenToWriteNamedPipeButFailOnNoReaders)
{
err = DoControl(EOpenToWriteButFailOnNoReaderNamedPipe, (TAny*)&name);
if(err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EWriteChannel;
}
else
Close();
}
else
{
Close();
err = KErrArgument;
}
return err;
}
EXPORT_C void RPipe::Wait(const TDesC& aName, TRequestStatus& aStatus)
/**
Block the thread until the other end of the pipe is opened for reading. If the other end
is already opened for reading the call will not block and status will complete immediately
This function will be deprecated , use WaitForReader.
Please note that Wait API will open a valid Write End of the pipe if not opened already.
User need not open write end of the pipe again after Wait call.
@param aName Name of the kernel-side pipe object to wait for
@param aStatus Status request that will complete when the other end is opened
for reading.
@return KErrNone Request is successfully registered
KErrBadName If the length of aName is greater then KMaxFileName or NULL
KErrInUse A notifier of this type has already been registered.
KErrPermissionDenied Not sufficient capabiliites
otherwise one of the other system wide error code.
*/
{
// To wait for Reader end pass flag as EWaitForReader.
TInt aFlag = EWaitForReader;
Wait(aName, aStatus , aFlag );
}
EXPORT_C void RPipe::CancelWait()
/**
Cancel previous call to RPipe::Wait(), RPipe::WaitForReader (), RPipe::WaitForWriter ()
@param None
@return None
*/
{
if(!iHandle)
return;
DoCancel(ECancelWaitNotification);
}
// Generic Methods
EXPORT_C void RPipe::Close()
/**
Close the handle. This method exhibits different behaviour depending upon whether the pipe
is named or unnamed.
Named pipes are allowed to persist without any open handles. Closing the last handle on a
named pipe will not destroy the kernel-side object. For an unnamed pipe, closing the last
handle will destroy the kernel-side pipe object. Any unread data in the pipe will be
discarded.
An attempt to close an unnamed pipe will have no effect. Closing a handle will not affect
the state of any other handles that may be open on the pipe.
@param None
@return None
*/
{
if(!iHandle)
return;
RHandleBase::Close();
}
EXPORT_C TInt RPipe::MaxSize()
/**
Returns the total size, in bytes, of the Pipe
@param None
@return >= 0 Size of the pipe in bytes
KErrBadHandle The handle is not open
otherwise one of the other system wide error code.
*/
{
if (!iHandle )
return KErrBadHandle;
if(iHandleType == EReadChannel || iHandleType == EWriteChannel)
return iSize;
else
return KErrAccessDenied;
}
EXPORT_C TInt RPipe::Read(TDes8& aMsg, TInt aNumByte)
/**
This is non-blocking synchronous method to read aNumByte bytes from the pipe into the
descriptor aMsg and returns the number of bytes read. If the pipe is empty the call will
immediately return a value of zero to indicate that no data was read
A successful RPipe::Read() operation will free up more space in the pipe.
@param aMsg Descriptor to receive data
@param aNumByte Number of bytes to be received.
@return >0 Amount of data read from the pipe, in bytes.
KErrUnderFlow The pipe was empty, no data was read
KErrAccessDenied An attempt has been made to read from a handle
has been opened for writing.
KErrBadHandle An attempt has been made to read from a handle
that has not been opened.
KErrNotReady Write end is closed and Pipe is empty.
0 No Data is available
otherwise one of the other system wide error code.
*/
{
// Check for the error condition
if (!iHandle)
return KErrBadHandle;
// Check for KErrArgument
if(aNumByte > aMsg.MaxLength())
return KErrArgument;
if(iHandleType != EReadChannel)
return KErrAccessDenied;
return DoControl(ERead, (TAny*)&aMsg, (TAny*)&aNumByte);
}
EXPORT_C TInt RPipe::Write( const TDesC8& aData, TInt aNumByte)
/**
This is non-blocking synchronous method to write data from aData. If the pipe is
full it will return immediately with KErrOverFlow
@param aData Descriptor from which data has to be written to the pipe
@return >0 Amount of data written to the pipe, in bytes
KErrAccessDenied An attempt has been made to write to a handle that
has been opened for reading.
KErrArgument If the size is more then aData's length
KErrBadName
KErrOverFlow The pipe is full. No data was inserted into the pipe.
KErrBadHandle An attempt has been made to read from a handle that
has not been opened.
KErrCompletion If the specified size is greater then the available size.
KErrNotReady Read end is closed.
otherwise one of the other system wide error code.
*/
{
// Check for the error condition
if (!iHandle)
return KErrBadHandle;
// Check for KErrArgument
if(aNumByte > aData.Length())
return KErrArgument;
if(iHandleType == EReadChannel)
return KErrAccessDenied;
return DoControl(EWrite, (TAny*)&aData, (TAny*)&aNumByte);
}
EXPORT_C TInt RPipe::ReadBlocking( TDes8& aMsg, TInt aNumByte)
/**
This is synchronous, blocking read operation. If the pipe is empty the client thread will
be blocked until data become available. A successful RPipe::ReadBlocking() operation will
free up more space in the pipe. This method is accompanied by data notification method to
complete the blocking mechanism
@param aMsg Descriptor to receive data
@param aNumByte Number of bytes to be received
@return >0 Amount of data read from the pipe in bytes.
KErrAccessDenied Am attempt has been made to read from the handle that
has been opened for writing.
KErrBadHandle Am attempt has been made to read from a handle that has
not been opened.
KErrArgument if the size is negative.
KErrInUse If the call is active from some another thread.
KErrNotReady Write end is closed and Pipe is empty.
otherwise one of the system wide error code.
*/
{
TRequestStatus stat = KRequestPending;
TInt err = KErrNone;
// Check for the error condition
if (!iHandle)
return KErrBadHandle;
if(aNumByte <= 0)
return KErrArgument;
if(iHandleType != EReadChannel)
return KErrAccessDenied;
// Asynchronous request to notify the data available.
do
{
stat = KRequestPending;
DoRequest(EReadBlocking, stat);
User::WaitForRequest(stat);
err = stat.Int();
if (err == KErrInUse || err == KErrNotReady)
{
return err;
}
// Synchronous read operation
err = DoControl(ERead, (TAny*)&aMsg, (TAny*)&aNumByte);
if (err == KErrNotReady)
return err;
} while (err == 0);
return err;
}
EXPORT_C TInt RPipe::WriteBlocking(const TDesC8& aData, TInt aNumByte)
/**
This is a synchronous, blocking write operation. It will attempt to
write aNumByte's worth of data to the pipe, waiting till space is available.
If aNumByte is less than or equal to the pipe size, MaxSize(), the write
shall be atomic (w.r.t other threads sharing this channel), otherwise
the data will be split into multiple atomic writes of pipe size
(except, of course, if less than MaxSize bytes of data remain to be written).
@param aData Descriptor from which data has to be written to the pipe.
@param aNumByte Amount of data to be written to the pipe
@return >0 Amount of data written to the pipe, in bytes.
KErrAccessDenied An attempt has been made to write to a handle that
has been opened for reading.
KErrBadHandle An attempt has been made to read from a handle that has
not been open.
KErrArgument if the size is negative.
KErrNotReady Read end is closed.
otherwise one of the other system wide error code.
*/
{
TBool first = ETrue;
TRequestStatus stat = KRequestPending;
TInt err = 0;
TInt index = 0;
TInt writeindex =0;
TPtrC8 tmp;
TInt r = aNumByte;
// Check for the error condition
if (!iHandle)
return KErrBadHandle;
if(aNumByte <= 0)
return KErrArgument;
if(iHandleType == EReadChannel)
return KErrAccessDenied;
if (aNumByte <= iSize)
writeindex = aNumByte;
else
writeindex = iSize;
do
{
// Asynchronous request to notify the space available.
stat = KRequestPending;
DoRequest(EWriteBlocking, stat,(TAny*)&writeindex);
User::WaitForRequest(stat);
err = stat.Int();
if (err == KErrInUse || err == KErrNotReady)
{
return err;
}
// Synchronous write operation
tmp.Set(aData.Ptr()+index, writeindex);
err = DoControl(EWrite, (TAny*)&tmp, (TAny*)&writeindex);
if(err == KErrNotReady)
{
return err;
}
else
{
if ( err == aNumByte)
{
first = EFalse;
}
else
{
index = index + err;
aNumByte = r - index;
if(aNumByte < iSize)
writeindex = aNumByte;
}
}
}while(first);
return r;
}
EXPORT_C void RPipe::NotifyDataAvailable(TRequestStatus& aStatus)
/**
This method registers the request status object to be completed when data become
available in the pipe.
@param aStatus Status request that will complete when Data is available.
@return KErrNone Successfully registered.
KErrAccessDenied Am attempt has been made to register a space available
notification on a handle that has not been opened for
reading.
KErrCompletion The request was NOT registered as the condition succeeded before wait.
KErrBadHandle The handle is not yet associated with a kernel pipe
otherwise of the other system wide error code.
*/
{
TInt err = KErrNone;
if(!iHandle)
{
err = KErrBadHandle;
}
else if(iHandleType != EReadChannel)
{
err = KErrAccessDenied;
}
if(err!= KErrNone)
{
ReqComplete(aStatus, err);
return;
}
aStatus = KRequestPending;
DoRequest(EDataAvailable, aStatus);
}
EXPORT_C void RPipe::NotifySpaceAvailable(TInt aSize, TRequestStatus& aStatus)
/**
This method registers the request status object to be completed when at least
aSize bytes are available for writing data into the pipe.
@param aSize Amount of space to wait for in the pipe.
@param aStatus Status request that will complete when aSize
bytes become available.
@returns KErrNone Successfully registered.
KErrAccessDenied An attempt has been made to register a space
available notification on a handle that has
not been opened for writing.
KErrArgument If the size is negative, zero, or greater than maximum pipe size
KErrBadHandle The handle is not yet associated with a kernel pipe
otherwise one of the other system wide error code
*/
{
TInt err = KErrNone;
if(!iHandle)
{
err = KErrBadHandle;
}
else if(iHandleType == EReadChannel)
{
err = KErrAccessDenied;
}
else if(aSize <= 0 || aSize > MaxSize())
{
err = KErrArgument;
}
if(err!= KErrNone)
{
ReqComplete(aStatus, err);
return;
}
aStatus = KRequestPending;
DoRequest(ESpaceAvailable, aStatus, (TAny*)&aSize);
}
EXPORT_C TInt RPipe::CancelSpaceAvailable()
/**
Cancels an outstanding space available notifier request.
@param None
@returns KErrNone Successfully cancelled the SpaceAvailable request.
KErrBadHandle An attempt has been made to Cancel Data Available with a
handle which has not been associated with any kernel pipe.
KErrAccessDenied An attempt has been made to cancel a space available
notification on a handle that has been opened for reading.
other wise on of the other system wide error code.
*/
{
if(!iHandle)
return KErrBadHandle;
if(iHandleType != EWriteChannel)
return KErrAccessDenied;
DoCancel(ECancelSpaceAvailable);
return KErrNone;
}
EXPORT_C TInt RPipe::CancelDataAvailable()
/**
Cancels an outstanding data available notifier request.
@param None
@return KErrNone Successfully cancelled the DataAvailable request.
KErrBadHandle An attempt has been made to Cancel Data Available with a
handle which has not been associated with any kernel pipe.
KErrAccessDenied Am attempt has been made to cancel a data available
notification on a handle that has been opened for writing.
otherwise one of the other system wide error code
*/
{
if(!iHandle)
return KErrBadHandle;
if(iHandleType != EReadChannel)
return KErrAccessDenied;
DoCancel(ECancelDataAvailable);
return KErrNone;
}
EXPORT_C void RPipe::Flush()
/**
This method will empty the pipe of all data
@param None
@returns None
*/
{
DoControl(EFlushPipe);
}
EXPORT_C TInt RPipe::HandleType()const
/**
This method returns the Type of operation it can perform with the current handle.
@param None
@returns
EReadChannel If the current handle is associated to the kernel-side
pipe object as to perform Read operations.
EWriteChannel If the current handle is associated to the kernel-side
pipe object as to perform Write operations.
KErrBadHandle If the handle is not associated with Kernel-side object.
otherwise one of the other system wide error code
*/
{
if(!iHandle)
return KErrBadHandle;
else
return iHandleType;
}
EXPORT_C TInt RPipe::Size()
/**
Returns the available data in the pipe
@param None
@return >= 0 Amount of data available in the pipe
KErrBadHandle The handle is not yet opened
otherwise one of the other system wide error code.
*/
{
if(!iHandle)
return KErrBadHandle;
return DoControl(EDataAvailableCount);
}
TInt RPipe::PipeHandle()const
/**
Returns the id of Pipe it has created.
*/
{
return iPipeHandle;
}
void RPipe::ReqComplete(TRequestStatus& aStatus, TInt err)
{
TRequestStatus* req=(&aStatus);
User::RequestComplete(req,err);
}
EXPORT_C void RPipe::WaitForReader(const TDesC& aName, TRequestStatus& aStatus)
/**
Block the thread until the other end of the pipe is opened for reading. If the other end
is already opened for reading the call will not block and status will complete immediately.
Please note that WaitForReader API will open a valid Write End of the pipe if not opened already.
User need not open write end of the pipe again after WaitForReader call.
@param aName Name of the kernel-side pipe object to wait for
@param aStatus Status request that will complete when the other end is opened
for reading.
@return KErrNone Request is successfully registered
KErrBadName If the length of aName is greater then KMaxFileName or NULL
KErrInUse A notifier of this type has already been registered.
KErrPermissionDenied Not sufficient capabiliites
KErrAccessDenied WaitForReader request is issued using Read handle.
otherwise one of the other system wide error code.
*/
{
// To wait for Reader end pass flag as EWaitForReader.
TInt aFlag = EWaitForReader;
Wait(aName, aStatus , aFlag );
}
EXPORT_C void RPipe::WaitForWriter(const TDesC& aName, TRequestStatus& aStatus)
/**
Block the thread until the other end of the pipe is opened for writing. If the other end
is already opened for writing the call will not block and status will complete immediately
Please note that WaitForWriter API will open a valid Read End of the pipe if not opened already.
User need not open read end of the pipe again after WaitForWriter call.
@param aName Name of the kernel-side pipe object to wait for
@param aStatus Status request that will complete when the other end is opened
for writing.
@return KErrNone Request is successfully registered
KErrBadName If the length of aName is greater then KMaxFileName or NULL
KErrInUse A notifier of this type has already been registered.
KErrPermissionDenied Not sufficient capabiliites
KErrAccessDenied WaitForWriter request is issued using Write handle.
otherwise one of the other system wide error code.
*/
{
// To wait for Writer end pass flag as EWaitForWriter.
TInt aFlag = EWaitForWriter;
Wait(aName, aStatus , aFlag );
}
void RPipe::Wait(const TDesC& aName, TRequestStatus& aStatus , TInt aChoice)
/**
Block the thread until the other end of the pipe is opened for reading (or writing). If the other end
is already opened for reading (or writing) the call will not block and status will complete immediately.
@param aName Name of the kernel-side pipe object to wait for
@param aStatus Status request that will complete when the other end is opened
for reading (or Writing).
@param aChoice EWaitForReader for WaitForReader.
EWaitForWriter for WaitForWriter.
@return KErrNone Request is successfully registered
KErrBadName If the length of aName is greater then KMaxFileName or NULL
KErrInUse A notifier of this type has already been registered.
KErrPermissionDenied Not sufficient capabiliites
KErrAccessDenied WaitForReader request is issued using Read handle or
WaitForWriter request is issued using Write handle.
otherwise one of the other system wide error code.
*/
{
// Code to check a valid Name field as per Symbian naming convention
TInt err = User::ValidateName(aName);
if(err != KErrNone)
{
ReqComplete(aStatus, err);
return;
}
if((aName.Length() > KMaxKernelName) || (aName.Length() == 0))
{
ReqComplete(aStatus, KErrBadName);
return;
}
TBuf8<KMaxKernelName> name8;
name8.Copy(aName);
aStatus = KRequestPending;
// Check if the current instance of RPipe is already opened.
if (!iHandle)
{
// Perform the capability check and create the channel
err = DoCreate(Name(),VersionRequired(), KNullUnit, NULL, NULL);
if (err!= KErrNone)
{
ReqComplete(aStatus, err);
return;
}
if (aChoice == EWaitForReader)
{
// Open the Write handle.
err = DoControl(EOpenToWriteNamedPipe, (TAny*)&name8);
if(err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EWriteChannel;
}
}
else
{
// Open the Read handle.
err = DoControl(EOpenToReadNamedPipe, (TAny*)&name8);
if(err == KErrNone)
{
iSize = DoControl(ESize);
iHandleType = EReadChannel;
}
}
if ( err!= KErrNone)
{
Close();
ReqComplete(aStatus, err);
return;
}
}
// use the existing Logical channel to send the request.
DoRequest(EWaitNotification, aStatus, (TAny*)&name8,(TAny*)&aChoice);
}