// 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:
// mdnsserver.cpp
// 
//
/**
@file
@internalTechnology
*/

#include "mdnsserver.h"
#include <commdbConnpref.h>
#include "mdnsserversession.h"
#include "shutdowntimer.h"
#include "cmessagehandler.h"
#include "cmdnscacheconsistencymgr.h"
#include <mdns/cmdnsserverconstants.h>
#include "cmdnsprobemanager.h"
#include <nifman.h>
#include <comms-infras/es_config.h> 
#include <EscapeUtils.h>
#include <ecom/ECom.h> 
#include <btengsettings.h>// Console
#include "cengsettingsobserver.h"
__FLOG_STMT(_LIT8(KComponent,"MDNSServer");)
CMdnsServer* CMdnsServer::NewL()
	{

	CMdnsServer* self = CMdnsServer::NewLC();
	CleanupStack::Pop(self);

	return self;
	}
	
/*
 * Two phase constructor
 */
CMdnsServer* CMdnsServer::NewLC()
	{
	CMdnsServer* self = new (ELeave) CMdnsServer;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

/*
 * Derived from CPolicy server
 * Creates a new session object.
 */
CSession2* CMdnsServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const
	{
	__FLOG(_L8("CMdnsServer::NewSessionL - Entry"));
	// if we're in the process of shutting the server down cleanly,
	// don't accept any more connections.
	if (iShutdownInProgress)
		{
		User::Leave(KErrCouldNotConnect);
		}
	
	CMdnsServerSession* session = CMdnsServerSession::NewL(*this);
	__FLOG(_L8("CMdnsServer::NewSessionL - Exit"));
	return session;
	}
	
TInt CMdnsServer::NewSession()
	{
	__FLOG(_L8("CMdnsServer::NewSession - Entry"));
	iShutdownTimer->Cancel();
	++iConnectionCount;
	++iSessionIdCounter;
	__FLOG(_L8("CMdnsServer::NewSession - Exit"));
	return iSessionIdCounter;
	}
	
void CMdnsServer::DropSession()
	{
	__FLOG(_L8("CMdnsServer::DropSession - Entry"));
	if (0 == --iConnectionCount)
		{
		//CActiveScheduler::Stop();
		iShutdownTimer->Start();
		}
	__FLOG(_L8("CMdnsServer::DropSession - Exit"));
	}
	
void CMdnsServer::BeginShutdownL()
	{
	__FLOG(_L8("CMdnsServer::BeginShutdownL - Entry"));
	iShutdownInProgress = ETrue;
	CActiveScheduler::Stop();
	__FLOG(_L8("CMdnsServer::BeginShutdownL - Exit"));
	}
	
/*
 * Destructor
 */
CMdnsServer::~CMdnsServer()
	{
	__FLOG(_L8("CMdnsServer::~CMdnsServer - Entry"));
	iCacheConsistencyMgr->Stop();
	delete iShutdownTimer;
	delete iMessageHandler;
	delete iProbeManager;
	delete iInternalMessageQueue;
	delete iCacheConsistencyMgr;
	iConnection.Close();
	iSockServ.Close();
	iHostName.Close();
	REComSession::FinalClose();
	__FLOG(_L8("CMdnsServer::~CMdnsServer - Exit"));
	__FLOG_CLOSE;
	}

CMdnsServer::CMdnsServer()
	: CPolicyServer(EPriorityStandard, zeroconfPolicy),iConnectionCount(0),iSessionIdCounter(0)
	{
	}

/*
 * Get the system ipaddress by amaking a query to the dns.
 * @param aAddr on return contains the address.
 */
TInt CMdnsServer::GetLocalHost ( TSockAddr& aAddr )
    {
    __FLOG(_L8("CMdnsServer::GetLocalHost - Entry"));
    RSocket socket;
    TInt err = socket.Open ( iSockServ, KAfInet, KSockStream, KProtocolInetTcp );

    if ( err == KErrNone )
        {
        TInetAddr localHost;
        localHost.SetAddress ( KInetAddrAny );
        TPckgBuf<TSoInetIfQuery> query;
        query ().iDstAddr = localHost;

        err = socket.GetOpt ( KSoInetIfQueryByDstAddr, KSolInetIfQuery, query );

        if ( err == KErrNone )
            {
            // its local IP address
            localHost = query ().iSrcAddr;
            aAddr = localHost;
            TBuf<255>name ;
            name.Append(query ().iName);
            }
        }

    socket.Close ();
    __FLOG(_L8("CMdnsServer::GetLocalHost - Exit"));
    return err;
    }

/*
 * Two phase constructor
 */
void CMdnsServer::ConstructL()
	{
	__FLOG_OPEN(KMDNSSubsystem, KComponent);
	__FLOG(_L8("CMdnsServer::ConstructL - Entry"));
	User::LeaveIfError(iSockServ.Connect());
	User::LeaveIfError(iConnection.Open(iSockServ));
	
	// fetch the IAP from the command line
	HBufC* iapBuf = HBufC::NewLC(User::CommandLineLength());
	TPtr iapPtr = iapBuf->Des();
	User::CommandLine(iapPtr);
	
	TUint32 iap(0);
	TLex lex(*iapBuf);
	User::LeaveIfError(lex.Val(iap, EDecimal));
	
	CleanupStack::PopAndDestroy(iapBuf);
	
	// start a connection with the appropriate IAP
	TCommDbConnPref prefs;
	prefs.SetIapId(iap);
	prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
	User::LeaveIfError(iConnection.Start(prefs));
		
	User::LeaveIfError(iSocket.Open(iSockServ, KAfInet, KSockDatagram, KProtocolInetUdp));
	User::LeaveIfError(iSocket.SetLocalPort(KMdnsPort));
	TInetAddr broadcast;
	//To be added in constant header
	const TUint32 KMDnsAddr = INET_ADDR(224, 0, 0, 251);
	broadcast.SetAddress(KMDnsAddr);
	JoinMulticastGroupL(broadcast);
	iMessageHandler = CMessageHandler::NewL(*this);
	iShutdownTimer = CShutdownTimer::NewL(*this);
	/***************************************PROBE**************************************************/
	 //From here : Probe only for Host Name
    iProbeManager = CMDNSProbeManager::NewL(iMessageHandler->DnsCache(),*iMessageHandler,ETrue);
    TInetAddr addr;
    GetLocalHost(addr);
    //iHostName.Create(_L8("vadan.Local")); 
    CEngSettingsObserver* observer = CEngSettingsObserver::NewLC();
            
    CBTEngSettings* btsettings= CBTEngSettings::NewL(observer);
    
    RBuf name;
    name.CreateL(64);
    btsettings->GetLocalName(name);
    if(name.Length()==0)
        {
        iHostName.CreateL(_L8("MyNokiaPhone.Local"));
        }
    else
        {
        name.Append(_L(".local"));    
        iHostName.CreateL(name.Collapse());
        }    
    
    iProbeManager->StartNameProbeL(iHostName,addr);
    /*****************************************END**************************************************/
    iInternalMessageQueue = CInternalMessageQueue::NewL(*this);
    /*****************************************ConsistencyMgr***************************************/
    iCacheConsistencyMgr = CMDNSCacheConsistencyMgr::NewL(ETrue,*iMessageHandler);
    iCacheConsistencyMgr->Start();
	// start up the server
	StartL(KMdnsServerName);
	__FLOG(_L8("CMdnsServer::ConstructL - Exit"));
	}
/*
 * Interface to join the multicast group.
 * @param aMulticastAddr specifies the multicast address to which it will join
 * this is generally the mdns multicast address.
 */
void CMdnsServer::JoinMulticastGroupL(TInetAddr& aMulticastAddr)
	{
	__FLOG(_L8("CMdnsServer::JoinMulticastGroupL - Entry"));
	TPckgBuf<TIp6Mreq> mReq;
	
	if (aMulticastAddr.Family() != KAfInet6)
		{
		aMulticastAddr.ConvertToV4Mapped();
		}
		
	mReq().iAddr =  aMulticastAddr.Ip6Address();
	mReq().iInterface = 0;
	User::LeaveIfError(iSocket.SetOpt(KSoIp6MulticastHops, KSolInetIp, 255));
	User::LeaveIfError(iSocket.SetOpt(KSoIp6JoinGroup, KSolInetIp, mReq));
	User::LeaveIfError(iSocket.SetOpt(KSoIp6MulticastLoop, KSolInetIp, 0));
	__FLOG(_L8("CMdnsServer::JoinMulticastGroupL - Exit"));
	}

/*
 * @return returns the reference to the socket.
 */
RSocket& CMdnsServer::Socket()
	{
	__FLOG(_L8("CMdnsServer::Socket -Entry  Exit"));
	return iSocket;	
	}
/*
 * returns the reference to messagehandler.
 */
CMessageHandler& CMdnsServer::MessageHandler()const
	{
	__FLOG(_L8("CMdnsServer::MessageHandler -Entry Exit"));
	return *iMessageHandler;
	}		

/*
 * Query from the client should be served after a delay .If sent to the 
 * network. usually 120ms. 
 * Server will be notified with the same after the time elapses.
 * @param aClientHandle session id which actually requested for the query .
 * 
 * */
void CMdnsServer::NotifyClientQuery(TInt aClientHandle)
	{
	__FLOG(_L8("CMdnsServer::NotifyClientQuery - Entry"));
	iSessionIter.SetToFirst();
	CSession2* session = NULL;
	while (NULL != (session = iSessionIter++))
		{
		CMdnsServerSession* serverSession = static_cast<CMdnsServerSession*>(session);
		if(serverSession->OutStandQueryClientHandle() == aClientHandle)
			{
			serverSession->SendResponseL();	
			}
		}	
	__FLOG(_L8("CMdnsServer::NotifyClientQuery - Exit"));
	}

/*
 * Returns the hostname with which it has been probed.
 */
TDesC8& CMdnsServer::HostName()const
    {
    __FLOG(_L8("CMdnsServer::HostName -Entry Exit"));
    return (TDesC8&)iHostName; 
    }


void CMdnsServer::SetHostNameL(const TDesC8& aName)
    {
    iHostName.Close();
    iHostName.CreateL(aName);
    }

/*
 * When a new service appears in the network. 
 * will be notified to the server using this.
 * Server in turn looks for the session interested in the service and completes the asynchronous reuest.
 */
void CMdnsServer::NotifyNewServiceL(const RArray<RBuf8>& aName)
	{
	__FLOG(_L8("CMdnsServer::NotifyNewServiceL - Entry"));
	iSessionIter.SetToFirst();
	CSession2* session = NULL;
	while (NULL != (session = iSessionIter++))
		{
		CMdnsServerSession* serverSession = static_cast<CMdnsServerSession*>(session);
		serverSession->NewServiceL(aName);
		}
	__FLOG(_L8("CMdnsServer::NotifyNewServiceL - Exit"));
	}

/*
 * After the service has been published succesfully.
 * Server will be notified with this interface.
 * @param aName name with which the service is published.
 * @param aError result of submission.
 * @param aSessionId session id of the client.
 */
void CMdnsServer::NotifyServicePublishL(const RBuf8& aName,TInt aError, TInt aSessionId)
	{
	__FLOG(_L8("CMdnsServer::NotifyServicePublishL - Entry"));
	iSessionIter.SetToFirst();
	CSession2* session = NULL;
	while ((NULL != (session = iSessionIter++)) )
		{
		CMdnsServerSession* serverSession = static_cast<CMdnsServerSession*>(session);
		if(serverSession->SessionId() == aSessionId)
		    {
		    serverSession->HandleServiceNameConflictL(aName,aError);
		    }
		}
	SetPublishingService(EFalse);
	if(MessageQueue()->Count()>0)
	    {
	    MessageQueue()->StartProcessing();
	    }
	__FLOG(_L8("CMdnsServer::NotifyServicePublishL - Exit"));
	}

/*
 * This performs two tast.
 * 1. Set the iIsHostprobing to ETrue if host probing is going on.
 * 2. If Hostprobing is over it sees whether there are any pending queries or 
 * publish request . IF there are any it will start processing the same .
 * @param aProbing true if host probing.
 */
void CMdnsServer::SetStateHostProbing(TBool aProbing)
    {
    __FLOG(_L8("CMdnsServer::SetStateHostProbing - Entry"));
    iIsHostProbing = aProbing;
    if(!aProbing && MessageQueue()->Count()>0)
        {
        MessageQueue()->StartProcessing();
        }
    __FLOG(_L8("CMdnsServer::SetStateHostProbing - Exit"));        
    }

/*
 * @return returns wheteher host probing is going on or not.
 */
TBool CMdnsServer::IsHostProbing()const
    {
    __FLOG(_L8("CMdnsServer::IsHostProbing - Exit"));
    return iIsHostProbing;
    }

/*
 * Starts any pending publish or query request in the queue.
 * @param aMessage query or publish request.
 * @param aType can be either publish or query.
 * @param aSessionId session which requested .
 */
void CMdnsServer::ProcessQueuedMessage(const RMessage2& aMessage, const TMessageType aType,TInt aSessionId)
    {
    __FLOG(_L8("CMdnsServer::ProcessQueuedMessage - Entry"));
    iSessionIter.SetToFirst();
        CSession2* session = NULL;
        while (NULL != (session = iSessionIter++))
            {
            CMdnsServerSession* serverSession = static_cast<CMdnsServerSession*>(session);
            if(aSessionId == serverSession->SessionId())
                {
                switch(aType)
                    {
                    case EQueryMessage:
                        {
                        serverSession->ServiceQueryL(aMessage);
                        break;
                        }
                    case EPublishMessage:
                        {
                        serverSession->PublishL(aMessage);
                        break;
                        }
                    }
                }
            }  
    __FLOG(_L8("CMdnsServer::ProcessQueuedMessage - Exit"));
    }

/*
 * Pointer to the internall message queue.
 */
CInternalMessageQueue* CMdnsServer::MessageQueue()
    {
    __FLOG(_L8("CMdnsServer::MessageQueue -Entry Exit"));
    return iInternalMessageQueue;
    }


void CMdnsServer::OnPacketSendL(TInt /*aError*/)
    {
    // this is the call back after the bye-bye packet is sent.
    // do nothing
    __FLOG(_L8("CMdnsServer::OnPacketSendL -Entry Exit"));
    }
/*
 * if publishing will be set to true.
 * this is to halt any further publish , till the one undergoing gets over.
 */
void CMdnsServer::SetPublishingService(TBool aFlag)
    {
    __FLOG(_L8("CMdnsServer::SetPublishingService - Entry"));
    iIsPublishing = aFlag;
    __FLOG(_L8("CMdnsServer::SetPublishingService - Exit"));

    }
TBool CMdnsServer::IsPublishingService() const
    {
    __FLOG(_L8("CMdnsServer::IsPublishingService -Entry Exit"));
    return iIsPublishing ;
    }