tcpiputils/dnd/Test/te_dnssuffix/src/te_dnssuffixtestwrapper.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Thu, 19 Aug 2010 11:25:30 +0300
branchRCL_3
changeset 20 7e41d162e158
child 23 425d8f4f7fa5
permissions -rw-r--r--
Revision: 201033 Kit: 201033

// 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);
        return err;
        }    
    
    aIfaceName.Copy((*interfaceNameArray)[index]);
    
    CleanupStack::PopAndDestroy(interfaceNameArray);
    
    TPtr tempName((TUint16*)aIfaceName.Ptr(),aIfaceName.Length(),aIfaceName.Length());
    INFO_PRINTF2(_L("Found Interface and name is: %S"),&tempName);
    
    INFO_PRINTF1(_L("GetInterfaceNameL - Exit"));
    return KErrNone;
    }

/**
 * DoInitTestingL. Configures the initial connections. 
 * Function to start the connection to configure the named server on one interface. 
 */
void CDNSSuffixTestWrapper::DoInitTestingL()
    {
    INFO_PRINTF1(_L("********************************************"));
    INFO_PRINTF1(_L("DoInitTestingL"));
    INFO_PRINTF1(_L("********************************************"));

    /*@Note, We need to configure the named servers on vTunnel and ethernet interfaces.
     * So, Configuring them by starting connections on both interfaces. 
     * 
     */
    TInt err = KErrNone;
    
    if((err = iSocketServ.Connect()) == KErrNone )
        INFO_PRINTF1(_L("Socket Server Opened."));
    else
        {
        ERR_PRINTF2(_L("Error Opening Socket Server: %d"), err);
        SetError(err);
        return;
        }
    
    ERR_PRINTF2(_L("Error Opening Socket Server: %d"), err);
    
    RConnection firstConn; 
    RConnection vTunConn; // Usef for virtual Tunnel interface
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed to start the Connections: %D"),err);
        CloseSocketSrv();
        SetError(err);
        return;
        }
    INFO_PRINTF1(_L("Started the connections successfully"));
    
    INFO_PRINTF1(_L("Close the connections"));
   
#ifndef DISABLE_TUNDRIVER
    if (vTunConn.SubSessionHandle())
        vTunConn.Close();
#endif

    if (firstConn.SubSessionHandle())
        firstConn.Close();
    
    SetError(err);      
    CloseSocketSrv();    
    }

/**
 * @DoEnumerateInterfacesL. Enumerates the all available interfaces.
 */
void CDNSSuffixTestWrapper::DoEnumerateInterfacesL()
    {
    INFO_PRINTF1(_L("********************************************"));
    INFO_PRINTF1(_L("DoEnumerateInterfacesL"));
    INFO_PRINTF1(_L("********************************************"));
    
    CDesCArray* interfaceNameArray = new(ELeave) CDesCArrayFlat(4);
    CleanupStack::PushL(interfaceNameArray);
    TRAPD(err,GetAvaiableInterfacesL(interfaceNameArray));
   
    if (KErrNone == err)
        {
        // Print the interface names        
        INFO_PRINTF2(_L("Found %D interfaces"),interfaceNameArray->Count());
        
        for(TInt a=0;a<interfaceNameArray->Count();a++)
            {
            TPtrC interfaceName = (*interfaceNameArray)[a];
            INFO_PRINTF2(_L("Interface: %S"),&interfaceName);
            }
        }
    else
        {
        ERR_PRINTF2(_L("Failed to enumeate the interfaces with error: %D"),err);
        }
    
    CleanupStack::PopAndDestroy(interfaceNameArray);
    
    SetError(err);
    }

/*
 * GetAvaiableInterfacesL. Function to get the names of all available names of  all interfaces.
 * @arg aInterfaceNamesArray (out param), Array of interface names owned by caller. 
 */
void CDNSSuffixTestWrapper::GetAvaiableInterfacesL(MDesCArray* aInterfaceNamesArray)
    {
    INFO_PRINTF1(_L("GetAvaiableInterfacesL - Entry"));
    
    CDesCArray* interfacesArray = static_cast<CDesCArray*>(aInterfaceNamesArray);
    interfacesArray->Reset();
    
    TInt err = KErrNone;
    RSocketServ socketSrv;
    
    if ( (err = socketSrv.Connect()) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Socet server error: %D"),err);
        SetError(err);
        return;
        }
    INFO_PRINTF1( _L("Connected to Socket server"));
    
    INFO_PRINTF1(_L("Opening socket..."));
    
    RSocket socket;
    err = socket.Open(socketSrv,KAfInet, KSockDatagram, KProtocolInetUdp);
    
    if (KErrNone != err)
        {
        INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);
        SetError(err);
        socketSrv.Close();
        return;
        }
    
    INFO_PRINTF1(_L("Socket opened"));
    
    err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);
  
    if (KErrNone != err)
        {
        INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);
        SetError(err);
        socket.Close();
        socketSrv.Close();
        return;
        }
    
    TSoInetInterfaceInfo info;
    TPckg<TSoInetInterfaceInfo> opt(info);
    
    while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)
        {
       // INFO_PRINTF2(_L("Interface Name %S"),&opt().iName);
        interfacesArray->AppendL(opt().iName);
        }
    
    INFO_PRINTF1(_L("Finished"));
    
    INFO_PRINTF1(_L("Closing connections"));
    socket.Close();
    socketSrv.Close();
    SetError(KErrNone);
    INFO_PRINTF1(_L("GetAvaiableInterfacesL - Exit"));
    }


