// ============================================================================ // RCwrtRegistryClientSession::getAttributeL() // Returns the attribute value for the widget // // ============================================================================ EXPORT_C QVariant RWACRegistryClientSession::getAttributeL( const QString& appId, const QString& attribute, const QVariant& defaultValue ) { const TInt maxSize = 5120; CBufFlat* sendBuf = CBufFlat::NewL( maxSize ); CleanupStack::PushL( sendBuf ); RBufWriteStream stream( *sendBuf ); CleanupClosePushL( stream ); SerializeStringL( stream, appId ); SerializeStringL( stream, attribute ); SerializeStringL( stream, defaultValue.toString() ); CleanupStack::PopAndDestroy( &stream ); CBufFlat* recvBuf = CBufFlat::NewL( maxSize ); CleanupStack::PushL( recvBuf ); recvBuf->ExpandL( 0, maxSize ); TPtr8 sendArg( sendBuf->Ptr(0) ); TPtr8 recvArg( recvBuf->Ptr(0) ); User::LeaveIfError( SendReceive( EOpCodeGetWebAttribute, TIpcArgs( &sendArg, &recvArg ) ) ); // deserialize RDesReadStream rstream( recvArg ); CleanupClosePushL( rstream ); QString attrValue = DeserializeStringL( rstream ); CleanupStack::PopAndDestroy( 3, sendBuf ); // rstream, recvBuf, sendBuf return ( QVariant( attrValue ) ); }
void CCmdTestList::AddMultipleWaitCommandL(TInt32 aTimeout) { RDebug::Printf("CCmdTestList::AddMultipleWaitCommandL"); SSMLOGLEAVEIFNULL(iCommandList); // const TInt KTempDataLength = 1024; CBufFlat* inputBuffer = CBufFlat::NewL(KTempDataLength); CleanupStack::PushL(inputBuffer); RBufWriteStream writeStream(*inputBuffer); CleanupClosePushL(writeStream); writeStream.WriteInt32L(aTimeout); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.WriteUint16L(KDefaultCommandPriority); #endif //SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.CommitL(); RDesReadStream readStream(inputBuffer->Ptr(0)); CleanupClosePushL(readStream); TArray<MSsmCommand*> deferredList = iDeferredList.Array(); CSsmCommandBase* cmd = CCmdMultipleWait::NewL(readStream, deferredList); CleanupStack::PushL(cmd); static_cast<MSsmCommandList&>(*iCommandList).AppendL(cmd); iDeferredList.Reset(); CleanupStack::Pop(cmd); CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(inputBuffer); }
void CRtaContentHandler::GetStringAttributeSetL(const RMessage2& aMessage) { RStringAttributeSet attributeSet; CleanupClosePushL(attributeSet); HBufC* uniqueId = ReadDesC16LC(aMessage, 0); HBufC8* value = ReadDes8LC(aMessage, 1); TPtr8 valuePtr = value->Des(); RDesReadStream readStream(valuePtr); attributeSet.InternalizeL(readStream); CleanupStack::PopAndDestroy(value); iArchive->DrmFilesL().FindL(*uniqueId).GetStringAttributeSet(attributeSet); // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); // write the directory to the stream attributeSet.ExternalizeL(writeStream); TPtr8 bufPtr = buf->Ptr(0); WriteL(aMessage, 1, bufPtr); CleanupStack::PopAndDestroy(3, &attributeSet); // buf, attributeSet, uniqueid }
// --------------------------------------------------------- // RNSmlPrivateAPI::GetDMAuthInfoL( CNSmlDMAuthInfo& aAuthInfo ) // Retrieves DM auhentication info from settings // --------------------------------------------------------- // EXPORT_C void RNSmlPrivateAPI::GetDMAuthInfoL( CNSmlDMAuthInfo& aAuthInfo ) { TPckgBuf<TInt> buf; TIpcArgs args(aAuthInfo.iProfileId, &buf); User::LeaveIfError( SendReceive( ECmdInitDMAuthInfo, args) ); CBufFlat* buffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity ); CleanupStack::PushL( buffer ); buffer->ResizeL( buf() ); TPtr8 pBuffer(0, NULL, 0); pBuffer.Set( buffer->Ptr(0) ); TIpcArgs argsGet( &pBuffer ); User::LeaveIfError( SendReceive( ECmdGetDMAuthInfo, argsGet) ); RDesReadStream stream; stream.Open( pBuffer ); CleanupClosePushL( stream ); aAuthInfo.InternalizeL( stream ); CleanupStack::PopAndDestroy(2); // stream, buffer }
// --------------------------------------------------------------------------- // XIMPEventCodec::PackL() // --------------------------------------------------------------------------- // EXPORT_C HBufC8* XIMPEventCodec::PackL( CXIMPApiEventBase& aEventObj, TInt32& aTypeOfEvent ) { CBufFlat* buffer = CBufFlat::NewL( 10 ); // initial granularity to 10 CleanupStack::PushL( buffer ); RBufWriteStream ws; CleanupClosePushL( ws ); ws.Open( *buffer ); // CSI: 65 # //Ask real event type through the event base interface TInt32 eventIfId = aEventObj.Base().GetInterfaceId(); //And write both event type and data ws.WriteInt32L( eventIfId ); aEventObj.ExternalizeL( ws ); ws.CommitL(); CleanupStack::PopAndDestroy(); //ws HBufC8* heapBuf = buffer->Ptr( 0 ).AllocL(); CleanupStack::PopAndDestroy( buffer ); aTypeOfEvent = eventIfId; return heapBuf; }
CIntent* CIntent::CopyL() const { // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); CleanupClosePushL(writeStream); // write *this to the stream ExternalizeL(writeStream); CleanupStack::PopAndDestroy(&writeStream); TPtr8 source = buf->Ptr(0); RDesReadStream readStream(source); CleanupClosePushL(readStream); // Create copy CIntent* copy = CIntent::NewL(readStream); CleanupStack::PopAndDestroy(2, buf); //readStream, buf return copy; }
/** Helper function to compare the data of the command. */ void CCmdTestWaitForApparcInit::CompareCommandsDataL(CCmdWaitForApparcInit* aTestCmd, TCmdErrorSeverity aSeverity, const TUint16 aPriority) { // create output buffer and stream CBufFlat* outputBuffer = CBufFlat::NewL(KTempDataLength); CleanupStack::PushL(outputBuffer); RBufWriteStream writeStream(*outputBuffer); CleanupClosePushL(writeStream); // externalise the data aTestCmd->ExternalizeL(writeStream); RDesReadStream readStream(outputBuffer->Ptr(0)); CleanupClosePushL(readStream); TCmdErrorSeverity severity = static_cast<TCmdErrorSeverity>(readStream.ReadInt16L()); TEST(aSeverity == severity); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE TUint16 priority = readStream.ReadUint16L(); TEST(aPriority == priority); #else TEST(aPriority == KDefaultPriority); #endif CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(outputBuffer); }
void CRtaContentHandler::GetWMDRMStringAttributeSetL(const RMessage2& aMessage) { RStringAttributeSet attributeSet; CleanupClosePushL(attributeSet); HBufC8* value = ReadDes8LC(aMessage, 1); TPtr8 valuePtr = value->Des(); RDesReadStream readStream(valuePtr); CleanupClosePushL(readStream); attributeSet.InternalizeL(readStream); CleanupStack::PopAndDestroy(2, value); iWmdrmContentObject->GetStringAttributeSetL(attributeSet); // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); CleanupClosePushL(writeStream); // write the directory to the stream attributeSet.ExternalizeL(writeStream); CleanupStack::PopAndDestroy(&writeStream); TPtr8 bufPtr = buf->Ptr(0); WriteL(aMessage, 1, bufPtr); CleanupStack::PopAndDestroy(2, &attributeSet); // buf, attributeSet }
// ============================================================================ // RCwrtRegistryClientSession::RegisterWidgetL() // Registers the widget // // ============================================================================ EXPORT_C bool RWACRegistryClientSession::RegisterWidgetL( const QString& appId, const QString& appTitle, const QString& appPath, const QString& iconPath, const AttributeMap& attributes, const QString& type, unsigned long size, const QString& startPath) { CBufFlat* buf = CBufFlat::NewL( 5120 ); CleanupStack::PushL( buf ); RBufWriteStream stream( *buf ); CleanupClosePushL( stream ); SerializeStringL( stream, appId ); SerializeStringL( stream, appTitle ); SerializeStringL( stream, appPath ); SerializeStringL( stream, iconPath ); SerializeMapL( stream, attributes ); SerializeStringL( stream, type ); SerializeIntL( stream, size ); SerializeStringL( stream, startPath ); CleanupStack::PopAndDestroy( &stream ); TPtr8 p( buf->Ptr(0) ); bool ret = SendReceive( EOpCodeRegisterWidget, TIpcArgs( &p ) ); CleanupStack::PopAndDestroy( buf ); return ret; }
EXPORT_C void RRtaRights::AddRightsL(CRightsObject& aRights) { // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); CleanupClosePushL(writeStream); // write the directory to the stream aRights.ExternalizeL(writeStream); CleanupStack::PopAndDestroy(&writeStream); TPtr8 bufPtr = buf->Ptr(0); if(IsDrmCapabilityEnforced()) { User::LeaveIfError(SendReceive(EAddRights, TIpcArgs(&bufPtr))); } else { User::LeaveIfError(SendReceive(ENoEnforceAddRights, TIpcArgs(&bufPtr))); } CleanupStack::PopAndDestroy(buf); }
void CSmfCredMgrClientSymbian::changePluginIDListL(const QString NewPluginID, const bool Flag, const QString OldPluginID) { CSmfPluginIDUpdate* changePluginListParams = new (ELeave) CSmfPluginIDUpdate; CleanupStack::PushL(changePluginListParams); //set the input params changePluginListParams->iNewPluginID = qt_QString2HBufC(NewPluginID); changePluginListParams->iOldPluginID = qt_QString2HBufC(OldPluginID); changePluginListParams->pluginIDEnabled = Flag; //create buffer to serialize data CBufFlat* buf = CBufFlat::NewL(KMaxBufSize); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); CleanupClosePushL(stream); changePluginListParams->ExternalizeL(stream); stream.CommitL(); TPtr8 bufPtr = buf->Ptr(0); TIpcArgs args; args.Set(0, &bufPtr); iSession.RequestService(EUpdatePluginIDList, args); CleanupStack::PopAndDestroy(&stream); CleanupStack::PopAndDestroy(buf); CleanupStack::PopAndDestroy(changePluginListParams); }
SMFCredMgrErrorCode CSmfCredMgrClientSymbian::signMessageL(QString Message, QString Key, QString& Signature, SmfSignatureMethod AlgorithmUsed) { SMFCredMgrErrorCode signError = SmfErrNone; TPtr msgPtr((qt_QString2HBufC(Message))->Des()); TPtr keyPtr((qt_QString2HBufC(Key))->Des()); CSmfSignParameters* signMsgParams = CSmfSignParameters::NewL( msgPtr.Collapse(), keyPtr.Collapse()); CleanupStack::PushL(signMsgParams); CBufFlat* buf = CBufFlat::NewL(KMinBufSize); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); CleanupClosePushL(stream); signMsgParams->ExternalizeL(stream); stream.CommitL(); TPtr8 bufPtr = buf->Ptr(0); TIpcArgs args; args.Set(0, &bufPtr); HBufC8* msgBuf = HBufC8::NewL(KMaxSignedMsgLength); TPtr8 msgBufPtr(msgBuf->Des()); CleanupStack::PushL(msgBuf); args.Set(1, &msgBufPtr); switch (AlgorithmUsed) { case ESMFRSAProtocol: { iSession.RequestService(ESmfRSASignMessage, args); } break; case ESMFHMACProtocol: { iSession.RequestService(ESmfHMACSHA1SignMessage, args); } break; default: { RDebug::Printf("Unsupported Algo:"); return SmfErrBadParameter; } } TBuf<KMaxSignedMsgLength> signedMsg; signedMsg.Copy(msgBufPtr); Signature = qt_TDesC2QString(signedMsg); CleanupStack::Pop(msgBuf); CleanupStack::PopAndDestroy(&stream); CleanupStack::PopAndDestroy(buf); CleanupStack::PopAndDestroy(signMsgParams); return signError; }
// ----------------------------------------------------------------------------- // CTestSDKNotes::TestNPIWriteInternalStateL // ----------------------------------------------------------------------------- TInt CTestSDKNotes::TestNPIWriteInternalStateL( CStifItemParser& /*aItem*/ ) { CEikProgressInfo::SInfo sInfo; sInfo.iTextType = EEikProgressTextPercentage; CTestSDKNotesProgressInfo* progress = CTestSDKNotesProgressInfo::NewLC( sInfo ); STIF_ASSERT_NOT_NULL( progress ); const TInt size = 2000; CBufFlat* buf = CBufFlat::NewL( size ); STIF_ASSERT_EQUALS( 0, buf->Ptr( 0 ).Length() ); CleanupStack::PushL( buf ); RBufWriteStream stream; CleanupClosePushL( stream ); stream.Open( *buf ); progress->WriteInternalStateL( stream ); stream.CommitL(); stream.Close(); CleanupStack::PopAndDestroy( &stream ); CleanupStack::PopAndDestroy( buf ); CleanupStack::PopAndDestroy( progress ); return KErrNone; }
void CRtaContentHandler::SearchL(const RMessage2& aMessage) { RStreamablePtrArray<CEmbeddedObject> array; CleanupClosePushL(array); HBufC8* mimeType = ReadDesC8LC(aMessage, 1); TBool recursive; TPckg<TBool> recursivePckg(recursive); aMessage.Read(2, recursivePckg); User::LeaveIfError(iArchive->DrmFilesL().CurrentContainer().Search(array, *mimeType, recursive)); // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); // write the directory to the stream array.ExternalizeL(writeStream); TPtr8 bufPtr = buf->Ptr(0); WriteL(aMessage, 0, bufPtr); CleanupStack::PopAndDestroy(3, &array); // buf, mimeType, array }
// ============================================================================ // CCwrtRegistryServerSession::OpGetWebAttributeL() // Returns the attribute value for the widget // // ============================================================================ // TInt CCwrtRegistryServerSession::OpGetWebAttributeL( const RMessage2& aMessage ) { TInt l = aMessage.GetDesMaxLength( 0 ); HBufC8* msgData = HBufC8::NewLC( l ); TPtr8 readPtr( msgData->Des() ); aMessage.ReadL( 0, readPtr ); RDesReadStream stream( *msgData ); CleanupClosePushL( stream ); QString appId = DeserializeStringL( stream ); QString attribute = DeserializeStringL( stream ); QString defaultValue = DeserializeStringL( stream ); CleanupStack::PopAndDestroy( 2 ); //stream, msgData, QVariant attrValue = WebAppRegistry::instance()->getAttribute( appId, attribute, QVariant( defaultValue ) ); TInt maxLength = aMessage.GetDesMaxLength( 1 ); CBufFlat* buf = CBufFlat::NewL( maxLength ); CleanupStack::PushL( buf ); RBufWriteStream wstream( *buf ); // stream over the buffer CleanupClosePushL( wstream ); SerializeStringL( wstream, attrValue.toString() ); CleanupStack::PopAndDestroy( &wstream ); aMessage.WriteL( 1, buf->Ptr(0) ); CleanupStack::PopAndDestroy( buf ); // buf return KErrNone; }
QString CSmfCredMgrClientSymbian::storeRSAKeysL(const QString KeyLabel, const QString keydata, const QDateTime Validity) { RDebug::Printf("Sending store RSA key message to server"); TPtrC labelPtr(qt_QString2TPtrC(KeyLabel)); TPtr dataPtr((qt_QString2HBufC(keydata)->Des())); QDateTime CurrentTime = QDateTime::currentDateTime(); TTimeIntervalSeconds duration(CurrentTime.secsTo(Validity)); TTime startDate; startDate.UniversalTime(); TTime endDate(startDate); endDate += duration; CSmfRsaKeyParameters* storeRSAKeysparams = CSmfRsaKeyParameters::NewL( labelPtr, startDate, endDate, (dataPtr.Collapse())); CleanupStack::PushL(storeRSAKeysparams); CBufFlat* buf = CBufFlat::NewL(KMinBufSize); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); CleanupClosePushL(stream); storeRSAKeysparams->ExternalizeL(stream); stream.CommitL(); TPtr8 bufPtr = buf->Ptr(0); TIpcArgs args; args.Set(0, &bufPtr); CleanupStack::PopAndDestroy(&stream); HBufC8* retBuf = HBufC8::NewLC(KSHA1HashLengthBytes); TPtr8 retBufPtr(retBuf->Des()); args.Set(1, &retBufPtr); iSession.RequestService(ESmfStoreRSAKey, args); RDebug::Printf("SMF: Message completed"); TBuf<KSHA1HashLengthBytes> key; key.Copy(retBufPtr); QString RetString(qt_TDesC2QString(key)); CleanupStack::Pop(retBuf); CleanupStack::PopAndDestroy(buf); CleanupStack::PopAndDestroy(storeRSAKeysparams); RDebug::Printf("-In storeAuthDataL()"); return (RetString); }
TInt CSenBaseIdentityManager::WriteConfigurationToL( const TDesC& aFile ) { // First, collect everything into MEMORY CBufFlat *pBuf = CBufFlat::NewL(KFLATBUF_SIZE); CleanupStack::PushL(pBuf); RBufWriteStream bufWs(*pBuf); CleanupClosePushL(bufWs); bufWs.WriteL(KUsersStart); if(iIdentity) { iIdentity->WriteAsXMLToL(bufWs); } bufWs.WriteL(KUsersEnd); TPtrC8 p8 = pBuf->Ptr(0); CleanupStack::PopAndDestroy(1); // bufWs // Everything in MEMORY ok, prepare to write into file RFs fss; User::LeaveIfError(fss.Connect()); CleanupClosePushL(fss); RFileWriteStream fileOutStream; CleanupClosePushL(fileOutStream); if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) ) { // note, this will zero-length the file(!) // it is better to require that 2xfilesize is available and not to // dangerously zero the old file and find out // that there is no space left.. //Data caging 2 implementation #if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA ) TBuf<KMaxPath> file; fss.CreatePrivatePath(EDriveC); fss.PrivatePath(file); file.Append(aFile); fileOutStream.Replace(fss, file, EFileWrite); #else fileOutStream.Replace(fss, aFile, EFileWrite); #endif // finally write the UTF-8 into the file. fileOutStream.WriteL(p8); } CleanupStack::PopAndDestroy(3); // fileOutStream, fss, pBuf return KErrNone; }
// --------------------------------------------------------- // RNSmlPrivateAPI::AddDMGenericAlertRequestL() // Adds a Generic Alert to DM Agent if it is found in the // server. // --------------------------------------------------------- // EXPORT_C TInt RNSmlPrivateAPI::AddDMGenericAlertRequestL( const TDesC8& aCorrelator, RArray<CNSmlDMAlertItem>& aItemList ) const { TInt err = KErrNone; // create buffer CBufFlat* buffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity ); CleanupStack::PushL( buffer ); // open stream to buffer RBufWriteStream stream( *buffer ); CleanupClosePushL( stream ); // externalize data to stream stream.WriteInt32L( aCorrelator.Length() ); stream.WriteL( aCorrelator ); TInt count = aItemList.Count(); stream.WriteInt32L( count ); if(count > 0) { for(TInt i =0 ; i <count; i++) { stream.WriteInt32L( (aItemList[i].iSource)->Length() ); stream.WriteL( (aItemList[i].iSource)->Des() ); stream.WriteInt32L( (aItemList[i].iTarget)->Length() ); stream.WriteL( aItemList[i].iTarget->Des() ); stream.WriteInt32L( (aItemList[i].iMetaType)->Length() ); stream.WriteL( aItemList[i].iMetaType->Des() ); stream.WriteInt32L( (aItemList[i].iMetaFormat)->Length() ); stream.WriteL( aItemList[i].iMetaFormat->Des()); stream.WriteInt32L( (aItemList[i].iMetaMark)->Length() ); stream.WriteL( aItemList[i].iMetaMark->Des() ); stream.WriteInt32L( (aItemList[i].iData)->Length() ); stream.WriteL( aItemList[i].iData->Des() ); } } // get modifiable pointer to buffer TPtr8 bufPtr( buffer->Ptr(0) ); CleanupStack::PopAndDestroy( &stream ); // send the data to sos server TIpcArgs args( &bufPtr ); err = SendReceive( ECmdAddGenericAlert, args ); CleanupStack::PopAndDestroy( buffer ); return err; }
/** Match an array of search strings against the contacts in the view. The descriptor from the client contains a flag at the start to indicate if a prefix or substring search has been requested. @param aMessage.Ptr0() Size of contact data to read (to client). @param aMessage.Int1() Size of descriptor (from client). @param aMessage.Ptr2() Descriptor (from client). */ void CViewSubSessionBase::ContactMatchingCriteriaExternalizedSizeL(const RMessage2& aMessage) { TPckgBuf<TInt> size; aMessage.ReadL(1,size); const TInt bufferSize = size(); // Restore buffer. CBufFlat* buffer = CBufFlat::NewL(bufferSize); CleanupStack::PushL(buffer); buffer->ExpandL(0,bufferSize); TPtr8 des(buffer->Ptr(0)); aMessage.ReadL(2,des); // Internalize the data from the stream. RBufReadStream readStream(*buffer); CleanupClosePushL(readStream); TBool prefixSearch = readStream.ReadUint32L(); const TInt numFindWords = readStream.ReadUint32L(); CPtrC16Array* findDesArray = new(ELeave) CPtrC16Array(numFindWords); CleanupStack::PushL(findDesArray); TInt findWordLength=0; for (TInt i=0; i<numFindWords; ++i) { findWordLength = readStream.ReadUint32L(); HBufC* findword = HBufC::NewLC(readStream,findWordLength); findDesArray->AppendL(*findword); } DeleteFindContacts(); if (prefixSearch) iView->ContactsMatchingPrefixL(*findDesArray,iContacts); else iView->ContactsMatchingCriteriaL(*findDesArray,iContacts); findDesArray->Reset(); CleanupStack::PopAndDestroy(numFindWords); CleanupStack::PopAndDestroy(3, buffer); // Compute contacts externalized size. const TInt contactsCount = iContacts.Count(); TInt contactsExternalizedSize=0; contactsExternalizedSize+=sizeof(TInt32); for (TInt jj=0;jj<contactsCount;++jj) { contactsExternalizedSize+=(iContacts)[jj]->ExternalizedSize(); } TPckgBuf<TInt> pckg(contactsExternalizedSize); aMessage.WriteL(0,pckg); }
/** Construct and delete a command using Internalise */ void CCmdTestLoadSup::CallInternalizeDataTestL(TCmdErrorSeverity aSeverity, TSsmExecutionBehaviour aExecutionBehaviour, TInt16 aRetries, const TSsmSupInfo& aInfo, const TUint16 aPriority) { // create a set of data and put it into a buffer CBufFlat* bufferin = CBufFlat::NewL(1024); CleanupStack::PushL(bufferin); // create write stream on buffer and put the data in RBufWriteStream writeStream(*bufferin); CleanupClosePushL(writeStream); writeStream.WriteInt16L(aSeverity); writeStream.WriteInt8L(aExecutionBehaviour); aInfo.ExternalizeL(writeStream); writeStream.WriteInt16L(aRetries); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.WriteUint16L(aPriority); #else TEST(aPriority == KDefaultPriority); #endif writeStream.CommitL(); // create a readstream on the data and put the data into the command RDesReadStream aReadStream(bufferin->Ptr(0)); CleanupClosePushL(aReadStream); CCmdLoadSup* loadSupCmd = CCmdLoadSup::NewL(aReadStream); CleanupStack::PushL(loadSupCmd); TEST(loadSupCmd->Type() == ESsmCmdLoadSup); // create output buffer and stream CBufFlat* bufferout = CBufFlat::NewL(1024); CleanupStack::PushL(bufferout); RBufWriteStream writeStream2(*bufferout); CleanupClosePushL(writeStream2); // externalise the data loadSupCmd->ExternalizeL(writeStream2); // check the data is correct #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE CompareInputAndOutputL(aSeverity, aExecutionBehaviour, aRetries, aInfo, bufferout, aPriority); #else CompareInputAndOutputL(aSeverity, aExecutionBehaviour, aRetries, aInfo, bufferout); #endif CleanupStack::PopAndDestroy(&writeStream2); CleanupStack::PopAndDestroy(bufferout); CleanupStack::PopAndDestroy(loadSupCmd); CleanupStack::PopAndDestroy(&aReadStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(bufferin); }
void CCntItemMsgHandler::FindAsyncTextDefInitL(const RMessage2& aMessage) { /* Initialisation for asynchronous find using CContactTextDef and array of "find words" constructed on the client-side and required on the server-side for matching. **/ CheckForManagerL(); // CContactTextDef can be NULL in which case the client will have // passed an empty descriptor. CContactTextDef* textDef = NULL; // Assuming that a KNullDesC parameter results in max length of 0. if(aMessage.GetDesLengthL(1) > 0) { // Use packager to unpack CContactTextDef. iPackager.SetBufferFromMessageL(aMessage,1); textDef = iPackager.UnpackCntTextDefLC(); CleanupStack::Pop(textDef); } // Unpack the CDesCArray manually as the packager does not package // both. CBufFlat* bufFlat = CBufFlat::NewL(1 << 8); CleanupStack::PushL(bufFlat); bufFlat->ExpandL(0,aMessage.GetDesLengthL(0)); TPtr8 ptr8(bufFlat->Ptr(0)); aMessage.ReadL(0,ptr8); RBufReadStream readStream; readStream.Open(*bufFlat); TInt count = readStream.ReadInt32L(); CDesCArray* unpacked = new (ELeave) CDesCArrayFlat(8); CleanupStack::PushL(unpacked); for(TInt i=0;i<count;++i) { TBuf<256> buf; TInt length = readStream.ReadInt32L(); readStream.ReadL(buf,length); unpacked->AppendL(buf); } readStream.Close(); // Persistence Layer does the actual initialisation and also takes // ownership of textDef. MLplCollection& collection = iManager->GetPersistenceLayer().FactoryL().GetCollectorL(); collection.FindAsyncTextDefInitL(*unpacked,textDef); CleanupStack::PopAndDestroy(unpacked); CleanupStack::PopAndDestroy(bufFlat); aMessage.Complete(KErrNone); }
EXPORT_C TInt RRtaContent::GetStringAttributeSetL(const TDesC& aUniqueId, RStringAttributeSet &aStringAttributeSet) const { TInt err = KErrOverflow; TInt length = 0; TPckg <TInt> lengthPckg(length); // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); CleanupClosePushL(writeStream); // write the directory to the stream aStringAttributeSet.ExternalizeL(writeStream); CleanupStack::PopAndDestroy(&writeStream); TPtr8 bufPtr = buf->Ptr(0); // allocate arbitary receive buffer much larger than the size of the source buffer length = bufPtr.Length() * 15; while(err == KErrOverflow) { HBufC8* transferBuffer = HBufC8::NewLC(length); transferBuffer->Des().Copy(bufPtr); TPtr8 transferPtr = transferBuffer->Des(); // attempt to retrieve the attributes err = SendReceive(EGetStringAttributeSet, TIpcArgs(&aUniqueId, &transferPtr)); if(err == KErrOverflow) { // Find out the length required to receive the resulting attribute set lengthPckg.Copy(transferPtr.Left(lengthPckg.MaxLength())); } else if(err == KErrNone) { // read in the attribute values from the buffer RDesReadStream readStream(transferPtr); CleanupClosePushL(readStream); aStringAttributeSet.InternalizeL(readStream); CleanupStack::PopAndDestroy(&readStream); } CleanupStack::PopAndDestroy(transferBuffer); } CleanupStack::PopAndDestroy(buf); return err; }
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); }
HBufC8* CSenLayeredXmlProperties::AsUtf8L() { CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize); CleanupStack::PushL(pBuf); RBufWriteStream bufWs(*pBuf); CleanupClosePushL(bufWs); this->WriteToL(bufWs); CleanupStack::PopAndDestroy(); // bufWs.Close(); TPtrC8 p = pBuf->Ptr(0); HBufC8* pRet = p.AllocL(); CleanupStack::PopAndDestroy(); // pBuf; return pRet; // return ipFragment->AsXmlL(); }
// ----------------------------------------------------------------------------- // CResultCollector::VisitL // ----------------------------------------------------------------------------- // void CResultCollector::VisitL( CNSPTest& aTest ) { CBufFlat* buffer = CBufFlat::NewL( 300 ); CleanupStack::PushL( buffer ); RBufWriteStream stream; stream.Open( *buffer ); CleanupClosePushL( stream ); aTest.ExternalizeL( stream ); TPckgBuf<TResult> pkgIn; pkgIn.Copy( buffer->Ptr(0) ); PrintResult( pkgIn() ); CleanupStack::PopAndDestroy(); CleanupStack::PopAndDestroy( buffer ); }
TBool CSmfCredMgrClientSymbian::isPluginAuthenticatedL(QString PluginID) { CBufFlat* buf = CBufFlat::NewL(KMinBufSize); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); CleanupClosePushL(stream); TPtr idPtr(qt_QString2HBufC(PluginID)->Des()); SmfUtils::ExternalizeDesL(idPtr, stream); stream.CommitL(); // to get the data from server, we create a space. HBufC8* retBuf = HBufC8::NewL(32); CleanupStack::PushL(retBuf); TPtr8 bufPtr = buf->Ptr(0); TPtr8 flag(retBuf->Des()); TIpcArgs args; args.Set(0, &bufPtr); args.Set(1, &flag); iSession.RequestService(ECheckPluginAuthentication, args); TLex8 iLex = TLex8(flag); TInt value = 0; iLex.Val(value); CleanupStack::PopAndDestroy(retBuf); CleanupStack::PopAndDestroy(&stream); CleanupStack::PopAndDestroy(buf); if (value) { RDebug::Printf("flag returned is ETrue"); return ETrue; } else { RDebug::Printf("flag returned is EFalse"); return EFalse; } }
/** Helper function to create instance of CCmdPersistHalAttributes trough readstream. */ CCmdPersistHalAttributes* CCmdTestPersistHalAttributes::CreateCmdFromStreamL(TCmdErrorSeverity aSeverity) { CBufFlat* inputBuffer = CBufFlat::NewL(KTempDataLength); CleanupStack::PushL(inputBuffer); RBufWriteStream writeStream(*inputBuffer); CleanupClosePushL(writeStream); writeStream.WriteInt16L(aSeverity); writeStream.CommitL(); RDesReadStream readStream(inputBuffer->Ptr(0)); CleanupClosePushL(readStream); CCmdPersistHalAttributes* newCmd = CCmdPersistHalAttributes::NewL(readStream); CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(inputBuffer); return newCmd; }
void CMsvSendErrorActionsStep::TestRestoreFromResourceL() { CBufFlat *buf = CBufFlat::NewL(32); CleanupStack::PushL(buf); buf->ResizeL(0x10000); RBufWriteStream writer(*buf); writer.PushL(); //default error action writer.WriteInt8L(0); //flag, action + retry + retry spacing writer.WriteInt16L(3); //max retries writer.WriteInt16L(1); //error code count writer.WriteInt32L(-1); //error code //error action count writer.WriteInt16L(1); //error action writer.WriteInt8L(1); writer.WriteInt16L(2); writer.WriteInt16L(2); //error code count writer.WriteInt32L(-2); //error code -2 writer.WriteInt32L(-3); //error code -3 writer.CommitL(); CleanupStack::PopAndDestroy(&writer); CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); CleanupStack::PushL(errorActions); TResourceReader reader; TPtr8 bufPtr = buf->Ptr(0); reader.SetBuffer(&bufPtr); errorActions->RestoreFromResourceL(reader); TMsvSendErrorAction errorAction; if(errorActions->GetSendErrorAction(-2, errorAction) != KErrNone || errorActions->GetSendErrorAction(-3, errorAction) != KErrNone || errorActions->Errors().Count() != 2) { INFO_PRINTF1(_L("CMsvSendErrorActions::RestoreFromResourceL failed")); SetTestStepResult(EFail); } CleanupStack::PopAndDestroy(errorActions); CleanupStack::PopAndDestroy(buf); }
// ----------------------------------------------------------------------------- // TMSCallSession::HandleFormatGetSupportedBitRatesL // // ----------------------------------------------------------------------------- // void TMSCallSession::HandleFormatGetSupportedBitRatesL( const RMessage2& aMessage) { TRACE_PRN_FN_ENT; gint status(TMS_RESULT_DOES_NOT_EXIST); if (iCallAdpt && (iActiveCallType == TMS_CALL_IP)) { CBufFlat* brbuf = CBufFlat::NewL(KArrayExpandSize); CleanupStack::PushL(brbuf); status = static_cast<TMSCallIPAdpt*>(iCallAdpt)->GetSupportedBitRates( brbuf); aMessage.WriteL(0, brbuf->Ptr(0)); CleanupStack::PopAndDestroy(brbuf); } aMessage.Complete(status); TRACE_PRN_FN_EXT; }
//----------------------------------------------------------------------------- // CAknDynamicSoftNotifier::SendMessageL //----------------------------------------------------------------------------- // TInt CAknDynamicSoftNotifier::SendMessageL( TInt aNoteId, TInt aCount, TBool aCancel, TBool aAddCount, TAknDynamicSoftNotificationParams& aParams ) { CBufFlat* buf = CBufFlat::NewL( KAknBufferGranularity ); CleanupStack::PushL( buf ); RBufWriteStream bufStream( *buf ); bufStream.PushL(); // Common data for dynamic notification bufStream.WriteInt32L( KAKNNOTIFIERSIGNATURE ); bufStream.WriteUint8L( ECustomSoftNotification ); bufStream.WriteInt16L( aCount ); // count bufStream.WriteUint8L( aCancel ? ETrue : EFalse ); // convert TBool to 0 or 1 bufStream.WriteUint8L( aAddCount ? ETrue : EFalse ); // convert TBool to 0 or 1 // text prompt (not used in this type of notification). // It's put here to simplify changes in server side bufStream << KNullDesC(); bufStream.WriteInt32L( aNoteId ); // notification id // Type Specific data for this dynamic notification // Keep this synchronized with AknDynamicNotificationData // bufStream.WriteInt16L( KAknSoftNotificationDynamic ); // parameter type id bufStream.WriteInt32L( aNoteId ); // notification id bufStream << aParams; // Additional data // // Secondary display data not available bufStream.WriteInt8L( EFalse ); bufStream.CommitL(); CleanupStack::PopAndDestroy(); // bufStream TPckgBuf<TInt> response; User::LeaveIfError( iNotifier->StartOrUpdate( buf->Ptr( 0 ), response ) ); CleanupStack::PopAndDestroy( buf ); return response(); }