TBool CSmsReplyToStep::WatchersAlreadyRunningL()
{
RSocketServ server;
RSocket socket;
User::LeaveIfError(server.Connect());
CleanupClosePushL(server);
// test if it's there...
TProtocolDesc protoInfo;
TProtocolName protocolname;
protocolname.Copy(KSmsDatagram);
User::LeaveIfError(server.FindProtocol(protocolname,protoInfo));
User::LeaveIfError(socket.Open(server,
protoInfo.iAddrFamily,
protoInfo.iSockType,
protoInfo.iProtocol));
CleanupClosePushL(socket);
TSmsAddr addr;
addr.SetSmsAddrFamily(ESmsAddrRecvAny);
TInt err = socket.Bind(addr);
CleanupStack::Pop(2, &server);
socket.CancelAll();
socket.Close();
server.Close();
return (err == KErrAlreadyExists);
}
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();
}
/**
Get the internet name of this host. Actually this will always return a null
string with TCPIP 030 and onwards because the "name" of a mobile host
isn't really very meaningful - in practice the IP address is chosen dynamically
once you start doing real networking, at which time the ISP can resolve the
IP address into a name of some sort if you really want.
@return
@param name
@param size
*/
EXPORT_C int gethostname (char *name, size_t size)
{
int* perrno=__errno();
RSocketServ ss;
TInt err=ss.Connect(1);
if (err==KErrNone)
{
RHostResolver r;
err=r.Open(ss, AF_INET, KProtocolInetUdp);
if (err==KErrNone)
{
TBuf<128> hostname;
err=r.GetHostName(hostname);
if (err==KErrNone)
{
if (size>(size_t)hostname.Length())
{
TPtr8 retval((TText8*)name,size);
retval.Copy(hostname);
retval.PtrZ();
}
else
err=ENAMETOOLONG;
}
r.Close();
}
ss.Close();
}
return MapError(err,*perrno);
}
void CGetPortCommand::DoExecuteL()
{
TInt errorCode = KErrNone;
RSocketServ socketServer;
errorCode = socketServer.Connect();
if(errorCode == KErrNone)
{
RSocket listeningSocket;
TSockAddr localAddress;
//TODO: add retrying to find ports
for(int i = 0; errorCode == KErrNone && i < iFreePortsNum; i++)
{
TInt port = iDriver->NextRandomPort();
listeningSocket.Open(socketServer, KAfInet, KSockStream, KProtocolInetTcp);
localAddress.SetPort(port);
errorCode = listeningSocket.Bind(localAddress);
if(errorCode == KErrNone)
{
iFreePorts.Append(port);
}
listeningSocket.Close();
}
}
socketServer.Close();
User::LeaveIfError(errorCode);
}
// from PDIS miso library
// Gets the local device name.
// Arguments:
// - aName - object to hold the retrieved name.
//
// Returns an error code.
static TInt GetLocalName(TDes& aName)
{
TInt err = KErrNone;
RSocketServ socketServ;
err = socketServ.Connect();
if (!err) {
TProtocolName protocolName;
// address and name queries are apparently supplied
// by the BT stack's link manager
_LIT(KBtLinkManager, "BTLinkManager");
protocolName.Copy(KBtLinkManager);
TProtocolDesc protocolDesc;
err = socketServ.FindProtocol(protocolName, protocolDesc);
if (!err) {
RHostResolver hostResolver;
err = hostResolver.Open(socketServ,
protocolDesc.iAddrFamily,
protocolDesc.iProtocol);
if (!err) {
err = hostResolver.GetHostName(aName);
hostResolver.Close();
}
}
socketServ.Close();
}
return err;
}
static int connect_test()
{
RSocketServ rSockServ;
RSocket rSock;
TInetAddr inetAddr;
TRequestStatus reqStatus;
char buffer[16];
TPtrC8 data((const TUint8*)buffer, (TInt)sizeof(buffer));
int rc;
rc = rSockServ.Connect();
if (rc != KErrNone)
return rc;
rc = rSock.Open(rSockServ, KAfInet, KSockDatagram, KProtocolInetUdp);
if (rc != KErrNone)
{
rSockServ.Close();
return rc;
}
inetAddr.Init(KAfInet);
inetAddr.Input(_L("127.0.0.1"));
inetAddr.SetPort(80);
rSock.Connect(inetAddr, reqStatus);
User::WaitForRequest(reqStatus);
if (reqStatus != KErrNone) {
rSock.Close();
rSockServ.Close();
return rc;
}
rSock.Send(data, 0, reqStatus);
User::WaitForRequest(reqStatus);
if (reqStatus!=KErrNone) {
rSock.Close();
rSockServ.Close();
return rc;
}
rSock.Close();
rSockServ.Close();
return KErrNone;
}
enum TVerdict CSocketTest8_2::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Ioctl observes InternalOptionBit"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// get a protocol
Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));
TProtocolDesc protoInfo;
ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// check internal options bit
RSocket socket;
Logger().WriteFormat(_L("Opening a new socket"));
ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying Ioctl on internal options bit"));
TRequestStatus stat;
socket.Ioctl(KInternalIoctlBit, stat);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrAccessDenied == stat.Int());
Logger().WriteFormat(_L("Trying to SetOpt internal options bit"));
ret = socket.SetOpt(KSocketInternalOptionBit, KSOLSocket);
Logger().WriteFormat(_L("SetOpt returned %S"), &EpocErrorToText(ret));
TESTL(KErrAccessDenied == ret);
Logger().WriteFormat(_L("Trying to GetOpt internal options bit"));
TPckgBuf<TBool> boolean;
ret = socket.GetOpt(KSocketInternalOptionBit, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOpt returned %S"), &EpocErrorToText(ret));
TESTL(KErrAccessDenied == ret);
Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));
socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrNone == stat.Int());
CleanupStack::Pop(&ss);
ss.Close();
SetTestStepResult(verdict);
return verdict;
}
// Looks up the name of the device with the given address.
// Arguments:
// - wantedAddr - address of the device to look up. Note that the address
// is expected without colons!! e.g. "000D9319C868"
// - aDeviceName - the object to hold the name once it is found
// - ignoreCache - if True, performs a remote name request even if the device
// name is known in the cache from a previous request.
//
// Returns an error code.
static TInt LookupName(TBTDevAddr& wantedAddr, THostName* aDeviceName,
bool ignoreCache)
{
TInt err = KErrNone;
RSocketServ socketServer;
RHostResolver hostResolver;
TRequestStatus status;
TNameEntry nameEntry;
// make a TInquirySockAddr with the address of the device we want to look up
TBTSockAddr sockAddr;
sockAddr.SetBTAddr(wantedAddr);
TInquirySockAddr addr = addr.Cast(sockAddr);
// connect
err = socketServer.Connect();
if (err)
return err;
// load protocol for discovery
TProtocolDesc protocolDesc;
err = socketServer.FindProtocol(_L("BTLinkManager"), protocolDesc);
if (!err) {
// initialize host resolver
err = hostResolver.Open(socketServer, protocolDesc.iAddrFamily, protocolDesc.iProtocol);
if (!err) {
// Request name lookup.
// We don't need to call SetIAC() if we're just doing name lookup.
// Don't put KHostResInquiry flag in SetAction(), because that
// will start a device inquiry, when we just want to find the one
// name.
if (ignoreCache) {
addr.SetAction(KHostResName|KHostResIgnoreCache);
} else {
addr.SetAction(KHostResName);
}
hostResolver.GetByAddress(addr, nameEntry, status);
User::WaitForRequest(status);
if (status == KErrNone) {
*aDeviceName = nameEntry().iName;
err = KErrNone;
} else {
err = KErrGeneral;
}
hostResolver.Close();
}
}
socketServer.Close();
return err;
}
/**
* Get the local IP address of the device
*
* @note Requires at least one IP packet sent in advance!
*/
int net_if_getaddr4(const char *ifname, int af, struct sa *ip)
{
(void)ifname;
if (AF_INET != af)
return EAFNOSUPPORT;
/* Already cached? */
if (sa_isset(&local_ip, SA_ADDR)) {
sa_cpy(ip, &local_ip);
return 0;
}
RSocketServ ss;
RSocket s;
TInt ret;
ret = ss.Connect();
if (KErrNone != ret) {
DEBUG_WARNING("connecting to socket server fail (ret=%d)\n",
ret);
return ECONNREFUSED;
}
ret = s.Open(ss, KAfInet, KSockDatagram, KProtocolInetUdp);
if (KErrNone != ret) {
DEBUG_WARNING("open socket failed (ret=%d)\n", ret);
return ECONNREFUSED;
}
TInetAddr bind;
bind.SetPort(0);
bind.SetAddress(KInetAddrAny);
ret = s.Bind(bind);
if (KErrNone != ret) {
DEBUG_WARNING("bind socket failed (ret=%d)\n", ret);
return ECONNREFUSED;
}
TInetAddr local;
s.LocalName(local);
s.Close();
ss.Close();
sa_set_in(&local_ip, local.Address(), local.Port());
DEBUG_NOTICE("local IP addr: %j\n", &local_ip);
if (!sa_isset(&local_ip, SA_ADDR))
return EINVAL;
sa_cpy(ip, &local_ip);
return 0;
}
enum TVerdict CSocketTest8_3::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Ioctl auto bind and check started"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// get a protocol
Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));
TProtocolDesc protoInfo;
ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Opening a new socket"));
RSocket socket;
ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));
TRequestStatus stat;
socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrNone == stat.Int());
Logger().WriteFormat(_L("Testing AutoBind()"));
TSockAddr addr;
Logger().WriteFormat(_L("Trying to Connect socket"));
socket.Connect(addr, stat);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Connect returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrNone == stat.Int());
Logger().WriteFormat(_L("Checking bound status with Ioctl"));
socket.Ioctl(KDummyIoctlCheckBound, stat, NULL, KIoctlDummyLevel);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrNone == stat.Int());
CleanupStack::Pop(&ss);
ss.Close();
SetTestStepResult(verdict);
return verdict;
}
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();
}
void ILibSocketWrapper_Destroy()
{
// make sure all sockets and connections are closed
for (int i = 0; i < SOCKET_ARRAY_SIZE; i++)
{
ILibSocketWrapper_close(i);
}
// release the socket server
socketServer.Close();
}
// Gets the local device class.
// Arguments:
// - aDeviceData - object to hold the retrieved class data.
//
// Returns an error code.
//static TInt GetLocalDeviceClass(TDeviceData& aDeviceData)
static TInt GetLocalDeviceClass(TBTDeviceClass& aDeviceClass)
{
TInt err = KErrNone;
#if defined(__SYMBIAN_9__)
TInt cod;
err = RProperty::Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceClass,
cod);
if (err == KErrNone) {
aDeviceClass = TBTDeviceClass(cod);
}
#elif defined(__SYMBIAN_8__)
TInt cod;
err = RProperty::Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothDeviceClass,
cod);
if (err == KErrNone) {
aDeviceClass = TBTDeviceClass(cod);
}
#else
RSocketServ socketServ;
RSocket sock;
err = socketServ.Connect();
if (!err) {
err = sock.Open(socketServ, KBTAddrFamily, KSockSeqPacket, KL2CAP);
if (!err) {
THCIDeviceClassBuf codBuf;
TRequestStatus status;
sock.Ioctl(KHCIReadDeviceClassIoctl, status, &codBuf, KSolBtHCI);
User::WaitForRequest(status);
if (status.Int() == KErrNone) {
aDeviceClass = TBTDeviceClass(codBuf().iMajorServiceClass,
codBuf().iMajorDeviceClass,
codBuf().iMinorDeviceClass);
}
sock.Close();
}
socketServ.Close();
}
#endif
return err;
}
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);
}
// from PDIS miso library
// Gets the local device address.
// Arguments:
// - aAddress - object to hold the retrieved address.
//
// Returns an error code.
static TInt GetLocalAddress(TBTDevAddr& aAddress)
{
TInt err = KErrNone;
#if defined(__SYMBIAN_9__)
TPtr8 ptr(aAddress.Des());
err = RProperty::Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetLocalDeviceAddress,
ptr);
#elif defined(__SYMBIAN_8__)
TPtr8 ptr(aAddress.Des());
err = RProperty::Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothLocalDeviceAddress,
ptr);
#else
RSocketServ socketServ;
err = socketServ.Connect();
if (err)
return err;
// this solution comes from the "bthci" Series 60 example;
// does not work on Symbian 8-up
RSocket socket;
err = socket.Open(socketServ, KBTAddrFamily, KSockSeqPacket, KL2CAP);
if (!err) {
TPckgBuf<TBTDevAddr> btDevAddrPckg;
TRequestStatus status;
socket.Ioctl(KHCILocalAddressIoctl, status, &btDevAddrPckg, KSolBtHCI);
User::WaitForRequest(status);
err = status.Int();
if (!err) {
TPtrC8 src(btDevAddrPckg().Des());
TPtr8 dest(aAddress.Des());
dest.Copy(src);
}
socket.Close();
}
socketServ.Close();
#endif
return err;
}
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();
}
enum TVerdict CSocketTest8_7::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: getOpt with small client buffer"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// try SetLocalPort
Logger().WriteFormat(_L("Opening a socket"));
RSocket socket;
ret = socket.Open(ss, _L("Dummy Protocol 1"));
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// try with small buffer - 8 bit descriptor
Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
TBuf8<1> smallBuf8;
ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, smallBuf8);
Logger().WriteFormat(_L("GetOption returned %S"),&EpocErrorToText(ret));
TESTL(KErrOverflow == ret);
// try with correct size descriptor
Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
TPckgBuf<TBool> boolean;
ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOption returned %S, value %d"),
&EpocErrorToText(ret), boolean());
TESTL(KErrNone == ret);
TESTL(TRUE == boolean());
CleanupStack::Pop(&ss);
ss.Close();
return verdict;
}
enum TVerdict CSocketTest8_1::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Ioctl returns not started on null socket"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
//PG 14/02/2001
//Added test for defect: TOD-4QLDXY - Ioctl on incorrectly opened socket crashes socket server.
Logger().WriteFormat(_L("Opening a socket with no protocol"));
RSocket socketNoProtoDefined;
ret = socketNoProtoDefined.Open(ss);
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// see if it's started
Logger().WriteFormat(_L("Check Ioctl fails"));
TRequestStatus stat;
socketNoProtoDefined.Ioctl(KDummyIoctlCheckStarted, stat);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrNotSupported == stat.Int());
socketNoProtoDefined.Close();
CleanupStack::Pop(&ss);
ss.Close();
SetTestStepResult(verdict);
return verdict;
}
// ---------------------------------------------------------------------------
// 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();
}
}
enum TVerdict CSocketTest3_1::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Basic Service Resolver"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// find dummy protocol 1
TProtocolDesc protoInfo;
Logger().WriteFormat(_L("Finding dummy protocol 1"));
ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// open a service resolver on it
Logger().WriteFormat(_L("Open Service resolver"));
RServiceResolver sr;
ret = sr.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
CleanupClosePushL(sr);
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// try a GetByName
Logger().WriteFormat(_L("Trying GetByName for DummyName"));
TPortNum port;
ret = sr.GetByName(_L("DummyName"), port);
Logger().WriteFormat(_L("GetByName returned %S, port %d"), &EpocErrorToText(ret), port());
TESTL(KErrNone == ret);
TESTL(64 == port());
Logger().WriteFormat(_L("Trying GetByName for Bogus"));
ret = sr.GetByName(_L("Bogus"), port);
Logger().WriteFormat(_L("GetByName returned %S"), &EpocErrorToText(ret));
TESTL(KErrNotFound == ret);
// now try Cancel GetByNumber
TRequestStatus stat;
TServiceName service;
Logger().WriteFormat(_L("Trying GetByNumber for 66"));
sr.GetByNumber(66, service, stat);
Logger().WriteFormat(_L("Cancelling GetByNumber"));
sr.Cancel();
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Request status is %S"), &EpocErrorToText(stat.Int()));
TESTL(KErrCancel == stat.Int());
Logger().WriteFormat(_L("Trying GetByNumber for 21"));
ret = sr.GetByNumber(21, service);
Logger().WriteFormat(_L("GetByNumber returned %S, service '%S'"),
&EpocErrorToText(ret), &service);
TESTL(KErrNone == ret);
TESTL(_L("DummyService") == service);
Logger().WriteFormat(_L("Trying GetByNumber for 22"));
ret = sr.GetByNumber(22, service);
Logger().WriteFormat(_L("GetByNumber returned %S"), &EpocErrorToText(ret));
TESTL(KErrNotFound == ret);
// register and remove service
Logger().WriteFormat(_L("Trying RegisterService for Simpson"));
ret = sr.RegisterService(_L("Simpson"),500);
Logger().WriteFormat(_L("RegisterService returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying RegisterService for Bart"));
ret = sr.RegisterService(_L("Bart"), 10);
Logger().WriteFormat(_L("RegisterService returned %S"), &EpocErrorToText(ret));
TESTL(KErrNotFound == ret);
Logger().WriteFormat(_L("Trying to RemoveService Colt"));
ret = sr.RemoveService(_L("Colt"),45);
Logger().WriteFormat(_L("RemoveService returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying to RemoveService Usi"));
ret = sr.RemoveService(_L("Usi"), 9);
Logger().WriteFormat(_L("RemoveService returned %S"), &EpocErrorToText(ret));
TESTL(KErrNotFound == ret);
Logger().WriteFormat(_L("Close service resolver"));
CleanupStack::Pop(&sr);
sr.Close();
CleanupStack::Pop(&ss);
ss.Close();
SetTestStepResult(verdict);
return verdict;
}
void CTestStepBtRomConfigUser002::
TestBluetoothSocketConstructorL(TInt aTestSubCase, TInt& aExpectedError)
{
// must set the expected error BEFORE the test calls a leaving function
CBluetoothSocket* btsocket(0);
switch(aTestSubCase)
{
case 0:
{
// Even if BT is missing from the ROM, this test will succeed.
// This is because we are only passing a hint to the socket server,
// not actually instantiating a Bluetooth connection
aExpectedError = KErrNone;
RSocketServ socketServ;
TSessionPref pref;
// ToDo Check that these are correct
pref.iAddrFamily = KSockStream;
pref.iProtocol = KRFCOMM;
User::LeaveIfError(socketServ.Connect(pref));
if (socketServ.Handle())
{
socketServ.Close();
}
}
break;
case 1:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KSockStream, KRFCOMM);
delete btsocket;
break;
case 2:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KSockSeqPacket, KL2CAP);
delete btsocket;
break;
case 3:
aExpectedError = iBtExcluded ? KErrBadName : KErrNotSupported;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KSockStream, KSDP);
delete btsocket;
break;
case 4:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KUndefinedSockType, KBTLinkManager);
delete btsocket;
break;
case 5:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KSockDatagram, KAVCTP);
delete btsocket;
break;
case 6:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KSockDatagram, KAVDTP);
delete btsocket;
break;
case 7:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KSockStream, KRFCOMM);
CleanupStack::PopAndDestroy(btsocket);
break;
case 8:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KSockSeqPacket, KL2CAP);
CleanupStack::PopAndDestroy(btsocket);
break;
case 9:
aExpectedError = iBtExcluded ? KErrBadName : KErrNotSupported;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KSockStream, KSDP);
CleanupStack::PopAndDestroy(btsocket);
break;
case 10:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KUndefinedSockType, KBTLinkManager);
CleanupStack::PopAndDestroy(btsocket);
break;
case 11:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KSockDatagram, KAVCTP);
CleanupStack::PopAndDestroy(btsocket);
break;
case 12:
aExpectedError = iBtExcluded ? KErrBadName : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KSockDatagram, KAVDTP);
CleanupStack::PopAndDestroy(btsocket);
break;
case 13: // use the protocol descriptor from bt_sock
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ, KRFCOMMDesC);
delete btsocket;
break;
case 14: // use the protocol descriptor from bt_sock
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ, KL2CAPDesC);
delete btsocket;
break;
case 15:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNotSupported;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ, KProtocolSdp);
delete btsocket;
break;
case 16:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KProtocolBtLinkManager);
delete btsocket;
break;
case 17:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewL(*this, iSocketServ,
KAVDTPProtocolName);
delete btsocket;
break;
case 18: // use the protocol descriptor from bt_sock
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ, KRFCOMMDesC);
CleanupStack::PopAndDestroy(btsocket);
break;
case 19: // use the protocol descriptor from bt_sock
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ, KL2CAPDesC);
CleanupStack::PopAndDestroy(btsocket);
break;
case 20:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNotSupported;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ, KProtocolSdp);
CleanupStack::PopAndDestroy(btsocket);
break;
case 21:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KProtocolBtLinkManager);
CleanupStack::PopAndDestroy(btsocket);
break;
case 22:
aExpectedError = iBtExcluded ? KErrNotFound : KErrNone;
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ,
KAVDTPProtocolName);
CleanupStack::PopAndDestroy(btsocket);
break;
case 23:
aExpectedError = KErrNone; // even with no BT, this will succeed
btsocket = CBluetoothSocket::NewL(*this, iSocketServ);
// Even though we can create a blank (CBluetooth)Socket, this isn't
// of any use without an instantiated Bluetooth socket, so it doesn't
// make sense to do any further API calls with this
delete btsocket;
break;
case 24:
aExpectedError = KErrNone; // even with no BT, this will succeed
btsocket = CBluetoothSocket::NewLC(*this, iSocketServ);
// Even though we can create a blank (CBluetooth)Socket, this isn't
// of any use without an instantiated Bluetooth socket, so it doesn't
// make sense to do any further API calls with this
CleanupStack::PopAndDestroy(btsocket);
break;
/*
CBluetoothSocket* NewL and NewLC taking an RConnection does not
have to be tested, the RConnection cannot be started over
Bluetooth BT_ROMCONFIG_PAN_001 confirms that this is not possible
without BT on ROM
*/
/* CBluetoothSocket* NewL and NewLC taking parameters
(MBluetoothSocketNotifier &aNotifier, RSocketServ &aServer,
RSocket &aSocket); does not have to be tested, as the API states:
"This should be used where an existing API returned a RSocket
representing a Bluetooth connection." BT_ROMCONFIG_RSOCKET_001
confirms that this is not possible without BT on ROM
*/
default:
User::Panic(KInvalidTestPanicString, aTestSubCase);
break;
}
}
enum TVerdict CSocketTest7_1::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Alloc Heaven during socket open"));
#if defined (_DEBUG_SOCKET_FUNCTIONS)
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// get a protocol
Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));
TProtocolDesc protoInfo;
ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// Stretch socket arrays in the server.
RSocket *sockets = new (ELeave) RSocket[KNumStretchOpens];
CleanupArrayDeletePushL(sockets);
TInt i;
Logger().WriteFormat(_L("Attempting to Open %d sockets"), KNumStretchOpens);
for (i=0; i<KNumStretchOpens; i++)
{
ret = sockets[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
if (KErrNone != ret)
{
Logger().WriteFormat(_L("Open returned %S for socket %d"), &EpocErrorToText(ret), i);
TESTL(EFalse);
}
}
Logger().WriteFormat(_L("Closing the first %d sockets"), KNumStretchOpens-1);
for (i=0; i<KNumStretchOpens-1; i++)
{
sockets[i].Close();
}
RSocket sock;
TInt failure = 0;
ret = -1;
Logger().WriteFormat(_L("Starting OOM Socket Open Loop"));
// ss.__DbgMarkHeap(); // in ESOCKMT leak checking is best done by shutting down the server
while (ret != KErrNone)
{
Logger().WriteFormat(_L("Failing after %d allocs"), failure);
ss.__DbgFailNext(failure);
ret = sock.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
// if (ret != KErrNone)
// {
// ss.__DbgCheckHeap(0);
// }
failure++;
}
Logger().WriteFormat(_L("Created socket OK"));
sockets[KNumStretchOpens-1].Close();
CleanupStack::PopAndDestroy(sockets);
sock.Close();
// ss.__DbgMarkEnd(0);
// Flush any FailNext there might be hanging around.
ss.__DbgFailNext(-1);
CleanupStack::Pop(&ss);
ss.Close();
#else
Logger().WriteFormat(_L("TestDisabled on release build."));
verdict = EInconclusive;
#endif
SetTestStepResult(verdict);
return verdict;
}
enum TVerdict CEsockTest29_10::easyTestStepL( void )
{
SetTestStepResult(EFail);
TInt ret;
const TUint KOneSecond = 1000000;
Logger().WriteFormat(_L("Send/ Recv on PDummy3 socket but no avail MBuf Memory, mBuf becomes avail after send"));
RSocketServ ss;
ret = ss.Connect();
TESTL(KErrNone == ret);
// open dummy prot 3
Logger().WriteFormat(_L("Openning Dummy Protocol 3"));
RSocket sock;
ret = sock.Open(ss,_L("Dummy Protocol 3"));
TESTL(KErrNone == ret);
// connect socket
TSockAddr addr;
TRequestStatus connStat;
sock.Connect(addr, connStat);
User::WaitForRequest(connStat);
TESTL(KErrNone == connStat.Int());
// send packet 1
TRequestStatus stat;
Logger().WriteFormat(_L("Attempting to create a packet to receive later"));
_LIT8(sendDataOne, "First Send");
sock.Send(sendDataOne,0,stat);
User::WaitForRequest(stat);
TESTL(KErrNone == stat.Int());
// wait for packets to go through esock
User::After(KOneSecond * 2);
// gobble mBufs
TInt nFree = 0;
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol"));
while (nFree > 0)
{
ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
}
Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret);
// we are running in high priority and allocating in a loop.
// so kernel may not be able to enlarge the pools.
// wait for kernel to enlarge the pool
// We have to come out from the loop as well.
User::After(KOneSecond * 2);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol"));
while (nFree > 0)
{
ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
}
Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret);
// Once again
User::After(KOneSecond * 2);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol"));
while (nFree > 0)
{
ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
}
Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetGobbleMBufs returned %d"), ret);
// Once again
User::After(KOneSecond * 2);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol"));
while (nFree > 0)
{
ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
}
// Once again
User::After(KOneSecond * 2);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetGobbleMBufs Option in Protocol"));
while (nFree > 0)
{
ret = sock.SetOpt(KDummyOptionSetGobbleMBufs, 0, 0);
sock.GetOpt(KDummyOptionGetMBufFreeSpace, 0, nFree);
}
// send packet 2
User::After(KOneSecond);
TRequestStatus stat2;
_LIT8(sendDataTwo, "Second Send");
Logger().WriteFormat(_L("Sending Data - Should never complete"));
sock.Send(sendDataTwo,0,stat2);
User::After(KOneSecond);
Logger().WriteFormat(_L("Now cancel the Send"));
sock.CancelSend();
User::WaitForRequest(stat2);
TESTL(stat2 == KErrCancel);
Logger().WriteFormat(_L("Receiving Data -- expected to pick up sendDataOne"));
TBuf8<100> buf;
TRequestStatus stat3;
sock.Recv(buf, 0, stat3);
User::After(KOneSecond);
User::WaitForRequest(stat3);
TESTL(buf.Compare(sendDataOne) == 0);
// send packet 3
_LIT8(sendDataThree, "Third Send");
Logger().WriteFormat(_L("Sending Data ... again"));
TRequestStatus stat4;
sock.Send(sendDataThree,0,stat4);
User::After(1000);
// free memory
Logger().WriteFormat(_L("Now free memory - should get send and receive completion"));
Logger().WriteFormat(_L("Attempting to set KDummyOptionSetFreeMBufs Option in Protocol"));
ret = sock.SetOpt(KDummyOptionSetFreeMBufs, 0, 0);
Logger().WriteFormat(_L("Socket::SetOpt KDummyOptionSetFreeMBufs returned %d"), ret);
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Sending Data - Should now complete"));
User::WaitForRequest(stat4);
TESTL(stat4.Int() == KErrNone);
// recieve data and compare contents to sent data
Logger().WriteFormat(_L("Receiving Data"));
sock.Recv(buf, 0, stat);
User::WaitForRequest(stat);
Logger().WriteFormat(_L("Recv has returned %d"), stat.Int());
TBuf<100> buf16;
buf16.Copy(buf);
if(buf.Compare(sendDataThree) == 0)
{
SetTestStepResult(EPass);
}
Logger().WriteFormat(_L("Data Recv'ed is '%S'"), &buf16);
sock.Close();
ss.Close();
return TestStepResult();
}
enum TVerdict CSocketTest8_8::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: KSOSelectLastError option update"));
RSocketServ ss;
TInt ret=OptimalConnect(ss);
CleanupClosePushL(ss);
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Open by name"));
RSocket sock, sock2;
ret=sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable
TESTL(KErrNone == ret);
// get last error - check that option value is updated
TInt val;
ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// return value should match the updated value
TESTL (val == ret);
ret=sock2.Open(ss); // null socket to accept onto
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Set test option"));
const TInt KExpectedError = -4567; // Something random.
ret=sock.SetOpt(KDummyOptionSetErrorNextListen,0,KExpectedError);
TESTL(KErrNone == ret);
TSockAddr addr;
ret=sock.Bind(addr);
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Listen"));
ret=sock.Listen(0); // No need for a que
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Accept - error"));
TRequestStatus rstat;
sock.Accept(sock2, rstat);
User::WaitForRequest(rstat);
TESTL(rstat.Int() == KExpectedError);
// get last error
ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));
TESTL(KExpectedError == ret);
// return value should match the updated value
TESTL(val == ret);
// Clears last error
ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// return value should match the updated value
TESTL(val == ret);
CleanupStack::Pop(&ss);
ss.Close();
SetTestStepResult(verdict);
return verdict;
}
enum TVerdict CSocketTest8_4::InternalDoTestStepL( void )
{
TVerdict verdict = EPass;
Logger().WriteFormat(_L("Test Purpose: Ioctl Get and Set Options"));
// connect to esock
Logger().WriteFormat(_L("Attempting to connect to socket server"));
RSocketServ ss;
TInt ret = OptimalConnect(ss);
CleanupClosePushL(ss);
Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
// try SetLocalPort
Logger().WriteFormat(_L("Opening a socket"));
RSocket socket;
ret = socket.Open(ss, _L("Dummy Protocol 1"));
Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying SetLocalPort to 666"));
ret = socket.SetLocalPort(666);
Logger().WriteFormat(_L("SetLocalPort returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Port now set to %d"), socket.LocalPort());
TESTL(666 == socket.LocalPort());
// try blocking Get/Set
Logger().WriteFormat(_L("Testing blocking mode Get and Set options"));
Logger().WriteFormat(_L("Trying to SetOption KSONonBlockingIO"));
ret = socket.SetOpt(KSONonBlockingIO, KSOLSocket);
Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));
TPckgBuf<TBool> boolean;
ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOption returned %S, value %d"),
&EpocErrorToText(ret), boolean());
TESTL(KErrNone == ret);
TESTL(TRUE == boolean());
Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOption returned %S, value %d"),
&EpocErrorToText(ret), boolean());
TESTL(KErrNone == ret);
TESTL(FALSE == boolean());
Logger().WriteFormat(_L("Trying to SetOption KSOBlockingIO"));
ret = socket.SetOpt(KSOBlockingIO, KSOLSocket);
Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));
TESTL(KErrNone == ret);
Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));
ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOption returned %S, value %d"),
&EpocErrorToText(ret), boolean());
TESTL(KErrNone == ret);
TESTL(FALSE == boolean());
Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
Logger().WriteFormat(_L("GetOption returned %S, value %d"),
&EpocErrorToText(ret), boolean());
TESTL(KErrNone == ret);
TESTL(TRUE == boolean());
CleanupStack::Pop(&ss);
ss.Close();
return verdict;
}
SilcStream silc_net_udp_connect(const char *local_ip_addr, int local_port,
const char *remote_ip_addr, int remote_port,
SilcSchedule schedule)
{
SilcSymbianSocket *s;
SilcStream stream;
TInetAddr local, remote;
TRequestStatus status;
RSocket *sock = NULL;
RSocketServ *ss = NULL;
TInt ret;
SILC_LOG_DEBUG(("Creating UDP stream"));
if (!schedule) {
schedule = silc_schedule_get_global();
if (!schedule) {
silc_set_errno(SILC_ERR_INVALID_ARGUMENT);
goto err;
}
}
SILC_LOG_DEBUG(("Binding to local address %s",
local_ip_addr ? local_ip_addr : "0.0.0.0"));
sock = new RSocket;
if (!sock)
goto err;
ss = new RSocketServ;
if (!ss)
goto err;
/* Open socket server */
ret = ss->Connect();
if (ret != KErrNone)
goto err;
#ifdef SILC_THREADS
/* Make our socket shareable between threads */
ss->ShareAuto();
#endif /* SILC_THREADS */
/* Get local bind address */
if (!silc_net_set_sockaddr(&local, local_ip_addr, local_port))
goto err;
/* Create the socket */
ret = sock->Open(*ss, KAfInet, KSockDatagram, KProtocolInetUdp);
if (ret != KErrNone) {
SILC_LOG_ERROR(("Cannot create socket"));
goto err;
}
/* Set the socket options */
sock->SetOpt(KSoReuseAddr, KSolInetIp, 1);
/* Bind the listener socket */
ret = sock->Bind(local);
if (ret != KErrNone) {
SILC_LOG_DEBUG(("Cannot bind socket"));
goto err;
}
/* Set to connected state if remote address is provided. */
if (remote_ip_addr && remote_port) {
if (silc_net_set_sockaddr(&remote, remote_ip_addr, remote_port)) {
sock->Connect(remote, status);
if (status != KErrNone) {
SILC_LOG_DEBUG(("Cannot connect UDP stream"));
goto err;
}
}
}
/* Encapsulate into socket stream */
s = silc_create_symbian_socket(sock, ss);
if (!s)
goto err;
stream =
silc_socket_udp_stream_create((SilcSocket)s, local_ip_addr ?
silc_net_is_ip6(local_ip_addr) : FALSE,
remote_ip_addr ? TRUE : FALSE, schedule);
if (!stream)
goto err;
SILC_LOG_DEBUG(("UDP stream created, fd=%d", sock));
return stream;
err:
if (sock)
delete sock;
if (ss) {
ss->Close();
delete ss;
}
return NULL;
}
TVerdict CPPPMinMaxMMU::doTestStepL()
{
const TInt KMaxMMU = 4000;
const TInt KMinMMU = 1;
TBuf8<KMaxMMU> *sendBuf = new(ELeave) TBuf8<KMaxMMU>();
CleanupStack::PushL(sendBuf);
TBuf8<KMaxMMU> *recvBuf = new(ELeave) TBuf8<KMaxMMU>();
CleanupStack::PushL(recvBuf);
TBuf8<KMaxMMU> *recvBuf2 = new(ELeave) TBuf8<KMaxMMU>();
CleanupStack::PushL(recvBuf2);
//initialize COMM
//CommInitL(EFalse);
//Start Comms server
// _LIT(KPhbkSyncCMI, "phbsync.cmi");
// (void)StartC32WithCMISuppressions(KPhbkSyncCMI);
SetTestStepResult(EPass);
INFO_PRINTF1(_L("Starting: Socket Server\n"));
RSocketServ ss;
// Start the socket server
TEST(KErrNone == ss.Connect());
RSocket sock;
TRequestStatus sta;
INFO_PRINTF1(_L("Open a socket\n"));
// Get the test address
TInetAddr RemAddr(7);
TPtrC testAddr;
TEST(GetStringFromConfig(_L("AddressInfo"), _L("TestPPPIPAddr"), testAddr));
if(testAddr.Length())
{
RemAddr.Input(testAddr);
}
else
{
INFO_PRINTF1(_L("Test FAILED\nMissing address information in config file: "));
return EFail;
}
// Open a socket
TEST(KErrNone == sock.Open(ss, KAfInet, KSockStream, KProtocolInetTcp));
INFO_PRINTF1(_L("Connecting Socket to:"));
TBuf<30> printAddr;
RemAddr.Output(printAddr);
INFO_PRINTF1(printAddr);
// Connect a socket
sock.Connect(RemAddr,sta);
// Wait for Connect to complete
User::WaitForRequest(sta);
TEST(sta.Int() == 0);
TInt iterEnd;
GetIntFromConfig(_L("MMUInfo"), _L("TestPPPmaxMMU"), iterEnd);
if (iterEnd > KMaxMMU)
iterEnd = KMaxMMU;
TInt iterStart;
GetIntFromConfig(_L("MMUInfo"), _L("TestPPPminMMU"), iterStart);
if (iterStart < KMinMMU)
iterStart = KMinMMU;
TInt i,j;
TSockXfrLength recvLen;
INFO_PRINTF1(_L("Send/Recv frames"));
for(j=iterStart;j<=iterEnd;j++)
{
sendBuf->Zero();
for (i=0;i<j;i++)
sendBuf->Append(Math::Random() & 0x7f);
INFO_PRINTF2(_L("Sending Packet of Size: %d"),j);
// Send data to echo port
sock.Write(*sendBuf,sta);
User::WaitForRequest(sta);
TEST(sta.Int() == 0);
i=0;
recvBuf->Zero();
while(i<j)
{
// Receive data from echo port
sock.RecvOneOrMore(*recvBuf2,0,sta,recvLen);
User::WaitForRequest(sta);
TEST(sta.Int() == 0);
i += recvBuf2->Length();
recvBuf->Append(*recvBuf2);
}
TEST(KErrNone == recvBuf->Compare(*sendBuf));
INFO_PRINTF1(_L(" Received echoed Packet"));
}
sock.Shutdown(RSocket::EStopOutput,sta);
User::WaitForRequest(sta);
TEST(sta.Int() == 0);
sock.Close();
ss.Close();
CleanupStack::PopAndDestroy(3);
return TestStepResult();
}
