// 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          : CSIPITCReceiverBase.cpp
// Part of       : SIPClient
// Version       : SIP/5.0 
//



#include "CSIPITCReceiverBase.h"
#include "MSIPITC.h"
#include "siprequestelements.h"
#include "sipresponseelements.h"
#include "sipmessageelements.h"
#include "siphttpdigestchallengeobserver.h"
#include "SipAssert.h"
#include "sipinternalerr.h"

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::CSIPITCReceiverBase
// -----------------------------------------------------------------------------
//
CSIPITCReceiverBase::CSIPITCReceiverBase (MSIPITC& aITC) 
 : CActive (EPriorityStandard),
   iITC (aITC)
	{
    CActiveScheduler::Add (this);
    iITCMsgArgs.Set (ESipItcArgIds, &iIdsPckg);
    iITCMsgArgs.Set (ESipItcArgBufSizes, &iSizesPckg);
	
	ReceiveNext ();
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::~CSIPITCReceiverBase
// -----------------------------------------------------------------------------
//
CSIPITCReceiverBase::~CSIPITCReceiverBase () 
	{
    CActive::Cancel();
	}
	
// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::SetHttpDigestObserver
// -----------------------------------------------------------------------------
//	
void CSIPITCReceiverBase::SetHttpDigestObserver(
    MSIPHttpDigestChallengeObserver& aObserver)
    {
    iHttpDigestObserver = &aObserver;
    iHttpDigestObserver2 = NULL;
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::SetHttpDigestObserver
// -----------------------------------------------------------------------------
//	
void CSIPITCReceiverBase::SetHttpDigestObserver(
    MSIPHttpDigestChallengeObserver2& aObserver)
    {
    iHttpDigestObserver2 = &aObserver;
    iHttpDigestObserver = NULL;
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::RemoveHttpDigestObserver
// -----------------------------------------------------------------------------
// 
void CSIPITCReceiverBase::RemoveHttpDigestObserver()
    {
    iHttpDigestObserver = NULL;
    iHttpDigestObserver2 = NULL;
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::RunL
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::RunL ()
	{
	TInt err = iStatus.Int();
	if (err == KErrServerTerminated)
		{
		// This will leave to RunError-function. See below.
		User::Leave(err);
		}
    // Take copy of the ids. iIdsPckg could be overwritten by ReceiveNext.
    TSIPIds ids(iIdsPckg());		
    if (err == KErrNone)
        {
		IncomingMessageL(ids);
        }
    else if (err == KChallengeReceived)
        {
        ChallengeReceivedL(ids);
        }    
    else
        {
        // For errors receive has to be renewed before calling the observer 
        // which might delete the CSIP or CSIPConnection, 
        // which leads to deletion of this object.
        ReceiveNext();
        ErrorOccuredL(ids,err);
        }    
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::RunError
// -----------------------------------------------------------------------------
//
TInt CSIPITCReceiverBase::RunError (TInt aError)
	{
	if (aError == KErrServerTerminated)
		{
		// Return the error to the active scheduler and stop receiving.
		// Receiving must be stopped.
		// It would lead to infinite RunL-RunError-loop.
		return aError;
		}
    // Ignore all the other errors and continue receiving
	ReceiveNext ();
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::RunError
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::DoCancel()
    {
    iITC.CancelReceive();
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::ReceiveNext
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::ReceiveNext ()
	{
	if (!IsActive())
        {
        iITC.Receive(iITCMsgArgs,iStatus);
	    SetActive();
        }
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::ChallengeReceivedL
// -----------------------------------------------------------------------------
//	
void CSIPITCReceiverBase::ChallengeReceivedL (TSIPIds& aIds)
    {
    HBufC8* response = NULL;
    HBufC8* content = NULL;
    ReadHeadersAndContentLC(response,content);
        
    // On one hand receive has to be renewed before calling the observer 
    // which might delete the CSIP or CSIPConnection, 
    // which leads to deletion of this object.
    // On the other hand for incoming SIP requests and responses 
    // asynchronous receive has to be called only after fetching 
    // the previous message syncrounously.
    // This is why ReceiveNext is called here instead of RunL. 
    ReceiveNext();        
    
    if (iHttpDigestObserver)
        {
        // The IPC place holder for response is used here for realm
        iHttpDigestObserver->ChallengeReceived(*response);
        CleanupStack::PopAndDestroy(content);
        }
    else if (iHttpDigestObserver2)
        {
	    RDesReadStream readStream(*response);
        CleanupClosePushL(readStream);
	    TUint8 isRequest = readStream.ReadUint8L();
	    __ASSERT_ALWAYS(!isRequest, User::Leave(KErrArgument));
		IncomingResponseL(readStream,content,aIds);
        readStream.Pop();
        readStream.Close();
        CleanupStack::Pop(content);
        }
    else
        {
        // No observer, should not happen, prevent memory leak
        CleanupStack::PopAndDestroy(content);
        }
        
    CleanupStack::PopAndDestroy(response);
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::IncomingMessageL
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::IncomingMessageL (TSIPIds& aIds)
    {
    HBufC8* headers = NULL;
    HBufC8* content = NULL;
    ReadHeadersAndContentLC(headers,content);
        
    // On one hand receive has to be renewed before calling the observer 
    // which might delete the CSIP or CSIPConnection, 
    // which leads to deletion of this object.
    // On the other hand for incoming SIP requests and responses 
    // asynchronous receive has to be called only after fetching 
    // the previous message syncrounously.
    // This is why ReceiveNext is called here instead of RunL. 
    ReceiveNext();        

	RDesReadStream readStream(*headers);
    CleanupClosePushL(readStream);
	TUint8 isRequest = readStream.ReadUint8L();
	if (isRequest)
		{
		IncomingRequestL(readStream,content,aIds);
		}
	else
		{
		IncomingResponseL(readStream,content,aIds);
		}
    readStream.Pop();
    readStream.Close();
    CleanupStack::Pop(content);
    CleanupStack::PopAndDestroy(headers);
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::IncomingRequestL
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::IncomingRequestL (RReadStream& aReadStream,
                                            HBufC8* aContent,
                                            TSIPIds& aIds)
    {
    __ASSERT_ALWAYS (aContent != 0, User::Leave(KErrArgument));

	CSIPRequestElements* request = 
        CSIPRequestElements::InternalizeL(aReadStream);
    CleanupStack::PushL(request);
    CSIPMessageElements& messageElements = request->MessageElements();
    messageElements.SetContent(aContent);
    CleanupStack::PushL(TCleanupItem(DetachContent,&messageElements));
    IncomingRequestL (aIds,request);
    CleanupStack::Pop(1); // cleanup item
    CleanupStack::Pop(request);
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::IncomingResponseL
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::IncomingResponseL (RReadStream& aReadStream,
                                             HBufC8* aContent,
										     TSIPIds& aIds)
	{
    __ASSERT_ALWAYS (aContent != 0, User::Leave(KErrArgument));

	CSIPResponseElements* response = 
        CSIPResponseElements::InternalizeL(aReadStream);
    CleanupStack::PushL(response);
    CSIPMessageElements& messageElements = response->MessageElements();
    messageElements.SetContent(aContent);
    CleanupStack::PushL(TCleanupItem(DetachContent,&messageElements));
    IncomingResponseL (aIds,response);
    CleanupStack::Pop(1); // cleanup item
    CleanupStack::Pop(response);
	}

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::DetachContent
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::DetachContent (TAny* aElements)
    {
    __SIP_ASSERT_RETURN(aElements, KErrGeneral);
    CSIPMessageElements* elements =
        reinterpret_cast<CSIPMessageElements*>(aElements);
    elements->DetachContent();
    }

// -----------------------------------------------------------------------------
// CSIPITCReceiverBase::ReadHeadersAndContentLC
// -----------------------------------------------------------------------------
//
void CSIPITCReceiverBase::ReadHeadersAndContentLC (HBufC8*& aHeaders,
                                                   HBufC8*& aContent)
    {
    TIpcArgs tmpITCArgs;

    TPckgBuf<TSIPIds> tmpIdsPckg;
    tmpITCArgs.Set (ESipItcArgIds, &tmpIdsPckg);

    HBufC8* headers = HBufC8::NewLC(iSizesPckg().iHeaderBufSize);
    TPtr8 headersPtr(headers->Des());
    tmpITCArgs.Set (ESipItcArgMessageHeaders, &headersPtr);

    HBufC8* content = HBufC8::NewLC(iSizesPckg().iContentBufSize);
    TPtr8 contentPtr(content->Des());
    tmpITCArgs.Set (ESipItcArgMessageContent, &contentPtr);

    TInt err = iITC.Receive(tmpITCArgs);
    if (err != KErrNone) 
        {
        User::Leave(err);
        }
    aHeaders = headers;
    aContent = content;
    }