/**
Function test the setting of suffix list and getting suffix list on interface.
*/
void CDNSSuffixTestWrapper::DoSetAndGetSuffixListL()
    {
    INFO_PRINTF1(_L("************************************************************"));
    INFO_PRINTF1(_L("DoSetAndGetSuffixListL - DNS_Suffix_Support_TC001"));
    INFO_PRINTF1(_L("************************************************************"));
        
    TInt err(KErrNone);
    
    TName interfaceName;
    
    TRAP(err, err = GetFirstInterfaceNameL(interfaceName));
        
    if (err != KErrNone )
        {
        ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);
        SetError(err);
        return;
        }
    
    TPtrC suffixList;
    iSuffixList.Reset();
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest001,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }
            
    err = iSocketServ.Connect();
           
    if(KErrNone != err)
       {
       ERR_PRINTF1(_L("Failed to connect socket Server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket Server"));
    
    TUint iapId = GetFirstIapId();
    
    if (KErrNotFound == (TInt)iapId)
       {
       ERR_PRINTF2(_L("Failed to get the iap id: %D"),err);
       SetError(err);
       CloseSocketSrv();
       return;
       }
    
    RConnection firstConn; 
    err = StartConnection(iSocketServ,firstConn,iapId);
    
    if (KErrNone != err)
      {
      ERR_PRINTF2(_L("Failed to start the Connections: %D"),err);
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Started the connections successfully"));
    
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);
    
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);
        SetError(err);  
        firstConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF1(_L("Getting the suffix list on interface:"));
    
    iSuffixList2.Reset();
    
    err = GetDNSSuffixList(iSocketServ,interfaceName,iSuffixList2);
        
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed to get the suffix list with errror : %D"),err);
        }
    
    
    if (err == KErrNone)
        {        
        if ( (err = IsSuffixListEqual(iSuffixList,iSuffixList2)) == KErrNone)
            {
            INFO_PRINTF1(_L("Suffix list are same and Test is successfull"));
            }
        else
            {
            ERR_PRINTF1(_L("Suffix list are not same and Test failed"));
            }
        }
    
    SetError(err);
    
    firstConn.Close();
    CloseSocketSrv();
    
    INFO_PRINTF1(_L("Set and Get Suffix list Test - Finished"));
    }



TInt CDNSSuffixTestWrapper::SetDNSSuffixListOnInterface(RSocketServ& aServ,RConnection& /*aConn*/,const TDesC& aInterfaceName,RInetSuffixList& aData)
    {
    INFO_PRINTF1(_L("SetDNSSuffixListOnInterfaceL - Entry"));
    
    INFO_PRINTF1(_L("Opening socket..."));    
       
    RSocket socket;
    TInt err = socket.Open(aServ,KAfInet, KSockDatagram, KProtocolInetUdp);    
    
    if (KErrNone != err)
        {
        INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);
        SetError(err);
        return err;
        }
  
    INFO_PRINTF1(_L("Socket opened"));
    
    err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);
    
    if (KErrNone != err)
        {
        INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);
        SetError(err);        
        socket.Close();
        return err;
        }
    
	TSoInetInterfaceInfo getOpt;
    TPckg<TSoInetInterfaceInfo> opt_out(getOpt);
    
    TBool isSuffixListSet(EFalse);
    
    while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt_out)== KErrNone)        
        {    
        
        INFO_PRINTF2(_L("Interface Name: %S"),&opt_out().iName);        
        INFO_PRINTF2(_L("Name Server: %D"),!opt_out().iNameSer1.IsUnspecified());
        
        TBuf<KIPAddrLen> ipBuf;
        opt_out().iAddress.Output(ipBuf);
        INFO_PRINTF2(_L("IP Address: %S"),&ipBuf);

        TBuf<KIPAddrLen> nameserBuf;
        opt_out().iNameSer1.Output(nameserBuf);
        INFO_PRINTF2(_L("Name Server IP: %S"),&nameserBuf);

        if( (opt_out().iName.Length()>0) /*&& !(opt_out().iNameSer1.IsUnspecified())*/ && (aInterfaceName.CompareF(opt_out().iName)==0) )       
            {
            INFO_PRINTF2(_L("Setting suffix list on Interface: %S"),&opt_out().iName);
            INFO_PRINTF2(_L("MTU on the interface is : %d"), opt_out().iMtu);

            TSoInetInterfaceInfoExtnDnsSuffix setOpt;
            (TSoInetInterfaceInfo &)setOpt = opt_out();
            TPckg<TSoInetInterfaceInfoExtnDnsSuffix> opt_in(setOpt);
            /*opt_in().iName = opt_out().iName;
            opt_in().iAddress = opt_out().iAddress;
            opt_in().iNetMask = opt_out().iNetMask;*/
            opt_in().iDoId = ETrue;
            opt_in().iDelete = EFalse;
            opt_in().iDomainSuffix.DeleteAll();
            
            err = socket.SetOpt(KSoInetConfigInterface,KSolInetIfCtrl,opt_in);
            
            if (err != KErrNone)
                {
                ERR_PRINTF2(_L("Failed to reset suffix list on the interface: %D"),err);
                break;
                }
            else
	            INFO_PRINTF1(_L("Interface domain suffix list reset successful"));
            	
            if (aData.Count() == 0) // We plan to set empty record, so only reset is sufficient
                isSuffixListSet = ETrue;
            
            for(TInt a=0;a<aData.Count();a++)
                {
                opt_in().iDomainSuffix.Copy(aData[a]);
                err = socket.SetOpt(KSoInetConfigInterface,KSolInetIfCtrl,opt_in);
                if (err != KErrNone)
                	{
                	ERR_PRINTF2(_L("Failed to set suffix list: %D"),err);
                	break;
            		}
                else
                	{
	                INFO_PRINTF1(_L("Suffix list added successfully"));
                	isSuffixListSet = ETrue;
            		}
                }
            break;
            }
        }
    
    if (!isSuffixListSet)
        {
        err = KErrNotFound;
        ERR_PRINTF2(_L("Failed to set suffix list with error: %D"),err);       
        }
        
    SetError(err);
    
    INFO_PRINTF1(_L("Closing socket"));
    
    socket.Close();
    INFO_PRINTF1(_L("SetDNSSuffixListOnInterfaceL - Exit"));
    return err;
    }



