EXPORT_C void CTestUtils::DoBuf(TDes8& buf, const TDesC& label, const TDesC8& data)
{
buf.Zero();
buf.Copy(label);
buf.Append(data);
buf.Append(_L("\r\n"));
}
/**
Convert data from the API's form (as we're given it by RemCon) the
bearer-specific form.
*/
TInt CCoreSerialConverter::InterfaceToBearer(TUid aInterfaceUid,
TUint aOperationId,
const TDesC8& aData,
TRemConMessageType aMsgType,
TDes8& aBearerData) const
{
TInt ret = KErrCorrupt;
if ( aData.Length() <= 10 )
{
if ( aMsgType == ERemConCommand )
{
aBearerData.Format(_L8("0x%08x 0x%02x %S %S"), aInterfaceUid, aOperationId, &KCmdText(), &aData);
// Pad it up in case aData was less than 4 characters.
while ( aBearerData.Length() < KRemConSerialBearerMessageLength )
{
aBearerData.Append(_L8(" "));
}
ret = KErrNone;
}
else if ( aMsgType == ERemConResponse )
{
aBearerData.Format(_L8("0x%08x 0x%02x %S %S"), aInterfaceUid, aOperationId, &KRspText(), &aData);
// Pad it up in case aData was less than 4 characters.
while ( aBearerData.Length() < KRemConSerialBearerMessageLength )
{
aBearerData.Append(_L8(" "));
}
ret = KErrNone;
}
}
return ret;
}
/**
Validates and Converts the valid Percent encoded triplets to Uppercase for specified
sub component of URI. For eg: Converts %3a to %3A
@param aData A reference to a string to be validated and converted to upper case.
@param aCaseNormalizedData A reference to a descriptor that is converted to
uppercase that is to be returned.
@return returns a bool whether it is a valid Percent encoded triplet
*/
TBool ValidateAndConvertPercentEncodedTriple(TDesC8& aData , TDes8& aCaseNormalizedData )
{
// See if the descriptor is actually long enough and
// Check that the three characters form an escape triple - first char is '%'
if( aData.Length() < KEscapeTripleLength || aData[KEscDelimiterPos] != KEscapeIndicator )
{
return EFalse;//do nothing
}
// Check that next two characters are valid
TInt mostSignificantDigitValue = KHexDigit().LocateF(aData[KMostSignificantNibblePos] );
TInt leastSignificantDigitValue = KHexDigit().LocateF(aData[KLeastSignificantNibblePos] );
if( mostSignificantDigitValue== KErrNotFound || leastSignificantDigitValue == KErrNotFound )
{
// Either of the characters were not a valid hex character
return EFalse;
}
aCaseNormalizedData.Zero();
aCaseNormalizedData.Append(KEscapeIndicator);
//Coverts most significant hex character to uppercase
(mostSignificantDigitValue >= 0 && mostSignificantDigitValue <= 0xF) ?
aCaseNormalizedData.Append(KHexDigit().Mid(mostSignificantDigitValue,1)) :
aCaseNormalizedData.Append(KHexDigit().Mid(mostSignificantDigitValue,1));
//Coverts least significant hex character to uppercase
(leastSignificantDigitValue >= 0 && leastSignificantDigitValue <= 0xF) ?
aCaseNormalizedData.Append(KHexDigit().Mid(leastSignificantDigitValue,1)) :
aCaseNormalizedData.Append(aData[KLeastSignificantNibblePos]);
return ETrue;
}
// -----------------------------------------------------------------------------
// CG711PayloadFormatRead::GetNextFrameL
// Passes next audio frame decoded with DecodePayload(). Return ETrue if decoded
// frames are remaining.
// -----------------------------------------------------------------------------
//
TBool CG711PayloadFormatRead::GetNextFrame( TDes8& aToBuffer )
{
iFrameIndex++;
DP_G711_READ3( "CG711PayloadFormatRead::GetNextFrame - FrameCount: %d, FrameIndex: %d",
iFrameArray.Count(), iFrameIndex );
const TInt frameCount( iFrameArray.Count() );
if ( iFrameIndex == frameCount )
{
aToBuffer.Append( iFrameArray[iFrameIndex - 1] );
iFrameArray.Reset();
return EFalse;
}
else if ( iFrameIndex < frameCount )
{
aToBuffer.Append( iFrameArray[iFrameIndex - 1] );
return ETrue;
}
else
{
return EFalse;
}
}
static void FormatSqlStmt(TDes8& aSqlBuf, const char aSql[], TInt aRecIds[], TInt aRecCnt)
{
aSqlBuf.Copy(TPtrC8((const TUint8*)aSql));
aSqlBuf.Append(_L8("("));
for(TInt i=0;i<aRecCnt;++i)
{
aSqlBuf.AppendNum((TInt64)aRecIds[i]);
aSqlBuf.Append(_L8(","));
}
aSqlBuf.SetLength(aSqlBuf.Length() - 1);
aSqlBuf.Append(_L8(")"));
}
// -----------------------------------------------------------------------------
// CTransactionIDGenerator::AddClockInfo
// -----------------------------------------------------------------------------
//
void CTransactionIDGenerator::AddClockInfo( TDes8& aBuf ) const
{
TTime now;
now.UniversalTime();
TInt64 timeAsInt = now.Int64();
aBuf.Append( reinterpret_cast<const TUint8*>( &timeAsInt ),
sizeof( timeAsInt ) );
TUint ticks = User::TickCount();
aBuf.Append( reinterpret_cast<const TUint8*>( &ticks ), sizeof( ticks ) );
}
TBool TDebugFunctionality::GetStopModeFunctionality(TDes8& aDFBlock)
{
TUint32 size = GetStopModeFunctionalityBufSize();
if (aDFBlock.MaxLength() < size)
{
// Insufficient space to contain the debug functionality block
return EFalse;
}
TUint8* ptr = (TUint8*)&size;
aDFBlock.SetLength(0);
aDFBlock.Append(ptr, 4);
TVersion version = TVersion(KStopModeMajorVersionNumber, KStopModeMinorVersionNumber, KStopModePatchVersionNumber);
ptr = (TUint8*)&version;
aDFBlock.Append(ptr, sizeof(TVersion));
AppendBlock((const TSubBlock&)StopModeFunctionalityCore,aDFBlock);
AppendBlock((const TSubBlock&)StopModeFunctionalityFunctions,aDFBlock);
AppendBlock((const TSubBlock&)StopModeFunctionalityList,aDFBlock);
const TTagHeader& header = StopModeFunctionalityBuffers->iHeader;
aDFBlock.Append((TUint8*)&header, sizeof(TTagHeader));
for(TInt i=0; i<EBuffersLast; i++)
{
TTag tag;
TheDBufferManager.GetBufferDetails((TBufferType)i, tag);
aDFBlock.Append((TUint8*)&tag, sizeof(TTag));
}
if(aDFBlock.Length() != size - 4)
{
return EFalse;
}
TUint32* ptr32 = (TUint32*)aDFBlock.Ptr();
TUint32 checksum = 0;
for(TInt i=0; i<aDFBlock.Length(); i+=4)
{
checksum^=*ptr32;
ptr32++;
}
ptr = (TUint8*)&checksum;
aDFBlock.Append(ptr, 4);
return ETrue;
}
/**
* Get the data from the transaction
*
* Return the minimum of client buffer size and amount left to read
*/
TInt CDummyWSPCOTrans::GetData(TDes8& aBuffer, RWSPCOTrans::TDataType aDataType, TInt* aSizeLeft) const
{
__ASSERT_DEBUG(aBuffer.MaxSize()>0, User::Panic(_L("Client buffer not allocated"),0));
//const TDesC8* requestedData=*iDataArray[aDataType];
const TDesC8* requestedData= iDataArray[aDataType];
TInt bufferSize = aBuffer.MaxSize();
TInt reqSize = requestedData->Size();
TInt* offset = iOffsetArray.At(aDataType);
TInt retSize = Min(bufferSize, (reqSize - *offset));
aBuffer.Zero();
aBuffer.Append(requestedData->Mid(*offset, retSize));
*offset += retSize;
if (*offset==reqSize)
{
*aSizeLeft = 0;
*offset = 0;
return KErrNone;
}
else
{
*aSizeLeft = reqSize-*offset;
return RWAPConn::EMoreData;
}
}
/**
* Convert a string to Hexadecimal
*
* @param aData String descriptor
* @param aDes Descriptor where Hex value is stored
*
* @return N/A
*
* @leave System wide error
*/
void CT_DataVerify::ConvertString2HexL( const TDesC8& aData, TDes8& aDes )
{
TBuf8<DataVerify::KCharlength> charBuf;
// Check that buffer is even number
if( ( aData.Length() % DataVerify::KCharlength ) != 0 )
{
User::Leave( KErrBadDescriptor );
}
// Go through the data and convert it two characters at a time
// buffer overflow does not occur because buffer is checked to be even number first
for( TInt i = 0, limit = aData.Length()-DataVerify::KCharlength; i <= limit; i+=DataVerify::KCharlength )
{
// Clean char buffer first
charBuf.Delete( 0, charBuf.Length() );
// Add KCharlength characters into buffer
for ( TInt j = 0; j < DataVerify::KCharlength; j++ )
{
charBuf.Append( aData[i+j] );
}
TUint number;
TLex8 converter = TLex8( charBuf );
// Two characters together represent a hex number in MD5 checksum
User::LeaveIfError( converter.Val( number, EHex ) );
aDes.Append( number );
}
}
TPtrC8 Read(TDes8& aTempBuf, TPtrC8& aData, TInt aLength, TPtrC8& aOverflowData)
{
if (aLength <= aData.Length())
{
// Can read it from this buffer
TPtrC8 res(aData.Left(aLength));
aData.Set(aData.Mid(aLength));
return res;
}
else /*if (aLength > aData.Length())*/
{
// Descriptor spans wrap point, so need to copy into temp buf
aTempBuf.Copy(aData.Left(aTempBuf.MaxLength())); // If anyone's crazy enough to write a platsec diagnostic string longer than 2k, it gets truncated
TInt overflowLen = aLength - aData.Length();
aData.Set(aOverflowData); // Wrap aData
aOverflowData.Set(TPtrC8());
if (overflowLen > aData.Length())
{
ASSERT(EFalse); // Shouldn't happen
// in urel, return everything we've got
return aData;
}
aTempBuf.Append(aData.Left(overflowLen));
aData.Set(aData.Mid(overflowLen));
return TPtrC8(aTempBuf);
}
}
TUint TInputManager::ReadString(TDes8& aStr)
{
TKeyCode key;
aStr.Zero();
while( (key = iConsole.Getch()) != EKeyEnter)
{
if (aStr.Length() == aStr.MaxLength())
return aStr.MaxLength();
if (key == EKeyBackspace)
{
if (aStr.Length() > 0)
{
aStr.Delete(aStr.Length()-1, 1);
ConsoleBackspace(1);
}
}
else
{
TUint8 keyChar(key);
aStr.Append(keyChar);
iConsole.Printf(_L("%c"), keyChar);
}
}
iConsole.Printf(_L("\n"));
return aStr.Length();
}
static void my_sprintf(TDes8 &aBuf, const char *aFormat, ...)
{
VA_LIST list;
VA_START(list, aFormat);
Kern::AppendFormat(aBuf, aFormat, list);
aBuf.Append(TChar(0));
}
TInt CTmsTestStep::ReadNextLineL( RFile &aFile, TDes8 &aLine )
// read a cr/lf limiited line from the file, assumes file is a valid file
// and that aLine is of sufficient length to hold the data
{
aLine.Zero();
TBuf8<1> chr;
for (;;)
{
aFile.Read(chr);
if ( chr.Length() == 0 )
{
break;
}
if (chr.CompareF(KRet) == 0)
{
// got a line, exctract newline as well
aFile.Read(chr);
break;
}
else
{
aLine.Append(chr);
}
}
return aLine.Length();
}
/**
* Helper function to append a DebugFunctionalityXXX SubBlock
* into a TDes buffer
*/
void TDebugFunctionality::AppendBlock(const TSubBlock& aDFSubBlock, TDes8& aDFBlock)
{
// Copy the aSubDFBlock.header into aDFBlock (Note we don't put in a TSubBlock structure
// as the block is just that - a flat block so the pointer is not required)
TPtr8 SubDFBlockHdrPtr((TUint8*)&aDFSubBlock.iHeader,sizeof(TTagHeader),sizeof(TTagHeader));
aDFBlock.Append(SubDFBlockHdrPtr);
// Append all the Tags
for (TUint i=0; i<aDFSubBlock.iHeader.iNumTags; i++)
{
TPtr8 tmpPtr((TUint8*)&aDFSubBlock.iTagArray[i],sizeof(TTag),sizeof(TTag));
aDFBlock.Append(tmpPtr);
}
}
// -----------------------------------------------------------------------------
// Converts from TDesC to TDesC8
// -----------------------------------------------------------------------------
//
void ConnMonUtils::TDesToTDes8( const TDes& aSrc, TDes8& aDest )
{
for ( TUint i = 0; i < aSrc.Length(); ++i )
{
aDest.Append( aSrc[i] & 0x00FF );
}
}
/** Fills a buffer with character aC
@param aBuffer Buffer to be filled, output
@param aLength Length to be filled
@param aC Character to be used to fill the buffer
*/
void FillBuffer(TDes8& aBuffer, TInt aLength, TChar aC)
{
test (aBuffer.MaxLength() >= aLength);
for(TInt i=0; i<aLength; i++)
{
aBuffer.Append(aC);
}
}
void CSerialWriter::AddSeverity(TDes8& aLogBuffer, const TInt& aSeverity)
{
if (aSeverity < 1)
{
return;
}
_LIT(KErr,"ERROR - ");
_LIT(KHigh,"HIGH - ");
_LIT(KWarn,"WARN - ");
_LIT(KMedium,"MEDIUM - ");
_LIT(KInfo,"INFO - ");
_LIT(KLow,"LOW - ");
if(aSeverity == ESevrErr)
aLogBuffer.Append(KErr);
else if(aSeverity == ESevrHigh)
aLogBuffer.Append(KHigh);
else if(aSeverity == ESevrWarn)
aLogBuffer.Append(KWarn);
else if(aSeverity == ESevrMedium)
aLogBuffer.Append(KMedium);
else if (aSeverity == ESevrInfo)
aLogBuffer.Append(KInfo);
else if(aSeverity == ESevrLow)
aLogBuffer.Append(KLow);
else //if(aSeverity == ESevrAll)
aLogBuffer.Append(KInfo);
}
TInt CBulkOnlyTransport::SendDataRxCmdL(const MClientCommandServiceReq* aCommand,
TDes8& aCopyBuf,
TInt& aLen)
{
__MSFNLOG
TInt r = KErrNone;
SendCbwL(aCommand, TBotCbw::EDataIn, aLen);
// store initial length as data is appended to the buffer
TInt startPos = aCopyBuf.Length();
TInt len = aLen;
while (len)
{
if(len > KResponsePacketSize)
iBulkDataTd.SaveData(KResponsePacketSize);
else
iBulkDataTd.SaveData(len);
iBulkPipeIn.Transfer(iBulkDataTd, iStatus);
User::WaitForRequest(iStatus);
r = iStatus.Int();
if (r != KErrNone)
{
if (r == KErrUsbStalled)
{
__BOTPRINT(_L("SendDataRxCmdL ClearRemoteStall"));
iBulkPipeIn.ClearRemoteStall();
#ifdef MASSSTORAGE_PUBLISHER
TMsPublisher publisher(TMsPublisher::KStallProperty);
#endif
break;
}
DoResetRecovery();
__BOTPRINT1(_L("Usb transfer error %d"),r);
User::Leave(KErrGeneral);
}
TPtrC8 data = iBulkDataTd.Buffer();
aCopyBuf.Append(data.Ptr(), data.Length());
if(len > KResponsePacketSize)
len -= KResponsePacketSize;
else
len = 0;
}
ReceiveCswL();
TUint32 lenReceived = 0;
r = ProcessInTransferL(lenReceived);
aLen = lenReceived;
aCopyBuf.SetLength(startPos + lenReceived);
return r;
}
void CATBase::AppendWildCardChar(TDes8& aString)
//
// A utility function to append a '*' to aString if there's not one already there
//
{
_LIT8(KAsterisk,"*");
if(aString.Right(1)!=KAsterisk)
aString.Append(KAsterisk);
}
EXPORT_C TInt TRuntimeCtxId::Store(TDes8& aDes) const
{
if (Size() > aDes.MaxSize())
{
return KErrOverflow;
}
aDes.Append((TUint8*)this, Size());
return KErrNone;
}
// ---------------------------------------------------------------------------
// CTransactionIDGenerator::ComputeChecksum
// ---------------------------------------------------------------------------
//
void CTransactionIDGenerator::ComputeChecksum( TDes8& aBuf,
const TAny* aPtr,
TInt aLength ) const
{
__STUN_ASSERT_RETURN( aPtr != NULL, KErrArgument );
TUint16 cs = 0;
Mem::Crc( cs, aPtr, aLength );
aBuf.Append( reinterpret_cast<const TUint8*>( &cs ), sizeof( cs ) );
}
void CPaddingSSLv3::DoPadL(const TDesC8& aInput,TDes8& aOutput)
{
TInt paddingBytes=BlockSize()-(aInput.Length()%BlockSize());
aOutput.Append(aInput);
aOutput.SetLength(aOutput.Length()+paddingBytes);
for (TInt i=1;i<=paddingBytes;i++)
{
aOutput[aOutput.Length()-i]=(TUint8)(paddingBytes-1);
}
}
void CSerialWriter::AddTime(TDes8& aLogBuffer)
{
TTime now;
now.UniversalTime();
TDateTime dateTime = now.DateTime();
_LIT8(KFormat,"%02d:%02d:%02d:%03d ");
// add the current time
aLogBuffer.Append(KTEFNewLine) ;
aLogBuffer.AppendFormat(KFormat,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),(dateTime.MicroSecond()/1000));
}
void CRuleManager::TimeFormat(const TTime& aTime,TDes8& aDes)
{
TDateTime time = aTime.DateTime();
TInt hour,minute;
hour = time.Hour() ;
minute = time.Minute() ;
aDes.AppendNum(hour);
aDes.Append(':');
aDes.AppendNum(minute);
}
// -----------------------------------------------------------------------------
// CUpnpEventQueueManagerBase::ClearVariables
// -----------------------------------------------------------------------------
//
void CUpnpEventQueueManagerBase::AddVariableToEventBody(
TDes8& aBuffer ,
CUpnpStateVariable * aVariable )
{
aBuffer.Append( KGenaPropertyStart );
aBuffer.Append( aVariable->Name() );
aBuffer.Append( KCloseBracket );
aBuffer.Append( aVariable->Value() );
aBuffer.Append( KOpenBracket );
aBuffer.Append( UpnpString::KSlash() );
aBuffer.Append( aVariable->Name() );
aBuffer.Append( KGenaPropertyEnd );
}
// ---------------------------------------------------------------------------
// CMMCScBkupReadDataTransferRequestBase::ReadChunkL()
//
//
// ---------------------------------------------------------------------------
void CMMCScBkupReadDataTransferRequestBase::ReadChunkL( TDes8& aSink, TInt aLength )
{
const TInt endOffset = CurrentReadInfo().EndOffset();
__LOG4("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - START - aLength: %d, endOffset: %d, iCurrentOffset: %d, sinkLength: %d", aLength, endOffset, iCurrentOffset, aSink.Length());
//
if ( iCurrentOffset >= 0 && iCurrentOffset <= endOffset )
{
if ( aLength > 0 )
{
MMMCScBkupArchiveDataInterface& archiveDataInterface = Driver().DrvADI();
// We read based upon the current offset and the specified length
TPtr8 sink( iTemporaryTransferSink->Des() );
const TMMCScBkupArchiveVector readRequest( iCurrentOffset, aLength );
const TMMCScBkupArchiveVector& readResult = archiveDataInterface.ADIReadL( sink, readRequest );
__LOG2("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - read result - offset: %d, length: %d", readResult.Offset(), readResult.Length());
// Update offset
iCurrentOffset += readResult.Length();
aSink.Append( sink );
__LOG2("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - new offset (iCurrentOffset): %d, sink Length: %d", iCurrentOffset, aSink.Length());
#ifdef DEBUGGING_DATA_TRANSFER
TRAP_IGNORE( DumpTransferDataL( archiveDataInterface.ADIFsSession(), sink) );
#endif
if ( iCurrentOffset > CurrentReadInfo().EndOffset() )
{
__LOG("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - Fatal Error - read went beyond archive entry boundary!");
ASSERT( EFalse );
User::Leave( KErrCorrupt );
}
else
{
__LOG("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - read was okay - updating stats & reporting progress...");
// We managed to read the data okay, so let's update our stats
DataTransferred( readResult.Length() );
// ... and also update progress
Driver().DrvProgressHandler().MMCScBkupHandleProgress( readResult.Length() );
}
}
}
else
{
__LOG("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - Fatal Error - current offset out of bounds!");
ASSERT( EFalse );
User::Leave( KErrCorrupt );
}
__LOG("CMMCScBkupReadDataTransferRequestBase::ReadChunkL() - END");
}
// --------------------------------------------------------------------------------------
// Generates random CID
// --------------------------------------------------------------------------------------
//
void CXmlEngSerializerXOP::GenerateRandomCid(TDes8& aCid)
{
_LIT8(KAt, "@");
//generate random CID as <randomNumber>@<homeTime>
TTime now;
now.HomeTime();
TInt64 homeTime = now.Int64();
TUint32 randomNumber = Math::Random();
aCid.AppendNum(randomNumber);
aCid.Append(KAt);
aCid.AppendNum(now.Int64());
}
static void BtDevAddrToString(TDes8& aString, const TBTDevAddr& addr)
{
// GetReadable() does not produce a "standard" result,
// so have to construct a string manually.
aString.Zero();
_LIT8(KColon, ":");
for (TInt i=0; i<6; i++) {
const TUint8& val = addr[i];
aString.AppendNumFixedWidthUC(val, EHex, 2);
if (i < 5)
aString.Append(KColon);
}
}
EXPORT_C TInt TMetaArrayBase::Store(TDes8& aBuffer) const
/**
* Stores content of a meta object (in iData) to a descriptor
*/
{
if (aBuffer.MaxLength() - aBuffer.Length() < (TInt)sizeof(TInt))
{
return KErrOverflow;
}
TInt count = Count();
aBuffer.Append((TUint8*)&count, sizeof(TInt));
TInt size = SizeOfType();
for ( TInt n = 0; n < count; n++ )
{
if (aBuffer.MaxLength() - aBuffer.Length() < size)
{
return KErrOverflow;
}
aBuffer.Append(At(n), size);
}
return KErrNone;
}
EXPORT_C void CStreamCipher::Process(const TDesC8& aInput, TDes8& aOutput)
{
TInt outputIndex = aOutput.Size();
// aOutput may already have outputIndex bytes of data in it
// check there will still be enough space to process the result
__ASSERT_DEBUG(aOutput.MaxLength() - outputIndex >= MaxOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));
aOutput.Append(aInput);
TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, aInput.Size(),
aInput.Size());
DoProcess(transformBuf);
}
