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); }