// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::ParseL
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TBool CUpnpHttpChunkParser::ParseExtension( TDes8& aBuffer, TInt& aPos )
{
if ( IsEmpty( aBuffer, aPos ) )
{
return ETrue;
}
//if '\r\n' exists
TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );
if ( lineFeed != KErrNotFound )
{
aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );
if ( !iChunkSize )
{
iContext = ETrailer;
return EFalse;
}
else
{
iContext = EBody;
return EFalse;
}
}
else
{
//one character left - possible linefeed
if ( aPos + 1 < aBuffer.Length() )
{
aBuffer.Delete( aPos, aBuffer.Length() - aPos - 1 );
}
return ETrue;
}
}
void CUtils::StripSpaces(TDes8& aText)
{
TInt i;
for (i=0; i<aText.Length(); i++)
if (aText[i] != ' ')
break;
if (i)
aText.Delete(0,i);
for (i=aText.Length()-1; i>=0; i--)
if (aText[i] != ' ')
break;
if (i != aText.Length()-1)
aText.Delete(i+1,aText.Length()-1-i);
}
// -----------------------------------------------------------------------------
// UpnpAVCPEngine::RemoveSlashes
// -----------------------------------------------------------------------------
//
void RemoveSlashes(TDes8& aPath)
{
if (aPath.Length() > 0 && aPath[0] == '/' )
{
aPath.Delete(0,1);
}
// remove ending '/'
TInt length = aPath.Length();
if (length > 0 && aPath[length-1] == '/' )
{
aPath.Delete(length-1,1);
}
}
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();
}
// -----------------------------------------------------------------------------
// CAsf::FormatGUID
// -----------------------------------------------------------------------------
//
void CAsf::FormatGUID( TDes8 &aGUID )
{
LOGFN( "CAsf::FormatGUID" );
TBuf8<16> copyGUID( aGUID );
TInt i;
for( i = 0; i < 4; i++ )
{
copyGUID[i] = aGUID[3-i];
}
for( i = 4; i < 6; i++ )
{
copyGUID[i] = aGUID[9 - i];
}
for ( i = 6; i < 8; i++ )
{
copyGUID[i] = aGUID[13 - i];
}
for( i = 8; i < 16 ; i++ )
{
copyGUID[i] = aGUID[i];
}
aGUID.Delete( 0, 32 );
for( i = 0; i < 16; i++ )
{
aGUID.AppendNumFixedWidthUC( copyGUID[i], EHex, 2 );
}
}
void DeleteBlank(TDes8& aData){
if(aData.Length()<=0) return;
_LIT8(KBlank," ");
TInt pos=aData.FindF(KBlank);
if(-1!=pos){
aData.Delete(pos,KBlank().Length());
DeleteBlank(aData);
}
}
// -----------------------------------------------------------------------------
// CUpnpContentHandlersController::RemoveForbiddenCharacters
// Removes forbidden characters
// -----------------------------------------------------------------------------
//
void CUpnpContentHandlersController::RemoveForbiddenCharacters( TDes8& aDescription )
{
for( TInt i=0; i<aDescription.Length(); i++ )
{
if ( ( aDescription[i] <= KUtfLowMax ) ||
( aDescription[i] >= KUtfHighMin && aDescription[i] <= KUtfHighMax ) )
{
aDescription.Delete( i, 1 );
i--;
}
}
}
// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::ParseL
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TBool CUpnpHttpChunkParser::ParseTrailer( TDes8& aBuffer, TInt& aPos )
{
if ( IsEmpty( aBuffer, aPos ) )
{
return ETrue;
}
//if double '\r\n' exists
TInt doublelineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KDoubleLineFeed );
if (doublelineFeed != KErrNotFound )
{
aBuffer.Delete( aPos, doublelineFeed + UpnpString::KDoubleLineFeed().Length() );
iContext = EFinish;
return ETrue;
}
else
{
//waiting,3 characters reserved for double linefeed
if ( aPos + UpnpString::KCRLFCRLength < aBuffer.Length() )
{
aBuffer.Delete( aPos, aBuffer.Length() - aPos - UpnpString::KCRLFCRLength );
}
return ETrue;
}
}
// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::ParseL
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TBool CUpnpHttpChunkParser::ParseBody( TDes8& aBuffer, TInt& aPos )
{
if ( IsEmpty( aBuffer, aPos ) )
{
return ETrue;
}
TPtrC8 pointer( aBuffer.Right( aBuffer.Length() - aPos ) );
if ( iBytesAppended + pointer.Length() >= iChunkSize )
{
aPos += ( iChunkSize - iBytesAppended );
pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ) );
TInt lineFeed = pointer.FindF(UpnpString::KLineFeed());
//linefeed found
if ( !lineFeed )
{
aBuffer.Delete( aPos, UpnpString::KLineFeed().Length() );
iContext = EEndChunkBody;
return ( aPos == aBuffer.Length() );
}
//linefeed not found, end of buffer
else if ( lineFeed == KErrNotFound &&
( ( aPos + UpnpString::KLineFeed().Length() ) > aBuffer.Length() )
)
{
iBytesAppended = iChunkSize;
return ETrue;
}
//size doesn't comply with the header value
iError = KErrGeneral;
iContext = EError;
return EFalse;
}
else
{
iBytesAppended += pointer.Length();
aPos = aBuffer.Length();
return ETrue;
}
}
// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::ParseL
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TBool CUpnpHttpChunkParser::ParseLastChunk( TDes8& aBuffer, TInt& aPos )
{
//if empty or only one character present
if ( (aBuffer.Length() - aPos) < UpnpString::KLineFeedLength )
{
return ETrue;
}
//if '\r\n' exists
TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );
if ( !lineFeed )
{
aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );
iContext = EFinish;
return ETrue;
}
else
{
iContext = ETrailer;
return EFalse;
}
}
// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::ParseL
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TBool CUpnpHttpChunkParser::ParseHeader( TDes8& aBuffer, TInt& aPos )
{
if ( IsEmpty( aBuffer, aPos ) )
{
return ETrue;
}
iChunkSize = KErrNotFound;
iBytesAppended = 0;
TPtrC8 pointer(NULL,0);
//if '\r\n' exists
TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );
//if ';' exists
TInt semiColon = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KSemiColon );
//semicolon ignored if occurs after the linefeed
if ( semiColon !=KErrNotFound && lineFeed !=KErrNotFound && lineFeed<semiColon )
{
semiColon = KErrNotFound;
}
if ( semiColon !=KErrNotFound )
{
pointer.Set(aBuffer.Right( aBuffer.Length() - aPos ).Mid( 0,semiColon ) );
}
else if ( lineFeed !=KErrNotFound )
{
pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ).Mid( 0,lineFeed ) );
}
else
{
pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ) );
}
TLex8 lex( pointer );
//skip white spaces
lex.SkipSpace();
TUint size;
//neither semicolon nor linefeed found
if ( lineFeed == KErrNotFound && semiColon == KErrNotFound )
{
//remember the num of cut spaces
TInt len = lex.Offset();
if ( !lex.Eos() )
{
//check the chunk header size for the limit
TInt error = lex.Val( size, EHex );
if ( error!= KErrNone || size > KMaxTInt )
{
//size too big
iError = ( error ) ? error: EHttpInsufficientStorage;
iContext = EError;
return EFalse;
}
}
aBuffer.Delete( aPos,len );
return ETrue;
}
//get size
TInt error = lex.Val( size, EHex );
if ( error!= KErrNone || size > KMaxTInt )
{
//unexpected characters or size too big
iError = ( error ) ? error: EHttpInsufficientStorage ;
iContext = EError;
return EFalse;
}
iChunkSize = size;
//skip white spaces
lex.SkipSpace();
if ( !lex.Eos() )
{
//unexpected characters
iError = KErrGeneral;
iContext = EError;
return EFalse;
}
if ( lineFeed != KErrNotFound )
{
//the whole chunk header is parsed
aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );
//chunk size == 0
if ( !iChunkSize )
{
iContext = ELastChunk;
}
else
{
iContext = EBody;
}
return ( aPos == aBuffer.Length() );
}
else if ( semiColon != KErrNotFound )
{
//extension found,
//one character left - possible linefeed
if ( aPos<aBuffer.Length() )
{
aBuffer.Delete( aPos, aBuffer.Length() - aPos - 1 );
}
iContext = EExtension;
return ETrue;
}
iError = KErrUnknown;
iContext = EError;
return EFalse;
}
TInt ParseMixedBinaryAsciiDataL(TDes8& aTextToConvert)
/**
Parses aTextToConvert based on the following rules:
'\\' (double backslash) is used to denote a single '\'
(single backslash)
'\xnn' denote a byte of binary data where nn is in hex-decimal.
The '\xnn' in aTextToConvert is replaced by the binary byte
that it represents.
For example: If aTextToConvert contains "abc\\def\xFF",
after parsing, it will contain "abc\def?" where ? = 0xFF.
@param aTextToConvert Modifiable buffer which will be parsed.
@return KErrNone if aTextToConvert is in valid
EAdditionalParamDataFormatMixedBinaryAndAscii format.
KErrArgument if aTextToConvert is in an incorrect format.
@panic KErrNoMemory if there is not enough memory to do the parsing.
*/
{
// Pointer to unparsed portion of additionalParamDataBuffer
HBufC8* resultBuffer = HBufC8::NewLC(aTextToConvert.Length());
__ASSERT_ALWAYS(resultBuffer, PanicClient(KErrNoMemory));
TPtr8 result(resultBuffer->Des());
// Position of backslash
TInt pos = 0;
while ((pos = aTextToConvert.Locate('\\')) != KErrNotFound)
{
// Check that the backslash is followed by at least one more character
if ((pos+1) >= aTextToConvert.Length())
{
return KErrArgument;
}
TUint8 modifier = aTextToConvert[pos+1];
// Parse depending on character after the backslash
switch (modifier)
{
case '\\':
// Next character after the '\' is another '\'.
// Replace it with a single '\' and move
// on.
result.Append(aTextToConvert.Left(pos+1));
aTextToConvert.Delete(0, pos+2);
break;
case 'x':
// Next character is an 'x' so check that there are three
// characters after the backslash (one for the x and two
// characters of HEX.
if ((pos+3) >= aTextToConvert.Length())
{
return KErrArgument;
}
// Convert those to HEX and replace '\xNN' with this.
result.Append(aTextToConvert.Left(pos));
TUint8 hexAsInt;
if (AsciiHexToNum(aTextToConvert.MidTPtr(pos+2,2), hexAsInt) != KErrNone)
{
return KErrArgument;
}
// Append the raw byte to the result
result.SetLength(result.Length()+1);
result[result.Length()-1] = hexAsInt;
aTextToConvert.Delete(0, pos+4);
break;
}
} // End while
aTextToConvert.Insert(0, result);
CleanupStack::PopAndDestroy(resultBuffer);
return KErrNone;
}
