Boolean TEditor::search( const char *findStr, ushort opts )
{
ushort pos = curPtr;
ushort i;
do {
if( (opts & efCaseSensitive) != 0 )
i = scan( &buffer[bufPtr(pos)], bufLen - pos, findStr);
else
i = iScan( &buffer[bufPtr(pos)], bufLen - pos, findStr);
if( i != sfSearchFailed )
{
i += pos;
if( (opts & efWholeWordsOnly) == 0 ||
!(
( i != 0 && isWordChar(bufChar(i - 1)) != 0 ) ||
( i + strlen(findStr) != bufLen &&
isWordChar(bufChar(i + strlen(findStr)))
)
))
{
lock();
setSelect(i, i + strlen(findStr), False);
trackCursor(Boolean(!cursorVisible()));
unlock();
return True;
}
else
pos = i + 1;
}
} while( i != sfSearchFailed );
return False;
}
HBufC8* CViewSubSession::UnpackageSortOrderAndPluginDetailsLC(const RMessage2& aMessage,RContactViewSortOrder& aSortOrder,TContactViewPreferences& aContactTypes,TUid& aSortPluginImplUid) const
{
HBufC8* buf=HBufC8::NewLC(aMessage.Int0());
TPtr8 bufPtr(buf->Des());
TInt32 nameLen;
aMessage.ReadL(1,bufPtr);
RDesReadStream readStream(bufPtr);
CleanupClosePushL(readStream);
readStream >> (TInt32&)aContactTypes;
readStream >> aSortOrder;
// Extract sort plugin UID.
aSortPluginImplUid.iUid = readStream.ReadInt32L();
// Extract sort plugin name.
nameLen = readStream.ReadInt32L();
HBufC8* pluginNameBuf = HBufC8::NewLC(nameLen);
TPtr8 pluginNamePtr = pluginNameBuf->Des();
readStream.ReadL(pluginNamePtr, nameLen);
CleanupStack::Pop(pluginNameBuf);
CleanupStack::PopAndDestroy(2); //readstream, buf.
CleanupStack::PushL(pluginNameBuf);
return pluginNameBuf;
}
TInt LoadLogicalDriverL(RFs &fileSystem, const TDesC16 &lddName, i_status_notif* cb)
{
TInt ret;
TUint val = 0x51000000U;
TPtr8 bufPtr((unsigned char *)&val, 4, 4);
TInt flag = 0;
TInt cnt = 0;
RFile ldd;
do
{ ret = User::LoadLogicalDevice(lddName);
if(ret == KErrNotSupported)
{ cb->error(_L("KErrNotSupported"));
ldd.Open(fileSystem, lddName, EFileWrite);
ldd.Write(0x48, bufPtr);
cnt++;
val += 0x40000;
ldd.Close();
} else if(ret == KErrNone || ret == KErrAlreadyExists) flag = 1; else
User::Leave(ret);
} while(!flag && val != 0x51000000U);
if(ret == KErrAlreadyExists) cb->error(_L("KErrAlreadyExists"));
return cnt;
}
/***********************************************************************************************************************************
Compress data
***********************************************************************************************************************************/
static Buffer *
testCompress(IoFilter *compress, Buffer *decompressed, size_t inputSize, size_t outputSize)
{
Buffer *compressed = bufNew(1024 * 1024);
size_t inputTotal = 0;
ioBufferSizeSet(outputSize);
IoFilterGroup *filterGroup = ioFilterGroupNew();
ioFilterGroupAdd(filterGroup, compress);
IoWrite *write = ioBufferWriteNew(compressed);
ioWriteFilterGroupSet(write, filterGroup);
ioWriteOpen(write);
// Compress input data
while (inputTotal < bufSize(decompressed))
{
// Generate the input buffer based on input size. This breaks the data up into chunks as it would be in a real scenario.
Buffer *input = bufNewC(
bufPtr(decompressed) + inputTotal,
inputSize > bufSize(decompressed) - inputTotal ? bufSize(decompressed) - inputTotal : inputSize);
ioWrite(write, input);
inputTotal += bufUsed(input);
bufFree(input);
}
ioWriteClose(write);
memContextFree(((GzipCompress *)ioFilterDriver(compress))->memContext);
return compressed;
}
/*
* ss_write_buffer() - Copy given value and meta data
* to shared buffer. In safe mode, if dirtify is TRUE then
* set dirty flag for each state set.
*/
void ss_write_buffer(CHAN *ch, void *val, PVMETA *meta, boolean dirtify)
{
PROG *sp = ch->prog;
char *buf = bufPtr(ch); /* shared buffer */
/* Must use dbCount for db channels, else we overwrite
elements we didn't get */
size_t count = ch->dbch ? ch->dbch->dbCount : ch->count;
size_t var_size = ch->type->size * count;
ptrdiff_t nch = chNum(ch);
unsigned nss;
epicsMutexMustLock(ch->varLock);
DEBUG("ss_write_buffer: before write %s", ch->varName);
print_channel_value(DEBUG, ch, buf);
memcpy(buf, val, var_size);
if (ch->dbch && meta)
/* structure copy */
ch->dbch->metaData = *meta;
DEBUG("ss_write_buffer: after write %s", ch->varName);
print_channel_value(DEBUG, ch, buf);
if (optTest(sp, OPT_SAFE) && dirtify)
for (nss = 0; nss < sp->numSS; nss++)
sp->ss[nss].dirty[nch] = TRUE;
epicsMutexUnlock(ch->varLock);
}
/*
* ss_read_buffer_static() - static version of ss_read_buffer.
* This is to enable inlining in the for loop in ss_read_all_buffer.
*/
static void ss_read_buffer_static(SSCB *ss, CHAN *ch, boolean dirty_only)
{
char *val = valPtr(ch,ss);
char *buf = bufPtr(ch);
ptrdiff_t nch = chNum(ch);
/* Must take dbCount for db channels, else we overwrite
elements we didn't get */
size_t count = ch->dbch ? ch->dbch->dbCount : ch->count;
size_t var_size = ch->type->size * count;
if (!ss->dirty[nch] && dirty_only)
return;
epicsMutexMustLock(ch->varLock);
DEBUG("ss %s: before read %s", ss->ssName, ch->varName);
print_channel_value(DEBUG, ch, val);
memcpy(val, buf, var_size);
if (ch->dbch)
{
/* structure copy */
ss->metaData[nch] = ch->dbch->metaData;
}
DEBUG("ss %s: after read %s", ss->ssName, ch->varName);
print_channel_value(DEBUG, ch, val);
ss->dirty[nch] = FALSE;
epicsMutexUnlock(ch->varLock);
}
/**
Returns the contact item at the specified index into the view.
@capability ReadUserData
@param aIndex Index
*/
CViewContact* RContactRemoteView::ContactAtL(TInt aIndex)
{
const TContactItemId KUnknownContactId = -1;
// 4 context switches
TPckgBuf<TInt>pckg;
TIpcArgs args(aIndex,&pckg);
User::LeaveIfError(SendReceive(ECntViewContactAtLength,args));
//
CViewContact* contact = CViewContact::NewLC(KUnknownContactId);
delete iContact;
iContact = contact;
CleanupStack::Pop(contact);
//
TInt contactLength=pckg();
HBufC8* buf=HBufC8::NewLC(contactLength);
TPtr8 bufPtr(buf->Des());
TIpcArgs args2(&bufPtr);
User::LeaveIfError(SendReceive(ECntViewContactAt,args2));
RDesReadStream readStream(bufPtr);
CleanupClosePushL(readStream);
readStream >> *iContact;
CleanupStack::PopAndDestroy(2); // readStream , buf.
return iContact;
}
/**
Write matching contacts back to client.
@param aMessage.Ptr0() Descriptor to write array of matching contacts.
*/
void CViewSubSessionBase::GetContactMatchingCriteriaL(const RMessage2& aMessage)
{
// Compute contacts externalized size.
const TInt contactsCount = iContacts.Count();
TInt contactsExternalizedSize=0;
contactsExternalizedSize+=sizeof(TInt32);
for (TInt jj=0;jj<contactsCount;++jj)
{
contactsExternalizedSize+=(iContacts)[jj]->ExternalizedSize();
}
HBufC8* buf=HBufC8::NewLC(contactsExternalizedSize);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
CleanupClosePushL(writeStream);
writeStream.WriteUint32L(contactsCount);
for (TInt ii=0;ii<contactsCount;++ii)
{
CViewContact* thisContact = (iContacts)[ii];
writeStream << *thisContact;
}
bufPtr.SetLength(contactsExternalizedSize);
aMessage.WriteL(0,*buf);
CleanupStack::PopAndDestroy(2, buf); //writeStream.Close(), buf
DeleteFindContacts();
}
/**
* Takes a buffer from the client, sends to the driver and back to the client.
*
* @param aMessage RMessage2 client request.
*/
void CShBufTestServerSession::FromTPtr8ProcessAndReturnL(const RMessage2& aMessage)
{
//
// Read the client buffer...
//
TPtr8 bufPtr(iSessionTempBuffer, sizeof(iSessionTempBuffer));
aMessage.ReadL(0, bufPtr);
TUint bufSize;
bufSize = aMessage.Int1();
//
// Pass to the server to pass to the driver and back...
//
TInt result;
result = Server().FromTPtr8ProcessAndReturn(bufPtr, bufSize);
//
// Write the client buffer back...
//
aMessage.WriteL(0, bufPtr);
//
// Complete the request...
//
CompleteRequest(aMessage, result);
} // CShBufTestServerSession::FromTPtr8ProcessAndReturnL
void CWin32Socket::SendTo(TWin32Message& aMessage)
{
__ASSERT_DEBUG((iSendMessage == NULL) && (iBytesSent == 0), Panic(EWinSockPrtCWin32SocketMultipleSendToRequests));
iSendMessage = &aMessage;
WSP_LOG(WspLog::Printf(_L("CWin32Socket::SendTo: this: 0x%x, bytes to send: %d"), this, iSendMessage->ReadBuffer().Length()));
TPtrC8 bufPtr(iSendMessage->ReadBuffer());
iSendBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(bufPtr.Ptr()));
iSendBuffer.len = bufPtr.Length();
iSendOverlapped.hEvent = (void*) this;
TInetAddr address;
address.Copy(iSendMessage->WriteBuffer());
SOCKADDR_IN winSockAddress;
ConvertAddress(address, winSockAddress);
DWORD numberOfBytesSent;
TInt ret = WSASendTo(iSocket, &iSendBuffer, 1, &numberOfBytesSent, 0, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in), &iSendOverlapped, &SendToCompletion);
if (ret == SOCKET_ERROR)
{
TInt err = WSAGetLastError();
if (err != WSA_IO_PENDING)
{
WSP_LOG(WspLog::Printf(_L("\tsocket error: %d"), err));
Complete(iSendMessage, MapWinSockError(err));
}
}
}
size_t CAafSocketUtils::SocketRead(struct soap *soap, char *s, size_t n)
{
__LOGSTR_TOFILE("CAafSocketUtils::SocketRead() begins");
// Get thread entry point data
MGSoapData* entryPointData = reinterpret_cast<MGSoapData*>(soap->user);
// Return value
size_t bufferLength = 0;
// Status object
TRequestStatus status;
// Initialize memory for income buffer
TUint8* desBuffer = new TUint8[TInt(n)];
TPtr8 bufPtr(NULL, 0);
bufPtr.Set(desBuffer, 0, TInt(n));
// Read socket content
entryPointData->GetSocketInstance()->Read(bufPtr, status);
User::WaitForRequest(status);
// Convert retrieved buffer to temp char* pointer
char* tempString = reinterpret_cast<char*>(desBuffer);
// Find last occurrence of the '>' symbol
char* lastOccurrence = NULL;
lastOccurrence = strrchr(tempString, '>');
if (lastOccurrence)
{
// Get position of the last occurrence of the '>' symbol
int pos = lastOccurrence - tempString;
// Copy read buffer content to output array
Mem::Copy(s, tempString, pos+1);
// Set end null value
s[pos+1] = '\0';
delete [] desBuffer;
desBuffer = NULL;
// Get read buffer length
bufferLength = strlen(s);
}
__LOGSTR_TOFILE("CAafSocketUtils::SocketRead() ends");
// In case of success return size of read buffer
if (status.Int() == KErrNone || status.Int() == KErrEof)
return bufferLength;
return 0;
}
void CSmfCredMgrClientSymbian::deleteRSAKey(QString KeyLabel)
{
TPtr bufPtr((qt_QString2HBufC(KeyLabel))->Des());
TIpcArgs args;
args.Set(0, &bufPtr);
iSession.RequestService(ESmfDeleteKeys, args);
}
// ---------------------------------------------------------
// RNSmlPrivateAPI::AddDMGenericAlertRequestL()
// Adds a Generic Alert to DM Agent if it is found in the
// server.
// ---------------------------------------------------------
//
EXPORT_C TInt RNSmlPrivateAPI::AddDMGenericAlertRequestL( const TDesC8& aCorrelator, RArray<CNSmlDMAlertItem>& aItemList ) const
{
TInt err = KErrNone;
// create buffer
CBufFlat* buffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity );
CleanupStack::PushL( buffer );
// open stream to buffer
RBufWriteStream stream( *buffer );
CleanupClosePushL( stream );
// externalize data to stream
stream.WriteInt32L( aCorrelator.Length() );
stream.WriteL( aCorrelator );
TInt count = aItemList.Count();
stream.WriteInt32L( count );
if(count > 0)
{
for(TInt i =0 ; i <count; i++)
{
stream.WriteInt32L( (aItemList[i].iSource)->Length() );
stream.WriteL( (aItemList[i].iSource)->Des() );
stream.WriteInt32L( (aItemList[i].iTarget)->Length() );
stream.WriteL( aItemList[i].iTarget->Des() );
stream.WriteInt32L( (aItemList[i].iMetaType)->Length() );
stream.WriteL( aItemList[i].iMetaType->Des() );
stream.WriteInt32L( (aItemList[i].iMetaFormat)->Length() );
stream.WriteL( aItemList[i].iMetaFormat->Des());
stream.WriteInt32L( (aItemList[i].iMetaMark)->Length() );
stream.WriteL( aItemList[i].iMetaMark->Des() );
stream.WriteInt32L( (aItemList[i].iData)->Length() );
stream.WriteL( aItemList[i].iData->Des() );
}
}
// get modifiable pointer to buffer
TPtr8 bufPtr( buffer->Ptr(0) );
CleanupStack::PopAndDestroy( &stream );
// send the data to sos server
TIpcArgs args( &bufPtr );
err = SendReceive( ECmdAddGenericAlert, args );
CleanupStack::PopAndDestroy( buffer );
return err;
}
HBufC8* RContactRemoteView::PackageSortOrderLC(const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes) const
{
TInt bufLength=aSortOrder.ExternalizedSize();
bufLength+=sizeof(TContactViewPreferences);//
HBufC8* buf=HBufC8::NewLC(bufLength);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
writeStream << (TInt32&)aContactTypes;
writeStream << aSortOrder;
bufPtr.SetLength(bufLength);
return buf;
}
void CViewSubSessionBase::ContactAtL(const RMessage2& aMessage) const
{
const TInt externalizedSize=iContact->ExternalizedSize();
HBufC8* buf=HBufC8::NewLC(externalizedSize);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
CleanupClosePushL(writeStream);
writeStream << *iContact;
bufPtr.SetLength(externalizedSize);
aMessage.WriteL(0,*buf);
CleanupStack::PopAndDestroy(2); // writeStream, buf.
}
void RestoreLDD(RFs &fileSystem, const TDesC16 &lddName)
{
TInt ret;
TUint val = 0;
TPtr8 bufPtr((unsigned char *)&val, 4, 4);
RFile ldd;
ldd.Open(fileSystem, lddName, EFileWrite);
ldd.Write(0x48, bufPtr);
ldd.Close();
return;
}
// -----------------------------------------------------------------------------
// CSIPMessage::ReadFromStreamL
// -----------------------------------------------------------------------------
//
RStringF CSIPMessage::ReadFromStreamL (RReadStream& aReadStream) const
{
TUint32 bufLength = aReadStream.ReadUint32L();
HBufC8* buf = HBufC8::NewLC (bufLength);
TPtr8 bufPtr(buf->Des());
if (bufLength > 0)
{
aReadStream.ReadL (bufPtr,bufLength);
}
RStringF str = SIPStrings::Pool().OpenFStringL(bufPtr);
CleanupStack::PopAndDestroy(buf);
return str;
}
void CIoFile::IowepWriteL(MIoWriter& aWriter)
{
HBufC* buf = HBufC::NewLC(aWriter.IowWriteLength());
TPtr bufPtr(buf->Des());
aWriter.IowWrite(bufPtr);
// Convert to UTF-8
HBufC8* narrowBuf = LtkUtils::Utf8L(*buf);
TInt err = iFile.Write(*narrowBuf);
delete narrowBuf;
aWriter.IowComplete(err);
CleanupStack::PopAndDestroy(buf);
}
void CViewSubSession::GetSortOrderL(const RMessage2& aMessage) const
{
const RContactViewSortOrder& sortOrder=View().SortOrder();
const TInt externalizedSize=sortOrder.ExternalizedSize();
HBufC8* buf=HBufC8::NewLC(externalizedSize);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
CleanupClosePushL(writeStream);
writeStream << sortOrder;
bufPtr.SetLength(externalizedSize);
aMessage.WriteL(0,*buf);
CleanupStack::PopAndDestroy(2); // writeStream, buf.
}
/**
Protect against NULL-pointer errors in the externalize/internalize methods.
*/
void CStartupPropertiesTestStepInternalExternal::DoTestWithNullPointersL()
{
INFO_PRINTF1(_L("Test 1B, using NULL pointers"));
// Create an startupprop instance with non NULL iFilename and iArgs
CStartupProperties* orig = CStartupProperties::NewLC();
//SetActionOnCommandFailure wasn't covered in any other testcase, so to increase testcoverage test it here
orig->SetActionOnCommandFailure(EPanicOnCommandFailure);
TEST(orig->ActionOnCommandFailure() == EPanicOnCommandFailure);
//Externalize it
CBufFlat* const buf = CBufFlat::NewL(orig->Size());
CleanupStack::PushL(buf);
orig->ExternalizeL(*buf); // this call could dereference NULL
// Create a new startupprop instance
CStartupProperties* copy = CStartupProperties::NewLC();
// Internalize the data
TPtr8 bufPtr(buf->Ptr(0));
copy->InternalizeL(bufPtr);
//And TEST that all members was read back successfully
TEST(orig->Version() == copy->Version());
TEST(orig->FileName() == copy->FileName());
TEST(orig->Args() == copy->Args());
TEST(orig->StartupType() == copy->StartupType());
TEST(orig->StartMethod() == copy->StartMethod());
TEST(orig->NoOfRetries() == copy->NoOfRetries());
TEST(orig->Timeout() == copy->Timeout());
TEST(orig->Monitored() == copy->Monitored());
TEST(orig->ActionOnCommandFailure() == copy->ActionOnCommandFailure());
TEST(orig->RecoveryMethod() == copy->RecoveryMethod());
TEST(orig->RestartMode() == copy->RestartMode());
TEST(orig->Viewless() == copy->Viewless());
TEST(orig->StartInBackground() == copy->StartInBackground());
//Externalize the second instance
CBufFlat* const buf2 = CBufFlat::NewL(copy->Size());
CleanupStack::PushL(buf2);
copy->ExternalizeL(*buf2);
//Assert that the first and second buffer have the same contents
TEST(buf->Ptr(0) == buf2->Ptr(0));
CleanupStack::PopAndDestroy(buf2);
CleanupStack::PopAndDestroy(copy);
CleanupStack::PopAndDestroy(buf);
CleanupStack::PopAndDestroy(orig);
}
void CViewSubSession::UnpackageSortOrderL(const RMessage2& aMessage,RContactViewSortOrder& aSortOrder,TContactViewPreferences& aContactTypes) const
{
HBufC8* buf=HBufC8::NewLC(aMessage.Int0());
TPtr8 bufPtr(buf->Des());
aMessage.ReadL(1,bufPtr);
RDesReadStream readStream(bufPtr);
CleanupClosePushL(readStream);
readStream >> (TInt32&)aContactTypes;
readStream >> aSortOrder;
CleanupStack::PopAndDestroy(2); //readstream, buf.
}
/**
@capability ReadUserData
*/
void RContactRemoteView::GetSortOrderL(RContactViewSortOrder& aSortOrder)
{
TPckgBuf<TInt> pckg;
TIpcArgs args(&pckg);
User::LeaveIfError(SendReceive(ECntViewSortOrderExternalizedSize,args));
HBufC8* buf=HBufC8::NewLC(pckg());
TPtr8 bufPtr(buf->Des());
TIpcArgs args2(&bufPtr);
User::LeaveIfError(SendReceive(ECntGetViewSortOrder,args2));
RDesReadStream readStream(bufPtr);
CleanupClosePushL(readStream);
readStream >> aSortOrder;
CleanupStack::PopAndDestroy(2); //readStream // buf.
}
/**
@capability ReadUserData
*/
HBufC* RContactRemoteView::AllFieldsLC(TInt aIndex,const TDesC& aSeparator) const
{
// 4 context switches
TPckgBuf<TInt>pckg;
TIpcArgs args(aIndex,&aSeparator,&pckg);
User::LeaveIfError(SendReceive(ECntAllFieldsLength,args));
TInt fieldLength = pckg();
HBufC* buf=HBufC::NewLC(fieldLength);
TPtr8 narrowBufPtr((TUint8*)buf->Ptr(),buf->Des().MaxLength()*2); // Note, must call MaxLength because the cell allocated may be larger than aLength.
TIpcArgs args2(&narrowBufPtr);
User::LeaveIfError(SendReceive(ECntAllFieldsText,args2));
TPtr bufPtr(buf->Des());
bufPtr.SetLength(narrowBufPtr.Length()/2);
return buf;
}
HBufC8* CTcFileHandlerSession::ReadLC(
TInt aItcArgIndex,
const RMessage2& aMessage ) const
{
TInt length = aMessage.GetDesLength( aItcArgIndex );
if ( length < 0 )
{
User::Leave( KErrBadDescriptor );
}
HBufC8* buf = HBufC8::NewLC( length );
if ( length > 0 )
{
TPtr8 bufPtr( buf->Des() );
aMessage.ReadL( aItcArgIndex, bufPtr );
}
return buf;
}
// ---------------------------------------------------------
// CBrCtlApiTestObserver::ReadFile
// ---------------------------------------------------------
//
HBufC8* CBrCtlApiTestObserver::ReadFileLC(const TDesC& aFileName)
{
RFs rfs;
RFile file;
User::LeaveIfError(rfs.Connect());
CleanupClosePushL(rfs);
User::LeaveIfError(file.Open(rfs, aFileName, EFileRead));
CleanupClosePushL(file);
TInt size;
User::LeaveIfError(file.Size(size));
HBufC8* buf = HBufC8::NewLC(size);
TPtr8 bufPtr(buf->Des());
User::LeaveIfError(file.Read(bufPtr));
CleanupStack::Pop(); // buf
CleanupStack::PopAndDestroy(2); // file, rfs
CleanupStack::PushL(buf);
return buf;
}
HBufC8* RContactRemoteView::PackageSortOrderAndPluginDetailsLC(const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,const TUid& aSortPluginImplUid,const TDesC8& aSortPluginName) const
{
// Make a packe that includes the sort plugin name
TInt bufLength = aSortOrder.ExternalizedSize();
bufLength += sizeof(TContactViewPreferences);
bufLength +=sizeof(TInt32);//length of UID
bufLength +=sizeof(TInt32);//length of aSortPluginName
bufLength +=aSortPluginName.Length();
HBufC8* buf=HBufC8::NewLC(bufLength);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
writeStream << (TInt32&)aContactTypes;
writeStream << aSortOrder;
writeStream.WriteInt32L(aSortPluginImplUid.iUid);
writeStream.WriteInt32L(aSortPluginName.Length());
writeStream.WriteL(aSortPluginName);
bufPtr.SetLength(bufLength);
return buf;
}
// -----------------------------------------------------------------------------
// CWidgetUiObserver::ReadFile
// -----------------------------------------------------------------------------
//
HBufC8* CWidgetUiObserver::ReadFileL( const TDesC& aFileName )
{
RFile file;
if (KErrNone != file.Open( CCoeEnv::Static()->FsSession(), aFileName, EFileRead ) )
{
return NULL;
}
CleanupClosePushL( file );
TInt size;
User::LeaveIfError( file.Size( size ) );
HBufC8* buf = HBufC8::NewLC( size );
TPtr8 bufPtr( buf->Des() );
User::LeaveIfError( file.Read( bufPtr ) );
CleanupStack::Pop( buf );
CleanupStack::PopAndDestroy( &file );
return buf;
}
void CTestContextData::InternalizeL( RReadStream& aStream )
{
TInt len = 0;
len = aStream.ReadInt16L();
HBufC* buf = HBufC::NewLC( len );
TPtr bufPtr( buf->Des() );
aStream.ReadL( bufPtr, len );
delete iKey;
iKey = buf;
CleanupStack::Pop( buf );
buf = NULL;
len = aStream.ReadInt16L();
buf = HBufC::NewLC( len );
bufPtr.Set( buf->Des() );
aStream.ReadL( bufPtr, len );
delete iValue;
iValue = buf;
CleanupStack::Pop( buf );
}
// ---------------------------------------------------------
// RNSmlPrivateAPI::AddDMGenericAlertRequestL()
// Adds a Generic Alert to DM Agent if it is found in the
// server.
// ---------------------------------------------------------
//
EXPORT_C TInt RNSmlPrivateAPI::AddDMGenericAlertRequestL( const TDesC8& aMgmtUri, const TDesC8& aMetaType, const TDesC8& aMetaFormat, TInt aFinalResult, const TDesC8& aCorrelator ) const
{
TInt err = KErrNone;
// create buffer
CBufFlat* buffer = CBufFlat::NewL( KDefaultNSmlBufferGranularity );
CleanupStack::PushL( buffer );
// open stream to buffer
RBufWriteStream stream( *buffer );
CleanupClosePushL( stream );
// externalize data to stream
stream.WriteInt32L( aMgmtUri.Length() );
stream.WriteL( aMgmtUri );
stream.WriteInt32L( aMetaType.Length() );
stream.WriteL( aMetaType );
stream.WriteInt32L( aMetaFormat.Length() );
stream.WriteL( aMetaFormat );
stream.WriteInt32L( aCorrelator.Length() );
stream.WriteL( aCorrelator );
stream.WriteInt32L( aFinalResult );
// get modifiable pointer to buffer
TPtr8 bufPtr( buffer->Ptr(0) );
CleanupStack::PopAndDestroy( &stream );
// send the data to sos server
TIpcArgs args( &bufPtr );
err = SendReceive( ECmdAddDMGenericAlert, args );
CleanupStack::PopAndDestroy( buffer );
return err;
}
/**
Provides conversion between view indexes and contact IDs.
@param aMessage.Int0() Buffer size (from client).
@param aMessage.Ptr1() Descriptor containing indices (from client).
@param aMessage.Ptr2() Descriptor containing contact IDs (to client).
*/
void CViewSubSessionBase::GetContactIdsL(const RMessage2& aMessage)
{
TPckgBuf<TInt> size;
aMessage.ReadL(0,size);
const TInt bufferSize = size();
CBufFlat* buffer = CBufFlat::NewL(bufferSize);
CleanupStack::PushL(buffer);
buffer->ExpandL(0,bufferSize);
TPtr8 des(buffer->Ptr(0));
aMessage.ReadL(1,des);
RBufReadStream readStream(*buffer);
CleanupClosePushL(readStream);
const TInt count = readStream.ReadUint32L();
CArrayFixFlat<TInt>* indexes = new(ELeave) CArrayFixFlat<TInt>(8);
CleanupStack::PushL(indexes);
for (TInt i=0; i<count; ++i)
{
TInt index = readStream.ReadUint32L();
indexes->AppendL(index);
}
CContactIdArray* array = CContactIdArray::NewLC();
iView->GetContactIdsL(*indexes, *array);
HBufC8* buf=HBufC8::NewLC(bufferSize);
TPtr8 bufPtr(buf->Des());
RDesWriteStream writeStream(bufPtr);
CleanupClosePushL(writeStream);
writeStream << *array;
bufPtr.SetLength(bufferSize);
aMessage.WriteL(2,*buf);
CleanupStack::PopAndDestroy(6, buffer); // &writeStream, buf, array, indexes, &readStream, buffer
}
