//returns >0 or CONNERR. int Syscall::httpCreateConnectionLC(const TDesC8& parturl, CHttpConnection*& conn, int method, SocketType socketType) { int port_m1_index = parturl.Locate(':'); int path_index = parturl.Locate('/'); if(path_index == KErrNotFound) { return CONNERR_URL; } if(port_m1_index > path_index) { port_m1_index = KErrNotFound; } TPtrC8 path(parturl.Mid(path_index)); int hostname_length; TUint16 port; if(port_m1_index == KErrNotFound) { port = (socketType == SSL) ? 443 : 80; hostname_length = path_index; } else { TLex8 portLex(parturl.Mid(port_m1_index + 1, path_index - (port_m1_index + 1))); hostname_length = port_m1_index; if(portLex.Val(port, EDecimal) != KErrNone) { return CONNERR_URL; } } TPtrC8 hostname(parturl.Left(hostname_length)); conn = new (ELeave) CHttpConnection(createSocket(socketType), method, port, gHttpStringPool); CleanupStack::PushL(conn); conn->ConstructL(hostname, path); return 1; }
void CSenPropertiesElement::Set( const TDesC8& aNamespaceURI, const TDesC8& aLocalName, const TDesC8& aQName ) { if ( !ipStringPool ) { CSenXmlElement::Set(aNamespaceURI, aLocalName, aQName); } else { RString localName; TInt leaveCode(KErrNone); TRAP( leaveCode, localName = ipStringPool->OpenStringL(aLocalName); ) if( !leaveCode ) { iLocalName.Close(); iLocalName = localName; TPtrC8 prefix(KNullDesC8); if(aQName != KNullDesC8) { TInt colon(KErrNotFound); colon = aQName.Locate(':'); if(colon!=KErrNotFound) { prefix.Set(aQName.Left(colon)); } } TRAP( leaveCode, SetNamespaceL(prefix, aNamespaceURI); )
// ----------------------------------------------------------------------------- // SdpUtil::IsValidCharSet // Generic checker to validate that string has only valid characters // ----------------------------------------------------------------------------- // TBool SdpUtil::IsValidCharSet( const TDesC8& aIllegalChars, const TDesC8& aValue, TInt aStart, TInt aEnd) { TBool result = EFalse; if ( aIllegalChars.Length() > 0 && aStart >= 0 && aEnd <= aValue.Length() && aStart < aEnd ) { TInt comp = KErrNotFound; while (comp == KErrNotFound && aStart < aEnd) { comp = aIllegalChars.Locate( aValue[aStart] ); ++aStart; } result = ( comp == KErrNotFound ); } else { result = ( ( aStart < aEnd ) && ( aIllegalChars.Length() == 0 || aValue.Length() == 0 ) ); } return result; }
// ---------------------------------------------------------- // CSimplePresenceList::ConstructL // ---------------------------------------------------------- // void CSimplePresenceList::ConstructL( const TDesC8& aData, const TDesC8& aBoundary, const TDesC8& aStart ) { _LIT(KUrl, "http://dummy.com/d1/d.html"); // body part array RPointerArray<CBodyPart> bodyPartArray; // Cleanup-routine TCleanupItem clItem( ResetAndDestroy, &bodyPartArray ); CleanupStack::PushL( clItem ); // remove "..." characters from boundary if needed TPtrC8 pUnQuoted = aBoundary; TInt quoted = aBoundary.Locate('"'); if (!quoted) { pUnQuoted.Set( aBoundary.Mid( 1, aBoundary.Length() - 2 )); } // parse MultipartParser::ParseL( aData, KSimpleMultipartType, pUnQuoted, KUrl, bodyPartArray ); DoConstructL( bodyPartArray, aStart ); CleanupStack::PopAndDestroy( ); // bodyPartArray }
// ---------------------------------------------------------------------------- // CWmDrmDlaParser::ProcessLicenseResponse // ---------------------------------------------------------------------------- // TInt CWmDrmDlaParser::ProcessLicenseResponse( const TDesC8& aLicenseResponse, HBufC8*& aTID, HBufC8*& aContentURL) { TInt error = KErrNone; LOGFNR( "CWmDrmDlaParser::ProcessLicenseResponse", error ); // Find beginning of XML document ('<') TInt pos = aLicenseResponse.Locate( '<' ); if ( pos != KErrNotFound ) { iContentUrl = &aContentURL; iTID = &aTID; iErrorCode = KErrNone; TPtrC8 ptrUrl = aLicenseResponse.Mid( pos ); TRAP( error, Xml::ParseL( *iParser, ptrUrl ) ); if ( !error ) { error = iErrorCode; } iTID = NULL; iContentUrl = NULL; delete iServerUrl; iServerUrl = NULL; } else { error = KErrCorrupt; } return error; }
void CPppMsChap2::ChallengeHashL(const TDesC8& aPeerChallenge, const TDesC8& aAuthenticatorChallenge, const TDesC8& aUserName, TDes8& aChallengeHash) /** Computes the hash of the Peer Challenge, Authenticator Challenge and username using SHA-1. @param aPeerChallenge [in] The Peer Challenge (16 octets). @param aAuthenticatorChallenge [in] The Authenticator Challenge (16 octets). @param aUserName [in] The Microsoft Windows NT username (0 to 256 char). @param aChallengeHash [out] The hash of the peer challenge, authenticator challenge and username, computed using SHA-1 (8 octets). @note This function implements the ChallengeHash routine specified in RFC 2759. @internalComponent */ { ASSERT(aPeerChallenge.Length() == KPppMsChap2PeerChallengeSize); ASSERT(aAuthenticatorChallenge.Length() == KPppMsChap2AuthenticatorChallengeSize); ASSERT(aUserName.Length() <= KPppMsChapMaxNTUserNameLength); ASSERT(aChallengeHash.Length()==KPppMsChap2ChallengeHashSize); CSHA1* sha1 = CSHA1::NewL(); CleanupStack::PushL(sha1); // RFC 2759: "Only the user name (as presented by the peer and // excluding any prepended domain name)" TPtrC8 userName(aUserName); TInt i = aUserName.Locate('\\'); if (i >= 0 && i < userName.Length() - 1) userName.Set(aUserName.Mid(i + 1)); else if (i >= userName.Length() - 1) User::Leave(KErrGeneral); sha1->Update(aPeerChallenge); sha1->Update(aAuthenticatorChallenge); aChallengeHash.Copy(sha1->Final(userName).Ptr(), KPppMsChap2ChallengeHashSize); CleanupStack::PopAndDestroy(sha1); ASSERT(aChallengeHash.Length()==KPppMsChap2ChallengeHashSize); }
// ----------------------------------------------------------------------------- // TSdpRtpmapValue::DecodeL // Decodes string and puts it into parts // ----------------------------------------------------------------------------- // EXPORT_C TSdpRtpmapValue TSdpRtpmapValue::DecodeL( const TDesC8& aText ) { __ASSERT_ALWAYS(aText.Length() > 0 && aText.Locate( KSlashChar ) != KErrNotFound, User::Leave(KErrSdpCodecMediaAttributeField)); TInt length( aText.Length() ); if ( aText[length - 1] == KLFChar ) { if ( length > 1 && aText[length - 2] == KCRChar ) { length--; } length--; } TPtrC8 restValue( aText.Left( length ) ); __ASSERT_ALWAYS(SdpUtil::IsByteString(restValue), User::Leave(KErrSdpCodecMediaAttributeField)); TInt pos = restValue.Locate( KSlashChar ); // <encoding name> TPtrC8 encName( restValue.Left( pos ) ); restValue.Set( restValue.Right( restValue.Length() - pos - 1 ) ); pos = restValue.Locate( KSlashChar ); // <clock rate> <encoding parameters> TPtrC8 encParam( KNullDesC8 ); TPtrC8 clockRate( KNullDesC8 ); if ( pos == KErrNotFound ) { clockRate.Set( restValue ); __ASSERT_ALWAYS( clockRate.Length() > 0 && encParam.Length() == 0, User::Leave( KErrSdpCodecMediaAttributeField ) ); } else { clockRate.Set( restValue.Left( pos ) ); encParam.Set( restValue.Right( restValue.Length() - pos - 1 ) ); __ASSERT_ALWAYS( clockRate.Length() > 0 && encParam.Length() > 0, User::Leave( KErrSdpCodecMediaAttributeField ) ); } return TSdpRtpmapValue( encName, clockRate, encParam ); }
// ----------------------------------------------------------------------------- // SdpUtil::IsValidChars // Checks if all the charcaters on the descriptor are from valid charset // ----------------------------------------------------------------------------- // TBool SdpUtil::IsValidChars( const TDesC8& aValidChars, const TDesC8& aDes ) { TBool valid( aDes.Length() > 0 ); for ( TInt i( 0 ); i < aDes.Length() && valid; i++ ) { if ( aValidChars.Locate( aDes[i] ) == KErrNotFound ) { valid = EFalse; } } return valid; }
bool splitPurl(const TDesC8& parturl, TPtrC8& hostnamePtrC8, int& port, int portMax) { int port_m1_index = parturl.Locate(':'); if(port_m1_index == KErrNotFound) { return false; } TLex8 portLex(parturl.Mid(port_m1_index + 1)); //port = atoi(port_m1 + 1); int result = portLex.Val(port); if(result != KErrNone || port <= 0 || port >= portMax) { return false; } hostnamePtrC8.Set(parturl.Left(port_m1_index)); return true; }
/** @internalComponent Parses a segment of the form name=value and returns the name and value parts @param aSegment the name-value segemnt to parse @param aName the name part that is returned @param aValue the value part that is returned */ void GetNameValuePair(const TDesC8& aSegment, TPtrC8& aName, TPtrC8& aValue) { TPtrC8 value; TInt sepPos = aSegment.Locate(KEqualsSeparator); if (sepPos != KErrNotFound) { aName.Set(aSegment.Left(sepPos)); value.Set(aSegment.Mid(sepPos+1)); } else { aName.Set(aSegment); } aValue.Set(value); }
void CHttpClientHeaderReader::SetCookieNameAndValueL(CHeaderFieldPart& aCookie, const TDesC8& aNameValue) const { TInt equalPos = aNameValue.Locate('='); if (equalPos <= 0) User::Leave(KErrHttpDecodeCookie); TPtrC8 nameVal(aNameValue.Left(equalPos)); InetProtTextUtils::RemoveWhiteSpace(nameVal, InetProtTextUtils::ERemoveBoth); TPtrC8 name(iStrPool.StringF(HTTP::ECookieName,iStringTable).DesC()); SetNewStringParamL(aCookie, name ,nameVal); TPtrC8 valueVal(aNameValue.Right(aNameValue.Length() - (equalPos+1))); InetProtTextUtils::RemoveWhiteSpace(valueVal, InetProtTextUtils::ERemoveBoth); TPtrC8 value(iStrPool.StringF(HTTP::ECookieValue,iStringTable).DesC()); SetNewStringParamL(aCookie, value ,valueVal); }
void CHttpConnection::HeaderLineHandlerL(const TDesC8& line) { LOGS("Handling header line \"%S\"\n", &line); if(line.Length() == 0) { CompleteReadHeaders(0, KErrNone); mState = FINISHED; return; } //format: "key: value" //const char* colon = strchr(baseLine, ':'); int colonIndex = line.Locate(':'); if(colonIndex != KErrNotFound) if(line[colonIndex + 1] != ' ') colonIndex = KErrNotFound; if(colonIndex == KErrNotFound) { LOG("HTTP bad header line: \"%S\"\n", &line); CompleteReadHeaders(CONNERR_PROTOCOL, 0); return; } TPtrC8 key(line.Left(colonIndex)); TPtrC8 value(line.Mid(colonIndex + 2)); LOGS("HTTP header %S: %S\n", &key, &value); //lower-case TCleaner<HBufC8> keyBuf(HBufC8::NewLC(key.Length())); keyBuf->Des().CopyLC(key); //if the key is already present, comma-combine the values. const TDesC8* oldValue = mResponseHeaders.find(*keyBuf); if(oldValue != NULL) { LOGS("Combined!\n"); //value = itr->second + ", " + value; _LIT(KCommaSpace, ", "); TCleaner<HBufC8> combBuf(HBufC8::NewLC(oldValue->Length() + KCommaSpace().Length() + value.Length())); TPtr8 combPtr(combBuf->Des()); combPtr.Append(*oldValue); combPtr.Append(KCommaSpace); combPtr.Append(value); mResponseHeaders.erase(*keyBuf); mResponseHeaders.insert(*keyBuf, combPtr); } else { mResponseHeaders.insert(*keyBuf, value); } }
// ----------------------------------------------------------------------------- // SdpUtil::IsTokenCharWithOptionalSlash // Checks if all the possible two elements divided by slash are valid tokens // ----------------------------------------------------------------------------- // TBool SdpUtil::IsTokenCharWithOptionalSlash(const TDesC8& aValue) { TInt lineEndPosition = aValue.Locate('/'); if ( lineEndPosition != KErrNotFound ) { TPtrC8 firstToken( aValue.Left( lineEndPosition ) ); if( !IsTokenChar( firstToken ) || !IsTokenChar( aValue.Mid( lineEndPosition + 1 ) ) ) { return EFalse; } } else { return IsTokenChar( aValue ); } return ETrue; }
void CSenPropertiesElement::BaseConstructL(const TDesC8& aNsUri, const TDesC8& aLocalName, const TDesC8& aQName, RStringPool* aStringPool) { ipStringPool = aStringPool; if (aLocalName == KNullDesC8) { User::Leave(KErrSenZeroLengthDescriptor); } SenXmlUtils::LeaveOnXmlEscapesL(aLocalName); if (aQName == KNullDesC8) { User::Leave(KErrSenZeroLengthDescriptor); } SenXmlUtils::LeaveOnXmlEscapesL(aQName); if ( ipStringPool ) { iLocalName = ipStringPool->OpenStringL(aLocalName); } else { Set(KNullDesC8, aLocalName, aLocalName); } TPtrC8 ptrPrefix(KNullDesC8); if (aQName.Length() > 0 ) { TInt colon = aQName.Locate(':'); if (colon > 0) // Note: 0 also treated as no prefix { ptrPrefix.Set(aQName.Ptr(),colon); } } SetNamespaceL(ptrPrefix, aNsUri); }
// ---------------------------------------------------------------------------- // CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader // ---------------------------------------------------------------------------- // TInt CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader( const TDesC8& aDrmHeader, HBufC8*& aServerURL ) { TInt error( KErrNone ); LOGFNR( "CWmDrmDlaParser::GetLicenseServerURLFromDRMHeader", error ); // Find beginning of XML document ('<') TInt pos = aDrmHeader.Locate( '<' ); if ( pos != KErrNotFound ) { iServerUrl = &aServerURL; iErrorCode = KErrNone; TPtrC8 ptrUrl = aDrmHeader.Mid( pos ); TRAP( error, Xml::ParseL( *iParser, ptrUrl ) ); if ( !error ) { error = iErrorCode; } iServerUrl = NULL; delete iTID; iTID = NULL; delete iContentUrl; iContentUrl = NULL; } else { error = KErrCorrupt; } return error; }
// --------------------------------------------------------------------------------- // CUpnpTmFilteredAppList::ParseAppFilterStringL // Method parses the descriptor containing the filter string // It parses the comma-separated list of A_ARG_TYPE_AppList schema // elements, attributes and their values // eg: "name="*Audio*",description="*",icon@mimetype="*svg+xml*", remotingInfo@protocolID="*", // appInfo@appCategory="*",audioInfo@audioType="*",resourceStatus="free",signature="*"" // @param aAppFilter Buffer containing application filter string // @param aErr[out] Terminal Mode error code // --------------------------------------------------------------------------------- // void CUpnpTmFilteredAppList::ParseAppFilterStringL( const TDesC8& aAppFilter, TTerminalModeErrorCode& aErr ) { OstTraceFunctionEntry0( CUPNPTMFILTEREDAPPLIST_PARSEAPPFILTERSTRINGL_ENTRY ); // Validate the filter string aErr = ETerminalModeSuccess; TInt quotePos = aAppFilter.Locate( KQuote ); if ( ( quotePos != 0 ) || ( aAppFilter.Find(KDoubleQuote) == KErrNotFound )) { // corrupt filter string aErr = ETerminalModeInvalidArgument; OstTrace1( TRACE_ERROR, DUP2_CUPNPTMFILTEREDAPPLIST_PARSEAPPFILTERSTRINGL, "CUpnpTmFilteredAppList::ParseAppFilterStringL;quotePos=%d", quotePos ); return; } RBuf8 filterBuffer; CleanupClosePushL(filterBuffer); /* Create a buffer having the content of AppFilter buffer but without the leading quote(") */ filterBuffer.CreateL(aAppFilter.Mid(quotePos+1)); TInt equalToQuoteToken; while( ( equalToQuoteToken = filterBuffer.Find(Keq)) != KErrNotFound ) { // Fetch the full key string TPtrC8 key = filterBuffer.Left(equalToQuoteToken); // Check for the presence of sub element by checking the @ in the key string TInt atTokenPos = key.Find(KAtToken); TBool displayInfo(EFalse); if ( atTokenPos != KErrNotFound ) { // @ is found in the key string // Now extract the parent element TPtrC8 parentKey = key.Left(atTokenPos); //Remove any leading and trailing whitespaces in the parent element const TDesC8& parentKeyWithoutSpace = RemoveWhiteSpace(parentKey); // Check if the parent elemet is one of desired element or not. // It should be one of the following : // <1> icon <2> remotingInfo <3> appInfo <4> displayInfo <5> audioInfo if ( ( parentKeyWithoutSpace.Compare(KIconElement) != KErrNone ) && ( parentKeyWithoutSpace.Compare(KRemotingInfo) != KErrNone ) && ( parentKeyWithoutSpace.Compare(KAppInfo) != KErrNone ) && ( parentKeyWithoutSpace.Compare(KDisplayInfo) != KErrNone ) && ( parentKeyWithoutSpace.Compare(KAudioInfo) != KErrNone ) ) { // parent element is not proper aErr = ETerminalModeInvalidArgument; break; } if ( parentKeyWithoutSpace.Compare(KDisplayInfo) == KErrNone ) { // The parent key element is displayInfo displayInfo = ETrue; } // Fetch the actual key name ( child element ) key.Set(key.Mid(atTokenPos+1)); } //Remove any leading and trailing whitespaces in the key const TDesC8& keyWithoutSpace = RemoveWhiteSpace(key); if ( (filterBuffer.Mid(equalToQuoteToken) ).Locate(KQuote) != 1 ) { // Missing quote(") ahead of the value aErr = ETerminalModeInvalidArgument; break; } TPtrC8 bufPtr = filterBuffer.Mid(equalToQuoteToken+2); quotePos = bufPtr.Locate( KQuote ); if ( quotePos == KErrNotFound ) { // missing quote (") at the end of the value aErr = ETerminalModeInvalidArgument; break; } /* Add the filter info as key-value pairs. // Also check if the parent key is display info. If display info flag is true then use the method with non default parameter */ if ( displayInfo ) { iFilterInfo->SetFilterInfoL( keyWithoutSpace, bufPtr.Left(quotePos), aErr, ETrue ); } else { // Use the method with default parameter iFilterInfo->SetFilterInfoL( keyWithoutSpace, bufPtr.Left(quotePos), aErr ); } if ( aErr != ETerminalModeSuccess ) { // Return the error code in case the key element is not as per the schema aErr = ETerminalModeInvalidArgument; break; } // Skip the quote position and set the buffer bufPtr.Set(bufPtr.Mid(quotePos+1)); if ( ( bufPtr.Locate(KCommaSeparator) != 0 ) && ( bufPtr.Locate(KQuote) != 0 ) ) { // missing quote (") or comma (,) following the quote. // Expected to be something of this kind ( ", or "" ) aErr = ETerminalModeInvalidArgument; break; } //Copy the residual content skipping two characters(", or "" ) in the actual buffer filterBuffer.Copy(bufPtr.Mid(UpnpString::KLinefeedLength)); } CleanupStack::PopAndDestroy(&filterBuffer); OstTrace1( TRACE_FLOW, CUPNPTMFILTEREDAPPLIST_PARSEAPPFILTERSTRINGL, "CUpnpTmFilteredAppList::ParseAppFilterStringL;aErr=%d", aErr ); OstTraceFunctionExit0( CUPNPTMFILTEREDAPPLIST_PARSEAPPFILTERSTRINGL_EXIT ); }
// ---------------------------------------------------------- // CSimplePresenceList::DoConstructL // ---------------------------------------------------------- // void CSimplePresenceList::DoConstructL( RPointerArray<CBodyPart>& aParts, const TDesC8& aStart ) { _LIT8( KMyContentType, "Content-Type: multipart/related;"); _LIT8( KMyBoundary, "boundary="); const TInt myBoundaryLen = 9; // boundary= 9 characters // Handle body parts one by one TInt size = aParts.Count(); TInt i; CBodyPart* cp = NULL; TPtrC8 boundary; TPtrC8 start; // remove "..." quoted marks when needed TPtrC8 pStartUnquoted( KNullDesC8 ); if ( aStart.Locate( '"') == 0 ) { pStartUnquoted.Set( aStart.Mid( 1, aStart.Length() - 2 )); } else { pStartUnquoted.Set( aStart ); } // remove <...> marks when needed if ( pStartUnquoted.Locate( '<') == 0 ) { pStartUnquoted.Set( pStartUnquoted.Mid( 1, pStartUnquoted.Length() - 2 )); } TPtrC8 p8; p8.Set( KSimpleDocumentType ); TInt mySize = p8.Length(); p8.Set( KSimpleMultipartType ); TInt mySize2 = p8.Length(); #ifdef _DEBUG TPtrC p16b; // notice: for debug TPtrC8 p8b; #endif // Make this handle direct content too in the RLMI list, i.e. // content-type: multipart/related; type="application/pidf+xml"; boundary=...; for (i = 0; i < size; i++) { cp = aParts[i]; // inline const TDesC8& Headers() { return iHeaders; } TPtrC8 allHeaders = cp->Headers(); HBufC8* headersBuff = allHeaders.AllocL(); CleanupStack::PushL( headersBuff ); #ifdef _DEBUG p16b.Set( cp->Url() ); // debug only p8b.Set( cp->ContentType() ); // debug only p8b.Set( cp->ContentID() ); // debug only #endif if ( !pStartUnquoted.Compare( cp->ContentID()) && !cp->ContentType().Left(sizeof(KSimpleListType)).CompareF( KSimpleListType )) { // Meta data is the root iMeta = CSimpleMeta::NewL( cp->Body() ); } else if ( !cp->ContentType().CompareF( KSimpleDocumentType )) { // Ordinary presence element CSimpleDocument* cd = CSimpleDocument::NewL( cp->Body() ); CleanupStack::PushL( cd ); User::LeaveIfError( iDocuments.Append( cd ) ); CleanupStack::Pop( cd ); } else if ( (!cp->ContentType().Left(mySize2).CompareF( KSimpleMultipartType ))) { // multipart for user's direct content data // get boundary from headers TPtrC8 pStart(KNullDesC8); TPtrC8 pBoundary(KNullDesC8); TPtrC8 pHeaders = headersBuff->Des(); TPtrC8 pContentType; TInt pos1 = pHeaders.Find( KMyContentType ); if ( pos1 >= 0 ) { TPtrC8 h2 = pHeaders.Mid( pos1 ); TInt pos2 = h2.Locate( '\r'); if ( pos2 < 0 ) { pContentType.Set( h2 ); } else { pContentType.Set( h2.Left( h2.Length() - pos2 )); } // search boundary TInt posx = pContentType.Find( KMyBoundary ); if ( posx >= 0 ) { TPtrC8 h5 = pContentType.Mid( posx ); TInt pos5 = h5.Locate( ';'); if ( pos5 < 0 ) { // There are no more parameters pBoundary.Set( h5.Mid( myBoundaryLen )); } else { // There are more in the line, has to cut off pBoundary.Set( h5.Mid( myBoundaryLen, pos5 - myBoundaryLen )); } } } // "..." characters are removed later from boundary in NewInMultiPartL( CSimpleDocument* cd = CSimpleDocument::NewInMultiPartL( cp->Body(), pBoundary, pStart ); CleanupStack::PushL( cd ); User::LeaveIfError( iDocuments.Append( cd ) ); CleanupStack::Pop( cd ); } /* notice: later nested multiparts if type = rlmi */ else { // This is something that should not be in the document. // Ignore it. } CleanupStack::PopAndDestroy( headersBuff ); } }
/** Parse the flags data and update to iFlags. @param aFlagsData contains list of flags to be parsed. @return The remaining portion of the aFlagsData parameter that was not parsed. */ TPtrC8 TMessageFlagInfo::ParseFlagsL(const TDesC8& aFlagsData) { // formal definition of the FLAGS data item of a FETCH FLAGS is // // msg-att-dynamic = "FLAGS" SP "(" [flag-fetch *(SP flag-fetch)] ")" // // flag-fetch = flag / "\Recent" // flag = "\Answered" / "\Flagged" / "\Deleted" / "\Seen" / "\Draft" / flag-keyword / flag-extension // flag-extension = "\" atom // flag-keyword = atom // // TPtrC8 parseData(aFlagsData); TInt start = aFlagsData.Locate('('); TInt end = aFlagsData.Locate(')'); // Reset the flags, prior to setting them. iFlags = 0; // Now set them. if ((start >= 0) && (end > start)) { RDesParts flags; CleanupClosePushL(flags); // lose the brackets parseData.Set(aFlagsData.Mid(start+1, end-start-1)); CImapCommand::GetDelimitedPartsL(' ', parseData, flags); TInt flagsCount = flags.Count(); for (TInt i = 0; i < flagsCount; ++i) { TPtrC8 flag = flags[i]; if(flag.CompareF(KImapTxtFlagDeleted) == 0) { SetFlag(TMessageFlagInfo::EDeleted, ETrue); } else if (flag.CompareF(KImapTxtFlagSeen) == 0) { SetFlag(TMessageFlagInfo::ESeen, ETrue); } else if(flag.CompareF(KImapTxtFlagFlagged) == 0) { SetFlag(TMessageFlagInfo::EFlagged, ETrue); } else if(flag.CompareF(KImapTxtFlagAnswered) == 0) { SetFlag(TMessageFlagInfo::EAnswered, ETrue); } else if(flag.CompareF(KImapTxtFlagDraft) == 0) { SetFlag(TMessageFlagInfo::EDraft, ETrue); } else if(flag.CompareF(KImapTxtFlagRecent) == 0) { SetFlag(TMessageFlagInfo::ERecent, ETrue); } } // return the remainder. // if there is a space after the closing bracket, // then remainder should start after the space. if (aFlagsData.Length() > end + 1) { if (aFlagsData[end+1] == ' ') { ++end; } } if (aFlagsData.Length() > end) { parseData.Set(aFlagsData.Mid(end + 1)); } else { parseData.Set(aFlagsData.Right(0)); } CleanupStack::PopAndDestroy(&flags); } return parseData; }
void CHTTPSession::InitializeFiltersL(const TDesC8& aProtocol) { __START_PERFORMANCE_LOGGER(); const TChar protocolSeparatorChar = '/'; // Get list of ECOM plugins that match the interface UID REComSession::ListImplementationsL(KUidFilterPluginInterface, iEComFilterInfoArray); // Locate the protocol separator and return with errorcode if its not found as its invalid const TInt clientProtSeparator = aProtocol.Locate(protocolSeparatorChar); if( clientProtSeparator == KErrNotFound ) User::Leave(KErrNotFound); // Store the protocol provided by the client TPtrC8 clientProtocol(aProtocol.Left(clientProtSeparator)); // Loop through all the filter plugins found by ECom const TInt filterCount = iEComFilterInfoArray.Count(); for(TInt ii=0; ii<filterCount; ++ii) { // Get the descriptor with the filter datatype TPtrC8 filterProtocol(iEComFilterInfoArray[ii]->DataType()); // Find the protocol in the data type, if thats not found then find the TFCORE data type TInt protocolDataTypeStart = filterProtocol.FindF(clientProtocol); TInt protocolLength = clientProtocol.Length(); if( protocolDataTypeStart == KErrNotFound ) { protocolDataTypeStart = filterProtocol.FindF(KTxtCoreFilterProtocol()); protocolLength = KTxtCoreFilterProtocol().Length(); } // Build table of plugins of core and specified protocol filters if( protocolDataTypeStart > KErrNotFound ) { // Set the offset for the beginning of the filter type and check that the seperator exists TInt offset = protocolDataTypeStart + protocolLength; if( filterProtocol[offset] != STATIC_CAST(TUint8, protocolSeparatorChar) ) User::Leave(KErrNotFound); // Increment the offset for the seperator ++offset; // Ensure that there is data after the seperator if( filterProtocol.Length() <= offset ) User::Leave(KErrNotFound); // Create a TSessionFilterInfo with the filter plugin data and append to client array TSessionFilterInfo* filterInfo = new(ELeave) TSessionFilterInfo; CleanupStack::PushL(filterInfo); // Set the filter properties filterInfo->iFilterInfo = iEComFilterInfoArray[ii]; // Get the category of the filter from the filter data type const TUint KTxtExplicitChar = '-'; const TUint KTxtMandatoryChar = '+'; TChar filterSymbol(filterProtocol[offset]); if( filterSymbol==KTxtExplicitChar) { filterInfo->iCategory = TSessionFilterInfo::EExplicit; filterInfo->iFilterPlugin = NULL; } else if( filterSymbol==KTxtMandatoryChar ) { filterInfo->iCategory = TSessionFilterInfo::EMandatory; // Install the filter // This should leave as the filter is mandatory filterInfo->iFilterPlugin = CEComFilter::InstallFilterL(this->Handle(), iEComFilterInfoArray[ii]->ImplementationUid()); } else { filterInfo->iCategory = TSessionFilterInfo::EImplicit; // Install the filter // This is trapped if it leaves as the transport framework should be able to plough on without it // But leave if the error is KErrNoMemory. TRAPD ( err, filterInfo->iFilterPlugin = CEComFilter::InstallFilterL(this->Handle(), iEComFilterInfoArray[ii]->ImplementationUid()) ); if ( err == KErrNoMemory ) { User::Leave ( err ); } } // Add the filter information to the list User::LeaveIfError(iFilterInfoList.Append(filterInfo)); CleanupStack::Pop(filterInfo); } } __END_PERFORMANCE_LOGGER(_L(",CHTTPSession::InitializeFiltersL()")); }