/**
 * GetDNSSuffixList. Gets the suffix list set on an interface.
 * 
 * @arg  aServ, session handle to a socket server. 
 * @arg  aData (in/out param) Data having the suffix list. Packed buffer of type TInetSuffixList
 *
 */
TInt CDNSSuffixTestWrapper::GetDNSSuffixList(RSocketServ& aServ,const TDesC& aInterfaceName,RInetSuffixList& aData)
    {
    INFO_PRINTF1(_L("GetDNSSuffixList - Entry"));
    
    INFO_PRINTF1(_L("Opening socket..."));
    RSocket socket;
    TInt err = socket.Open(aServ,KAfInet, KSockDatagram, KProtocolInetUdp);
    
    if (KErrNone != err)
       {
       INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);
       SetError(err);
       return err;
       }
    
    INFO_PRINTF1(_L("Socket opened"));
    
    err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);
    
    if (KErrNone != err)
       {
       INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);
       SetError(err);
       socket.Close();
       return err;
       }

	TSoInetInterfaceInfo getOpt;
    TPckg<TSoInetInterfaceInfo> opt(getOpt);
       
    while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)
		{
		if (aInterfaceName.CompareF(opt().iName) == KErrNone)
			{
			INFO_PRINTF2(_L("Reading suffix list from interface: %S"),&opt().iName);     

			TBuf<KIPAddrLen> tempIp;
			opt().iAddress.Output(tempIp);
			INFO_PRINTF2(_L("IP: %S"),&tempIp);

			TInetSuffix domainSuffix;
			TPckg<TInetSuffix> dom_opt(domainSuffix);
			if (err = socket.SetOpt(KSoInetEnumDomainSuffix, KSolInetIfCtrl) != KErrNone)
				return err; 
			while( socket.GetOpt(KSoInetNextDomainSuffix, KSolInetIfCtrl, dom_opt) == KErrNone)
				{
                aData.AppendL(dom_opt().iSuffixName);
				}
			break;
			}
		}
    
    INFO_PRINTF1(_L("Closing socket"));
    socket.Close();

    INFO_PRINTF1(_L("GetDNSSuffixList - Exit"));
    return KErrNone;
    }



/**
 * FillSuffixListL, Function to fill the suffix names in the TInetSuffixList object. 
 * @arg aSuffixList, out param, on return has the suffix list set in it.
 * @arg aData, has the list of domain suffix names in the form of abc.xyz.com;efg.xyz.com
 */
TInt CDNSSuffixTestWrapper::FillSuffixList(RInetSuffixList& aSuffixList,TDesC& aData)
    {
    INFO_PRINTF1(_L("FillSuffixList - Entry"));
    
    INFO_PRINTF2(_L("Processing Suffix list: %S"),&aData);
    
    TPtr data((TUint16*)aData.Ptr(),aData.Length(),aData.Length());
    data.TrimAll();
    
    TInt pos = KErrNone;
    while( (pos = data.Find(_L(";"))) != KErrNotFound)
        {
        TPtr suffixItem((TUint16*)data.Left(pos).Ptr(),pos,pos);
        INFO_PRINTF3(_L("Processing %D suffix name: %S"),/*sListBuf()*/iSuffixList.Count()+1,&suffixItem);
        
        TSuffixName tmpBuf;
        tmpBuf.Copy(suffixItem);
        aSuffixList.AppendL(tmpBuf);
        data.Copy(data.Mid(pos+1));
        }
    data.TrimAll();
    INFO_PRINTF3(_L("Processing %D suffix name: %S"),/*sListBuf()*/iSuffixList.Count()+1,&data);
    INFO_PRINTF2(_L("Data Len: %D"),data.Length());
    
    TSuffixName tmpBuf;
    tmpBuf.Copy(data);
    aSuffixList.AppendL(tmpBuf);
    
    INFO_PRINTF1(_L("FillSuffixList - Exit"));
    
    return aSuffixList.Count() == 0 ? KErrNotFound : KErrNone;
    }


void CDNSSuffixTestWrapper::CloseSocketSrv()
    {
    INFO_PRINTF1(_L("Closing socket server"));
    
    if (iSocketServ.Handle())
        {
        iSocketServ.Close();
        INFO_PRINTF1(_L("Closed Sock Srv successfully"));
        }
    else
        {
        INFO_PRINTF1(_L("Inavild Sock Srv handle"));
        }
    }

/* 
 * IsSuffixListEqual, Utility function, compares the two suffix list structures. 
 * @arg aSuffixList1 First structure holding the suffix list
 * @arg aSuffixList2 second structure holding the suffix list
 * 
 * @return KErrNone if both suffix list strucures same otherwise KErrArgument.  
 * 
 */
TInt CDNSSuffixTestWrapper::IsSuffixListEqual(const RInetSuffixList& aSuffixList1, const RInetSuffixList& aSuffixList2)
    {
    INFO_PRINTF1(_L("IsSuffixListEqual - Entry"));
    
    if (aSuffixList1.Count() != aSuffixList2.Count())
        {
        return KErrArgument;
        }
    
    for (TInt a=0; a<aSuffixList1.Count();a++)
        {
        if (aSuffixList1[a].CompareF(aSuffixList2[a]) != KErrNone)
            {
            return KErrArgument;
            }
        }
    INFO_PRINTF1(_L("IsSuffixListEqual - Exit"));
    return KErrNone;
    }


/*
 * Prerequisite: Two interfaces required to be up and running (virtual Tunnel and ethernet).
 * 
 * DoResolveL. Resolves the domain name
 * 
 * 
 */
