// Copyright (c) 2005-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          : CSipCSReceiverBase.cpp

// Part of       : SIPServerCore

// Version       : SIP/4.0 

//

#include "CSipCSReceiverBase.h"

#include "CSipCSReceiveQueue.h"

#include "CSipCSServerITC.h"

#include "CSIPCSSerializer.h"

#include "sipmessage.h"

#include "siprequest.h"

#include "SipAssert.h"

#include "sipinternalerr.h"

#include "SipLogs.h"

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

// CSipCSReceiverBase::ConstructL

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

//

void CSipCSReceiverBase::ConstructL()

	{

    iReceiveQueue = new(ELeave)CSipCSReceiveQueue;

	}

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

// CSipCSReceiverBase::CSipCSReceiverBase

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

//

CSipCSReceiverBase::CSipCSReceiverBase(CSipCSServerITC& aITC,

                                       MSIPSecUser& aSIPSecUser)

: iITC (aITC),

  iSIPSecUser (aSIPSecUser),

  iClientReadyToReceive (EFalse)

	{

	}

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

// CSipCSReceiverBase::~CSipCSReceiverBase

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

//

CSipCSReceiverBase::~CSipCSReceiverBase()

	{

    delete iReceiveQueue;

	}

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

// CSipCSReceiverBase::WriteSipMessageToClientL

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

//

void CSipCSReceiverBase::WriteSipMessageToClientL(const RMessage2& aMessage)

	{

    __ASSERT_ALWAYS (!iReceiveQueue->IsEmpty(), User::Leave (KErrNotFound));

    __ASSERT_ALWAYS (iReceiveQueue->First().Headers() != 0, 

                     User::Leave (KErrNotFound));

    __ASSERT_ALWAYS (iReceiveQueue->First().Content() != 0,

                     User::Leave (KErrNotFound));

    iITC.WriteL (aMessage, *iReceiveQueue->First().Headers());

    iITC.WriteL (aMessage, *iReceiveQueue->First().Content(), 

                 ESipItcArgMessageContent);

    iReceiveQueue->RemoveFirst();

	}

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

// CSipCSReceiverBase::ClientReadyToReceiveL

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

//

void CSipCSReceiverBase::ClientReadyToReceiveL(const RMessage2& aMessage)

	{

    __ASSERT_ALWAYS (!iClientReadyToReceive, User::Leave (KErrAlreadyExists));

    if (iReceiveQueue->IsEmpty())

		{

        iClientReadyToReceive = ETrue;

        iReceiveRMessage = aMessage;

		}

    else

		{

        const TSipCSReceiveItem& item = iReceiveQueue->First();

        TInt error = item.Error();

        iITC.WriteL (aMessage,item.Ids());

        if (error == KErrNone || error == KChallengeReceived)

            {

            iITC.WriteL (aMessage,item.BufSizes());

            }

        else

            {

            iReceiveQueue->RemoveFirst();

            }

        iITC.Complete (aMessage,error);

		}

	}

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

// CSipCSReceiverBase::CancelClientReceiveL

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

//

void CSipCSReceiverBase::CancelClientReceiveL()

	{

    __ASSERT_ALWAYS (iClientReadyToReceive, User::Leave (KErrNotFound));

    iClientReadyToReceive = EFalse;

    iITC.Complete (iReceiveRMessage, KErrCancel);

	}

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

// CSipCSReceiverBase::AddItemL

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

//	

void CSipCSReceiverBase::AddItemL(const TSipCSReceiveItem& aReceiveItem)

    {

    HandleNewReceiveItemL(aReceiveItem);

    }

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

// CSipCSReceiverBase::TransactionEnded

// From MTransactionOwner:

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

//

TInt CSipCSReceiverBase::TransactionEnded(TUint32 aIapId,

                                          TTransactionId aTransactionId,

                                          TInt aReason)

	{

	TSIPIds ids;

	ids.iIapId = aIapId;

	ids.iRequestId = aTransactionId;

	return ErrorReceived(ids,aReason);

	}

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

// CSipCSReceiverBase::NextCSeq

// From MTransactionOwner:

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

//

TInt CSipCSReceiverBase::NextCSeq(TUint& aCSeq)

    {

    aCSeq++;

    return KErrNone;

    }

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

// CSipCSReceiverBase::SIPSecUser

// From MTransactionOwner:

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

//    

const MSIPSecUser* CSipCSReceiverBase::SIPSecUser() const

    {

    return &(iSIPSecUser);

    }

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

// CSipCSReceiverBase::SipRequestReceivedL

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

//

void CSipCSReceiverBase::SipRequestReceivedL(TUint32 aIapId,

                                             TTransactionId aTransactionId,

                                             CSIPRequest* aRequest)

	{

	TSIPIds ids;

    ids.iIapId = aIapId;

	ids.iRequestId = aTransactionId;

    SipMessageReceivedL(ids,aRequest);

	}

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

// CSipCSReceiverBase::SipMessageReceivedL

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

//

void CSipCSReceiverBase::SipMessageReceivedL(const TSIPIds& aIds,

                                             CSIPMessage* aSipMessage)

    {

    __ASSERT_ALWAYS (aSipMessage, User::Leave(KErrArgument));

    __SIP_MESSAGE_LOG ("ServerCore: ReceiveL",*aSipMessage)

    CBufFlat* headers = iITC.Serializer().ExternalizeLC(*aSipMessage);

    HBufC8* content = aSipMessage->TakeContentOwnershipL();

    CleanupStack::PushL (content);

    TSipCSReceiveItem item(aIds,headers,content,aSipMessage->IsRequest());

    HandleNewReceiveItemL(item);

    CleanupStack::Pop(content);

    CleanupStack::Pop(headers);

    delete aSipMessage;

    }

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

// CSipCSReceiverBase::HandleNewReceiveItemL

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

//       

void CSipCSReceiverBase::HandleNewReceiveItemL(const TSipCSReceiveItem& aItem)

    {

    if (iClientReadyToReceive)

        {

        iITC.WriteL (iReceiveRMessage,aItem.Ids());

        iITC.WriteL (iReceiveRMessage,aItem.BufSizes());

        User::LeaveIfError(iReceiveQueue->AddLast(aItem));

        iITC.Complete (iReceiveRMessage,aItem.Error());

        iClientReadyToReceive = EFalse;

        }

    else

        {

        User::LeaveIfError(iReceiveQueue->AddLast(aItem));

        }     

    }

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

// CSipCSReceiverBase::ErrorReceived

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

//

TInt CSipCSReceiverBase::ErrorReceived(const TSIPIds& aIds, TInt aError)

    {

    TInt err = KErrNone;

    if (aError != KErrNone)

        {

        if (iClientReadyToReceive)

            {

            TRAP (err, iITC.WriteL (iReceiveRMessage,aIds));

            if (err == KErrNone)

                {

                iITC.Complete(iReceiveRMessage,aError);

                iClientReadyToReceive = EFalse;

                }

            }

        else

        	{

            TSipCSReceiveItem item(aIds,aError);

            err = iReceiveQueue->AddLast(item);       		

        	}

        if (aError == KErrTimedOut && err == KErrNone)

        	{

        	// In case a transaction times out before a client

        	// has received the SIP request related to the transaction

        	// these SIP requests are dropped.

        	iReceiveQueue->RemoveSIPRequestsWith(aIds.iRequestId);

        	}

        }

    return err;

    }