void CUPnPHeaderReader::DecodeGenericNumberL(RHeaderField& aHeader) const { TPtrC8 buffer; aHeader.RawDataL(buffer); TInt number = KErrNotFound; TInt decimalPos = buffer.Locate('.'); if(decimalPos == 0) { // first character is decimal. So, set the value as zero. SetNewIntegerPartL(aHeader, 0, 0); } else { // Search for '\n' separator. In the case when a duplicate header has been received, // only use the fist instance of the valid data. TInt newLinePos = buffer.Locate('\n'); if (newLinePos != KErrNotFound) { buffer.Set(buffer.Left(newLinePos)); } TInt value = KErrNotFound; TInt ret = InetProtTextUtils::ConvertDescriptorToInt(buffer, value); if ( ret > KErrNone ) { // Extract an integer. Do not permit terminators other than WS or EOL. InetProtTextUtils::ExtractIntegerValueL(buffer, number, EFalse); } SetNewIntegerPartL(aHeader, 0, number); // part 0, i.e. the first (and only) part } }
void CUPnPHeaderReader::DecodeTimeoutHeaderL(RHeaderField& aHeader) const { TPtrC8 buffer; aHeader.RawDataL(buffer); // Search for '\n' separator. In the case when a duplicate header has been received, // only use the fist instance of the valid data. TInt newLinePos = buffer.Locate('\n'); if (newLinePos != KErrNotFound) { buffer.Set(buffer.Left(newLinePos)); } RStringF infinite = iStringPool.StringF(UPnP::EInfinite, TUPnPTable::Table()); if(buffer.Compare(infinite.DesC()) == 0) { SetNewIntegerPartL(aHeader, 0, -(KMaxTInt)); } else { TPtrC8 token; InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KSemiSpaceSep); TInt consumed = token.Locate('-'); token.Set(token.Mid(consumed+1)); TInt intVal; InetProtTextUtils::ConvertDescriptorToInt(token, intVal); SetNewIntegerPartL(aHeader, 0, intVal); // part 0, i.e. the first (and only) part } }
void CApaDRMRecognizer::DoRecognizeL( const TDesC& aName, const TDesC8& aBuffer ) { if ( aBuffer.Size() < 3) { return; } #ifdef RECOGNIZE_KEY_CHAIN // Recognize device key chain if ( aName.Length() > 3 && aName.Right(4).CompareF(_L(".dkc")) == 0) { iConfidence = ECertain; iDataType = TDataType( _L8("application/x-device-key-chain") ); return; } #endif #ifdef DRM_OMA2_ENABLED // Recognize ROAP Trigger if ( RecognizeRoapTrigger( aBuffer ) ) { return; } // Recognize DCFv2 if ( RecognizeODF( aBuffer ) ) { return; } #endif // Recognize DCFv1 TUint8 version = aBuffer[0]; TUint8 contentTypeLen = aBuffer[1]; TUint8 contentURILen = aBuffer[2]; if ( contentTypeLen < KMinContentTypeLen || contentURILen == 0 ) { return; } if ( version != KDCFVersionSupported ) { return; } // Too little data received if ( aBuffer.Size() < ( contentTypeLen + KDCFHeaderLength ) ) { return; } TPtrC8 mimeType = aBuffer.Mid( KDCFHeaderLength, contentTypeLen ); if ( mimeType.Locate( '/' ) != KErrNotFound ) { iConfidence = ECertain; iDataType=TDataType( mimeType ); } return; }
void CUPnPHeaderReader::DecodeCallbackL(RHeaderField& aHeader) const { //Callback: <token1><token2><token3>...<tokenN> TPtrC8 rawData; aHeader.RawDataL(rawData); TInt remaining = rawData.Length(); TPtrC8 token; TInt tokensFound = 0; TInt consumed; while (remaining) { // Locate and remove the '<' character from the token consumed = rawData.Locate(KOpenAngleBracket); if(consumed == KErrNotFound) { // No more tokens. break; } // '<' character has now been removed. rawData.Set(rawData.Mid(consumed+1)); // Now extract the value before '>' character. // This will be the actual value of the token. remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KCloseAngleBracket); // No parameters. Just store the field value InetProtTextUtils::RemoveWhiteSpace(token, InetProtTextUtils::ERemoveBoth); SetNewFStringPartL(aHeader, tokensFound, token); ++tokensFound; } }
/** Checks that a Query/Header is in a valid form as specified in RFC 3261. @return A boolean value of ETrue if uri contains valid Query/Header, EFalse if it does not. */ TBool TValidatorSip::IsValidQuery() const { const TDesC8& headers = iUri.Extract(EUriQuery); if (IsEmpty(headers)) { return EFalse; } TDelimitedQueryParser8 parser; parser.Parse(headers); TPtrC8 name; TPtrC8 value; TPtrC8 segment; while( parser.GetNext(segment) == KErrNone ) { // must be in the form name=value even if the value part is empty if (segment.Locate(KEqualsSeparator) == KErrNotFound) { return EFalse; } GetNameValuePair(segment, name, value); if (IsDuplicated(name, parser) || !IsValidHeaderSegment(name, value)) { return EFalse; } } return ETrue; }
/** Parses the descriptor aUri into uri components. @param aUri A reference to a descriptor pointer of an Uri. @param aScheme A reference to a descriptor pointer for retieved scheme component. */ void TUriParser8::RetrieveScheme(const TPtrC8& aUri, TPtrC8& aScheme) { TInt schemePos = aUri.Locate(KSchemeDelimiter); if(schemePos != KErrNotFound) { // Got a scheme - store information aScheme.Set(aUri.Left(schemePos)); } }
TInt CExampleCookieManager::CountSeparators(const TDesC8& aDes) { const TChar pathSeparator('/'); TInt numSeps = 0; // Get all the descriptor to start with TPtrC8 desPtr = aDes.Mid(0); TInt sepPos = desPtr.Locate(pathSeparator); while(sepPos != KErrNotFound) { ++numSeps; // Get the rest of the descriptor without the separator that we have found desPtr.Set(desPtr.Mid(sepPos + 1)); sepPos = desPtr.Locate(pathSeparator); } return numSeps; }
void RElementIdArray::SetListL( const TDesC8& aChilds) { TInt index = 0; TPtrC8 ptr = aChilds; while ( 0 <= ( index = ptr.Locate( KMessageDelimiterChar))) { AppendL( ptr.Left( index).AllocL()); ptr.Set( ptr.Mid(index + 1)); } }
// ----------------------------------------------------------------------------- // SdpUtil::IsTokenTextPair // Checks if aValue is valid pair ("valid token":"valid byte-string") // ----------------------------------------------------------------------------- // TBool SdpUtil::IsTokenTextPair( const TDesC8& aValue, TInt aStart, TInt aEnd ) { // token ":" text TBool result = EFalse; if ( aStart >= 0 && aEnd <= aValue.Length() && aStart < aEnd ) { TPtrC8 subVal = aValue.Mid( aStart, aEnd - aStart ); TInt colonPos = subVal.Locate( KColonChar ); result = colonPos != KErrNone && IsToken( subVal, 0, colonPos ) && IsByteString( subVal, colonPos + 1, subVal.Length() ); } return result; }
void CUPnPHeaderReader::DecodeGenericUpnpHeadersL(RHeaderField& aHeader) const { TPtrC8 buffer; aHeader.RawDataL(buffer); // Search for '\n' separator. In the case when a duplicate header has been received, // only use the fist instance of the valid data. TInt newLinePos = buffer.Locate('\n'); if (newLinePos != KErrNotFound) { buffer.Set(buffer.Left(newLinePos)); } TPtrC8 token; InetProtTextUtils::ExtractNextTokenFromList(buffer, token, KSemiSpaceSep); SetNewFStringPartL(aHeader, 0, token); // part 0, i.e. the first (and only) part }
// ----------------------------------------------------------------------------- // MceSip::ToSIPExtensionHeadersL // ----------------------------------------------------------------------------- // void MceSip::ToSIPExtensionHeadersL( RPointerArray<CSIPHeaderBase>& aSIPHeaders, const MDesC8Array& aHeaders ) { for ( int i = 0; i < aHeaders.MdcaCount(); i++ ) { TPtrC8 param = aHeaders.MdcaPoint( i ); TInt index = param.Locate( KMceSipSeparator ); if ( index != KErrNotFound && param.Left( index ) != KMceSipSubscriptionStateHeader ) { CSIPExtensionHeader* extHeader = CSIPExtensionHeader::NewL( param.Left(index), param.Right( param.Length() - ( index + 1 ) ) ); CleanupStack::PushL( extHeader ); User::LeaveIfError( aSIPHeaders.Append( extHeader ) ); CleanupStack::Pop( extHeader ); } } }
// --------------------------------------------------------- // CDdEng::ParseLicenseL() // --------------------------------------------------------- // void CDdEng::ParseLicenseL() { HBufC8* descriptorBuf = CodUtil::ConvertLC( iCodBuf->Des()); TPtrC8 license; TPtrC8 descriptor (descriptorBuf->Ptr()); TInt startTag = descriptor.Find(KLicenseStartTag); // "<license" if (startTag != KErrNotFound) { descriptor.Set(descriptor.Right(descriptor.Length()- startTag -1)); TInt endTag = descriptor.Locate(KElementEnd); //'>' if (endTag != KErrNotFound) { license.Set(descriptor.Right(descriptor.Length()-endTag-1)); TInt licenseTagEnd = license.Find(KLicenseEndTag); // "</license" if (licenseTagEnd != KErrNotFound) { license.Set(license.Left(licenseTagEnd)); } } } iSaver->AppendData( license ); CleanupStack::PopAndDestroy( descriptorBuf ); }
TBool CExampleCookieManager::ValidateCookieL(CCookie& aCookie, const TUriC8& aUri) { THTTPHdrVal attributeVal; if(aCookie.Attribute(CCookie::EPath, attributeVal) == KErrNone) { // if the path attribute exists check it is a prefix of the path // of the uri that issued it (if not reject) RStringF cookiePath = attributeVal.StrF(); const TDesC8& uriPath = aUri.Extract(EUriPath); if(uriPath.FindF(RemoveQuotes(cookiePath.DesC())) != 0) return EFalse; } else { // if the path attribute doesn't exist add it THTTPHdrVal val(iStringPool.OpenFStringL(aUri.Extract(EUriPath))); aCookie.SetAttributeL(CCookie::EPath, val); } if(aCookie.Attribute(CCookie::EDomain, attributeVal) == KErrNone) { const TChar dot('.'); const TDesC8& cookieDomain = attributeVal.StrF().DesC(); const TDesC8& uriDomain = aUri.Extract(EUriHost); // if the domain does not exactly match the uri and does not begin // with a dot then add one if((cookieDomain.Compare(uriDomain) != 0) && (cookieDomain.Locate(dot) != 0)) { _LIT8(KAddDotString, ".%S"); HBufC8* newDomain = HBufC8::NewLC(cookieDomain.Length() + 1); newDomain->Des().AppendFormat(KAddDotString(), &cookieDomain); RStringF domain = iStringPool.OpenFStringL(*newDomain); CleanupStack::PopAndDestroy(newDomain); THTTPHdrVal val(domain); aCookie.SetAttributeL(CCookie::EDomain, val); domain.Close(); } // if the domain does not contain an embedded dot then reject it // ie reject .com or .com. // Start by removing one character from each end. ie start at pos 1 and take a length // which is 2 shorter than the original descriptor TPtrC8 domainMiddle = cookieDomain.Mid(1, cookieDomain.Length() - 2); if(domainMiddle.Locate(dot) == KErrNotFound) return EFalse; // Reject the cookie if the domain differs by two or more levels from the uri // ie if uri=www.x.y.com then accept a cookie with .x.y.com but reject .y.com TInt pos = uriDomain.FindF(cookieDomain); if(pos > 2) { const TDesC8& domainDiff = uriDomain.Left(pos); // Remove one character from each end. ie start at pos 1 and take a length // which is 2 shorter than the original descriptor const TDesC8& diffMiddle = domainDiff.Mid(1, domainDiff.Length() - 2); if(diffMiddle.Locate(dot) != KErrNotFound) return EFalse; } } else { // if the domain attribute is not found add it THTTPHdrVal val(iStringPool.OpenFStringL(aUri.Extract(EUriHost))); aCookie.SetAttributeL(CCookie::EDomain, val); val.StrF().Close(); } if(!CheckPortMatch(aCookie, aUri)) return EFalse; return ETrue; }
SYSCALL(MAHandle, maConnect(const char* url)) { TPtrC8 urlP(CBP url, SYSCALL_THIS->ValidatedStrLen(url)); LOGST("Connect %i %s", gConnNextHandle, url); if(gConnections.size() >= CONN_MAX) return CONNERR_MAX; _LIT8(KLocalhost, "localhost"); CConnection* conn = NULL; TPtrC8 match; SocketType socketType = TCP; // initialized to placate stupid compiler ConnectionType type; // determine type of connection if(SSTREQ(urlP, KSocket)) { match.Set(KSocket); type = eSocket; socketType = TCP; } else if(SSTREQ(urlP, KDatagram)) { match.Set(KDatagram); type = eSocket; socketType = UDP; } else if(SSTREQ(urlP, KSsl)) { match.Set(KSsl); type = eSocket; socketType = SSL; } else if(SSTREQ(urlP, KHttp)) { match.Set(KHttp); type = eHttp; socketType = TCP; } else if(SSTREQ(urlP, KHttps)) { match.Set(KHttps); type = eHttp; socketType = SSL; } else if(SSTREQ(urlP, KBtspp)) { match.Set(KBtspp); type = eBtspp; } else { //error return CONNERR_URL; } TPtrC8 parturl = urlP.Mid(match.Length()); if(type == eSocket) { TPtrC8 hostnamePtrC8; int port; if(!splitPurl(parturl, hostnamePtrC8, port, (1<<16))) { return CONNERR_URL; } Smartie<CSocket> sockp(createSocket(socketType)); _LIT8(K127, "127."); TInetAddr addr; bool localhost = false; if(hostnamePtrC8 == KLocalhost) { localhost = true; addr.SetAddress(INET_ADDR(127,0,0,1)); } else if(hostnamePtrC8.Length() > K127().Length()) { if(hostnamePtrC8.Left(K127().Length()) == K127) { localhost = true; Smartie<HBufC16> hostname(CreateHBufC16FromDesC8LC(hostnamePtrC8)); addr.Input(*hostname()); } } sockp->state |= CONNOP_CONNECT; if(localhost) { StartConnOpL(CO_AddrConnect::NewL(false, *this, gConnNextHandle, *sockp(), addr, port, *sockp())); } else { Smartie<HBufC16> hostname(CreateHBufC16FromDesC8LC(hostnamePtrC8)); CleanupStack::Pop(hostname()); StartConnOpL(CO_NameConnect::NewL(gNetworkingState != EStarted, *this, gConnNextHandle, *sockp(), hostname, port, *sockp())); } conn = sockp.extract(); } else if(type == eHttp) { CHttpConnection* http; TLTZ_PASS(httpCreateConnectionLC(parturl, http, HTTP_GET, socketType)); http->state |= CONNOP_CONNECT; StartConnOpL(CO_HttpFinish::NewL(gNetworkingState != EStarted, *this, gConnNextHandle, *http, *http, true)); http->mState = CHttpConnection::WRITING; conn = http; CleanupStack::Pop(conn); } else if(type == eBtspp) { if(gBtState != eAvailable) { return CONNERR_UNAVAILABLE; } TPtrC8 hostnamePtrC8; int port_m1_index = parturl.Locate(':'); if(port_m1_index == KErrNotFound) { return false; } hostnamePtrC8.Set(parturl.Left(port_m1_index)); if(hostnamePtrC8 == KLocalhost) { // server // extract and parse uuid static const int KUuidLength = 32; int uuidStartIndex = port_m1_index + 1; int paramStartIndex = uuidStartIndex + KUuidLength; if(parturl.Length() < paramStartIndex) { return CONNERR_URL; } TPtrC8 uuidPtrC8(parturl.Mid(uuidStartIndex, KUuidLength)); TUint32 us[4]; for(int i=0; i<4; i++) { TPtrC8 p(uuidPtrC8.Mid(i*8, 8)); for(int j=0; j<8; j++) { if(!TChar(p[j]).IsHexDigit()) return CONNERR_URL; } LHEL(TLex8(p).Val(us[i], EHex)); } TUUID uuid(us[0], us[1], us[2], us[3]); //TUUID uuid(KSerialPortUUID); //temp hack // create listener socket Smartie<CBtServerSocket> sockp(new (ELeave) CBtServerSocket(gBtSdpDB)); // extract name, if it's there. initialize the socket. TPtrC8 paramPtrC8(parturl.Mid(paramStartIndex)); _LIT8(KNameParam, ";name="); if(SSTREQ(paramPtrC8, KNameParam)) { TPtrC8 namePtrC8(paramPtrC8.Mid(KNameParam().Length())); sockp->init(gSocketServ, uuid, true, namePtrC8); } else if(paramPtrC8.Length() == 0) { sockp->init(gSocketServ, uuid, false); } else { return CONNERR_URL; } //skip the async/connect step gConnections.insert(gConnNextHandle, sockp.extract()); return gConnNextHandle++; } else { // client // extract port number int port; if(!splitPurl(parturl, hostnamePtrC8, port, 31)) { return CONNERR_URL; } TRfcommSockAddr rfcsa; // parse address TBTDevAddr btaddr; for(int i=0; i<BTADDR_LEN; i++) { TLex8 btaLex(parturl.Mid(i*2, 2)); int result = btaLex.Val(btaddr[i], EHex); if(result != KErrNone) return CONNERR_URL; } rfcsa.SetBTAddr(btaddr); // create socket Smartie<CSocket> sockp(new (ELeave) CSocket(gSocketServ, CSocket::ERfcomm)); sockp->state |= CONNOP_CONNECT; StartConnOpL(CO_AddrConnect::NewL(false, *this, gConnNextHandle, *sockp(), rfcsa, port, *sockp())); conn = sockp.extract(); } } CleanupStack::PushL(conn); gConnections.insert(gConnNextHandle, conn); CleanupStack::Pop(conn); return gConnNextHandle++; }
// Convert the WWW-Authenticate header field from OTA to generic form. void CHttpClientHeaderReader::DecodeWWWAuthenticateL( RHeaderField& aHeader ) const { // RFC2616, section 14.47 WWW-Authenticate // RFC2617, 'HTTP Authentication: Basic and Digest Access Authentication' // // WWW-Authenticate = "WWW-Authenticate" ":" 1#challenge // challenge = auth-scheme 1*SP 1#auth-param // auth-scheme = token // auth-param = token "=" ( token | quoted-string ) // There may be one or more challenge, in a comma-separated list. TPtrC8 buffer; aHeader.RawDataL( buffer ); TInt totalBytesConsumed = 0; TInt numChallenges = 0; CHeaderFieldPart* part = NULL; TBool done = EFalse; while ( !done ) { _LIT8( commaSpaceNewline, ", \n" ); TPtrC8 token; TInt bytesConsumed = InetProtTextUtils::ExtractNextTokenFromList( buffer, token, commaSpaceNewline ); done = (bytesConsumed == 0); if ( done && ( numChallenges == 0 ) ) // if we didn't find _anything_ at all... { User::Leave( KErrHttpDecodeWWWAuthenticate ); } if ( !done && ( token.Length() > 0 ) ) { totalBytesConsumed += bytesConsumed; TBool equalsPresent = ( token.Locate( '=' ) != KErrNotFound ); if ( ( totalBytesConsumed == bytesConsumed ) && equalsPresent ) { // The first token has an equals sign in it. That // can't be as it has to be an authentication scheme User::Leave( KErrHttpDecodeWWWAuthenticate ); } if ( !equalsPresent ) { // Got a new part. Add it. ++numChallenges; part = SetNewFStringPartL( aHeader, numChallenges - 1, token ); if( token.Compare( iStrPool.StringF(HTTP::ENTLM, iStringTable).DesC() ) == 0 ) { TInt consumed = InetProtTextUtils::ExtractNextTokenFromList( buffer, token, commaSpaceNewline ); if( consumed > 0 ) { ++numChallenges; part = SetNewFStringPartL( aHeader, numChallenges -1, token ); } } } else { // Got a param & parameter value. TPtrC8 paramName; TInt paramBytesConsumed = InetProtTextUtils::ExtractNextTokenFromList( token, paramName, '=' ); if ( paramBytesConsumed == 0 ) { User::Leave( KErrHttpDecodeBasicAuth ); } // Obtain the parameter value. It is a string which // may or may not be quoted. TPtrC8 paramVal; if ( token.Length() > 0 && token[0] == '"' ) { bytesConsumed += InetProtTextUtils::ExtractQuotedStringL( token, paramVal ); } else { paramVal.Set( token ); } SetNewStringParamL( *part, paramName, paramVal ); } } } }
// --------------------------------------------------------------------------- // CNSmlDmACLParser::ParseL() // Parses ACL data and keeps data until Reset() is called or instance // is destructed // --------------------------------------------------------------------------- TInt CNSmlDmACLParser::ParseL(const TDesC8& aACL) { Reset(); for(TInt i=EAclExecute;i>=EAclAdd;i--) { TInt aclStart = 0; TBool found=EFalse; switch(i) { case EAclAdd: aclStart = aACL.Find(KNSmlDmAclAddEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclAddEqual().Length(); break; case EAclReplace: aclStart = aACL.Find(KNSmlDmAclReplaceEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclReplaceEqual().Length(); break; case EAclDelete: aclStart = aACL.Find(KNSmlDmAclDeleteEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclDeleteEqual().Length(); break; case EAclGet: aclStart = aACL.Find(KNSmlDmAclGetEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclGetEqual().Length(); break; case EAclExecute: aclStart = aACL.Find(KNSmlDmAclExecEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclExecEqual().Length(); break; default: User::Panic(KSmlDmTreeDbHandlerPanic,KErrArgument); break; } if(found) { TInt aclStop = aACL.Right(aACL.Length()-aclStart). Locate(KNSmlDMAclCommandSeparator); if(aclStop<0) { aclStop = aACL.Length()-aclStart; } TPtrC8 commandAcl = aACL.Mid(aclStart,aclStop); CNSmlAclElement* aclElement = new(ELeave) CNSmlAclElement(); aclElement->iCommandType = (TNSmlDmCmdType)i; aclElement->iNext = iCommandAcls; iCommandAcls=aclElement; if(commandAcl.Compare(KNSmlDmAclAll)==0) { aclElement->iAllServers=ETrue; } else { TBool end = EFalse; TInt serverIdStart=0; while(!end) { TPtrC8 serverIdPtr = commandAcl.Right(commandAcl.Length()-serverIdStart); TInt serverIdStop = serverIdPtr.Locate(KNSmlDMAclSeparator); if(serverIdStop == KErrNotFound) { serverIdStop=commandAcl.Length(); end=ETrue; } HBufC8* serverId = serverIdPtr.Left(serverIdStop).AllocL(); aclElement->iServerIds.AppendL(serverId); serverIdStart=serverIdStart+serverIdStop+1; } } } } return KErrNone; }
/** ConstructL() Parses a .txt file and creates Arrays of fields and there values @param aFileName Name of the file to be parsed. */ EXPORT_C void CT_MsgUtilsConfigFileParserUtility::ConstructL(const TDesC& aFileName) { RFs fileServerSession; fileServerSession.Connect(); RFile file; User::LeaveIfError(file.Open(fileServerSession, aFileName, EFileRead)); TInt eof = EFalse; TInt fileOffset = 0; TBuf8<KFileBufferSize> fileBuffer; while (!eof) { fileBuffer.SetLength(0); User::LeaveIfError(file.Read(fileOffset, fileBuffer, KFileBufferSize)); TInt read = fileBuffer.Length(); if (read < KFileBufferSize) { fileBuffer.Append('\n'); eof = ETrue; } TInt lineOverflow = fileBuffer.Locate('\n'); if ((lineOverflow == KErrNotFound) && (read == KFileBufferSize)) { User::Leave(KErrOverflow); } TInt eol = EFalse; while (!eol) { TInt lineFeedLocation = fileBuffer.Locate('\n'); if (lineFeedLocation == KErrNotFound) { eol = ETrue; } else { fileOffset += lineFeedLocation + 1; TInt lineLength; if ((lineFeedLocation != 0) && (fileBuffer[lineFeedLocation - 1] == '\r')) { lineLength = lineFeedLocation - 1; } else { lineLength = lineFeedLocation; } TPtrC8 line = fileBuffer.Left(lineLength); TInt commentLocation = line.Match(KComment); if (commentLocation != KErrNotFound) { TPtrC8 skipComment = line.Left(commentLocation); line.Set(skipComment); } TInt seperatorLocation = line.Locate('='); if (seperatorLocation != KErrNotFound) { if ((seperatorLocation == 0) || (seperatorLocation == line.Length() - 1)) { seperatorLocation = KErrNotFound; } } if (seperatorLocation != KErrNotFound) { TPtrC8 namePtr = line.Left(seperatorLocation); HBufC8* nameBuf8 = HBufC8::NewL(namePtr.Length()); CleanupStack::PushL(nameBuf8); TPtr8 name8 = nameBuf8->Des(); name8.Copy(namePtr); name8.Trim(); HBufC* nameBuf16 = HBufC::NewL(namePtr.Length()); TPtr name16 = nameBuf16->Des(); name16.Copy(name8); iName.Append(nameBuf16); CleanupStack::PopAndDestroy(nameBuf8); TPtrC8 contentPtr = line.Mid(seperatorLocation + 1); HBufC8* contentBuf8 = HBufC8::NewL(contentPtr.Length()); CleanupStack::PushL(contentBuf8); TPtr8 content8 = contentBuf8->Des(); content8.Copy(contentPtr); content8.Trim(); HBufC* contentBuf16 = HBufC::NewL(contentPtr.Length()); TPtr content16 = contentBuf16->Des(); content16.Copy(content8); iContent.Append(contentBuf16); iContent8.Append(contentBuf8); CleanupStack::Pop(contentBuf8); } TPtrC8 theRest = fileBuffer.Mid(lineFeedLocation + 1); fileBuffer.Copy(theRest); } } } file.Close(); fileServerSession.Close(); }
// --------------------------------------------------------------------------------- // 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 ); }
void CUPnPHeaderReader::DecodeManL(RHeaderField& aHeader) const { TPtrC8 rawData; aHeader.RawDataL(rawData); TInt remaining = rawData.Length(); TPtrC8 token; TInt tokensFound = 0; while (remaining > 0) { remaining -= InetProtTextUtils::ExtractNextTokenFromList(rawData, token, KCommaChar); TInt pos = token.Locate(KSemiColonChar); if (pos < 0) { // No parameters. Just store the field value InetProtTextUtils::RemoveWhiteSpace(token, InetProtTextUtils::ERemoveBoth); SetNewFStringPartL(aHeader, tokensFound, token); } else if (pos==0) { // No valid ns-value. Just store the parameter. User::Leave(KErrUPnPDecodeMAN); } else { // parameter value(s) exist. if (pos==token.Length()) // if no field value exists. i.e. an invalid header User::Leave(KErrUPnPDecodeMAN); // store the field TPtrC8 fieldValue(token.Left(pos)); TPtrC8 parameters(token.Mid(pos+1)); InetProtTextUtils::RemoveWhiteSpace(fieldValue, InetProtTextUtils::ERemoveBoth); CHeaderFieldPart* part = SetNewFStringPartL(aHeader, tokensFound, fieldValue); TPtrC8 thisParam; do { // check if there is another parameter pos = parameters.Locate(KSemiColonChar); if (pos > 0) { if (pos==token.Length()) // if no field value exists. i.e. an invalid header User::Leave(KErrUPnPDecodeMAN); thisParam.Set(parameters.Left(pos)); parameters.Set(parameters.Mid(pos+1)); } else thisParam.Set(parameters); TInt pPos = thisParam.Locate(KEqualsChar); if (pPos <= 0 || pPos==thisParam.Length()) // Invalid parameter, missing '=' char, or missing field value. User::Leave(KErrUPnPDecodeMAN); TPtrC8 paramField(thisParam.Left(pPos)); TPtrC8 paramData(thisParam.Mid(pPos + 1)); SetNewFStringParamL(*part, paramField, paramData); } while (pos > 0); } ++tokensFound; } }
TInt CISO2022KRImplementation::ConvertToUnicode( CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, TDes16& aUnicode, const TDesC8& aForeign, TInt& aState, TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter) { TInt err; TInt ret = 0; TInt currPos = 0; TInt convPos = 0; TInt shiftInPos = KErrNotFound; TInt shiftOutPos = KErrNotFound; TInt shiftPos = KErrNotFound; TInt escPos = KErrNotFound; TPtrC8 currSegment; TPtrC8 convSegment; TBool changeState = EFalse; TUint outputConversionFlags = 0; TUint inputConversionFlags = CCnvCharacterSetConverter::EInputConversionFlagAppend; TInt numberOfUnconvertibleCharacters = 0; TInt indexOfFirstByteOfFirstUnconvertibleCharacter = 0; aNumberOfUnconvertibleCharacters = 0; while( currPos < aForeign.Length() ) { currSegment.Set( aForeign.Mid( currPos ) ); /* First change state if needed */ if( changeState ) { changeState = EFalse; if( (aState & KBitsForNonStandardStates) == KShiftedToKSCState ) { /* Switch back to default ASCII */ aState &= ~(KShiftedToKSCState); } else { /* Switch to KSC */ aState |= KShiftedToKSCState; } } /* Search for escape which should be skipped */ escPos = currSegment.Find( KLit8EscapeSequence ); /* Search for shift in byte */ shiftInPos = currSegment.Locate( SHIFT_IN_BYTE ); /* Search for shift out byte */ shiftOutPos = currSegment.Locate( SHIFT_OUT_BYTE ); /* Set shift pos according to found shift bytes */ if( shiftInPos == KErrNotFound && shiftOutPos == KErrNotFound ) { /* Neither found */ shiftPos = KErrNotFound; } else { if( (shiftInPos != KErrNotFound) && ((shiftInPos < shiftOutPos) || (shiftOutPos == KErrNotFound)) ) { /* shift in is nearer or shift out not found */ shiftPos = shiftInPos; /* Set state change if needed */ if( (aState & KBitsForNonStandardStates) == KShiftedToKSCState ) { changeState = ETrue; } } else { /* shift out must be nearer or shift in not fouind */ shiftPos = shiftOutPos; /* Set state change if needed */ if( (aState & KBitsForNonStandardStates) != KShiftedToKSCState ) { changeState = ETrue; } } } if( shiftPos == KErrNotFound ) { /* Shift byte not found, same coding for the rest of the data */ if( escPos == KErrNotFound ) { /* No escape sequence either, just convert the rest */ convSegment.Set( currSegment ); } } else if( ((escPos != KErrNotFound) && (shiftPos < escPos)) || (escPos == KErrNotFound) ) { /* Shift byte found and it comes before escape sequence or no escape sequence was found, convert data preceeding the shift byte if shift byte isn't the first character */ if( shiftPos == 0 ) { /* No data to convert preceeds the shift byte, just skip it and continue */ currPos += 1; continue; } convSegment.Set( currSegment.Left( shiftPos ) ); /* Clear to prevent convert to escape sequence */ escPos = KErrNotFound; } if( escPos != KErrNotFound ) { /* Escape sequence found before any shift bytes, clear possible state change and convert data preceeding the escape sequence if escape sequence is not at the beginning */ changeState = EFalse; if( escPos == 0 ) { /* No data to convert preceeds the escape sequence, just skip it continue */ currPos += KLit8EscapeSequence().Length(); continue; } convSegment.Set( currSegment.Left( escPos ) ); } if( (aState & KBitsForNonStandardStates) == KShiftedToKSCState ) { /* Convert KSC encoded */ HBufC8 *tmpForeign = NULL; if( (convSegment.Length() & 0x1) ) { /* KSC should have even amount of bytes */ ret = CCnvCharacterSetConverter::EErrorIllFormedInput; } else { convPos = 0; while( convPos < convSegment.Length() ) { TRAP( err, tmpForeign = HBufC8::NewL( KMaxSizeOfTmpBuffer ) ); if( err != KErrNone ) { User::Panic( _L("ISO-2022-KR"), err ); } if( convSegment.Length() < KMaxSizeOfTmpBuffer ) { /* Convert whole segment */ tmpForeign->Des().Copy( convSegment ); } else { /* Convert in chunks */ if( (convPos + KMaxSizeOfTmpBuffer) >= convSegment.Length() ) { /* Last chunk */ tmpForeign->Des().Copy( convSegment.Mid( convPos ) ); } else { tmpForeign->Des().Copy( convSegment.Mid( convPos, KMaxSizeOfTmpBuffer ) ); } } TUint8 *chars = (TUint8 *)tmpForeign->Des().Ptr(); for( TInt i = 0 ; i < tmpForeign->Length() ; i++ ) { /* Set highest bit in characters */ chars[i] |= 0x80; } numberOfUnconvertibleCharacters = 0; ret = CCnvCharacterSetConverter::DoConvertToUnicode( CnvCp949Table::ConversionData(), aDefaultEndiannessOfForeignCharacters, aUnicode, *tmpForeign, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter, outputConversionFlags, inputConversionFlags ); if( numberOfUnconvertibleCharacters != 0 && aNumberOfUnconvertibleCharacters == 0 ) { /* First uncovertible found, set index relative to actual input buffer*/ aIndexOfFirstByteOfFirstUnconvertibleCharacter = (currPos + convPos + indexOfFirstByteOfFirstUnconvertibleCharacter); } aNumberOfUnconvertibleCharacters += numberOfUnconvertibleCharacters; if( ret < 0 ) { /* Some error, break the loop, errors are handled later */ delete tmpForeign; break; } if( ret > 0 ) { /* Not all were converted, fix return value to be relative to convSegment and break the loop */ ret = (convSegment.Length() - convPos - tmpForeign->Length() + ret); delete tmpForeign; break; } convPos += tmpForeign->Length(); delete tmpForeign; } } } else { /* Convert ASCII encoded by default, KSC can be used without setting highest bit */ numberOfUnconvertibleCharacters = 0; ret = CCnvCharacterSetConverter::DoConvertToUnicode( CnvCp949Table::ConversionData(), aDefaultEndiannessOfForeignCharacters, aUnicode, convSegment, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter, outputConversionFlags, inputConversionFlags ); if( numberOfUnconvertibleCharacters != 0 && aNumberOfUnconvertibleCharacters == 0 ) { /* First uncovertible found, set index relative to actual input buffer*/ aIndexOfFirstByteOfFirstUnconvertibleCharacter = currPos + indexOfFirstByteOfFirstUnconvertibleCharacter; } aNumberOfUnconvertibleCharacters += numberOfUnconvertibleCharacters; } if( ret < 0 ) { /* Error during conversion */ return ret; } else if( ret > 0 ) { /* Not all characters where converted, return value indicating how many bytes in total are left unconverted */ return (aForeign.Length() - currPos - convSegment.Length() + ret); } /* Increase to skip converted data */ currPos += convSegment.Length(); if( escPos != KErrNotFound ) { /* Increase to skip escape sequence */ currPos += KLit8EscapeSequence().Length(); } else if( shiftPos != KErrNotFound ) { /* Increase to skip shift byte */ currPos += 1; } } return 0; }
void COperationParser::ParseOperationsL( TDes8& aReturnTxt) { //reset line counter and initialize XML-parser iActiveLine = 0; iReturnText = &aReturnTxt; iXMLStackPointer = 0; ResetOperations(); //initliaze symbian xml parser iParser->ParseBeginL(); //Max size of chunk (max text length, which go once to parser) const TInt KMaxChunkLength = 1000; TPtrC8 xml = iXMLContent; TPtrC8 chunk; TInt length = KMaxChunkLength < xml.Length() ? KMaxChunkLength : xml.Length(); do { //Find line feed mark (asciicode 10) TInt indexLineFeed = xml.Locate(10); TInt elementEndIndex = xml.Locate( KXMLElementEndMark ); if ( elementEndIndex != KErrNotFound && (elementEndIndex < indexLineFeed || indexLineFeed == KErrNotFound)) { length = elementEndIndex + 1; } else if ( indexLineFeed != KErrNotFound) { //max text, which go to parser is one line or KMaxChunkLength. Counter tracks line, where parsing is going iActiveLine++; length = indexLineFeed + 1; } //set chunk pointer chunk.Set( xml.Left(length)); if ( ParserUtility::ContainsCDataField( chunk)) { //cdata mark indicated in chunk, remove cdata area from chunk, TPtrC8 cdata; ParserUtility::ReadCDataAreaL( cdata, chunk, xml); //pointer to cdata content ParserUtility::RemoveCDataMarksL( cdata); if ( !iActiveOperation) { HandleErrorL( ParserErrors::UnexpectedElement, KCDataElement); } iActiveOperation->SetXACMLContentL( cdata); iActiveOperation->SetLineOffset( iActiveLine - 1); iActiveLine += ParserUtility::LineCounter( cdata); } else { //set remaining XACML description to xacmlDescription xml.Set( xml.Mid(length)); } //'|' and '~' are not allowed in policy system... if ( chunk.Locate('|') != KErrNotFound || chunk.Locate('~') != KErrNotFound) { HandleErrorL( ParserErrors::InvalidMark, ParserErrors::InvalidMarks); } //drive description to parser iParser->ParseL( chunk); length = KMaxChunkLength < xml.Length() ? KMaxChunkLength : xml.Length(); } while ( length); //close parser iParser->ParseEndL(); }