void CDNSSuffixTestWrapper::DoResolveL()
    {
    INFO_PRINTF1(_L("********************************************"));
    INFO_PRINTF1(_L("DoResolveL  - DNS_Suffix_Support_TC002"));
    INFO_PRINTF1(_L("********************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest002,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name value"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name: %S"),&hostname);       
        }

	TInt err = KErrNone;
    TName interfaceName;
    
    TRAP(err, err = GetFirstInterfaceNameL(interfaceName));
        
    if (err != KErrNone )
        {
        ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);
        SetError(err);
        return;
        }
        
    TPtrC suffixList;
    iSuffixList.Reset();
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest002,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }

    if ( (err = iSocketServ.Connect()) != KErrNone)
        {
        ERR_PRINTF1(_L("Failed Connecting to socket server"));
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    /*
     * @Note: Start more than one interface. 
     * Here starting vitual tunnel nif interface as a default. @see ethernet ced.xml file in which I have made 
     * vTun as default in pref table.
     */ 
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
   
    if (err != KErrNone)
        {
        ERR_PRINTF1(_L("Failed to start connections"));
        CloseSocketSrv();
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connections started successfully"));
   
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);
    
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);
        SetError(err);  
        firstConn.Close();
        CloseSocketSrv();
        return;
        }

    // Open implicit resolver.
    RHostResolver resolver;
    
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);        
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname);
    
    if ( (err = resolver.GetByName(hostname,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Failed host resolution for %S with error: %D"),&hostname,err);       
      }
    else
      {
      TInetAddr& netAddress = TInetAddr::Cast(nameEntry().iAddr);
      
      if (netAddress.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> address;
          netAddress.Output(address);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&address);
          }
      }
    
    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close();

    SetError(err);
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    }



