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 #define DISABLE_TUNDRIVER

    40 

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

    42 #define KMaxHosts 8

    43 

    44 // Commands

    45 _LIT(KInitDNSSuffixTesting, "InitDNSSuffixTesting");

    46 _LIT(KEnumerateInterface,   "EnumerateInterface");

    47 _LIT(KSetAndGetSuffixList,  "SetAndGetSuffixList");

    48 _LIT(KDoResolve,            "DoResolve");

    49 _LIT(KDoResolveHostWithoutDomainWithSuffix,     "DoResolveHostWithoutDomainWithSuffix");

    50 _LIT(KDoResolveHostWithoutDomainWithoutSuffix,  "DoResolveHostWithoutDomainWithoutSuffix");

    51 

    52 _LIT(KDNSSuffixSupportTC005,    "DNSSuffixSupportTC005");

    53 _LIT(KDNSSuffixSupportTC006,    "DNSSuffixSupportTC006");

    54 _LIT(KDNSSuffixSupportTC007,    "DNSSuffixSupportTC007");

    55 _LIT(KDNSSuffixSupportTC008,    "DNSSuffixSupportTC008");

    56 _LIT(KDNSSuffixSupportTC009,    "DNSSuffixSupportTC009");

    57 _LIT(KDNSSuffixSupportTC010,    "DNSSuffixSupportTC010");

    58 _LIT(KDNSSuffixSupportTC011,    "DNSSuffixSupportTC011");

    59 

    60 

    61 //Test code

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

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

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

    65 

    66 _LIT(KKeyDNSSuffixTestSuffixList,   "suffixlist");

    67 _LIT(KKeyDNSSuffixTestSuffixList1,   "suffixlist1");

    68 _LIT(KKeyDNSSuffixTestSuffixList2,   "suffixlist2");

    69 _LIT(KKeyDNSSuffixTestSuffixList3,   "suffixlist3");

    70 

    71 _LIT(KKeyDNSSuffixTestHostname,     "hostname");

    72 

    73 _LIT(KSectionDNSSuffixTest001,      "dnssuffix_test001");

    74 _LIT(KSectionDNSSuffixTest002,      "dnssuffix_test002");

    75 _LIT(KSectionDNSSuffixTest003,      "dnssuffix_test003");

    76 _LIT(KSectionDNSSuffixTest004,      "dnssuffix_test004");

    77 _LIT(KSectionDNSSuffixTest005,      "dnssuffix_test005");

    78 

    79 _LIT(KSectionDNSSuffixTest006,          "dnssuffix_test006");

    80 _LIT(KKeyDNSSuffixTest006NoOfHostname,  "noofhosts");

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

    82 

    83 _LIT(KSectionDNSSuffixTest007,              "dnssuffix_test007");

    84 _LIT(KKeyDNSSuffixTest007ValidHostname,     "validhostname");

    85 _LIT(KKeyDNSSuffixTest007InValidHostname,   "invalidhostname");

    86 

    87 _LIT(KSectionDNSSuffixTest008,      "dnssuffix_test008");

    88 _LIT(KKeyDNSSuffixTestHostname1,    "hostname1");

    89 _LIT(KKeyDNSSuffixTestHostname2,    "hostname2");

    90 

    91 _LIT(KSectionDNSSuffixTest009,      "dnssuffix_test009");

    92 

    93 _LIT(KSectionDNSSuffixTest010,      "dnssuffix_test010");

    94 

    95 _LIT(KSectionDNSSuffixTest011,      "dnssuffix_test011");

    96 

    97 _LIT(KSectionDNSSuffixFirstInterface, "dnssuffix_first_interface");

    98 _LIT(KSectionDNSSuffixSecondInterface, "dnssuffix_second_interface");

    99 _LIT(KKeyDNSSuffixIAPId,"iapid");

   100 _LIT(KKeyInterfaceName,                "interfacename");

   101 

   102 /*

   103  * @author: Santosh K Patil

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

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

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

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

   108  * @See Test spec for more details.

   109  * 

   110  * TODO: Check all config sections

   111  */

   112 

   113 

   114 /**

   115 Constructor.

   116 

   117 @internalTechnology

   118  */

   119 CDNSSuffixTestWrapper::CDNSSuffixTestWrapper()

   120     {

   121     }

   122 

   123 /**

   124 Destructor.

   125 

   126 @internalTechnology

   127  */

   128 CDNSSuffixTestWrapper::~CDNSSuffixTestWrapper()

   129     {  

   130     

   131     }

   132 

   133 /**

   134 Function to instantiate TestWrapper.

   135 @return Returns constructed TestWrapper instance pointer

   136 @internalTechnology

   137  */

   138 CDNSSuffixTestWrapper* CDNSSuffixTestWrapper::NewL()

   139     {

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

   141     CleanupStack::PushL(ret);

   142     ret->ConstructL();

   143     CleanupStack::Pop(ret);

   144     return ret;	

   145     }

   146 

   147 /**

   148 Second level constructor, constructs TestWrapper instance.

   149 @internalTechnology

   150  */

   151 void CDNSSuffixTestWrapper::ConstructL()

   152     {    

   153     }

   154 

   155 

   156 /*

   157  * @HandleCallBackL Called by the CDNSSuffixHostResolver::RunL

   158  * 

   159  */

   160 void CDNSSuffixTestWrapper::HandleCallBackL(TInt aError)

   161     {

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

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

   164     

   165     if (KErrNone != aError)

   166         SetError(KErrNone);

   167     else

   168         SetError(KErrGeneral);

   169     

   170     if (iWait.IsStarted())

   171         {

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

   173         iWait.AsyncStop();

   174         }

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

   176     }

   177 

   178 /**

   179 Function to map the input command to respective function.

   180 

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

   182 @param aCommand Function name has to be called

   183 @param aSection INI file paramenter section name

   184 @param aAsyncErrorIndex Error index

   185 @see Refer the script file COMMAND section.

   186 

   187 @internalTechnology

   188  */

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

   190     {

   191     TBool ret = ETrue;

   192 

   193     // Print out the parameters for debugging

   194     INFO_PRINTF2( KCommand, &aCommand );

   195     INFO_PRINTF2( KSection, &aSection );

   196     INFO_PRINTF2( KAsyncErrorIndex, aAsyncErrorIndex );

   197     

   198     if(KInitDNSSuffixTesting() == aCommand)

   199         {

   200         DoInitTestingL();

   201         }

   202     else if(KEnumerateInterface() == aCommand)

   203         {

   204         DoEnumerateInterfacesL();

   205         }

   206     else if (KSetAndGetSuffixList() == aCommand)

   207         {

   208         DoSetAndGetSuffixListL();

   209         }

   210     else if( KDoResolve() == aCommand)

   211         {

   212         DoResolveL();

   213         }

   214     else if( KDoResolveHostWithoutDomainWithSuffix() == aCommand)

   215         {

   216         DoResolveHostWithoutDomainWithSuffixListSetL();

   217         }    

   218     else if( KDoResolveHostWithoutDomainWithoutSuffix() == aCommand)

   219         {

   220         DoResolveHostWithoutDomainWithoutSuffixListL();

   221         }

   222     else if( KDNSSuffixSupportTC005() == aCommand)

   223         {

   224         DNSSuffixSupportTC005L();

   225         }

   226     else if( KDNSSuffixSupportTC006() == aCommand)

   227         {

   228         DNSSuffixSupportTC006L();

   229         }

   230     else if( KDNSSuffixSupportTC007() == aCommand)

   231         {

   232         DNSSuffixSupportTC007L();

   233         }

   234     else if( KDNSSuffixSupportTC008() == aCommand)

   235         {

   236         DNSSuffixSupportTC008L();

   237         }

   238     else if( KDNSSuffixSupportTC009() == aCommand)

   239         {

   240         DNSSuffixSupportTC009L();

   241         }

   242     else if( KDNSSuffixSupportTC010() == aCommand)

   243        {

   244        DNSSuffixSupportTC010L();

   245        }

   246     else if( KDNSSuffixSupportTC011() == aCommand)

   247        {

   248        DNSSuffixSupportTC011L();

   249        }    

   250     else

   251         {        

   252         ret = EFalse;

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

   254         }

   255     

   256     return ret;

   257     }

   258 

   259 

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

   261     {

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

   263     

   264     TUint iapId = GetFirstIapId();

   265     

   266     if ((TInt)iapId == KErrNotFound)

   267         return KErrNotFound;

   268     

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

   270         

   271     if (err != KErrNone)

   272         {

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

   274         SetError(err);

   275         return err;

   276         }

   277         

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

   279     

   280 #ifndef DISABLE_TUNDRIVER

   281     iapId = GetSecondIapId();

   282              

   283     if ((TInt)iapId == KErrNotFound)

   284         {       

   285         aConn1.Close();

   286         return KErrNotFound;

   287         }

   288         

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

   290         

   291     if (err != KErrNone)

   292         {

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

   294         aConn1.Close();

   295         return err;

   296         }

   297         

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

   299 #endif

   300             

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

   302     return KErrNone;

   303     }

   304 

   305 

   306 

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

   308     {

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

   310     

   311     TInt err(KErrNone);

   312     

   313     TCommDbConnPref connPref;

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

   315     

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

   317     

   318     if (KErrNone != err)

   319         {

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

   321         return err;

   322         }

   323     

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

   325     

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

   327         {

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

   329         return err;

   330         }

   331         

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

   333     

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

   335     err = aConn.Start(connPref);

   336     

   337     if (KErrNone != err)

   338         {

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

   340         aConn.Close();

   341         return err;

   342         }

   343     

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

   345     

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

   347     

   348     return KErrNone;    

   349     }

   350 

   351    

   352 

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

   354     {

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

   356     

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

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

   359     CleanupStack::PushL(commsDb);

   360     

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

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

   363     

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

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

   366     

   367     TInt isFound(KErrNotFound);

   368     do

   369         {

   370         CCommsDbConnectionPrefTableView::TCommDbIapConnectionPref pref;

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

   372         commsDbView->ReadConnectionPreferenceL(pref);

   373         

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

   375             {

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

   377             aPref.SetIapId(aIapId);

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

   379             aPref.SetDirection(pref.iDirection);

   380             aPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

   381             isFound = KErrNone;

   382             break;

   383             }

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

   385     

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

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

   388     

   389     User::LeaveIfError(isFound);

   390     

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

   392     }

   393 

   394 

   395 

   396 TInt32 CDNSSuffixTestWrapper::GetFirstIapId()

   397     {

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

   399     

   400     TInt iapId(KErrNotFound);

   401     

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

   403          {

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

   405          }

   406       else

   407          {

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

   409          }

   410     

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

   412     return iapId;

   413     }

   414 

   415 

   416 TInt32 CDNSSuffixTestWrapper::GetSecondIapId()

   417    {

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

   419    

   420    TInt iapId(KErrNotFound);

   421    

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

   423         {

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

   425         }

   426      else

   427         {

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

   429         }

   430    

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

   432    return iapId;

   433    }

   434  

   435 

   436 TInt CDNSSuffixTestWrapper::GetFirstInterfaceNameL(TDes& aIfaceName)

   437     {

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

   439     TInt err(KErrNone);    

   440     

   441     TPtrC interfaceName;

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

   443         {

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

   445         err = KErrNotFound;

   446         SetError(err);

   447         return err;

   448         }

   449         

   450     err = GetInterfaceNameL(interfaceName,aIfaceName);

   451     

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

   453     return err;

   454     }

   455     

   456 

   457 TInt CDNSSuffixTestWrapper::GetSecondInterfaceNameL(TDes& aIfaceName)

   458     {    

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

   460     TInt err(KErrNone);    

   461     

   462     TPtrC interfaceName;

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

   464         {

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

   466         err = KErrNotFound;

   467         SetError(err);

   468         return err;

   469         }    

   470     

   471     err = GetInterfaceNameL(interfaceName,aIfaceName);

   472     

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

   474     return err;    

   475     }

   476 

   477     

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

   479     {

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

   481 

   482     TInt err = KErrNone;

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

   484     CleanupStack::PushL(interfaceNameArray);

   485     TRAP(err,GetAvaiableInterfacesL(interfaceNameArray));

   486     

   487     if (KErrNone != err)

   488         {       

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

   490         return err;

   491         }

   492     

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

   494     

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

   496        {

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

   498        CleanupStack::PopAndDestroy(interfaceNameArray);

   499        err = KErrNotFound;

   500        SetError(err);

   501        return err;

   502        }

   503     

   504     TBool isInterfaceFound(EFalse);

   505     TInt index = -1;

   506    

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

   508        {

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

   510        

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

   512        

   513        delete interfaceNameBuf;

   514        

   515        if ( KErrNotFound != pos)

   516            {

   517            isInterfaceFound = ETrue;

   518            index = a;

   519            break;

   520            }

   521        }

   522     

   523     if (!isInterfaceFound)

   524         {

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

   526         CleanupStack::PopAndDestroy(interfaceNameArray);

   527         err = KErrNotFound;

   528         SetError(err);

   529         return err;

   530         }    

   531     

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

   533     

   534     CleanupStack::PopAndDestroy(interfaceNameArray);

   535     

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

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

   538     

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

   540     return KErrNone;

   541     }

   542 

   543 /**

   544  * DoInitTestingL. Configures the initial connections. 

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

   546  */

   547 void CDNSSuffixTestWrapper::DoInitTestingL()

   548     {

   549     INFO_PRINTF1(_L("********************************************"));

   550     INFO_PRINTF1(_L("DoInitTestingL"));

   551     INFO_PRINTF1(_L("********************************************"));

   552 

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

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

   555      * 

   556      */

   557     TInt err = KErrNone;

   558     

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

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

   561     else

   562         {

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

   564         SetError(err);

   565         return;

   566         }

   567     

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

   569     

   570     RConnection firstConn; 

   571     RConnection vTunConn; // Usef for virtual Tunnel interface

   572     

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

   574     

   575     if (KErrNone != err)

   576         {

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

   578         CloseSocketSrv();

   579         SetError(err);

   580         return;

   581         }

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

   583     

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

   585    

   586 #ifndef DISABLE_TUNDRIVER

   587     if (vTunConn.SubSessionHandle())

   588         vTunConn.Close();

   589 #endif

   590 

   591     if (firstConn.SubSessionHandle())

   592         firstConn.Close();

   593     

   594     SetError(err);      

   595     CloseSocketSrv();    

   596     }

   597 

   598 /**

   599  * @DoEnumerateInterfacesL. Enumerates the all available interfaces.

   600  */

   601 void CDNSSuffixTestWrapper::DoEnumerateInterfacesL()

   602     {

   603     INFO_PRINTF1(_L("********************************************"));

   604     INFO_PRINTF1(_L("DoEnumerateInterfacesL"));

   605     INFO_PRINTF1(_L("********************************************"));

   606     

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

   608     CleanupStack::PushL(interfaceNameArray);

   609     TRAPD(err,GetAvaiableInterfacesL(interfaceNameArray));

   610    

   611     if (KErrNone == err)

   612         {

   613         // Print the interface names        

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

   615         

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

   617             {

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

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

   620             }

   621         }

   622     else

   623         {

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

   625         }

   626     

   627     CleanupStack::PopAndDestroy(interfaceNameArray);

   628     

   629     SetError(err);

   630     }

   631 

   632 /*

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

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

   635  */

   636 void CDNSSuffixTestWrapper::GetAvaiableInterfacesL(MDesCArray* aInterfaceNamesArray)

   637     {

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

   639     

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

   641     interfacesArray->Reset();

   642     

   643     TInt err = KErrNone;

   644     RSocketServ socketSrv;

   645     

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

   647         {

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

   649         SetError(err);

   650         return;

   651         }

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

   653     

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

   655     

   656     RSocket socket;

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

   658     

   659     if (KErrNone != err)

   660         {

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

   662         SetError(err);

   663         socketSrv.Close();

   664         return;

   665         }

   666     

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

   668     

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

   670   

   671     if (KErrNone != err)

   672         {

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

   674         SetError(err);

   675         socket.Close();

   676         socketSrv.Close();

   677         return;

   678         }

   679     

   680     TSoInetInterfaceInfo info;

   681     TPckg<TSoInetInterfaceInfo> opt(info);

   682     

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

   684         {

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

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

   687         }

   688     

   689     INFO_PRINTF1(_L("Finished"));

   690     

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

   692     socket.Close();

   693     socketSrv.Close();

   694     SetError(KErrNone);

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

   696     }

   697 

   698 

   699 /**

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

   701 */

   702 void CDNSSuffixTestWrapper::DoSetAndGetSuffixListL()

   703     {

   704     INFO_PRINTF1(_L("************************************************************"));

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

   706     INFO_PRINTF1(_L("************************************************************"));

   707         

   708     TInt err(KErrNone);

   709     

   710     TName interfaceName;

   711     

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

   713         

   714     if (err != KErrNone )

   715         {

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

   717         SetError(err);

   718         return;

   719         }

   720     

   721     TPtrC suffixList;

   722     iSuffixList.Reset();

   723     

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

   725         {

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

   727         SetError(KErrNotFound);

   728         return;

   729         }

   730     else

   731         {

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

   733         FillSuffixList(iSuffixList,suffixList);

   734         }

   735             

   736     err = iSocketServ.Connect();

   737            

   738     if(KErrNone != err)

   739        {

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

   741        SetError(err);

   742        return;

   743        }

   744     

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

   746     

   747     TUint iapId = GetFirstIapId();

   748     

   749     if (KErrNotFound == (TInt)iapId)

   750        {

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

   752        SetError(err);

   753        CloseSocketSrv();

   754        return;

   755        }

   756     

   757     RConnection firstConn; 

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

   759     

   760     if (KErrNone != err)

   761       {

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

   763       CloseSocketSrv();

   764       SetError(err);

   765       return;

   766       }

   767     

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

   769     

   770     

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

   772     

   773     if (KErrNone != err)

   774         {

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

   776         SetError(err);  

   777         firstConn.Close();

   778         CloseSocketSrv();

   779         return;

   780         }

   781     

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

   783     

   784     iSuffixList2.Reset();

   785     

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

   787         

   788     if (KErrNone != err)

   789         {

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

   791         }

   792     

   793     

   794     if (err == KErrNone)

   795         {        

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

   797             {

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

   799             }

   800         else

   801             {

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

   803             }

   804         }

   805     

   806     SetError(err);

   807     

   808     firstConn.Close();

   809     CloseSocketSrv();

   810     

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

   812     }

   813 

   814 

   815 

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

   817     {

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

   819     

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

   821        

   822     RSocket socket;

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

   824     

   825     if (KErrNone != err)

   826         {

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

   828         SetError(err);

   829         return err;

   830         }

   831   

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

   833     

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

   835     

   836     if (KErrNone != err)

   837         {

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

   839         SetError(err);        

   840         socket.Close();

   841         return err;

   842         }

   843     

   844 	TSoInetInterfaceInfo getOpt;

   845     TPckg<TSoInetInterfaceInfo> opt_out(getOpt);

   846     

   847     TBool isSuffixListSet(EFalse);

   848     

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

   850         {    

   851         

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

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

   854         

   855         TBuf<KIPAddrLen> ipBuf;

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

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

   858 

   859         TBuf<KIPAddrLen> nameserBuf;

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

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

   862 

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

   864             {

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

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

   867 

   868             TSoInetInterfaceInfoExtnDnsSuffix setOpt;

   869             (TSoInetInterfaceInfo &)setOpt = opt_out();

   870             TPckg<TSoInetInterfaceInfoExtnDnsSuffix> opt_in(setOpt);

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

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

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

   874             opt_in().iDoId = ETrue;

   875             opt_in().iDelete = EFalse;

   876             opt_in().iDomainSuffix.DeleteAll();

   877             

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

   879             

   880             if (err != KErrNone)

   881                 {

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

   883                 break;

   884                 }

   885             else

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

   887             	

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

   889                 isSuffixListSet = ETrue;

   890             

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

   892                 {

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

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

   895                 if (err != KErrNone)

   896                 	{

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

   898                 	break;

   899             		}

   900                 else

   901                 	{

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

   903                 	isSuffixListSet = ETrue;

   904             		}

   905                 }

   906             break;

   907             }

   908         }

   909     

   910     if (!isSuffixListSet)

   911         {

   912         err = KErrNotFound;

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

   914         }

   915         

   916     SetError(err);

   917     

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

   919     

   920     socket.Close();

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

   922     return err;

   923     }

   924 

   925 

   926 

   927 /**

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

   929  * 

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

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

   932  *

   933  */

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

   935     {

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

   937     

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

   939     RSocket socket;

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

   941     

   942     if (KErrNone != err)

   943        {

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

   945        SetError(err);

   946        return err;

   947        }

   948     

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

   950     

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

   952     

   953     if (KErrNone != err)

   954        {

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

   956        SetError(err);

   957        socket.Close();

   958        return err;

   959        }

   960 

   961 	TSoInetInterfaceInfo getOpt;

   962     TPckg<TSoInetInterfaceInfo> opt(getOpt);

   963        

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

   965 		{

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

   967 			{

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

   969 

   970 			TBuf<KIPAddrLen> tempIp;

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

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

   973 

   974 			TInetSuffix domainSuffix;

   975 			TPckg<TInetSuffix> dom_opt(domainSuffix);

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

   977 				return err; 

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

   979 				{

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

   981 				}

   982 			break;

   983 			}

   984 		}

   985     

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

   987     socket.Close();

   988 

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

   990     return KErrNone;

   991     }

   992 

   993 

   994 

   995 /**

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

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

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

   999  */

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

  1001     {

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

  1003     

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

  1005     

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

  1007     data.TrimAll();

  1008     

  1009     TInt pos = KErrNone;

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

  1011         {

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

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

  1014         

  1015         TSuffixName tmpBuf;

  1016         tmpBuf.Copy(suffixItem);

  1017         aSuffixList.AppendL(tmpBuf);

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

  1019         }

  1020     data.TrimAll();

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

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

  1023     

  1024     TSuffixName tmpBuf;

  1025     tmpBuf.Copy(data);

  1026     aSuffixList.AppendL(tmpBuf);

  1027     

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

  1029     

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

  1031     }

  1032 

  1033 

  1034 void CDNSSuffixTestWrapper::CloseSocketSrv()

  1035     {

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

  1037     

  1038     if (iSocketServ.Handle())

  1039         {

  1040         iSocketServ.Close();

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

  1042         }

  1043     else

  1044         {

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

  1046         }

  1047     }

  1048 

  1049 /* 

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

  1051  * @arg aSuffixList1 First structure holding the suffix list

  1052  * @arg aSuffixList2 second structure holding the suffix list

  1053  * 

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

  1055  * 

  1056  */

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

  1058     {

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

  1060     

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

  1062         {

  1063         return KErrArgument;

  1064         }

  1065     

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

  1067         {

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

  1069             {

  1070             return KErrArgument;

  1071             }

  1072         }

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

  1074     return KErrNone;

  1075     }

  1076 

  1077 

  1078 /*

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

  1080  * 

  1081  * DoResolveL. Resolves the domain name

  1082  * 

  1083  * 

  1084  */

  1085 void CDNSSuffixTestWrapper::DoResolveL()

  1086     {

  1087     INFO_PRINTF1(_L("********************************************"));

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

  1089     INFO_PRINTF1(_L("********************************************"));

  1090     

  1091     TPtrC hostname;

  1092     

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

  1094         {

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

  1096         SetError(KErrNotFound);

  1097         return;

  1098         }

  1099     else

  1100         {

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

  1102         }

  1103 

  1104 	TInt err = KErrNone;

  1105     TName interfaceName;

  1106     

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

  1108         

  1109     if (err != KErrNone )

  1110         {

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

  1112         SetError(err);

  1113         return;

  1114         }

  1115         

  1116     TPtrC suffixList;

  1117     iSuffixList.Reset();

  1118     

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

  1120         {

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

  1122         SetError(KErrNotFound);

  1123         return;

  1124         }

  1125     else

  1126         {

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

  1128         FillSuffixList(iSuffixList,suffixList);

  1129         }

  1130 

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

  1132         {

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

  1134         SetError(err);