1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

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

    15 //

    16 

    17 /**

    18  @file

    19  @internalTechnology

    20  */

    21 

    22 #include "te_dnssuffixtestwrapper.h"

    23 #include "DNSSuffixHostResolver.h"

    24 

    25 

    26 #include <e32base.h>

    27 #include <in_sock.h>

    28 #include <es_sock.h>

    29 #include <commdbconnpref.h>

    30 #include <commdb.h>

    31 

    32 /*

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

    34  * 

    35  * 

    36  */

    37 #define KIPAddrLen 39

    38 

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

    40 #define KMaxHosts 8

    41 

    42 // Commands

    43 _LIT(KInitDNSSuffixTesting, "InitDNSSuffixTesting");

    44 _LIT(KEnumerateInterface,   "EnumerateInterface");

    45 _LIT(KSetAndGetSuffixList,  "SetAndGetSuffixList");

    46 _LIT(KDoResolve,            "DoResolve");

    47 _LIT(KDoResolveHostWithoutDomainWithSuffix,     "DoResolveHostWithoutDomainWithSuffix");

    48 _LIT(KDoResolveHostWithoutDomainWithoutSuffix,  "DoResolveHostWithoutDomainWithoutSuffix");

    49 

    50 _LIT(KDNSSuffixSupportTC005,    "DNSSuffixSupportTC005");

    51 _LIT(KDNSSuffixSupportTC006,    "DNSSuffixSupportTC006");

    52 _LIT(KDNSSuffixSupportTC007,    "DNSSuffixSupportTC007");

    53 _LIT(KDNSSuffixSupportTC008,    "DNSSuffixSupportTC008");

    54 _LIT(KDNSSuffixSupportTC009,    "DNSSuffixSupportTC009");

    55 _LIT(KDNSSuffixSupportTC010,    "DNSSuffixSupportTC010");

    56 _LIT(KDNSSuffixSupportTC011,    "DNSSuffixSupportTC011");

    57 

    58 

    59 //Test code

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

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

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

    63 

    64 _LIT(KKeyDNSSuffixTestSuffixList,   "suffixlist");

    65 _LIT(KKeyDNSSuffixTestSuffixList1,   "suffixlist1");

    66 _LIT(KKeyDNSSuffixTestSuffixList2,   "suffixlist2");

    67 _LIT(KKeyDNSSuffixTestSuffixList3,   "suffixlist3");

    68 

    69 _LIT(KKeyDNSSuffixTestHostname,     "hostname");

    70 

    71 _LIT(KSectionDNSSuffixTest001,      "dnssuffix_test001");

    72 _LIT(KSectionDNSSuffixTest002,      "dnssuffix_test002");

    73 _LIT(KSectionDNSSuffixTest003,      "dnssuffix_test003");

    74 _LIT(KSectionDNSSuffixTest004,      "dnssuffix_test004");

    75 _LIT(KSectionDNSSuffixTest005,      "dnssuffix_test005");

    76 

    77 _LIT(KSectionDNSSuffixTest006,          "dnssuffix_test006");

    78 _LIT(KKeyDNSSuffixTest006NoOfHostname,  "noofhosts");

    79 _LIT(KKeyDNSSuffixTest006Hostname,      "hostname%D");

    80 

    81 _LIT(KSectionDNSSuffixTest007,              "dnssuffix_test007");

    82 _LIT(KKeyDNSSuffixTest007ValidHostname,     "validhostname");

    83 _LIT(KKeyDNSSuffixTest007InValidHostname,   "invalidhostname");

    84 

    85 _LIT(KSectionDNSSuffixTest008,      "dnssuffix_test008");

    86 _LIT(KKeyDNSSuffixTestHostname1,    "hostname1");

    87 _LIT(KKeyDNSSuffixTestHostname2,    "hostname2");

    88 

    89 _LIT(KSectionDNSSuffixTest009,      "dnssuffix_test009");

    90 

    91 _LIT(KSectionDNSSuffixTest010,      "dnssuffix_test010");

    92 

    93 _LIT(KSectionDNSSuffixTest011,      "dnssuffix_test011");

    94 

    95 _LIT(KSectionDNSSuffixFirstInterface, "dnssuffix_first_interface");

    96 _LIT(KSectionDNSSuffixSecondInterface, "dnssuffix_second_interface");

    97 _LIT(KKeyDNSSuffixIAPId,"iapid");

    98 _LIT(KKeyInterfaceName,                "interfacename");

    99 

   100 /*

   101  * @author: Santosh K Patil

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

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

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

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

   106  * @See Test spec for more details.

   107  * 

   108  * TODO: Check all config sections

   109  */

   110 

   111 

   112 /**

   113 Constructor.

   114 

   115 @internalTechnology

   116  */

   117 CDNSSuffixTestWrapper::CDNSSuffixTestWrapper()

   118     {

   119     }

   120 

   121 /**

   122 Destructor.

   123 

   124 @internalTechnology

   125  */

   126 CDNSSuffixTestWrapper::~CDNSSuffixTestWrapper()

   127     {  

   128     

   129     }

   130 

   131 /**

   132 Function to instantiate TestWrapper.

   133 @return Returns constructed TestWrapper instance pointer

   134 @internalTechnology

   135  */

   136 CDNSSuffixTestWrapper* CDNSSuffixTestWrapper::NewL()

   137     {

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

   139     CleanupStack::PushL(ret);

   140     ret->ConstructL();

   141     CleanupStack::Pop(ret);

   142     return ret;	

   143     }

   144 

   145 /**

   146 Second level constructor, constructs TestWrapper instance.

   147 @internalTechnology

   148  */

   149 void CDNSSuffixTestWrapper::ConstructL()

   150     {    

   151     }

   152 

   153 

   154 /*

   155  * @HandleCallBackL Called by the CDNSSuffixHostResolver::RunL

   156  * 

   157  */

   158 void CDNSSuffixTestWrapper::HandleCallBackL(TInt aError)

   159     {

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

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

   162     

   163     if (KErrNone != aError)

   164         SetError(KErrNone);

   165     else

   166         SetError(KErrGeneral);

   167     

   168     if (iWait.IsStarted())

   169         {

   170         INFO_PRINTF1(_L("Stoping waiter"));

   171         iWait.AsyncStop();

   172         }

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

   174     }

   175 

   176 /**

   177 Function to map the input command to respective function.

   178 

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

   180 @param aCommand Function name has to be called

   181 @param aSection INI file paramenter section name

   182 @param aAsyncErrorIndex Error index

   183 @see Refer the script file COMMAND section.

   184 

   185 @internalTechnology

   186  */

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

   188     {

   189     TBool ret = ETrue;

   190 

   191     // Print out the parameters for debugging

   192     INFO_PRINTF2( KCommand, &aCommand );

   193     INFO_PRINTF2( KSection, &aSection );

   194     INFO_PRINTF2( KAsyncErrorIndex, aAsyncErrorIndex );

   195     

   196     if(KInitDNSSuffixTesting() == aCommand)

   197         {

   198         DoInitTestingL();

   199         }

   200     else if(KEnumerateInterface() == aCommand)

   201         {

   202         DoEnumerateInterfacesL();

   203         }

   204     else if (KSetAndGetSuffixList() == aCommand)

   205         {

   206         DoSetAndGetSuffixListL();

   207         }

   208     else if( KDoResolve() == aCommand)

   209         {

   210         DoResolveL();

   211         }

   212     else if( KDoResolveHostWithoutDomainWithSuffix() == aCommand)

   213         {

   214         DoResolveHostWithoutDomainWithSuffixListSetL();

   215         }    

   216     else if( KDoResolveHostWithoutDomainWithoutSuffix() == aCommand)

   217         {

   218         DoResolveHostWithoutDomainWithoutSuffixListL();

   219         }

   220     else if( KDNSSuffixSupportTC005() == aCommand)

   221         {

   222         DNSSuffixSupportTC005L();

   223         }

   224     else if( KDNSSuffixSupportTC006() == aCommand)

   225         {

   226         DNSSuffixSupportTC006L();

   227         }

   228     else if( KDNSSuffixSupportTC007() == aCommand)

   229         {

   230         DNSSuffixSupportTC007L();

   231         }

   232     else if( KDNSSuffixSupportTC008() == aCommand)

   233         {

   234         DNSSuffixSupportTC008L();

   235         }

   236     else if( KDNSSuffixSupportTC009() == aCommand)

   237         {

   238         DNSSuffixSupportTC009L();

   239         }

   240     else if( KDNSSuffixSupportTC010() == aCommand)

   241        {

   242        DNSSuffixSupportTC010L();

   243        }

   244     else if( KDNSSuffixSupportTC011() == aCommand)

   245        {

   246        DNSSuffixSupportTC011L();

   247        }    

   248     else

   249         {        

   250         ret = EFalse;

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

   252         }

   253     

   254     return ret;

   255     }

   256 

   257 

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

   259     {

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

   261     

   262     TUint iapId = GetFirstIapId();

   263     

   264     if ((TInt)iapId == KErrNotFound)

   265         return KErrNotFound;

   266     

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

   268         

   269     if (err != KErrNone)

   270         {

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

   272         SetError(err);

   273         return err;

   274         }

   275         

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

   277         

   278     iapId = GetSecondIapId();

   279              

   280     if ((TInt)iapId == KErrNotFound)

   281         {       

   282         aConn1.Close();

   283         return KErrNotFound;

   284         }

   285         

   286     err = StartConnection(iSocketServ,aConn2,iapId);

   287         

   288     if (err != KErrNone)

   289         {

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

   291         aConn1.Close();

   292         return err;

   293         }

   294         

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

   296             

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

   298     return KErrNone;

   299     }

   300 

   301 

   302 

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

   304     {

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

   306     

   307     TInt err(KErrNone);

   308     

   309     TCommDbConnPref connPref;

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

   311     

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

   313     

   314     if (KErrNone != err)

   315         {

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

   317         return err;

   318         }

   319     

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

   321     

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

   323         {

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

   325         return err;

   326         }

   327         

   328     INFO_PRINTF1(_L("Connection opened"));

   329     

   330     INFO_PRINTF1(_L("Starting Connection"));

   331     err = aConn.Start(connPref);

   332     

   333     if (KErrNone != err)

   334         {

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

   336         aConn.Close();

   337         return err;

   338         }

   339     

   340     INFO_PRINTF1(_L("Connection Started"));

   341     

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

   343     

   344     return KErrNone;    

   345     }

   346 

   347    

   348 

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

   350     {

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

   352     

   353     INFO_PRINTF1(_L("Instantiating CCommsDatabase"));

   354     CCommsDatabase* commsDb = CCommsDatabase::NewL();

   355     CleanupStack::PushL(commsDb);

   356     

   357     INFO_PRINTF1(_L("Calling OpenConnectionPrefTableLC"));

   358     CCommsDbConnectionPrefTableView* commsDbView = commsDb->OpenConnectionPrefTableLC();

   359     

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

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

   362     

   363     TInt isFound(KErrNotFound);

   364     do

   365         {

   366         CCommsDbConnectionPrefTableView::TCommDbIapConnectionPref pref;

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

   368         commsDbView->ReadConnectionPreferenceL(pref);

   369         

   370         if (pref.iBearer.iIapId == aIapId)

   371             {

   372             INFO_PRINTF1(_L("Match found"));

   373             aPref.SetIapId(aIapId);

   374             aPref.SetBearerSet(pref.iBearer.iBearerSet);

   375             aPref.SetDirection(pref.iDirection);

   376             aPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

   377             isFound = KErrNone;

   378             break;

   379             }

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

   381     

   382     INFO_PRINTF1(_L("Cleanup resources"));

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

   384     

   385     User::LeaveIfError(isFound);

   386     

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

   388     }

   389 

   390 

   391 

   392 TInt32 CDNSSuffixTestWrapper::GetFirstIapId()

   393     {

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

   395     

   396     TInt iapId(KErrNotFound);

   397     

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

   399          {

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

   401          }

   402       else

   403          {

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

   405          }

   406     

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

   408     return iapId;

   409     }

   410 

   411 

   412 TInt32 CDNSSuffixTestWrapper::GetSecondIapId()

   413    {

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

   415    

   416    TInt iapId(KErrNotFound);

   417    

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

   419         {

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

   421         }

   422      else

   423         {

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

   425         }

   426    

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

   428    return iapId;

   429    }

   430  

   431 

   432 TInt CDNSSuffixTestWrapper::GetFirstInterfaceNameL(TDes& aIfaceName)

   433     {

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

   435     TInt err(KErrNone);    

   436     

   437     TPtrC interfaceName;

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

   439         {

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

   441         err = KErrNotFound;

   442         SetError(err);

   443         return err;

   444         }

   445         

   446     err = GetInterfaceNameL(interfaceName,aIfaceName);

   447     

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

   449     return err;

   450     }

   451     

   452 

   453 TInt CDNSSuffixTestWrapper::GetSecondInterfaceNameL(TDes& aIfaceName)

   454     {    

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

   456     TInt err(KErrNone);    

   457     

   458     TPtrC interfaceName;

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

   460         {

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

   462         err = KErrNotFound;

   463         SetError(err);

   464         return err;

   465         }    

   466     

   467     err = GetInterfaceNameL(interfaceName,aIfaceName);

   468     

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

   470     return err;    

   471     }

   472 

   473     

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

   475     {

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

   477 

   478     TInt err = KErrNone;

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

   480     CleanupStack::PushL(interfaceNameArray);

   481     TRAP(err,GetAvaiableInterfacesL(interfaceNameArray));

   482     

   483     if (KErrNone != err)

   484         {       

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

   486         return err;

   487         }

   488     

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

   490     

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

   492        {

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

   494        CleanupStack::PopAndDestroy(interfaceNameArray);

   495        err = KErrNotFound;

   496        SetError(err);

   497        return err;

   498        }

   499     

   500     TBool isInterfaceFound(EFalse);

   501     TInt index = -1;

   502    

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

   504        {

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

   506        

   507        TInt pos = interfaceNameBuf->FindF(aCriteria);

   508        

   509        delete interfaceNameBuf;

   510        

   511        if ( KErrNotFound != pos)

   512            {

   513            isInterfaceFound = ETrue;

   514            index = a;

   515            break;

   516            }

   517        }

   518     

   519     if (!isInterfaceFound)

   520         {

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

   522         CleanupStack::PopAndDestroy(interfaceNameArray);

   523         err = KErrNotFound;

   524         SetError(err);

   525         return err;

   526         }    

   527     

   528     aIfaceName.Copy((*interfaceNameArray)[index]);

   529     

   530     CleanupStack::PopAndDestroy(interfaceNameArray);

   531     

   532     TPtr tempName((TUint16*)aIfaceName.Ptr(),aIfaceName.Length(),aIfaceName.Length());

   533     INFO_PRINTF2(_L("Found Interface and name is: %S"),&tempName);

   534     

   535     INFO_PRINTF1(_L("GetInterfaceNameL - Exit"));

   536     return KErrNone;

   537     }

   538 

   539 /**

   540  * DoInitTestingL. Configures the initial connections. 

   541  * Function to start the connection to configure the named server on one interface. 

   542  */

   543 void CDNSSuffixTestWrapper::DoInitTestingL()

   544     {

   545     INFO_PRINTF1(_L("********************************************"));

   546     INFO_PRINTF1(_L("DoInitTestingL"));

   547     INFO_PRINTF1(_L("********************************************"));

   548 

   549     /*@Note, We need to configure the named servers on vTunnel and ethernet interfaces.

   550      * So, Configuring them by starting connections on both interfaces. 

   551      * 

   552      */

   553     TInt err = KErrNone;

   554     

   555     if((err = iSocketServ.Connect()) == KErrNone )

   556         INFO_PRINTF1(_L("Socket Server Opened."));

   557     else

   558         {

   559         ERR_PRINTF2(_L("Error Opening Socket Server: %d"), err);

   560         SetError(err);

   561         return;

   562         }

   563     

   564     ERR_PRINTF2(_L("Error Opening Socket Server: %d"), err);

   565     

   566     RConnection firstConn; 

   567     RConnection vTunConn; // Usef for virtual Tunnel interface

   568     

   569     err = StartConnections(iSocketServ,firstConn, vTunConn);

   570     

   571     if (KErrNone != err)

   572         {

   573         ERR_PRINTF2(_L("Failed to start the Connections: %D"),err);

   574         CloseSocketSrv();

   575         SetError(err);

   576         return;

   577         }

   578     INFO_PRINTF1(_L("Started the connections successfully"));

   579     

   580     INFO_PRINTF1(_L("Close the connections"));

   581    

   582     if (vTunConn.SubSessionHandle())

   583         vTunConn.Close();

   584 

   585     if (firstConn.SubSessionHandle())

   586         firstConn.Close();

   587     

   588     SetError(err);      

   589     CloseSocketSrv();    

   590     }

   591 

   592 /**

   593  * @DoEnumerateInterfacesL. Enumerates the all available interfaces.

   594  */

   595 void CDNSSuffixTestWrapper::DoEnumerateInterfacesL()

   596     {

   597     INFO_PRINTF1(_L("********************************************"));

   598     INFO_PRINTF1(_L("DoEnumerateInterfacesL"));

   599     INFO_PRINTF1(_L("********************************************"));

   600     

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

   602     CleanupStack::PushL(interfaceNameArray);

   603     TRAPD(err,GetAvaiableInterfacesL(interfaceNameArray));

   604    

   605     if (KErrNone == err)

   606         {

   607         // Print the interface names        

   608         INFO_PRINTF2(_L("Found %D interfaces"),interfaceNameArray->Count());

   609         

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

   611             {

   612             TPtrC interfaceName = (*interfaceNameArray)[a];

   613             INFO_PRINTF2(_L("Interface: %S"),&interfaceName);

   614             }

   615         }

   616     else

   617         {

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

   619         }

   620     

   621     CleanupStack::PopAndDestroy(interfaceNameArray);

   622     

   623     SetError(err);

   624     }

   625 

   626 /*

   627  * GetAvaiableInterfacesL. Function to get the names of all available names of  all interfaces.

   628  * @arg aInterfaceNamesArray (out param), Array of interface names owned by caller. 

   629  */

   630 void CDNSSuffixTestWrapper::GetAvaiableInterfacesL(MDesCArray* aInterfaceNamesArray)

   631     {

   632     INFO_PRINTF1(_L("GetAvaiableInterfacesL - Entry"));

   633     

   634     CDesCArray* interfacesArray = static_cast<CDesCArray*>(aInterfaceNamesArray);

   635     interfacesArray->Reset();

   636     

   637     TInt err = KErrNone;

   638     RSocketServ socketSrv;

   639     

   640     if ( (err = socketSrv.Connect()) != KErrNone)

   641         {

   642         ERR_PRINTF2(_L("Failed Connecting to Socet server error: %D"),err);

   643         SetError(err);

   644         return;

   645         }

   646     INFO_PRINTF1( _L("Connected to Socket server"));

   647     

   648     INFO_PRINTF1(_L("Opening socket..."));

   649     

   650     RSocket socket;

   651     err = socket.Open(socketSrv,KAfInet, KSockDatagram, KProtocolInetUdp);

   652     

   653     if (KErrNone != err)

   654         {

   655         INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);

   656         SetError(err);

   657         socketSrv.Close();

   658         return;

   659         }

   660     

   661     INFO_PRINTF1(_L("Socket opened"));

   662     

   663     err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);

   664   

   665     if (KErrNone != err)

   666         {

   667         INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);

   668         SetError(err);

   669         socket.Close();

   670         socketSrv.Close();

   671         return;

   672         }

   673     

   674     TSoInetInterfaceInfo info;

   675     TPckg<TSoInetInterfaceInfo> opt(info);

   676     

   677     while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)

   678         {

   679        // INFO_PRINTF2(_L("Interface Name %S"),&opt().iName);

   680         interfacesArray->AppendL(opt().iName);

   681         }

   682     

   683     INFO_PRINTF1(_L("Finished"));

   684     

   685     INFO_PRINTF1(_L("Closing connections"));

   686     socket.Close();

   687     socketSrv.Close();

   688     SetError(KErrNone);

   689     INFO_PRINTF1(_L("GetAvaiableInterfacesL - Exit"));

   690     }

   691 

   692 

   693 /**

   694 Function test the setting of suffix list and getting suffix list on interface.

   695 */

   696 void CDNSSuffixTestWrapper::DoSetAndGetSuffixListL()

   697     {

   698     INFO_PRINTF1(_L("************************************************************"));

   699     INFO_PRINTF1(_L("DoSetAndGetSuffixListL - DNS_Suffix_Support_TC001"));

   700     INFO_PRINTF1(_L("************************************************************"));

   701         

   702     TInt err(KErrNone);

   703     

   704     TName interfaceName;

   705     

   706     TRAP(err, err = GetFirstInterfaceNameL(interfaceName));

   707         

   708     if (err != KErrNone )

   709         {

   710         ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);

   711         SetError(err);

   712         return;

   713         }

   714     

   715     TPtrC suffixList;

   716     iSuffixList.Reset();

   717     

   718     if (!GetStringFromConfig(KSectionDNSSuffixTest001,KKeyDNSSuffixTestSuffixList,suffixList))

   719         {

   720         ERR_PRINTF1(_L("Failed to read suffix lists from config"));    

   721         SetError(KErrNotFound);

   722         return;

   723         }

   724     else

   725         {

   726         INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);

   727         FillSuffixList(iSuffixList,suffixList);

   728         }

   729             

   730     err = iSocketServ.Connect();

   731            

   732     if(KErrNone != err)

   733        {

   734        ERR_PRINTF1(_L("Failed to connect socket Server"));

   735        SetError(err);

   736        return;

   737        }

   738     

   739     INFO_PRINTF1(_L("Connected to socket Server"));

   740     

   741     TUint iapId = GetFirstIapId();

   742     

   743     if (KErrNotFound == (TInt)iapId)

   744        {

   745        ERR_PRINTF2(_L("Failed to get the iap id: %D"),err);

   746        SetError(err);

   747        CloseSocketSrv();

   748        return;

   749        }

   750     

   751     RConnection firstConn; 

   752     err = StartConnection(iSocketServ,firstConn,iapId);

   753     

   754     if (KErrNone != err)

   755       {

   756       ERR_PRINTF2(_L("Failed to start the Connections: %D"),err);

   757       CloseSocketSrv();

   758       SetError(err);

   759       return;

   760       }

   761     

   762     INFO_PRINTF1(_L("Started the connections successfully"));

   763     

   764     

   765     err = SetDNSSuffixListOnInterface(iSocketServ,firstConn,interfaceName,iSuffixList);

   766     

   767     if (KErrNone != err)

   768         {

   769         ERR_PRINTF2(_L("Failed Setting the suffix list with errror : %D"),err);

   770         SetError(err);  

   771         firstConn.Close();

   772         CloseSocketSrv();

   773         return;

   774         }

   775     

   776     INFO_PRINTF1(_L("Getting the suffix list on interface:"));

   777     

   778     iSuffixList2.Reset();

   779     

   780     err = GetDNSSuffixList(iSocketServ,interfaceName,iSuffixList2);

   781         

   782     if (KErrNone != err)

   783         {

   784         ERR_PRINTF2(_L("Failed to get the suffix list with errror : %D"),err);

   785         }

   786     

   787     

   788     if (err == KErrNone)

   789         {        

   790         if ( (err = IsSuffixListEqual(iSuffixList,iSuffixList2)) == KErrNone)

   791             {

   792             INFO_PRINTF1(_L("Suffix list are same and Test is successfull"));

   793             }

   794         else

   795             {

   796             ERR_PRINTF1(_L("Suffix list are not same and Test failed"));

   797             }

   798         }

   799     

   800     SetError(err);

   801     

   802     firstConn.Close();

   803     CloseSocketSrv();

   804     

   805     INFO_PRINTF1(_L("Set and Get Suffix list Test - Finished"));

   806     }

   807 

   808 

   809 

   810 TInt CDNSSuffixTestWrapper::SetDNSSuffixListOnInterface(RSocketServ& aServ,RConnection& /*aConn*/,const TDesC& aInterfaceName,RInetSuffixList& aData)

   811     {

   812     INFO_PRINTF1(_L("SetDNSSuffixListOnInterfaceL - Entry"));

   813     

   814     INFO_PRINTF1(_L("Opening socket..."));    

   815        

   816     RSocket socket;

   817     TInt err = socket.Open(aServ,KAfInet, KSockDatagram, KProtocolInetUdp);    

   818     

   819     if (KErrNone != err)

   820         {

   821         INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);

   822         SetError(err);

   823         return err;

   824         }

   825   

   826     INFO_PRINTF1(_L("Socket opened"));

   827     

   828     err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);

   829     

   830     if (KErrNone != err)

   831         {

   832         INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);

   833         SetError(err);        

   834         socket.Close();

   835         return err;

   836         }

   837     

   838 	TSoInetInterfaceInfo getOpt;

   839     TPckg<TSoInetInterfaceInfo> opt_out(getOpt);

   840     

   841     TBool isSuffixListSet(EFalse);

   842     

   843     while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt_out)== KErrNone)        

   844         {    

   845         

   846         INFO_PRINTF2(_L("Interface Name: %S"),&opt_out().iName);        

   847         INFO_PRINTF2(_L("Name Server: %D"),!opt_out().iNameSer1.IsUnspecified());

   848         

   849         TBuf<KIPAddrLen> ipBuf;

   850         opt_out().iAddress.Output(ipBuf);

   851         INFO_PRINTF2(_L("IP Address: %S"),&ipBuf);

   852 

   853         TBuf<KIPAddrLen> nameserBuf;

   854         opt_out().iNameSer1.Output(nameserBuf);

   855         INFO_PRINTF2(_L("Name Server IP: %S"),&nameserBuf);

   856 

   857         if( (opt_out().iName.Length()>0) /*&& !(opt_out().iNameSer1.IsUnspecified())*/ && (aInterfaceName.CompareF(opt_out().iName)==0) )       

   858             {

   859             INFO_PRINTF2(_L("Setting suffix list on Interface: %S"),&opt_out().iName);

   860             INFO_PRINTF2(_L("MTU on the interface is : %d"), opt_out().iMtu);

   861 

   862             TSoInetInterfaceInfoExtnDnsSuffix setOpt;

   863             (TSoInetInterfaceInfo &)setOpt = opt_out();

   864             TPckg<TSoInetInterfaceInfoExtnDnsSuffix> opt_in(setOpt);

   865             /*opt_in().iName = opt_out().iName;

   866             opt_in().iAddress = opt_out().iAddress;

   867             opt_in().iNetMask = opt_out().iNetMask;*/

   868             opt_in().iDoId = ETrue;

   869             opt_in().iDelete = EFalse;

   870             opt_in().iDomainSuffix.DeleteAll();

   871             

   872             err = socket.SetOpt(KSoInetConfigInterface,KSolInetIfCtrl,opt_in);

   873             

   874             if (err != KErrNone)

   875                 {

   876                 ERR_PRINTF2(_L("Failed to reset suffix list on the interface: %D"),err);

   877                 break;

   878                 }

   879             else

   880 	            INFO_PRINTF1(_L("Interface domain suffix list reset successful"));

   881             	

   882             if (aData.Count() == 0) // We plan to set empty record, so only reset is sufficient

   883                 isSuffixListSet = ETrue;

   884             

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

   886                 {

   887                 opt_in().iDomainSuffix.Copy(aData[a]);

   888                 err = socket.SetOpt(KSoInetConfigInterface,KSolInetIfCtrl,opt_in);

   889                 if (err != KErrNone)

   890                 	{

   891                 	ERR_PRINTF2(_L("Failed to set suffix list: %D"),err);

   892                 	break;

   893             		}

   894                 else

   895                 	{

   896 	                INFO_PRINTF1(_L("Suffix list added successfully"));

   897                 	isSuffixListSet = ETrue;

   898             		}

   899                 }

   900             break;

   901             }

   902         }

   903     

   904     if (!isSuffixListSet)

   905         {

   906         err = KErrNotFound;

   907         ERR_PRINTF2(_L("Failed to set suffix list with error: %D"),err);       

   908         }

   909         

   910     SetError(err);

   911     

   912     INFO_PRINTF1(_L("Closing socket"));

   913     

   914     socket.Close();

   915     INFO_PRINTF1(_L("SetDNSSuffixListOnInterfaceL - Exit"));

   916     return err;

   917     }

   918 

   919 

   920 

   921 /**

   922  * GetDNSSuffixList. Gets the suffix list set on an interface.

   923  * 

   924  * @arg  aServ, session handle to a socket server. 

   925  * @arg  aData (in/out param) Data having the suffix list. Packed buffer of type TInetSuffixList

   926  *

   927  */

   928 TInt CDNSSuffixTestWrapper::GetDNSSuffixList(RSocketServ& aServ,const TDesC& aInterfaceName,RInetSuffixList& aData)

   929     {

   930     INFO_PRINTF1(_L("GetDNSSuffixList - Entry"));

   931     

   932     INFO_PRINTF1(_L("Opening socket..."));

   933     RSocket socket;

   934     TInt err = socket.Open(aServ,KAfInet, KSockDatagram, KProtocolInetUdp);

   935     

   936     if (KErrNone != err)

   937        {

   938        INFO_PRINTF2(_L("Failed Opening socket with error: %D"),err);

   939        SetError(err);

   940        return err;

   941        }

   942     

   943     INFO_PRINTF1(_L("Socket opened"));

   944     

   945     err = socket.SetOpt(KSoInetEnumInterfaces,KSolInetIfCtrl);

   946     

   947     if (KErrNone != err)

   948        {

   949        INFO_PRINTF2(_L("Failed enumerating interfaces with error: %D"),err);

   950        SetError(err);

   951        socket.Close();

   952        return err;

   953        }

   954 

   955 	TSoInetInterfaceInfo getOpt;

   956     TPckg<TSoInetInterfaceInfo> opt(getOpt);

   957        

   958     while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)

   959 		{

   960 		if (aInterfaceName.CompareF(opt().iName) == KErrNone)

   961 			{

   962 			INFO_PRINTF2(_L("Reading suffix list from interface: %S"),&opt().iName);     

   963 

   964 			TBuf<KIPAddrLen> tempIp;

   965 			opt().iAddress.Output(tempIp);

   966 			INFO_PRINTF2(_L("IP: %S"),&tempIp);

   967 

   968 			TInetSuffix domainSuffix;

   969 			TPckg<TInetSuffix> dom_opt(domainSuffix);

   970 			if (err = socket.SetOpt(KSoInetEnumDomainSuffix, KSolInetIfCtrl) != KErrNone)

   971 				return err; 

   972 			while( socket.GetOpt(KSoInetNextDomainSuffix, KSolInetIfCtrl, dom_opt) == KErrNone)

   973 				{

   974                 aData.AppendL(dom_opt().iSuffixName);

   975 				}

   976 			break;

   977 			}

   978 		}

   979     

   980     INFO_PRINTF1(_L("Closing socket"));

   981     socket.Close();

   982 

   983     INFO_PRINTF1(_L("GetDNSSuffixList - Exit"));

   984     return KErrNone;

   985     }

   986 

   987 

   988 

   989 /**

   990  * FillSuffixListL, Function to fill the suffix names in the TInetSuffixList object. 

   991  * @arg aSuffixList, out param, on return has the suffix list set in it.

   992  * @arg aData, has the list of domain suffix names in the form of abc.xyz.com;efg.xyz.com

   993  */

   994 TInt CDNSSuffixTestWrapper::FillSuffixList(RInetSuffixList& aSuffixList,TDesC& aData)

   995     {

   996     INFO_PRINTF1(_L("FillSuffixList - Entry"));

   997     

   998     INFO_PRINTF2(_L("Processing Suffix list: %S"),&aData);

   999     

  1000     TPtr data((TUint16*)aData.Ptr(),aData.Length(),aData.Length());

  1001     data.TrimAll();

  1002     

  1003     TInt pos = KErrNone;

  1004     while( (pos = data.Find(_L(";"))) != KErrNotFound)

  1005         {

  1006         TPtr suffixItem((TUint16*)data.Left(pos).Ptr(),pos,pos);

  1007         INFO_PRINTF3(_L("Processing %D suffix name: %S"),/*sListBuf()*/iSuffixList.Count()+1,&suffixItem);

  1008         

  1009         TSuffixName tmpBuf;

  1010         tmpBuf.Copy(suffixItem);

  1011         aSuffixList.AppendL(tmpBuf);

  1012         data.Copy(data.Mid(pos+1));

  1013         }

  1014     data.TrimAll();

  1015     INFO_PRINTF3(_L("Processing %D suffix name: %S"),/*sListBuf()*/iSuffixList.Count()+1,&data);

  1016     INFO_PRINTF2(_L("Data Len: %D"),data.Length());

  1017     

  1018     TSuffixName tmpBuf;

  1019     tmpBuf.Copy(data);

  1020     aSuffixList.AppendL(tmpBuf);

  1021     

  1022     INFO_PRINTF1(_L("FillSuffixList - Exit"));

  1023     

  1024     return aSuffixList.Count() == 0 ? KErrNotFound : KErrNone;

  1025     }

  1026 

  1027 

  1028 void CDNSSuffixTestWrapper::CloseSocketSrv()

  1029     {

  1030     INFO_PRINTF1(_L("Closing socket server"));

  1031     

  1032     if (iSocketServ.Handle())

  1033         {

  1034         iSocketServ.Close();

  1035         INFO_PRINTF1(_L("Closed Sock Srv successfully"));

  1036         }

  1037     else

  1038         {

  1039         INFO_PRINTF1(_L("Inavild Sock Srv handle"));

  1040         }

  1041     }

  1042 

  1043 /* 

  1044  * IsSuffixListEqual, Utility function, compares the two suffix list structures. 

  1045  * @arg aSuffixList1 First structure holding the suffix list

  1046  * @arg aSuffixList2 second structure holding the suffix list

  1047  * 

  1048  * @return KErrNone if both suffix list strucures same otherwise KErrArgument.  

  1049  * 

  1050  */

  1051 TInt CDNSSuffixTestWrapper::IsSuffixListEqual(const RInetSuffixList& aSuffixList1, const RInetSuffixList& aSuffixList2)

  1052     {

  1053     INFO_PRINTF1(_L("IsSuffixListEqual - Entry"));

  1054     

  1055     if (aSuffixList1.Count() != aSuffixList2.Count())

  1056         {

  1057         return KErrArgument;

  1058         }

  1059     

  1060     for (TInt a=0; a<aSuffixList1.Count();a++)

  1061         {

  1062         if (aSuffixList1[a].CompareF(aSuffixList2[a]) != KErrNone)

  1063             {

  1064             return KErrArgument;

  1065             }

  1066         }

  1067     INFO_PRINTF1(_L("IsSuffixListEqual - Exit"));

  1068     return KErrNone;

  1069     }

  1070 

  1071 

  1072 /*

  1073  * Prerequisite: Two interfaces required to be up and running (virtual Tunnel and ethernet).

  1074  * 

  1075  * DoResolveL. Resolves the domain name

  1076  * 

  1077  * 

  1078  */

  1079 void CDNSSuffixTestWrapper::DoResolveL()

  1080     {

  1081     INFO_PRINTF1(_L("********************************************"));

  1082     INFO_PRINTF1(_L("DoResolveL  - DNS_Suffix_Support_TC002"));

  1083     INFO_PRINTF1(_L("********************************************"));

  1084     

  1085     TPtrC hostname;

  1086     

  1087     if (!GetStringFromConfig(KSectionDNSSuffixTest002,KKeyDNSSuffixTestHostname,hostname))

  1088         {

  1089         ERR_PRINTF1(_L("Failed to read the host name value"));    

  1090         SetError(KErrNotFound);

  1091         return;

  1092         }

  1093     else

  1094         {

  1095         INFO_PRINTF2(_L("Host name: %S"),&hostname);       

  1096         }

  1097 

  1098 	TInt err = KErrNone;

  1099     TName interfaceName;

  1100     

  1101     TRAP(err, err = GetFirstInterfaceNameL(interfaceName));

  1102         

  1103     if (err != KErrNone )

  1104         {

  1105         ERR_PRINTF2(_L("Failed to get the interface error: %D"),err);

  1106         SetError(err);

  1107         return;

  1108         }

  1109         

  1110     TPtrC suffixList;

  1111     iSuffixList.Reset();

  1112     

  1113     if (!GetStringFromConfig(KSectionDNSSuffixTest002,KKeyDNSSuffixTestSuffixList,suffixList))

  1114         {

  1115         ERR_PRINTF1(_L("Failed to read suffix lists from config"));    

  1116         SetError(KErrNotFound);

  1117         return;

  1118         }

  1119     else

  1120         {

  1121         INFO_PRINTF2(_L("Suffix list: %S"),&suffixList);

  1122         FillSuffixList(iSuffixList,suffixList);

  1123         }

  1124 

  1125     if ( (err = iSocketServ.Connect()) != KErrNone)

  1126         {

  1127         ERR_PRINTF1(_L("Failed Connecting to socket server"));

  1128         SetError(err);

  1129         return;

  1130         }

  1131     

  1132     INFO_PRINTF1(_L("Connected to socket server successfully"));

  1133     

  1134     /*