void CDNSSuffixTestWrapper::DoResolveHostWithoutDomainWithSuffixListSetL()
    {
    INFO_PRINTF1(_L("******************************************************"));
    INFO_PRINTF1(_L("DoResolveHostWithoutDomainL with Domain suffix Set"));
    INFO_PRINTF1(_L(" - DNS_Suffix_Support_TC003"));
    INFO_PRINTF1(_L("******************************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest003,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name value"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name: %S"),&hostname);       
        }
    
    TInt err = KErrNone;
    
    if ( (err = iSocketServ.Connect()) != KErrNone)
        {
        ERR_PRINTF1(_L("Failed Connecting to socket server"));
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
        
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
       {
       ERR_PRINTF1(_L("Failed to start connections"));
       CloseSocketSrv();
       SetError(err);
       return;
       }

   INFO_PRINTF1(_L("Connections started successfully"));
       
    // Open explicit resolver with ethernet
    RHostResolver resolver;
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    if ( (err = resolver.GetByName(hostname,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Failed host resolution for %S with error: %D"),&hostname,err);
      INFO_PRINTF1(_L("Test success"));
      SetError(err);
      }
    else
      {
      TInetAddr address = nameEntry().iAddr;
      
      if (address.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> ipAddr;
          address.Output(ipAddr);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&ipAddr);
          }
      SetError(err);
      }
    
    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close();
    firstConn.Close();
    vTunConn.Close();   
    CloseSocketSrv();           
    }


void CDNSSuffixTestWrapper::DoResolveHostWithoutDomainWithoutSuffixListL()
    {
    INFO_PRINTF1(_L("******************************************************"));
    INFO_PRINTF1(_L("DoResolveHostWithoutDomainL  With no Suffix list"));
    INFO_PRINTF1(_L("DNS_Suffix_Support_TC004"));
    INFO_PRINTF1(_L("******************************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest004,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name value"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name: %S"),&hostname);       
        }
    
    TInt err(KErrNone);
    // Note: Remove the suffix list set on Ethernet interface.
  
    TName interfaceName;
    err = GetFirstInterfaceNameL(interfaceName);   
   
    if ( (err = iSocketServ.Connect()) != KErrNone)
        {
        ERR_PRINTF1(_L("Failed Connecting to socket server"));
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
        
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn;
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    /*
    * @Note: Remove the suffix list (which we set in TC001) set on the interface by just setting empty list on it.
    */
    INFO_PRINTF1(_L("Setting empty suffix list on interface:"));
    iSuffixList.Reset();
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);
    
    if (err != KErrNone)
        {
        ERR_PRINTF2(_L("Failed to remove the suffix list set on interface with error: %D"),err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF1(_L("Removed suffix list from interface:"));
    
    // Open explicit resolver with ethernet
    RHostResolver resolver;
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    if ( (err = resolver.GetByName(hostname,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Failed host resolution for %S with error: %D"),&hostname,err);
      INFO_PRINTF1(_L("Test success"));
      SetError(EPass);
      }
    else
      {
      TInetAddr address = nameEntry().iAddr;
      
      if (address.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> ipAddr;
          address.Output(ipAddr);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&ipAddr);
          }
      SetError(EFail);
      }
    
    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close();
    firstConn.Close();
    vTunConn.Close();   
    CloseSocketSrv();      
    INFO_PRINTF1(_L("DoResolveHostWithoutDomainWithoutSuffixListL - Exit"));
    }



void CDNSSuffixTestWrapper::DNSSuffixSupportTC005L()
    {
    INFO_PRINTF1(_L("****************************************************"));
    INFO_PRINTF1(_L("DNSSuffixSupportTC005L - DNS_Suffix_Support_TC005"));
    INFO_PRINTF1(_L("****************************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest005,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name value"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name: %S"),&hostname);       
        }
    
    TInt err(KErrNone);
        
    TFileName interfaceName;
    
    TRAP(err, err = GetFirstInterfaceNameL(interfaceName));
    
    if (err != KErrNone )
        {
        ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);
        SetError(err);
        return;
        }
    
    TPtrC suffixList;    
    iSuffixList.Reset();
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest005,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }
     
    if ( (err = iSocketServ.Connect()) != KErrNone)
        {
        ERR_PRINTF1(_L("Failed Connecting to socket server"));
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
       {
       ERR_PRINTF1(_L("Failed to start connections"));
       CloseSocketSrv();
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    INFO_PRINTF2(_L("Setting suffix list on : %S"),&interfaceName);
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);    
        
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);
        SetError(err);    
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF1(_L("Suffix list set successfully"));
    
    INFO_PRINTF1(_L("Creating explicit host resolver"));
    
    // Open explicit resolver
    RHostResolver resolver;
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    if ( (err = resolver.GetByName(hostname,nameEntry)) != KErrNone)
        {
        INFO_PRINTF3(_L("Host resolution for %S with error: %D"),&hostname,err);
        INFO_PRINTF1(_L("Test success"));
        err = KErrNone;
        }    
    else
        {
        err = KErrArgument;
        ERR_PRINTF1(_L("Test failed: Expected no resolution, but resolved"));
        }
    
    SetError(err);
    INFO_PRINTF1(_L("Closing host resolver, connections and Sock Srv session"));
    resolver.Close();
    firstConn.Close();
    vTunConn.Close();    
    CloseSocketSrv();
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC005L - Exit"));
    }


void CDNSSuffixTestWrapper::DNSSuffixSupportTC006L()
    {
    INFO_PRINTF1(_L("****************************************************"));
    INFO_PRINTF1(_L("DNSSuffixSupportTC006L - DNS_Suffix_Support_TC006"));
    INFO_PRINTF1(_L("****************************************************"));
    
    TInt numberOfHosts(0);
    
    if (!GetIntFromConfig(KSectionDNSSuffixTest006,KKeyDNSSuffixTest006NoOfHostname,numberOfHosts))
        {
        ERR_PRINTF1(_L("Failed to read the no of hosts from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("No of hosts: %D"),numberOfHosts);       
        }       

    TPtrC hostnames[KMaxHosts];
    
    for (TInt b=0;b<numberOfHosts;b++)
        {
        TFileName keyName;
        keyName.Format(KKeyDNSSuffixTest006Hostname,b+1);
        
        if (!GetStringFromConfig(KSectionDNSSuffixTest006,keyName,hostnames[b]))
            {
            ERR_PRINTF1(_L("Failed to read the 1st host name value"));    
            SetError(KErrNotFound);
            return;
            }
        else
            {
            INFO_PRINTF3(_L("Host name%D: %S"),b,&hostnames[b]);       
            }        
        }
        
    TInt err(KErrNone);
        
    TName interfaceName;
    
    TRAP(err, err = GetFirstInterfaceNameL(interfaceName));
    
    if (err != KErrNone )
        {
        ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);
        SetError(err);
        return;
        }
    
    TPtrC suffixList;
    iSuffixList.Reset();
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest006,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }
     
    if ( (err = iSocketServ.Connect()) != KErrNone)
        {
        ERR_PRINTF1(_L("Failed Connecting to socket server"));
        SetError(err);
        return;
        }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);
       
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }

    INFO_PRINTF1(_L("Set suffix list on interface successfully"));
    
    RHostResolver resolver;
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry[KMaxHosts];
    
    // Resolve all three hosts
    for (TInt a=0;a<numberOfHosts;a++)
        {
        INFO_PRINTF2(_L("Resolving host: %S"),&hostnames[a]);
        
        if ( (err = resolver.GetByName(hostnames[a],nameEntry[a])) != KErrNone)
            {
            INFO_PRINTF3(_L("Host resolution for %S failed with error: %D"),&hostnames[a],err);
            INFO_PRINTF1(_L("Test Failed"));
            SetError(err);
            break;
            }
        }
    
    if (err == KErrNone)
        {
        for (TInt a=0;a<numberOfHosts;a++)
            {
            TInetAddr address = nameEntry[a]().iAddr;
            
            if (address.IsUnspecified())
                {
                ERR_PRINTF1(_L("Invalid host address"));
                err = KErrArgument;
                }
            else
                {
                TBuf<KIPAddrLen> ipAddr;
                address.Output(ipAddr);
                INFO_PRINTF1(_L("Got valid IP address:"));
                INFO_PRINTF2(_L("Host name: %S"),&nameEntry[a]().iName);
                INFO_PRINTF2(_L("Host address: %S"),&ipAddr);
                }            
            }       
        }
    
    SetError(err);
    INFO_PRINTF1(_L("Closing host resolver, connections and Sock Srv session"));
    resolver.Close();
    firstConn.Close();
    vTunConn.Close();    
    CloseSocketSrv();
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC006L - Exit"));
    }


/*
 * TODO: Needs to find the way to change the ranking IAP's programatically. 
 * Note: Before running this test case make ethernet iap as default
 * by changing its ranking to one(1). 
 * @ See te_dnssuffixcedv2.xml
 * @See te_dnssuffixsuite.script for below line
 * ced -i z:\testdata\configs\te_dnssuffixcedv2.xml 
 *
 */
void CDNSSuffixTestWrapper::DNSSuffixSupportTC007L()
    {
    INFO_PRINTF1(_L("**********************************************************************"));
    INFO_PRINTF1(_L("DNS_Suffix_Test007L - DNS_Suffix_Support_007"));
    INFO_PRINTF1(_L("**********************************************************************"));
    
    TPtrC validHostname;
    TPtrC inValidHostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest007,KKeyDNSSuffixTest007ValidHostname,validHostname))
        {
        ERR_PRINTF1(_L("Failed to read the valid host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Valid Host name: %S"),&validHostname);       
        }
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest007,KKeyDNSSuffixTest007InValidHostname,inValidHostname))
        {
        ERR_PRINTF1(_L("Failed to read the invalid host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Invalid Host name: %S"),&inValidHostname);       
        }   
   
    // @Santosh K Patil
    // Note: Remove the suffix lists from the interfaces set by previous test cases, if any.    
    // Note: start multiple interfaces
    
    TFileName interfaceName;
    TInt err = KErrNone;
    err = GetFirstInterfaceNameL(interfaceName);
    
    /*
     * @Note: Remove the suffix list set on the interface (which we set in earlier test cases) 
     *  by just setting empty list on it.
     */
    INFO_PRINTF1(_L("Setting empty suffix list on interface:"));
    iSuffixList.Reset();
    
    if ( (err = iSocketServ.Connect()) != KErrNone)
       {
       ERR_PRINTF1(_L("Failed Connecting to socket server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);
           
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF1(_L("Removed suffix list from interface:"));

    INFO_PRINTF1(_L("Opening implicit resolver"));
    // Open implicit resolver.
    RHostResolver resolver;
    
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);        
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    INFO_PRINTF2(_L("Requesting to resolve valid hostname: %S"),&validHostname);
    
    if ( (err = resolver.GetByName(validHostname,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Host resolution failed for %S with error: %D"),&validHostname,err);       
      }
    else
      {
      TInetAddr& netAddress = TInetAddr::Cast(nameEntry().iAddr);
      
      if (netAddress.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> address;
          netAddress.Output(address);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&address);
          }
      }    
    
    if (err == KErrNone)
        {
        TNameEntry nameEntry2;
        
        INFO_PRINTF2(_L("Requesting to resolve invalid hostname: %S"),&inValidHostname);
        
        if ( (err = resolver.GetByName(inValidHostname,nameEntry2)) != KErrNone)
          {
          INFO_PRINTF3(_L("Host resolution failed for %S with error: %D"),&inValidHostname,err);
          INFO_PRINTF1(_L("Test scenario passed"));
          err = KErrNone;
          }
        else
          {
          err = KErrArgument;
          INFO_PRINTF1(_L("Error: Seems host is resolvable"));
          }        
        }
    
    SetError(err);
    
    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close();    
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC007L - Exit"));
    }


void CDNSSuffixTestWrapper::DNSSuffixSupportTC008L()
    {
    INFO_PRINTF1(_L("**********************************************************************"));
    INFO_PRINTF1(_L("DNS_Suffix_Test008L - DNS_Suffix_Support_008"));
    INFO_PRINTF1(_L("**********************************************************************"));
    
    TPtrC hostname1;
    TPtrC hostname2;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest008,KKeyDNSSuffixTestHostname1,hostname1))
        {
        ERR_PRINTF1(_L("Failed to read the 1 host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name1: %S"),&hostname1);       
        }
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest008,KKeyDNSSuffixTestHostname2,hostname2))
        {
        ERR_PRINTF1(_L("Failed to read the 2 host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name2: %S"),&hostname2);       
        }   
   
    // @Santosh K Patil
    // @note: Set suffix lists on both interfaces (eth and vtun)    
    // @note: start multiple interfaces
    
    TName ethernetInterface;
    TName vTunInterface;
    TInt err = KErrNone;
    err = GetFirstInterfaceNameL(ethernetInterface);
    
    if (KErrNone != err)
        { 
        ERR_PRINTF1(_L("Failed get the name of the interface (ethernet)"));    
        SetError(KErrNotFound);
        return;
        }
    
