// 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:

// cadvertizehandler.cpp

// 

//

/**

@file

@internalTechnology

*/

//System include 

#include <mdns/ccacheentry.h>

//UserInclude

#include "cadvertizehandler.h"

__FLOG_STMT(_LIT8(KComponent,"MDNSServer");)

/*

 * Two phase constructor

 * @param aMessagHandler areference to messagehandler object.

 * @param aAutoResolveEnabled If true sercice name conflict will be handled.

 * aAutoResolveEnabled is True by default

 */

CAdvertizeHandler* CAdvertizeHandler::NewL(CMessageHandler& aMessageHandler,TBool aAutoResolveEnabled)

	{

	CAdvertizeHandler* self = new (ELeave) CAdvertizeHandler(aMessageHandler,aAutoResolveEnabled);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/*

 * Destructor

 */

CAdvertizeHandler::~CAdvertizeHandler()

	{

	__FLOG(_L8("CAdvertizeHandler::~CAdvertizeHandler- Entry"));

	iData.ResetAndDestroy();

	iData.Close();

	iName.Close();

	iProbeName.Close();

	iProbeType.Close();

	__FLOG(_L8("CAdvertizeHandler::~CAdvertizeHandler- Exit"));

	__FLOG_CLOSE;

	}

/*

 * No incoming packet for this so no need to handle

 */	

void CAdvertizeHandler::HandleIncomingPacketL(CDnsMessage& /*aMessage*/)

	{

	__FLOG(_L8("CAdvertizeHandler::HandleIncomingPacketL- Entry"));

	//Nothing To Do ............

	__FLOG(_L8("CAdvertizeHandler::HandleIncomingPacketL- Exit"));

	}

static void CleanUpCache(TAny* aAny)

    {

    //RPointerArray <CCacheEntry>  records = static_cast < RPointerArray <CCacheEntry> > (*aAny);

    RPointerArray <CCacheEntry>*  records = static_cast < RPointerArray <CCacheEntry> *> (aAny);

    records->ResetAndDestroy();

    records->Close();

    }

/*

 * Constructor

 * @param aMessageHandler reference to messagehandler

 * @param aAutoResolveEnabled will be true by default ,if true servicename conflict

 * will be handled by default

 */

CAdvertizeHandler::CAdvertizeHandler(CMessageHandler& aMessageHandler,TBool aAutoResolveEnabled):CBaseHandler(aMessageHandler)

	{

	__FLOG(_L8("CAdvertizeHandler::CAdvertizeHandler- Entry"));

	iAutoResolveEnabled = aAutoResolveEnabled;

	iCurrentProbeState = EIdle;

	iProbeCounter = 0 ;

	__FLOG(_L8("CAdvertizeHandler::CAdvertizeHandler- Exit"));

	}

/*

 * Twophase constructor

 */

void CAdvertizeHandler::ConstructL()

	{

	__FLOG_OPEN(KMDNSSubsystem, KComponent);

	__FLOG(_L8("CAdvertizeHandler::ConstructL- Entry"));

	CBaseHandler::ConstructL();

	//Nothing 

	__FLOG(_L8("CAdvertizeHandler::ConstructL- Exit"));

	}

/*

 * Keeps a copy of the records to be published and starts the active object.

 * @param aData an array of records to be published.

 * @param aSessionId session id initiating the advertizement.

 */

void CAdvertizeHandler::AdvertizePacketL(const RPointerArray<CDnsResourceData> aData, TInt aSessionId,TBool aIsUpdate)

    {

    __FLOG(_L8("CAdvertizeHandler::AdvertizePacketL- Entry"));

    iName.Close();

    iName.Create(aData[0]->Name());

    iProbeName.Close();

    iProbeName.CreateL(KMaxLength);

    iProbeName.Append(iName);

    iCurrentProbeState = EStart;

    iData.ResetAndDestroy();

    for(TInt i =0 ; i<aData.Count();i++)

        {

        iData.AppendL(aData[i]);

        }

     // assign the session id so that, we can send bye-bye packet when the session is closed

    iSessionId = aSessionId;

    if(aIsUpdate)

        {

        iCurrentProbeState = EIdle;

        TBool isExist = DefensiveResponseL();

        if(!isExist)

            {

            User::Leave(KErrNotFound);

            }

        SendAnnouncementL();

        InsertInCache();

        return;

        }

    Schedule();

    __FLOG(_L8("CAdvertizeHandler::AdvertizePacketL- Exit"));

    }

/*

 * This is a callback function will be notified whenever a packet sent from this

 * client is sent to the network.

 * @param aError any error in sending the packet.

 */

void CAdvertizeHandler::OnPacketSendL(TInt aError)

    {

    __FLOG(_L8("CAdvertizeHandler::OnPacketSendL- Entry"));

    if(aError != KErrNone)

        {

        MessageHandler().NotifyServicePublishL(iName,EFail,iSessionId);

        }

    if( iCurrentProbeState != EIdle)

            {

            After(KProbeDelay*1000);//Give more delay than this

            return;

            }

    //When a service is published successfully ,iCurrentProbe state will be 

    //EIdle ,this state change will be used to notify the client .

    MessageHandler().NotifyServicePublishL(iName,ESuccess,iSessionId);

    __FLOG(_L8("CAdvertizeHandler::OnPacketSendL- Exit"));

    }

void CAdvertizeHandler::RunL()

    {    

    __FLOG(_L8("CAdvertizeHandler::RunL- Entry"));

    TTime currentTime;

    if(iCurrentProbeState <= EProbeComplete)

        {

        if(DefensiveResponseL())

            {       

            iCurrentProbeState = EStart;                

            if(iAutoResolveEnabled)

                {

                GenerateNonConflictingName(); 

                if(iProbeCounter >= KMaxFailures)

                    {

                    //If Probe Failure rate is greater then 15 per second, wait for 

                    //5 seconds before probing again

                    iProbeCounter = 0;

                    After(5*1000*1000);             

                    }

                }       

              else //  to intimate server of failure

                  {

                  MessageHandler().NotifyServicePublishL(iName,EConflictWithoutAutoResolve,iSessionId);

                  }

            }       

        }

    switch(iCurrentProbeState)

        {       

        case EIdle:

        break;//Do Nothing

        case EStart:

            {

            currentTime.UniversalTime();

            TInt64 randseed = currentTime.Int64();                  

            //Random time between 0 & 250 ms

            TInt delay = Math::Rand(randseed) % 250;

            iCurrentProbeState = EProbeFirstUnicast;

            //Convert to microsecond

            After(delay*1000);          

            }               

            break;

        case EProbeFirstUnicast:

            {

            SendProbeL(ETrue);  

            iCurrentProbeState = EProbeSecondUnicast;                           

            }

            break;

        case EProbeSecondUnicast:

            {               

            SendProbeL(ETrue);  

            iCurrentProbeState = EProbeMulticast;                                       

            }

            break;      

        case EProbeMulticast:

            {

            SendProbeL(EFalse); 

            iCurrentProbeState = EProbeComplete;            

            }

            break;

        case EProbeComplete:

            {

            iCurrentProbeState = EFirstAnnouncement;

            //Probe succeeded ,insert in cache 

            InsertInCache();    

            After(KProbeDelay*1000);

            //Some Delay ?? Required or defensive response HAS TO come within 750ms?

            }

            break;

        case EFirstAnnouncement:

            {

            SendAnnouncementL();

            iCurrentProbeState = ESecondAnnouncement;

            //After(1000);// A Millisecond delay: Required??    

            }

            break;

        case ESecondAnnouncement:

            {

            SendAnnouncementL();

            iCurrentProbeState = EIdle;

            }

            break;  

        }

    __FLOG(_L8("CAdvertizeHandler::RunL- Exit"));

    }

/*

 * Handles any leave in RunL

 * @param aError error with which runL leaves.

 */

TInt CAdvertizeHandler::RunError(TInt aError)

    {

    __FLOG(_L8("CAdvertizeHandler::RunError- Entry"));

    return aError;

    }

/*

 * Self completes the request.

 */

void CAdvertizeHandler::Schedule()

    {

    __FLOG(_L8("CAdvertizeHandler::Schedule- Entry"));

    TRequestStatus* status(&iStatus);

    *status = KRequestPending;

    SetActive();

    User::RequestComplete(status, KErrNone);

    __FLOG(_L8("CAdvertizeHandler::Schedule- Exit"));

    }

/*

 * Function will be called when there is a conflict.

 * this will change the publishing name by appending a 

 * number at the end of it. 

 * @return iProbeCounter returns probecounter value.

 */

TInt CAdvertizeHandler::GenerateNonConflictingName()

    {

    __FLOG(_L8("CAdvertizeHandler::GenerateNonConflictingName- Entry"));

    _LIT8(KDot,".");

        RBuf8 oldName;

        oldName.CreateL(iName);

        ++iProbeCounter;

        TBuf8 <KMaxLength> newName;

        iName.Close();  

        iName.Create(KMaxLength);

        iName.Append(iProbeName);

        TInt pos = iName.Locate('.');

        _LIT8(KOpenBrace,"(");

        newName.Append(KOpenBrace);

        newName.AppendNum(iProbeCounter);

        _LIT8(KCloseBrace,")");

        newName.Append(KCloseBrace);

        iName.Insert(pos,newName); 

        ChangeDomainL(oldName);

        oldName.Close();

        __FLOG(_L8("CAdvertizeHandler::GenerateNonConflictingName- Exit"));

        return iProbeCounter;

    }

/*

 * Finds whether the service already exists in the network .

 * If service is in the network ,same will be present in the cache.

 * @return probFailed returns true if probe has failed.

 */

TBool CAdvertizeHandler::DefensiveResponseL()

    {

    __FLOG(_L8("CAdvertizeHandler::DefensiveResponseL- Entry"));

    TBool probeFailed(EFalse);      

    RPointerArray <CCacheEntry> entries;

    CleanupStack::PushL(TCleanupItem(TCleanupOperation(&CleanUpCache),&entries));

     _LIT8(KDot,".");

     TBuf8 <KMaxLength> buffer;  

     buffer.Copy(iName);

     buffer.Append(KDot);

     MessageHandler().DnsCache().FindServiceL(entries,buffer,EDnsQType_Any);   

     if(entries.Count()>0)

        {

        probeFailed = ETrue;

        }

     CleanupStack::PopAndDestroy();	

     //entries.ResetAndDestroy();

     //entries.Close();

     __FLOG(_L8("CAdvertizeHandler::DefensiveResponseL- Exit"));

     return probeFailed;

    }

/*

 * creates a DnsMessage object and send it to the messagehandler to handle it.

 * @param aUnicast true if the packet to be sent is an unicast one;false for multicast.

 * 

 */

void CAdvertizeHandler::SendProbeL(TBool aUnicast)

    {

    __FLOG(_L8("CAdvertizeHandler::SendProbeL- Entry"));

    //Construct DNS Message

    CDnsMessage* message = CDnsMessage::NewL(0,ETrue);

    CleanupStack::PushL(message);

    //Form the Query/Question part of the message

    CDnsQuestion* question = CDnsQuestion::NewL();

    CleanupStack::PushL(question);

    question->SetNameL(iName);

    question->SetClass(EDnsClass_IN);

    question->SetType(EDnsQType_Any);

    if(aUnicast)

        {

        question->SetUnicast(ETrue);

        }

    //Append the Query to the Message

    message->AppendQueryL(question);

    //Append to the Authoritative Section

    for(TInt i =0 ; i < iData.Count();i++)

        {

        message->AppendAuthorityL(iData[i]->CloneL());

        }

    //Send the query

    MessageHandler().SendQueryL(message,*this);

    CleanupStack::Pop();//question

    CleanupStack::Pop();//message

    __FLOG(_L8("CAdvertizeHandler::SendProbeL- Exit"));

    }

/*

 * If probing is successfull ,new service record will 

 * be added to the cache using this.

 */

void CAdvertizeHandler::InsertInCache()

    {

    __FLOG(_L8("CAdvertizeHandler::InsertInCache- Entry"));

    TBuf8<KMaxLength> name;

    _LIT8(KDot,".");

    //TODO name should be appended with dot

    for(TInt i =0 ; i<iData.Count();i++)

        {

        //Append  a "." at the end of the name

       name.Copy(iData[i]->Name());

       name.Append(KDot);  

       iData[i]->SetNameL(name);

       MessageHandler().DnsCache().UpdateCacheL(*(iData[i]),ETrue,iSessionId);

        }

    __FLOG(_L8("CAdvertizeHandler::InsertInCache- Exit"));   

    }

/*

 * Announces the new service.

 */

void CAdvertizeHandler::SendAnnouncementL()

    {

    __FLOG(_L8("CAdvertizeHandler::SendAnnouncementL- Entry"));

    RPointerArray<CCacheEntry> entries;

    //An API in Cache Interface that returns a list of all Authoritative records

    MessageHandler().DnsCache().AuthoritativeEntriesL(entries);

    CDnsMessage* message = CDnsMessage::NewL(0,EFalse);

    CleanupStack::PushL(message);  

    TDnsHeader header(message->Header());

    header.SetAuthoritative(ETrue);

    message->SetHeader(header);

    //Append to the Authoritative Section

    for(TInt i =0 ; i < iData.Count();i++)

        {

        message->AppendAuthorityL(iData[i]->CloneL());

        }

/*    

    for(TInt index =0; index<entries.Count();index++)

        {

        CCacheEntry* entry = entries[index];

        //Send Announcements for all the Services we have published, and entered in Cache           

        if(entry->AddressRecord())

            message->AppendAnswerL(entry->AddressRecord()->CloneL());

        if(entry->ServiceRecord())

            message->AppendAnswerL(entry->ServiceRecord()->CloneL());

        if(entry->PtrRecord())

            message->AppendAnswerL(entry->PtrRecord()->CloneL());

        if(entry->TxtRecord())

            message->AppendAnswerL(entry->TxtRecord()->CloneL());

        //should've been a new API sendresponse

        }

*/        

    MessageHandler().SendQueryL(message,*this);

    CleanupStack::Pop();//message

    entries.ResetAndDestroy();

    entries.Close();

    __FLOG(_L8("CAdvertizeHandler::SendAnnouncementL- Exit"));

    }

void CAdvertizeHandler::ChangeDomainL(TDesC8& aName)

    {

    for(TInt i =0 ; i<iData.Count();i++)

        {

        if(iData[i]->Name().Compare(aName) == 0)

            {

            iData[i]->SetNameL(iName);

            }

        if(iData[i]->Type()==EDnsType_PTR)

            {

            CRdTypePtr* ptr = static_cast<CRdTypePtr*>(iData[i]);

            if(ptr->DomainName().Compare(aName) == 0)

                {

                ptr->SetDomainNameL(iName);

                }

            }

        }

    }