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