//////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////
void ReplaceUrl(TDes8& aUrl,const TDesC8& aIsRepeatedKStr,const TDesC8& aStr){
HBufC8* tmp=HBufC8::NewL(aUrl.Length()+aStr.Length()+128);
int iPos=aUrl.FindF(aIsRepeatedKStr);
if(iPos>=0){
tmp->Des().Copy(aUrl.Left(iPos)); //加上前面有用的字符
tmp->Des().Append(aStr);
int iStart=iPos+aIsRepeatedKStr.Length(); //要被替换的字符，加上要被替换的字符长度
int iLen2=aUrl.Length()-iStart;
tmp->Des().Append(aUrl.Mid(iStart,iLen2)); //加上后面有用的字符
aUrl.Copy(tmp->Des());
}
delete tmp;
}
inline void CPppMsChap::ChallengeResponseL(const TDesC8& aChallenge,
TDes8& aPaddablePasswordHash,
TDes8& aResponse)
/**
Computes the Challenge Response.
@param aChallenge [in] A MS-CHAP Challenge (8 octets).
@param aPaddablePasswordHash [in/out] The hash of the password in a
paddable buffer (16 octets in a buffer with at least 21 octets
maximum length).
@param aResponse [out] The Challenge Response (24 octets).
@note This function implements the ChallengeResponse routine
specified in RFC 2433.
@internalComponent
*/
{
ASSERT(aChallenge.Length()==KPppMsChapChallengeSize);
ASSERT(aPaddablePasswordHash.Length()==KPppMsChapHashSize &&
aPaddablePasswordHash.MaxLength() >=
KPppMsChapPaddedHashSize);
ASSERT(aResponse.Length() == KPppMsChapNTResponseSize);
// aPaddablePasswordHash contains the hash of the password (16 octets)
// zero-padded to 21 octets
// RFC 2433 - ChallengeResponse(): "Set ZPasswordHash to
// PasswordHash zero-padded to 21 octets", i.e. 5 octets
aPaddablePasswordHash.AppendFill(0,
KPppMsChapPaddedHashSize -
KPppMsChapHashSize);
// The first 8 octets of aResponse
TPtr8 responseChunk(const_cast<TUint8*>(aResponse.Ptr()),
KPppDESKeySize,
KPppDESKeySize);
DesEncryptL(aChallenge,
aPaddablePasswordHash.Left(KPppMsChapDESKeySize),
responseChunk);
// The second 8 octets of aResponse
responseChunk.Set(const_cast<TUint8*>(aResponse.Ptr()) +
KPppDESKeySize,
KPppDESKeySize,
KPppDESKeySize);
DesEncryptL(aChallenge,
aPaddablePasswordHash.Mid(KPppMsChapDESKeySize,
KPppMsChapDESKeySize),
responseChunk);
// The third 8 octets of aResponse
responseChunk.Set(const_cast<TUint8*>(aResponse.Ptr()) +
2*KPppDESKeySize, KPppDESKeySize, KPppDESKeySize);
DesEncryptL(aChallenge,
aPaddablePasswordHash.Mid(2*KPppMsChapDESKeySize,
KPppMsChapDESKeySize),
responseChunk);
// Restore the original length of the password hash
aPaddablePasswordHash.SetLength(KPppMsChapHashSize);
ASSERT(aResponse.Length() == KPppMsChapNTResponseSize);
}
// -----------------------------------------------------------------------------
// CExprUDPMsg::TryParsingL
// -----------------------------------------------------------------------------
//
TInt CExprUDPMsg::TryParsingL( TDes8& aData, TInt& aLength )
{
__ASSERT_ALWAYS( aData.Left( KUDPPrefix().Length() ) == KUDPPrefix,
User::Panic( _L("Protocol"), 1 ) );
// UDP:0123,000e,[Some test data]
TInt frameOverhead =
KUDPPrefix().Length() +
KHexDecimalLength +
KPortSuffix().Length() +
KHexDecimalLength +
KLengthSuffix().Length() +
KDataSuffix().Length() +
KMessageSuffix().Length();
if ( aData.Length() >= frameOverhead )
{
TPtrC8 portPtr(
aData.Mid( KUDPPrefix().Length(), KHexDecimalLength ) );
TLex8 portLexer( portPtr );
TUint port;
if ( portLexer.Val( port, EHex ) != KErrNone )
{
return KErrCorrupt;
}
DEBUG_PRINT( DEBUG_STRING( "CExprUDPMsg::TryParsingL, port = %d" ), port );
//Check port suffix
if ( aData.Mid( KUDPPrefix().Length() +
KHexDecimalLength, KPortSuffix().Length() ) != KPortSuffix )
{
return KErrCorrupt;
}
TPtrC8 lengthPtr( aData.Mid( KUDPPrefix().Length() +
KHexDecimalLength + KPortSuffix().Length(), KHexDecimalLength ) );
TLex8 lengthLexer( lengthPtr );
TUint length;
if ( lengthLexer.Val( length, EHex ) != KErrNone )
{
return KErrCorrupt;
}
DEBUG_PRINT( DEBUG_STRING( "CExprUDPMsg::TryParsingL, length = %d" ), length );
//Check length suffix
if ( aData.Mid(
KUDPPrefix().Length() +
KHexDecimalLength +
KPortSuffix().Length() +
KHexDecimalLength, KLengthSuffix().Length() ) != KLengthSuffix )
{
return KErrCorrupt;
}
DEBUG_PRINT( DEBUG_STRING( "CExprUDPMsg::TryParsingL, parsing data" ), length );
if ( aData.Length() >= TInt( frameOverhead + length ) )
{
TInt messagePos = KUDPPrefix().Length() +
KHexDecimalLength +
KPortSuffix().Length() +
KHexDecimalLength +
KLengthSuffix().Length();
TPtrC8 message( aData.Mid( messagePos, length ) );
if ( aData.Mid( messagePos + length,
KDataSuffix().Length() ) != KDataSuffix )
{
return KErrCorrupt;
}
DEBUG_PRINT( DEBUG_STRING( "CExprUDPMsg::TryParsingL, message OK" ) );
if ( aData.Mid( messagePos + length + KDataSuffix().Length(),
KMessageSuffix().Length() ) != KMessageSuffix )
{
return KErrCorrupt;
}
// send parsed results
iObserver->FrameParsedL( port, message );
// set the length of the handled message
aLength = frameOverhead + length;
return KErrNone;
}
}
return KErrNone;
}
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;
}
