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