TPtr8 CSmtpAuthCramMd5MechanismHelper::FormSharedSecret(TPtr8 aPassword)
{
TPtr8 secret = aPassword;
if (aPassword.Length() <= KMd5BlockLength)
{
//pad up to 64 bytes with zeros
secret.SetLength(64);
TInt origLen = aPassword.Length();
TInt lengthToFill = KMd5BlockLength-aPassword.Length();
for (TInt i = 0; i<lengthToFill; i++)
{
secret[origLen+i]=0x00;
}
}
else
{
//make shared secret the Digest of the password
secret.Zero();
iMd5Hash->Reset();
secret = (iMd5Hash->Hash(aPassword));
//do we need to call this function again now to pad out the 16 byte result?
}
return secret;
}
/**
* Function that will look at all the devices on the RConnection
* and update the device array accordingly.
*/
TInt CPanConnections::UpdateCurrentConnections()
{
TInt rerr = KErrNone;
HBufC8* buffer=0;
const TInt KAddrLen = sizeof(TBTDevAddr);
TRAP(rerr, buffer = HBufC8::NewL(7*KAddrLen));// create a buffer to house the device address
if(rerr == KErrNone)
{
TPtr8 ptr = buffer->Des();
// use RConnection to enumerate all the devices
rerr = iConnection.Control(KCOLAgent, KCOAgentPanEnumerateDevices, ptr);
if(rerr == KErrNone)
{
iActiveConnections.Reset();
while(ptr.Length()>=KBTDevAddrSize)
{
// inspect the addr's in the descriptor and append them to the array.
TBTDevAddr parsedAddr(ptr.Mid(ptr.Length()-KAddrLen, KBTDevAddrSize));
ptr.SetLength(Max(ptr.Length()-KAddrLen, 0));
iActiveConnections.Append(parsedAddr);
}
}
}
delete buffer;
return rerr;
}
/**
Intended Usage : Stream out the internal state to aStream.
Error Condition : Leave with the error code.
@leave KErrNoMemory.
@leave @see RWriteStream.
@since 7.0
@param aClientSide a boolean indicating whether the streaming is to performed in client/server side
@param aStream The stream to store the data in.
@pre CImplementationInformation is fully constructed and initialized
*/
void CImplementationInformation::ExternalizeL(TBool aClientSide,RWriteStream& aStream) const
{
aStream.WriteInt32L(iImplementationUid.iUid);
aStream.WriteInt32L(iVersion);
if(iDisplayName)
{
TPtr outputBuf = iDisplayName->Des();
aStream.WriteInt32L(outputBuf.Length());
aStream.WriteL(outputBuf);
}
else
{
aStream.WriteInt32L(0);
}
if(iData)
{
TPtr8 outputBuf = iData->Des();
aStream.WriteInt32L(outputBuf.Length());
aStream.WriteL(outputBuf);
}
else
{
aStream.WriteInt32L(0);
}
if(iOpaqueData)
{
TPtr8 outputBuf = iOpaqueData->Des();
aStream.WriteInt32L(outputBuf.Length());
aStream.WriteL(outputBuf);
}
else
{
aStream.WriteInt32L(0);
}
if (aClientSide)
{
aStream.WriteInt32L(iDrive);
aStream.WriteInt32L(iVid.iId);
}
TInt additionalImplInfo=iRomOnly;
additionalImplInfo|=iRomBased<<1;
additionalImplInfo|=iDisabled<<2;
aStream.WriteInt8L(additionalImplInfo);
if (iExtendedInterfaceList != NULL)
{
TInt count = iExtendedInterfaceList->Count();
aStream.WriteInt32L(count);
for(TInt i = 0; i < count; ++i)
{
aStream.WriteInt32L((*iExtendedInterfaceList)[i].iUid);
}
}
else
{
aStream.WriteInt32L(KNoneExtendedInterface);
}
}
void CBrdSession::PrintfStr(TPtr8 &bufPtr, TPtr8 &bufPtr2)
{
CBrdServer *server = (CBrdServer*)Server();
TInt lth = bufPtr.Length();
HBufC* uniBuf=HBufC::NewL(lth*2);
CleanupStack::PushL(uniBuf);
TPtr uniBufPtr = uniBuf->Des();
uniBufPtr.Copy(bufPtr);
lth = bufPtr2.Length();
HBufC* uniBuf2=HBufC::NewL((lth*2)+2);
CleanupStack::PushL(uniBuf2);
TPtr uniBufPtr2 = uniBuf2->Des();
uniBufPtr2.Copy(bufPtr2);
server->iControl->WriteText(uniBufPtr, uniBufPtr2.PtrZ());
server->iControl->ShowText(_L("\n"));
CleanupStack::Pop();
CleanupStack::Pop();
delete uniBuf;
uniBuf = NULL;
delete uniBuf2;
uniBuf2 = NULL;
}
// The caller must free the returned buffer. The buffer is guaranteed
// to have a zero terminator.
HBufC8* ConvToUtf8ZL(const TDesC& name16)
{
// Note that there is no non-leaving variant of this function, such
// that the result has no maximum size.
//
// Do not know what happens if any 0 values appear in "name16"; this
// is not documented.
HBufC8* name8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(name16);
// Ensure there is a zero terminator. Quite a lot of work to do this
// efficiently.
TPtr8 ptr = name8->Des();
if (ptr.Length() < ptr.MaxLength()) {
ptr.PtrZ(); // modifies HBufC8 content
} else {
HBufC8* bigger8 = name8->ReAlloc(ptr.Length() + 1);
if (bigger8) {
name8 = bigger8; // name8 already deleted by ReAlloc
name8->Des().PtrZ(); // modifies HBufC8 content
} else {
delete name8;
User::Leave(KErrNoMemory);
}
}
return name8;
}
EXPORT_C TInt CDosExtensionBase::ExecuteMessageL(const RMessage2& aMessage)
{
API_TRACE_( "[DOSSERVER] CDosExtensionBase::ExecuteMessageL(...)" );
__ASSERT_DEBUG(aMessage.Function() == ECallFunction,
PanicClient(aMessage,EPanicIllegalFunction));
TInt retVal(KErrNone);
TBool parameterModifiedByDSY(EFalse);
// Get data from RMessage
TExtensionParPckg extPars;
aMessage.ReadL(0, extPars);
TInt dataLength(extPars().iParLength);
if (dataLength >= 0)
{
HBufC8* dataBuffer = HBufC8::NewMaxLC( dataLength );
TPtr8 dataPtr = dataBuffer->Des();
aMessage.ReadL( 1, dataPtr );
// Check autocomplete flag
TUint autoCompl(aMessage.Int2());
if (autoCompl == KAutoComplete)
{
COM_TRACE_4( "[DOSSERVER] MDosExtensionBaseDSY::CallFunctionL(0x%x,0x%x,0x%x,0x%x)"
,extPars().iFunc
,dataPtr.Ptr()
,dataPtr.Length()
,autoCompl );
retVal = CallFunctionL(extPars().iFunc, const_cast<TUint8*>(dataPtr.Ptr()), dataPtr.Length(), parameterModifiedByDSY);
if((retVal == KErrNone) && parameterModifiedByDSY)
{
// Write over client's parameters
retVal = aMessage.Write(1, dataPtr);
}
}
else
{
COM_TRACE_3( "[DOSSERVER] MDosExtensionBaseDSY::CallFunctionAndCompleteL(0x%x,0x%x,0x%x)"
,extPars().iFunc
,dataPtr.Ptr()
,dataPtr.Length() );
CallFunctionAndCompleteL(extPars().iFunc, const_cast<TUint8*>(dataPtr.Ptr()), dataPtr.Length(), aMessage);
}
CleanupStack::PopAndDestroy(); // dataBuffer
}
else
{
// Client passed negative parameter length
retVal = KErrGeneral;
}
return retVal;
}
TInt CTlsEncrypt::DecryptAndVerifyL(const TDesC8& aInput,HBufC8*& aOutput,
TInt64& aSeqNumber, TRecordProtocol& aType)
{
if(!aInput.Length())
return KErrBadDescriptor;
TLSPROV_LOG2(_L("Before Decryption...RecordType: %d"),(TInt)aType)
TLSPROV_LOG_HEX(aInput.Ptr(),aInput.Size() )
TInt nAlloc = iCryptos.iDecryptor->MaxFinalOutputLength(aInput.Size()) + 24;
if ( !aOutput || aOutput->Des().MaxLength() < nAlloc )
{
delete aOutput;
aOutput = NULL;
aOutput = HBufC8::NewL( nAlloc );
}
TPtr8 DecOutput = aOutput->Des();
DecOutput.Zero();
TRAP_IGNORE(iCryptos.iDecryptor->ProcessFinalL(aInput,DecOutput));
TUint HashSize = KSetOfTLSCipherSuites[iCipherIndex].iHashSize;
if(DecOutput.Length() < HashSize)
{
return KErrSSLAlertDecryptError;
}
//set ptr to MAC
TPtrC8 ReceivedMac = DecOutput.Mid(DecOutput.Length()-HashSize,HashSize);
//& set length to trim MAC
DecOutput.SetLength( DecOutput.Length()-HashSize );
TBuf8<64> CalculatedMac;
ComputeMacL(CalculatedMac,DecOutput,ETrue,aSeqNumber,aType);
TInt err = KErrBadMAC;
if(ReceivedMac.Compare(CalculatedMac) == 0)
{
err = KErrNone;
}
else
{
TLSPROV_LOG(_L("Decryption: Received MAC error"))
err = KErrSSLAlertBadRecordMac;
}
TLSPROV_LOG(_L("After Decryption , no mac"))
TLSPROV_LOG_HEX(aOutput->Ptr(),aOutput->Size() )
return err;
}
// ----------------------------------------------------------------------------
// 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 );
}
}
TInt TMD5Checker::ReadAndHashFileL(class RFs& aFs, const TDesC& aFile)
{
TInt ret = KErrNone;
class RFile file;
// CAP: dependent
User::LeaveIfError(file.Open(aFs, aFile, EFileRead));
CleanupClosePushL(file);
HBufC8* readBuf = HBufC8::NewLC(6*1024);
TPtr8 buf = readBuf->Des();
Reset();
User::LeaveIfError(file.Read(buf));
while(buf.Length() > 0){
Append(buf);
User::LeaveIfError(file.Read(buf));
}
Finish();
CleanupStack::PopAndDestroy(readBuf);
CleanupStack::PopAndDestroy(/*file*/);
return ret;
}
EXPORT_C int Tptr8ToWcharp(const TPtr8& aSrc, wchar_t* aDes, int& n_size)
{
int retval = ESuccess;
unsigned int ilen = aSrc.Length();
int minusone = -1;
if (0 == ilen)
{
return EDescriptorNoData;
}
else if(!aDes)
{
return EInvalidPointer;
}
else if(n_size < ilen+1)
{
n_size = ilen+1 ;
return EInvalidSize;
}
if(minusone != mbstowcs(aDes, (const char*)aSrc.Ptr(), ilen))
{
aDes[ilen] = L'\0';
}
else
{
retval = EInvalidMBSSequence;
}
return retval;
}
void CBulkOnlyTransport::SendCbwL(const MClientCommandServiceReq* aReq,
TBotCbw::TCbwDirection aDirection,
TUint32 aTransferLength)
{
__MSFNLOG
__BOTPRINT1(_L("Cbw Tag=0x%x"), iCbwTag);
iCbw.SetTag(iCbwTag++);
iCbw.SetDataTransferLength(aTransferLength);
iCbw.SetDataTransferDirection(aDirection);
iCbw.SetLun(iLun);
TPtr8 buf = iBulkOutCbwTd.WritableBuffer();
iCbw.EncodeL(buf, aReq);
iBulkOutCbwTd.SaveData(buf.Length());
iBulkPipeOut.Transfer(iBulkOutCbwTd, iStatus);
User::WaitForRequest(iStatus);
TInt r = iStatus.Int();
if (r != KErrNone)
{
if (r == KErrUsbStalled)
{
__BOTPRINT(_L("Cbw: BulkOut stalled"));
DoResetRecovery();
}
__BOTPRINT1(_L("Usb transfer error %d"),r);
User::Leave(KErrGeneral);
}
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
wchar_t* mywcharstring = L"Hello Widechar String";
int wchar_length= wcslen(mywcharstring);
TBufC8<30> buf;
TPtr8 myTptr = buf.Des();
char* temp=new char[30];
retval = WcharpToTptr8(mywcharstring,temp, myTptr);
int buf_len = myTptr.Length();
if (retval ==ESuccess &&\
wchar_length == buf_len )
{
printf("wcharptotptr8 boundary1 Passed\n");
}
else
{
assert_failed = true;
printf("wcharptotptr8 boundary1 Failed\n");
}
delete[] temp;
__UHEAP_MARKEND;
testResultXml("test_wcharptotptr8_boundary1");
return 0;
}
void CDomainNameCodec::DecodeL(TPtr8& aInDes)
{
TDomainName domainName;
TUint8* pChar = const_cast<TUint8*>(aInDes.Ptr());
TUint listLength = aInDes.Length();
TUint8 labelLength = 0;
// Walk the list of domain names
while(pChar < aInDes.Ptr() + listLength)
{
domainName.Zero();
while(*pChar++ != NULL)
{
if(domainName.Length() > 0)
{
domainName.Append('.');
}
labelLength = *(pChar - 1);
// The two highest order bits must be clear
User::LeaveIfError(labelLength & 0xC0 ? KErrArgument : KErrNone);
// Add in the label data
domainName.Append(pChar, labelLength);
// Advance the pointer to the next length value
pChar += labelLength;
}
iDomainList.Append(domainName);
}
}
// -----------------------------------------------------------------------------
// CMccCodecRed::SetRedCodecs
// Set the payload types used in redundancy
// -----------------------------------------------------------------------------
//
void CMccCodecRed::SetRedPayloadsL( RArray<TUint>& aRedPayloads )
{
iRedPayloads.Reset();
TInt i;
for( i = 0; i < aRedPayloads.Count(); i++ )
{
iRedPayloads.AppendL( aRedPayloads[ i ] );
}
// Convert parsed payload formats back to string and set
// the iFmtpAttr variable
const TInt KCharsPerPayload( 4 );
delete iFmtpAttr;
iFmtpAttr = NULL;
iFmtpAttr = HBufC8::NewL( iRedPayloads.Count() * KCharsPerPayload );
TPtr8 descPtr = iFmtpAttr->Des();
for( i = 0; i < iRedPayloads.Count(); i++ )
{
descPtr.AppendNum( static_cast<TUint64>( iRedPayloads[i] ), EDecimal );
descPtr.Append( KCharSlash );
}
// Remove the last slash character
descPtr.SetLength( descPtr.Length() - 1 );
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
wchar_t* mywcharstring = L"Hello Widechar String";
int wchar_length= wcslen(mywcharstring);
TBufC8<30> buf;
TPtr8 myTptr = buf.Des();
char* temp=new char[30];
retval = WcharpToTptr8(mywcharstring,temp, myTptr);
int buf_len = myTptr.Length();
if (retval ==ESuccess &&\
wchar_length == buf_len &&\
strncmp("Hello Widechar String",(char*)myTptr.Ptr() , 21) ==0 )
{
printf("wcharptotptr8 content check Passed\n");
}
else
{
assert_failed = true;
printf("wcharptotptr8 content check Failed\n");
}
delete []temp;
__UHEAP_MARKEND;
testResultXml("test_wcharptotptr8_content_check");
return 0;
}
void CLocationEngine::InsertIntoPayload(TInt aPosition, const TDesC8& aString, TPtr8& aLogStanza) {
if(aLogStanza.Length() + aString.Length() > aLogStanza.MaxLength()) {
iLogStanza = iLogStanza->ReAlloc(aLogStanza.MaxLength() + aString.Length() + 32);
aLogStanza.Set(iLogStanza->Des());
}
aLogStanza.Insert(aPosition, aString);
}
TInt CIniFileParser::GetNextTokenAndCheck(TLex8& lex, TPtr8& tempPtr)
/*
Gets next token and ensures the token is simply not the EOF or a linefeed.
lex is the lexical string to get the next token from.
tempPtr points to the next token
Returns KErrGeneral if token is bad or if we've already read past the end.
*/
{
TUint8 ch;
TInt len;
if (lex.Eos())
{
return KErrGeneral;
}
tempPtr = lex.NextToken();
len = tempPtr.Length();
if (len == 0)
{
// lex has figured out what is left is just the EOF
return KErrGeneral;
}
// this next part may be superfluous but we've had so much strife with
// the parser thus far that for now we're leaving it in
ch = tempPtr[0];
if (ch == KCarriageReturn || ch == KLineFeed)
{
return KErrGeneral;
}
if (tempPtr.Length() < 2)
{
return KErrNone;
}
ch = tempPtr[1];
if (ch == KCarriageReturn || ch == KLineFeed)
{
return KErrGeneral;
}
return KErrNone;
}
// ----------------------------------------------------------------------------
// TTCPCompMsgStart::DataReceivedL
// ----------------------------------------------------------------------------
//
void TTCPCompMsgStart::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 );
if ( iMsgAssembler.MsgBuffer().Size() > 0 )
{
// insert the received data to msg buffer.
iMsgAssembler.MsgBuffer().InsertL(
iMsgAssembler.MsgBuffer().Size(), aData );
iMsgAssembler.MsgBuffer().Compress();
// clean the content of received data.
aData.Delete( 0, aData.Length() );
TPtr8 bufPtr = iMsgAssembler.MsgBuffer().Ptr( 0 );
// check if the msg buffer a complete sig comp message, if so
// copy the msg buffer to a new data buf, clean the msg buffer
// and enter to comp msg end state.
if ( iMsgAssembler.SigComp().IsCompleteSigCompMessageL( bufPtr ) )
{
HBufC8* newData = HBufC8::NewLC( bufPtr.Length() );
// copy the msg buffer data and the received data to new buffer
TPtr8 newDataPtr = newData->Des();
newDataPtr.Append(bufPtr);
// clean the msg buffer
iMsgAssembler.MsgBuffer().Reset();
iMsgAssembler.MsgBuffer().Compress();
iMsgAssembler.ChangeState( MMsgAssemblerContext::ECompMsgEnd );
iMsgAssembler.CurrentState().DataReceivedL( newDataPtr,
aNextLength );
CleanupStack::PopAndDestroy(newData);
}
}
else if (iMsgAssembler.SigComp().IsCompleteSigCompMessageL( aData ) )
{
iMsgAssembler.ChangeState( MMsgAssemblerContext::ECompMsgEnd );
iMsgAssembler.CurrentState().DataReceivedL( aData, aNextLength );
}
else
{
iMsgAssembler.MsgBuffer().InsertL(
iMsgAssembler.MsgBuffer().Size(), aData );
iMsgAssembler.MsgBuffer().Compress();
}
}
TInt CBulkOnlyTransport::SendDataTxCmdL(const MClientCommandServiceReq* aCommand,
TDesC8& aData,
TUint aPos,
TInt& aLen)
{
__MSFNLOG
TInt r = KErrNone;
SendCbwL(aCommand, TBotCbw::EDataOut, aLen);
TInt len = aLen;
TInt length = 0;
iBulkDataTd.SetZlpStatus(RUsbTransferDescriptor::ESuppressZlp);
while (len)
{
TPtr8 senddata = iBulkDataTd.WritableBuffer();
senddata.Append(aData.Ptr() + length + aPos, len > KResponsePacketSize? KResponsePacketSize : len);
iBulkDataTd.SaveData(senddata.Length());
iBulkPipeOut.Transfer(iBulkDataTd, iStatus);
User::WaitForRequest(iStatus);
if (iStatus.Int() != KErrNone)
{
if (iStatus.Int() == KErrUsbStalled)
{
__BOTPRINT(_L("SendDataTxCmdL ClearRemoteStall"));
iBulkPipeOut.ClearRemoteStall();
#ifdef MASSSTORAGE_PUBLISHER
TMsPublisher publisher(TMsPublisher::KStallProperty);
#endif
break;
}
DoResetRecovery();
__BOTPRINT1(_L("Usb transfer error %d"), r);
User::Leave(KErrGeneral);
}
if(len > KResponsePacketSize)
{
len -= KResponsePacketSize;
length += KResponsePacketSize;
}
else
{
length += len;
len = 0;
}
}
ReceiveCswL();
TUint32 lenSent = 0;
r = ProcessOutTransferL(lenSent);
aLen = lenSent;
return r;
}
TInt RBTBaseband::Enumerate(RBTDevAddrArray& aBTDevAddrArray, TUint aMaxNumber)
{
if (!SubSessionHandle())
{
return KErrNotReady;
}
__ASSERT_DEBUG(aMaxNumber>=1, Panic(EBadArgument));
if(!aMaxNumber)
{
return KErrArgument;
}
HBufC8* buffer=0;
const TInt KAddrLen = sizeof(TBTDevAddr);
TRAPD(err, buffer = HBufC8::NewL(aMaxNumber*KAddrLen));
if(err)
{
return KErrNoMemory;
}
TPtr8 ptr = buffer->Des();
err = iSocket.GetOpt(EBBEnumeratePhysicalLinks, KSolBtLMProxy, ptr);
if (err)
{
delete buffer;
return err;
}
/**
Parse the supplied descriptor
*/
aBTDevAddrArray.Reset();
while(ptr.Length()>=KBTDevAddrSize)
{
TBTDevAddr parsedAddr(ptr.Mid(ptr.Length()-KAddrLen, KBTDevAddrSize));
ptr.SetLength(Max(ptr.Length()-KAddrLen, 0));
aBTDevAddrArray.Append(parsedAddr);
}
delete buffer;
return KErrNone;
}
/**
@SYMTestCaseID PDS-SQL-UT-4207
@SYMTestCaseDesc RFileBuf64::Write() OOM test.
The test calls RFileBuf64:Write() in an OOM
simulation loop and verifies that no memory is leaked.
The test also check that RFileBuf::DoSetCapacity() correctly operates in
"out of memory" situation.
@SYMTestActions RFileBuf64::Write() OOM test.
@SYMTestExpectedResults Test must not fail
@SYMTestPriority High
@SYMDEF 380056
*/
void WriteOomTest()
{
HBufC8* databuf = HBufC8::New(KPageSize);
TEST(databuf != NULL);
TPtr8 dataptr = databuf->Des();
dataptr.SetLength(KPageSize);
dataptr.Fill(TChar(KChar));
TInt err = KErrNoMemory;
TInt failingAllocationNo = 0;
TheTest.Printf(_L("Iteration:\r\n"));
while(err == KErrNoMemory)
{
TheTest.Printf(_L(" %d"), ++failingAllocationNo);
(void)TheFs.Delete(KTestFile);
MarkHandles();
MarkAllocatedCells();
__UHEAP_MARK;
__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
const TInt KDefaultBufCapacity = 1024;
RFileBuf64 fbuf(KDefaultBufCapacity);
err = fbuf.Create(TheFs, KTestFile, EFileWrite | EFileRead);
if(err == KErrNone)
{
err = fbuf.Write(0LL, dataptr);
}
fbuf.Close();
__UHEAP_RESET;
__UHEAP_MARKEND;
CheckAllocatedCells();
CheckHandles();
}
TEST2(err, KErrNone);
RFile64 file;
err = file.Open(TheFs, KTestFile, EFileRead);
TEST2(err, KErrNone);
dataptr.Zero();
err = file.Read(dataptr);
TEST2(err, KErrNone);
file.Close();
TEST2(dataptr.Length(), KPageSize);
for(TInt i=0;i<KPageSize;++i)
{
TEST(dataptr[i] == KChar);
}
TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
//The file is left undeleted - to be used in ReadOomTest().
delete databuf;
}
/**
Implementation of pure virtual function.
@see MWTCacheInterface::ReadL()
*/
void CDynamicDirCache::ReadL(TInt64 aPos, TInt aLength, TDes8& aDes)
{
#ifdef _DEBUG
if(iCacheDisabled)
{
// cache is disabled for debug purposes
__PRINT(_L("CDynamicDirCache disabled"));
User::LeaveIfError(iDrive.ReadNonCritical(aPos, aLength, aDes));
return;
}
#endif //_DEBUG
aDes.Zero();
const TUint32 PageSz = iPageSizeInBytes;//-- cache page size
TInt64 pageStartMedPos = CalcPageStartPos(aPos);
const TUint32 bytesToPageEnd = (TUint32)(pageStartMedPos + PageSz - aPos); //-- number of bytes from aPos to the end of the page
// __PRINT5(_L("CDynamicDirCache::ReadL: aPos=%lx, aLength=%x, page:%lx, pageSz:%x, bytesToPageEnd=%x"), aPos, aLength, pageStartMedPos, PageSz, bytesToPageEnd);
// if all data needed is on a single page
if((TUint32)aLength <= bytesToPageEnd)
{
ReadDataFromSinglePageL(aPos, aLength, aDes);
}
// or data to be read cross cache page boundary or probably we have more than 1 page to read
else
{
__PRINT(_L("CDynamicDirCache::ReadL() CROSS PAGE!"));
TUint32 dataLen(aLength); //-- current data length
TInt64 currMediaPos(aPos); //-- current media position
//-- 1. read data that are already in the current page
ReadDataFromSinglePageL(currMediaPos, bytesToPageEnd, aDes);
dataLen -= bytesToPageEnd;
currMediaPos += bytesToPageEnd;
TPtr8 dataNext = aDes.MidTPtr(aDes.Length());
//-- 2. read whole pages of data
while (dataLen >= PageSz)
{
//-- find out if currMediaPos is in cache. If not, find a spare page and read data there
ReadDataFromSinglePageL(currMediaPos, PageSz, dataNext);
currMediaPos += PageSz;
dataLen -= PageSz;
dataNext = dataNext.MidTPtr(dataNext.Length());
}
//-- 3. read the rest of the data
if(dataLen > 0)
{
ReadDataFromSinglePageL(currMediaPos, dataLen, dataNext);
}
} //else((TUint32)aLength <= bytesToPageEnd)
}
/**
Updates the strings specified in step c of section 5.2.4 of RFC 3986
@param aInputBuf A reference to the inputBuf needs to be modified
@param aOutPutBuf A reference to the outPutBuf needs to be modified
@param aLength length of the string to be replaced.
*/
void updateStrings(TPtr8& aInputBuf, TPtr8& aOutPutBuf, TInt aLength)
{
aInputBuf.Replace(0,aLength,KSlash);
//In outPutBuf to remove the last segment starting with / (if exist)
//eg: /abc/def/fgh --> /abc/def
TInt outputBufLength = aOutPutBuf.Length();
TInt pos = aOutPutBuf.LocateReverse('/');
//remove the last segment including '/'
pos != KErrNotFound ? aOutPutBuf.Delete( pos, outputBufLength - pos ) : aOutPutBuf.Delete( 0,outputBufLength );
}
// -----------------------------------------------------------------------------
// AppendBufL
// -----------------------------------------------------------------------------
//
void AppendBufL( TPtr8& aDest, HBufC8* aSrc )
{
TInt length = aSrc ? aSrc->Length() : KNullBuffer;
APPEND_BUF_INT( aDest, length );
if( length > 0 )
{
__ASSERT_DEBUG( (aDest.MaxLength() - aDest.Length()) > length, User::Panic( KNullDesC, KErrTooBig ) );
aDest.Append( *aSrc );
}
}
void CTestUTCParse::ReadDataL(CImRecvConvert* aRecvConvert, TFileName aFileName)
{
// open the file
RFile file;
TInt error = file.Open(iTestUtils->FileSession(), aFileName, EFileShareAny);
if(error != KErrNone)
{
ERR_PRINTF2(TRefByValue<const TDesC>_L("\r\nFile open error %d"), error);
User::Leave(KErrNotFound);
}
INFO_PRINTF2(TRefByValue<const TDesC>_L("Data from %s...\r\n"), aFileName.PtrZ());
// read the file into the conversion object
HBufC8* lineBuffer = HBufC8::NewLC(1024);
TPtr8 line = lineBuffer->Des();
TBuf8<1> theChar;
TBool finished = EFalse;
aRecvConvert->ResetL();
// supply a new attachment path since previous one is discarded by call to Reset()
do {
line.FillZ();
line.SetLength(0);
// compile a line one char at a time
do {
file.Read(theChar, 1);
if(theChar.Length())
line.Append(theChar);
else
finished = ETrue;
// stop at the end of line or no more data
} while(theChar.Length() && theChar[0] != 0x0A);
if(!line.Length())
break;
aRecvConvert->ParseNextField(line); // This function doesnt actually leave, any leaves are relayed to the MessageCompleteL() function
} while(!finished);
TRAPD(err, aRecvConvert->MessageCompleteL());
if(err!=KErrNone)
{
// At this point the message should be deleted and CImRecvConvert should be Reset()
ERR_PRINTF3(TRefByValue<const TDesC>_L("\r\nError %d occured during the conversion of Message %d"), err, aRecvConvert->EntryId());
}
CleanupStack::PopAndDestroy(lineBuffer);
file.Close();
}
//------------------------------------------------------------
// CNsmlObexClient::ReceiveDataL( TDes8& aStartPtr, TRequestStatus &aStatus )
//------------------------------------------------------------
void CNsmlObexClient::ReceiveDataL( TPtr8& aStartPtr, TRequestStatus &aStatus )
{
iAgentStatus = &aStatus;
// agent
*iAgentStatus = KRequestPending;
iDataPtr.Set( aStartPtr );
if ( iState != EWaitingToReceive )
{
User::Leave( KErrDisconnected );
}
else if ( IsActive() )
{
User::Leave( KErrInUse );
}
iDataBuf->Reset();
iCurrObject->Reset();
TBuf8<KNameLen> str;
str.Copy( this->iMimeType->Des() );
iCurrObject->SetTypeL( str );
iClient->Get( *iCurrObject, iStatus );
DBG_DUMP((void*)aStartPtr.Ptr(), aStartPtr.Length(),
_S8("ReceiveDataL (WBXML)"));
#ifdef __NSML_DEBUG__
_DBG_FILE("CNsmlObexClient::ReceiveDataL: CWbxml2XmlConverter::ConvertL()\
begin");
CWbxml2XmlConverter* c = CWbxml2XmlConverter::NewLC();
c->ConvertL(aStartPtr.Ptr(), aStartPtr.Length());
DBG_DUMP((void*)c->Document().Ptr(), c->Document().Length(),
_S8("ReceiveDataL (XML)") );
CleanupStack::PopAndDestroy(); // c
_DBG_FILE("CNsmlObexClient::ReceiveDataL: CWbxml2XmlConverter::ConvertL() end");
#endif // __NSML_DEBUG__
SetActive ();
}
// -----------------------------------------------------------------------------
// AppendBufL
// -----------------------------------------------------------------------------
//
void AppendBufL( TPtr8& aDest, HBufC* aSrc )
{
TInt length = aSrc ? aSrc->Length() * 2 : KNullBuffer;
APPEND_BUF_INT( aDest, length );
if( length > 0 )
{
TPtr8 tmp8( (TUint8*)aSrc->Ptr(), length, length);
__ASSERT_DEBUG( (aDest.MaxLength() - aDest.Length()) > tmp8.Length() , User::Panic( KNullDesC, KErrTooBig ) );
aDest.Append( tmp8 );
}
}
// --------------------------------------------------------------------------------------
// Decodes input data from base64 to binary octets and creates
// heap buffer with the decoded data. The buffer is pushed on the cleanup stack.
// --------------------------------------------------------------------------------------
//
HBufC8* CXmlEngSerializerXOP::CreateDecodedBufLC(TPtrC8 aEncodedData)
{
// The decoded length of base64 is about half (use same) encoded length
HBufC8* decodedData = HBufC8::NewLC(aEncodedData.Size());
TPtr8 decodedDataPtr = decodedData->Des();
// Decode the base64 Content-Transfer-Encoding
using namespace BSUL;
Base64Codec::Decode(aEncodedData, decodedDataPtr);
if(decodedDataPtr.Length() == 0)
{
User::Leave(KXmlEngErrDecodingFailed);
}
return decodedData;
}
EXPORT_C TInt RRtaContent::GetStringAttributeSetL(const TDesC& aUniqueId, RStringAttributeSet &aStringAttributeSet) const
{
TInt err = KErrOverflow;
TInt length = 0;
TPckg <TInt> lengthPckg(length);
// Write the object out to a buffer, send to client
CBufFlat* buf = CBufFlat::NewL(50);
CleanupStack::PushL(buf);
// create write stream
RBufWriteStream writeStream(*buf);
CleanupClosePushL(writeStream);
// write the directory to the stream
aStringAttributeSet.ExternalizeL(writeStream);
CleanupStack::PopAndDestroy(&writeStream);
TPtr8 bufPtr = buf->Ptr(0);
// allocate arbitary receive buffer much larger than the size of the source buffer
length = bufPtr.Length() * 15;
while(err == KErrOverflow)
{
HBufC8* transferBuffer = HBufC8::NewLC(length);
transferBuffer->Des().Copy(bufPtr);
TPtr8 transferPtr = transferBuffer->Des();
// attempt to retrieve the attributes
err = SendReceive(EGetStringAttributeSet, TIpcArgs(&aUniqueId, &transferPtr));
if(err == KErrOverflow)
{
// Find out the length required to receive the resulting attribute set
lengthPckg.Copy(transferPtr.Left(lengthPckg.MaxLength()));
}
else if(err == KErrNone)
{
// read in the attribute values from the buffer
RDesReadStream readStream(transferPtr);
CleanupClosePushL(readStream);
aStringAttributeSet.InternalizeL(readStream);
CleanupStack::PopAndDestroy(&readStream);
}
CleanupStack::PopAndDestroy(transferBuffer);
}
CleanupStack::PopAndDestroy(buf);
return err;
}
void CActiveWriter::RunL()
{
TPtr8 currentbuffer = (iWriteBuffers[0])->Des();
iConsole.Printf(_L("Write of %d bytes (including header) returned result %d.\n"), currentbuffer.Length(), iStatus.Int());
// the write has completed - clear up the buffer
delete iWriteBuffers[0];
iWriteBuffers.Remove(0);
if (iWriteBuffers.Count())
// more to send
DoWrite();
}
