// non-javadoc, see interface LineParser
        public virtual bool HasProtocolVersion(CharArrayBuffer buffer, ParserCursor cursor
                                               )
        {
            Args.NotNull(buffer, "Char array buffer");
            Args.NotNull(cursor, "Parser cursor");
            int    index       = cursor.GetPos();
            string protoname   = this.protocol.GetProtocol();
            int    protolength = protoname.Length;

            if (buffer.Length() < protolength + 4)
            {
                return(false);
            }
            // not long enough for "HTTP/1.1"
            if (index < 0)
            {
                // end of line, no tolerance for trailing whitespace
                // this works only for single-digit major and minor version
                index = buffer.Length() - 4 - protolength;
            }
            else
            {
                if (index == 0)
                {
                    // beginning of line, tolerate leading whitespace
                    while ((index < buffer.Length()) && HTTP.IsWhitespace(buffer.CharAt(index)))
                    {
                        index++;
                    }
                }
            }
            // else within line, don't tolerate whitespace
            if (index + protolength + 4 > buffer.Length())
            {
                return(false);
            }
            // just check protocol name and slash, no need to analyse the version
            bool ok = true;

            for (int j = 0; ok && (j < protolength); j++)
            {
                ok = (buffer.CharAt(index + j) == protoname[j]);
            }
            if (ok)
            {
                ok = (buffer.CharAt(index + protolength) == '/');
            }
            return(ok);
        }
        /// <summary>Helper to skip whitespace.</summary>
        /// <remarks>Helper to skip whitespace.</remarks>
        protected internal virtual void SkipWhitespace(CharArrayBuffer buffer, ParserCursor
                                                       cursor)
        {
            int pos     = cursor.GetPos();
            int indexTo = cursor.GetUpperBound();

            while ((pos < indexTo) && HTTP.IsWhitespace(buffer.CharAt(pos)))
            {
                pos++;
            }
            cursor.UpdatePos(pos);
        }
示例#3
0
        // non-javadoc, see interface HeaderValueParser
        public virtual NameValuePair[] ParseParameters(CharArrayBuffer buffer, ParserCursor
                                                       cursor)
        {
            Args.NotNull(buffer, "Char array buffer");
            Args.NotNull(cursor, "Parser cursor");
            int pos     = cursor.GetPos();
            int indexTo = cursor.GetUpperBound();

            while (pos < indexTo)
            {
                char ch = buffer.CharAt(pos);
                if (HTTP.IsWhitespace(ch))
                {
                    pos++;
                }
                else
                {
                    break;
                }
            }
            cursor.UpdatePos(pos);
            if (cursor.AtEnd())
            {
                return(new NameValuePair[] {  });
            }
            IList <NameValuePair> @params = new AList <NameValuePair>();

            while (!cursor.AtEnd())
            {
                NameValuePair param = ParseNameValuePair(buffer, cursor);
                @params.AddItem(param);
                char ch = buffer.CharAt(cursor.GetPos() - 1);
                if (ch == ElemDelimiter)
                {
                    break;
                }
            }
            return(Sharpen.Collections.ToArray(@params, new NameValuePair[@params.Count]));
        }
示例#4
0
        // non-javadoc, see interface HeaderValueParser
        public virtual HeaderElement ParseHeaderElement(CharArrayBuffer buffer, ParserCursor
                                                        cursor)
        {
            Args.NotNull(buffer, "Char array buffer");
            Args.NotNull(cursor, "Parser cursor");
            NameValuePair nvp = ParseNameValuePair(buffer, cursor);

            NameValuePair[] @params = null;
            if (!cursor.AtEnd())
            {
                char ch = buffer.CharAt(cursor.GetPos() - 1);
                if (ch != ElemDelimiter)
                {
                    @params = ParseParameters(buffer, cursor);
                }
            }
            return(CreateHeaderElement(nvp.GetName(), nvp.GetValue(), @params));
        }
