--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/ClientResolver/Server/src/CSIPCRSessionReceiver.cpp	Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,285 @@
+// 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          : CSipCRSessionReceiver.cpp
+// Part of       : SIP Client Resolver
+// Version       : 1.0
+//
+
+
+
+// INCLUDES
+#include "CSIPCRSessionReceiver.h"
+#include "CSIPCRResponseQueue.h"
+#include "CSIPCRITCUtility.h"
+#include "CSIPCRResponseItem.h"
+#include "sipresponse.h"
+#include "SIPCRSerializer.h"
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::NewLC
+// ----------------------------------------------------------------------------
+//
+CSIPCRSessionReceiver* CSIPCRSessionReceiver::NewL(CSIPCRITCUtility& aITC)
+    {
+    CSIPCRSessionReceiver* self = CSIPCRSessionReceiver::NewLC(aITC);
+    CleanupStack::Pop (self);
+    return self;
+    }
+    
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::NewLC
+// ----------------------------------------------------------------------------
+//
+CSIPCRSessionReceiver* CSIPCRSessionReceiver::NewLC(CSIPCRITCUtility& aITC)
+    {
+    CSIPCRSessionReceiver* self = new(ELeave)CSIPCRSessionReceiver (aITC);
+    CleanupStack::PushL(self);
+    self->ConstructL ();
+    return self;
+	}
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::ConstructL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::ConstructL()
+    {
+    User::LeaveIfError(iReceiverMutex.CreateLocal());
+    iResponseQueue = new(ELeave)CSIPCRResponseQueue;
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::~CSIPCRSessionReceiver
+// ----------------------------------------------------------------------------
+//
+CSIPCRSessionReceiver::~CSIPCRSessionReceiver()
+	{
+	delete iResponseQueue;
+	iReceiverMutex.Close();
+	}
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::ConstructL
+// ----------------------------------------------------------------------------
+//
+CSIPCRSessionReceiver::CSIPCRSessionReceiver(CSIPCRITCUtility& aITC)
+: iITC(aITC),
+  iClientReadyToReceive(EFalse)
+    {
+    }
+    
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::ClientReadyToReceiveL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::ClientReadyToReceiveL(const RMessage2& aMessage)
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    __ASSERT_ALWAYS (!iClientReadyToReceive, User::Leave (KErrAlreadyExists));
+
+    if (iResponseQueue->IsEmpty())
+		{
+        iClientReadyToReceive = ETrue;
+        iReceiveRMessage = aMessage;
+		}
+    else
+        {
+        CSIPCRResponseItem& item = iResponseQueue->First();
+        TInt error = item.Error();
+        iITC.WriteRequestIdL(aMessage, item.RequestId());
+        if (error == KErrNone)
+            {
+            if (item.SIPResponse() == 0)
+                {
+                iITC.WriteClientResolvedL(aMessage, ESIPCRChannelComplete);
+                iITC.WriteChannelUidL(aMessage,item.Channel());
+                iResponseQueue->RemoveFirst();
+                }
+            else
+                {
+                iITC.WriteClientResolvedL(aMessage, ESIPCRClientNotFound);
+                iITC.WriteResponseSizeL(aMessage, item.BufSizes());
+                }
+            }
+        else
+            {
+            iResponseQueue->RemoveFirst();
+            }
+        iITC.Complete (aMessage,error);
+        }
+        
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::CancelClientReceiveL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::CancelClientReceiveL()
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    __ASSERT_ALWAYS (iClientReadyToReceive, User::Leave (KErrNotFound));
+    iClientReadyToReceive = EFalse;
+    iITC.Complete (iReceiveRMessage, KErrCancel);
+    
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::WriteSipResponseToClientL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::WriteSipResponseToClientL(
+    const RMessage2& aMessage)
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    __ASSERT_ALWAYS (!iResponseQueue->IsEmpty(), User::Leave (KErrNotFound));
+    CSIPCRResponseItem& item = iResponseQueue->First();
+    __ASSERT_ALWAYS (item.RequestId() != 0,User::Leave (KErrGeneral));
+    __ASSERT_ALWAYS (item.SIPResponse() != 0,User::Leave (KErrGeneral));
+    __ASSERT_ALWAYS (item.SIPResponseContent() != 0,User::Leave (KErrGeneral));   
+    iITC.WriteSIPResponseL(aMessage, *item.SIPResponse());
+    iITC.WriteSIPResponseContentL(aMessage, *item.SIPResponseContent());
+    iResponseQueue->RemoveFirst();
+    
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::AddErrorResponseL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::AddErrorResponseL(
+    TUint32 aRequestId, 
+    CSIPResponse* aResponse)
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    __ASSERT_ALWAYS (aResponse, User::Leave(KErrArgument));  
+    CBufFlat* response = SIPCRSerializer::ExternalizeL(*aResponse);
+    CleanupStack::PushL(response);
+    HBufC8* content = aResponse->TakeContentOwnershipL();
+    CleanupStack::PushL(content);
+    CSIPCRResponseItem* item = 
+        new(ELeave)CSIPCRResponseItem(aRequestId,response,content);
+    CleanupStack::Pop(content);
+    CleanupStack::Pop(response);
+    CleanupStack::PushL(item);    
+    if (iClientReadyToReceive)
+        {
+        iITC.WriteRequestIdL(iReceiveRMessage, aRequestId);
+        iITC.WriteClientResolvedL(iReceiveRMessage, ESIPCRClientNotFound);
+        iITC.WriteResponseSizeL(iReceiveRMessage, item->BufSizes());
+        User::LeaveIfError(iResponseQueue->AddLast(item));
+        iITC.Complete (iReceiveRMessage,KErrNone);
+        iClientReadyToReceive = EFalse;
+        }
+    else
+        {
+        User::LeaveIfError(iResponseQueue->AddLast(item));
+        }
+    CleanupStack::Pop(item);
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex 
+    
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::RequestCompletedL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::RequestCompletedL(
+    TUint32 aRequestId, 
+    TUid aChannel)
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    __ASSERT_ALWAYS (aChannel.iUid != 0, User::Leave(KErrArgument));
+    __ASSERT_ALWAYS (aRequestId, User::Leave(KErrArgument));
+    if (iClientReadyToReceive)
+        {
+        iITC.WriteRequestIdL(iReceiveRMessage, aRequestId);
+        iITC.WriteClientResolvedL(iReceiveRMessage, ESIPCRChannelComplete);
+        iITC.WriteChannelUidL(iReceiveRMessage, aChannel);
+        iITC.Complete (iReceiveRMessage,KErrNone);
+        iClientReadyToReceive = EFalse;
+        }
+    else
+        {
+        CSIPCRResponseItem* item = 
+            new(ELeave)CSIPCRResponseItem(aRequestId,aChannel);
+        CleanupStack::PushL(item);
+        User::LeaveIfError(iResponseQueue->AddLast(item));
+        CleanupStack::Pop(item);
+        }
+        
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
+    }
+    
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::ErrorReceivedL
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::ErrorReceivedL(
+    TUint32 aRequestId,
+    TInt aError)   
+    {
+    CSIPCRITCUtility::WaitForMutexLC(iReceiverMutex);
+    
+    if (aError != KErrNone)
+        {
+        if (iClientReadyToReceive)
+            {
+            iITC.WriteRequestIdL (iReceiveRMessage, aRequestId);
+            iITC.Complete(iReceiveRMessage,aError);
+            iClientReadyToReceive = EFalse;
+            }
+        else
+            {
+            CSIPCRResponseItem* item = 
+                new(ELeave)CSIPCRResponseItem(aRequestId,aError);
+            CleanupStack::PushL(item);
+            User::LeaveIfError(iResponseQueue->AddLast(item));
+            CleanupStack::Pop(item);
+            }
+        }
+        
+    CleanupStack::PopAndDestroy(); // signals iReceiverMutex     
+    }
+
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::RemoveByRequestId
+// ----------------------------------------------------------------------------
+//
+void CSIPCRSessionReceiver::RemoveByRequestId(TUint32 aRequestId)
+    {
+    iReceiverMutex.Wait();
+    iResponseQueue->RemoveByRequestId(aRequestId);
+    iReceiverMutex.Signal();
+    }
+    
+// ----------------------------------------------------------------------------
+// CSIPCRSessionReceiver::RemoveAll
+// ----------------------------------------------------------------------------
+//    
+void CSIPCRSessionReceiver::RemoveAll()
+    {
+    iReceiverMutex.Wait();
+    iResponseQueue->RemoveAll();
+    iReceiverMutex.Signal();
+    }
+
+// End of File