// 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 "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:
// Name          : CReceiver.cpp
// Part of       : ConnectionMgr
// Version       : SIP/5.0
//



#include "CReceiver.h"
#include "SipLogs.h"
#include "CSipConnection.h"
#include "CommonConsts.h"
#include "MContext.h"
#include "MSigCompController.h"
#include "CSocketContainer.h"

// -----------------------------------------------------------------------------
// CReceiver::NewL
// -----------------------------------------------------------------------------
//
CReceiver* CReceiver::NewL( MContext& aContext, TUint aIPAddrFamily )
	{
	CReceiver* self = NewLC( aContext, aIPAddrFamily );
	CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CReceiver::NewLC
// -----------------------------------------------------------------------------
//
CReceiver* CReceiver::NewLC( MContext& aContext, TUint aIPAddrFamily )
	{
	CReceiver* self = new ( ELeave ) CReceiver( aContext, aIPAddrFamily );
	CleanupStack::PushL( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CReceiver::CReceiver
// -----------------------------------------------------------------------------
//
CReceiver::CReceiver( MContext& aContext, TUint aIPAddrFamily ) : 
    CActive( EPriorityStandard ), 
    iContext( aContext ),
    iIPAddrFamily( aIPAddrFamily ),
    iState( EIdle ),
    iReceivedMsgPtr( 0, 0, 0 )
	{
	CActiveScheduler::Add( this );
	}

// -----------------------------------------------------------------------------
// CReceiver::~CReceiver
// -----------------------------------------------------------------------------
//
CReceiver::~CReceiver()
	{
	Cancel();
	delete iReceivedMsg;
	}

// -----------------------------------------------------------------------------
// CReceiver::DoCancel
// -----------------------------------------------------------------------------
//
void CReceiver::DoCancel()
	{
	CSocketContainer* socketContainer = 
	    iContext.SocketContainer( iIPAddrFamily );
	if ( iState == EListening )
	    {
	    socketContainer->Socket().CancelIoctl();
	    }
	else
        {
        socketContainer->Socket().CancelRecv();
        }
	}

// -----------------------------------------------------------------------------
// CReceiver::Listen
// -----------------------------------------------------------------------------
//
void CReceiver::Listen()
	{
	CSocketContainer* socketContainer = 
	    iContext.SocketContainer( iIPAddrFamily );	
	if ( socketContainer && !IsActive() )
		{	
		iState = EListening;
		
		iFlags() = KSockSelectRead | KSockSelectExcept;
	    socketContainer->Socket().Ioctl( 
	        KIOctlSelect, 
	        iStatus, 
	        &iFlags, 
            KSOLSocket );	
		SetActive();
		}
	}

// -----------------------------------------------------------------------------
// CReceiver::RunL
// -----------------------------------------------------------------------------
//
void CReceiver::RunL()
	{
	switch ( iStatus.Int() )
		{
		case KErrNone:
			{
			if ( iState == EListening )
			    {
			    ReceivePendingL();
			    }
			else if ( iState == EReceiving )
			    {
    			__SIP_MESSAGE_LOG( "Connection Manager::ReceivedFromNetwork",
    							   *iReceivedMsg )
    			__SIP_DES8_LOG( "Received data via UDP", *iReceivedMsg )	
    			// Give away ownership of the received message
    			HBufC8* tmpReceivedMsg = iReceivedMsg;
    			iReceivedMsg = 0; 
    			
    			Listen();
    			ReceivedDataL( tmpReceivedMsg );
			    }
			else
			    {
			    // Required by PC-Lint
			    }
			break;
			}
		case KErrCancel:
			break;
		default:
			{
			__SIP_INT_LOG1( "CReceiver::RunL() status", iStatus.Int() )
			iContext.Remove();
			break;
			}
		}
	}

// -----------------------------------------------------------------------------
// CReceiver::ReceivedDataL
// -----------------------------------------------------------------------------
//
void CReceiver::ReceivedDataL( HBufC8* aData )
	{
	if ( iContext.SigCompHandler()->IsSupported() &&		
		 iContext.SigCompHandler()->IsSigCompMsg( *aData ) )
		{
		__SIP_LOG( "IsSigComp complete == ETrue" )

		CleanupStack::PushL( aData );
		TUint bytesconsumed = 0;
		CBufBase* decompressedmessage =				  
			iContext.SigCompHandler()->DecompressL( *aData,
													bytesconsumed,
													EFalse );
		CleanupStack::PopAndDestroy( aData );
		CleanupStack::PushL( decompressedmessage );

		HBufC8* receiveddata = HBufC8::NewL( decompressedmessage->Size() );
		receiveddata->Des().Copy( decompressedmessage->Ptr( 0 ) );
		CleanupStack::PopAndDestroy( decompressedmessage );

		iContext.ReceivedDataL( receiveddata, iAddr, ETrue );
		}
	else
		{
		iContext.ReceivedDataL( aData, iAddr, EFalse );
		}
	}

// -----------------------------------------------------------------------------
// CReceiver::ReceivePendingL
// -----------------------------------------------------------------------------
//	
void CReceiver::ReceivePendingL()
    {
    __ASSERT_ALWAYS( !IsActive(), User::Leave( KErrInUse ) );
    
    CSocketContainer* socketContainer = 
	    iContext.SocketContainer( iIPAddrFamily );
    __ASSERT_ALWAYS( socketContainer, User::Leave( KErrNotFound ) );
    
    iState = EReceiving;
			    
	TInt bytesPending( 0 );
	User::LeaveIfError( 
	    socketContainer->Socket().GetOpt( 
	        KSOReadBytesPending, 
            KSOLSocket, 
            bytesPending ) );

    __SIP_INT_LOG1( "CReceiver::ReceivePendingL() bytes", bytesPending )

	// Don't allow excessive buffer
	if ( bytesPending > KMaxMessageLength )
	    {
	    bytesPending = KMaxMessageLength;
	    }
	    
    delete iReceivedMsg;
	iReceivedMsg = 0;
	iReceivedMsg = HBufC8::NewL( bytesPending );
	iReceivedMsgPtr.Set( iReceivedMsg->Des() );
	socketContainer->Socket().RecvFrom( iReceivedMsgPtr, iAddr, 0, iStatus );     	
	SetActive();
    }

// -----------------------------------------------------------------------------
// CReceiver::RunError
// -----------------------------------------------------------------------------
//
TInt CReceiver::RunError( TInt aError )
	{
	Listen();
	if ( aError != KErrNoMemory )
		{
		return KErrNone;
		}
	return aError;
	}