// Copyright (c) 2010 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:

// Contains the implementation of all the commands, which is used by the script file.

//

/**

 @file

 @internalTechnology

 */

#include "te_dnssuffixtestwrapper.h"

#include "DNSSuffixHostResolver.h"

#include <e32base.h>

#include <in_sock.h>

#include <es_sock.h>

#include <commdbconnpref.h>

#include <commdb.h>

/*

 * TODO: 1. Try to test with end to end real scenario. Means resolving over real tunnel.

 * 

 * 

 */

#define KIPAddrLen 39

#define DISABLE_TUNDRIVER

// Used for handle the multiple hosts in same test cases. @See TC006

#define KMaxHosts 8

// Commands

_LIT(KInitDNSSuffixTesting, "InitDNSSuffixTesting");

_LIT(KEnumerateInterface,   "EnumerateInterface");

_LIT(KSetAndGetSuffixList,  "SetAndGetSuffixList");

_LIT(KDoResolve,            "DoResolve");

_LIT(KDoResolveHostWithoutDomainWithSuffix,     "DoResolveHostWithoutDomainWithSuffix");

_LIT(KDoResolveHostWithoutDomainWithoutSuffix,  "DoResolveHostWithoutDomainWithoutSuffix");

_LIT(KDNSSuffixSupportTC005,    "DNSSuffixSupportTC005");

_LIT(KDNSSuffixSupportTC006,    "DNSSuffixSupportTC006");

_LIT(KDNSSuffixSupportTC007,    "DNSSuffixSupportTC007");

_LIT(KDNSSuffixSupportTC008,    "DNSSuffixSupportTC008");

_LIT(KDNSSuffixSupportTC009,    "DNSSuffixSupportTC009");

_LIT(KDNSSuffixSupportTC010,    "DNSSuffixSupportTC010");

_LIT(KDNSSuffixSupportTC011,    "DNSSuffixSupportTC011");

//Test code

_LIT(KCommand, 			    "aCommand = %S");

_LIT(KSection, 			    "aSection = %S");

_LIT(KAsyncErrorIndex, 	    "aAsyncErrorIndex = %D");

_LIT(KKeyDNSSuffixTestSuffixList,   "suffixlist");

_LIT(KKeyDNSSuffixTestSuffixList1,   "suffixlist1");

_LIT(KKeyDNSSuffixTestSuffixList2,   "suffixlist2");

_LIT(KKeyDNSSuffixTestSuffixList3,   "suffixlist3");

_LIT(KKeyDNSSuffixTestHostname,     "hostname");

_LIT(KSectionDNSSuffixTest001,      "dnssuffix_test001");

_LIT(KSectionDNSSuffixTest002,      "dnssuffix_test002");

_LIT(KSectionDNSSuffixTest003,      "dnssuffix_test003");

_LIT(KSectionDNSSuffixTest004,      "dnssuffix_test004");

_LIT(KSectionDNSSuffixTest005,      "dnssuffix_test005");

_LIT(KSectionDNSSuffixTest006,          "dnssuffix_test006");

_LIT(KKeyDNSSuffixTest006NoOfHostname,  "noofhosts");

_LIT(KKeyDNSSuffixTest006Hostname,      "hostname%D");

_LIT(KSectionDNSSuffixTest007,              "dnssuffix_test007");

_LIT(KKeyDNSSuffixTest007ValidHostname,     "validhostname");

_LIT(KKeyDNSSuffixTest007InValidHostname,   "invalidhostname");

_LIT(KSectionDNSSuffixTest008,      "dnssuffix_test008");

_LIT(KKeyDNSSuffixTestHostname1,    "hostname1");

_LIT(KKeyDNSSuffixTestHostname2,    "hostname2");

_LIT(KSectionDNSSuffixTest009,      "dnssuffix_test009");

_LIT(KSectionDNSSuffixTest010,      "dnssuffix_test010");

_LIT(KSectionDNSSuffixTest011,      "dnssuffix_test011");

_LIT(KSectionDNSSuffixFirstInterface, "dnssuffix_first_interface");

_LIT(KSectionDNSSuffixSecondInterface, "dnssuffix_second_interface");

_LIT(KKeyDNSSuffixIAPId,"iapid");

_LIT(KKeyInterfaceName,                "interfacename");

