/** @SYMTestCaseID PDS-STORE-UT-4056 @SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests. PREQ2505 Insturmentation of PDS. RBufWriteStream & RBufReadStream performance tests. @SYMTestPriority High @SYMTestActions Test for DEF141471 - STORE, new stream performance tests. @SYMTestExpectedResults Test must not fail @SYMDEF DEF141471 */ void BufStreamTestL() { CBufFlat* bufFlat = CBufFlat::NewL(KTestDataLen); CleanupStack::PushL(bufFlat); //RBufWriteStream::Open() RBufWriteStream strm1; CleanupClosePushL(strm1); TUint32 fc = User::FastCounter(); strm1.Open(*bufFlat); TUint32 openFc = CalcTickDiff(fc, User::FastCounter()); PrintFcDiffAsUs(_L("### RBufWriteStream::Open(), Time=%d us\r\n"), openFc); DoStreamWriteTestL(strm1); CleanupStack::PopAndDestroy(&strm1); TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size()); //RBufWriteStream::Append() RBufWriteStream strm2; CleanupClosePushL(strm2); fc = User::FastCounter(); strm2.Append(*bufFlat); TUint32 appendFc = CalcTickDiff(fc, User::FastCounter()); PrintFcDiffAsUs(_L("### RBufWriteStream::Append(), Time=%d us\r\n"), appendFc); DoStreamWriteTestL(strm2); CleanupStack::PopAndDestroy(&strm2); TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size()); //RBufWriteStream::Insert() RBufWriteStream strm3; CleanupClosePushL(strm3); fc = User::FastCounter(); strm3.Insert(*bufFlat, KBufSize); TUint32 insertFc = CalcTickDiff(fc, User::FastCounter()); PrintFcDiffAsUs(_L("### RBufWriteStream::Insert(), Time=%d us\r\n"), insertFc); DoStreamWriteTestL(strm3); CleanupStack::PopAndDestroy(&strm3); TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size()); //RBufWriteStream::Truncate() RBufWriteStream strm4; CleanupClosePushL(strm4); fc = User::FastCounter(); strm4.Truncate(*bufFlat); TUint32 truncateFc = CalcTickDiff(fc, User::FastCounter()); PrintFcDiffAsUs(_L("### RBufWriteStream::Truncate(), Time=%d us\r\n"), truncateFc); DoStreamWriteTestL(strm4); CleanupStack::PopAndDestroy(&strm4); TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size()); RBufReadStream strm5; CleanupClosePushL(strm5); fc = User::FastCounter(); strm5.Open(*bufFlat); openFc = CalcTickDiff(fc, User::FastCounter()); PrintFcDiffAsUs(_L("### RBufReadStream::Open(), Time=%d us\r\n"), openFc); DoStreamReadTestL(strm5); CleanupStack::PopAndDestroy(&strm5); CleanupStack::PopAndDestroy(bufFlat); }
// --------------------------------------------------------- // CDownloadDataClient::MarshalDataL() // --------------------------------------------------------- // HBufC8* CDownloadDataClient::MarshalDataL() const { TInt bufLen = Bytes(); // Size of class including iMediaArray elements. // Note that this includes actual bytes occupied by // contents of descriptors and pointers. bufLen += sizeof(TInt); // We include the count of elements in iMediaArray // while externalizing. bufLen += sizeof(TInt) * iMediaArray.Count(); // iMediaArray has an array iTypes. We are including // count of elements in iTypes array while externalizing // each element of iMediaArray. // Dynamic data buffer CBufFlat* buf = CBufFlat::NewL(bufLen); CleanupStack::PushL(buf); // Stream over the buffer RBufWriteStream stream(*buf); CleanupClosePushL(stream); ExternalizeL(stream); CleanupStack::PopAndDestroy(); //stream // Create a heap descriptor from the buffer HBufC8* des = HBufC8::NewL(buf->Size()); TPtr8 ptr(des->Des()); buf->Read(0, ptr, buf->Size()); CleanupStack::PopAndDestroy(); //buf return des; }
void CReferenceHandler::CreateReferenceObject2L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfObjects = 2; aObjectBuf.ResizeL(KNumOfObjects * 20); //populate the buffer... _LIT8(KRefDesc2, "*Reference Object 2*"); TUint i; for (i=0; i<KNumOfObjects; i++) { aObjectBuf.Write(20*i, KRefDesc2); } //populate the object aObject.SetNameL(KRef2Name); aObject.SetTypeL(KRefType); aObject.SetLengthL(aObjectBuf.Size()); const TTime KRef2Time = TDateTime(2002, EJanuary, 0, 0, 0, 0, 0); aObject.SetTimeL(KRef2Time); // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefIrMCTarget); aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrLength | KObexHdrTime | KObexHdrDescription | KObexHdrTarget); }
// Creates and returns a heap descriptor which holds contents of ’this’ EXPORT_C HBufC8* CRTSecMgrRegisterScriptMsg::PackMsgL() const { // Dynamic data buffer CBufFlat* buf = CBufFlat::NewL(KMaxMsgLength); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); // Stream over the buffer CleanupClosePushL(stream); ExternalizeL(stream); CleanupStack::PopAndDestroy(&stream); // Create a heap descriptor from the buffer HBufC8* des = HBufC8::NewL(buf->Size()); TPtr8 ptr(des->Des()); buf->Read(0, ptr, buf->Size()); CleanupStack::PopAndDestroy(buf); // Finished with the buffer return (des); }
void CReferenceHandler::CreateReferenceObject7L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfAlphabets = 200; aObjectBuf.ResizeL(KNumOfAlphabets * 30); //populate the buffer... TBuf8<4> buf; TUint i; for (i=0; i<KNumOfAlphabets; i++) { buf.Zero(); buf.AppendNumFixedWidth(i, EDecimal, 4); aObjectBuf.Write(30*i, buf); aObjectBuf.Write(30*i + 4, KAlphabet); } //populate the object aObject.SetNameL(KRef7Name); aObject.SetTypeL(KRefImageJpegType); aObject.SetLengthL(aObjectBuf.Size()); const TTime KRef5Time = TDateTime(2001, EFebruary, 14, 15, 38, 24, 0);//set time to 15:38:24.0 on 14th Feb 2001 - obex doesn't transfer microseconds!! aObject.SetTimeL(KRef5Time); _LIT8(KRef1HTTP, "Accept: text/*"); _LIT8(KRef2HTTP, "Location: http://www.w3.org"); _LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT"); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); /* ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); */ CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefSyncMLTarget); aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrTime | KObexHdrLength | KObexHdrHttp | KObexHdrTarget); }
EXPORT_C HBufC8* CSTBencodedList::BencodeL() const { CBufFlat* buf = CBufFlat::NewL(128); CleanupStack::PushL(buf); buf->InsertL(0, _L8("l")); for (TInt i=0; i<iItems.Count(); i++) { HBufC8* bencodedItem = iItems[i]->BencodeL(); CleanupStack::PushL(bencodedItem); buf->InsertL(buf->Size(), *bencodedItem); CleanupStack::PopAndDestroy(); // bencodedItem } buf->InsertL(buf->Size(), _L8("e")); HBufC8* bencodedData = buf->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(); // buf return bencodedData; }
// -------------------------------------------------------------------------- // CUpnpAVDevice::ToDes8L // See upnpavdevice.h // -------------------------------------------------------------------------- EXPORT_C HBufC8* CUpnpAVDevice::ToDes8L() const { // serialize object CBufFlat* tempFlatBuf = CBufFlat::NewL( KBufferGranularity ); CleanupStack::PushL( tempFlatBuf ); RBufWriteStream stream( *tempFlatBuf ); CleanupClosePushL( stream ); stream << *this; // create heap descriptor HBufC8* tempBuf = HBufC8::NewLC( tempFlatBuf->Size() ); TPtr8 ptr( tempBuf->Des() ); tempFlatBuf->Read( 0, ptr, tempFlatBuf->Size() ); // clean up CleanupStack::Pop( tempBuf ); CleanupStack::PopAndDestroy( &stream ); CleanupStack::PopAndDestroy( tempFlatBuf ); return tempBuf; }
// --------------------------------------------------------------------------- // Data package from CatalogsPCConnectivityPlugin // --------------------------------------------------------------------------- // void RCatalogsPCConnectivityClient::PutDataL( const TDataType& aMimeType, const CBufFlat& aData ) { TInt size = aData.Size(); RBuf8 desData; desData.CreateL( size ); desData.CleanupClosePushL(); aData.Read( 0, desData, size ); TPckgBuf<TDataType> pckgMIME( aMimeType ); User::LeaveIfError( SendReceive( ECatalogsPCConnectivityPutData, TIpcArgs( &pckgMIME, &desData, size ) ) ); CleanupStack::Pop(); //desData desData.Close(); }
void CCntFileManagerMsgHandler::DefinitionsOfExistingViewsL(const RMessage2& aMessage) { TFileName fileName; ReadL(aMessage,KSlot0,fileName); if (fileName.Length() == 0) { Server().Controller().DefaultDatabaseL(fileName); } RPointerArray<CContactDefaultViewDefinition> viewDefs; CleanupResetAndDestroyPushL(viewDefs); CCntDbManager* manager = Server().Controller().DbManagerL(fileName); if (manager) { manager->ViewManagerL().GetDefinitionsOfExistingViewsL(viewDefs); } // Compute the size of the buffer that is needed. CBufFlat* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); const TInt32 count = viewDefs.Count(); writeStream << count; for (TInt i = 0; i < count; i++) { writeStream << *viewDefs[i]; } // Check that the client-side write buffer is large enough. TInt length = buffer->Size(); if(aMessage.GetDesMaxLength(1) >= length) { aMessage.WriteL(1, buffer->Ptr(0)); aMessage.Complete(KErrNone); } else { aMessage.Complete(length); } CleanupStack::PopAndDestroy(3, &viewDefs); // writeStream, buffer, viewDefs }
void CReferenceHandler::CreateReferenceObject4L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfAlphabets = 200; aObjectBuf.ResizeL(KNumOfAlphabets * 30); //populate the buffer... TBuf8<4> buf; TUint i; for (i=0; i<KNumOfAlphabets; i++) { buf.Zero(); buf.AppendNumFixedWidth(i, EDecimal, 4); aObjectBuf.Write(30*i, buf); aObjectBuf.Write(30*i + 4, KAlphabet); } //populate the object aObject.SetNameL(KRef4Name); aObject.SetLengthL(aObjectBuf.Size()); // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefTarget); TBuf8<40> param; param.Copy(_L("\x04")); param.Append(_L("\x03")); param.Append(_L("App params 456")); aObject.SetAppParamL(param); aObject.SetHeaderMask(KObexHdrName | KObexHdrLength | KObexHdrDescription | KObexHdrTarget | KObexHdrAppParam); }
void CCntFileManagerMsgHandler::ListDatabasesL(const RMessage2& aMessage) { // Non file-specific. Does not require manager instance. // Client request to list contact databases on a specific or all system // drives. // Return parameter for serialized CDesCArray. CBufFlat* listBuffer; // IPC args thus: // 0 (Return param) - Address of our return buffer // 1 (Param) - The drive number 0 - 25 or ECntAllDrives // 2 (Return param) - The size of buffer we are returning or want to return TInt driveNumber = aMessage.Int1(); // Call controller to retrieve list of databases. if(driveNumber == ECntAllDrives) { Server().Controller().ListDatabasesL(listBuffer); } else { Server().Controller().ListDatabasesL(listBuffer,(TDriveUnit*)&driveNumber); } // Controller will have filled the listBuffer with a serialized // CDesCArray. CleanupStack::PushL(listBuffer); // Size of the buffer we want to return to client. TInt size = listBuffer->Size(); TPckg<TInt> pckg(size); // Write return buffer size to client. aMessage.WriteL(2,pckg); // Only write if client has provided large enough buffer. Client can // call us again with a larger buffer if contents are too large. if(aMessage.GetDesMaxLength(0) >= size) { aMessage.WriteL(0,listBuffer->Ptr(0)); } aMessage.Complete(KErrNone); CleanupStack::PopAndDestroy(listBuffer); }
/** Returns the commandlist to the client from swppolicy. @return A pointer to commandlist. */ void CSsmSwpPolicyServer::CallCommandListL(const RMessage2& aMessage, TInt aSessionIndex) { DEBUGPRINT1(_L("CSsmSwpPolicyServer: CallCommandListL")); __ASSERT_DEBUG(IN_RANGE(aSessionIndex, iSessionInfoArray.Count()), PanicNow(KSsmSwpPolicyBadIdx, KSsmSwpPolicySrvArrayIndexInvalid)); __ASSERT_DEBUG(iSessionInfoArray[aSessionIndex].iSsmSwpPolicyStepCompletion != NULL, PanicNow(KSsmSwpPolicyServer, ESsmSwpPolicyServerError4)); // CommandList should be called only after preparing the command list, so the active object state should be EPrepareCommandList. __ASSERT_DEBUG(iSessionInfoArray[aSessionIndex].iSsmSwpPolicyStepCompletion->CurrentStep() == CSsmSwpPolicyServer::CSsmSwpPolicyStepCompletion::EPrepareCommandList, PanicNow(KSsmSwpPolicyServer, ESsmSwpPolicySrvStepError3)); // CSsmSwpPolicyFrame checks whether initialize is called before CallCommandList is called, so no need to check // for valid iSsmSwpPolicyStepCompletion pointer. // Sets the current step to CallCommandList iSessionInfoArray[aSessionIndex].iSsmSwpPolicyStepCompletion->SetCurrentStep(CSsmSwpPolicyServer::CSsmSwpPolicyStepCompletion::ECallCommandList); CSsmCommandList* ssmCmdList = (iSessionInfoArray[aSessionIndex].iSwpPolicy)->CommandList(); CleanupStack::PushL(ssmCmdList); CBufFlat* buf = CBufFlat::NewL(KSsmSwpPolicyStreamBufMaxSize); CleanupStack::PushL(buf); RBufWriteStream writeStream(*buf); CleanupClosePushL(writeStream); DEBUGPRINT1(_L("CSsmSwpPolicyServer: Externalizes the commandlist")); ssmCmdList->ExternalizeL(writeStream); // Ensure any memory that might already have been allocated is disposed of. // Transfer the streamed cmd list from the CBuf. RBuf8 cmdListBuf; cmdListBuf.CreateL(buf->Size()); CleanupClosePushL(cmdListBuf); buf->Read(0, cmdListBuf); aMessage.WriteL(0, cmdListBuf); aMessage.Complete(KErrNone); CleanupStack::PopAndDestroy(4, ssmCmdList); // buf, writeStream and cmdListBuf }
void CNcdProtocolDefaultObserver::ConfigurationActionRequestL( MNcdConfigurationProtocolActionRequest* aActionRequest ) { DLTRACEIN(("")); CleanupDeletePushL( aActionRequest ); if( aActionRequest->Type() == MNcdConfigurationProtocolActionRequest::ETypeUpdate && aActionRequest->UpdateDetails() ) { DLTRACE(( "Update" )); DLINFO(( _L("Target: %S"), &aActionRequest->Target() )); DLINFO(( _L("Id: %S"), &aActionRequest->UpdateDetails()->Id() )); DLINFO(( _L("Version: %S"), &aActionRequest->UpdateDetails()->Version() )); DLINFO(( _L("Uri: %S"), &aActionRequest->UpdateDetails()->Uri() )); DLINFO(( "Forced: %d", aActionRequest->Force() )); DLINFO(( "Client SID %08x", iContext.SecureId().iId )); if ( aActionRequest->Target() == KNcdActionTargetMasterServerUri && aActionRequest->UpdateDetails()->Uri().Length() ) { const TDesC& currentMaster( iConfigurationManager.MasterServerAddressL( iContext ) ); // Ensure that request was received from the master server if ( *iServerUri == currentMaster ) { /** * @ Improve this check to notice missing '/' at the end of the URIs */ if ( aActionRequest->UpdateDetails()->Uri() != currentMaster ) { DLINFO(("Updating MasterServerUri")); iConfigurationManager.SetMasterServerAddressL( iContext, aActionRequest->UpdateDetails()->Uri(), 0 ); } else { DLINFO(("MasterServerUri didn't change")); } } else { DLERROR(( _L("Invalid update request source! Request source: %S"), iServerUri )); } } else if( aActionRequest->Target() == KNcdActionTargetSkin || aActionRequest->Target() == KNcdActionTargetClient ) { HBufC* msgQueueName = HBufC::NewLC( KCatalogsUpdateQueueNameFormat().Length() + 8 ); msgQueueName->Des().Format( KCatalogsUpdateQueueNameFormat, iContext.SecureId().iId ); DLINFO(( _L("Opening client's update message queue: %S"), msgQueueName )); RMsgQueueBase queue; TInt err = queue.OpenGlobal( *msgQueueName ); if( err == KErrNone ) { CleanupClosePushL( queue ); TInt msgSize = queue.MessageSize(); // Prepare a buffer to write to update information P&S variable. CBufFlat* buffer = CBufFlat::NewL( KCatalogsUpdateInformationMaxSize + msgSize ); CleanupStack::PushL( buffer ); // Externalize the info to the buffer. RBufWriteStream stream( *buffer ); CleanupClosePushL( stream ); stream << (TInt32)(aActionRequest->Target().Size() + aActionRequest->UpdateDetails()->Id().Size() + aActionRequest->UpdateDetails()->Version().Size() + aActionRequest->UpdateDetails()->Uri().Size() + sizeof( TInt32 )); stream << aActionRequest->Target(); stream << aActionRequest->UpdateDetails()->Id(); stream << aActionRequest->UpdateDetails()->Version(); stream << aActionRequest->UpdateDetails()->Uri(); stream << (TInt32)aActionRequest->Force(); // Write the update information to the client's update message queue. TInt bytesToSend = buffer->Size(); for( TInt sendPos = 0; sendPos < bytesToSend; sendPos += msgSize ) { const TUint8* sendPtr = buffer->Ptr( sendPos ).Ptr(); queue.SendBlocking( sendPtr, msgSize ); } DLINFO(( "Update information sent to message queue" )); CleanupStack::PopAndDestroy( 3, &queue ); // stream-close, buffer, queue } // Clean up the local info buffer. CleanupStack::PopAndDestroy( msgQueueName ); } else { DLINFO(("Unknown Action target")); } } // Action request no longer needed, delete it. CleanupStack::PopAndDestroy( aActionRequest ); }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::GetRunningProcessesL // ---------------------------------------------------------------------------------------- CBufFlat* CTerminalControlServer::GetRunningProcessesL( ) { RDEBUG("CTerminalControlServer::GetRunningProcessesL"); TFullName processName; TFindProcess findProcess; CBufFlat *buffer = CBufFlat::NewL(128); iProcessInfoArray->Reset(); while( KErrNone == findProcess.Next( processName ) ) { TTcProcessInfo info; RProcess process; if( KErrNone == process.Open( findProcess ) ) { // // Add process information to local array // info.iProcessName = processName; info.iFileName = process.FileName(); info.iHandle = process.Handle(); info.iId = process.Id(); info.iSecureId = process.SecureId(); info.iProtected = EFalse; process.GetMemoryInfo( info.iMemoryInfo ); User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); if( !info.iCodeInRom ) { User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); } iProcessInfoArray->AppendL( info ); // // Add process also to return buffer // /* TInt appendPosition = buffer->Size(); if(iProcessInfoArray->Count() >= 2) { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, proName); } else { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, proName); } } */ // Enumerate names from 1 TInt appendPosition = buffer->Size(); TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf; TBuf8<sizeof(KFormatProcessNamePrefix)+20> nameBuf; numBuf.Num(iProcessInfoArray->Count()); nameBuf.Zero(); nameBuf.Append(KFormatProcessNamePrefix); nameBuf.Append(numBuf); if(iProcessInfoArray->Count() >= 2) { buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, nameBuf); } else { buffer->InsertL(appendPosition, nameBuf); } } } /* TUint32 flags = Exec::ProcessFlags(KCurrentProcessHandle); if (flags & KProcessFlagSystemPermanent) return ESystemPermanent; if (flags & KProcessFlagSystemCritical) return ESystemCritical; if (flags & KThreadFlagProcessPermanent) return EAllThreadsCritical; return ENotCritical; */ return buffer; }
// --------------------------------------------------------- // CMmsSession::SendMessageL // --------------------------------------------------------- // EXPORT_C void CMmsSession::SendMessageL( const TDesC& aUri, CBufFlat& aMessageBuffer, MMmsCodecDataSupplier& aDataSupplier, MMmsCodecDataSink& aDataSink, TRequestStatus& aStatus ) { LOG( _L("CMmsSession::SendMessageL ") ); __ASSERT_DEBUG( iSessionStatus == ESessionIdle, gPanic(EMmsAlreadyBusy) ); TInt method = HTTP::EPOST; iDataSupplier = &aDataSupplier; iDataSink = &aDataSink; iRequestStatus = &aStatus; // Check if the buffer is empty if ( aMessageBuffer.Size() == 0 ) { aStatus = KRequestPending; User::RequestComplete( iRequestStatus, KMmsErrorBufferEmpty ); } // Check if we are connected else if ( !iConnected ) { aStatus = KRequestPending; User::RequestComplete( iRequestStatus, KMmsErrorSessionNotOpen ); } else { // Start the sending procedures if ( !iTransaction ) { iTransaction = CMmsTransaction::NewL(); } iTransaction->ExecuteL( iHTTPSession, *iTransferControl, aUri, method, aMessageBuffer, iTransactionTimeout, iMaxReceiveSize, 0, // "expected receive size" not needed for sending *iDataSupplier, *iDataSink, iStatus ); aStatus = KRequestPending; iSessionStatus = ESessionSending; SetActive(); } }
// --------------------------------------------------------- // CT_LbsClientPosTp261::StartL // // (other items were commented in a header). // --------------------------------------------------------- // void CT_LbsClientPosTp261::StartL() { _LIT(KService1, "Service1"); _LIT(KService2, "Service2"); _LIT(KService3, "Service3"); _LIT(KContact1, "Contact1"); _LIT(KContact2, "Contact2"); _LIT(KContact3, "Contact3"); CRequestor* serviceId1 = CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService1); CRequestor* serviceId2 = CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService2); CRequestor* serviceId3 = CRequestor::NewL(CRequestor::ERequestorService, CRequestor::EFormatApplication, KService3); CRequestor* contactId1 = CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatTelephone, KContact1); CRequestor* contactId2 = CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatUrl, KContact2); CRequestor* contactId3 = CRequestor::NewL(CRequestor::ERequestorContact, CRequestor::EFormatMail, KContact3); RRequestorStack stack = RRequestorStack(); CleanupStack::PushL(TCleanupItem(CleanOp ,&stack)); CleanupStack::PushL(serviceId1); CleanupStack::PushL(serviceId2); CleanupStack::PushL(serviceId3); CleanupStack::PushL(contactId1); CleanupStack::PushL(contactId2); CleanupStack::PushL(contactId3); ConnectL(); OpenPositioner(); stack.Append(serviceId1); stack.Append(contactId1); stack.Append(contactId2); stack.Append(serviceId2); stack.Append(contactId3); stack.Append(serviceId3); CleanupStack::Pop(contactId3); CleanupStack::Pop(contactId2); CleanupStack::Pop(contactId1); CleanupStack::Pop(serviceId3); CleanupStack::Pop(serviceId2); CleanupStack::Pop(serviceId1); TInt err = iPositioner.SetRequestor(stack); if (err != KErrNone) { _LIT(KErrorAndLeave, "Problems setting requestorstack"); LogErrorAndLeaveL(KErrorAndLeave); } const TInt KPosBufFlatExpandSize = 100; //ExternalizeL CBufFlat* bufFlat = CBufFlat::NewL(KPosBufFlatExpandSize); CleanupStack::PushL(bufFlat); RBufWriteStream stream(*bufFlat); CleanupClosePushL(stream); stack.ExternalizeL(stream); TPtr8 dataPtr((TUint8*)NULL, 0); dataPtr.Set(bufFlat->Ptr(0)); CleanupStack::PopAndDestroy(&stream); HBufC8* tempBuf = HBufC8::NewLC(bufFlat->Size()); TPtr8 ptr = tempBuf->Des(); ptr = dataPtr; //Internalize bufFlat->InsertL(0, ptr); RBufReadStream rstream(*bufFlat); CleanupClosePushL(rstream); RRequestorStack stack2 = RRequestorStack(); CleanupStack::PushL(TCleanupItem(CleanOp ,&stack2)); stack2.InternalizeL(rstream); // Verify the requestor stack VerifyRequestorStackL(stack2); _LIT(KResult, "The RequestorStack is correct after Externalize/Internalize"); INFO_PRINTF1(KResult); CleanupStack::PopAndDestroy(1); // CleanupOp stack2 CleanupStack::PopAndDestroy(&rstream); CleanupStack::PopAndDestroy(tempBuf); CleanupStack::PopAndDestroy(bufFlat); CleanupStack::PopAndDestroy(1); // CleanupOp stack1 ClosePositioner(); Disconnect(); }
void CSTTrackerConnection::CreateUriL() { TInetAddr localAddress; TInt getAddressRes = KErrGeneral; // only send IP if we are connected via proxy //if (Preferences()->IncomingConnectionsMode() == EEnabledWithProxy) // getAddressRes = iNetMgr->Address(localAddress); CBufFlat* uriBuf = CBufFlat::NewL(512); CleanupStack::PushL(uriBuf); //TPtrC8 activeTracker = iTorrent.AnnounceList()->ActiveAddress(); //LWRITE(iLog, _L("Active tracker: ")); //LWRITELN(iLog, activeTracker); uriBuf->InsertL(uriBuf->Size(), *iAddress); uriBuf->InsertL(uriBuf->Size(), _L8("?")); uriBuf->InsertL(uriBuf->Size(), _L8("info_hash=")); HBufC8* encoded = EscapeUtils::EscapeEncodeL(iTorrent.InfoHash(), EscapeUtils::EEscapeUrlEncoded); CleanupStack::PushL(encoded); uriBuf->InsertL(uriBuf->Size(), *encoded); CleanupStack::PopAndDestroy(); // encoded uriBuf->InsertL(uriBuf->Size(), _L8("&peer_id=")); encoded = EscapeUtils::EscapeEncodeL(TorrentMgr()->PeerId(), EscapeUtils::EEscapeUrlEncoded); CleanupStack::PushL(encoded); uriBuf->InsertL(uriBuf->Size(), *encoded); CleanupStack::PopAndDestroy(); // encoded uriBuf->InsertL(uriBuf->Size(), _L8("&key=")); TBuf8<32> keyBuf; keyBuf.Num(TorrentMgr()->Key()); uriBuf->InsertL(uriBuf->Size(), keyBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&port=")); TBuf8<32> portBuf; if (getAddressRes == KErrNone) portBuf.Num(localAddress.Port()); else portBuf.Num(Preferences()->IncomingPort()); uriBuf->InsertL(uriBuf->Size(), portBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&uploaded=")); TBuf8<24> bytesUploaded; bytesUploaded.Num(iTorrent.BytesUploaded()); uriBuf->InsertL(uriBuf->Size(), bytesUploaded); uriBuf->InsertL(uriBuf->Size(), _L8("&downloaded=")); TBuf8<24> bytesDownloaded; bytesDownloaded.Num(iTorrent.BytesDownloaded()); uriBuf->InsertL(uriBuf->Size(), bytesDownloaded); uriBuf->InsertL(uriBuf->Size(), _L8("&left=")); TBuf8<24> bytesLeft; bytesLeft.Num(iTorrent.BytesLeft()); uriBuf->InsertL(uriBuf->Size(), bytesLeft); // it seems that some trackers support only compact responses uriBuf->InsertL(uriBuf->Size(), _L8("&compact=1")); if (iEvent != ETrackerEventNotSpecified) { uriBuf->InsertL(uriBuf->Size(), _L8("&event=")); switch (iEvent) { case ETrackerEventStarted: uriBuf->InsertL(uriBuf->Size(), _L8("started")); break; case ETrackerEventStopped: uriBuf->InsertL(uriBuf->Size(), _L8("stopped")); break; case ETrackerEventCompleted: uriBuf->InsertL(uriBuf->Size(), _L8("completed")); break; default: break; } } if (getAddressRes == KErrNone) { TBuf<64> ipBuf; localAddress.Output(ipBuf); TBuf8<64> ipBuf8; ipBuf8.Copy(ipBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&ip=")); uriBuf->InsertL(uriBuf->Size(), ipBuf8); #ifdef LOG_TO_FILE // debug info LWRITE(iLog, _L("Sent to tracker: ")); LWRITE(iLog, ipBuf); TBuf8<32> portBuf; portBuf.Num(localAddress.Port()); LWRITE(iLog, _L(":")); LWRITELN(iLog, portBuf); #endif // } iUri = uriBuf->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(); // uriBuf //iLog->WriteL(_L("[Trackerconnection] GET ")); //iLog->WriteLineL(*iUri); }
void CReferenceHandler::CreateReferenceObject3L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfAlphabets = 1000; aObjectBuf.ResizeL(KNumOfAlphabets * 30); //populate the buffer... TBuf8<4> buf; TUint i; for (i=0; i<KNumOfAlphabets; i++) { buf.Zero(); buf.AppendNumFixedWidth(i, EDecimal, 4); aObjectBuf.Write(30*i, buf); aObjectBuf.Write(30*i + 4, KAlphabet); } //populate the object aObject.SetNameL(KRef3Name); aObject.SetTypeL(KRefRichTextType); aObject.SetLengthL(aObjectBuf.Size()); const TTime KRef3Time = TDateTime(2002, EJanuary, 0, 0, 0, 0, 0); aObject.SetTimeL(KRef3Time); // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefTarget); CObexHeader* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x30, KRef1Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x36, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x3F, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xB0, 0x03); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xBF, 0x12); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xF0, 0x54); aObject.AddHeaderL(*header); CleanupStack::Pop(header); // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic // 0x2F header doesnt have a FourByte HI Type. /* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0x2F, 0x54); aObject.AddHeaderL(*header); CleanupStack::Pop(header); */ header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xFF, 0x43); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByteSeqL(0x73, KRefTarget); aObject.AddHeaderL(*header); CleanupStack::Pop(header); aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrLength | KObexHdrTime | KObexHdrDescription | KObexHdrTarget | KObexHdrUserDefined); }
void CReferenceHandler::CreateReferenceObject1L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfAlphabets = 2; aObjectBuf.ResizeL(KNumOfAlphabets * 30); //populate the buffer... TBuf8<4> buf; TUint i; for (i=0; i<KNumOfAlphabets; i++) { buf.Zero(); buf.AppendNumFixedWidth(i, EDecimal, 4); aObjectBuf.Write(30*i, buf); aObjectBuf.Write(30*i + 4, KAlphabet); } //populate the object aObject.SetNameL(KRef2Name); // check the deletecurrentheader method aObject.SetNameL(KRef1Name); _LIT8(KRef1HTTP, "Accept: text/*"); _LIT8(KRef2HTTP, "Location: http://www.w3.org"); _LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT"); // add Http header using old API // /* aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); // USE THE HEADER MASK TO REMOVE HTTP HEADERS FROM HEADERSET // THIS DOES NOT REMOVE THE ITEMS FROM iHttp LIST - this tests // the Http() function which should remove items from iHttp list // TObexMatchHeader* headerMask = new(ELeave) TObexMatchHeader; headerMask->SetHeader(TObexInternalHeader::EName); aObject.HeaderSet().SetMask(headerMask); aObject.HeaderSet().DeleteMasked(); aObject.HeaderSet().SetMask(NULL); delete headerMask; */ aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef3HTTP); /* if (aObject.Http()) { NULL; } */ // add a Count header using new API // CObexHeader* tempheader = CObexHeader::NewL(); CleanupStack::PushL(tempheader); tempheader->SetFourByte(TObexInternalHeader::ECount, 0xFE22FF54); aObject.AddHeaderL(*tempheader); CleanupStack::Pop(tempheader); // add an Http header using new API // tempheader = CObexHeader::NewL(); CleanupStack::PushL(tempheader); tempheader->SetByteSeqL(TObexInternalHeader::EHttp, KRef1HTTP); aObject.AddHeaderL(*tempheader); CleanupStack::Pop(tempheader); aObject.SetTypeL(KRefType); // set again to check header update functionality aObject.SetTypeL(KRefType); aObject.SetLengthL(aObjectBuf.Size()); // set again to check header update functionality aObject.SetLengthL(aObjectBuf.Size()); TBuf8<40> param; param.Copy(_L("\x04")); param.Append(_L("\x03")); param.Append(_L("App params 123")); aObject.SetAppParamL(param); // set again to check header update functionality aObject.SetAppParamL(param); const TTime KRef1Time = TDateTime(2003, EApril, 29, 10, 10, 10, 0); aObject.SetTimeL(KRef1Time); // set again to check header update functionality aObject.SetTimeL(KRef1Time); // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); // set again to check header update functionality aObject.SetDescriptionL(ptr); CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefTarget); // set again to check header update functionality aObject.SetTargetL(KRefTarget); CObexHeader* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x30, KRef1Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(TObexInternalHeader::ECreatorID, 0x5F3A2343); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x36, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByteSeqL(TObexInternalHeader::EWanUUID, KRefTarget); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x3F, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xB0, 0x03); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xBF, 0x12); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xBE, 0x12); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xF0, 0x54545454); aObject.AddHeaderL(*header); CleanupStack::Pop(header); // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic // 0x2F header doesnt have a FourByte HI Type. /* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0x2F, 0x54); aObject.AddHeaderL(*header); CleanupStack::Pop(header); */ header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xFF, 0x00111243); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByteSeqL(0x73, KRefTarget); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByteSeqL(TObexInternalHeader::EObjectClass, KRefTarget); aObject.AddHeaderL(*header); CleanupStack::Pop(header); aObject.SetHeaderMask(KObexHdrName |KObexHdrType | KObexHdrLength | KObexHdrTime | KObexHdrDescription | KObexHdrTarget | KObexHdrHttp | KObexHdrCount | KObexHdrAppParam | KObexHdrUserDefined | KObexHdrObjectClass | KObexHdrWanUUID | KObexHdrCreatorID); }
void CReferenceHandler::CreateReferenceObject6L(CObexBufObject& aObject, CBufFlat& aObjectBuf, TTransport aTransport) { //Reset the object (also resets the buffer) aObject.Reset(); const TUint KNumOfAlphabets = 200; aObjectBuf.ResizeL(KNumOfAlphabets * 30); //populate the buffer... TBuf8<4> buf; TUint i; for (i=0; i<KNumOfAlphabets; i++) { buf.Zero(); buf.AppendNumFixedWidth(i, EDecimal, 4); aObjectBuf.Write(30*i, buf); aObjectBuf.Write(30*i + 4, KAlphabet); } //populate the object aObject.SetNameL(KRef6Name); aObject.SetTypeL(KRefImageJpegType); aObject.SetLengthL(aObjectBuf.Size()); const TTime KRef5Time = TDateTime(2001, EFebruary, 14, 15, 38, 24, 0);//set time to 15:38:24.0 on 14th Feb 2001 - obex doesn't transfer microseconds!! aObject.SetTimeL(KRef5Time); _LIT8(KRef1HTTP, "Accept: text/*"); _LIT8(KRef2HTTP, "Location: http://www.w3.org"); _LIT8(KRef3HTTP, "Date: Tue, 10 Nov 2002 09:17:21 GMT"); /* TObexMatchHeader* headerMask = new(ELeave) TObexMatchHeader; headerMask->SetHeader(TObexInternalHeader::EName); aObject.HeaderSet().SetMask(headerMask); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef3HTTP); if (aObject.Http()) { NULL; } aObject.HeaderSet().SetMask(headerMask); aObject.HeaderSet().DeleteMasked(); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef3HTTP); if (aObject.Http()) { NULL; } aObject.HeaderSet().SetMask(headerMask); aObject.HeaderSet().DeleteMasked(); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef3HTTP); if (aObject.Http()) { NULL; } aObject.HeaderSet().SetMask(headerMask); aObject.HeaderSet().DeleteMasked(); delete headerMask; */ aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef3HTTP); aObject.AddHttpL(KRef1HTTP); aObject.AddHttpL(KRef2HTTP); aObject.AddHttpL(KRef2HTTP); /* if (aObject.Http()) { NULL; } aObject.HeaderSet().SetMask(NULL); */ // Set up the MF description header const TUint KDescLength = ( (aTransport==EBluetooth?KObexPacketDefaultSize:2044) - KObexPacketHeaderSize - 5 - 5)/sizeof(TText); // Size in characters HBufC* descBuf = HBufC::NewLC(KDescLength); /* ASSERT(descBuf); TPtr ptr(descBuf->Des()); ptr.Zero(); for (i=0; i<KDescLength; i++) { ptr.AppendNumFixedWidth(i%10, EDecimal, 1); } aObject.SetDescriptionL(ptr); */ CleanupStack::PopAndDestroy(descBuf); aObject.SetTargetL(KRefTarget); CObexHeader* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x30, KRef1Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x36, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetUnicodeL(0x3F, KRef5Name); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xB0, 0x03); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByte(0xBF, 0x12); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xF0, 0x54); aObject.AddHeaderL(*header); CleanupStack::Pop(header); // THIS NEXT HEADER IS A NEGATIVE TEST. It should cause a panic // 0x2F header doesnt have a FourByte HI Type. /* header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0x2F, 0x54); aObject.AddHeaderL(*header); CleanupStack::Pop(header); */ header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetFourByte(0xFF, 0x43); aObject.AddHeaderL(*header); CleanupStack::Pop(header); header = CObexHeader::NewL(); CleanupStack::PushL(header); header->SetByteSeqL(0x73, KRefTarget); aObject.AddHeaderL(*header); CleanupStack::Pop(header); aObject.SetHeaderMask(KObexHdrName | KObexHdrType | KObexHdrTime | KObexHdrLength | KObexHdrHttp | KObexHdrTarget | KObexHdrUserDefined ); }