// -----------------------------------------------------------------------------
// TMSCallServer::StartThreadL
//
// -----------------------------------------------------------------------------
//
void TMSCallServer::StartThreadL(TMSCallServerStartParam& aStart)
{
TRACE_PRN_FN_ENT;
CActiveScheduler* sched = new (ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
TMSCallServer* server = TMSCallServer::NewL(aStart.iTMSServer);
CleanupStack::PushL(server);
//Rename tmscall server name
RThread tmscallServerThread;
TThreadId threadId;
TName name;
name.Append(KTMSCallServerName);
threadId = tmscallServerThread.Id();
name.AppendNum(threadId.Id(), EHex);
//We are ignoring the error code returned from User::RenameThread
//as it is not important here, may be for profiling
User::RenameThread(name);
aStart.iTMSCallServerHandle = server->Server();
// Sync with the client and enter the active scheduler
RThread::Rendezvous(KErrNone);
sched->Start();
CleanupStack::PopAndDestroy(server); // server
CleanupStack::PopAndDestroy(sched); // sched
TRACE_PRN_FN_EXT;
}
/**
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 CMMFAudioPolicyServer::StartThreadL(TServerStart& aStart)
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
//Rename Audio Policy server name
RThread audioPolicyThread;
TName name;
name.Append(KMMFAudioPolicyServerName);
//We are ignoring the error code returned from User::RenameThread
//as it is not important here, may be for profiling
User::RenameThread(name);
CMMFAudioPolicyServer* server = CMMFAudioPolicyServer::NewL();
CleanupStack::PushL(server);
aStart.iPolicyServerHandle = server->Server();
// Sync with the client and enter the active scheduler
RThread::Rendezvous(KErrNone);
sched->Start();
CleanupStack::PopAndDestroy(2, sched); // sched, server
}
static QList<QNetworkInterfacePrivate *> interfaceListing()
{
TInt err(KErrNone);
QList<QNetworkInterfacePrivate *> interfaces;
QList<QHostAddress> addressesWithEstimatedNetmasks;
// Open dummy socket for interface queries
RSocket socket;
err = socket.Open(qt_symbianGetSocketServer(), _L("udp"));
if (err) {
return interfaces;
}
// Ask socket to start enumerating interfaces
err = socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);
if (err) {
socket.Close();
return interfaces;
}
int ifindex = 0;
TPckgBuf<TSoInetInterfaceInfo> infoPckg;
TSoInetInterfaceInfo &info = infoPckg();
while (socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, infoPckg) == KErrNone) {
if (info.iName != KNullDesC) {
TName address;
QNetworkAddressEntry entry;
QNetworkInterfacePrivate *iface = 0;
iface = new QNetworkInterfacePrivate;
iface->index = ifindex++;
interfaces << iface;
iface->name = qt_TDesC2QString(info.iName);
iface->flags = convertFlags(info);
if (/*info.iFeatures&KIfHasHardwareAddr &&*/ info.iHwAddr.Family() != KAFUnspec) {
for (TInt i = sizeof(SSockAddr); i < sizeof(SSockAddr) + info.iHwAddr.GetUserLen(); i++) {
address.AppendNumFixedWidth(info.iHwAddr[i], EHex, 2);
if ((i + 1) < sizeof(SSockAddr) + info.iHwAddr.GetUserLen())
address.Append(_L(":"));
}
address.UpperCase();
iface->hardwareAddress = qt_TDesC2QString(address);
}
// Get the address of the interface
entry.setIp(qt_QHostAddressFromTInetAddr(info.iAddress));
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "address is" << info.iAddress.Family() << entry.ip();
qDebug() << "netmask is" << info.iNetMask.Family() << qt_QHostAddressFromTInetAddr( info.iNetMask );
#endif
// Get the interface netmask
if (info.iNetMask.IsUnspecified()) {
// For some reason netmask is always 0.0.0.0 for IPv4 interfaces
// and loopback interfaces (which we statically know)
if (info.iAddress.IsV4Mapped()) {
if (info.iFeatures & KIfIsLoopback) {
entry.setPrefixLength(32);
} else {
// Workaround: Let Symbian determine netmask based on IP address class (IPv4 only API)
TInetAddr netmask;
netmask.NetMask(info.iAddress);
entry.setNetmask(QHostAddress(netmask.Address())); //binary convert v4 address
addressesWithEstimatedNetmasks << entry.ip();
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "address class determined netmask" << entry.netmask();
#endif
}
} else {
// For IPv6 interfaces
if (info.iFeatures & KIfIsLoopback) {
entry.setPrefixLength(128);
} else if (info.iNetMask.IsUnspecified()) {
//Don't see this error for IPv6, but try to handle it if it happens
entry.setPrefixLength(64); //most common
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "total guess netmask" << entry.netmask();
#endif
addressesWithEstimatedNetmasks << entry.ip();
}
}
} else {
//Expected code path for IPv6 non loopback interfaces (IPv4 could come here if symbian is fixed)
entry.setNetmask(qt_QHostAddressFromTInetAddr(info.iNetMask));
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "reported netmask" << entry.netmask();
#endif
}
// broadcast address is determined from the netmask in postProcess()
// Add new entry to interface address entries
iface->addressEntries << entry;
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug("\n Found network interface %s, interface flags:\n\
IsUp = %d, IsRunning = %d, CanBroadcast = %d,\n\
IsLoopBack = %d, IsPointToPoint = %d, CanMulticast = %d, \n\
ip = %s, netmask = %s, broadcast = %s,\n\
hwaddress = %s",
iface->name.toLatin1().constData(),
iface->flags & QNetworkInterface::IsUp, iface->flags & QNetworkInterface::IsRunning, iface->flags & QNetworkInterface::CanBroadcast,
iface->flags & QNetworkInterface::IsLoopBack, iface->flags & QNetworkInterface::IsPointToPoint, iface->flags & QNetworkInterface::CanMulticast,
entry.ip().toString().toLatin1().constData(), entry.netmask().toString().toLatin1().constData(), entry.broadcast().toString().toLatin1().constData(),
iface->hardwareAddress.toLatin1().constData());
#endif
}
}
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();
}
/**
* List existing network interfaces, IP addresses bound to them
* and fill up array of IP addresses for all interfaces.
*/
void CTestStepLLMNR_Init::ListInterfacesL()
{
RSocket socket;
TInt nRes;
TInt exceed;
TInt idx;
TName tmpBuf;
TName tmpBuf1;
nRes = socket.Open(ipTestServer->iSocketServer, KAfInet, KSockStream, KProtocolInetTcp);
TESTL(nRes == KErrNone);
TUint bufsize = 2048;
HBufC8 *buffer =NULL;
buffer = GetBuffer(buffer, bufsize);
TESTL(buffer != NULL);
TPtr8 bufdes = buffer->Des();
//-- reset array of local addresses
ipTestServer->iLocalAddrs.Reset();
//-- list all available network interfaces
INFO_PRINTF1(KNewLine);
INFO_PRINTF1(_L("--- available network interfaces:"));
do
{//-- get list of network interfaces
// if exceed>0, all interface could not fit into the buffer.
// In that case allocate a bigger buffer and retry.
// There should be no reason for this while loop to take more than 2 rounds.
bufdes.Set(buffer->Des());
exceed = socket.GetOpt(KSoInetInterfaceInfo, KSolInetIfQuery, bufdes);
if(exceed > 0)
{
bufsize += exceed * sizeof(TInetInterfaceInfo);
buffer = GetBuffer(buffer, bufsize);
TESTL(buffer != NULL);
}
} while (exceed > 0);
if (exceed < 0)
{
INFO_PRINTF1(_L("socket.GetOpt() error!"));
TESTL(EFalse);
}
TOverlayArray<TInetInterfaceInfo> infoIface(bufdes);
for(idx=0; idx < infoIface.Length(); ++idx)
{
TInetInterfaceInfo& iface = infoIface[idx];
tmpBuf.Format(_L("index:%d, name: "),iface.iIndex);
tmpBuf.Append(iface.iName );
tmpBuf.AppendFormat(_L(" state:%d"), iface.iState);
INFO_PRINTF1(tmpBuf);
}
//-- list all IP addresses, bound to the interfaces
//-- and append this address to the array of host-local addresses
INFO_PRINTF1(KNewLine);
INFO_PRINTF1(_L("--- IP addresses bound to the interfaces:"));
do
{
// if exceed>0, all interface could not fit into the buffer.
// In that case allocate a bigger buffer and retry.
// There should be no reason for this while loop to take more than 2 rounds.
bufdes.Set(buffer->Des());
exceed = socket.GetOpt(KSoInetAddressInfo, KSolInetIfQuery, bufdes);
if(exceed > 0)
{
bufsize += exceed * sizeof(TInetAddressInfo);
buffer = GetBuffer(buffer, bufsize);
}
} while (exceed > 0);
if (exceed < 0)
{
INFO_PRINTF1(_L("socket.GetOpt() error!"));
TESTL(EFalse);
}
//-- print out IP addresses
TOverlayArray<TInetAddressInfo> infoAddr(bufdes);
TInetAddr inetAddr;
for(idx=0; idx < infoAddr.Length(); ++idx)
{
TInetAddressInfo& addr = infoAddr[idx];
tmpBuf.Format(_L("iface index: %d, scopeID: %d, state: %d, IP addr: "), addr.iInterface, addr.iScopeId, addr.iState);
inetAddr.SetAddress(addr.iAddress);
inetAddr.Output(tmpBuf1);
tmpBuf.Append(tmpBuf1);
INFO_PRINTF1(tmpBuf);
//-- if obtained IP address is valid and not loopback, add it to the array.
if(inetAddr.IsLoopback() || inetAddr.IsUnspecified())
{}
else
ipTestServer->iLocalAddrs.Append(inetAddr);
}
delete buffer;
socket.Close();
INFO_PRINTF1(KNewLine);
}
/**
* 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 CAppStarter::StartL()
{
TFileName newname = iExeFileName;
TThreadId threadId = 0;
switch(iAppType)
{
case EApplicationType:
{
TApaAppInfo info;
if(iSession.GetAppInfo(info,TUid::Uid(iAppUid)) != KErrNone)
{
After(KRetryWait);
return;
}
if(iViewless)
{
TRAPD(err, TryStartViewlessAppL(info, threadId));
if (err != KErrNone)
{
After(KRetryWait);
return; //ignore error
}
}
else if (info.iUid!=KNullUid)
{
if(iSession.StartDocument(newname, TUid::Uid(iAppUid), threadId) != KErrNone)
{
After(KRetryWait);
return;
}
}
else
{
iState = EAppFailed;
Next();
}
}
break;
case EExecutableType:
{
newname.Append(KExtension);
if(iSession.StartDocument(newname, TUid::Uid(0), threadId) != KErrNone)
{
After(KRetryWait);
return;
}
}
break;
case ECmdLnArgExecutableType:
{
ASSERT( !iMonitoring); // Not imlpemented yet
#if defined(__WINS__) || defined(__WINSCW__)
TName libName = iDllFileName;
libName.Append(KExtension);
RLibrary lib;
TInt error = lib.Load(libName);
if (error!=KErrNone)
{
After(KRetryWait);
return;
}
TThreadFunction serverFunc=reinterpret_cast<TThreadFunction>(lib.Lookup(1));
RThread server;
error=server.Create(libName,serverFunc, iStackSize, iCmdLineArgs, &lib,NULL,
iMinHeapSize,iMaxHeapSize,EOwnerProcess);
lib.Close(); // if successful, server thread has handle to library now
#else
RProcess server;
TInt error = server.Create(newname, *iCmdLineArgs);
#endif
if( error != KErrNone)
{
After(KRetryWait);
return;
}
server.Resume();
server.Close();
}
break;
default:
iState = EAppFailed;
Next();
}
if (iMonitoring)
{
CThreadWatcher *threadWatcher=NULL;
TRAPD(err, threadWatcher = CThreadWatcher::NewL(iAppType, threadId, newname, iStarter, iAppUid, iViewless));
if (err == KErrNone) //ignore errors
iQue->AddLast(*threadWatcher);
}
iState = EAppStarted;
Next();
}
TVerdict CSimPacketGPRSQOSTest::doTestStepL()
{
INFO_PRINTF1(_L("BeginPacketGPRSQOSTest"));
CreateConfigFileL(_L("c:\\config3.txt"));
SetTestNumberL(6);
TInt ret = iPhone.Open(iTelServer,KPhoneName);
INFO_PRINTF2(_L("Result: %d"),ret);
TESTL(ret == KErrNone);
INFO_PRINTF1(_L("Opened phone object"));
TESTL(iPacketService.Open(iPhone)==KErrNone);
INFO_PRINTF1(_L("Opened Packet object"));
TName contextName;
TName contextNameCompare;
TESTL(iFirstPrimaryPacketContext.OpenNewContext(iPacketService, contextName)==KErrNone);
contextNameCompare.Append(KSimPrimaryPacketContextName);
contextNameCompare.AppendNum(1);
TESTL(contextName.Compare(contextNameCompare)==KErrNone);
INFO_PRINTF1(_L("Opened Context object"));
TRequestStatus reqStatus;
TRequestStatus notifyStatus;
TName gprsQosName;
TESTL(iGPRSPacketqos.OpenNewQoS(iFirstPrimaryPacketContext, gprsQosName)==KErrNone);
TName gprsQosNameCompare;
gprsQosNameCompare.Append(KSimPacketQosName);
gprsQosNameCompare.AppendNum(1);
TESTL(gprsQosName.Compare(gprsQosNameCompare)==KErrNone);
INFO_PRINTF1(_L("Opened GPRS QoS object"));
TName qosname;
iFirstPrimaryPacketContext.GetProfileName(qosname);
INFO_PRINTF1(_L("Retrieved GPRS QoS object reference name"));
// Set QoS Profile Params
RPacketQoS::TQoSGPRSRequested aGPRSQoSReqConfig;
TPckg<RPacketQoS::TQoSGPRSRequested> aGPRSQoSReqPckg(aGPRSQoSReqConfig);
// post a notification
RPacketQoS::TQoSGPRSNegotiated aGPRSNotifyQoS;
TPckg<RPacketQoS::TQoSGPRSNegotiated> aGPRSNotifyQoSPckg(aGPRSNotifyQoS);
//Profile data
aGPRSQoSReqConfig.iMinDelay = RPacketQoS::EDelayClass1;
aGPRSQoSReqConfig.iMinMeanThroughput = RPacketQoS::EMeanThroughput200;
aGPRSQoSReqConfig.iMinPeakThroughput = RPacketQoS::EPeakThroughput16000;
aGPRSQoSReqConfig.iMinPrecedence = RPacketQoS::EPriorityLowPrecedence;
aGPRSQoSReqConfig.iMinReliability = RPacketQoS::EReliabilityClass1;
aGPRSQoSReqConfig.iReqDelay = RPacketQoS::EDelayClass2;
aGPRSQoSReqConfig.iReqMeanThroughput = RPacketQoS::EMeanThroughput2000;
aGPRSQoSReqConfig.iReqPeakThroughput = RPacketQoS::EPeakThroughput64000;
aGPRSQoSReqConfig.iReqPrecedence = RPacketQoS::EPriorityMediumPrecedence;
aGPRSQoSReqConfig.iReqReliability = RPacketQoS::EReliabilityClass2;
//post the notification
iGPRSPacketqos.NotifyProfileChanged(notifyStatus, aGPRSNotifyQoSPckg);
//Set the config
iGPRSPacketqos.SetProfileParameters(reqStatus, aGPRSQoSReqPckg);
User::WaitForRequest(notifyStatus);
User::WaitForRequest(reqStatus);
TESTL(aGPRSNotifyQoS.ExtensionId()==TPacketDataConfigBase::KConfigGPRS);
TESTL(aGPRSNotifyQoS.iDelay == RPacketQoS::EDelayClass2);
TESTL(aGPRSNotifyQoS.iDelay == RPacketQoS::EDelayClass2);
TESTL(aGPRSNotifyQoS.iMeanThroughput == RPacketQoS::EMeanThroughput2000);
TESTL(aGPRSNotifyQoS.iPeakThroughput == RPacketQoS::EPeakThroughput64000);
TESTL(aGPRSNotifyQoS.iPrecedence == RPacketQoS::EPriorityMediumPrecedence);
TESTL(aGPRSNotifyQoS.iReliability == RPacketQoS::EReliabilityClass2);
// post a notification
TRequestStatus cancelStatus;
iGPRSPacketqos.NotifyProfileChanged(cancelStatus, aGPRSNotifyQoSPckg);
iGPRSPacketqos.CancelAsyncRequest(EPacketQoSNotifyProfileChanged);
User::WaitForRequest(cancelStatus);
TESTL(cancelStatus.Int()==KErrCancel);
INFO_PRINTF1(_L("Set Profile Test passed"));
// need to call Notify first to set pending to true after
// cancel event which sets it to false
iGPRSPacketqos.NotifyProfileChanged(notifyStatus, aGPRSNotifyQoSPckg);
iGPRSPacketqos.SetProfileParameters(reqStatus, aGPRSQoSReqPckg);
User::WaitForRequest(notifyStatus);
TESTL(notifyStatus.Int()==KErrNone);
User::WaitForRequest(reqStatus);
TESTL(reqStatus.Int()==KErrNone);
// test RPacketContext::Activate - before calling ModifyActiveContext
StartNTRasSimulation();
iFirstPrimaryPacketContext.Activate(reqStatus);
User::WaitForRequest(reqStatus);
TESTL(reqStatus.Int()==KErrNone);
INFO_PRINTF1(_L("Activate test passed"));
// test RPacketContext::ModifyActiveContext - it shouldn't work unless
// a profile/tft has changed since activation
TRequestStatus modifyStatus;
iFirstPrimaryPacketContext.ModifyActiveContext(modifyStatus);
User::WaitForRequest(modifyStatus);
TESTL(modifyStatus.Int()==KErrNotReady);
iGPRSPacketqos.SetProfileParameters(reqStatus, aGPRSQoSReqPckg);
User::WaitForRequest(reqStatus);
TESTL(reqStatus.Int()==KErrNone);
iFirstPrimaryPacketContext.ModifyActiveContext(modifyStatus);
User::WaitForRequest(modifyStatus);
TESTL(modifyStatus.Int()==KErrNone);
INFO_PRINTF1(_L("ModifyActiveContext Test Passed"));
INFO_PRINTF1(_L("Notify GPRS QoS Profile Test passed"));
// Get QoS GPRS Capabilities
RPacketQoS::TQoSCapsGPRS aQoSCaps;
TPckg<RPacketQoS::TQoSCapsGPRS> aQoSCapsPckg(aQoSCaps);
iGPRSPacketqos.GetProfileCapabilities(reqStatus, aQoSCapsPckg);
User::WaitForRequest(reqStatus);
TESTL(reqStatus.Int()==KErrNone);
TESTL(aQoSCaps.ExtensionId()==TPacketDataConfigBase::KConfigGPRS);
TESTL(aQoSCaps.iDelay == RPacketQoS::EDelayClass2);
TESTL(aQoSCaps.iMean == RPacketQoS::EMeanThroughput100);
TESTL(aQoSCaps.iPeak == RPacketQoS::EPeakThroughput64000);
TESTL(aQoSCaps.iPrecedence == RPacketQoS::EPriorityMediumPrecedence);
TESTL(aQoSCaps.iReliability == RPacketQoS::EReliabilityClass2);
INFO_PRINTF1(_L("Get QoS Profile Capabilities Test passed"));
//Get QoS Profile Params
RPacketQoS::TQoSGPRSNegotiated aGPRSQoSNegConfig;
TPckg<RPacketQoS::TQoSGPRSNegotiated> aGPRSQoSNegPckg(aGPRSQoSNegConfig);
iGPRSPacketqos.GetProfileParameters(cancelStatus, aGPRSQoSNegPckg);
iGPRSPacketqos.CancelAsyncRequest(EPacketQoSGetProfileParams);//no implementation-does nothing
User::WaitForRequest(cancelStatus);
TESTL(cancelStatus.Int()==KErrNone);
TESTL(aGPRSQoSNegConfig.ExtensionId()==TPacketDataConfigBase::KConfigGPRS);
TESTL(aGPRSQoSNegConfig.iDelay==RPacketQoS::EDelayClass2);
TESTL(aGPRSQoSNegConfig.iMeanThroughput==RPacketQoS::EMeanThroughput100);
TESTL(aGPRSQoSNegConfig.iPeakThroughput==RPacketQoS::EPeakThroughput64000);
TESTL(aGPRSQoSNegConfig.iPrecedence==RPacketQoS::EPriorityMediumPrecedence);
TESTL(aGPRSQoSNegConfig.iReliability==RPacketQoS::EReliabilityClass2);
INFO_PRINTF1(_L("Get QoS Profile Test passed"));
// End of RPacketQos tests
iGPRSPacketqos.Close();
iFirstPrimaryPacketContext.Close();
iPacketService.Close();
iPhone.Close();
ASSERT(RThread().RequestCount()==0);
return TestStepResult();
}
TVerdict CSimPacketGPRSRel99NotifyProfileChangeTest::doTestStepL()
{
INFO_PRINTF1(_L("BeginPacketGPRSRel99NotifyProfileChangeTest"));
CreateConfigFileL(_L("c:\\config3.txt"));
SetTestNumberL(6);
TRequestStatus gprsReqStatus, rel99ReqStatus;
TRequestStatus gprsNotifyStatus, rel99NotifyStatus;
// Open phone
TInt ret = iPhone.Open(iTelServer,KPhoneName);
INFO_PRINTF2(_L("Result: %d"),ret);
TESTL(ret == KErrNone);
INFO_PRINTF1(_L("Opened phone object"));
// Open GPRS packet service
TESTL(iGPRSPacketService.Open(iPhone)==KErrNone);
INFO_PRINTF1(_L("Opened Packet object"));
// Open GPRS context
TName contextName;
TName contextNameCompare;
TESTL(iGPRSPacketContext.OpenNewContext(iGPRSPacketService, contextName)==KErrNone);
contextNameCompare.Append(KSimPrimaryPacketContextName);
contextNameCompare.AppendNum(1);
TESTL(contextName.Compare(contextNameCompare)==KErrNone);
INFO_PRINTF1(_L("Opened Context object"));
// Open GPRS PacketQoS
TName gprsQosName;
TESTL(iGPRSPacketqos.OpenNewQoS(iGPRSPacketContext, gprsQosName)==KErrNone);
TName gprsQosNameCompare;
gprsQosNameCompare.Append(KSimPacketQosName);
gprsQosNameCompare.AppendNum(1);
TESTL(gprsQosName.Compare(gprsQosNameCompare)==KErrNone);
INFO_PRINTF1(_L("Opened GPRS QoS object"));
// Open UMTS Rel99 packet service - opened from same session RTelServer object as GPRS packet service
TESTL(iRel99PacketService.Open(iPhone)==KErrNone);
INFO_PRINTF1(_L("Opened Rel99 Packet object"));
// Open UMTS Rel99 context
TESTL(iRel99PacketContext.OpenExistingContext(iRel99PacketService, contextName) == KErrNone);
// Open Rel99 PacketQoS
TESTL(iRel99Packetqos.OpenExistingQoS(iRel99PacketContext, gprsQosName)==KErrNone);
INFO_PRINTF1(_L("Opened Rel99 QoS object"));
//Configure GPRS parameters
//
//
// Set GPRS QoS Profile Params
RPacketQoS::TQoSGPRSRequested aGPRSQoSReqConfig;
TPckg<RPacketQoS::TQoSGPRSRequested> aGPRSQoSReqPckg(aGPRSQoSReqConfig);
// post a GPRS notification
RPacketQoS::TQoSGPRSNegotiated aGPRSNotifyQoS;
TPckg<RPacketQoS::TQoSGPRSNegotiated> aGPRSNotifyQoSPckg(aGPRSNotifyQoS);
//GPRS Profile data
aGPRSQoSReqConfig.iMinDelay = RPacketQoS::EDelayClass1;
aGPRSQoSReqConfig.iMinMeanThroughput = RPacketQoS::EMeanThroughput200;
aGPRSQoSReqConfig.iMinPeakThroughput = RPacketQoS::EPeakThroughput16000;
aGPRSQoSReqConfig.iMinPrecedence = RPacketQoS::EPriorityLowPrecedence;
aGPRSQoSReqConfig.iMinReliability = RPacketQoS::EReliabilityClass1;
aGPRSQoSReqConfig.iReqDelay = RPacketQoS::EDelayClass2;
aGPRSQoSReqConfig.iReqMeanThroughput = RPacketQoS::EMeanThroughput2000;
aGPRSQoSReqConfig.iReqPeakThroughput = RPacketQoS::EPeakThroughput64000;
aGPRSQoSReqConfig.iReqPrecedence = RPacketQoS::EPriorityMediumPrecedence;
aGPRSQoSReqConfig.iReqReliability = RPacketQoS::EReliabilityClass2;
//
//
//Configure Rel99 QoS Profile Params
//
//
RPacketQoS::TQoSR99_R4Requested aR99QoSReqConfig;
TESTL(aR99QoSReqConfig.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4);
TPckg<RPacketQoS::TQoSR99_R4Requested> aR99QoSReqPckg(aR99QoSReqConfig);
RPacketQoS::TQoSR99_R4Negotiated aR99NotifyQoS;
TPckg<RPacketQoS::TQoSR99_R4Negotiated> aR99NotifyQoSPckg(aR99NotifyQoS);
TInt req = 4;
TInt min = 2;
//Profile data
aR99QoSReqConfig.iReqTrafficClass = RPacketQoS::ETrafficClassStreaming; // 0x04
aR99QoSReqConfig.iMinTrafficClass = RPacketQoS::ETrafficClassConversational; // 0x02
aR99QoSReqConfig.iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; // 0x04
aR99QoSReqConfig.iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderRequired; // 0x02
aR99QoSReqConfig.iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; // 0x08
aR99QoSReqConfig.iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; // 0x04
aR99QoSReqConfig.iReqMaxSDUSize = req; // 4
aR99QoSReqConfig.iMinAcceptableMaxSDUSize = min; // 2
aR99QoSReqConfig.iReqMaxRate.iUplinkRate = min; // between 0 - 1840
aR99QoSReqConfig.iReqMaxRate.iDownlinkRate = min;
aR99QoSReqConfig.iMinAcceptableMaxRate.iDownlinkRate = min-1; // between 0 - 1840
aR99QoSReqConfig.iMinAcceptableMaxRate.iUplinkRate = req;
aR99QoSReqConfig.iReqBER = RPacketQoS::EBEROnePerHundred; // 0x04
aR99QoSReqConfig.iMaxBER = RPacketQoS::EBERFivePerHundred; // 0x02
aR99QoSReqConfig.iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioSevenPerThousand; // 0x08
aR99QoSReqConfig.iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundred; // 0x04
aR99QoSReqConfig.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; // 0x04
aR99QoSReqConfig.iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; // 0x02
aR99QoSReqConfig.iReqTransferDelay = req;
aR99QoSReqConfig.iMaxTransferDelay = min;
aR99QoSReqConfig.iReqGuaranteedRate.iDownlinkRate = min;
aR99QoSReqConfig.iReqGuaranteedRate.iUplinkRate = req;
aR99QoSReqConfig.iMinGuaranteedRate.iDownlinkRate = min;
aR99QoSReqConfig.iMinGuaranteedRate.iUplinkRate = req;
//
//
//post the notifications
iRel99Packetqos.NotifyProfileChanged(rel99NotifyStatus, aR99NotifyQoSPckg);
iGPRSPacketqos.NotifyProfileChanged(gprsNotifyStatus, aGPRSNotifyQoSPckg);
//Set the profile
iRel99Packetqos.SetProfileParameters(rel99ReqStatus, aR99QoSReqPckg);
iGPRSPacketqos.SetProfileParameters(gprsReqStatus, aGPRSQoSReqPckg);
User::WaitForRequest(rel99NotifyStatus);
User::WaitForRequest(gprsNotifyStatus);
//User::WaitForRequest(rel99ReqStatus);
User::WaitForRequest(rel99ReqStatus);
User::WaitForRequest(gprsReqStatus);
//Test the notification packages are correct
//Rel99
TESTL(aR99NotifyQoS.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4);
TESTL(aR99NotifyQoS.iTrafficClass==RPacketQoS::ETrafficClassConversational);
TESTL(aR99NotifyQoS.iDeliveryOrderReqd==RPacketQoS::EDeliveryOrderNotRequired);
TESTL(aR99NotifyQoS.iDeliverErroneousSDU==RPacketQoS::EErroneousSDUNoDetection);
TESTL(aR99NotifyQoS.iMaxSDUSize==min);
TESTL(aR99NotifyQoS.iMaxRate.iUplinkRate==min);
TESTL(aR99NotifyQoS.iMaxRate.iDownlinkRate==req);
TESTL(aR99NotifyQoS.iBER==RPacketQoS::EBEROnePerHundred);
TESTL(aR99NotifyQoS.iSDUErrorRatio==RPacketQoS::ESDUErrorRatioOnePerTen);
TESTL(aR99NotifyQoS.iTrafficHandlingPriority==RPacketQoS::ETrafficPriority2);
TESTL(aR99NotifyQoS.iTransferDelay==min);
TESTL(aR99NotifyQoS.iGuaranteedRate.iUplinkRate==min);
TESTL(aR99NotifyQoS.iGuaranteedRate.iDownlinkRate==req);
//Gprs
TESTL(aGPRSNotifyQoS.ExtensionId()==TPacketDataConfigBase::KConfigGPRS);
TESTL(aGPRSNotifyQoS.iDelay == RPacketQoS::EDelayClass2);
TESTL(aGPRSNotifyQoS.iDelay == RPacketQoS::EDelayClass2);
TESTL(aGPRSNotifyQoS.iMeanThroughput == RPacketQoS::EMeanThroughput2000);
TESTL(aGPRSNotifyQoS.iPeakThroughput == RPacketQoS::EPeakThroughput64000);
TESTL(aGPRSNotifyQoS.iPrecedence == RPacketQoS::EPriorityMediumPrecedence);
TESTL(aGPRSNotifyQoS.iReliability == RPacketQoS::EReliabilityClass2);
// Close
iGPRSPacketqos.Close();
iGPRSPacketContext.Close();
iGPRSPacketService.Close();
iRel99Packetqos.Close();
iRel99PacketContext.Close();
iRel99PacketService.Close();
iPhone.Close();
ASSERT(RThread().RequestCount()==0);
return TestStepResult();
}
void CCTsySessionManagementFU::AuxOpenExisting3L(const TDesC &aName)
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TName lineName(aName);
RLine line;
TInt ret = line.Open(iPhone, lineName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(line);
TName callname;
RCall call;
ret = OpenNewCall(line, call, lineName, callname);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(call);
// test on bad call name
_LIT(KBadCallName, "BadCallName");
RCall call2;
ret = call2.OpenExistingCall(line, KBadCallName);
ASSERT_EQUALS(KErrNotFound, ret);
AssertMockLtsyStatusL();
// test on bad line name
_LIT(KBadLineName, "BadLineName");
TName name;
name = KBadLineName;
name.Append(KDoubleColon);
name.Append(callname);
ret = call2.OpenExistingCall(iPhone, name);
ASSERT_EQUALS(KErrNotSupported, ret);
AssertMockLtsyStatusL();
// test on bad call name and correct line
name = lineName;
name.Append(KDoubleColon);
name.Append(KBadCallName);
ret = call2.OpenExistingCall(iPhone, name);
ASSERT_EQUALS(KErrNotFound, ret);
AssertMockLtsyStatusL();
// test on bad phone name
_LIT(KBadPhoneName, "BadPhoneName");
name = KBadPhoneName;
name.Append(KDoubleColon);
name.Append(lineName);
name.Append(KDoubleColon);
name.Append(callname);
ret = call2.OpenExistingCall(iTelServer, name);
ASSERT_EQUALS(KErrNotFound, ret);
AssertMockLtsyStatusL();
// test on bad line name and correct phone
name = KMmTsyPhoneName;
name.Append(KDoubleColon);
name.Append(KBadLineName);
name.Append(KDoubleColon);
name.Append(callname);
ret = call2.OpenExistingCall(iTelServer, name);
ASSERT_EQUALS(KErrNotSupported, ret);
AssertMockLtsyStatusL();
// test on bad call name with correct phone and line
name = KMmTsyPhoneName;
name.Append(KDoubleColon);
name.Append(lineName);
name.Append(KDoubleColon);
name.Append(KBadCallName);
ret = call2.OpenExistingCall(iTelServer, name);
ASSERT_EQUALS(KErrNotFound, ret);
// test on string analyze
_LIT(KBad, "::::::::");
name = KBad;
ret = call2.OpenExistingCall(iTelServer, name);
ASSERT_EQUALS(KErrNotFound, ret);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(3, this);
}
void CCTsySessionManagementFU::AuxOpenExisting1L(const TDesC &aName)
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
TName lineName(aName);
RLine line;
TInt ret = line.Open(iPhone, lineName);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(line);
TName callname;
RCall call;
ret = OpenNewCall(line, call, lineName, callname);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(call);
// test on successful completion
RCall call2;
ret = call2.OpenExistingCall(line, callname);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(call2);
AssertMockLtsyStatusL();
// test on successful completion (another params set)
TName name;
name = lineName;
name.Append(KDoubleColon);
name.Append(callname);
RCall call3;
ret = call3.OpenExistingCall(iPhone, name);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(call3);
AssertMockLtsyStatusL();
// test on successful completion (another params set)
RCall call4;
name = KMmTsyPhoneName;
name.Append(KDoubleColon);
name.Append(lineName);
name.Append(KDoubleColon);
name.Append(callname);
ret = call4.OpenExistingCall(iTelServer, name);
ASSERT_EQUALS(KErrNone, ret);
CleanupClosePushL(call4);
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(6, this);
}
/*
-------------------------------------------------------------------------------
Class: CUnderTaker
Method: RunL
Description: Handles thread death.
Function does:
1 ) Stops monitoring thread
1 ) Marks thread death
2 ) Completes ongoing requests
3 ) Cleans the memory
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
void CUnderTaker::RunL()
{
// Make sure that any of the test interference thread's won't stay to run.
iModuleContainer->KillTestinterferenceThread();
// Make sure that any of the test measurement's process won't stay to run.
iModuleContainer->KillTestMeasurement();
// Get the exit category
TName exitCategory = _L( "Crash reason:" );
exitCategory.Append( iModuleContainer->iThread.ExitCategory() );
TInt exitReason = iModuleContainer->iThread.ExitReason();
TFullTestResult::TCaseExecutionResult exitType = TFullTestResult::ECaseException;
if( iModuleContainer->iThread.ExitType() == EExitPanic )
{
exitType = TFullTestResult::ECasePanic;
}
// it is not running anymore..
iModuleContainer->iUpAndRunning = EFalse;
// Do not monitor anymore.
iModuleContainer->iThread.LogonCancel( iStatus );
iCancelNeeded = EFalse;
__TRACE( KError,( CStifLogger::ERed, _L( "Execution thread crashed, exitReason = %d" ), exitReason ) );
__TRACE( KError,( CStifLogger::ERed, exitCategory ) );
if ( iSynchronousMode )
{
// Synchronous request was running. Complete that
// operation.
__TRACE( KVerbose,( _L( "CUnderTaker::RunL Crash during synchronous operation" ) ) );
iModuleContainer->iErrorResult = KErrDied;
iModuleContainer->Cancel();
iModuleContainer->iUpAndRunning = EFalse;
// Print notification
TName operationText = _L("Test module died when calling:");
operationText.Append( iModuleContainer->iOperationText );
// Print to log file
__TRACE( KError,( CStifLogger::ERed, operationText ) );
// Print to UI
iModuleContainer->iCTestModule->ErrorPrint ( 1, operationText );
// Stop active scheduler.
CActiveScheduler::Stop();
// Execution continues from CTestModuleContainer::StartAndWaitOperation.
}
else
{// Test case was running,
__TRACE( KError,( _L( "Test case execution aborted" ) ) );
__TRACE( KVerbose,( _L( "CUnderTaker::Run crash during test execution" ) ) );
TInt caseResult = KErrGeneral;
// Check if case have any special panic or exception codes that are "passed"
if ( iModuleContainer->iAllowedExitReason !=
CTestModuleIf::ENormal )
{
if ( iModuleContainer->iAllowedExitReason ==
CTestModuleIf::EPanic &&
exitType == TFullTestResult::ECasePanic &&
iModuleContainer->iAllowedExitCode == exitReason )
{
exitType = TFullTestResult::ECaseExecuted;
caseResult = KErrNone;
exitCategory = _L("Allowed case panic");
__TRACE( KError,( _L( "Test case execution panic, setting to OK" ) ) );
}
if ( iModuleContainer->iAllowedExitReason ==
CTestModuleIf::EException &&
exitType == TFullTestResult::ECaseException &&
iModuleContainer->iAllowedExitCode == exitReason )
{
exitType = TFullTestResult::ECaseExecuted;
caseResult = KErrNone;
exitCategory = _L("Allowed case exception");
__TRACE( KError,( _L( "Test case execution exception, setting to OK" ) ) );
}
}
// This was asynchronous request, and nobody is waiting for it
// completion in server, so all clean-up must be done here
// Forget iTestThreadContainer pointer, memory is freed because test thread
// is destroyed
// This is needed to prevent from accessing memory from thread that is destroyed.
// Do this only if test is been executed.
iModuleContainer->iThreadContainer = NULL;
if (iModuleContainer->iCTestExecution != NULL)
{
// Execution thread have been killed
iModuleContainer->iCTestExecution->SetThreadState( CTestExecution::ECancelled );
// Cancel the request
iModuleContainer->iCTestExecution->CompleteTestExecution( KErrNone,
exitType,
exitReason,
caseResult,
exitCategory );
// If the print queue is empty, and there is active print
// request, then cancel that request.
// NOTE: Case queue not empty AND request waiting AND
// thread terminated can't happen due iPrintMutex
iModuleContainer->iCTestExecution->CompletePrintRequestIfQueueEmpty();
}
else
{
__TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CUnderTaker::RunL." ) ) );
User::Leave(KErrGeneral);
}
// Free the memory
// Remove undertaker from module container to make sure that
// it does not delete this.
iModuleContainer->iUnderTaker = NULL;
delete iModuleContainer;
iModuleContainer = NULL;
// Suicide. "Parent", i.e iModuleContainer has already died
// and no-one have pointer to this active object, so die.
delete this;
}
}
static QList<QNetworkInterfacePrivate *> interfaceListing()
{
TInt err(KErrNone);
QList<QNetworkInterfacePrivate *> interfaces;
// Connect to Native socket server
RSocketServ socketServ;
err = socketServ.Connect();
if (err)
return interfaces;
// Open dummy socket for interface queries
RSocket socket;
err = socket.Open(socketServ, _L("udp"));
if (err) {
socketServ.Close();
return interfaces;
}
// Ask socket to start enumerating interfaces
err = socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);
if (err) {
socket.Close();
socketServ.Close();
return interfaces;
}
int ifindex = 0;
TPckgBuf<TSoInetInterfaceInfo> infoPckg;
TSoInetInterfaceInfo &info = infoPckg();
while (socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, infoPckg) == KErrNone) {
// Do not include IPv6 addresses because netmask and broadcast address cannot be determined correctly
if (info.iName != KNullDesC && info.iAddress.IsV4Mapped()) {
TName address;
QNetworkAddressEntry entry;
QNetworkInterfacePrivate *iface = 0;
iface = new QNetworkInterfacePrivate;
iface->index = ifindex++;
interfaces << iface;
iface->name = qt_TDesC2QString(info.iName);
iface->flags = convertFlags(info);
if (/*info.iFeatures&KIfHasHardwareAddr &&*/ info.iHwAddr.Family() != KAFUnspec) {
for (TInt i = sizeof(SSockAddr); i < sizeof(SSockAddr) + info.iHwAddr.GetUserLen(); i++) {
address.AppendNumFixedWidth(info.iHwAddr[i], EHex, 2);
if ((i + 1) < sizeof(SSockAddr) + info.iHwAddr.GetUserLen())
address.Append(_L(":"));
}
address.UpperCase();
iface->hardwareAddress = qt_TDesC2QString(address);
}
// Get the address of the interface
info.iAddress.Output(address);
entry.setIp(QHostAddress(qt_TDesC2QString(address)));
// Get the interface netmask
// For some reason netmask is always 0.0.0.0
// info.iNetMask.Output(address);
// entry.setNetmask( QHostAddress( qt_TDesC2QString( address ) ) );
// Workaround: Let Symbian determine netmask based on IP address class
// TODO: Works only for IPv4 - Task: 259128 Implement IPv6 support
TInetAddr netmask;
netmask.NetMask(info.iAddress);
netmask.Output(address);
entry.setNetmask(QHostAddress(qt_TDesC2QString(address)));
// Get the interface broadcast address
if (iface->flags & QNetworkInterface::CanBroadcast) {
// For some reason broadcast address is always 0.0.0.0
// info.iBrdAddr.Output(address);
// entry.setBroadcast( QHostAddress( qt_TDesC2QString( address ) ) );
// Workaround: Let Symbian determine broadcast address based on IP address
// TODO: Works only for IPv4 - Task: 259128 Implement IPv6 support
TInetAddr broadcast;
broadcast.NetBroadcast(info.iAddress);
broadcast.Output(address);
entry.setBroadcast(QHostAddress(qt_TDesC2QString(address)));
}
// Add new entry to interface address entries
iface->addressEntries << entry;
#if defined(QNETWORKINTERFACE_DEBUG)
printf("\n Found network interface %s, interface flags:\n\
IsUp = %d, IsRunning = %d, CanBroadcast = %d,\n\
IsLoopBack = %d, IsPointToPoint = %d, CanMulticast = %d, \n\
ip = %s, netmask = %s, broadcast = %s,\n\
hwaddress = %s",
iface->name.toLatin1().constData(),
iface->flags & QNetworkInterface::IsUp, iface->flags & QNetworkInterface::IsRunning, iface->flags & QNetworkInterface::CanBroadcast,
iface->flags & QNetworkInterface::IsLoopBack, iface->flags & QNetworkInterface::IsPointToPoint, iface->flags & QNetworkInterface::CanMulticast,
entry.ip().toString().toLatin1().constData(), entry.netmask().toString().toLatin1().constData(), entry.broadcast().toString().toLatin1().constData(),
iface->hardwareAddress.toLatin1().constData());
#endif
}
}
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;
}
}
