// Copyright (c) 2007-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          : CSipCSSessionReceiver.cpp
// Part of       : SIPServerCore
// Version       : SIP/6.0 
//



#include "CSipCSSessionReceiver.h"
#include "CSipCSSession.h"
#include "TSipCSReceiveItem.h"
#include "sipinternalerr.h"
#include "siperr.h"
#include "CSipCSServerITC.h"
#include "CSIPCSSerializer.h"
#include "sipresponse.h"

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::NewL
// -----------------------------------------------------------------------------
//
CSipCSSessionReceiver* CSipCSSessionReceiver::NewL(CSipCSServerITC& aITC, 
                                                   MSipCSSession& aSession)
	{
    CSipCSSessionReceiver* self = CSipCSSessionReceiver::NewLC(aITC,aSession);
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::NewLC
// -----------------------------------------------------------------------------
//
CSipCSSessionReceiver* CSipCSSessionReceiver::NewLC(CSipCSServerITC& aITC,
                                                    MSipCSSession& aSession)
	{
    CSipCSSessionReceiver* self = 
        new(ELeave)CSipCSSessionReceiver(aITC,aSession);
    CleanupStack::PushL (self);
    self->ConstructL();
    return self;
	}

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::CSipCSSessionReceiver
// -----------------------------------------------------------------------------
//
CSipCSSessionReceiver::CSipCSSessionReceiver(CSipCSServerITC& aITC,
                                             MSipCSSession& aSession)
: CSipCSReceiverBase(aITC,*this),
  iHttpDigestObserverType(ESipNoHttpDigestObserver),
  iSession(aSession)
	{
	}

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::~CSipCSSessionReceiver
// -----------------------------------------------------------------------------
//
CSipCSSessionReceiver::~CSipCSSessionReceiver()
	{
	iPendingErrorItems.Close();
	}
	
// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::SetHttpDigestObserver
// -----------------------------------------------------------------------------
//	
void CSipCSSessionReceiver::SetHttpDigestObserver(
    TSipHttpDigestObserverType aType)
    {
    iHttpDigestObserverType = aType;
    }

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::MovePendingErrorsL
// -----------------------------------------------------------------------------
//    
void CSipCSSessionReceiver::MovePendingErrorsL(TUint32 aIapId,
                                               CSipCSReceiverBase& aReceiver)
    {
    for (TInt i=iPendingErrorItems.Count()-1; i >= 0; i--)
        {
        const TSipCSReceiveItem& item = iPendingErrorItems[i];
        if (item.Ids().iIapId == aIapId)
            {
            aReceiver.AddItemL(item);
            iPendingErrorItems.Remove(i);
            }
        }
    }

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::ReceiveL
// From MTransactionOwner:
// -----------------------------------------------------------------------------
//
void CSipCSSessionReceiver::ReceiveL(TUint32 aIapId,
                                     TTransactionId aTransactionId,
                                     CSIPRequest* aRequest)
	{
	MTransactionOwner& owner = iSession.FindOwner(aIapId);
    if (&owner == this)
        {
        SipRequestReceivedL(aIapId,aTransactionId,aRequest);
        }
    else
        {
        // Subsession with matching IAP ID exists. Route request to it.
        owner.ReceiveL(aIapId,aTransactionId,aRequest);
        }
	}
	
// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::TransactionEnded
// From MTransactionOwner:
// -----------------------------------------------------------------------------
//
TInt CSipCSSessionReceiver::TransactionEnded(TUint32 aIapId,
                                             TTransactionId aTransactionId,
                                             TInt aReason)
	{
	MTransactionOwner& owner = iSession.FindOwner(aIapId);
    if (&owner != this)
        {
        // Subsession with matching IAP ID exists. Route callback to it.
        return owner.TransactionEnded(aIapId,aTransactionId,aReason);
        }
    if (aReason != KErrTimedOut && aReason != KErrNone)
        {
        // For other errors than KErrTimedOut there is no callback
        // in SIP Client API. Put these errors waiting until the 
        // user has created CSIPConnection (C/S subsession).
	    TSIPIds ids;
	    ids.iIapId = aIapId;
	    ids.iRequestId = aTransactionId;        
        TSipCSReceiveItem item(ids,aReason);
        return iPendingErrorItems.Append(item);
        }
    return CSipCSReceiverBase::TransactionEnded(aIapId,aTransactionId,aReason);
	}	

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::ReceiveL
// From MTransactionOwner:
// -----------------------------------------------------------------------------
//
void CSipCSSessionReceiver::ReceiveL(TTransactionId /*aTransactionId*/,
                                     CSIPResponse* /*aResponse*/)
	{
    User::Leave(KErrNotSupported);
	}

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::PassOnlyRealmsToUser
// From MSIPSecUser:
// -----------------------------------------------------------------------------
//
TBool CSipCSSessionReceiver::PassOnlyRealmsToUser() const
    {
    return (iHttpDigestObserverType == ESipRealmHttpDigestObserver);
    }

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::RequestCredentialsL
// From MSIPSecUser:
// -----------------------------------------------------------------------------
//	
void CSipCSSessionReceiver::RequestCredentialsL(const TDesC8& aRealm)
    {
    __ASSERT_ALWAYS(iHttpDigestObserverType == ESipRealmHttpDigestObserver, 
                    User::Leave(KErrSIPForbidden));

    HBufC8* dummyContent = KNullDesC8().AllocLC();
    
    const TInt KRealmBufExpandSize = 50;
    CBufFlat* realmBuf = CBufFlat::NewL(KRealmBufExpandSize);
    CleanupStack::PushL(realmBuf);
    realmBuf->InsertL(0,aRealm);
    
    TSIPIds dummyIds;
    TSipCSReceiveItem item(dummyIds,realmBuf,dummyContent,
                           EFalse,KChallengeReceived);
                           
    HandleNewReceiveItemL(item);  
    
    CleanupStack::Pop(realmBuf);     
    CleanupStack::Pop(dummyContent);
    }
    
// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::RequestCredentialsL
// From MSIPSecUser:
// -----------------------------------------------------------------------------
//
void CSipCSSessionReceiver::RequestCredentialsL(CSIPResponse& aResponse,
	                                            TTransactionId aTransactionId,
	                                            TRefreshId aRefreshId)
    {
    __ASSERT_ALWAYS(iHttpDigestObserverType == ESipResponseHttpDigestObserver, 
                    User::Leave(KErrSIPForbidden));

	TSIPIds ids;
	ids.iRequestId = aTransactionId;
	ids.iRefreshId = aRefreshId;
                    
    CBufFlat* headers = iITC.Serializer().ExternalizeLC(aResponse);
    HBufC8* content = aResponse.Content().AllocLC();
    TSipCSReceiveItem item(ids,headers,content,EFalse,KChallengeReceived);

    HandleNewReceiveItemL(item);

    CleanupStack::Pop(content);
    CleanupStack::Pop(headers);                                    
    }

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::TrustedUser
// From MSIPSecUser:
// -----------------------------------------------------------------------------
//	
const MSIPSecUser* CSipCSSessionReceiver::TrustedUser(
    TRegistrationId aRegistrationId)
    {
    return iSession.SIPSecUser(aRegistrationId);
    }

// -----------------------------------------------------------------------------
// CSipCSSessionReceiver::ByPassSIPSec
// From MSIPSecUser:
// -----------------------------------------------------------------------------
//
TBool CSipCSSessionReceiver::ByPassSIPSec() const
    {
    return iSession.ByPassSIPSec();
    }