/*

 * @author: Santosh K Patil

 * TODO: Needs to verify the interfaces used to resolve the hosts in each test case.

 * It is required to verify wheather test executed as desired or not. 

 * In other words to confirm the new solution is working as expected we need to get 

 * and verify the inteface name used to resolve the host.

 * @See Test spec for more details.

 * 

 * TODO: Check all config sections

 */

/**

Constructor.

@internalTechnology

 */

CDNSSuffixTestWrapper::CDNSSuffixTestWrapper()

    {

    }

/**

Destructor.

@internalTechnology

 */

CDNSSuffixTestWrapper::~CDNSSuffixTestWrapper()

    {  

    }

/**

Function to instantiate TestWrapper.

@return Returns constructed TestWrapper instance pointer

@internalTechnology

 */

CDNSSuffixTestWrapper* CDNSSuffixTestWrapper::NewL()

    {

    CDNSSuffixTestWrapper*	ret = new (ELeave) CDNSSuffixTestWrapper();

    CleanupStack::PushL(ret);

    ret->ConstructL();

    CleanupStack::Pop(ret);

    return ret;	

    }

/**

Second level constructor, constructs TestWrapper instance.

@internalTechnology

 */

void CDNSSuffixTestWrapper::ConstructL()

    {    

    }

/*

 * @HandleCallBackL Called by the CDNSSuffixHostResolver::RunL

 * 

 */

void CDNSSuffixTestWrapper::HandleCallBackL(TInt aError)

    {

    INFO_PRINTF1(_L("HandleCallBackL - Entry"));    

    INFO_PRINTF2(_L("Error code: %D"),aError);

    if (KErrNone != aError)

        SetError(KErrNone);

    else

        SetError(KErrGeneral);

    if (iWait.IsStarted())

        {

        INFO_PRINTF1(_L("Stoping waiter"));

        iWait.AsyncStop();

        }

    INFO_PRINTF1(_L("HandleCallBackL - Exit"));

    }

/**

Function to map the input command to respective function.

@return - True Upon successfull command to Function name mapping otherwise False

@param aCommand Function name has to be called

@param aSection INI file paramenter section name

@param aAsyncErrorIndex Error index

@see Refer the script file COMMAND section.

@internalTechnology

 */

TBool CDNSSuffixTestWrapper::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

    {

    TBool ret = ETrue;

    // Print out the parameters for debugging

    INFO_PRINTF2( KCommand, &aCommand );

    INFO_PRINTF2( KSection, &aSection );

    INFO_PRINTF2( KAsyncErrorIndex, aAsyncErrorIndex );

    if(KInitDNSSuffixTesting() == aCommand)

        {

        DoInitTestingL();

        }

    else if(KEnumerateInterface() == aCommand)

        {

        DoEnumerateInterfacesL();

        }

    else if (KSetAndGetSuffixList() == aCommand)

        {

        DoSetAndGetSuffixListL();

        }

    else if( KDoResolve() == aCommand)

        {

        DoResolveL();

        }

    else if( KDoResolveHostWithoutDomainWithSuffix() == aCommand)

        {

        DoResolveHostWithoutDomainWithSuffixListSetL();

        }    

    else if( KDoResolveHostWithoutDomainWithoutSuffix() == aCommand)

        {

        DoResolveHostWithoutDomainWithoutSuffixListL();

        }

    else if( KDNSSuffixSupportTC005() == aCommand)

        {

        DNSSuffixSupportTC005L();

        }

    else if( KDNSSuffixSupportTC006() == aCommand)

        {

        DNSSuffixSupportTC006L();

        }

    else if( KDNSSuffixSupportTC007() == aCommand)

        {

        DNSSuffixSupportTC007L();

        }

    else if( KDNSSuffixSupportTC008() == aCommand)

        {

        DNSSuffixSupportTC008L();

        }

    else if( KDNSSuffixSupportTC009() == aCommand)

        {

        DNSSuffixSupportTC009L();

        }

    else if( KDNSSuffixSupportTC010() == aCommand)

       {

       DNSSuffixSupportTC010L();

       }

    else if( KDNSSuffixSupportTC011() == aCommand)

       {

       DNSSuffixSupportTC011L();

       }    

    else

        {        

        ret = EFalse;

        User::LeaveIfError(KErrNone); // just to suppress LeaveScan warning

        }

    return ret;

    }

