enum TVerdict CTestIdna08::doTestStepL()
{
INFO_PRINTF1(_L(" Testing the Loading of the new Library "));
INFO_PRINTF1(_L("****************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RLibrary testLibrary;
TInt err = testLibrary.Load(_L("punycodeconverter.dll"));
if(err == KErrNone)
{
INFO_PRINTF1(_L(" Loading the punycodeconverter library is successful"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF1(_L(" Loading the punycodeconverter library is NOT successful"));
User::LeaveIfError(KErrNone); // just to suppress the LeaveScan warning
}
INFO_PRINTF1(_L("Negative Testing of SetOpt "));
INFO_PRINTF1(_L("****************************************"));
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
TBool enableIdn = ETrue;//enabling the option of IDN support
TPckgC<TBool> pckgEnable(enableIdn);
TInt setOptErr = hr.SetOpt(KSoInetConfigInterface , KSolInetDns , pckgEnable);
if(setOptErr != KErrNone)
{
INFO_PRINTF1(_L(" Negative Testing of the Setopt successful "));
SetTestStepResult(EPass);
}
setOptErr = hr.SetOpt(KSoDnsEnableIdn , KSolInetDns , pckgEnable);
User::LeaveIfError(setOptErr);
enableIdn = EFalse;
TPckgC<TBool> pckgDisable(enableIdn);
setOptErr = hr.SetOpt(KSoDnsEnableIdn , KSolInetDns , pckgDisable);
User::LeaveIfError(setOptErr);
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
int ILibSocketWrapper_socket(int socketType)
{
int RetVal;
// create a new connection for the socket
RConnection* pConnection = new RConnection;
// open a connection
pConnection->Open(socketServer);
TCommDbConnPref prefs;
// set the preference for the requested interface
prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
pConnection->Start(prefs);
if ( (socketType == SOCK_DGRAM) ||
(socketType == SOCK_STREAM) )
{
RSocket *pSocket = new RSocket();
if ( socketType == SOCK_DGRAM )
{
pSocket->Open(socketServer,
KAfInet,
KSockDatagram,
KProtocolInetUdp,
*pConnection);
}
else
{
pSocket->Open(socketServer,
KAfInet,
KSockStream,
KProtocolInetTcp,
*pConnection);
}
RetVal = ILibSocketWrapper_GetNextAvailableHandle();
if( RetVal >= 0 )
{
SocketArray[RetVal] = (int)pSocket;
ConnectionArray[RetVal] = pConnection;
}
else
{
pSocket->Close();
delete pSocket;
pConnection->Close();
delete pConnection;
RetVal = -1;
}
}
return RetVal;
}
/*
* Close a Connection from the array of type RConnection CArrayFixSeg<RConnection *>
*/
void CMultipleArray::CloseConnection(TInt aIndex)
{
/* Close the Connection
* Remove entry from list
*/
RConnection* conn = iConnectionList->At(aIndex - 1);
conn->Close();
iConnectionList->Delete(aIndex - 1);
delete conn;
}
enum TVerdict CTestIdna04::doTestStepL()
{
INFO_PRINTF1(_L(" Testing GetByAddress(for an IDN) with IDN Enabled "));
INFO_PRINTF1(_L("*********************************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
TBool enableIdn = ETrue;//enabling the option of IDN support
TPckgC<TBool> pckgEnable(enableIdn);
TInt setOptErr = hr.SetOpt(KSoDnsEnableIdn , KSolInetDns , pckgEnable);
User::LeaveIfError(setOptErr);
TInetAddr inetAddr;
//inetAddr.Input(_L("83.241.177.38")); // this is the IPAddress of the domain räksmörgås.josefsson.org
// as of 06 Feb 2009. If this IP changes, this test case might fail
// but no harm on this.
//TNameEntry resultEntry;
inetAddr.Input(_L("64.233.169.103"));
TNameRecord asdf;
TPckgBuf<TNameRecord> resultEntry(asdf);
hr.GetByAddress(inetAddr,resultEntry,myStatus);
User::WaitForRequest(myStatus);
TInt err = myStatus.Int();
if(err == KErrNone)
{
INFO_PRINTF2(_L(" GetByAddress with IDN disabled returned %d"),err);
SetTestStepResult(EPass);
}
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
enum TVerdict CTestIdna02::doTestStepL()
{
INFO_PRINTF1(_L(" Testing GetByName(IDN) with IDN Enabled "));
INFO_PRINTF1(_L("****************************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
_LIT(KTestName1,"räksmörgås.josefsson.org");
TName myHostName = KTestName1();
TNameEntry myResolvedName;
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
TBool enableIdn = ETrue;//enabling the option of IDN support
TPckgC<TBool> pckgEnable(enableIdn);
TInt setOptErr = hr.SetOpt(KSoDnsEnableIdn , KSolInetDns , pckgEnable);
User::LeaveIfError(setOptErr);
hr.GetByName(myHostName,myResolvedName,myStatus);
User::WaitForRequest(myStatus);
TInt err = myStatus.Int();
if(err == KErrNone)
{
INFO_PRINTF2(_L(" GetByName(%S) with IDN Enabled returned KErrNone "),&myHostName);
SetTestStepResult(EPass);
}
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
void CTe_rtpSuite::ConfigureReflectorModeL(TBool aMode, TInetAddr& aAddr)
{
/* Configures the reflector to change the SSRC or not
*/
RSocketServ sockServer;
//Open a connection
RConnection conn;
User::LeaveIfError(sockServer.Connect());
CleanupClosePushL(sockServer);
User::LeaveIfError(conn.Open(sockServer));
CleanupClosePushL(conn);
//Start the connection
User::LeaveIfError(conn.Start());
RSocket ctrlSock;
User::LeaveIfError(ctrlSock.Open(sockServer,KAfInet, KSockDatagram, KProtocolInetUdp, conn));
CleanupClosePushL(ctrlSock);
TBuf8<64> lCmdBuff;
TUint8* lPtr = const_cast<TUint8*>(lCmdBuff.Ptr());
TUint32* lIntData = (TUint32*)lPtr;
*lIntData = ByteOrder::Swap32(0xFF00BABE);
if (aMode)
{
*(lIntData + 1) = ByteOrder::Swap32(0xCD000100);
}
else
{
*(lIntData + 1) = ByteOrder::Swap32(0xCD000101);
}
lCmdBuff.SetLength(64);
TRequestStatus lMyReqStat;
ctrlSock.SendTo(lCmdBuff,aAddr,0,lMyReqStat);
User::WaitForRequest(lMyReqStat);
ctrlSock.Close();
conn.Close();
sockServer.Close();
CleanupStack::Pop(3);
}
enum TVerdict CTestIdna05::doTestStepL()
{
INFO_PRINTF1(_L(" Testing GetByName(IDN in UTF-16) without IDN Enabled "));
INFO_PRINTF1(_L("***********************************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
THostName utf16HostName;
TInt surrogateInt = 55301 ; //0xD805
utf16HostName.Copy((const unsigned short*)&surrogateInt);
surrogateInt = 57173; // 0xDF55
utf16HostName.Append((const unsigned short*)&surrogateInt, sizeof(TInt));
TNameEntry myResolvedName;
hr.GetByName(utf16HostName,myResolvedName,myStatus);
User::WaitForRequest(myStatus);
TInt err = myStatus.Int();
if(err == KErrDndBadName)
{
INFO_PRINTF1(_L(" GetByName (IDN in UTF16) without IDN enabled returned KErrDndBadName"));
SetTestStepResult(EPass);
}
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
enum TVerdict CTestIdna03::doTestStepL()
{
INFO_PRINTF1(_L(" Testing GetByAddress(for an IDN) without IDN Enabled "));
INFO_PRINTF1(_L("*********************************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
TInetAddr inetAddr;
inetAddr.Input(_L("83.241.177.38")); // this is the IPAddress of the domain räksmörgås.josefsson.org
// as of 06 Feb 2009. If this IP changes, this test case might fail
// but no harm on this.
TNameEntry resultEntry;
hr.GetByAddress(inetAddr,resultEntry,myStatus);
User::WaitForRequest(myStatus);
TInt err = myStatus.Int();
if(err == KErrNone)
{
INFO_PRINTF2(_L(" GetByAddress with IDN disabled returned %d"),err);
SetTestStepResult(EPass);
}
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
enum TVerdict CTestIdna01::doTestStepL()
{
INFO_PRINTF1(_L(" Testing GetByName(IDN) without IDN Enabled "));
INFO_PRINTF1(_L("****************************************************"));
SetTestStepResult(EFail); // By default start the test case with failure.
RSocketServ pSocketServ;
User::LeaveIfError(pSocketServ.Connect());
RConnection myConnection;
myConnection.Open(pSocketServ, KAfInet);
TRequestStatus myStatus=KErrNone;
myConnection.Start(myStatus);
User::WaitForRequest(myStatus);
_LIT(KTestName1,"räksmörgås.josefsson.org");
TName myHostName = KTestName1();
TNameEntry myResolvedName;
RHostResolver hr;
hr.Open(pSocketServ,KAfInet,KProtocolInetUdp);
hr.GetByName(myHostName,myResolvedName,myStatus);
User::WaitForRequest(myStatus);
TInt err = myStatus.Int();
if(err == KErrDndNameNotFound)
{
INFO_PRINTF2(_L(" GetByName(%S) without IDN Enabled returned KErrDndNameNotFound "),&myHostName);
SetTestStepResult(EPass);
}
hr.Close();
myConnection.Close();
pSocketServ.Close();
return TestStepResult();
}
// ---------------------------------------------------------
// RHssInterface::StopConnectionL
// ---------------------------------------------------------
//
TInt RHssInterface::StopConnectionL( const TUint aIapId, const TUint aNetworkId )
{
DEBUG( "RHssInterface::StopConnectionL()" );
TInt ret( KErrNone );
RSocketServ socketServ;
RConnection conn;
User::LeaveIfError( socketServ.Connect() );
CleanupClosePushL( socketServ );
// Open connection
User::LeaveIfError( conn.Open(socketServ) );
CleanupClosePushL( conn );
TConnectionInfo info;
info.iIapId = aIapId;
info.iNetId = aNetworkId;
TInt err = conn.Attach(
TPckg< TConnectionInfo >( info ),
RConnection::EAttachTypeNormal );
DEBUG1( "RHssInterface::conn.Attach: %d", err );
if ( err == KErrNone )
{
ret = conn.Stop( RConnection::EStopAuthoritative );
DEBUG1( "RHssInterface::connection.Stop: %d", ret );
}
/* Note: In previous version, tried to PopAndDestroy conn (RConnection)
* from cleanup stack...
* => Somehow this broke Sniffer connection opening, no idea why.
*/
CleanupStack::Pop( &conn );
conn.Close();
CleanupStack::PopAndDestroy( &socketServ );
return ret;
}
int ILibSocketWrapper_close(int socketObject)
{
// lookup the socket handle and close and delete if exists
RSocket *s = (RSocket*)SocketArray[socketObject];
if ( s != NULL )
{
s->Close();
delete s;
SocketArray[socketObject] = 0;
}
// lookup the connection handle and close and delete if exists
RConnection *c = ConnectionArray[socketObject];
if ( c != NULL )
{
c->Close();
delete c;
ConnectionArray[socketObject] = NULL;
}
return(0);
}
// ---------------------------------------------------------------------------
// CRoHandlerDMgrWrapper::PostResponseUrlL
// ---------------------------------------------------------------------------
//
void CRoHandlerDMgrWrapper::PostResponseUrlL( const TDesC8& aPostResponseUrl )
{
UpdateBufferL< HBufC8, TDesC8 >( iTriggerUrl, aPostResponseUrl );
if ( !iIapId )
{
// Take AP from open conenction
RSocketServ socketServer;
TInt err( KErrNone );
err = socketServer.Connect();
RConnection myConnection;
err = myConnection.Open( socketServer );
TUint connectionCount( 0 );
err = myConnection.EnumerateConnections( connectionCount );
if ( err != KErrNone || connectionCount < 1 )
{
return;
}
TPckgBuf<TConnectionInfoV2> connectionInfo;
err = myConnection.GetConnectionInfo( connectionCount,
connectionInfo );
iIapId = connectionInfo().iIapId;
myConnection.Close();
socketServer.Close();
}
}
