diff -r 78fbd574edf4 -r da856f45b798 zeroconf/server/src/mdnsserversession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/zeroconf/server/src/mdnsserversession.cpp	Thu Jun 24 19:09:47 2010 +0530
@@ -0,0 +1,732 @@
+// Copyright (c) 2008-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:
+// mdnsserversession.cpp
+// 
+//
+/**
+@file
+@internalTechnology
+*/
+
+#include "mdnsserversession.h"
+#include <s32mem.h>
+#include <utf.h>
+#include "mdnsserver.h"
+#include <mdns/cmdnsserverconstants.h>
+#include <f32file.h>
+__FLOG_STMT(_LIT8(KComponent,"MDNSServer");)
+/*
+ * Two phase constructor.
+ */
+CMdnsServerSession* CMdnsServerSession::NewL(const CMdnsServer& aServer)
+	{
+	CMdnsServerSession* self = CMdnsServerSession::NewLC(aServer);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+/*
+ * Two phase constructor
+ * @param aServer reference to the server.
+ */
+CMdnsServerSession* CMdnsServerSession::NewLC(const CMdnsServer& aServer)
+	{
+	CMdnsServerSession* self = new (ELeave) CMdnsServerSession(aServer);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+/*
+ * @param aMessage RMessage object.
+ */
+void CMdnsServerSession::ServiceL(const RMessage2& aMessage)
+	{
+	__FLOG(_L8("CMdnsServerSession::ServiceL - Entry"));
+	switch (aMessage.Function())
+		{
+	case EZeroconfServerMessageVersion:
+		break;
+		
+	case EMdnsServerQueryMessages:
+		{
+		if(NULL != iClientQuery.Handle())
+			{
+			aMessage.Complete(KErrInUse);	
+			}
+		else if (iServer.IsHostProbing() )
+            {
+            iServer.MessageQueue()->AppendMessageL(EQueryMessage,aMessage,SessionId());
+            }
+		else	
+			{
+			ServiceQueryL(aMessage);
+			}	
+		}
+		break;
+		
+	case EMdnsServerRecieveMessages:
+		{
+		HBufC8* buffer = HBufC8::NewLC(KDnsBufferlength);
+		TPtr8 bufferPointer(buffer->Des());
+		iResponseBundle.Store(bufferPointer);	
+		aMessage.Write(0,bufferPointer);	
+		CleanupStack::PopAndDestroy();//delete buffer
+		aMessage.Complete(KErrNone);
+		iResponseBundle.Close();
+		}	
+		break;
+	
+	case EMndsServerPublishMessages:
+	    {
+	    if( iServer.IsHostProbing() || iServer.IsPublishingService())
+	        {
+	        iServer.MessageQueue()->AppendMessageL(EPublishMessage,aMessage,SessionId());
+	        }
+	    else
+	        {
+	        iServer.SetPublishingService(ETrue);
+	        PublishL(aMessage);
+	        }
+	    break;
+	    }
+	case EMdnsServerStartNotifyMessages:
+	    {
+	    RegisterNotifyL(aMessage);
+	    aMessage.Complete(KErrNone);
+	    break;
+	    }
+	    
+	case EMdnsServerStopNotifyMessages:
+	    {
+	    StopNotifyL(aMessage);
+	    aMessage.Complete(KErrNone);
+	    break;
+	    }
+	    
+	case EMdnsServerRecieveNotifyMessages:
+	    {
+	    iNotifyMessageRequest = aMessage;
+	    break;
+	    }
+	default:
+		User::Leave(KErrUnknown);
+		break;
+		}
+	
+	__FLOG(_L8("CMdnsServerSession::ServiceL - Exit"));
+	}
+	
+void CMdnsServerSession::ServiceError(const RMessage2& aMessage, TInt aError)
+	{
+	__FLOG(_L8("CMdnsServerSession::ServiceError - Entry Exit"));
+	aMessage.Complete(aError);
+	}
+
+
+
+void CMdnsServerSession::CleanUp()
+    {
+    __FLOG(_L8("CMdnsServerSession::CleanUp - Entry"));
+    // First thing is to send bye-bye packets to the services that we have published.
+    
+    RPointerArray <CCacheEntry> cacheEntries;
+    iServer.MessageHandler().DnsCache().AuthoritativeEntriesL(cacheEntries);
+    
+    for(TInt index =0; index < cacheEntries.Count();index++)
+        {               
+        CCacheEntry* entry = cacheEntries[index];
+        if(entry->SessionId()==iSessionId)
+            {
+            // To filter out address records.
+            if(entry->ServiceRecord())
+                {
+                
+                // found the entry to be deleted
+                if(entry->ServiceRecord())
+                    entry->ServiceRecord()->SetTtl(0);
+                if(entry->TxtRecord())
+                    entry->TxtRecord()->SetTtl(0);
+                if(entry->PtrRecord())
+                    entry->PtrRecord()->SetTtl(0);
+                
+                // delete the entry in the cache
+                
+                // !!!!!! Assuming that the entry will always contain a srv record.
+                iServer.MessageHandler().DnsCache().DeleteEntryL(entry->ServiceRecord()->Name());
+                
+                CDnsMessage* message = CDnsMessage::NewL(0,EFalse);
+                CleanupStack::PushL(message);    
+                
+                TDnsHeader header(message->Header());
+                header.SetAuthoritative(ETrue);
+                message->SetHeader(header);
+                
+                if(entry->ServiceRecord())
+                message->AppendAnswerL(entry->ServiceRecord()->CloneL());
+                if(entry->PtrRecord())
+                message->AppendAnswerL(entry->PtrRecord()->CloneL());
+                if(entry->TxtRecord())
+                message->AppendAnswerL(entry->TxtRecord()->CloneL());
+    
+                // bye-bye packet on the way to the network !!!
+                iServer.MessageHandler().SendQueryL(message,iServer);
+                CleanupStack::Pop(); //message   
+                }
+            
+            }
+        }       
+    
+    
+    cacheEntries.ResetAndDestroy();
+    cacheEntries.Close();   
+    __FLOG(_L8("CMdnsServerSession::CleanUp - Exit"));
+    }
+/*
+ * Destructor
+ */
+CMdnsServerSession::~CMdnsServerSession()
+	{
+	__FLOG(_L8("CMdnsServerSession::~CMdnsServerSession - Entry"));
+	CleanUp();
+	iQueryBundle.Close();
+	iResponseBundle.Close();
+	iServer.DropSession();
+	for(TInt i =0 ; i<iRegisterNotifyArray.Count();i++ )
+	    {
+	    iRegisterNotifyArray[i].Close();
+	    }
+	iRegisterNotifyArray.Close();
+	__FLOG(_L8("CMdnsServerSession::~CMdnsServerSession - Exit"));
+	__FLOG_CLOSE;
+	}
+/*
+ * Constructor
+ */
+CMdnsServerSession::CMdnsServerSession(const CMdnsServer& aServer)
+	: iServer(const_cast<CMdnsServer&>(aServer))
+	{
+	iSessionId = iServer.NewSession();
+	}
+	
+/*
+ * Two phase constructor
+ */
+void CMdnsServerSession::ConstructL()
+	{
+	__FLOG_OPEN(KMDNSSubsystem, KComponent);
+	}
+
+//TODO
+TInt CMdnsServerSession::CountResources()
+	{
+	return 3;
+	}
+
+void CMdnsServerSession::ServerVersionL(const RMessage2& aMessage)
+	{
+	__FLOG(_L8("CMdnsServerSession::ServerVersionL - Entry"));
+	TVersion mdnsServerVersion(0, 8, 0);
+	TPckgC<TVersion> pkg(mdnsServerVersion);
+	aMessage.WriteL(0, pkg);
+	aMessage.Complete(KErrNone);
+	__FLOG(_L8("CMdnsServerSession::ServerVersionL - Exit"));
+
+	}
+/*
+ * Service any query rom the client
+ */
+void CMdnsServerSession::ServiceQueryL(const RMessage2& aMessage)
+	{
+	__FLOG(_L8("CMdnsServerSession::ServiceQueryL - Entry"));
+	iQueryBundle.Close();
+	iClientQuery = aMessage;
+	TInt len = aMessage.GetDesLengthL(0);
+	HBufC8* query = HBufC8::NewLC(aMessage.GetDesLengthL(0));
+	TPtr8 loadPtr = query->Des();
+	aMessage.ReadL(0,loadPtr);
+	iQueryBundle.CreateL();
+	TInt retOnLoad = iQueryBundle.Load(loadPtr);
+	User::LeaveIfError(retOnLoad);
+	RParameterFamily pnpFamily = iQueryBundle.GetFamilyAtIndex(0);
+	TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+	CDnsMessage* message = CDnsMessage::NewL(0,ETrue );
+	CleanupStack::PushL(message);
+	for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+		{ 
+		CMDnsQueryRequestParamSet* queryParam = static_cast<CMDnsQueryRequestParamSet*> (pnpFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+		HBufC8* name = HBufC8::NewL(256);
+		CleanupStack::PushL(name);
+		TPtr8 ptrName(name->Des());
+		ptrName.Append(queryParam->InstanceName());
+		if(queryParam->InstanceName().Length() > 0)
+			{
+			ptrName.Append(_L8("."));	
+			}
+		ptrName.Append(queryParam->ServiceType());
+		if(queryParam->QueryType() != EDnsType_A)
+			{
+			ptrName.Append(1 == queryParam->Protocol() ? KTcpProtocolType : KUdpProtocolType);	
+			}
+		ptrName.Append(KLocalTld);
+		ptrName.Append(_L8("."));
+		CDnsQuestion* question = CDnsQuestion::NewL();
+		CleanupStack::PushL(question);
+		question->SetNameL(ptrName);
+		question->SetClass(EDnsClass_IN);
+		question->SetType(queryParam->QueryType());
+		question->SetUnicast(EFalse);
+		message->AppendQueryL(question);
+		CleanupStack::Pop();
+		CleanupStack::PopAndDestroy();//name
+		}
+	iServer.MessageHandler().ServiceClientQueryL(message,aMessage.Handle());	
+	CleanupStack::Pop();//message
+	CleanupStack::PopAndDestroy();//query
+	__FLOG(_L8("CMdnsServerSession::ServiceQueryL - Exit"));
+	}
+
+TInt CMdnsServerSession::OutStandQueryClientHandle()const
+	{
+	return iClientQuery.Handle();	
+	}
+	
+void CMdnsServerSession::SendResponseL()
+	{
+	__FLOG(_L8("CMdnsServerSession::SendResponseL - Entry"));
+	RParameterFamily pnpFamily = iQueryBundle.GetFamilyAtIndex(0);
+	TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+	//Open a new reference to ResponseBundle 
+	iResponseBundle.Open ();
+	CleanupClosePushL( iResponseBundle );
+	for(TInt index =0 ;index <count ; index++)
+		{
+		CMDnsQueryRequestParamSet* queryParam = static_cast<CMDnsQueryRequestParamSet*> (pnpFamily.GetParameterSetAtIndex ( index, RParameterFamily::ERequested ));
+		HBufC8* name = HBufC8::NewL(KDnsBufferlength);
+		CleanupStack::PushL(name);
+		TPtr8 ptrName(name->Des());
+		ptrName.Append(queryParam->InstanceName());
+		if(queryParam->InstanceName().Size()>0)
+		    ptrName.Append(_L8("."));
+		ptrName.Append(queryParam->ServiceType());
+		if(queryParam->QueryType() != EDnsType_A)
+			{
+			ptrName.Append(1 == queryParam->Protocol() ? KTcpProtocolType : KUdpProtocolType);	
+			}
+		ptrName.Append(KLocalTld);
+		ptrName.Append(_L8("."));	
+		RPointerArray<CCacheEntry> records;
+		iServer.MessageHandler().DnsCache().FindServiceL(records,ptrName,(TDnsType)queryParam->QueryType());
+		TInt count = records.Count();
+		switch((TDnsType)queryParam->QueryType())	
+			{
+				case EDnsType_PTR:
+					{
+					RParameterFamily pnpFamily = iResponseBundle.CreateFamilyL (EMdnsPtrParamset);
+					while(count -- > 0 )
+						{
+						iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+						CMDnsPtrParamSet* responseParam = CMDnsPtrParamSet::NewL(pnpFamily);
+						responseParam->SetInstanceNameL(records[count]->PtrRecord()->Name());
+						responseParam->SetDomainNameL(records[count]->PtrRecord()->DomainName());
+						//responseParam->SetTtlL(records[count]->PtrRecord()->Ttl());
+						}
+					break;
+					}
+				case EDnsType_SRV:
+					{
+					RParameterFamily pnpFamily = iResponseBundle.CreateFamilyL (EMdnsSrvParamset);
+					while(count -- > 0 )
+						{
+						iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+						CMDnsSrvParamSet* responseParam = CMDnsSrvParamSet::NewL(pnpFamily);
+						responseParam->SetDomainNameL(records[count]->ServiceRecord()->Name());
+						responseParam->SetTargetL(records[count]->ServiceRecord()->Target());
+						responseParam->SetPriority(records[count]->ServiceRecord()->Priority());
+						responseParam->SetWeight(records[count]->ServiceRecord()->Weight());
+						responseParam->SetPort(records[count]->ServiceRecord()->Port());	
+						}
+					break;	
+					}
+				case EDnsType_TXT:
+					{
+					RParameterFamily pnpFamily = iResponseBundle.CreateFamilyL (EMdnsTxtParamset);
+					while(count -- > 0 )
+						{
+						iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+						CMDnsTxtParamSet* responseParam = CMDnsTxtParamSet::NewL(pnpFamily);
+						responseParam->SetDomainNameL(records[count]->TxtRecord()->Name());
+						RArray<RBuf8> txtData = records[count]->TxtRecord()->Text();
+						
+						for(TInt j=0;j<txtData.Count();j++)
+						    {
+						    responseParam->AppendTxtData(txtData[j]);
+						    }
+						}
+					break;
+					}
+				case EDnsType_A:
+					{
+					RParameterFamily pnpFamily = iResponseBundle.CreateFamilyL (EMdnsAddrParamset);
+					while(count -- > 0 )
+						{
+						iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+						CMDnsAddrParamSet* responseParam = CMDnsAddrParamSet::NewL(pnpFamily);
+						responseParam->SetDomainNameL(records[count]->AddressRecord()->Name());	
+						responseParam->SetAddress(records[count]->AddressRecord()->Address());
+						}
+					break;
+					}
+				case EDnsQType_Any:
+				    {
+				    iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+                    while(count -- > 0 )
+                         {
+                         CreateAnyQueryResponseL(*records[count]);
+                         }
+				    break;
+				    }
+					
+			}
+		records.ResetAndDestroy();
+		records.Close();	
+		CleanupStack::PopAndDestroy();//name	
+		}//end of for loop
+		
+		HBufC8* buffer = HBufC8::NewLC(KDnsBufferlength);	
+		TPtr8 bufferPointer(buffer->Des());
+		iResponseBundle.Store(bufferPointer);
+		TInt len = bufferPointer.Length();
+		TPckgC<TInt> lenbuf(len); 
+		iClientQuery.Write(1,lenbuf);
+		CleanupStack::PopAndDestroy();//buffer
+		iClientQuery.Complete(KErrNone);
+		CleanupStack::Pop();//iResponseBundle
+		__FLOG(_L8("CMdnsServerSession::SendResponseL - Exit"));	
+	}
+
+void CMdnsServerSession::PublishL(const RMessage2& aMessage)
+    {
+    __FLOG(_L8("CMdnsServerSession::PublishL - Entry"));
+    TBool isUpdate = aMessage.Int2();
+    iPublishRequest = aMessage;
+    TInt len = aMessage.GetDesLengthL(0);
+    HBufC8* query = HBufC8::NewLC(aMessage.GetDesLengthL(0));
+    TPtr8 loadPtr = query->Des();
+    aMessage.ReadL(0,loadPtr);
+    iPublishBundle.CreateL();
+    TInt retOnLoad = iPublishBundle.Load(loadPtr);
+    TInt familyCount = iPublishBundle.CountParameterFamilies();
+    RPointerArray<CDnsResourceData> publishRecordArray;
+    for(TInt i =0 ; i< familyCount; i++)
+        {
+        RParameterFamily pnpFamily = iPublishBundle.GetFamilyAtIndex(i);
+        switch (pnpFamily.Id())
+            {
+            case EMdnsSrvParamset:
+                {
+                TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+                for (TInt index= 0; index < count ; index++ )
+                    {
+                    CMDnsSrvParamSet* srvParamSet = static_cast<CMDnsSrvParamSet*> (pnpFamily.GetParameterSetAtIndex ( index, RParameterFamily::ERequested ));
+                    CRdTypeSrv* srvRecord = CRdTypeSrv::NewL();
+                    CleanupStack::PushL(srvRecord);
+                    srvRecord->SetNameL(srvParamSet->DomainName());
+                    srvRecord->SetClass(EDnsClass_IN);
+                    srvRecord->SetFlushBit(EFalse);
+                    srvRecord->SetPort(srvParamSet->Port()); 
+                    srvRecord->SetPriority(srvParamSet->Priority() );
+                    srvRecord->SetTargetL(iServer.HostName());
+                    srvRecord->SetTtl(120);
+                    srvRecord->SetType(EDnsType_SRV);
+                    srvRecord->SetWeight(srvParamSet->Weight());
+                    publishRecordArray.AppendL(srvRecord);
+                    CleanupStack::Pop();//CRdtypeSrv
+                    //Ptr Record
+                    /*
+                    CRdTypePtr* ptrRecord = CRdTypePtr::NewL();
+                    CleanupStack::PushL(ptrRecord);
+                    TInt pos = srvParamSet->DomainName().Locate('.');
+                    ptrRecord->SetNameL(srvParamSet->DomainName().Mid(pos+1));
+                    ptrRecord->SetClass(EDnsClass_IN);
+                    ptrRecord->SetFlushBit(EFalse);
+                    ptrRecord->SetTtl(120);
+                    ptrRecord->SetType(EDnsType_PTR);
+                    ptrRecord->SetDomainNameL(srvParamSet->DomainName());
+                    publishRecordArray.AppendL(ptrRecord);
+                    CleanupStack::Pop();
+                    */
+                    }
+                break;
+                }
+            case EMdnsPtrParamset:
+                {
+                //do nothing
+                TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+                for (TInt index= 0; index < count ; index++ )
+                     {
+                     CMDnsPtrParamSet* ptrParamSet = static_cast<CMDnsPtrParamSet*>(pnpFamily.GetParameterSetAtIndex( index, RParameterFamily::ERequested ));
+                     CRdTypePtr* ptrRecord = CRdTypePtr::NewL();
+                     CleanupStack::PushL(ptrRecord);
+                     ptrRecord->SetNameL(ptrParamSet->InstanceName());
+                     ptrRecord->SetClass(EDnsClass_IN);
+                     ptrRecord->SetFlushBit(EFalse);
+                     ptrRecord->SetTtl(120);
+                     ptrRecord->SetType(EDnsType_PTR);
+                     ptrRecord->SetDomainNameL(ptrParamSet->DomainName());
+                     publishRecordArray.AppendL(ptrRecord);
+                     CleanupStack::Pop();//Remove Ptr Record from the queue..
+                     }
+                break;
+                }
+            case EMdnsAddrParamset:
+                {
+                TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+                for (TInt index= 0; index < count ; index++ )
+                     {
+                     CMDnsAddrParamSet* addrParamSet = static_cast<CMDnsAddrParamSet*>(pnpFamily.GetParameterSetAtIndex( index, RParameterFamily::ERequested ));
+                     CRdTypeA* addrRecord = CRdTypeA::NewL();
+                     CleanupStack::PushL(addrRecord);
+                     addrRecord->SetAddr(addrParamSet->Address());
+                     addrRecord->SetNameL(addrParamSet->DomainName());
+                     addrRecord->SetClass(EDnsClass_IN);
+                     addrRecord->SetFlushBit(EFalse);
+                     addrRecord->SetTtl(120);
+                     addrRecord->SetType(EDnsType_A);
+                     publishRecordArray.AppendL(addrRecord);
+                     CleanupStack::Pop();//remove addrecord from the queue
+                     }
+                break;
+                }
+            case EMdnsTxtParamset:
+                {
+                TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+                for (TInt index= 0; index < count ; index++ )
+                     {
+                     CMDnsTxtParamSet* txtParamSet = static_cast<CMDnsTxtParamSet*>(pnpFamily.GetParameterSetAtIndex( index, RParameterFamily::ERequested ));
+                     CRdTypeTxt* txtRecord = CRdTypeTxt::NewL();
+                     CleanupStack::PushL(txtRecord);
+                     txtRecord->SetNameL(txtParamSet->DomainName());
+                     txtRecord->SetClass(EDnsClass_IN);
+                     txtRecord->SetFlushBit(EFalse);
+                     txtRecord->SetTtl(120);
+                     txtRecord->SetType(EDnsType_TXT);
+                     RArray<RBuf8> txtArray ;
+                     txtParamSet->TxtDataL(txtArray);
+                     TInt txtCnt = txtArray.Count();
+                     for(TInt count = 0; count < txtCnt ; count ++ )
+                         {
+                         txtRecord->AppendTextDataL(txtArray[count]);
+                         }
+                     txtArray.Close();
+                     publishRecordArray.AppendL(txtRecord);
+                     CleanupStack::Pop();//remove txtRecord from the queue..
+                     }
+                break;
+                }
+            }
+        
+        }
+    TRAPD(publishError ,iServer.MessageHandler().AdvertizePacketL(publishRecordArray,iSessionId , isUpdate));
+    if(publishError == KErrNotFound)
+        {
+        aMessage.Complete(KErrNotFound);
+        }
+    publishRecordArray.Close();
+    iPublishBundle.Close();
+    CleanupStack::PopAndDestroy(query);
+    __FLOG(_L8("CMdnsServerSession::PublishL - Exit"));
+    }
+    
+void CMdnsServerSession::HandleServiceNameConflictL(const RBuf8& aName,TInt aError)
+    {
+    __FLOG(_L8("CMdnsServerSession::HandleServiceNameConflictL - Entry"));
+    iResponseBundle.Open ();
+    CleanupClosePushL( iResponseBundle );
+    
+    RParameterFamily pnpFamily = iResponseBundle.CreateFamilyL (EMdnsPublishResponseParamset);
+    iResponseBundle.SetPnPObserver((MPnPObserver*)NULL);
+    
+    CMDnsPublishResponseParamSet* responseParam = CMDnsPublishResponseParamSet::NewL(pnpFamily);
+    responseParam->SetDomainNameL(aName);
+    responseParam->SetError(aError);
+
+    
+    TInt len = iResponseBundle.Length();
+    TPckgC<TInt> lenbuf(len); 
+    iPublishRequest.Write(1,lenbuf);
+    
+    iPublishRequest.Complete(KErrNone);
+    CleanupStack::Pop();//iResponseBundle
+    __FLOG(_L8("CMdnsServerSession::HandleServiceNameConflictL - Exit"));
+    }
+   
+void CMdnsServerSession::RegisterNotifyL(const RMessage2& aMessage)
+    {
+    __FLOG(_L8("CMdnsServerSession::RegisterNotifyL - Entry"));
+    iIsNotifyRequested = ETrue;
+    RPnPParameterBundle registerBundle;
+    TInt size = aMessage.GetDesLength(0);
+    HBufC8* registerbuf = HBufC8::NewLC(aMessage.GetDesLengthL(0));
+    TPtr8 loadPtr = registerbuf->Des();
+    aMessage.ReadL(0,loadPtr);
+    registerBundle.CreateL();
+    registerBundle.Load(loadPtr);
+    RParameterFamily pnpFamily = registerBundle.GetFamilyAtIndex(0);
+    TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+    for(TInt index =0 ; index<count ; index++)
+        {
+        CMDnsRegisterNotifyParamSet* registerParamSet = static_cast<CMDnsRegisterNotifyParamSet*>(pnpFamily.GetParameterSetAtIndex( index, RParameterFamily::ERequested ));
+        RBuf8 instanceName;
+        instanceName.CreateL(registerParamSet->InstanceName());
+        iRegisterNotifyArray.AppendL(instanceName);
+        }
+    registerBundle.Close();
+    CleanupStack::PopAndDestroy();//registerbuffer
+    __FLOG(_L8("CMdnsServerSession::RegisterNotifyL - Exit"));
+    }
+
+void CMdnsServerSession::StopNotifyL(const RMessage2& aMessage)
+    {
+    __FLOG(_L8("CMdnsServerSession::StopNotifyL - Entry"));
+    RPnPParameterBundle registerBundle;
+    TInt size = aMessage.GetDesLength(0);
+    HBufC8* registerbuf = HBufC8::NewLC(aMessage.GetDesLengthL(0));
+    TPtr8 loadPtr = registerbuf->Des();
+    aMessage.ReadL(0,loadPtr);
+    registerBundle.CreateL();
+    registerBundle.Load(loadPtr);
+    RParameterFamily pnpFamily = registerBundle.GetFamilyAtIndex(0);
+    TUint count = pnpFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+    for(TInt index =0 ; index< count; index++)
+        {
+        CMDnsRegisterNotifyParamSet* registerParamSet = static_cast<CMDnsRegisterNotifyParamSet*>(pnpFamily.GetParameterSetAtIndex( index, RParameterFamily::ERequested ));
+        RBuf8 instanceName;
+        instanceName.CreateL(registerParamSet->InstanceName());
+        for(TInt i =0 ; i< iRegisterNotifyArray.Count();i++)
+                {
+                if(instanceName.Compare(iRegisterNotifyArray[i]) == 0)
+                    {
+                    RBuf8& temp = iRegisterNotifyArray[i];
+                    iRegisterNotifyArray.Remove(i);
+                    temp.Close();
+                    }
+                }
+        instanceName.Close();
+        }
+    if(iRegisterNotifyArray.Count() == 0 )
+        {
+        iIsNotifyRequested =EFalse;
+        }
+    registerBundle.Close();
+    CleanupStack::PopAndDestroy();//registerbuffer
+    __FLOG(_L8("CMdnsServerSession::StopNotifyL - Exit"));
+    }
+
+TInt CMdnsServerSession::SessionId()
+    {
+    __FLOG(_L8("CMdnsServerSession::SessionId - Exit"));
+    return iSessionId;
+    }
+void CMdnsServerSession::NewServiceL(const RArray<RBuf8>& aName)
+    {
+    __FLOG(_L8("CMdnsServerSession::NewServiceL - Entry"));
+    if(iIsNotifyRequested && iNotifyMessageRequest.Handle())
+        {
+        RPnPParameterBundle publishBundle;
+        publishBundle.CreateL();
+        RParameterFamily pnpFamily = publishBundle.CreateFamilyL (EMdnsPtrParamset);
+        publishBundle.SetPnPObserver((MPnPObserver*)NULL);
+        for(TInt i =0 ; i < aName.Count();i++)
+            {
+            for(TInt j= 0 ; j< iRegisterNotifyArray.Count(); j++)
+                {
+                TInt pos = aName[i].Find(iRegisterNotifyArray[j]);
+                if(pos != KErrNotFound)
+                    {
+                    CMDnsPtrParamSet* responseParam = CMDnsPtrParamSet::NewL(pnpFamily);
+                    responseParam->SetInstanceNameL(iRegisterNotifyArray[j]);
+                    responseParam->SetDomainNameL(aName[i]); 
+                    // have to fill up the ttl field, query the cache
+                    RPointerArray <CCacheEntry>  aEntries;
+                    iServer.MessageHandler().DnsCache().FindServiceL(aEntries,aName[i],EDnsType_SRV);
+                    responseParam->SetTtlL(0);
+                    if(aEntries.Count()==0)
+                        {
+                        // already deleted from cache
+                        responseParam->SetTtlL(0);
+                        }
+                    else if(aEntries[0]->PtrRecord()!=NULL)
+                        {
+                        responseParam->SetTtlL(aEntries[0]->PtrRecord()->Ttl());
+                        }
+                    aEntries.ResetAndDestroy();
+                    aEntries.Close();    
+                    break;
+                    }
+                }
+            }
+        HBufC8* buffer = HBufC8::NewLC(KDnsBufferlength);   
+        TPtr8 bufferPointer(buffer->Des());
+        publishBundle.Store(bufferPointer);
+        iNotifyMessageRequest.Write(0,bufferPointer);
+        iNotifyMessageRequest.Complete(KErrNone);
+        CleanupStack::PopAndDestroy(buffer);//buffer
+        publishBundle.Close();
+        }
+    __FLOG(_L8("CMdnsServerSession::NewServiceL - Exit"));
+    }
+
+
+void CMdnsServerSession::CreateAnyQueryResponseL(CCacheEntry& aEntry)
+    {
+    RParameterFamily ptrFamily = iResponseBundle.CreateFamilyL (EMdnsPtrParamset);
+    RParameterFamily srvFamily = iResponseBundle.CreateFamilyL (EMdnsSrvParamset);
+    RParameterFamily txtFamily = iResponseBundle.CreateFamilyL (EMdnsTxtParamset);
+    RParameterFamily AFamily = iResponseBundle.CreateFamilyL (EMdnsAddrParamset);
+    if(aEntry.AddressRecord()!= NULL)
+        {
+        CMDnsAddrParamSet* responseParam = CMDnsAddrParamSet::NewL(AFamily);
+        responseParam->SetDomainNameL(aEntry.AddressRecord()->Name()); 
+        responseParam->SetAddress(aEntry.AddressRecord()->Address());
+        }
+    if(aEntry.ServiceRecord()!= NULL)
+        {
+        CMDnsSrvParamSet* responseParam = CMDnsSrvParamSet::NewL(srvFamily);
+        responseParam->SetDomainNameL(aEntry.ServiceRecord()->Name());
+        responseParam->SetTargetL(aEntry.ServiceRecord()->Target());
+        responseParam->SetPriority(aEntry.ServiceRecord()->Priority());
+        responseParam->SetWeight(aEntry.ServiceRecord()->Weight());
+        responseParam->SetPort(aEntry.ServiceRecord()->Port());
+        }
+    if(aEntry.PtrRecord()!= NULL)
+        {
+        CMDnsPtrParamSet* responseParam = CMDnsPtrParamSet::NewL(ptrFamily);
+        responseParam->SetInstanceNameL(aEntry.PtrRecord()->Name());
+        responseParam->SetDomainNameL(aEntry.PtrRecord()->DomainName());
+        //responseParam->SetTtlL(aEntry.PtrRecord()->Ttl());
+        }
+    if(aEntry.TxtRecord()!= NULL)
+        {
+        CMDnsTxtParamSet* responseParam = CMDnsTxtParamSet::NewL(txtFamily);
+        responseParam->SetDomainNameL(aEntry.TxtRecord()->Name());
+        RArray<RBuf8> txtData = aEntry.TxtRecord()->Text();
+        for(TInt txtCount = 0 ;txtCount < txtData.Count();txtCount++)
+            {
+            responseParam->AppendTxtData(txtData[txtCount]);
+            }
+        }
+    
+    }