Esempio n. 1
0
        /// <summary>
        /// Splits a string without the use of a regex, which could split either by isDot() or %2e
        /// @param input the input string that will be split by dot
        /// @return an array of strings that is a partition of the original string split by dot
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string[] SplitByDot(string input)
        {
            var splitList = new List <string>();
            var section   = new StringBuilder();

            if (string.IsNullOrEmpty(input))
            {
                return(new[] { "" });
            }

            var reader = new InputTextReader(input);

            while (!reader.Eof())
            {
                var curr = reader.Read();
                if (IsDot(curr))
                {
                    splitList.Add(section.ToString());
                    section.Length = 0;
                }
                else if (curr == '%' && reader.CanReadChars(2) && reader.Peek(2).Equals("2e", StringComparison.InvariantCultureIgnoreCase))
                {
                    reader.Read();
                    reader.Read();                     //advance past the 2e
                    splitList.Add(section.ToString());
                    section.Length = 0;
                }
                else
                {
                    section.Append(curr);
                }
            }

            splitList.Add(section.ToString());
            return(splitList.ToArray());
        }
Esempio n. 2
0
        /// <summary>
        /// The default input reader which looks for specific flags to start detecting the url.
        /// </summary>
        private void ReadDefault()
        {
            //Keeps track of the number of characters read to be able to later cut out the domain name.
            var length = 0;

            // keep track of how many times each character in each index of the raw input has been read
            var contentReadByIndexCount = new byte[_reader.ContentLength];

            //until end of string read the contents
            while (!_reader.Eof())
            {
                // We want to ensure that backtracking and looping on content is limited from infinite-loops, so
                // we take the hit and track each time an element in the input is read, and if its been hit too
                // many times, we step forwards until we find an element that has NOT been read too many times
                var currentIndex = _reader.GetPosition();
                contentReadByIndexCount[currentIndex] += 1;
                while (contentReadByIndexCount[currentIndex] >= ContentReadByIndexMaximum)
                {
                    // Forcably step to the next character in the input, so we jump out of infinite loops
                    _reader.Read();
                    currentIndex = _reader.GetPosition();
                }

                // Read the next char to process.
                var curr = _reader.Read();

                switch (curr)
                {
                case ' ':
                    //space was found, check if it's a valid single level domain.
                    if (_options.HasFlag(UrlDetectorOptions.ALLOW_SINGLE_LEVEL_DOMAIN) && _buffer.Length > 0 && _hasScheme)
                    {
                        _reader.GoBack();
                        if (!ReadDomainName(_buffer.ToString().Substring(length)))
                        {
                            ReadEnd(ReadEndState.InvalidUrl);
                        }
                        ;
                    }

                    _buffer.Append(curr);
                    ReadEnd(ReadEndState.InvalidUrl);
                    length = 0;
                    break;

                case '%':
                    if (_reader.CanReadChars(2))
                    {
                        if (_reader.Peek(2).Equals("3a", StringComparison.InvariantCultureIgnoreCase))
                        {
                            _buffer.Append(curr);
                            _buffer.Append(_reader.Read());
                            _buffer.Append(_reader.Read());
                            length = ProcessColon(length);
                        }
                        else if (CharUtils.IsHex(_reader.PeekChar(0)) && CharUtils.IsHex(_reader.PeekChar(1)))
                        {
                            _buffer.Append(curr);
                            _buffer.Append(_reader.Read());
                            _buffer.Append(_reader.Read());

                            if (!ReadDomainName(_buffer.ToString().Substring(length)))
                            {
                                ReadEnd(ReadEndState.InvalidUrl);
                            }
                            length = 0;
                        }
                    }

                    break;

                case '\u3002':                         //non-standard dots
                case '\uFF0E':
                case '\uFF61':
                case '.':                         //"." was found, read the domain name using the start from length.
                    _buffer.Append(curr);
                    if (!ReadDomainName(_buffer.ToString().Substring(length)))
                    {
                        ReadEnd(ReadEndState.InvalidUrl);
                    }
                    length = 0;
                    break;

                case '@':                         //Check the domain name after a username
                    if (_buffer.Length > 0)
                    {
                        _currentUrlMarker.SetIndex(UrlPart.USERNAME_PASSWORD, length);
                        _buffer.Append(curr);
                        if (!ReadDomainName(null))
                        {
                            ReadEnd(ReadEndState.InvalidUrl);
                        }
                        length = 0;
                    }

                    break;

                case '[':
                    if (_dontMatchIpv6)
                    {
                        //Check if we need to match characters. If we match characters and this is a start or stop of range,
                        //either way reset the world and start processing again.
                        if (CheckMatchingCharacter(curr) != CharacterMatch.CharacterNotMatched)
                        {
                            ReadEnd(ReadEndState.InvalidUrl);
                            length = 0;
                        }
                    }

                    var beginning = _reader.GetPosition();

                    //if it doesn't have a scheme, clear the buffer.
                    if (!_hasScheme)
                    {
                        _buffer.Remove(0, _buffer.Length);
                    }

                    _buffer.Append(curr);

                    if (!ReadDomainName(_buffer.ToString().Substring(length)))
                    {
                        //if we didn't find an ipv6 address, then check inside the brackets for urls
                        ReadEnd(ReadEndState.InvalidUrl);
                        _reader.Seek(beginning);
                        _dontMatchIpv6 = true;
                    }

                    length = 0;
                    break;

                case '/':
                    // "/" was found, then we either read a scheme, or if we already read a scheme, then
                    // we are reading a url in the format http://123123123/asdf

                    if (_hasScheme || _options.HasFlag(UrlDetectorOptions.ALLOW_SINGLE_LEVEL_DOMAIN) && _buffer.Length > 1)
                    {
                        //we already have the scheme, so then we already read:
                        //http://something/ <- if something is all numeric then its a valid url.
                        //OR we are searching for single level domains. We have buffer length > 1 condition
                        //to weed out infinite backtrack in cases of html5 roots

                        //unread this "/" and continue to check the domain name starting from the beginning of the domain
                        _reader.GoBack();
                        if (!ReadDomainName(_buffer.ToString().Substring(length)))
                        {
                            ReadEnd(ReadEndState.InvalidUrl);
                        }

                        length = 0;
                    }
                    else
                    {
                        //we don't have a scheme already, then clear state, then check for html5 root such as: "//google.com/"
                        // remember the state of the quote when clearing state just in case its "//google.com" so its not cleared.
                        ReadEnd(ReadEndState.InvalidUrl);
                        _buffer.Append(curr);
                        _hasScheme = ReadHtml5Root();
                        length     = _buffer.Length;
                    }

                    break;

                case ':':
                    //add the ":" to the url and check for scheme/username
                    _buffer.Append(curr);
                    length = ProcessColon(length);
                    break;

                default:
                    //Check if we need to match characters. If we match characters and this is a start or stop of range,
                    //either way reset the world and start processing again.
                    if (CheckMatchingCharacter(curr) != CharacterMatch.CharacterNotMatched)
                    {
                        ReadEnd(ReadEndState.InvalidUrl);
                        length = 0;
                    }
                    else
                    {
                        _buffer.Append(curr);
                    }

                    break;
                }
            }

            if (_options.HasFlag(UrlDetectorOptions.ALLOW_SINGLE_LEVEL_DOMAIN) && _buffer.Length > 0 && _hasScheme)
            {
                if (!ReadDomainName(_buffer.ToString().Substring(length)))
                {
                    ReadEnd(ReadEndState.InvalidUrl);
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Reads the Dns and returns the next state the state machine should take in throwing this out, or continue processing
        /// if this is a valid domain name.
        /// @return The next state to take.
        /// </summary>
        public ReaderNextState ReadDomainName()
        {
            //Read the current, and if its bad, just return.
            if (ReadCurrent() == ReaderNextState.InvalidDomainName)
            {
                return(ReaderNextState.InvalidDomainName);
            }

            //If this is the first domain part, check if it's ip address in is hexa
            //similar to what is done on 'readCurrent' method
            bool isAllHexSoFar = (_current == null || _current.Equals("")) &&
                                 _reader.CanReadChars(3) &&
                                 ("0x".Equals(_reader.Peek(2), StringComparison.InvariantCultureIgnoreCase));

            if (isAllHexSoFar)
            {
                //Append hexa radix symbol characters (0x)
                _buffer.Append(_reader.Read());
                _buffer.Append(_reader.Read());
                _currentLabelLength += 2;
                _topLevelLength      = _currentLabelLength;
            }

            //while not done and not end of string keep reading.
            var done = false;

            while (!done && !_reader.Eof())
            {
                var curr = _reader.Read();

                if (curr == '/')
                {
                    //continue by reading the path
                    return(CheckDomainNameValid(ReaderNextState.ReadPath, curr));
                }

                if (curr == ':' && (!_seenBracket || _seenCompleteBracketSet))
                {
                    //Don't check for a port if it's in the middle of an ipv6 address
                    //continue by reading the port.
                    return(CheckDomainNameValid(ReaderNextState.ReadPort, curr));
                }

                if (curr == '?')
                {
                    //continue by reading the query string
                    return(CheckDomainNameValid(ReaderNextState.ReadQueryString, curr));
                }

                if (curr == '#')
                {
                    //continue by reading the fragment
                    return(CheckDomainNameValid(ReaderNextState.ReadFragment, curr));
                }
                else if (curr == '@')
                {
                    //this may not have been a domain after all, but rather a username/password instead
                    _reader.GoBack();
                    return(ReaderNextState.ReadUserPass);
                }
                else if (CharUtils.IsDot(curr) ||
                         curr == '%' && _reader.CanReadChars(2) && _reader.Peek(2).Equals(HEX_ENCODED_DOT, StringComparison.InvariantCultureIgnoreCase))
                {
                    //if the current character is a dot or a urlEncodedDot

                    //handles the case: hello..
                    if (_currentLabelLength < 1)
                    {
                        done = true;
                    }
                    else
                    {
                        //append the "." to the domain name
                        _buffer.Append(curr);

                        //if it was not a normal dot, then it is url encoded
                        //read the next two chars, which are the hex representation
                        if (!CharUtils.IsDot(curr))
                        {
                            _buffer.Append(_reader.Read());
                            _buffer.Append(_reader.Read());
                        }

                        //increment the dots only if it's not part of the zone index and reset the last length.
                        if (!_zoneIndex)
                        {
                            _dots++;
                            _currentLabelLength = 0;
                        }

                        //if the length of the last section is longer than or equal to 64, it's too long to be a valid domain
                        if (_currentLabelLength >= MAX_LABEL_LENGTH)
                        {
                            return(ReaderNextState.InvalidDomainName);
                        }
                    }
                }
                else if (_seenBracket && (CharUtils.IsHex(curr) || curr == ':' || curr == '[' || curr == ']' || curr == '%') &&
                         !_seenCompleteBracketSet)
                {
                    //if this is an ipv6 address.
                    switch (curr)
                    {
                    case ':':
                        _currentLabelLength = 0;
                        break;

                    case '[':
                        // if we read another '[', we need to restart by re-reading from this bracket instead.
                        _reader.GoBack();
                        return(ReaderNextState.InvalidDomainName);

                    case ']':
                        _seenCompleteBracketSet = true;                     //means that we already have a complete ipv6 address.
                        _zoneIndex = false;                                 //set this back off so that we can keep counting dots after ipv6 is over.
                        break;

                    case '%':                             //set flag to subtract subsequent dots because it's part of the zone index
                        _zoneIndex = true;
                        break;

                    default:
                        _currentLabelLength++;
                        break;
                    }

                    _numeric = false;
                    _buffer.Append(curr);
                }
                else if (CharUtils.IsAlphaNumeric(curr) || curr == '-' || curr >= INTERNATIONAL_CHAR_START)
                {
                    //Valid domain name character. Either a-z, A-Z, 0-9, -, or international character
                    if (_seenCompleteBracketSet)
                    {
                        //covers case of [fe80::]www.google.com
                        _reader.GoBack();
                        done = true;
                    }
                    else
                    {
                        if (isAllHexSoFar && !CharUtils.IsHex(curr))
                        {
                            _numeric = false;
                        }
                        //if its not numeric, remember that;
                        if (!isAllHexSoFar && !CharUtils.IsNumeric(curr))
                        {
                            _numeric = false;
                        }

                        //append to the states.
                        _buffer.Append(curr);
                        _currentLabelLength++;
                        _topLevelLength = _currentLabelLength;
                    }
                }
                else if (curr == '[' && !_seenBracket)
                {
                    _seenBracket = true;
                    _numeric     = false;
                    _buffer.Append(curr);
                }
                else if (curr == '[' && _seenCompleteBracketSet)
                {
                    //Case where [::][ ...
                    _reader.GoBack();
                    done = true;
                }
                else if (curr == '%' && _reader.CanReadChars(2) && CharUtils.IsHex(_reader.PeekChar(0)) &&
                         CharUtils.IsHex(_reader.PeekChar(1)))
                {
                    //append to the states.
                    _buffer.Append(curr);
                    _buffer.Append(_reader.Read());
                    _buffer.Append(_reader.Read());
                    _currentLabelLength += 3;
                    _topLevelLength      = _currentLabelLength;
                }
                else
                {
                    //called to increment the count of matching characters
                    //_characterHandler.addCharacter(curr);

                    _characterHandler(curr);

                    //invalid character, we are done.
                    done = true;
                }
            }

            //Check the domain name to make sure its ok.
            return(CheckDomainNameValid(ReaderNextState.ValidDomainName, null));
        }