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

#include "ccontrolchannel.h"
#include <es_sock.h>
#include <e32const.h>
#include <upnpconstants.h>

CControlChannelHandler::CControlChannelHandler ( RSocket &aSocket, TBool aChannelType )
:CActive ( EPriorityNormal ), iSocket ( aSocket ), iChannelType ( aChannelType )
	{
	CActiveScheduler::Add(this);
	}

TInt CControlChannelHandler::RunError ( TInt aError )
	{
	User::RequestComplete ( iChannelStatus, aError );
	return KErrNone;	
	}
// -------------------------------------------------------------
CControlChannelReader* CControlChannelReader::NewL ( RSocket& aSocket, TBool aChannelType )
	{
	return new ( ELeave ) CControlChannelReader ( aSocket, aChannelType );
	}
		
CControlChannelReader::CControlChannelReader ( RSocket& aSocket, TBool aChannelType )
	: CControlChannelHandler ( aSocket, aChannelType )
	{
	}

CControlChannelReader::~CControlChannelReader ()
	{
	Cancel ();	
	}
	
void CControlChannelReader::Read ( TControlMessage& aMessage, TRequestStatus& aStatus )
	{
	if ( iChannelType == EFalse )
		{	
		__ASSERT_DEBUG ( !aMessage.IsDirty (), User::Panic ( KUPnPControlChannel, KErrInUse ) );
		}
		
	iMessage 		= &aMessage;
	iChannelStatus 	= &aStatus;	
	*iChannelStatus = KRequestPending;
	
	iMessage->MessagePtr().SetLength ( 0 );
	iSocket.RecvOneOrMore ( iMessage->MessagePtr(), 0, iStatus, iBytesReceived );
	SetActive ();
	}

void CControlChannelReader::RunL ()
	{
	User::LeaveIfError ( iStatus.Int() );	
	TPtrC8 buffer ( iMessage->MessagePtr() );
	TInt lenToSkip = 0;
	if ( iDataLength == 0 )  // ie; first message
		{
		// We should have more than 4 bytes ( ie; the identifier, which is of TUint,
		// size. here, sizeof (TUint) )
		__ASSERT_DEBUG ( buffer.Length () >= sizeof(TUint), User::Invariant() );
		
		// Extract the first 4 bytes. we will have our identifier with it.
		TLex8 parser ( buffer );
		TUint id = 0;
		User::LeaveIfError ( parser.Val ( id, EDecimal ) );
		iMessage->SetId( id );
		lenToSkip = sizeof (TUint);
		
		// Check how we are going to end with the message. checking the TControlMessage::MaxLength
		// or by explicitly specifying it.
		
		// Get the Maxlength and set it to the iMessage
		TInt maxLen = 0;
		User::LeaveIfError ( iSocket.GetOpt ( KCHMaxRecvLength, KCHOptionLevel, maxLen ) ); 
		iMessage->SetMaxLength ( maxLen );
		}
	TPtrC8 bufferToCopy ( buffer.Ptr() + lenToSkip, buffer.Length() - lenToSkip );
	iMessage->MessagePtr().Copy ( bufferToCopy );
	iDataLength += bufferToCopy.Length ();
	TInt maxLen = iMessage->MaxLength ();
	if ( maxLen == KErrUnknown )
		{
		// We have to issue a GetOpt to see whether we complete with the message.
		TBool last = EFalse;
		User::LeaveIfError ( iSocket.GetOpt ( KCHLastMessage, KCHOptionLevel, last ) );
		if ( last )
			iMessage->SetLast ();
		}
	else
		{
		if ( iDataLength == maxLen )
			{
			// We completed with the message. Set the message end flag as ETrue
			// and reset the iRecvLength
			iDataLength = 0;
			iMessage->SetLast ();
			}
		}
		
	if ( iMessage->IsLast () && iChannelType == EFalse )
		{
		// client usage is done with the current control message
		// We have to set a dirty bit as well for not reusing this message again
		iMessage->SetDirty ();
		}
	
	User::RequestComplete ( iChannelStatus, KErrNone );
	}
	
void CControlChannelReader::DoCancel ()
	{
	iSocket.CancelRecv ();
	User::RequestComplete ( iChannelStatus, KErrCancel );	
	}

// ---------------------------------------------------------------
	
CControlChannelWriter* CControlChannelWriter::NewL ( RSocket& aSocket, TBool aChannelType )
	{
	return new ( ELeave ) CControlChannelWriter ( aSocket, aChannelType );
	}
		
CControlChannelWriter::CControlChannelWriter ( RSocket& aSocket, TBool aChannelType )
	: CControlChannelHandler ( aSocket, aChannelType)
	{
	}

