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; }
int main() { __UHEAP_MARK; int retval =ESuccess; wchar_t* mywcharstring = NULL; RBuf8 myRBuf; myRBuf.CreateL(10); myRBuf.CleanupClosePushL(); retval = WcharToRbuf8 (mywcharstring, myRBuf); if (retval == EInvalidPointer) { printf("wchartorbuf8 negative1 Passed\n"); } else { assert_failed = true; printf("wchartorbuf8 negative1 Failed\n"); } CleanupStack::PopAndDestroy(1); __UHEAP_MARKEND; testResultXml("test_wchartorbuf8_negative1"); return 0; }
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; }
void CSifTransportServer::ConstructL(const TDesC& aServerName, TInt aShutdownPeriodUs) /** Second-phase construction initializes the superclass and starts the server. */ { // Define a key (KSifOperationKey) which would be used to notify the client of any new operations. TInt ret = RProperty::Define(KUidSystemCategory, KSifOperationKey, RProperty::EByteArray, KSecurityPolicyWDD, KSecurityPolicyNone,(sizeof(TInt) * KMaxNumberOfOperations)); if (ret != KErrAlreadyExists && ret != KErrNone) { User::Leave(ret); } if(ret == KErrNone) { // Create a empty CSifOperationKey object and publish it. CSifOperationKey* nullKey = CSifOperationKey::NewL(); CleanupStack::PushL(nullKey); RBuf8 nullKeyBuffer; nullKeyBuffer.CleanupClosePushL(); ExternalizeRefObjectL(*nullKey, nullKeyBuffer); User::LeaveIfError(RProperty::Set(KUidSystemCategory, KSifOperationKey, nullKeyBuffer)); CleanupStack::PopAndDestroy(2, nullKey); } CScsServer::ConstructL(aShutdownPeriodUs); StartL(aServerName); }
// --------------------------------------------------------------------------- // Data request from CatalogsPCConnectivityPlugin // First ask the size from server, then give correct size CBufFlat // --------------------------------------------------------------------------- // void RCatalogsPCConnectivityClient::GetDataL( TDataType& aMimeType, CBufFlat& aData ) { TPckgBuf<TInt> pckgSize; TPckgBuf<TDataType> pckgMIME; User::LeaveIfError( SendReceive( ECatalogsPCConnectivityGetSize, TIpcArgs( &pckgMIME, &pckgSize ) ) ); TInt size = pckgSize(); aMimeType = pckgMIME(); RBuf8 desData; desData.CreateL( size ); desData.CleanupClosePushL(); User::LeaveIfError( SendReceive( ECatalogsPCConnectivityGetData, TIpcArgs( &desData ) ) ); aData.Reset(); aData.ExpandL( 0, size ); aData.Write( 0, desData, size ); CleanupStack::Pop(); //desData desData.Close(); }
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() { __UHEAP_MARK; int retval =ESuccess; char* mycharstring = "Hello Char String"; int char_length= strlen(mycharstring); RBuf8 myRBuf; myRBuf.CreateL(30); myRBuf.CleanupClosePushL(); retval = CharToRbuf8 (mycharstring, myRBuf); int buf_len = myRBuf.Length(); if (retval ==ESuccess &&\ char_length == buf_len &&\ strncmp("Hello Char String",(char*)myRBuf.Ptr() , 17) ==0 ) { printf("CharToRbuf8 content check Passed\n"); } else { assert_failed = true; printf("CharToRbuf8 content check Failed\n"); } CleanupStack::PopAndDestroy(1); __UHEAP_MARKEND; testResultXml("test_chartorbuf8_content_check"); return 0; }
// --------------------------------------------------------------------------- // 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(); }
QNdefMessage QNFCNdefUtility::CNdefMsg2QNdefMsgL( const CNdefMessage& msg ) { BEGIN QNdefMessage result; LOG("CNdefMessage size is "<<msg.SizeL()); HBufC8* newBuf = HBufC8::NewL(msg.SizeL()); RBuf8 buf; buf.Assign(newBuf); buf.CleanupClosePushL(); LOG("export msg to raw data"); msg.ExportRawDataL(buf,0); LOG("import raw data to msg"); QByteArray qtArray; qtArray.append(reinterpret_cast<const char*>(newBuf->Ptr()),newBuf->Size()); result = QNdefMessage::fromByteArray(qtArray); CleanupStack::PopAndDestroy(&buf); END return result; }
/** Adds a child part to this part and set the content to the same content stored in the input file handle /param aProperties the headers of the newly added part /param aFile file handle that contains the content. /note This method leaves with KErrNotSupported if it is NOT multi-part, i.e. this part already has content. */ EXPORT_C CMsgStoreMessagePart* CMsgStoreMessagePart::AddChildPartL( const CMsgStorePropertyContainer& aProperties, RFile& aFile ) { RBuf8 serializedProperties; serializedProperties.CleanupClosePushL(); aProperties.SerializeL( serializedProperties ); TInt partId = iContext.iSession.CreateContainerL( Id(), KMsgStoreInvalidId, //do not check grand parent id iMailBoxId, EMsgStorePartBits, serializedProperties, ETrue, aFile ); CMsgStoreMessagePart* part = CMsgStoreMessagePart::NewL( iContext, partId, Id(), iMailBoxId, serializedProperties ); CleanupStack::PopAndDestroy( &serializedProperties ); return part; }
void CDnsUpdateOption::ToStringL(RBuf8& aBuf8) const /** * Writes DNS update option data to a string suitable for sending out * on to the network * * @internalTechnology * */ { RBuf8 encodedDomainName; encodedDomainName.CleanupClosePushL(); TDomainNameArray domainNames; CleanupClosePushL(domainNames); domainNames.AppendL(iDomainName); CDomainNameCodec* domainNameEncoder = new(ELeave) CDomainNameCodec(); CleanupStack::PushL(domainNameEncoder); domainNameEncoder->EncodeL(domainNames, encodedDomainName); CleanupStack::PopAndDestroy(domainNameEncoder); CleanupStack::PopAndDestroy(&domainNames); // closes the RBuf8 aBuf8.Zero(); aBuf8.ReAllocL( 3 + encodedDomainName.Length() ); aBuf8.Append((TChar)(iFlags.Value())); aBuf8.Append((TChar)iRCode1); aBuf8.Append((TChar)iRCode2); aBuf8.Append(encodedDomainName); CleanupStack::PopAndDestroy(&encodedDomainName); // closes the array }
int main() { __UHEAP_MARK; int retval =ESuccess; wchar_t* mywcharstring = L"Hello Widechar String"; RBuf8 myRBuf; myRBuf.CreateL(50); myRBuf.CleanupClosePushL(); retval = WcharToRbuf8(mywcharstring, myRBuf); if (retval ==ESuccess) { printf("wchartorbuf8 positive1 Passed\n"); } else { assert_failed = true; printf("wchartorbuf81 Failed\n"); } CleanupStack::PopAndDestroy(1); __UHEAP_MARKEND; testResultXml("test_wchartorbuf8_positive1"); return 0; }
TVerdict CBigSendRecvRtp::doTestStepL() /** * @return - TVerdict code */ { SetTestStepResult(EFail); if(KErrNone == InitSocketsL()) { iIpAddrDest1.SetPort(9000); RBuf8 sendBuf; sendBuf.CreateMax(KBufferSize1); sendBuf.CleanupClosePushL(); RBuf8 recvBuf; recvBuf.CreateMax(KBufferSize1); recvBuf.CleanupClosePushL(); /* Fill the buffer with given character upto its length */ sendBuf.Fill('Q'); TRequestStatus status; /* do a Send of the data */ iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Now do a Receive */ recvBuf.FillZ(); iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Obtain a TPtr of the data excluding the RTP header */ TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize); TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize); /* Check if the data received is the same as the data sent */ TInt ret = sendBufPtr.Compare(recvBufPtr); if(ret == 0) { /* Increase the buffer size and fill it up with given data */ sendBuf.ReAlloc(KBufferSize2); recvBuf.ReAlloc(KBufferSize2); sendBuf.Fill('Q', KBufferSize2); /* Send the larger data */ iRtpSocket.SendTo(sendBuf, iIpAddrDest1, NULL, status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Now do a Receive */ recvBuf.FillZ(KBufferSize2); iRtpSocket.RecvFrom(recvBuf,iIpAddrDest1,NULL,status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); /* Get pointer to data and compare both of them */ TPtr8 sendBufPtr = sendBuf.MidTPtr(KRtpHeaderSize); TPtr8 recvBufPtr = recvBuf.MidTPtr(KRtpHeaderSize); TInt ret = sendBufPtr.Compare(recvBufPtr); if(ret == 0) { SetTestStepResult(EPass); } } CleanupStack::PopAndDestroy(2); } return TestStepResult(); }
// --------------------------------------------------------------------------- // CRoHandlerDMgrWrapper::DoSaveRoapTriggerL // --------------------------------------------------------------------------- // void CRoHandlerDMgrWrapper::DoSaveRoapTriggerL( TMeterState aNextState ) { // Check success of download DRMDEBUG2( RoHdlrDMgrWrDebugLiterals::KFormatDoDlHdlRoapTrigL(), &RoHdlrDMgrWrDebugLiterals::KStrDlFinished() ); try { // Fetch download created in DoDownloadRoapTriggerL QString downloadUrl((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length()); //uncomment iDownload = NULL; //iDlMgr->findDownload( downloadUrl ); } catch(const std::exception& exception) { qt_symbian_exception2LeaveL(exception); } // Delete trigger URL so that it is possible to check // whether or not meteringResponse has PrUrl. delete iTriggerUrl; iTriggerUrl = NULL; RFile roapTrigger; if ( !iDownloadSuccess ) { if ( iConnectionError ) { User::Leave( KErrCouldNotConnect ); } else { User::Leave( KErrGeneral ); } } User::LeaveIfError( roapTrigger.Open( iFs, *iFileName, EFileShareReadersOrWriters ) ); CleanupClosePushL( roapTrigger ); // Get filehandle of ROAP trigger const TInt KReadBufSize = 512; RBuf8 readBuf; readBuf.CleanupClosePushL(); readBuf.CreateL( KReadBufSize ); // Read file to buffer TInt triggerFileSize( 0 ); User::LeaveIfError( roapTrigger.Size( triggerFileSize ) ); if ( iTriggerBuf ) { delete iTriggerBuf; iTriggerBuf = NULL; } iTriggerBuf = HBufC8::NewL( triggerFileSize ); User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) ); iTriggerBuf->Des().Copy( readBuf ); while ( readBuf.Length() == KReadBufSize ) { User::LeaveIfError( roapTrigger.Read( readBuf, KReadBufSize ) ); iTriggerBuf->Des().Append( readBuf ); } // And let ROAP handle it... CleanupStack::PopAndDestroy( &readBuf ); CleanupStack::PopAndDestroy( &roapTrigger ); iFs.Delete( *iFileName ); delete iFileName; iFileName=NULL; Continue( aNextState, KErrNone ); }
// second-phase constructor void CServerCrashDataSource::ConstructL() { LOG_MSG("->CServerCrashDataSource::ConstructL()\n" ); // Get the debug func block and make appropriate changes to our structures TInt err; TUint32 bufsize = 0; LOG_MSG( " -> iSecSess->GetDebugFunctionalityBufSize( &bufsize )\n" ); err = iSecSess.GetDebugFunctionalityBufSize( &bufsize ); if( (err != KErrNone) || (0 == bufsize) ) { // No debug functionality block, cannot do much without that. LOG_MSG2("CServerCrashDataSource::ConstructL() - unable to get debug functionality block! err:%d\n", err); User::Leave( KErrNotSupported ); } RBuf8 DFBlock; DFBlock.CreateL(bufsize); DFBlock.CleanupClosePushL(); LOG_MSG2( " -> HBufC8::NewLC( bufsize=%d )\n", bufsize ); LOG_MSG("CServerCrashDataSource::ConstrucL -> GetDebugFunctionality()\n" ); err = iSecSess.GetDebugFunctionality(DFBlock); if( KErrNone != err ) { LOG_MSG( "CServerCrashDataSource::ConstructL() : ERROR !* : Could not retrieve debug functionality block\n" ); User::Leave( KErrNotSupported ); } LOG_MSG( " -> GetDebugHeader( EDF_TagHdrId_RegistersCore )\n" ); TTagHeader * hdr = GetDebugHeader( ETagHeaderIdRegistersCore, DFBlock ); if( hdr == NULL ) { LOG_MSG( "Could not retrieve ETagHeaderIdRegistersCore register debug block\n" ); } else if( 0 == hdr->iNumTags ) { LOG_MSG( "Zero tags found for ETagHeaderIdRegistersCore register debug block\n" ); } else { iRegisterList.ReserveL( (TInt)hdr->iNumTags ); // Skip the header to get to the tags TUint8 * ptr = ((TUint8 *) hdr) + sizeof( TTagHeader ); TTag * tag = (TTag *) ptr; TRegisterData regData; TRegisterData * reg = ®Data; // Process all the register tags for( TInt regIdx = 0; regIdx < hdr->iNumTags; regIdx ++ ) { reg->iRegClass = 0; // Core = 0 reg->iId = tag->iTagId; // reg->iSubId = 0; // reg->iSize = 2; // Should all be 32 bits == 2. reg->iAvailable = ETrue; reg->iValue64 = 0; iRegisterList.Append( *reg ); tag++; } } hdr = GetDebugHeader( ETagHeaderIdMemory, DFBlock ); if( hdr == NULL ) { LOG_MSG( "Could not retrieve ETagHeaderIdMemory. Cannot read memory\n" ); iMaxMemReadSize = 0; } else if( 0 == hdr->iNumTags ) { LOG_MSG( "Zero tags found for ETagHeaderIdMemory register debug block\n" ); iMaxMemReadSize = 0; } else { TTag* tag = GetTag( hdr, EMemoryMaxBlockSize ); if( tag ) { //LOG_MSG2( " EMemoryMaxBlockSize =0x%X\n", tag->iValue ); iMaxMemReadSize = tag->iValue; } } iLastThreadListSize = 1; iLastProcListSize = 1; iLastRegListSize = 1; CleanupStack::PopAndDestroy(&DFBlock); }
void CServerCrashDataSource::SetRegValuesL( const TUint64 aThreadId, RRegisterList &aRegisterList ) { LOG_MSG2("->CServerCrashDataSource::SetRegValuesL(aThreadId=%Lu)\n", aThreadId); TInt numberOfRegisters = aRegisterList.Count(); RBuf8 ids; ids.CreateL( numberOfRegisters * sizeof(TFunctionalityRegister) ); ids.CleanupClosePushL(); TInt totalByteSize = 0; // Keeps track of the number of bytes that we are requesting for( TInt i=0; i < numberOfRegisters; i++ ) { TRegisterInfo reg = (TRegisterInfo)( aRegisterList[i].iId ); // iSize = (0 == 1 byte); (3 == 8 bytes) TInt byteSize = (aRegisterList[i].iSize) << 1; totalByteSize += byteSize; ids.Append( reinterpret_cast<const TUint8*>(®), sizeof(TRegisterInfo) ); } RBuf8 registerValues; registerValues.CreateL( totalByteSize ); registerValues.CleanupClosePushL(); RBuf8 registerFlags; registerFlags.CreateL( numberOfRegisters ); registerFlags.CleanupClosePushL(); LOG_MSG("CServerCrashDataSource::SetRegValuesL - reading registers\n"); User::LeaveIfError(iSecSess.ReadRegisters( aThreadId, ids, registerValues, registerFlags )); // Now copy the values back to the array and mark the availability from the flags TUint8* valuePtr = (TUint8*) registerValues.Ptr(); for( TInt i=0; i < numberOfRegisters; i++ ) { TRegisterData & reg = aRegisterList[i]; switch( reg.iSize ) { case 0: reg.iValue8 = *((TUint8 *)valuePtr); valuePtr += 1; break; case 1: reg.iValue16 = *((TUint16 *)valuePtr); valuePtr += 2; break; case 2: reg.iValue32 = *((TUint32 *)valuePtr); valuePtr += 4; break; case 3: reg.iValue64 = *((TUint64 *)valuePtr); valuePtr += 8; break; } if( EValid == registerFlags[i] ) { reg.iAvailable = ETrue; } else { reg.iAvailable = EFalse; } } CleanupStack::PopAndDestroy(®isterFlags); CleanupStack::PopAndDestroy(®isterValues); CleanupStack::PopAndDestroy(&ids); }
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 }