1 // Copyright (c) 2001-2009 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 // This contains ESock Test cases from section 26

    15 // Component test for DNS Query interface.

    16 // Note: These tests try to make different queries to the DNS (DND), using dummy protocol pdummy.prt, which

    17 // forges DNS answers. Ensure that pdummy.prt is present and listed in appropriate .esk file.

    18 // This test doesn't require a network connection.

    19 // 

    20 //

    21 

    22 // EPOC includes

    23 #include <e32base.h>

    24 #include <in_sock.h>

    25 #include <dns_qry.h>

    26 

    27 // Test system includes

    28 #include "EsockTestSection26.h"

    29 

    30 

    31 //-------------------------------------------------------------------------------------------------------

    32 

    33 /**

    34 *   find "dummy protocol 1" and open Host Resolver

    35 */

    36 TBool   CTestRHostRslvQuery_26::OpenHostResolver(void)

    37     {

    38     TInt            ret;

    39     TProtocolDesc   protoInfo;

    40     

    41     //-- find a dummy protocol 1

    42     Logger().WriteFormat(_L("Finding dummy protocol 1"));

    43     ret = iEsockSuite->iSocketServer.FindProtocol(_L("Dummy Protocol 1"), protoInfo);

    44     

    45     if(ret != KErrNone)

    46         {

    47         Logger().WriteFormat(_L("FindProtocol error code: %d"), ret);    

    48         return EFalse;

    49         }

    50     

    51     //-- open host resolver on this one

    52     Logger().WriteFormat(_L("Opening host resolver on dummy protocol 1"));

    53     ret = iHostRslv.Open(iEsockSuite->iSocketServer, protoInfo.iAddrFamily, protoInfo.iProtocol);

    54     

    55     if(ret != KErrNone)

    56         {

    57         Logger().WriteFormat(_L("iHostRslv.Open error code: %d"), ret);    

    58         return EFalse;

    59         }

    60     

    61     return ETrue;

    62     }

    63 

    64     /**

    65     *   close Hostresolver

    66 */

    67 void    CTestRHostRslvQuery_26::CloseHostResolver(void)

    68     {

    69     Logger().WriteFormat(_L("Closing host resolver"));

    70     iHostRslv.Close();

    71     }

    72 

    73 

    74     /**

    75     *   test preamble: find "dummy protocol 1" and open Host Resolver

    76 */

    77 TVerdict CTestRHostRslvQuery_26::doTestStepPreambleL (void)

    78     {

    79     

    80     TESTL(OpenHostResolver());

    81     SetTestStepResult(EPass);

    82     return EPass;

    83     }

    84 

    85     /**

    86     *   test postamble: close Host Resolver

    87 */

    88 TVerdict CTestRHostRslvQuery_26::doTestStepPostambleL(void)

    89     {

    90     CloseHostResolver();

    91     return EPass;

    92     }

    93 

    94 //-------------------------------------------------------------------------------------------------------

    95 //--  Test step 26.1

    96 //--  Testing RHostResolver::Query() of 'A' type

    97 //-------------------------------------------------------------------------------------------------------

    98 

    99 const TDesC& CEsockTest26_1::GetTestName()

   100     {

   101     // store the name of this test case

   102     _LIT(ret,"Test26.1");

   103 	

   104 	return ret;

   105     }

   106 

   107 TVerdict CEsockTest26_1::easyTestStepL()

   108     {

   109     

   110     TVerdict    verdict = EPass;

   111     TInt        ret;

   112     

   113     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'A' type"));

   114     

   115     TDnsQueryBuf      dnsQryBuf;

   116     TDnsRespABuf      dnsRespABuf;

   117     

   118     dnsQryBuf().SetType(KDnsRRTypeA);

   119     dnsQryBuf().SetData(_L8("http://www.sample.net/"));

   120     

   121     //-- make an A query. 

   122     //-- The query result shall be forged by pdummy.prt

   123     ret = iHostRslv.Query(dnsQryBuf, dnsRespABuf);

   124     TESTEL(KErrNone == ret, ret);

   125     

   126     //-- verify query response

   127     const TDnsRespA& dnsRespA = dnsRespABuf();

   128     

   129     //-- this is an expected ansver, forged by pdummy.

   130     TInetAddr expInetAddr;

   131     expInetAddr.Input(_L("192.168.40.4"));

   132     

   133     //-- check answer

   134     TESTL(dnsRespA.HostAddress().CmpAddr(expInetAddr));

   135     

   136     TESTL(dnsRespA.RRType()  == KDnsRRTypeA);

   137     TESTL(dnsRespA.RRClass() == KDnsRRClassIN);

   138     TESTL(dnsRespA.RRTtl()   == 0x121212);

   139     

   140     //-- Get next query result. 

   141     //-- error code shall be KErrNotFound, see pdummy.prt

   142     Logger().WriteFormat(_L("Testing RHostResolver::QueryGetNext(...)"));

   143     

   144     //--

   145     ret = iHostRslv.QueryGetNext(dnsRespABuf);

   146     TESTEL(KErrNone == ret, ret);

   147     expInetAddr.Input(_L("177.123.221.251"));

   148     //-- check answer

   149     TESTL(dnsRespA.HostAddress().CmpAddr(expInetAddr));

   150     TESTL(dnsRespA.RRType()  == KDnsRRTypeA);

   151     TESTL(dnsRespA.RRClass() == KDnsRRClassIN);

   152     TESTL(dnsRespA.RRTtl()   == 0x112233);

   153     

   154     

   155     //-- Get next query result. 

   156     //-- error code shall be KErrNotFound, see pdummy.prt

   157     ret = iHostRslv.QueryGetNext(dnsRespABuf);

   158     TESTEL(KErrNotFound == ret, ret);

   159     

   160     return verdict;

   161     }

   162 

   163 //-------------------------------------------------------------------------------------------------------

   164 //--  Test step 26.2

   165 //--  Testing RHostResolver::Query() of 'SVR' type

   166 //-------------------------------------------------------------------------------------------------------

   167 

   168 const TDesC& CEsockTest26_2::GetTestName()

   169     {

   170     // store the name of this test case

   171     _LIT(ret,"Test26.2");

   172 	

   173 	return ret;

   174     }

   175 

   176 TVerdict CEsockTest26_2::easyTestStepL()

   177     {

   178     TVerdict    verdict = EPass;

   179     TInt        ret;

   180     

   181     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'SRV' type"));

   182     

   183     TDnsQueryBuf      dnsQryBuf;

   184     TDnsRespSRVBuf    dnsRespSrvBuf;

   185     

   186     //-- test SRV query. see also RFC2782

   187     _LIT8(KSRVqrySample, "_ldap._tcp.example.com"); 

   188     dnsQryBuf().SetType(KDnsRRTypeSRV);

   189     dnsQryBuf().SetData(KSRVqrySample);

   190     

   191     //-- make a SRV query. 

   192     //-- The query result shall be forged by pdummy.prt

   193     ret = iHostRslv.Query(dnsQryBuf, dnsRespSrvBuf);

   194     TESTEL(KErrNone == ret, ret);

   195     

   196     //-- verify query response

   197     const TDnsRespSRV& dnsResp=dnsRespSrvBuf();

   198     

   199     TESTL(dnsResp.RRType() == KDnsRRTypeSRV);

   200     TESTL(dnsResp.RRClass() == KDnsRRClassIN);

   201     TESTL(dnsResp.RRTtl() == 0x123456);

   202     

   203     //-- verify RR fields obtained from pdummy.

   204     TESTL(dnsResp.Target().CompareF(_L8("old-slow-box")) == 0);

   205     

   206     TESTL(dnsResp.Priority()== 384);

   207     TESTL(dnsResp.Weight()  == 784);

   208     TESTL(dnsResp.Port()    == 123);

   209     

   210     //-- Get next query result. 

   211     //-- The result shall be forged by pdummy.prt

   212     Logger().WriteFormat(_L("Testing RHostResolver::QueryGetNext(...)"));

   213     ret = iHostRslv.QueryGetNext(dnsRespSrvBuf);

   214     TESTEL(KErrNone == ret, ret);

   215     

   216     //-- verify QueryGetNext data

   217     TESTL(dnsResp.RRType()  == KDnsRRTypeSRV);

   218     TESTL(dnsResp.RRClass() == KDnsRRClassIN);

   219     TESTL(dnsResp.RRTtl()   == 0x123765);

   220     TESTL(dnsResp.Priority()== 236);

   221     TESTL(dnsResp.Weight()  == 962);

   222     TESTL(dnsResp.Port()    == 125);

   223     

   224     TESTL(dnsResp.Target().CompareF(_L8("new-fast-box")) == 0);

   225     

   226     //-- try to get the next result, error code shall be KErrNotFound

   227     //-- see pdummy.prt

   228     ret = iHostRslv.QueryGetNext(dnsRespSrvBuf);

   229     TESTEL(KErrNotFound == ret, ret);

   230     

   231     return verdict;

   232     }

   233 

   234 //-------------------------------------------------------------------------------------------------------

   235 //--  Test step 26.3

   236 //--  Testing RHostResolver::Query() of 'PTR' type

   237 //-------------------------------------------------------------------------------------------------------

   238 

   239 const TDesC& CEsockTest26_3::GetTestName()

   240     {

   241     // store the name of this test case

   242     _LIT(ret,"Test26.3");

   243 	

   244 	return ret;

   245     }

   246 

   247 TVerdict CEsockTest26_3::easyTestStepL()

   248     {

   249     

   250     TVerdict    verdict = EPass;

   251     TInt        ret;

   252     

   253     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'PTR' type"));

   254     

   255     TDnsQueryBuf      dnsQryBuf;

   256     TDnsRespPTRBuf    dnsRespPtrBuf;

   257     

   258     dnsQryBuf().SetType(KDnsRRTypePTR);

   259     

   260     //-- pass this address to pdummy.prt for resolution

   261     TInetAddr inetAddr;

   262     inetAddr.Input(_L("192.111.22.77"));

   263     dnsQryBuf().SetData(inetAddr);

   264     

   265     //-- make an PTR query. 

   266     //-- The query result shall be forged by pdummy.prt

   267     ret = iHostRslv.Query(dnsQryBuf, dnsRespPtrBuf);

   268     TESTEL(KErrNone == ret, ret);

   269     

   270     const TDnsRespPTR& dnsRespPTR = dnsRespPtrBuf();

   271     TESTL(dnsRespPTR.HostName().CompareF(_L8("http://www.CDatagramHostResolver_QryProcessPTR.response/")) ==0);

   272     TESTL(dnsRespPTR.RRType()  == KDnsRRTypePTR);

   273     TESTL(dnsRespPTR.RRClass() == KDnsRRClassIN);

   274     TESTL(dnsRespPTR.RRTtl()   == 0x223441);

   275     

   276     //-- try to get the next result, error code shall be KErrNotFound

   277     //-- see pdummy.prt

   278     ret = iHostRslv.QueryGetNext(dnsRespPtrBuf);

   279     TESTEL(KErrNotFound == ret, ret);

   280     

   281     

   282     return verdict;

   283     }

   284 

   285 //-------------------------------------------------------------------------------------------------------

   286 //--  Test step 26.4

   287 //--  Testing RHostResolver::Query() of 'NAPTR' type

   288 //-------------------------------------------------------------------------------------------------------

   289 

   290 const TDesC& CEsockTest26_4::GetTestName()

   291     {

   292     // store the name of this test case

   293     _LIT(ret,"Test26.4");

   294 	

   295 	return ret;

   296     }

   297 

   298 TVerdict CEsockTest26_4::easyTestStepL()

   299     {

   300     TVerdict    verdict = EPass;

   301     TInt        ret;

   302     

   303     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'NAPTR' type"));

   304     

   305     TDnsQueryBuf        dnsQryBuf;

   306     TDnsRespNAPTRBuf    dnsRespNaptrBuf;

   307     

   308     dnsQryBuf().SetType(KDnsRRTypeNAPTR);

   309     dnsQryBuf().SetData(_L8("http://www.foo_bar.ru/"));

   310     

   311     //-- make  NAPTR query. 

   312     //-- The query result shall be forged by pdummy.prt

   313     ret = iHostRslv.Query(dnsQryBuf, dnsRespNaptrBuf);

   314     TESTEL(KErrNone == ret, ret);

   315     

   316     const TDnsRespNAPTR& dnsRespNAPTR = dnsRespNaptrBuf();

   317     

   318     TESTL(dnsRespNAPTR.RRType()  == KDnsRRTypeNAPTR);

   319     TESTL(dnsRespNAPTR.RRClass() == KDnsRRClassIN);

   320     TESTL(dnsRespNAPTR.RRTtl()   == 0x2673411);

   321     

   322     TESTL(dnsRespNAPTR.Order() == 123);

   323     TESTL(dnsRespNAPTR.Pref()  == 99);

   324     

   325     TESTL(dnsRespNAPTR.Flags().CompareF(_L8("SAUP")) == 0);

   326     TESTL(dnsRespNAPTR.Service().CompareF(_L8("http+I2R")) == 0);

   327     TESTL(dnsRespNAPTR.Regexp().CompareF(_L8("!£%^^&($%£$~~## !!!!!")) == 0);

   328     TESTL(dnsRespNAPTR.Replacement().CompareF(_L8("www.next-name.it")) == 0);

   329     

   330     //-- try to get the next result, error code shall be KErrNotFound

   331     //-- see pdummy.prt

   332     ret = iHostRslv.QueryGetNext(dnsRespNaptrBuf);

   333     TESTEL(KErrNotFound == ret, ret);

   334     

   335     return verdict;

   336     }

   337 

   338 //-------------------------------------------------------------------------------------------------------

   339 //--  Test step 26.5

   340 //--  Testing RHostResolver::Query() of 'MX' type

   341 //-------------------------------------------------------------------------------------------------------

   342 

   343 const TDesC& CEsockTest26_5::GetTestName()

   344     {

   345     // store the name of this test case

   346     _LIT(ret,"Test26.5");

   347 	

   348 	return ret;

   349     }

   350 

   351 TVerdict CEsockTest26_5::easyTestStepL()

   352     {

   353     TVerdict    verdict = EPass;

   354     TInt        ret;

   355     

   356     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'MX' type"));

   357     

   358     TDnsQueryBuf    dnsQryBuf;

   359     TDnsRespMXBuf   dnsRespMXBuf;

   360     

   361     dnsQryBuf().SetType(KDnsRRTypeMX);

   362     dnsQryBuf().SetData(_L8("http://www.gooooooogle.ru/"));

   363     

   364     //-- make MX query. 

   365     //-- The query result shall be forged by pdummy.prt

   366     ret = iHostRslv.Query(dnsQryBuf, dnsRespMXBuf);

   367     TESTEL(KErrNone == ret, ret);

   368     

   369     const TDnsRespMX& dnsRespMx = dnsRespMXBuf();

   370     

   371     TESTL(dnsRespMx.RRType()  == KDnsRRTypeMX);

   372     TESTL(dnsRespMx.RRClass() == KDnsRRClassIN);

   373     TESTL(dnsRespMx.RRTtl()   == 0xdead);

   374     

   375     

   376     TESTL(dnsRespMx.Pref()  == 345);

   377     TESTL(dnsRespMx.HostName().CompareF(_L8("c.example.org")) == 0);

   378     

   379     //-- try to get the next result, error code shall be KErrNotFound

   380     //-- see pdummy.prt

   381     ret = iHostRslv.QueryGetNext(dnsRespMXBuf);

   382     TESTEL(KErrNotFound == ret, ret);

   383     

   384     

   385     return verdict;

   386     }

   387 

   388 //-------------------------------------------------------------------------------------------------------

   389 //--  Test step 26.6

   390 //--  Testing RHostResolver::Query() of 'AAAA' type

   391 //-------------------------------------------------------------------------------------------------------

   392 

   393 const TDesC& CEsockTest26_6::GetTestName()

   394     {

   395     // store the name of this test case

   396     _LIT(ret,"Test26.6");

   397 	

   398 	return ret;

   399     }

   400 

   401 TVerdict CEsockTest26_6::easyTestStepL()

   402     {

   403     TVerdict    verdict = EPass;

   404     TInt        ret;

   405     

   406     Logger().WriteFormat(_L("Testing RHostResolver::Query() of 'AAAA' type"));

   407     

   408     TDnsQueryBuf      dnsQryBuf;

   409     TDnsRespAAAABuf   dnsRespAAAABuf;

   410     

   411     dnsQryBuf().SetType(KDnsRRTypeAAAA);

   412     dnsQryBuf().SetData(_L8("http://www.sample_AAAA.net/"));

   413     

   414     //-- make an AAAA query. 

   415     //-- The query result shall be forged by pdummy.prt

   416     ret = iHostRslv.Query(dnsQryBuf, dnsRespAAAABuf);

   417     TESTEL(KErrNone == ret, ret);

   418     

   419     //-- verify query response

   420     const TDnsRespAAAA& dnsRespAAAA = dnsRespAAAABuf();

   421     

   422     //-- this is an expected ansver, forged by pdummy.

   423     TInetAddr expInetAddr;

   424     expInetAddr.Input(_L("2001:618:400:6a:0:0:0:abc"));

   425     

   426     //-- check answer

   427     TESTL(dnsRespAAAA.HostAddress().CmpAddr(expInetAddr));

   428     

   429     TESTL(dnsRespAAAA.RRType()  == KDnsRRTypeAAAA);

   430     TESTL(dnsRespAAAA.RRClass() == KDnsRRClassIN);

   431     TESTL(dnsRespAAAA.RRTtl()   == 0xbeef);

   432     

   433     

   434     //-- Get next query result. 

   435     //-- error code shall be KErrNotFound, see pdummy.prt

   436     ret = iHostRslv.QueryGetNext(dnsRespAAAABuf);

   437     TESTEL(KErrNotFound == ret, ret);

   438     

   439     return verdict;

   440     }

   441 

   442 

   443 //-------------------------------------------------------------------------------------------------------

   444 //--  Test step 26.7

   445 //--  Esock server memory allocation testing for RHostResolver Query interface

   446 //-------------------------------------------------------------------------------------------------------

   447 

   448 const TDesC& CEsockTest26_7::GetTestName()

   449     {

   450     // store the name of this test case

   451     _LIT(ret,"Test26.7");

   452 	

   453 	return ret;

   454     }

   455 

   456 TVerdict CEsockTest26_7::easyTestStepL()

   457     {

   458     

   459     TVerdict    verdict = EPass;

   460     Logger().WriteFormat(_L("Esock server memory allocation testing for RHostResolver Query interface"));

   461     

   462     TInt        ret;

   463     

   464     TDnsQueryBuf      dnsQryBuf;

   465     TDnsRespABuf      dnsRespABuf;

   466     TDnsRespNAPTRBuf  dnsRespNaptrBuf;

   467     TDnsRespPTRBuf    dnsRespPtrBuf;

   468     

   469     

   470     dnsQryBuf().SetType(KDnsRRTypeA);

   471     dnsQryBuf().SetData(_L8("http://www.sample.net/"));

   472     

   473     ret = iHostRslv.Query(dnsQryBuf, dnsRespABuf);

   474     TESTEL(KErrNone == ret, ret);

   475     

   476     CloseHostResolver();

   477     

   478     TESTL(OpenHostResolver());

   479     

   480     //-- 1. make 'A' query, it will make esock allocate memory for query and response buffers

   481     dnsQryBuf().SetType(KDnsRRTypeA);

   482     dnsQryBuf().SetData(_L8("http://www.sample.net/"));

   483     

   484     ret = iHostRslv.Query(dnsQryBuf, dnsRespABuf);

   485     TESTEL(KErrNone == ret, ret);

   486     

   487     //-- 2. make 'NAPTR' query, it will make esock reallocate query data buffers, because for 

   488     //-- this query type they are larger.

   489     dnsQryBuf().SetType(KDnsRRTypeNAPTR);

   490     dnsQryBuf().SetData(_L8("http://www.foo_bar.ru/"));

   491     ret = iHostRslv.Query(dnsQryBuf, dnsRespNaptrBuf);

   492     TESTEL(KErrNone == ret, ret);

   493     

   494     //-- 3. this will make Esock reuse eisting buffers

   495     TInetAddr inetAddr;

   496     inetAddr.Input(_L("192.111.22.77"));

   497     dnsQryBuf().SetData(inetAddr);

   498     dnsQryBuf().SetType(KDnsRRTypePTR);

   499     ret = iHostRslv.Query(dnsQryBuf, dnsRespPtrBuf);

   500     TESTEL(KErrNone == ret, ret);

   501     

   502     CloseHostResolver();

   503     

   504     //-- check esock server's heap balance by shutting down the socket server

   505     return verdict;

   506     }

   507