TInt CTS_MultiHomingStep::GetResolverConfig(const TInt aIndex, TName &aHostName, TInt& aProtocol,
TBool& aExpectSuccess, TBool& aExpectTimeout, TBool& aExpectNotReady,
TBool& aExplicitResolve, TConnDetails **aConnDetails)
/**
* Gets resolver configuration from file, using defaults if necessary
* @param aIndex The index for the socket configkey
* @param aHostName The host to be resolved
* @param aProtocol The protocol to be used
* @param aExpectSuccess Flag indicating if name should be resolved ok
* @param aExpectTimeout Flag indicating if name resolution should timeout
* @param aConnDetails The connection for an explicit resolver
* @return System wide error code
*/
{
TInt err=KErrNone;
TName resolverName; // Create the Key for the config lookup
resolverName = KResolver;
resolverName.AppendNum(aIndex);
TPtrC ptrBuf;
err = GetStringFromConfig(resolverName, KDestName, ptrBuf);
if (!err)
{
LogExtra((TText8*)__FILE__, __LINE__, ESevrWarn, KEConfigFile);
iTestStepResult= EInconclusive;
return KErrNotFound;
}
aHostName.Copy(ptrBuf.Ptr(), ptrBuf.Length());
aExpectSuccess = ETrue;
GetBoolFromConfig(resolverName, KExpectSuccess, aExpectSuccess);
aExpectTimeout = EFalse;
GetBoolFromConfig(resolverName, KExpectTimeout, aExpectTimeout);
aExpectNotReady = EFalse;
GetBoolFromConfig(resolverName, KExpectNoDnsServer, aExpectNotReady);
aExplicitResolve = EFalse;
GetBoolFromConfig(resolverName, KExplicitResolve, aExplicitResolve);
err = GetStringFromConfig(resolverName, KProtocol, ptrBuf);
if (err && (ptrBuf.Compare(KTcp)==0))
aProtocol = KProtocolInetTcp;
else
aProtocol = KProtocolInetUdp;
err = GetStringFromConfig(resolverName, KConnName, ptrBuf);
if (!err)
{
return KErrNotFound;
}
*aConnDetails = iOwnerSuite->GetTConnection(ptrBuf);
return KErrNone;
}
void CListCertificates::TestAction()
{
TInt count = iCertInfos.Count();
if (count == iExpectedLabels.Count())
{
TInt i;
for (i = 0; i < count; i++)
{
TName expected;
TName retrieved;
expected.Copy(iExpectedLabels[i].iName.Ptr());
retrieved.Copy(iCertInfos[i]->Label());
if (expected.Compare(retrieved))
{
break;
}
// this fails the test if any of the certs are marked as not
// deletable
if (iCertInfos[i]->IsDeletable() != !iExpectedLabels[i].iReadOnly)
break;
}
if (i == count)
{
iResult = ETrue;
}
else
{
iResult = EFalse;
}
}
else
{
iResult = EFalse;
}
}
/**
Wait for message completion by the helper process
@param aProcessLog if ETrue, log messages from the helper process will be logged by TEF
@return error code, result of the message processing.
*/
TInt CSyncMessageSender::WaitForMsgComplete(TBool aProcessLog/*=ETrue*/)
{
if( !aProcessLog )
{ //-- don't need to process messages from the helper process
User::WaitForRequest(iMsgRqStat);
return iMsgRqStat.Int();
}
//-- wait for message completion processing logs from the helper process
TName logBuf;
for(;;)
{
iLogMsgQueue.NotifyDataAvailable(iLogRqStat);
User::WaitForRequest(iMsgRqStat, iLogRqStat);
if(iLogRqStat.Int() == KRequestPending)
{ //-- iMsgRqStat has been completed, the pessage has been processed
//-- cancel waiting for the log messages.
iLogMsgQueue.CancelDataAvailable();
User::WaitForRequest(iLogRqStat);
break;
}
else
{ //-- log message has been posted to the queue, pull all log messages up and process them
TIPLogMsg logMsg;
TInt nRes;
for(;;)
{
nRes = iLogMsgQueue.Receive(logMsg);
if(nRes != KErrNone)
break;
if(ipLogger)
{ //-- logger is available, log the message.
logBuf.Copy(_L("\t~helper: "));
logBuf.Append(logMsg.iLogMsg);
ipLogger->Write(logBuf);
}
}//for(;;)
}
}//for(;;)
return iMsgRqStat.Int();
}
void CTestConfig::ParseAndSetItemValueL(const TDesC8& aText, const TLex8& aInput, TInt aCurrentItemStart, CTestConfigItem*& arCurrentItem)
{
if (arCurrentItem)
{
delete arCurrentItem->iValue;
arCurrentItem->iValue = NULL;
TPtrC8 val(ParseValue(aText, aInput, aCurrentItemStart));
arCurrentItem->iValue = ReplaceLC(KScriptCRLF, KScriptLF, val);
arCurrentItem->iValue->Des().Trim();
CleanupStack::Pop(arCurrentItem->iValue);
if (arCurrentItem->Item().CompareF(KScriptDefaults) == 0)
{
TName filename;
filename.Copy(arCurrentItem->Value());
CopyInDefaultsL(arCurrentItem->iParent, filename);
}
}
arCurrentItem = NULL;
}
TVerdict CTestStepLLMNR_Init::doTestStepL()
{
TInt cntNode, nRes;
TName tmpBuf;
TName tmpBuf1;
SetTestStepResult(EPass);
TESTL(GetIntFromConfig(KNodesSection, _L("StartUpDelay"), nRes) && nRes > 0);
const TInt startUpDelay = nRes*KOneSecond;
INFO_PRINTF1(KNewLine);
INFO_PRINTF1(_L("Initializing LLMNR test engine..."));
//-- wait some time for settling name conflict resolution within LLMNR mechanism
User::After(ipTestServer->RandomizeNum(startUpDelay, startUpDelay));
RIPAddrArray& localAddrs = ipTestServer->iLocalAddrs;
TNetworkInfo& networkInfo = ipTestServer->iNetworkInfo;
//-- reset network information and local IP addresses table
networkInfo.Reset();
localAddrs.Reset();
//--------------------------------------------
//-- load network configuration from ini file
LoadNetworkConfigFromIniL(networkInfo);
//-- start up network layer and LLMNR engine
TESTL(StartUpLLMNR());
//-- wait some time for settling name conflict resolution within LLMNR mechanism
User::After(ipTestServer->RandomizeNum(startUpDelay));
//-- list available network interfaces and their IP addresses
ListInterfacesL();
//-- try to resolve every host name and obtain its IP address
ProbeNodes(networkInfo);
//-----------------------------------------------------------
//-- print out alive hosts names, IP addresses, etc and check the number of hosts
INFO_PRINTF1(_L("--- available hosts list:\n"));
TInt foreignNodeCnt = 0; //-- number of foreign hosts (IP addresses that not ours)
TInt localNodeCnt = 0; //-- number of local IP addresses
for(cntNode=0; cntNode < networkInfo.NodesCount(); ++cntNode)
{
TNodeInfo& currNode = networkInfo[cntNode]; //-- current node info
if(currNode.iAlive)
{
//-- print host name and its IP address
tmpBuf.Copy(currNode.iHostName);
tmpBuf.Append(_L(" "));
currNode.iAddr.Output(tmpBuf1);
tmpBuf.Append(tmpBuf1);
//-- search IP address in the array of local host addresses.
//-- if found, mark the appropriate hostInfo element as having local address.
currNode.iLocal = (ipTestServer->iLocalAddrs.Find(currNode.iAddr, TIdentityRelation<TInetAddr>(IPAddrIsEqual)) != KErrNotFound);
if(currNode.iLocal)
{
tmpBuf.Append(_L(" [local address]"));
localNodeCnt++;
}
if(currNode.iIpUnique)
tmpBuf.Append(_L(" [U]"));
if(! currNode.iLocal && currNode.iIpUnique)
foreignNodeCnt++;
INFO_PRINTF1(tmpBuf);
}
}
INFO_PRINTF1(KNewLine);
//-- check the number of nodes with local IP addresses to ensure that test config are correct
if(localNodeCnt <1)
{
INFO_PRINTF1(_L("??? Error! No nodes found with local IP. Check the test configuration.\n"));
SetTestStepResult(EInconclusive);
return TestStepResult();
}
//-- we need at least 1 other external host
if(foreignNodeCnt < 1)
{
INFO_PRINTF1(_L("Error! For successfull testing you should have at least 1 external hosts available!\n"));
SetTestStepResult(EInconclusive);
return TestStepResult();
}
//-- check if all IP adresses are link-local
INFO_PRINTF1(_L("check all hosts' IP adresses to be link-local"));
for(cntNode=0; cntNode< networkInfo.NodesCount(); ++cntNode)
{
TNodeInfo& currNode = networkInfo[cntNode]; //-- current node info
if(currNode.iAlive)
if(! currNode.iAddr.IsLinkLocal())
{
tmpBuf.Copy(_L("host "));
tmpBuf.Append(currNode.iHostName);
tmpBuf.Append(_L(" "));
currNode.iAddr.Output(tmpBuf1);
tmpBuf.Append(tmpBuf1);
tmpBuf.Copy(_L(" IP address isn't link local! "));
INFO_PRINTF1(tmpBuf);
SetTestStepResult(EInconclusive);
return TestStepResult();
}
}
//-----------------------------------------------------------
//-- LLMNR has been initialized and information about network collected
networkInfo.SetInitialized(ETrue);
SetTestStepResult(EPass);
return TestStepResult();
}
/**
* Tries to resolve each host name from the table loaded from ini file.
* @param aNetworkInfo ref. to the TNetworkInfo structure, which will be populated
*/
void CTestStepLLMNR_Init::ProbeNodes(TNetworkInfo& aNetworkInfo)
{
TName tmpBuf;
TInt nRes;
TNameEntry nameEntry;
//-- start name resolution for every entry in HostInfo
GetIntFromConfig(KNodesSection, _L("ScanMaxDelay"), nRes);
const TInt scanMaxDelay = nRes*KOneSecond;
for(;;)
{
TInt cntFinishedHosts = 0;
for(TInt cntNode=0; cntNode< aNetworkInfo.NodesCount(); ++cntNode)
{
TNodeInfo& currNode = aNetworkInfo[cntNode]; //-- current node info
if( ! currNode.iAlive && currNode.iCntTrials >0)
{//-- the host is worth asking its IP address
//-- a small random delay between sending queries
User::After(ipTestServer->RandomizeNum(scanMaxDelay));
INFO_PRINTF1(KNewLine);
tmpBuf.Copy(_L("- Probing host: "));
tmpBuf.Append(currNode.iHostName);
INFO_PRINTF1(tmpBuf);
nRes = ipTestServer->iHostResolver.GetByName(currNode.iHostName, nameEntry);
if(nRes == KErrNone)
{//-- current host name has been resolver successfully, mark it alive and store its IP address
//-- check if the obtained IP address is unique in TNetworkInfo
currNode.iIpUnique = (aNetworkInfo.FindIP(nameEntry().iAddr) < 0);
currNode.iAddr = nameEntry().iAddr;
currNode.iAlive = ETrue;
currNode.iAddr.Output(nameEntry().iName);
tmpBuf.Copy(_L("name resolved: "));
tmpBuf.Append(nameEntry().iName);
INFO_PRINTF1(tmpBuf);
}
else
{//-- no response
currNode.iCntTrials --; //-- decrease trials counter for this hostname
INFO_PRINTF2(_L("name resolution error: %d"), nRes);
}
}
else
cntFinishedHosts++;
}
//-- check, whether we need to continue nodes scanning
//-- if either host is alive or has trials counted down to 0, exit
if(cntFinishedHosts == aNetworkInfo.NodesCount())
break;
} //for(;;)
INFO_PRINTF1(KNewLine);
}
void CHlpFileEntry::ConstructL(TLanguage aLanguage)
{
_LIT(KDefaultHelpFileExtension, ".hlp");
// Decide what type of file this is....
TFileName file;
TChar driveLetter;
User::LeaveIfError(RFs::DriveToChar(iDrive, driveLetter));
file.Append(driveLetter);
file.Append(':');
file.Append(KHlpFileSearchPath);
file.Append(iFile);
TParsePtrC parser(file);
if (!parser.ExtPresent())
User::Leave(KErrCorrupt);
iName.Copy(parser.Name());
TPtrC extension(parser.Ext());
if (extension.CompareF(KDefaultHelpFileExtension) == 0)
iType = EGeneral;
else
{
TFileName idealHelpFileName(parser.DriveAndPath());
idealHelpFileName.Append(parser.Name());
MakeLocaleSpecificExtension(idealHelpFileName, aLanguage);
if (idealHelpFileName.CompareF(file) == 0)
{
// This is a primary match
iType = EPrimary;
iHelpFileLocale = aLanguage;
}
else
{
// Is it a secondary match? If it isn't then it should be discarded....
idealHelpFileName = parser.DriveAndPath();
idealHelpFileName.Append(parser.Name());
// Get the nearest secondary language
aLanguage = NextLanguage(aLanguage);
MakeLocaleSpecificExtension(idealHelpFileName, aLanguage);
if (idealHelpFileName.CompareF(file) == 0)
{
iHelpFileLocale = aLanguage;
iType = ESecondary;
}
else
{
TLex lexer(extension);
// Skip the leading .H
lexer.Inc(2);
// Lex the value, but silently ignore errors
TUint localeAsUnsignedInt = ELangOther;
lexer.Val(localeAsUnsignedInt);
iHelpFileLocale = STATIC_CAST(TLanguage, localeAsUnsignedInt);
iType = EInpropperLocale;
}
}
}
}
TBool CC32RunThreadStep::ThreadCreationL()
/**
* @return - TBool
* Implementation of ThreadCreationL virtual function
* This function is used to spawn each client thread and result will be logged to
* a HTML file.
* returns EFalse if a thread panics or test case fails.
*/
{
//create a global semaphore
RSemaphore clientSemaphore;
CleanupClosePushL(clientSemaphore);
TInt result = clientSemaphore.CreateGlobal(KSemaphoreName, 0);
//create threads based on the information given in ini file
for (TInt n = 0 ; n<iTaskCounter; n++ )
{
iNetPerformanceThread[n] = new(ELeave) C32PerformanceThread( *iThreadData[n] );
TName name;
name.Copy( iThreadData[n]->iThreadName );
RThread thread;
const TUint KStackSize=0x1000;
TInt nErr;
if ( (nErr = thread.Create(name, C32PerformanceThread::RunL, KStackSize, NULL, iNetPerformanceThread[n])) == KErrNone)
{
thread.SetPriority(ParseThreadPriority(iThreadData[n]->iThreadPriority));
thread.Logon(iRequestStatus[n]);
thread.Resume();
thread.Close();
}
else
{
INFO_PRINTF3(_L(" Failed to create thread = %S .Failed with error = %d "),&iThreadData[n]->iThreadName,nErr);
}
}
INFO_PRINTF1(_L("------------------------ C32 Performance Results -------------------------------- "));
for (TInt j=0 ; j<iTaskCounter; j++ )
{
//wait for the thread to complete
User::WaitForRequest( iRequestStatus[j] );
//print the results to a log file
INFO_PRINTF2(_L(" Thread Name = %S "),&iThreadData[j]->iThreadName);
INFO_PRINTF2(_L(" Task Name = %S "),&iThreadData[j]->iTaskName);
INFO_PRINTF2(_L(" Time taken to execute the thread = %ld microseconds "), iThreadData[j]->iThreadTime);
INFO_PRINTF2(_L(" Error occured in line no = %d. Expected value was 0 "), iThreadData[j]->iTestResult);
INFO_PRINTF2(_L(" Thread terminated value = %d. Expected value was 0 "),iRequestStatus[j].Int());
INFO_PRINTF1(_L("--------------------------------------------------------------------------------- "));
}
CleanupStack::PopAndDestroy();
/*
iTestResult is used to indicate the line no of the error occured in each test case.
return EFalse,if a test case failed or a thread paniced
*/
for (TInt j=0 ; j<iTaskCounter; j++ )
{
if((iThreadData[j]->iTestResult > 0) || (iRequestStatus[j].Int() > 0 ))
{
return EFalse;
}
}
return ETrue;
}
// -----------------------------------------------------------------------------
// CHttpConnHandler::ConnectL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CHttpConnHandler::ConnectL()
{
LOGGER_ENTERFN( "ConnectL" );
TBool doComplete( ETrue );
iShutDown->Cancel();
if( !iConnection.SubSessionHandle() )
// only the first connection request does this initialization
{
CLOG_WRITE( "No subsession" );
// forget the previous notifier
if( iConnName )
{
CLOG_WRITE_1("ConnName set: [%S]", iConnName);
TName connName;
connName.Copy( *iConnName );
User::LeaveIfError( iConnection.Open( iClientApp->Engine()->SocketServ(), connName ) );
CLOG_WRITE( "connection open" );
TNifProgress progress;
iConnection.Progress( progress );
iConnStage = progress.iStage;
CLOG_WRITE_1("Stage: %d", iConnStage);
UpdateIapId();
}
else
{
User::LeaveIfError( iConnection.Open( iClientApp->Engine()->SocketServ() ) );
CLOG_WRITE8_1( "Start: %d", iIapId );
if( iIapId )
{
iPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );
iPref.SetIapId( iIapId );
}
else
{
iPref.SetDialogPreference( ECommDbDialogPrefPrompt );
}
iConnection.Start( iPref, iStatus );
// RConnection will complete us.
doComplete = EFalse;
}
iConnNotif->Start();
iNewConnection = ETrue;
}
CLOG_WRITE_1( "stage: %d", iConnStage );
if( !IsActive() )
{
CLOG_WRITE( "Not active" );
SetActive();
CLOG_WRITE_1( "doComplete: %d", doComplete );
if( doComplete )
{
TRequestStatus* dummy = &iStatus;
User::RequestComplete( dummy, KErrNone );
}
}
}
void CTelServerProcessor::OpenNewCallL()
/**
Load the TSY and open a new call from the ETEL server
*/
{
__ASSERT_ALWAYS(!iCallOpen, NetDialPanic(EEtelCallAlreadyOpen));
__ASSERT_ALWAYS(iCallType==EUnknown, NetDialPanic(EEtelCallAlreadyOpen));
TBuf<KCommsDbSvrMaxFieldLength> newTsyName;
iDb->GetTsyNameL(newTsyName);
// Remove unnecessary .TSY extension, if found
if (newTsyName.Right(4).CompareF(KTsyNameExtension) == 0)
newTsyName = newTsyName.Left(newTsyName.Length() - 4);
TBool loaded=EFalse;
if (iTsyName.Length()!=0)
{
if (iTsyName.CompareF(newTsyName)==KErrNone) // the one we want is already loaded
loaded=ETrue;
else // unload the one we were using
{
User::LeaveIfError(iTelServer.UnloadPhoneModule(iTsyName));
iTsyLoaded=EFalse;
}
}
if (!loaded)
{
User::LeaveIfError(iTelServer.LoadPhoneModule(newTsyName));
iTsyName=newTsyName;
iTsyLoaded=ETrue;
}
if (iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended)!=KErrNone)
{
User::LeaveIfError(iTelServer.SetExtendedErrorGranularity(RTelServer::EErrorBasic));
}
RTelServer::TPhoneInfo info;
GetPhoneInfoL(info);
TName callName;
callName.Zero();
callName.Copy(info.iName); // phone name
callName.Append(KDoubleColon);
RPhone::TLineInfo lineInfo;
GetLineInfoL(lineInfo,info.iName,RLine::KCapsData);
callName.Append(lineInfo.iName);
callName.Append(KDoubleColon);
OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CTELSERVERPROCESSOR_OPENNEWCALLL_1, "NetDial:\tOpening Call");
iDb->CopyIspInitStringToModemL(); // will not leave if the field is blank
// Only MultimodeV1 and greater supported!
if (info.iExtensions>=(TUint)KETelExtMultimodeV1)
{
User::LeaveIfError(iMmCall.OpenNewCall(iTelServer,callName));
iCallOpen=ETrue;
iCallType=EMmDataCall;
SetMmParametersL(); // may change call type to EMmHscsdCall
}
else
{
User::LeaveIfError(iCall.OpenNewCall(iTelServer,callName));
iCallOpen=ETrue;
iCallType=ECoreCallOnly;
}
}