TInt CDNSSuffixTestWrapper::StartConnections(RSocketServ& aSockServ, RConnection& aConn1, RConnection& aConn2)

    {

    INFO_PRINTF1(_L("StartConnections - Entry"));

    TUint iapId = GetFirstIapId();

    if ((TInt)iapId == KErrNotFound)

        return KErrNotFound;

    TInt err = StartConnection(aSockServ,aConn1,iapId);

    if (err != KErrNone)

        {

        ERR_PRINTF1(_L("Failed to start first connection"));

        SetError(err);

        return err;

        }

    INFO_PRINTF2(_L("First connection started successfully - IAP: %D"),iapId);        

#ifndef DISABLE_TUNDRIVER

    iapId = GetSecondIapId();

    if ((TInt)iapId == KErrNotFound)

        {       

        aConn1.Close();

        return KErrNotFound;

        }

    err = StartConnection(iSocketServ,aConn2,iapId);

    if (err != KErrNone)

        {

        ERR_PRINTF1(_L("Failed to start second connection"));

        aConn1.Close();

        return err;

        }

    INFO_PRINTF2(_L("Second connection started successfully - IAP: %D"),iapId);

#endif

    INFO_PRINTF1(_L("StartConnections - Exit"));

    return KErrNone;

    }

TInt CDNSSuffixTestWrapper::StartConnection(RSocketServ& aSockServ, RConnection& aConn, TUint aIapId)

    {

    INFO_PRINTF1(_L("StartConnection - Entry"));

    TInt err(KErrNone);

    TCommDbConnPref connPref;

    INFO_PRINTF1(_L("Getting conn preference"));

    TRAP(err, GetConnPrefL(aIapId,connPref));

    if (KErrNone != err)

        {

        ERR_PRINTF1(_L("Failed to read conn preference"));

        return err;

        }

    INFO_PRINTF1(_L("Got conn preference"));

    if((err = aConn.Open(aSockServ, KAfInet)) != KErrNone )

        {

        ERR_PRINTF2(_L("Failed to open Connection: %D"),err);

        return err;

        }

    INFO_PRINTF1(_L("Connection opened"));

    INFO_PRINTF1(_L("Starting Connection"));

    err = aConn.Start(connPref);

    if (KErrNone != err)

        {

        ERR_PRINTF2(_L("Failed starting Connection: %D"),err);

        aConn.Close();

        return err;

        }

    INFO_PRINTF1(_L("Connection Started"));

    INFO_PRINTF1(_L("StartConnection - Exit"));

    return KErrNone;    

    }

void CDNSSuffixTestWrapper::GetConnPrefL(TUint aIapId,TCommDbConnPref& aPref)

    {

    INFO_PRINTF1(_L("GetConnPrefL - Entry"));

    INFO_PRINTF1(_L("Instantiating CCommsDatabase"));

    CCommsDatabase* commsDb = CCommsDatabase::NewL();

    CleanupStack::PushL(commsDb);

    INFO_PRINTF1(_L("Calling OpenConnectionPrefTableLC"));

    CCommsDbConnectionPrefTableView* commsDbView = commsDb->OpenConnectionPrefTableLC();

    INFO_PRINTF1(_L("Going to first record"));

    User::LeaveIfError(commsDbView->GotoFirstRecord());

    TInt isFound(KErrNotFound);

    do

        {

        CCommsDbConnectionPrefTableView::TCommDbIapConnectionPref pref;

        INFO_PRINTF1(_L("Reading conn preferecne."));

        commsDbView->ReadConnectionPreferenceL(pref);

        if (pref.iBearer.iIapId == aIapId)

            {

            INFO_PRINTF1(_L("Match found"));

            aPref.SetIapId(aIapId);

            aPref.SetBearerSet(pref.iBearer.iBearerSet);

            aPref.SetDirection(pref.iDirection);

            aPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

            isFound = KErrNone;

            break;

            }

        } while(!commsDbView->GotoNextRecord());    

    INFO_PRINTF1(_L("Cleanup resources"));

    CleanupStack::PopAndDestroy(2, commsDb); // commsDbView, commsDb

    User::LeaveIfError(isFound);

    INFO_PRINTF1(_L("GetConnPrefL - Exit"));    

    }

