Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2012 Red Hat, Inc., and individual contributors
   * as indicated by the @author tags.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.coyote.http11;
 
 import static org.jboss.web.CoyoteMessages.MESSAGES;
 
 
AbstractInternalInputBuffer Created on Jan 10, 2012 at 10:31:06 AM

Author(s):
Nabil Benothman
 
 public abstract class AbstractInternalInputBuffer implements InputBuffer {

Associated Coyote request.
 
 	protected Request request;

Headers of the associated request.
 
 	protected MimeHeaders headers;

State.
 
 	protected boolean parsingHeader;

Swallow input ? (in the case of an expectation)
 
 	protected boolean swallowInput;

Pointer to the current read buffer.
 
 	protected byte[] buf;

Direct byte buffer used to perform actual reading.
 
 	protected ByteBuffer bbuf;

Last valid byte.
 
 	protected int lastValid;

Position in the buffer.
 
 	protected int pos;

Position of the end of the header in the buffer, which is also the start of the body.
 
 	protected int end;

Filter library. Note: Filter[0] is always the "chunked" filter.
 
 	protected InputFilter[] filterLibrary;

Active filters (in order).
 
 	protected InputFilter[] activeFilters;

Index of the last active filter.
	protected int lastActiveFilter;

Underlying input buffer.
Read timeout
	protected int readTimeout = -1;

The default time unit
	protected static final TimeUnit unit = .;

Create a new instance of AbstractInternalInputBuffer

Parameters:
request
headerBufferSize
	public AbstractInternalInputBuffer(Request requestint headerBufferSize) {
		this. = request;
		 = request.getMimeHeaders();
		 = new byte[headerBufferSize];
		 = true;
		 = true;
		 = ByteBuffer.allocateDirect(headerBufferSize);
	}

Get filters.

Returns:
the list of filters
	public InputFilter[] getFilters() {
	}

Set the swallow input flag.

Parameters:
swallowInput
	public void setSwallowInput(boolean swallowInput) {
		this. = swallowInput;
	}

Add an input filter to the filter library.

Parameters:
filter
	public void addFilter(InputFilter filter) {
		if (filter == null) {
			return;
		}
		InputFilter[] newFilterLibrary = new InputFilter[. + 1];
		for (int i = 0; i < .i++) {
			newFilterLibrary[i] = [i];
		}
		newFilterLibrary[.] = filter;
		 = newFilterLibrary;
	}

Clear filters.
	public void clearFilters() {
	}

Add an input filter to the filter library.

Parameters:
filter
	public void addActiveFilter(InputFilter filter) {
		if ( == -1) {
else {
			for (int i = 0; i <= i++) {
				if ([i] == filter)
					return;
			}
		}
	}
    public void removeActiveFilters() {
        // Recycle filters
        for (int i = 0; i <= i++) {
            [i].recycle();
        }
         = -1;
         = .;
    }

Recycle the input buffer. This should be called when closing the connection.
	public void recycle() {
		// Recycle Request object
		 = 0;
	}

	protected void reset() {
		 = 0;
		 = true;
		 = true;
	}

End processing of current HTTP request. Note: All bytes of the current request should have been already consumed. This method only resets all the pointers so that we are ready to parse the next HTTP request.

Returns:
true if the position of the last valid char is > 0, else false
	public boolean nextRequest() {
		// Recycle Request object
		// Copy leftover bytes to the beginning of the buffer
		if ( -  > 0 &&  > 0) {
			int npos = 0;
			int opos = ;
			while ( - opos > opos - npos) {
				System.arraycopy(oposnposopos - npos);
				npos += ;
				opos += ;
			}
			System.arraycopy(oposnpos - opos);
		}
		// Recycle filters
		for (int i = 0; i <= i++) {
		}
		// Reset pointers
		return ( > 0);
	}

End request (consumes leftover bytes).

Throws:
java.io.IOException an undelying I/O error occured
	public void endRequest() throws IOException {
		if ( && ( != -1)) {
			int extraBytes = (int[].end();
			 =  - extraBytes;
		}
	}

Read the request line. This function is meant to be used during the HTTP request header parsing. Do NOT attempt to read the request body using it.

Throws:
java.io.IOException If an exception occurs during the underlying socket read operations, or if the given buffer is not big enough to accomodate the whole line.
	public void parseRequestLine() throws IOException {
		int start = 0;
		// Skipping blank lines
		byte chr = 0;
		do {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill())
			}
			chr = [++];
while ((chr == .) || (chr == .));
		--;
		// Mark the current buffer position
		start = ;
		// Reading the method name
		// Method name is always US-ASCII
		boolean space = false;
		while (!space) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			// Spec says single SP but it also says be tolerant of HT
			if ([] == . || [] == .) {
				space = true;
				.method().setBytes(start - start);
			}
			++;
		}
		// Spec says single SP but also says be tolerant of multiple and/or HT
		while (space) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			if ([] == . || [] == .) {
				++;
else {
				space = false;
			}
		}
		// Mark the current buffer position
		start = ;
		int end = 0;
		int questionPos = -1;
		// Reading the URI
		boolean eol = false;
		while (!space) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			// Spec says single SP but it also says be tolerant of HT
			if ([] == . || [] == .) {
				space = true;
				end = ;
else if (([] == .) || ([] == .)) {
				// HTTP/0.9 style request
				eol = true;
				space = true;
				end = ;
else if (([] == .) && (questionPos == -1)) {
				questionPos = ;
			}
			++;
		}
		.unparsedURI().setBytes(startend - start);
		if (questionPos >= 0) {
			.queryString().setBytes(questionPos + 1, end - questionPos - 1);
			.requestURI().setBytes(startquestionPos - start);
else {
			.requestURI().setBytes(startend - start);
		}
		// Spec says single SP but also says be tolerant of multiple and/or HT
		while (space) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			if ([] == . || [] == .) {
				++;
else {
				space = false;
			}
		}
		// Mark the current buffer position
		start = ;
		end = 0;
		// Reading the protocol
		// Protocol is always US-ASCII
		while (!eol) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			if ([] == .) {
				end = ;
else if ([] == .) {
				if (end == 0)
					end = ;
				eol = true;
			}
			++;
		}
		if ((end - start) > 0) {
			.protocol().setBytes(startend - start);
else {
		}
	}

Parse the HTTP headers.

	public void parseHeaders() throws IOException {
		while (parseHeader()) {
		}
		 = false;
		 = ;
	}

Parse an HTTP header.

Returns:
false after reading a blank line (which indicates that the HTTP header parsing is done
Throws:
java.io.IOException
	public boolean parseHeader() throws IOException {
		// Check for blank line
		byte chr = 0;
		while (true) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill())
			}
			chr = [];
			if ((chr == .) || (chr == .)) {
				if (chr == .) {
					++;
					return false;
				}
else {
				break;
			}
			++;
		}
		// Mark the current buffer position
		int start = ;
		// Reading the header name
		// Header name is always US-ASCII
		boolean colon = false;
		MessageBytes headerValue = null;
		while (!colon) {
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			if ([] == .) {
				colon = true;
				headerValue = .addValue(start - start);
			}
			chr = [];
			if ((chr >= .) && (chr <= .)) {
				[] = (byte) (chr - .);
			}
			++;
		}
		// Mark the current buffer position
		start = ;
		int realPos = ;
		// Reading the header value (which can be spanned over multiple lines)
		boolean eol = false;
		boolean validLine = true;
		while (validLine) {
			boolean space = true;
			// Skipping spaces
			while (space) {
				// Read new bytes if needed
				if ( >= ) {
					if (!fill()) {
					}
				}
				if (([] == .) || ([] == .)) {
					++;
else {
					space = false;
				}
			}
			int lastSignificantChar = realPos;
			// Reading bytes until the end of the line
			while (!eol) {
				// Read new bytes if needed
				if ( >= ) {
					if (!fill()) {
					}
				}
				if ([] == .) {
else if ([] == .) {
					eol = true;
else if ([] == .) {
					[realPos] = [];
					realPos++;
else {
					[realPos] = [];
					realPos++;
					lastSignificantChar = realPos;
				}
				++;
			}
			realPos = lastSignificantChar;
			// Checking the first character of the new line. If the character
			// is a LWS, then it's a multiline header
			// Read new bytes if needed
			if ( >= ) {
				if (!fill()) {
				}
			}
			chr = [];
			if ((chr != .) && (chr != .)) {
				validLine = false;
else {
				eol = false;
				// Copying one extra space in the buffer (since there must
				// be at least one space inserted between the lines)
				[realPos] = chr;
				realPos++;
			}
		}
		// Set the header value
		headerValue.setBytes(startrealPos - start);
		return true;
	}

Fill the internal buffer using data from the undelying input stream.

Returns:
false if at end of stream
	protected abstract boolean fill() throws IOException;
New to GrepCode? Check out our FAQ X