示例#5
0
        public virtual NameValuePair ParseNameValuePair(CharArrayBuffer buffer, ParserCursor
                                                        cursor, char[] delimiters)
        {
            Args.NotNull(buffer, "Char array buffer");
            Args.NotNull(cursor, "Parser cursor");
            bool terminated = false;
            int  pos        = cursor.GetPos();
            int  indexFrom  = cursor.GetPos();
            int  indexTo    = cursor.GetUpperBound();
            // Find name
            string name;

            while (pos < indexTo)
            {
                char ch = buffer.CharAt(pos);
                if (ch == '=')
                {
                    break;
                }
                if (IsOneOf(ch, delimiters))
                {
                    terminated = true;
                    break;
                }
                pos++;
            }
            if (pos == indexTo)
            {
                terminated = true;
                name       = buffer.SubstringTrimmed(indexFrom, indexTo);
            }
            else
            {
                name = buffer.SubstringTrimmed(indexFrom, pos);
                pos++;
            }
            if (terminated)
            {
                cursor.UpdatePos(pos);
                return(CreateNameValuePair(name, null));
            }
            // Find value
            string value;
            int    i1      = pos;
            bool   qouted  = false;
            bool   escaped = false;

            while (pos < indexTo)
            {
                char ch = buffer.CharAt(pos);
                if (ch == '"' && !escaped)
                {
                    qouted = !qouted;
                }
                if (!qouted && !escaped && IsOneOf(ch, delimiters))
                {
                    terminated = true;
                    break;
                }
                if (escaped)
                {
                    escaped = false;
                }
                else
                {
                    escaped = qouted && ch == '\\';
                }
                pos++;
            }
            int i2 = pos;

            // Trim leading white spaces
            while (i1 < i2 && (HTTP.IsWhitespace(buffer.CharAt(i1))))
            {
                i1++;
            }
            // Trim trailing white spaces
            while ((i2 > i1) && (HTTP.IsWhitespace(buffer.CharAt(i2 - 1))))
            {
                i2--;
            }
            // Strip away quotes if necessary
            if (((i2 - i1) >= 2) && (buffer.CharAt(i1) == '"') && (buffer.CharAt(i2 - 1) == '"'
                                                                   ))
            {
                i1++;
                i2--;
            }
            value = buffer.Substring(i1, i2);
            if (terminated)
            {
                pos++;
            }
            cursor.UpdatePos(pos);
            return(CreateNameValuePair(name, value));
        }
        // non-javadoc, see interface LineParser
        /// <exception cref="Org.Apache.Http.ParseException"></exception>
        public virtual ProtocolVersion ParseProtocolVersion(CharArrayBuffer buffer, ParserCursor
                                                            cursor)
        {
            Args.NotNull(buffer, "Char array buffer");
            Args.NotNull(cursor, "Parser cursor");
            string protoname   = this.protocol.GetProtocol();
            int    protolength = protoname.Length;
            int    indexFrom   = cursor.GetPos();
            int    indexTo     = cursor.GetUpperBound();

            SkipWhitespace(buffer, cursor);
            int i = cursor.GetPos();

            // long enough for "HTTP/1.1"?
            if (i + protolength + 4 > indexTo)
            {
                throw new ParseException("Not a valid protocol version: " + buffer.Substring(indexFrom
                                                                                             , indexTo));
            }
            // check the protocol name and slash
            bool ok = true;

            for (int j = 0; ok && (j < protolength); j++)
            {
                ok = (buffer.CharAt(i + j) == protoname[j]);
            }
            if (ok)
            {
                ok = (buffer.CharAt(i + protolength) == '/');
            }
            if (!ok)
            {
                throw new ParseException("Not a valid protocol version: " + buffer.Substring(indexFrom
                                                                                             , indexTo));
            }
            i += protolength + 1;
            int period = buffer.IndexOf('.', i, indexTo);

            if (period == -1)
            {
                throw new ParseException("Invalid protocol version number: " + buffer.Substring(indexFrom
                                                                                                , indexTo));
            }
            int major;

            try
            {
                major = System.Convert.ToInt32(buffer.SubstringTrimmed(i, period));
            }
            catch (FormatException)
            {
                throw new ParseException("Invalid protocol major version number: " + buffer.Substring
                                             (indexFrom, indexTo));
            }
            i = period + 1;
            int blank = buffer.IndexOf(' ', i, indexTo);

            if (blank == -1)
            {
                blank = indexTo;
            }
            int minor;

            try
            {
                minor = System.Convert.ToInt32(buffer.SubstringTrimmed(i, blank));
            }
            catch (FormatException)
            {
                throw new ParseException("Invalid protocol minor version number: " + buffer.Substring
                                             (indexFrom, indexTo));
            }
            cursor.UpdatePos(blank);
            return(CreateProtocolVersion(major, minor));
        }
示例#7
0
        private NameValuePair ParseNameValuePair(CharArrayBuffer buffer, ParserCursor cursor
                                                 )
        {
            bool terminated = false;
            int  pos        = cursor.GetPos();
            int  indexFrom  = cursor.GetPos();
            int  indexTo    = cursor.GetUpperBound();
            // Find name
            string name = null;

            while (pos < indexTo)
            {
                char ch = buffer.CharAt(pos);
                if (ch == '=')
                {
                    break;
                }
                if (ch == ';')
                {
                    terminated = true;
                    break;
                }
                pos++;
            }
            if (pos == indexTo)
            {
                terminated = true;
                name       = buffer.SubstringTrimmed(indexFrom, indexTo);
            }
            else
            {
                name = buffer.SubstringTrimmed(indexFrom, pos);
                pos++;
            }
            if (terminated)
            {
                cursor.UpdatePos(pos);
                return(new BasicNameValuePair(name, null));
            }
            // Find value
            string value = null;
            int    i1    = pos;

            while (pos < indexTo)
            {
                char ch = buffer.CharAt(pos);
                if (ch == ';')
                {
                    terminated = true;
                    break;
                }
                pos++;
            }
            int i2 = pos;

            // Trim leading white spaces
            while (i1 < i2 && (HTTP.IsWhitespace(buffer.CharAt(i1))))
            {
                i1++;
            }
            // Trim trailing white spaces
            while ((i2 > i1) && (HTTP.IsWhitespace(buffer.CharAt(i2 - 1))))
            {
                i2--;
            }
            value = buffer.Substring(i1, i2);
            if (terminated)
            {
                pos++;
            }
            cursor.UpdatePos(pos);
            return(new BasicNameValuePair(name, value));
        }