void CTcpClientTestUPnP13::NewData(TUint aCount)
{
RMBufChain data;
RBuf8 resData;
iLogger.WriteFormat(_L("<i>NewData..... </i>"));
iSSP->GetOption(1,KCHMaxLength,resData);
resData.Create( aCount );
iSSP->GetOption(KCHOptionLevel,KCHMaxLength,resData);
TInt len = *(TUint*) resData.Ptr();
resData.Close();
iSSPData->GetData(data,aCount,0);
resData.Create( aCount );
data.CopyOut(resData);
resData.Close();
resData.Create( aCount );
iSSP->GetOption(KCHOptionLevel,KCHLastMessage,resData);
TBool isLastMsg = *(TUint*) resData.Ptr();
resData.Close();
data.Init();
if(isLastMsg)
{
iLogger.WriteFormat(_L("<i>NewData.LastMsg.... </i>"));
CompleteSelf ( KErrNone );
}
}
/*
Tests whether Publishing a Service/Device is performing as specified in UPnP specifications.
@param aOperationType is reference to a section name in ini file where required parameters
needs to be referred for this operation.
@return None.
*/
void CTestRControlChannel::PublishServiceL (const TDesC& aOperationType)
{
_LIT(KInfoLogFile, "CTestRControlChannel::PublishServiceL ().... \n");
INFO_PRINTF1(KInfoLogFile);
CRControlChannelObserver* upnpObserver = CRControlChannelObserver::NewL(this);
CleanupStack::PushL( upnpObserver );
iObserverArray.Append(upnpObserver);
RPnPParameterBundle pnpBundle ;
pnpBundle.Open();
CleanupClosePushL( pnpBundle );
pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
RParameterFamily family = pnpBundle.CreateFamilyL(EUPnPServiceRegisterParamSet);
CUPnPServiceRegisterParamSet* registerServiceParamSet = CUPnPServiceRegisterParamSet::NewL(family );
_LIT(KParentDeviceUid, "ParentDeviceUid");
TPtrC parentDeviceUid;
GetStringFromConfig(aOperationType, KParentDeviceUid, parentDeviceUid);
RBuf8 parentDeviceUidBuf;
parentDeviceUidBuf.Create(parentDeviceUid.Length());
parentDeviceUidBuf.Copy(parentDeviceUid);
registerServiceParamSet->SetDeviceUidL (parentDeviceUidBuf);
TPtrC serviceType;
GetStringFromConfig(aOperationType, KServiceType, serviceType);
RBuf8 serviceTypeBuf;
serviceTypeBuf.Create(serviceType.Length());
serviceTypeBuf.Copy(serviceType);
registerServiceParamSet->SetUriL ( serviceTypeBuf );
TInt duration;
GetIntFromConfig(aOperationType, KCacheControl, duration);
registerServiceParamSet->SetCacheControlData (duration);
ExtractServiceDescriptionL (aOperationType, *registerServiceParamSet);
_LIT8(KInitialMessage, "Initial notification message");
registerServiceParamSet->SetInitialMessageL(KInitialMessage);
OpenPublisherL();
iPublisher.Publish( pnpBundle );
CActiveScheduler::Start();
serviceTypeBuf.Close();
parentDeviceUidBuf.Close();
CleanupStack::PopAndDestroy( &pnpBundle );
CleanupStack::Pop( upnpObserver );
InitiateControlL();
_LIT(KInfoLogFile1, "CTestRControlChannel::PublishServiceL () Stop.... \n");
INFO_PRINTF1(KInfoLogFile1);
}
/*!
Implementation for traverse so always true.
*/
bool SdFixture::execute(void * objectInstance, QString actionName, QHash<QString, QString> parameters, QString & stdOut)
{
debug("SdFixture::execute");
bool returnValue = true;
#ifdef Q_OS_SYMBIAN
const TUid fixtureUid = TUid::Uid(0x20026F7E);
THashFunction32<RBuf8> hashFunc( RBufHashFunction );
TIdentityRelation<RBuf8> idFunc( RBufIdentityFunction );
RHashMap<RBuf8, RBuf8> paramPairs( hashFunc, idFunc );
CleanupClosePushL( paramPairs );
debug("SdFixture::execute read params");
QHashIterator<QString, QString> i(parameters);
while (i.hasNext()) {
i.next();
if(!i.key().isEmpty() && !i.value().isEmpty() && i.key() != OBJECT_TYPE){
debug("parametrit: " + i.key()+";"+ i.value());
debug("SdFixture::execute read key");
RBuf8 keyBuf;
RBuf8 valueBuf;
TPtrC16 keyStr(reinterpret_cast<const TUint16*>(i.key().utf16()));
TPtrC16 valueStr(reinterpret_cast<const TUint16*>(i.value().utf16()));
keyBuf.Create(keyStr.Length());
valueBuf.Create(valueStr.Length());
keyBuf.Copy(keyStr);
valueBuf.Copy(valueStr);
debug("SdFixture::execute insert to hash");
paramPairs.InsertL( keyBuf, valueBuf );
debug("SdFixture::execute pop hbufs");
}
}
debug("SdFixture::execute make fixture");
CTasFixturePluginInterface* fixture = CTasFixturePluginInterface::NewL( fixtureUid );
CleanupStack::PushL( fixture );
debug("SdFixture::execute conver actionname");
TPtrC16 actionStr(reinterpret_cast<const TUint16*>(actionName.utf16()));
RBuf8 actionBuf;
actionBuf.Create(actionStr.Length());
CleanupClosePushL( actionBuf );
actionBuf.Copy(actionStr);
debug("SdFixture::execute execute fixture");
RBuf8 response;
CleanupClosePushL( response );
if(fixture->Execute( NULL, actionBuf, paramPairs, response ) != KErrNone){
returnValue = false;
}
debug("SdFixture::execute convert response");
stdOut = XQConversions::s60Desc8ToQString(response);
CleanupStack::PopAndDestroy( 4 );//response, fixture, paramPairs
#endif
debug("SdFixture::execute done");
return returnValue;
}
int main()
{
__UHEAP_MARK;
RBuf8 myrbuf;
TBufC8<20> myTBufC (_L8(""));
myrbuf.Create(myTBufC);
myrbuf.CleanupClosePushL();
wchar_t * des= new wchar_t [20];
int size=20;
int retval =ESuccess;
retval= Rbuf8ToWchar(myrbuf,des,size);
if(retval == EDescriptorNoData)
{
printf("Test_rbuf8towchar_nodata passed\n");
}
else
{
assert_failed = true;
printf("Test_rbuf8towchar_nodata FAILURE\n");
}
delete[] des;
des = NULL;
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_rbuf8towchar_nodata");
return 0;
}
int main()
{
int retval =ESuccess;
wstring des;
__UHEAP_MARK;
RBuf8 buf;
buf.Create(10);
buf.Copy((TUint8 *)"Hello", 5);
buf.CleanupClosePushL();
//int size =15;
retval = Rbuf8ToWstring(buf, des );
int rbuf_len = buf.Length();
int string_len = des.length();
if (retval ==ESuccess && rbuf_len == string_len && rbuf_len == 5 && string_len == 5)
{
printf("test rbuf8towstring boundary2 Passed\n");
}
else
{
assert_failed = true;
printf("test rbuf8towstring boundary2 Failed\n");
}
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("test_rbuf8towstring_boundary2");
return 0;
}
/** Decode PDU ID 0x40 - fragmentation support
*/
TInt CControlCommand::ParseContinuingResponse(TPtrC8& aMtPayload,
CAVRCPFragmenter& aFragmenter)
{
// Check if in fragmentation state, return error if not
if (! aFragmenter.InFragmentedState())
{
return KErrAvrcpMetadataInvalidCommand;
}
// Check if the parameter matches the fragmented response
TMetadataTransferPDUID pduId = MetadataTransferParser::GetPDUID(aMtPayload);
if (pduId != aFragmenter.GetPDU())
{
return KErrAvrcpMetadataInvalidParameter;
}
RBuf8 respPayload;
CAVCFrame* frame = NULL;
TRAPD(err, frame = CAVCVendorDependentResponse::NewL(KBluetoothSIGVendorId));
err = respPayload.Create(KAVCMaxVendorDependentPayload); //longest resp
if (err == KErrNone)
{
respPayload.Append(aFragmenter.GetNextFragmentHeader());
respPayload.Append(aFragmenter.GetNextFragment());
frame->SetType(AVC::EStable);
frame->Append(respPayload);
delete iFrame;
iFrame = frame;
respPayload.Close();
}
else
return KErrAvrcpMetadataInternalError;
return KErrAvrcpHandledInternallyRespondNow;
}
/**
* @see GetInfoCpm test case NET-CONFIGURATOR-I-0018-HP
*
* doTestStepL virtual function does the below action
* Connect to a configurator
* Configurator get the module inidata section. Inidata section contains
module initialisation information in the module's configuration file.
* close the connection to configuator
* Expected:-GetInfoCpm return kerrNone
*/
TVerdict CGetInfoCpm::doTestStepL()
{
SetTestStepResult(EFail);
_LIT8(KNameDummyCpm,"DummyCpm");
RBuf8 data;
data.Create(100);
TInt actualdatasize;
//Configurator call to get the module inidata section
TInt error = iConfigurator.GetModuleIniData(KNameDummyCpm(), data, actualdatasize);
if (error == KErrOverflow)
{
INFO_PRINTF2(_L("GetModuleIniData returned KErrOverflow (%d) \n"), error);
data.ReAlloc(actualdatasize);
error = iConfigurator.GetModuleIniData(KNameDummyCpm(), data, actualdatasize);
}
else if (error == KErrRSModuleUnknown )
{
INFO_PRINTF2(_L("GetModuleIniData returned KErrRSModuleUnknown (%d) \n"), error);
}
else if (error == KErrNone)
{
INFO_PRINTF1(_L("GetModuleIniData Sucessful"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF2(_L("GetModuleIniData (DummyCpm) returned Error (%d) \n"), error);
}
data.Close();
return TestStepResult();
}
int main()
{
__UHEAP_MARK;
RBuf8 myrbuf;
TBufC8<5> myTBufC (_L8("hello"));
myrbuf.Create(myTBufC);
myrbuf.CleanupClosePushL();
char *des= new char[5];
int retval=ESuccess;
int size=5;
retval= Rbuf8ToChar(myrbuf,des,size);
if(retval ==ESuccess)
{
printf("Test_rbuf8tochar_minsize passed\n");
}
else
{
assert_failed = true;
printf("Test_rbuf8tochar_minsize FAILURE\n");
}
delete[] des;
des=NULL;
CleanupStack::PopAndDestroy(1);
__UHEAP_MARKEND;
testResultXml("Test_rbuf8tochar_minsize");
return 0;
}
int ILibSocketWrapper_recv(int socketObject, char *buffer, int bufferLength)
{
RSocket *s = (RSocket*)SocketArray[socketObject];
RBuf8 *buf = new RBuf8();
TRequestStatus status;
TSockXfrLength aLen;
int RetVal=0;
if(buf->Create(bufferLength)==KErrNone)
{
s->RecvOneOrMore(*buf,0,status,aLen);
User::WaitForRequest(status);
if(status!=KErrNone)
{
RetVal = 0;
}
else
{
RetVal = aLen();
Mem::Copy(buffer,(void*)buf->Ptr(),RetVal);
}
}
buf->Close();
delete buf;
return(RetVal);
}
bool ChatSessionImpl::sendChatData(QString newChatData)
{
TPtrC16 dataPtr(reinterpret_cast<const TUint16*>(newChatData.utf16()));
RBuf8 chatData;
chatData.Create(300);
chatData.Copy(dataPtr);
mMessageSource->SendDataL(chatData);
chatData.Close();
return true;
}
void CTestRControlChannel::ExtractServiceDescriptionL (const TDesC& aConfigSection, CUPnPServiceRegisterParamSet& aServiceRegisterParamSet)
{
RFs fs;
RFile file;
RBuf8 buf;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
TPtrC descriptionPath;
_LIT(KDescriptionPath, "Description_Path");
GetStringFromConfig(aConfigSection, KDescriptionPath, descriptionPath);
TInt err = file.Open(fs, descriptionPath, EFileShareReadersOnly);
// For Hardware system path is c:, so descriptionPath value present in '.ini' is referring 'c:'
if ( err == KErrPathNotFound )
{
RBuf fileName;
TDriveName aSystemDrive;
TDriveUnit driveunit(RFs::GetSystemDrive());
aSystemDrive.Zero();
aSystemDrive=driveunit.Name();
fileName.CreateL ( descriptionPath.Length () );
fileName.Zero();
fileName.Append(aSystemDrive);
fileName.Append ( descriptionPath.Mid ( aSystemDrive.Length () ) );
err = file.Open(fs, fileName, EFileShareReadersOnly);
}
if (err != KErrNone)
{
User::LeaveIfError(err);
}
CleanupClosePushL(file);
TInt fileSize = 0;
file.Size(fileSize);
buf.Create(fileSize);
err = file.Read(buf, fileSize);
aServiceRegisterParamSet.SetServiceDescriptionL ( buf );
CleanupStack::PopAndDestroy(2 );
buf.Close();
_LIT(KInfoLogFile, "CRControlChannelObserver::ExtractServiceDescriptionL End.... \n");
INFO_PRINTF1(KInfoLogFile);
}
void CSmfCredMgrClientSymbian::authenticatedPluginListL(
QString RegistrationToken, QStringList& List)
{
CSmfPluginIDListParams* fetchPluginListParams =
new (ELeave) CSmfPluginIDListParams;
CleanupStack::PushL(fetchPluginListParams);
//fill input params
fetchPluginListParams->iRegistrationToken = qt_QString2HBufC(
RegistrationToken);
//create buffer to serialize data
CBufFlat* buf = CBufFlat::NewL(KMinBufSize);
CleanupStack::PushL(buf);
RBufWriteStream stream(*buf);
CleanupClosePushL(stream);
fetchPluginListParams->ExternalizeL(stream);
stream.CommitL();
TPtr8 bufPtr1 = buf->Ptr(0);
TIpcArgs args;
args.Set(0, &bufPtr1);
// to get the data from server, we create a space.
HBufC8* retBuf = HBufC8::NewL(KMaxBufSize);
CleanupStack::PushL(retBuf);
TPtr8 outputptr = retBuf->Des();
args.Set(1, &outputptr);
iSession.RequestService(ESendPluginIDList, args);
//create buffer to read data received
RBuf8 dataBuf;
CleanupClosePushL(dataBuf);
dataBuf.Create(outputptr);
fetchPluginListParams->InternalizeL(dataBuf);
smfcredmgrclientutil::convertToQStringList(
fetchPluginListParams->iPluginList, List);
CleanupStack::PopAndDestroy(&dataBuf);
CleanupStack::PopAndDestroy(retBuf);
CleanupStack::PopAndDestroy(&stream);
CleanupStack::PopAndDestroy(buf);
CleanupStack::PopAndDestroy(fetchPluginListParams);
}
// The client application has signaled that all attributes have been returned so
// response can now be sent
EXPORT_C void CRemConMediaInformationTarget::Completed()
{
if (!iInProgress)
{
return;
}
// Finalise response; update number of attributes returned
iResponse->iNumberAttributes = iResponse->iAttributes.Count();
//Check the bound of the number of attributes, zero is not permitted
if (iResponse->iNumberAttributes == 0)
{
return SendError(KErrAvrcpMetadataInternalError);
}
// Allocate a buffer for the formatted message
RBuf8 messageBuffer;
if ( messageBuffer.Create(iResponse->Size()) != KErrNone )
{
// On OOM drop the message
iResponse->Close();
return;
}
// send the result back to the CT
TInt error = KErrNone;
TRAP(error, iResponse->WriteL(messageBuffer));
if (error == KErrNone)
{
InterfaceSelector().SendUnreliable(TUid::Uid(KRemConMediaInformationApiUid),
EGetElementAttributes, ERemConResponse, messageBuffer);
}
// Make sure attribute list is reset for next time
iResponse->Close();
messageBuffer.Close();
iInProgress = EFalse;
if (!iMsgQueue.IsEmpty())
{
iNextMessageCallBack->CallBack();
}
}
// from MRemConInterfaceIf
void CRemConMediaInformationTarget::SendError(TInt aError)
{
RBuf8 outBuf;
if (outBuf.Create(KAVCFrameMaxLength) != KErrNone)
{
// On OOM drop the message
return;
}
TInt error = 0;
RAvrcpIPCError response;
response.iError = aError;
TRAP(error, response.WriteL(outBuf)); // Don't send error if OOM
if (error == KErrNone)
{
InterfaceSelector().SendUnreliable(TUid::Uid(KRemConMediaInformationApiUid),
EGetElementAttributes, ERemConResponse, outBuf);
}
outBuf.Close();
}
int ILibSocketWrapper_recvfrom(int socketObject, char *buffer, int bufferLength, struct sockaddr *src)
{
RSocket *s = (RSocket*)SocketArray[socketObject];
TRequestStatus status;
TInetAddr addr;
int RetVal=0;
RBuf8 *buf = new RBuf8();
if(buf->Create(bufferLength)==KErrNone)
{
TProtocolDesc aProtocol;
s->Info(aProtocol);
if(aProtocol.iSockType==KSockStream)
{
s->RemoteName(addr);
((struct in_addr*)src->sa_data)->s_addr = ntohl(addr.Address());
src->sa_port = htons(addr.Port());
RetVal = ILibSocketWrapper_recv(socketObject, buffer, bufferLength);
}
else
{
s->RecvFrom(*buf,addr,(unsigned int)0,status);
User::WaitForRequest(status);
if(status!=KErrNone)
{
RetVal = 0;
}
else
{
((struct in_addr*)src->sa_data)->s_addr = ntohl(addr.Address());
src->sa_port = htons(addr.Port());
Mem::Copy(buffer,buf->Ptr(),buf->Length());
RetVal = buf->Length();
}
}
}
buf->Close();
delete buf;
return(RetVal);
}
TInt GetRecogniserInfo(TUid aImplementationUid, RArray<TDataType>& aMimeTypes)
{
TInt size = SendReceive(EGetRecog, TIpcArgs(aImplementationUid.iUid));
if (size < 0) return size;
TInt err = aMimeTypes.Reserve(size/sizeof(TDataType));
if (err) return err;
RBuf8 buf;
err = buf.Create(size);
if (err) return err;
err = SendReceive(EGetRecog2, TIpcArgs(&buf));
if (err) { buf.Close(); return err; }
const TDataType* ptr = (const TDataType*)buf.Ptr();
for (TInt i = 0; i < size/sizeof(TDataType); i++)
{
err = aMimeTypes.Append(ptr[i]);
if (err) break;
}
buf.Close();
return err;
}
int TransferTestThread(TAny* aData) {
// This delay is needed to make sure this thread starts only after
// receive data function is called from the main thread.
TData& data = *(TData *)aData;
// Wait On the semaphore.
// This is to make sure that this thread do not start untill main thread
// calls ReceiveData method.
data.iSem1->Wait();
testTransferThread.Start(_L("Start Transfer Thread\n"));
RExDriverChannel *iLdd2;
iLdd2= data.iLdd;
RBuf8 rxBuf;
TInt r=rxBuf.Create(1000);
testTransferThread.Printf(_L("Check Multiple receive request on same channel : "));
// Try calling Receive Data again from the same channel when already another
// receive data request is pending.
// It should return KErrInUse.
r = iLdd2->ReceiveData(rxBuf);
testTransferThread(r == KErrInUse);
testTransferThread.Printf(_L("Fails : As Expected \n"));
r = iLdd2->TransmitData(*data.iTxData);
testTransferThread(r == KErrNone);
testTransferThread.Printf(_L("Data Transfer Complete.\n"));
testTransferThread.End();
testTransferThread.Close();
return KErrNone;
}
void CUPnPRControlChannelAO::ExtractSoapResponse(RBuf8& aSoapResponse)
{
aSoapResponse.Create(iCompleteBuffer);
}
void ScrShotsGenUtils::DumpJsFileL(CScrShotsSettings* scrShotsSettings)
{
CGetImei* getImei = CGetImei::NewL();
CleanupStack::PushL(getImei);
RBuf8 formatBuf;
formatBuf.Create(256);
formatBuf.CleanupClosePushL();
TFileName infoFile;
User::LeaveIfError(CEikonEnv::Static()->FsSession().PrivatePath(infoFile));
infoFile.Append( KDeviceJSFile );
TParsePtrC parse((CEikonEnv::Static()->EikAppUi()->Application())->AppFullName());
infoFile.Insert(0, KCDriveWithColon);
RFs fsConn;
User::LeaveIfError(fsConn.Connect());
CleanupClosePushL(fsConn);
RFile jsFile;
if(BaflUtils::FileExists(fsConn, infoFile)){
BaflUtils::DeleteFile(fsConn, infoFile);
}
//now create the file
User::LeaveIfError(jsFile.Create(fsConn, infoFile, EFileWrite));
CleanupClosePushL(jsFile);
// User::LeaveIfError(jsFile.Write(KFunctionBlockStart));
RBuf8 values;
values.Create(256);
for(int i = 0; i < KDeviceParamsCount ; i++){
formatBuf.Zero();
TInt sizeOfItem = User::StringLength((TText8 *)DeviceParams [i]);
TPtr8 item((unsigned char*)DeviceParams [i],sizeOfItem ,sizeOfItem );
switch(i){
//device_model
case 0:{
CDeviceTypeInformation* devInfo = SysUtil::GetDeviceTypeInfoL();
CleanupStack::PushL(devInfo);
TPtrC manufName, modelCode, modelName;
devInfo->GetManufacturerName(manufName);
devInfo->GetModelCode(modelCode);
devInfo->GetModelName(modelName);
RBuf8 manufName8, modelName8, modelCode8;
manufName8.Create(128); modelName8.Create(128); modelCode8.Create(128);
manufName8.CleanupClosePushL(); modelName8.CleanupClosePushL(); modelCode8.CleanupClosePushL();
manufName8.Copy(manufName);
modelName8.Copy(modelName);
modelCode8.Copy(modelCode);
values.Format(KModelNameFormatString, &manufName8, &modelName8, &modelCode8);
CleanupStack::PopAndDestroy(4);
break;
}
//firmware_version
case 1:{
RBuf swVersion;
swVersion.Create(128);
SysUtil::GetSWVersion(swVersion);
values.Copy(swVersion);
TInt pos = 0;
while((pos = values.Find(_L8("\n"))) != KErrNotFound){
//values.Delete(pos,1);
values.Replace(pos,1,_L8("_"));
}
swVersion.Close();
break;
}
//ram_info
case 2:{
TInt totalram= 0;
HAL::Get(HALData::EMemoryRAM, totalram);
totalram /= 1024;
values.Num(totalram);
break;
}
//uptime
case 3:{
TTimeIntervalMicroSeconds32 iTickPeriod;
UserHal::TickPeriod(iTickPeriod);
TUint tickCount = User::TickCount();
TUint noOfTicksPerSecond = (1000 * 1000) / iTickPeriod.Int();
TInt noOfSecsSinceStartUp = tickCount / noOfTicksPerSecond;//noOfMicroSecsSinceStartup / (1000 * 1000);
values.Num(noOfSecsSinceStartUp);
break;
}
//scrshot count
case 4:{
values.Num(scrShotsSettings->TotalScrShotCount());
break;
}
//symbian version
case 5:{
TVersion epocver = User::Version();
values.Copy(epocver.Name());
break;
}
//series 60 version
case 6:{
VersionInfo::TPlatformVersion platformVersion;
VersionInfo::GetVersion(platformVersion);
TInt aMajor = platformVersion.iMajorVersion;
TInt aMinor = platformVersion.iMinorVersion;
values.Format(_L8("%d.%d"),aMajor, aMinor);
break;
}
//country code
case 7:{
TLocale loc;
int code = loc.CountryCode();
values.Num(code);
break;
}
//imei hash
case 8:{
TBuf8<256> inputimei;
TBuf8<256> outimeihash;
if(getImei->IsImeiFetched()){
getImei->GetImei(inputimei);
GetWhirlPoolHash(outimeihash,inputimei);
values.Copy(outimeihash);
}
}
break;
}
formatBuf.Format(KStringVariableDeclaration,
&item,
&values);
TRACE_ON(RDebug::Printf((const char*)formatBuf.PtrZ()));
jsFile.Write(formatBuf);
}
values.Close();
CleanupStack::PopAndDestroy(4);
//TODO: This code should be commented in final release build
#if BRAHMA_DEBUG
//code to copy the js file just created to the c:\ so that it can be analyzed
_LIT(KTargetFileName, "c:\\device_info.js");
BaflUtils::CopyFile(CEikonEnv::Static()->FsSession(),infoFile, KTargetFileName);
#endif
}
/**
* Write the file to the hard drive.
*
* @param aFileName
* @param aBodyPartArray
*/
void CMultipartTestContainer::WriteFileL( const TDesC& aFileName,
RPointerArray<CBodyPart>& aBodyPartArray )
{
RFs fs;
fs.Connect();
CleanupClosePushL(fs);
RFile output;
TInt err = output.Open(fs, aFileName, EFileWrite);
if (err == KErrNotFound)
{
User::LeaveIfError(output.Create(fs, aFileName, EFileWrite));
}
// output file
TInt size = aBodyPartArray.Count();
TInt i;
_LIT8(KEol, "\r\n");
for (i = 0; i < size; i++)
{
CBodyPart* bodyPart = aBodyPartArray[i];
if( bodyPart->Url().Ptr() )
{
output.Write(_L8("***************Ur"));
output.Write(KEol);
RBuf8 narrow;
err = narrow.Create(bodyPart->Url().Length()*2);
if (err != KErrNone)
{
INFO_PRINTF1(_L("Error printing Url to output file; continueing..."));
}
narrow.Copy(bodyPart->Url());
output.Write(narrow.Left(narrow.Length()));
output.Write(KEol);
}
if( bodyPart->ContentID().Ptr() )
{
output.Write(_L8("***************ContentID"));
output.Write(KEol);
output.Write(bodyPart->ContentID() );
output.Write(KEol);
}
if( bodyPart->Charset().Ptr() )
{
output.Write(_L8("***************Charset"));
output.Write(KEol);
output.Write( bodyPart->Charset() );
output.Write(KEol);
}
if( bodyPart->ContentType().Ptr() )
{
output.Write(_L8("***************ContentType"));
output.Write(KEol);
output.Write( bodyPart->ContentType() );
output.Write(KEol);
}
if( bodyPart->Headers().Ptr() )
{
output.Write(_L8("***************Headers"));
output.Write(KEol);
output.Write(bodyPart->Headers() );
output.Write(KEol);
}
if( bodyPart->Body().Ptr() )
{
output.Write(_L8("***************Body"));
output.Write(KEol);
output.Write(bodyPart->Body() );
output.Write(KEol);
}
output.Write(_L8("=========================================part ends"));
output.Write(KEol);
} // end of loop
output.Close();
CleanupStack::PopAndDestroy(1, &fs);
fs.Close();
}
TBool CSmfCredMgrClientSymbian::AuthDataSetL(QString RegToken,
QDateTime Validity, SmfAuthParams& AuthTokenSet)
{
RDebug::Printf("+In AuthDataSetL()");
CSmfFetchAuthTokenSet* fetchAuthTokenSetParams =
new (ELeave) CSmfFetchAuthTokenSet;
CleanupStack::PushL(fetchAuthTokenSetParams);
//fill the input params
fetchAuthTokenSetParams->iRegistrationToken = qt_QString2HBufC(RegToken);
fetchAuthTokenSetParams->iValidity = Validity.toTime_t();
//create buffer to serialize data
CBufFlat* buf = CBufFlat::NewL(KMaxBufSize);
CleanupStack::PushL(buf);
RBufWriteStream stream(*buf);
CleanupClosePushL(stream);
fetchAuthTokenSetParams->ExternalizeL(stream);
stream.CommitL();
TPtr8 bufPtr = buf->Ptr(0);
TIpcArgs args;
args.Set(0, &bufPtr);
// to get the data from server, we create a space.
HBufC8* retBuf = HBufC8::NewL(KMaxBufSize);
CleanupStack::PushL(retBuf);
TPtr8 outputptr = retBuf->Des();
args.Set(1, &outputptr);
iSession.RequestService(ESendAuthDataSet, args);
//create buffer to read data sent by server
RBuf8 dataBuf;
CleanupClosePushL(dataBuf);
dataBuf.Create(outputptr);
fetchAuthTokenSetParams->InternalizeL(dataBuf);
CleanupStack::PopAndDestroy(&dataBuf);
CleanupStack::PopAndDestroy(retBuf);
CleanupStack::PopAndDestroy(&stream);
CleanupStack::PopAndDestroy(buf);
//return EFalse if count is 0
if (fetchAuthTokenSetParams->iAuthTokenArray.Count() == 0)
{
CleanupStack::PopAndDestroy(fetchAuthTokenSetParams);
RDebug::Printf("-In AuthDataSetL()");
return EFalse;
}
smfcredmgrclientutil::RArrayToSmfAuthParams(
fetchAuthTokenSetParams->iAuthTokenArray, AuthTokenSet);
CleanupStack::PopAndDestroy(fetchAuthTokenSetParams);
RDebug::Printf("-In AuthDataSetL()");
return ETrue;
}
QString CSmfCredMgrClientSymbian::storeAuthDataL(SmfAuthParams Set,
QDateTime Validity, QList<QUrl> URLList, QStringList PluginList,
QString AuthAppAID, bool Flag)
{
RDebug::Printf("+In storeAuthDataL()");
CSmfStoreAuthParams* authenticationProcessData =
new (ELeave) CSmfStoreAuthParams;
CleanupStack::PushL(authenticationProcessData);
//create space for iRegistrationToken
authenticationProcessData->iRegistrationToken = HBufC::NewL(
KMaxRegistrationTokenLength);
//fill the input params
smfcredmgrclientutil::SmfAuthParamstoRArray(Set,
authenticationProcessData->iAuthTokenArray);
authenticationProcessData->pluginIDEnabled = Flag;
//set iValidity
authenticationProcessData->iValidity = Validity.toTime_t();
//set authappid
authenticationProcessData->iAuthAppID = qt_QString2HBufC(AuthAppAID);
//set the lists
authenticationProcessData->iURLList
= smfcredmgrclientutil::convertToSymbianURLList(URLList);
authenticationProcessData->iPluginIDList
= smfcredmgrclientutil::convertToSymbianPluginList(
PluginList);
//create buffer to serialize data
CBufFlat* buf = CBufFlat::NewL(KMaxBufSize);
CleanupStack::PushL(buf);
RBufWriteStream stream(*buf);
CleanupClosePushL(stream);
authenticationProcessData->ExternalizeL(stream);
stream.CommitL();
TPtr8 bufPtr = buf->Ptr(0);
TIpcArgs args;
args.Set(0, &bufPtr);
// to get the data from server, we create a space.
HBufC8* retBuf = HBufC8::NewL(KMaxBufSize);
CleanupStack::PushL(retBuf);
TPtr8 outputptr = retBuf->Des();
args.Set(1, &outputptr);
iSession.RequestService(EStoreAuthData, args);
//create buffer to read data received
RBuf8 dataBuf;
CleanupClosePushL(dataBuf);
dataBuf.Create(outputptr);
authenticationProcessData->InternalizeL(dataBuf);
TPtr regTokenPtr(
authenticationProcessData->iRegistrationToken->Des());
//convert and return
QString regString = qt_TDes2QString( regTokenPtr );
CleanupStack::PopAndDestroy(&dataBuf);
CleanupStack::PopAndDestroy(retBuf);
CleanupStack::PopAndDestroy(&stream);
CleanupStack::PopAndDestroy(buf);
CleanupStack::Pop();
return regString;
}
/**
Test the driver data flow path by loopback,
i.e Transmit the data and receive same data back.
It runs the device @ default configuration
@param aLoopback
Loopback mode as internal or external
aTxData
Transmit Data buffer
aRxSize
Receive data size
*/
void TestExDriver::TestConcurrentTxRx(TInt aLoopback, const TDesC8& aTxData, TInt aRxSize)
{
TInt r;
TRequestStatus stat;
iTest.Printf(_L("Test Concurrent Synchronous Requests - Tx/Rx\n"));
// Open channel
r=iLdd.Open(KUnit1);
iTest(r==KErrNone);
// Create a buffer that has to be filled and returned by the driver
RBuf8 rxBuf;
r=rxBuf.Create(aRxSize);
iTest(r==KErrNone);
r=iLdd.SetIntLoopback(aLoopback);
iTest(r==KErrNone);
TData TData(&iLdd,&aTxData,&iSem1);
// Call ldd interface ReceiveData() API to get data to rxBuf
RThread TransferThread;
_LIT(KThreadName, "TestThread");
TInt ret = TransferThread.Create( KThreadName, // Thread name
TransferTestThread, // Function to be called
KDefaultStackSize,
KHeapSize,
KHeapSize,
(TAny *)&TData
);
iTest.Printf(_L("Receive Data\n"));
TransferThread.Logon(stat);
TransferThread.Resume();
iSem1.Signal();
r = iLdd.ReceiveData(rxBuf);
// In case of zero length request
if (aRxSize==0)
{
// Driver should return error immediately
iTest(r!=KErrNone);
TransferThread.Kill(KErrNone);
TransferThread.Close();
// Close the RBuf
rxBuf.Close();
// Close channel
iLdd.Close();
return;
}
// Print the receive data to display.
// It automatically checks the Tx and Rx data. Fails if not matched.
//
TInt i;
iTest.Printf(_L("Received Data of size (%d):"),rxBuf.Size());
for (i=0; i<rxBuf.Size(); i++)
{
iTest.Printf(_L("%c"),(rxBuf.Ptr())[i]);
if ((TUint8)(rxBuf.Ptr())[i] != aTxData[i])
{
iTest.Printf(_L("Transmit and Receive data do not match\n"));
iTest(EFalse);
}
}
iTest.Printf(_L("\n"));
User::WaitForRequest(stat);
TransferThread.Close();
// Free the receive buffer
rxBuf.Close();
// Close channel
iLdd.Close();
}
/**
Test the driver data flow path by loopback,
i.e Transmit the data and receive same data back.
It runs the device @ default configuration
@param aLoopback
Loopback mode as internal or external
aTxData
Transmit Data buffer
aRxSize
Receive data size
*/
void TestExDriver::TestConcurrentTxRx(TInt aLoopback, const TDesC8& aTxData, TInt aRxSize)
{
TInt r;
// Request status object for transmit and receive. These object will be
// used to read the status of asynchronous requests after the notification
// of request completion
//
TRequestStatus txStatus;
TRequestStatus rxStatus;
// Timers and their respective status objects for Tx and Rx
RTimer timerTx;
RTimer timerRx;
TRequestStatus timeStatusTx;
TRequestStatus timeStatusRx;
iTest.Printf(_L("Test Concurrent Asynchronous Requests - Tx/Rx\n"));
// Open channel
r=iLdd.Open(KUnit1);
iTest(r==KErrNone);
// Create a buffer that has to be filled and returned by the driver
RBuf8 rxBuf;
r=rxBuf.Create(aRxSize);
iTest(r==KErrNone);
r=iLdd.SetIntLoopback(aLoopback);
iTest(r==KErrNone);
// Create the timer that is relative to the thread
r = timerTx.CreateLocal();
iTest(r==KErrNone);
r = timerRx.CreateLocal();
iTest(r==KErrNone);
// Trigger timerRx expiry after KTimeOutTxRx. The status should be pending
timerRx.After(timeStatusRx,KTimeOutTxRx);
iTest(timeStatusRx==KRequestPending);
// Call ldd interface ReceiveData() API to get data to rxBuf
r = iLdd.ReceiveData(rxStatus, rxBuf);
// In case of zero length request
if (aRxSize==0)
{
// Driver should return error immediately
iTest(r!=KErrNone);
// Close the RBuf
rxBuf.Close();
// Close channel
iLdd.Close();
return;
}
else
{
// Asynchronous request should be pending, with request message
// posted to driver successfully
//
iTest((r==KErrNone)&&(rxStatus.Int()==KRequestPending));
}
// Trigger timerTx expiry after KTimeOutTxRx. The status should be pending
timerTx.After(timeStatusTx,KTimeOutTxRx);
iTest(timeStatusTx==KRequestPending);
// Call ldd interface TransmitData() API test data descriptor as parameter
r = iLdd.TransmitData(txStatus, aTxData);
// In case of zero length request
if (aTxData.Size()==0)
{
// Driver should return error immediately
iTest(r!=KErrNone);
// Close the RBuf
rxBuf.Close();
// Close channel
iLdd.Close();
return;
}
else
{
// Asynchronous request should be pending, with request message
// posted to driver successfully
//
iTest(r==KErrNone);
}
// Wait till the request is complete on rxStatus and txStatus. User thread
// is blocked with this call, till it is notified about the request
// completion.
//
if(txStatus.Int()==KRequestPending)
User::WaitForRequest(txStatus,timeStatusTx);
if(rxStatus.Int()==KRequestPending)
User::WaitForRequest(rxStatus,timeStatusRx);
// if transmit has occured correctly, the iTimeStatus will not be KErrNone, else
// no transmit complete has occured and iTimer has expired
iTest (timeStatusTx!=KErrNone);
iTest (timeStatusRx!=KErrNone);
// Cancel the iTimer request
timerTx.Cancel();
timerRx.Cancel();
// txStatus holds the request completion. TRequestStatus::Int() returns the
// completion code. It will be KErrNone in case of successful completion
//
r = txStatus.Int();
iTest((r==KErrNone)||(r==KErrTimedOut));
r = rxStatus.Int();
iTest((r==KErrNone)||(r==KErrTimedOut));
// Close the handle to the timerTx and timerRx
timerTx.Close();
timerRx.Close();
// Print the recieve data to display and verify the data received manually.
TInt i;
iTest.Printf(_L("Received Data of size (%d):"),rxBuf.Size());
for (i=0;i<rxBuf.Size();i++)
{
iTest.Printf(_L("%c"),(TUint8*)(rxBuf.Ptr())[i]);
if ((rxBuf.Ptr())[i] != aTxData[i])
{
iTest.Printf(_L("Transmit and Receive data do not match\n"));
iTest(EFalse);
}
}
iTest.Printf(_L("\n"));
// Free the receive buffer
rxBuf.Close();
// Close channel
iLdd.Close();
}
