diff -r abbed5a4b42a -r 8d540f55e491 tcpiputils/dnd/Test/te_dnssuffix/src/te_dnssuffixtestwrapper.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tcpiputils/dnd/Test/te_dnssuffix/src/te_dnssuffixtestwrapper.cpp	Wed Sep 01 12:33:58 2010 +0100
@@ -0,0 +1,2599 @@
+// 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