#ifndef DISABLE_TUNDRIVER
    err = GetSecondInterfaceNameL(vTunInterface);
    
    if (KErrNone != err)
        { 
        ERR_PRINTF1(_L("Failed get the name of the interface (vTun)"));    
        SetError(KErrNotFound);
        return;
        }
#endif
   
    INFO_PRINTF1(_L("Setting suffix list on interface:"));
    
    iSuffixList2.Reset();
    
    TPtrC suffixList;
    if (!GetStringFromConfig(KSectionDNSSuffixTest008,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList2,suffixList);
        }   
    
    if ( (err = iSocketServ.Connect()) != KErrNone)
       {
       ERR_PRINTF1(_L("Failed Connecting to socket server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,ethernetInterface,iSuffixList2);
             
    if (KErrNone != err)
        {
        ERR_PRINTF3(_L("Failed Setting the suffix list on %S with errror : %D"),&ethernetInterface,err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF2(_L("Set suffix list on %S successfully"),&ethernetInterface);
    
#ifndef DISABLE_TUNDRIVER
    err = SetDNSSuffixListOnInterface(iSocketServ,vTunConn,vTunInterface,iSuffixList2);
               
    if (KErrNone != err)
        {
        ERR_PRINTF3(_L("Failed Setting the suffix list on %S with errror : %D"),&vTunInterface,err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF2(_L("Set suffix list on %S successfully"),&vTunInterface);        
#endif
    
    INFO_PRINTF1(_L("Opening implicit resolver"));
    // Open implicit resolver.
    RHostResolver resolver;
    INFO_PRINTF1(_L("Creating implicit resolver"));
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);        
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to implicit Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname1);
    
    if ( (err = resolver.GetByName(hostname1,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Failed to resolve the host %S with error: %D"),&hostname1,err);       
      }
    else
      {
      TInetAddr& netAddress = TInetAddr::Cast(nameEntry().iAddr);
      
      if (netAddress.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> address;
          netAddress.Output(address);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&address);
          }
      }    
    
    INFO_PRINTF1(_L("Closing implicit host resolver"));
    resolver.Close(); 
        
#ifndef DISABLE_TUNDRIVER
    if (err == KErrNone)
        {
        // Open explicit resolver.
        RHostResolver resolver2;
        INFO_PRINTF1(_L("Creating explicit resolver"));
        if ( (err = resolver2.Open(iSocketServ,KAfInet,KProtocolInetUdp,vTunConn)) != KErrNone)
            {
            ERR_PRINTF2(_L("Failed Connecting to explicit Host resolver with error: %D"),err);
            firstConn.Close();
            vTunConn.Close();
            CloseSocketSrv();
            SetError(err);        
            return;
            }       
        
        INFO_PRINTF1(_L("Connected to explicit Host resolver successfully"));
        
        
        TNameEntry nameEntry2;        
        INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname2);
        
        if ( (err = resolver2.GetByName(hostname2,nameEntry2)) != KErrNone)
          {
          INFO_PRINTF3(_L("Host resolution failed for %S with error: %D"),&hostname2,err);
          INFO_PRINTF1(_L("Test scenario passed"));
          err = KErrNone;
          }
        else
          {
          err = KErrArgument;
          INFO_PRINTF1(_L("Error: Seems host is resolvable"));
          }      
        
        INFO_PRINTF1(_L("Closing explicit host resolver"));
        resolver2.Close();    
        }
#endif
    
    SetError(err);
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC008L - Exit"));
    }


// TODO: Cross check the correct ness of the implementation.
void CDNSSuffixTestWrapper::DNSSuffixSupportTC009L()
    {
    INFO_PRINTF1(_L("**********************************************************************"));
    INFO_PRINTF1(_L("DNSSuffixSupportTC009L - DNS_Suffix_Support_009"));
    INFO_PRINTF1(_L("**********************************************************************"));
    
    TPtrC hostname1;
    TPtrC hostname2;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest009,KKeyDNSSuffixTestHostname1,hostname1))
        {
        ERR_PRINTF1(_L("Failed to read the 1 host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name1: %S"),&hostname1);       
        }
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest009,KKeyDNSSuffixTestHostname2,hostname2))
        {
        ERR_PRINTF1(_L("Failed to read the 2 host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name2: %S"),&hostname2);       
        }
    
    /*
     * @Santosh K Patil        
     * @note: start multiple interfaces
     * Set suffix lists on vTunnel interface    
     * Open explicit connection on other interface
     */
     TInt err = KErrNone;
#ifndef DISABLE_TUNDRIVER
    TFileName vTunInterface;
    err = GetSecondInterfaceNameL(vTunInterface);
    
    if (KErrNone != err)
        { 
        ERR_PRINTF1(_L("Failed get the name of the interface (vTun)"));    
        SetError(KErrNotFound);
        return;
        }    
   
    INFO_PRINTF1(_L("Setting suffix list on vTun interface:"));
    
    iSuffixList.Reset();
    
    TPtrC suffixList;
    if (!GetStringFromConfig(KSectionDNSSuffixTest009,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }
#endif

    if ( (err = iSocketServ.Connect()) != KErrNone)
       {
       ERR_PRINTF1(_L("Failed Connecting to socket server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
#ifndef DISABLE_TUNDRIVER
    err = SetDNSSuffixListOnInterface(iSocketServ,vTunConn,vTunInterface,iSuffixList);
                   
    if (KErrNone != err)
        {
        ERR_PRINTF3(_L("Failed Setting the suffix list on %S with errror : %D"),&vTunInterface,err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF2(_L("Set suffix list on %S successfully"),&vTunInterface);  
#endif

    INFO_PRINTF1(_L("Opening explicit resolver"));
    // Open implicit resolver.
    RHostResolver resolver;
    INFO_PRINTF1(_L("Creating explicit resolver"));
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);        
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to explicit Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname1);
    
    if ( (err = resolver.GetByName(hostname1,nameEntry)) != KErrNone)
      {
      ERR_PRINTF3(_L("Failed to resolve the host %S with error: %D"),&hostname1,err);       
      }
    else
      {
      TInetAddr& netAddress = TInetAddr::Cast(nameEntry().iAddr);
      
      if (netAddress.IsUnspecified())
          {
          ERR_PRINTF1(_L("Invalid host address"));
          err = KErrArgument;
          }
      else
          {
          TBuf<KIPAddrLen> address;
          netAddress.Output(address);
          INFO_PRINTF1(_L("Got valid IP address:"));
          INFO_PRINTF2(_L("Host name: %S"),&nameEntry().iName);
          INFO_PRINTF2(_L("Host address: %S"),&address);
          }
      }
        
    if (err == KErrNone)
        { 
        TNameEntry nameEntry2;        
        INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname2);
        
        if ( (err = resolver.GetByName(hostname2,nameEntry2)) != KErrNone)
          {
          INFO_PRINTF3(_L("Host resolution failed for %S with error: %D"),&hostname2,err);
          INFO_PRINTF1(_L("Test scenario passed"));
          err = KErrNone;
          }
        else
          {
          // TODO: We have to change this once we come up with end to end setup for VTun err = KErrArgument;
          INFO_PRINTF1(_L("We assumed that host is resolved through explicit connection and hence test is pass."));
          INFO_PRINTF1(_L("We have to change this once we come up with end to end setup for VTun."));
          err = KErrNone;
         // INFO_PRINTF1(_L("Error: Seems host is resolvable"));
          } 
        }   
    
    SetError(err);

    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close(); 
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC009L - Exit"));
    }


// TODO: If I set suffix list name of length with max size then client panic's.
void CDNSSuffixTestWrapper::DNSSuffixSupportTC010L()
    {
    INFO_PRINTF1(_L("**********************************************************************"));
    INFO_PRINTF1(_L("DNSSuffixSupportTC010L - DNS_Suffix_Support_010"));
    INFO_PRINTF1(_L("**********************************************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest010,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name1: %S"),&hostname);       
        }
    
    // @Santosh K Patil     
    // @note: start multiple interfaces
    // @note: Set long suffix lists on both interface  
    // @note: Create explicit resolver and set the suffixlist with max size.
    
    TFileName ethernetInterface;
    TInt err = KErrNone;
    err = GetFirstInterfaceNameL(ethernetInterface);
    
    if (KErrNone != err)
        { 
        ERR_PRINTF1(_L("Failed get the name of the interface (ethernet)"));    
        SetError(KErrNotFound);
        return;
        }
  
    INFO_PRINTF1(_L("Setting suffix list on interface:"));
    iSuffixList.Reset();
    
    
    // @Ganesh - Constructing suffix list for FillSuffixList with 3 separate suffix name entries in ini
    // @Ganesh - as the names are too long for the parser to parse and add it in one GetStringFromConfig call 
    TPtrC suffixName;
    TBuf<1024> suffixList;
    if (!GetStringFromConfig(KSectionDNSSuffixTest010,KKeyDNSSuffixTestSuffixList1,suffixName))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF1(_L("Suffix name:"));
        INFO_PRINTF2(_L("%S"),&suffixName);
        suffixList.Append(suffixName);
        suffixList.Append(_L(";"));
        }

    if (!GetStringFromConfig(KSectionDNSSuffixTest010,KKeyDNSSuffixTestSuffixList2,suffixName))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF1(_L("Suffix name:"));
        INFO_PRINTF2(_L("%S"),&suffixName);
        suffixList.Append(suffixName);
        suffixList.Append(_L(";"));
        }
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest010,KKeyDNSSuffixTestSuffixList3,suffixName))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF1(_L("Suffix name:"));
        INFO_PRINTF2(_L("%S"),&suffixName);
        suffixList.Append(suffixName);
        }
    FillSuffixList(iSuffixList,suffixList);
    
    if ( (err = iSocketServ.Connect()) != KErrNone)
       {
       ERR_PRINTF1(_L("Failed Connecting to socket server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,ethernetInterface,iSuffixList);
                  
    if (KErrNone != err)
        {
        ERR_PRINTF3(_L("Failed Setting the suffix list on %S with errror : %D"),&ethernetInterface,err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF2(_L("Set suffix list on %S successfully"),&ethernetInterface);  
    
    INFO_PRINTF1(_L("Opening explicit resolver"));
    
    RHostResolver resolver;
    INFO_PRINTF1(_L("Creating explicit resolver"));
    if ( (err = resolver.Open(iSocketServ,KAfInet,KProtocolInetUdp,firstConn)) != KErrNone)
        {
        ERR_PRINTF2(_L("Failed Connecting to Host resolver with error: %D"),err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        SetError(err);        
        return;
        }       
    
    INFO_PRINTF1(_L("Connected to explicit Host resolver successfully"));
               
    TNameEntry nameEntry;
    
    INFO_PRINTF2(_L("Requesting to resolve hostname: %S"),&hostname);
    
    if ( (err = resolver.GetByName(hostname,nameEntry)) != KErrNone)
      {
      INFO_PRINTF3(_L("Failed to resolve the host %S with error: %D"),&hostname,err);   
      INFO_PRINTF1(_L("Test Pass"));
      err = KErrNone;
      }
    else
      {
      err = KErrArgument;
      INFO_PRINTF1(_L("Host seems to be resolvable"));
      }    
    
    SetError(err);
    
    INFO_PRINTF1(_L("Closing host resolver"));
    resolver.Close();  
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC010L - Exit"));
    }


/*
 * @Test: Connection dissconnection test
 * 
 * Make vTun as default interface
 * Set suffix on ethernet
 * Open implicit resolver (assumed that it is opened on vTun)
 * Request for name resolution (Async one)
 * Stop the connection and observe the behaviour.(Expected, resolution should fail gracefully)
 * With appropriate error code.
 * 
 */
void CDNSSuffixTestWrapper::DNSSuffixSupportTC011L()
    {
    INFO_PRINTF1(_L("**********************************************************************"));
    INFO_PRINTF1(_L("DNSSuffixSupportTC011L - DNS_Suffix_Support_011"));
    INFO_PRINTF1(_L("**********************************************************************"));
    
    TPtrC hostname;
    
    if (!GetStringFromConfig(KSectionDNSSuffixTest011,KKeyDNSSuffixTestHostname,hostname))
        {
        ERR_PRINTF1(_L("Failed to read the host name from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF2(_L("Host name1: %S"),&hostname);       
        }
    
    TFileName ethernetInterface;
    TInt err = KErrNone;
    err = GetFirstInterfaceNameL(ethernetInterface);
    
    if (KErrNone != err)
        { 
        ERR_PRINTF1(_L("Failed get the name of the interface (ethernet)"));    
        SetError(KErrNotFound);
        return;
        }
  
    INFO_PRINTF1(_L("Setting suffix list on interface:"));
    iSuffixList.Reset();
        
    
    TPtrC suffixList;
    if (!GetStringFromConfig(KSectionDNSSuffixTest011,KKeyDNSSuffixTestSuffixList,suffixList))
        {
        ERR_PRINTF1(_L("Failed to read suffix lists from config"));    
        SetError(KErrNotFound);
        return;
        }
    else
        {
        INFO_PRINTF1(_L("Suffix list:"));
        INFO_PRINTF2(_L("%S"),&suffixList);
        FillSuffixList(iSuffixList,suffixList);
        }   
    
    if ( (err = iSocketServ.Connect()) != KErrNone)
       {
       ERR_PRINTF1(_L("Failed Connecting to socket server"));
       SetError(err);
       return;
       }
    
    INFO_PRINTF1(_L("Connected to socket server successfully"));
    
    RConnection vTunConn; // used for vTunnel
    RConnection firstConn; 
    
    err = StartConnections(iSocketServ,firstConn, vTunConn);
    
    if (err != KErrNone)
      {
      ERR_PRINTF1(_L("Failed to start connections"));
      CloseSocketSrv();
      SetError(err);
      return;
      }
    
    INFO_PRINTF1(_L("Connections started successfully"));
    
    err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,ethernetInterface,iSuffixList);
                     
    if (KErrNone != err)
        {
        ERR_PRINTF3(_L("Failed Setting the suffix list on %S with errror : %D"),&ethernetInterface,err);
        SetError(err);
        firstConn.Close();
        vTunConn.Close();
        CloseSocketSrv();
        return;
        }
    
    INFO_PRINTF2(_L("Set suffix list on %S successfully"),&ethernetInterface);  

    
    // Open explcit resolver. using CDNSSuffixHostResolver    
    CDNSSuffixHostResolver* resolver = CDNSSuffixHostResolver::NewLC(*this,iSocketServ,firstConn);
    
    INFO_PRINTF2(_L("Request to resolve host(async): %S"),&hostname);
    err = resolver->ResolveL(hostname);
    
    INFO_PRINTF1(_L("Stoping the connection"));
    
    err = firstConn.Stop();
    
    // Note: we have to stop the wait loop in HandleCallBackL
    iWait.Start();
    
    CleanupStack::PopAndDestroy();
    
    INFO_PRINTF1(_L("Closing connections and socket serv session"));
    firstConn.Close();
    vTunConn.Close();
    CloseSocketSrv();           
    INFO_PRINTF1(_L("CDNSSuffixTestWrapper::DNSSuffixSupportTC011L - Exit"));
    }


// End of file