1 // Copyright (c) 2003-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 //

    15  

    16 #include "TS_MultiHomingStep.h"

    17 #include "TS_ResolveName.h"

    18 

    19 // From ../../networking/inhook6/inc/dnd_err.h

    20 const TInt KErrDndNameNotFound = -5120; 

    21 

    22 /*       

    23  * Resolve a hostname to an address

    24  */

    25 CTS_ResolveName::CTS_ResolveName()

    26 	{

    27 	iTestStepName = KResolveName;

    28 	}

    29 

    30 CTS_ResolveName::~CTS_ResolveName()

    31 	{	

    32 	}

    33 

    34 

    35 enum TVerdict CTS_ResolveName::doTestStepPreambleL(void)

    36 /**

    37  * Implements OOM testing in each test

    38  */

    39 	{

    40 	if (!(GetBoolFromConfig(KResolveName, KOomTest, iIsOOMTest)))

    41 		iIsOOMTest=EFalse;

    42 	return EPass;

    43 	}

    44 

    45 enum TVerdict CTS_ResolveName::doTestStepL(void)

    46 /**

    47  * Resolve a hostname to address

    48  * @return The test step verdict  

    49  */

    50 	{			

    51 	TInt err = KErrNone;

    52 	TInt numOfResolvers = 0;

    53 

    54 	

    55 	err = GetIntFromConfig(KResolveName, KNumOfResolvers, numOfResolvers);

    56 	if ((!err) || (numOfResolvers < 1))

    57 		{

    58 		return EInconclusive;

    59 		}

    60 

    61 	RArray<CResolveName*> resolverArray;

    62 	RArray<TBool> expectResolveToSucceedArray;

    63 	RArray<TBool> expectResolveToTimeoutArray;

    64 	RArray<TBool> expectResolveToBeNotReadyArray;

    65 

    66 	TInt i;

    67 	for (i = 0; i < numOfResolvers; i++)

    68 		{

    69 				

    70 		CResolveName* newResolver = CResolveName::NewL();

    71 			 

    72 		TConnDetails *theConn;

    73 		TBool expectSuccess = ETrue;

    74 		TBool expectTimeout = EFalse; 

    75 		TBool expectNotReady = EFalse;

    76 		TBool explicitResolve = EFalse;

    77 		TInt protocol = KProtocolInetTcp;

    78 		

    79 		TName	hostName;  

    80 		GetResolverConfig(i, hostName, protocol, expectSuccess, expectTimeout, expectNotReady, explicitResolve, &theConn);

    81 				

    82 		expectResolveToSucceedArray.Append(expectSuccess);   

    83 		expectResolveToTimeoutArray.Append(expectTimeout); 

    84 		expectResolveToBeNotReadyArray.Append(expectNotReady); 

    85 

    86 		StepLog(_L("Trying to resolving[%i]: %S"), i, &hostName);			

    87 		err = newResolver->DoResolution(hostName, theConn, protocol, this, explicitResolve);		

    88 		if (err == KErrNone)

    89 			{

    90 			err = resolverArray.Append(newResolver);

    91 			if (err != KErrNone)

    92 				{

    93 				newResolver->DoCancel();

    94 				delete newResolver;

    95 				newResolver = 0;

    96 				//Log(KELogger,err);		// We can't keep a ref outside the loop...

    97 				}

    98 			}

    99 //		else

   100 //			Log (KELogger,err);

   101 		}	// for (i<numOfSockets)

   102 	

   103 	CEnhancedScheduler::Start();	// And start them off...

   104 	

   105 	// Wait for all to finish / time out.	

   106 	TInt result(0);

   107 	for (i = 0; i < resolverArray.Count(); i++)

   108 		{

   109 		result = resolverArray[i]->GetResult();

   110 		StepLog(_L("Resolving %i: returned:%i"), i, result);

   111 

   112 		if(result == KErrNotFound  && !expectResolveToSucceedArray[i] 

   113 			||	result == KErrDndNameNotFound && !expectResolveToSucceedArray[i]

   114 			||  result == KErrNone && expectResolveToSucceedArray[i] 

   115 			||  result == KErrNotReady && expectResolveToBeNotReadyArray[i]

   116 			||  result == KErrTimedOut && expectResolveToTimeoutArray[i] 

   117 			||  result == KErrDndNameNotFound && expectResolveToTimeoutArray[i] )

   118 			{

   119 		

   120 			}

   121 		else

   122 			{

   123 			// fail all case

   124 			iTestStepResult = EFail;

   125 			}

   126 			

   127 		

   128 		delete resolverArray[i];

   129 		}

   130 

   131 	expectResolveToSucceedArray.Close();

   132 	expectResolveToTimeoutArray.Close();    

   133 	expectResolveToBeNotReadyArray.Close();    

   134 	resolverArray.Close();

   135 	return iTestStepResult;

   136 

   137 	}

   138 

   139 

   140 					

   141 TInt CResolveName::DoResolution(TName aHostName, TConnDetails *aConn, TInt aProtocol, 

   142 								CTS_ResolveName *aOwnerStep, TBool aExplicitResolve)

   143 								

   144 	{

   145 	TInt err;

   146 	iResolverHasSS = FALSE;	

   147 	iHostName.Copy(aHostName.Ptr(), aHostName.Length());

   148 

   149 

   150 	iOwnerStep = aOwnerStep;

   151 	iTConnection = aConn;

   152 

   153 

   154 	

   155 	if (aExplicitResolve)		

   156 		{		

   157 		err = iResolver.Open(iTConnection->iSocketServ, KAfInet, 

   158 			aProtocol, iTConnection->iConnection);		

   159 		}

   160 	else

   161 		{						

   162 		if (iTConnection != 0)

   163 			// Use the SocketServ session of opened connection 

   164 			err = iResolver.Open(iTConnection->iSocketServ, KAfInet, aProtocol);			

   165 		else

   166 			{

   167 			// No connection specified to use so create session

   168 			iResolverHasSS = TRUE;

   169 			err = iResolverSS.Connect();

   170 			if(err != KErrNone)

   171 			    {

   172 			    return err;

   173 			    }

   174 			err = iResolver.Open(iResolverSS, KAfInet, aProtocol);

   175 			}

   176 		}

   177 		

   178 	if (err != KErrNone)

   179 		return err;			// No point going any further...

   180 	

   181 	iStatus = KRequestPending; 

   182 

   183 	// Increment the counter before we start.

   184 	iOwnerStep->iOwnerSuite->iScheduler->IncCount();

   185 	SetActive();

   186 

   187 	TRequestStatus* pS = &iStatus;

   188 	User::RequestComplete(pS,KErrNone);

   189 

   190 	return KErrNone;

   191 	}

   192 

   193 

   194 CResolveName::~CResolveName()

   195 	{

   196 	//Cancel();	

   197 	if (iResolverHasSS)

   198 	    {

   199 	    iResolver.Close();

   200 	    iResolverSS.Close();

   201 	    }

   202 

   203 	}

   204 

   205 CResolveName* CResolveName::NewL()

   206 	{

   207 	

   208 	CResolveName* self = new(ELeave) CResolveName;

   209 	CleanupStack::PushL(self);

   210 	self->ConstructL();

   211 	CleanupStack::Pop();

   212 	return self;

   213 	}

   214 

   215 

   216 void CResolveName::ConstructL()

   217 	{

   218 	CEnhancedScheduler::Add(this);

   219 	}

   220 

   221 void CResolveName::DoCancel()

   222 	{

   223 	iResolver.Close();

   224 	}

   225 

   226 void CResolveName::RunL()

   227 	{

   228 	

   229 	switch (iState)

   230 		{

   231 		case EResReady:

   232 			{

   233 			iResolver.GetByName(iHostName, iResultingName, iStatus);

   234 			iState = EWaitingForResult;

   235 			SetActive();

   236 			}

   237 			break;

   238 

   239 		case EWaitingForResult:

   240 			{

   241 				iState = EResComplete;

   242 				iResolverResult = iStatus.Int();

   243 				iOwnerStep->iOwnerSuite->iScheduler->DecCount();

   244 				if(0 == iOwnerStep->iOwnerSuite->iScheduler->GetCount())

   245 						CEnhancedScheduler::Stop();

   246 			}		

   247 			break;

   248 				

   249 		default:

   250 				iOwnerStep->StepLog(KTxtWhatHappened);

   251 			break;

   252 		}

   253 		//iOwnerStep->StepLog(KState, iState, iOwnerStep->iOwnerSuite->iScheduler->GetCount());

   254 	}

   255