CControlChannelWriter::~CControlChannelWriter ()
	{
	Cancel ();
	}	
	  
void CControlChannelWriter::Write ( TControlMessage& aMessage, TRequestStatus& aStatus )
	{
	if ( iChannelType )
		{
		__ASSERT_DEBUG ( !aMessage.IsDirty (), User::Panic ( KUPnPControlChannel, KErrInUse ) );
		}
		
	iMessage 		= &aMessage;
	iChannelStatus 	=  &aStatus;	
	*iChannelStatus = KRequestPending;
	
	if ( iMessage->Id () == 0 )
		{
		// Message ID is not set. Typically when we do the first send after connect 
		// ie; Client side RControlChannel operation.
		iMessage->SetId ( iSocket.SubSessionHandle () );							
		}

	if ( iMessage->MaxLength() != KErrUnknown )
		{
		TCHMessageOption option ( iMessage->Id (), iMessage->MaxLength () );
		TPckg < TCHMessageOption > optionBuf ( option );
		// Set the total size if set in the TControlMessage
		iSocket.SetOpt ( KCHMaxRecvLength, KCHOptionLevel, optionBuf );		
		}
	
	if ( iMessage->IsLast () && iChannelType )
		{
		// server usage is done with the current control message
		// We have to set a dirty bit as well for not reusing this message again
		iMessage->SetDirty ();
		}
		
	iSocket.Send ( iMessage->MessageDes(), iMessage->Id(), iStatus );
	SetActive ();
	}

void CControlChannelWriter::RunL ()
	{
	User::LeaveIfError ( iStatus.Int() );	
	if ( iMessage->MaxLength() == KErrUnknown && iMessage->IsLast () )
		{
		TCHMessageOption option ( iMessage->Id (), iMessage->IsLast () );
		TPckg < TCHMessageOption > optionBuf ( option );

		// SetOpt to know whether we are sending the last message
		User::LeaveIfError ( iSocket.SetOpt( KCHLastMessage, KCHOptionLevel, optionBuf ) );
		}
	
	User::RequestComplete ( iChannelStatus, KErrNone );
	}

void CControlChannelWriter::DoCancel ()
	{
	iSocket.CancelSend ();
	User::RequestComplete ( iChannelStatus, KErrCancel );
	}

// ----------------------------------------------------------------

CControlChannel* CControlChannel::NewL ( RSocketServ& aSocketServ, RSubConnection& aSubConnection, TUint aAddrFamily, TBool aChannelType, TUint aProtocol, const TConnectionDetails& aConnInfo )
	{
	CControlChannel* self = new (ELeave) CControlChannel ( );
	CleanupStack::PushL ( self );
	self->ConstructL ( aSocketServ, aSubConnection, aAddrFamily, aChannelType, aProtocol, aConnInfo );
	CleanupStack::Pop (); // self
	return self;
	}

CControlChannel::~CControlChannel ()
	{
	delete iReader;
	delete iWriter;
	iSocket.Close ();		
	}

void CControlChannel::Recv ( TControlMessage& aMessage, TRequestStatus& aStatus )
	{
	iReader->Read ( aMessage, aStatus );	
	}

void CControlChannel::Send ( TControlMessage& aMessage, TRequestStatus& aStatus )
	{
	iWriter->Write ( aMessage, aStatus );
	}


CControlChannel::CControlChannel ( )
	{		
	}

void CControlChannel::ConstructL ( RSocketServ& aSocketServ, RSubConnection& aSubConnection, TUint aAddrFamily, TBool aChannelType, TUint aProtocol, const TConnectionDetails& aConnInfo )
	{
	User::LeaveIfError ( iSocket.Open( aSocketServ, aAddrFamily, KSockStream, aProtocol, aSubConnection ) );
	
	if ( aConnInfo.iAddr )
		{
		TRequestStatus connectStatus;
		iSocket.Connect ( *(aConnInfo.iAddr), connectStatus );
		User::WaitForRequest ( connectStatus );  // This is Ok to do... as in the esock server ( actually flow )will just store the 
												// connect address internally and not attempting to do an actual connect. As good as 
												// setopt but we need the socket to know that this is a connected socket.
		User::LeaveIfError ( connectStatus.Int() );					
		}
	
	if ( aConnInfo.iUri.Length() != 0 )
		{
		// Do a setopt to inform the esock about our URI
		User::LeaveIfError ( iSocket.SetOpt ( KCHAbsoluteUri, KCHOptionLevel, aConnInfo.iUri ) );
		}
		
	iReader = CControlChannelReader::NewL ( iSocket, aChannelType );
	iWriter = CControlChannelWriter::NewL ( iSocket, aChannelType );
	}