TInt32 CDNSSuffixTestWrapper::GetFirstIapId()

    {

    INFO_PRINTF1(_L("GetFirstIapId - Entry"));

    TInt iapId(KErrNotFound);

    if (!GetIntFromConfig(KSectionDNSSuffixFirstInterface,KKeyDNSSuffixIAPId,iapId))

         {

         ERR_PRINTF1(_L("Failed to read the First IAP id"));

         }

      else

         {

         INFO_PRINTF2(_L("Got the IAP: %D"),iapId);

         }

    INFO_PRINTF1(_L("GetFirstIapId - Exit"));

    return iapId;

    }

TInt32 CDNSSuffixTestWrapper::GetSecondIapId()

   {

   INFO_PRINTF1(_L("GetSecondIapId - Entry"));

   TInt iapId(KErrNotFound);

   if (!GetIntFromConfig(KSectionDNSSuffixSecondInterface,KKeyDNSSuffixIAPId,iapId))

        {

        ERR_PRINTF1(_L("Failed to read second IAP id"));

        }

     else

        {

        INFO_PRINTF2(_L("Got the IAP: %D"),iapId);

        }

   INFO_PRINTF1(_L("GetSecondIapId - Exit"));

   return iapId;

   }

TInt CDNSSuffixTestWrapper::GetFirstInterfaceNameL(TDes& aIfaceName)

    {

    INFO_PRINTF1(_L("GetFirstInterfaceNameL - Entry"));

    TInt err(KErrNone);    

    TPtrC interfaceName;

    if (!GetStringFromConfig(KSectionDNSSuffixFirstInterface,KKeyInterfaceName,interfaceName))

        {

        ERR_PRINTF1(_L("Failed to read the interface name from config"));

        err = KErrNotFound;

        SetError(err);

        return err;

        }

    err = GetInterfaceNameL(interfaceName,aIfaceName);

    INFO_PRINTF1(_L("GetFirstInterfaceNameL - Exit"));

    return err;

    }

TInt CDNSSuffixTestWrapper::GetSecondInterfaceNameL(TDes& aIfaceName)

    {    

    INFO_PRINTF1(_L("GetSecondInterfaceNameL - Entry"));

    TInt err(KErrNone);    

    TPtrC interfaceName;

    if (!GetStringFromConfig(KSectionDNSSuffixSecondInterface,KKeyInterfaceName,interfaceName))

        {

        ERR_PRINTF1(_L("Failed to read the interface name from config"));

        err = KErrNotFound;

        SetError(err);

        return err;

        }    

    err = GetInterfaceNameL(interfaceName,aIfaceName);

    INFO_PRINTF1(_L("GetSecondInterfaceNameL - Exit"));

    return err;    

    }

TInt CDNSSuffixTestWrapper::GetInterfaceNameL(const TDesC& aCriteria,TDes& aIfaceName)

    {

    INFO_PRINTF1(_L("GetInterfaceNameL - Entry"));

    TInt err = KErrNone;

    CDesCArray* interfaceNameArray = new(ELeave) CDesCArrayFlat(4);

    CleanupStack::PushL(interfaceNameArray);

    TRAP(err,GetAvaiableInterfacesL(interfaceNameArray));

    if (KErrNone != err)

        {       

        ERR_PRINTF2(_L("Failed to enumeate the interfaces with error: %D"),err);

        return err;

        }

    INFO_PRINTF2(_L("No of interfaces: %D"),interfaceNameArray->Count());

    if (interfaceNameArray->Count() <= 0)

       {

       INFO_PRINTF1(_L("No interfaces available:"));

       CleanupStack::PopAndDestroy(interfaceNameArray);

       err = KErrNotFound;

       SetError(err);

       return err;

       }

    TBool isInterfaceFound(EFalse);

    TInt index = -1;

    for (TInt a=0; a<interfaceNameArray->Count();a++)

       {

       HBufC* interfaceNameBuf = (*interfaceNameArray)[a].AllocL();

       TInt pos = interfaceNameBuf->FindF(aCriteria);

       delete interfaceNameBuf;

       if ( KErrNotFound != pos)

           {

           isInterfaceFound = ETrue;

           index = a;

           break;

           }

       }

    if (!isInterfaceFound)

        {

        ERR_PRINTF1(_L("Interface not found"));

        CleanupStack::PopAndDestroy(interfaceNameArray);

        err = KErrNotFound;

        SetError(err);