Address interface is used to represent a generic
* uniform resource identifier. This interface allows each section
* of the uniform resource identifier to be represented. A generic
* uniform resource identifier syntax is represented in RFC 2616
* section 3.2.2 for the HTTP protocol, this allows similar URI's
* for example ftp, http, https, tftp. The syntax is
*
*
* URI = [scheme "://"] host [ ":" port ] [ path [ "?" query ]]
*
*
* This will normalize the path part of the uniform resource
* identifier. A normalized path is one that contains no back
* references like "./" and "../". The normalized path will not
* contain the path parameters.
*
* @author Niall Gallagher
*/
public interface Address {
/**
* This allows the scheme of the URL given to be returned.
* If the URI does not contain a scheme then this will
* return null. The scheme of the URI is the part that
* specifies the type of protocol that the URI is used
* for, an example http://domain/path is
* a URI that is intended for the http protocol. The
* scheme is the string http.
*
* @return the scheme tag for the address if available
*/
public String getScheme();
/**
* This is used to retrieve the domain of this URI. The
* domain part in the URI is an optional part, an example
* http://domain/path?querypart. This will
* return the value of the domain part. If there is no
* domain part then this will return null otherwise the
* domain value found in the uniform resource identifier.
*
* @return the domain part of the address if available
*/
public String getDomain();
/**
* This is used to retrieve the port of the uniform resource
* identifier. The port part in this is an optional part, an
* example http://host:port/path?querypart. This
* will return the value of the port. If there is no port then
* this will return -1 because this represents
* an impossible uniform resource identifier port. The port
* is an optional part.
*
* @return this returns the port part if it is available
*/
public int getPort();
/**
* This is used to retrieve the path of this URI. The path part
* is the most fundamental part of the URI. This will return
* the value of the path. If there is no path part then this
* will return a Path implementation that represents the root
* path represented by /.
*
* @return the path part of the uniform resource identifier
*/
public Path getPath();
/**
* This is used to retrieve the query of this URI. The query part
* in the URI is an optional part. This will return the value
* of the query part. If there is no query part then this will
* return an empty Query object. The query is
* an optional member of a URI and comes after the path part, it
* is preceded by a question mark, ? character.
* For example the following URI contains query for
* its query part, http://host:port/path?query.
*
* This returns a org.simpleframework.http.Query
* object that can be used to interact directly with the query
* values. The Query object is a read-only interface
* to the query parameters, and so will not affect the URI.
*
* @return a Query object for the query part
*/
public Query getQuery();
/**
* This extracts the parameter values from the uniform resource
* identifier represented by this object. The parameters that a
* uniform resource identifier contains are embedded in the path
* part of the URI. If the path contains no parameters then this
* will return an empty Map instance.
*
* This will produce unique name and value parameters. Thus if the
* URI contains several path segments with similar parameter names
* this will return the deepest parameter. For example if the URI
* represented was
* It can return
* The
* The
* The name must conform to RFC 2109, which means that it can
* contain only ASCII alphanumeric characters and cannot have
* commas, white space, or semicolon characters.
*
* @param name this is the name of this cookie instance
* @param value this is the value of this cookie instance
*/
public Cookie(String name, String value) {
this(name, value, "/");
}
/**
* Constructor of the
* The name must conform to RFC 2109, which means that it can
* contain only ASCII alphanumeric characters and cannot have
* commas, white space, or semicolon characters.
*
* @param name this is the name of this cookie instance
* @param value this is the value of this cookie instance
* @param created this determines if the cookie is new
*/
public Cookie(String name, String value, boolean created) {
this(name, value, "/", created);
}
/**
* Constructor of the
* The name must conform to RFC 2109, which means that it can
* contain only ASCII alphanumeric characters and cannot have
* commas, white space, or semicolon characters.
*
* @param name this is the name of this cookie instance
* @param value this is the value of this cookie instance
* @param path the path attribute of this cookie instance
*/
public Cookie(String name, String value, String path) {
this(name, value, path, false);
}
/**
* Constructor of the
* The name must conform to RFC 2109, which means that it can
* contain only ASCII alphanumeric characters and cannot have
* commas, white space, or semicolon characters.
*
* @param name this is the name of this cookie instance
* @param value this is the value of this cookie instance
* @param path the path attribute of this cookie instance
* @param created this determines if the cookie is new
*/
public Cookie(String name, String value, String path, boolean created) {
this.created = created;
this.value = value;
this.name = name;
this.path = path;
this.version = 1;
this.expiry = -1;
}
/**
* This is used to determine if the cookie is new. A cookie is
* considered new if it has just been created on the server. A
* cookie is considered not new if it has been received by the
* client in a request. This allows the server to determine if
* the cookie needs to be delivered to the client.
*
* @return this returns true if the cookie was just created
*/
public boolean isNew() {
return created;
}
/**
* This returns the version for this cookie. The version is
* not optional and so will always return the version this
* cookie uses. If no version number is specified this will
* return a version of 1, to comply with RFC 2109.
*
* @return the version value from this cookie instance
*/
public int getVersion() {
return version;
}
/**
* This enables the version of the
* Some old browsers can only handle cookie version 0. This
* can be used to comply with the original Netscape cookie
* specification. Version 1 complies with RFC 2109.
*
* @param version this is the version number for the cookie
*/
public void setVersion(int version) {
this.version = version;
}
/**
* This returns the name for this cookie. The name and value
* attributes of a cookie define what the
* Because the cookie may be stored by name, the cookie name
* cannot be modified after the creation of the cookie object.
*
* @return the name from this cookie instance object
*/
public String getName() {
return name;
}
/**
* This returns the value for this cookie. The name and value
* attributes of a cookie define what the
* Netscape and IE-5.0 cant or wont handle
* For maximum compatibility cookie values are not transmitted
* in quotations. This is done to ensure that platforms like
* PHP, JavaScript and various others that don't comply with
* RFC 2109 can transparently access the sent cookies.
*
* @return this returns a Set-Cookie encoding of the cookie
*/
public String toString(){
return name+"="+value+"; version="+
version +(path ==null ?"":"; path="+path)+
(domain ==null ?"": "; domain="+domain)+
(expiry < 0 ? "" : "; max-age="+expiry)+
(secure ? "; secure;" : ";");
}
}
simple-http-4.1.21/src/org/simpleframework/http/Form.java 0000664 0000000 0000000 00000004000 12536602605 0023356 0 ustar 00root root 0000000 0000000 /*
* Form.java February 2007
*
* Copyright (C) 2007, Niall Gallagher
* If the path that this represents is
* This will also encode any special characters that appear
* within the name and value pairs as an escaped sequence.
* If there are no parameters an empty string is returned.
*
* @return returns an empty string if the is no parameters
*/
public String toString();
}
simple-http-4.1.21/src/org/simpleframework/http/Request.java 0000664 0000000 0000000 00000021127 12536602605 0024114 0 ustar 00root root 0000000 0000000 /*
* Request.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
* This can also maintain data during the request lifecycle as well
* as the session lifecycle. A
* It is important to note that the entity body can be read multiple
* times from the request. Calling
* As well as providing the header values and request line values
* this will also provide convenience methods which enable the user
* to determine the length of the body this message header prefixes.
*
* @author Niall Gallagher
*/
public interface RequestHeader extends RequestLine {
/**
* This method is used to get a
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered array of tokens extracted from the header(s)
*/
public List
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearence.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has higest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered array of tokens extracted from the header(s)
*/
public List
* This should never allow the message body be sent if it should not
* be sent with the headers as of RFC 2616 rules for the presence of
* a message body. A message body must not be included with a HEAD
* request or with a 304 or a 204 response. A proper implementation
* of this will prevent a message body being sent if the response
* is to a HEAD request of if there is a 304 or 204 response code.
*
* It is important to note that the
* This removes any previous Content-Length headers from the message
* header. This will then set the appropriate Content-Length header
* with the correct length. If a the Connection header is set with the
* close token then the semantics of the connection are such that the
* server will close it once the output stream or request is closed.
*
* @param length this is the length of the HTTP message body
*/
public void setContentLength(int length);
/**
* Used to write a message body with the
* This will ensure that there is buffering done so that the output
* can be reset using the
* The retrieved
* Implementations of the
* The retrieved
* Implementations of the
* This will ensure that there is buffering done so that the output
* can be reset using the
* This also performs some final checks on the headers submitted.
* This is done to determine the optimal performance of the
* output. If no specific Connection header has been specified
* this will set the connection so that HTTP/1.0 closes by default.
*
* @exception IOException thrown if there was a problem writing
*/
public void commit() throws IOException;
/**
* This can be used to determine whether the
* All cookies set on the response header will be delivered as a
* Set-Cookie header in the response message. The Content-Length and
* Transfer-Encoding headers can be set to configure how the message
* body is delivered to the connected client.
*
* @author Niall Gallagher
*/
public interface ResponseHeader extends StatusLine {
/**
* This is used to acquire the names of the of the headers that
* have been set in the response. This can be used to acquire all
* header values by name that have been set within the response.
* If no headers have been set this will return an empty list.
*
* @return a list of strings representing the set header names
*/
public List
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered list of tokens extracted from the header(s)
*/
public List
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered list of tokens extracted from the header(s)
*/
public List
* This removes any previous Content-Length headers from the message
* header. This will then set the appropriate Content-Length header with
* the correct length. If a the Connection header is set with the close
* token then the semantics of the connection are such that the server
* will close it once the
* This will ensure that there is buffering done so that the output
* can be reset using the
* The retrieved
* Implementations of the
* The retrieved
* Implementations of the
* This will ensure that there is buffering done so that the output
* can be reset using the
* This also performs some final checks on the headers submitted.
* This is done to determine the optimal performance of the
* output. If no specific Connection header has been specified
* this will set the connection so that HTTP/1.0 closes by default.
*
* @exception IOException thrown if there was a problem writing
*/
public void commit() throws IOException {
response.commit();
}
/**
* This can be used to determine whether the
* The official HTTP status codes are defined in RFC 2616 section 10.
* Each set of status codes belongs to a specific family. Each family
* describes a specific scenario. Although it is possible to use other
* status codes it is recommended that servers restrict their status
* code responses to those specified in this enumeration.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.StatusLine
*/
public enum Status {
/**
* This represents a successful response of a targeted request.
*/
OK(200, "OK"),
/**
* This is used to signify that a resource was created successfully.
*/
CREATED(201, "Created"),
/**
* This is used to signify that the request has been accepted.
*/
ACCEPTED(202, "Accepted"),
/**
* This represents a response that contains no response content.
*/
NO_CONTENT(204, "No Content"),
/**
* This is used to represent a response that resets the content.
*/
RESET_CONTENT(205, "Reset Content"),
/**
* This is used to represent a response that has partial content.
*/
PARTIAL_CONTENT(206, "Partial Content"),
/**
* This is used to represent a response where there are choices.
*/
MULTIPLE_CHOICES(300, "Multiple Choices"),
/**
* This is used to represent a target resource that has moved.
*/
MOVED_PERMANENTLY(301, "Moved Permanently"),
/**
* This is used to represent a resource that has been found.
*/
FOUND(302, "Found"),
/**
* This is used to tell the client to see another HTTP resource.
*/
SEE_OTHER(303, "See Other"),
/**
* This is used in response to a target that has not been modified.
*/
NOT_MODIFIED(304, "Not Modified"),
/**
* This is used to tell the client that it should use a proxy.
*/
USE_PROXY(305, "Use Proxy"),
/**
* This is used to redirect the client to a resource that has moved.
*/
TEMPORARY_REDIRECT(307, "Temporary Redirect"),
/**
* This is used to tell the client they have send an invalid request.
*/
BAD_REQUEST(400, "Bad Request"),
/**
* This is used to tell the client that authorization is required.
*/
UNAUTHORIZED(401, "Unauthorized"),
/**
* This is used to tell the client that payment is required.
*/
PAYMENT_REQUIRED(402, "Payment Required"),
/**
* This is used to tell the client that the resource is forbidden.
*/
FORBIDDEN(403, "Forbidden"),
/**
* This is used to tell the client that the resource is not found.
*/
NOT_FOUND(404, "Not Found"),
/**
* This is used to tell the client that the method is not allowed.
*/
METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
/**
* This is used to tell the client the request is not acceptable.
*/
NOT_ACCEPTABLE(406, "Not Acceptable"),
/**
* This is used to tell the client that authentication is required.
*/
PROXY_AUTHENTICATION_REQUIRED(407, "Proxy Authentication Required"),
/**
* This is used to tell the client that the request has timed out.
*/
REQUEST_TIMEOUT(408, "Request Timeout"),
/**
* This is used to tell the client that there has been a conflict.
*/
CONFLICT(409, "Conflict"),
/**
* This is used to tell the client that the resource has gone.
*/
GONE(410, "Gone"),
/**
* This is used to tell the client that a request length is needed.
*/
LENGTH_REQUIRED(411, "Length Required"),
/**
* This is used to tell the client that a precondition has failed.
*/
PRECONDITION_FAILED(412, "Precondition Failed"),
/**
* This is used to tell the client that the request body is too big.
*/
REQUEST_ENTITY_TOO_LARGE(413, "Request Entity Too Large"),
/**
* This is used to tell the client that the request URI is too long.
*/
REQUEST_URI_TOO_LONG(414, "Request-URI Too Long"),
/**
* This is used to tell the client that the content type is invalid.
*/
UNSUPPORTED_MEDIA_TYPE(415, "Unsupported Media Type"),
/**
* This is used to tell the client that the range is invalid.
*/
REQUESTED_RANGE_NOT_SATISFIABLE(416, "Requested Range Not Satisfiable"),
/**
* This is used to tell the client that the expectation has failed.
*/
EXPECTATION_FAILED(417, "Expectation Failed"),
/**
* This is sent when the request has caused an internal server error.
*/
INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
/**
* This is used to tell the client the resource is not implemented.
*/
NOT_IMPLEMENTED(501, "Not Implemented"),
/**
* This is used to tell the client that the gateway is invalid.
*/
BAD_GATEWAY(502, "Bad Gateway"),
/**
* This is used to tell the client the resource is unavailable.
*/
SERVICE_UNAVAILABLE(503, "Service Unavailable"),
/**
* This is used to tell the client there was a gateway timeout.
*/
GATEWAY_TIMEOUT(504, "Gateway Timeout"),
/**
* This is used to tell the client the request version is invalid.
*/
VERSION_NOT_SUPPORTED(505, "Version Not Supported");
/**
* This is the description of the status this instance represents.
*/
private final String description;
/**
* This is the code for the status that this instance represents.
*/
private final int code;
/**
* Constructor for the
* Reading and writing to a channel is performed using two special
* interfaces. The first is the
* Because this collects bytes in a non-blocking manner there may
* be a situation where there are no bytes left. In such an event
* the collector needs to be queued until such time as there are
* more bytes ready to read from the socket. To achieve this it is
* given a
* A consumer has completed its task when it has either exhausted its
* stream, or when it has consume a terminal token. For instance a
* consumer for a HTTP header will have two
* All implementations must ensure that the container is thread safe
* as it will receive multiple HTTP transactions concurrently. Also
* it should be known that the
* The
* The request and response objects are used to interact with the
* connected pipeline, in such a way that requests and response
* objects can be delivered in sequence and without interference.
* The next request from a HTTP pipeline is only processed once
* the
* Typical usage of this method is to accept multiple transport
* objects, each representing a unique HTTP channel to the client,
* and process requests from those transports concurrently.
*
* @param transport the transport to process requests from
*/
public void process(Transport transport) throws IOException {
selector.start(new TransportChannel(transport));
}
/**
* This method is used to stop the
* Typically this method is called once all connections to the
* server have been stopped. As a final act of shutting down the
* entire server all threads must be stopped, this allows collection
* of unused memory and the closing of file and socket resources.
*/
public void stop() throws IOException {
selector.stop();
allocator.close();
}
} simple-http-4.1.21/src/org/simpleframework/http/core/ContainerSelector.java 0000664 0000000 0000000 00000014117 12536602605 0027040 0 ustar 00root root 0000000 0000000 /*
* ContainerSelector.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
* Here we stop the
* In order to process the requests this uses two thread pools. One
* is used to collect data from the pipelines and create the requests.
* The other is used to service those requests. Such an architecture
* ensures that the serving thread does not have to deal with I/O
* operations. All data is consumed before it is serviced.
*
* @author Niall Gallagher
*/
public class ContainerServer implements Server {
/**
* This is the transporter used to process the connections.
*/
private final Processor processor;
/**
* This is used to deliver pipelines to the container.
*/
private final Server server;
/**
* Constructor for the
* Typical usage of this method is to accept multiple pipeline
* objects, each representing a unique HTTP channel to the client,
* and process requests from those pipelines concurrently.
*
* @param socket this is the connected HTTP pipeline to process
*/
public void process(Socket socket) throws IOException {
server.process(socket);
}
/**
* This method is used to stop the
* Typically this method is called once all connections to the
* server have been stopped. As a final act of shutting down the
* entire server all threads must be stopped, this allows collection
* of unused memory and the closing of file and socket resources.
*/
public void stop() throws IOException {
server.stop();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ContentConsumer.java 0000664 0000000 0000000 00000025021 12536602605 0026537 0 ustar 00root root 0000000 0000000 /*
* ContentConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher
* The definition of a literal for RFC 2616 is anything between 2
* quotes but excuding quotes that are prefixed with the backward
* slash character.
*/
private void pack() {
char old = buf[0];
int len = count;
int seek = 0;
int pos = 0;
while(seek < len){
char ch = buf[seek++];
if(ch == '"' && old != '\\'){ /* qd-text*/
buf[pos++] = ch;
while(seek < len){
old = buf[seek-1];
ch = buf[seek++];
buf[pos++] = ch;
if(ch =='"'&& old!='\\'){ /*qd-text*/
break;
}
}
}else if(!space(ch)){
old = buf[seek - 1];
buf[pos++] = old;
}
}
count = pos;
}
/**
* This is used to determine the type of the disposition header. This
* will allow the parser to determine it the header represents form
* data or a file upload. Once it determines the type of the upload
* header it sets an internal flag which can be used.
*/
private void type() {
if(skip("form-data")) {
form = true;
} else if(skip("file")) {
form = false;
}
}
/**
* This will read the parameters from the header value. This will search
* for the
* As well as providing the header values and request line values
* this will also provide convenience methods which enable the user
* to determine the length of the body this message header prefixes.
*
* @author Niall Gallagher
*/
interface Header extends Segment {
/**
* This can be used to get the target specified for this HTTP
* request. This corresponds to the URI sent in the request
* line. Typically this will be the path part of the URI, but
* can be the full URI if the request is a proxy request.
*
* @return the target URI that this HTTP request specifies
*/
public String getTarget();
/**
* This is used to acquire the address from the request line.
* An address is the full URI including the scheme, domain,
* port and the query parts. This allows various parameters
* to be acquired without having to parse the target.
*
* @return this returns the address of the request line
*/
public Address getAddress();
/**
* This is used to acquire the path as extracted from the
* the HTTP request URI. The
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered list of tokens extracted from the header(s)
*/
public List
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param list this is the list of individual header values
*
* @return ordered list of tokens extracted from the header(s)
*/
public List
* If however the response is delivered successfully the monitor is
* notified of this event. On successful delivery the monitor will
* hand the
* This will also encode any special characters that appear
* within the name and value pairs as an escaped sequence.
* If there are no parameters an empty string is returned.
*
* @return returns an empty string if the is no parameters
*/
public String toString() {
return query.toString();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartHeaderConsumer.java 0000664 0000000 0000000 00000005261 12536602605 0027150 0 ustar 00root root 0000000 0000000 /*
* PartHeaderConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher
* The
* The
* It is important to note that the
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearence.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has higest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered array of tokens extracted from the header(s)
*/
public List
* This should never allow the message body be sent if it should not
* be sent with the headers as of RFC 2616 rules for the presence of
* a message body. A message body must not be included with a HEAD
* request or with a 304 or a 204 response. A proper implementation
* of this will prevent a message body being sent if the response
* is to a HEAD request of if there is a 304 or 204 response code.
*
* It is important to note that the
* This removes any previous Content-Length headers from the message
* header. This will then set the appropriate Content-Length header with
* the correct length. If a the Connection header is set with the close
* token then the semantics of the connection are such that the server
* will close it once the
* This will ensure that there is buffering done so that the output
* can be reset using the
* The retrieved
* The retrieved
* This will ensure that there is buffering done so that the output
* can be reset using the
* This also performs some final checks on the headers submitted.
* This is done to determine the optimal performance of the
* output. If no specific Connection header has been specified
* this will set the connection so that HTTP/1.0 closes by default.
*
* @exception IOException thrown if there was a problem writing
*/
public void commit() throws IOException {
if(!committed) {
Cookie cookie = header.getSession(false);
if(cookie != null) {
setSession(cookie);
}
byte[] message = getMessage();
sender.send(message);
committed = true;
}
}
/**
* This is used to set the session cookie for the response. This
* checks to see if the session cookie has not been overwritten.
* If the cookie was overwritten then the provided session cookie
* will not be used and the existing one will be used by this.
*
* @param session this is the session cookie that is to be set
*/
private void setSession(Cookie session) {
String name = session.getName();
Cookie cookie = getCookie(name);
if(cookie == null) {
cookie = session;
}
if(cookie.isNew()) {
setCookie(cookie);
}
}
/**
* This can be used to determine whether the
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered array of tokens extracted from the header(s)
*/
public List
* The tokens returned by this method are ordered according to
* there HTTP quality values, or "q" values, see RFC 2616 section
* 3.9. This also strips out the quality parameter from tokens
* returned. So "image/html; q=0.9" results in "image/html". If
* there are no "q" values present then order is by appearance.
*
* The result from this is either the trimmed header value, that
* is, the header value with no leading or trailing whitespace
* or an array of trimmed tokens ordered with the most preferred
* in the lower indexes, so index 0 is has highest preference.
*
* @param name the name of the headers that are to be retrieved
*
* @return ordered array of tokens extracted from the header(s)
*/
public List
* The start event is used to immediately consume bytes form the
* underlying transport, it does not require a select to determine
* if the socket is read ready which provides an initial performance
* enhancement. Also when a response has been delivered the next
* request from the pipeline is consumed immediately.
*
* The select event is used to register the connected socket with a
* Java NIO selector which can efficiently determine when there are
* bytes ready to read from the socket. Finally, the ready event
* is used when a full HTTP entity has been collected from the
* underlying transport. On such an event the request and response
* can be handled by a container.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Collector
*/
interface Selector extends Initiator {
/**
* The start event is used to immediately consume bytes form the
* underlying transport, it does not require a select to check
* if the socket is read ready which improves performance. Also,
* when a response has been delivered the next request from the
* pipeline is consumed immediately.
*
* @param collector this is the collector used to collect data
*/
public void start(Collector collector) throws IOException;
/**
* The select event is used to register the connected socket with
* a Java NIO selector which can efficiently determine when there
* are bytes ready to read from the socket.
*
* @param collector this is the collector used to collect data
*/
public void select(Collector collector) throws IOException;
/**
* The ready event is used when a full HTTP entity has been
* collected from the underlying transport. On such an event the
* request and response can be handled by a container.
*
* @param collector this is the collector used to collect data
*/
public void ready(Collector collector) throws IOException;
/**
* This method is used to stop the
* This will normalize the path part of the uniform resource
* identifier. A normalized path is one that contains no back
* references like "./" and "../". The normalized path will not
* contain the path parameters.
*
* The
* The
* This returns a
* This will produce unique name and value parameters. Thus if the
* URI contains several path segments with similar parameter names
* this will return the deepest parameter. For example if the URI
* represented was
* Caution must be taken to ensure that the port and
* the scheme are consistent. So if the original URI
* was
* This will reset the parameters this URI has. If the value
* given to this method has embedded parameters these will form
* the parameters of this URI. The value given may not be the
* same value that the
* This will reset the parameters this URI has. If the value
* given to this method has embedded parameters these will form
* the parameters of this URI. The value given may not be the
* same value that the
* The syntax for the scheme is given in RFC 2396 as follows
*
* This uses the following delimiters to determine the end of the
* domain
* This is slightly different from RFC 2396 in that it defines a
* pchar as the RFC 2396 definition of a pchar without the escaped
* chars. So this method has to ensure that no escaped chars go
* unchecked. This ensures that the read offset does not go out
* of bounds and throw an
* This method has to ensure that no escaped chars go unchecked.
* This ensures that the read offset does not goe out of bounds
* and consequently throw an out of bounds exception.
*/
private void param() {
name();
if(skip("=")){ /* in case of error*/
value();
}
}
/**
* This extracts the name of the parameter from the character
* buffer. The name of a parameter is defined as a set of
* pchars including escape sequences. This will extract the
* parameter name and buffer the chars. The name ends when a
* equals character, "=", is encountered or in the case of a
* malformed parameter when the next character is not a pchar.
*/
private void name(){
int mark = off;
int pos = off;
while(off < count){
if(buf[off]=='%'){ /* escaped */
escape();
}else if(buf[off]=='=') {
break;
}else if(!pchar(buf[off])){
break;
}
buf[pos++] = buf[off++];
}
name.len = pos - mark;
name.off = mark;
}
/**
* This extracts a parameter value from a path segment. The
* parameter value consists of a sequence of pchars and some
* escape sequences. The parameter value is buffered so that
* the name and values can be paired. The end of the value
* is determined as the end of the buffer or the last pchar.
*/
private void value(){
int mark = off;
int pos = off;
while(off < count){
if(buf[off]=='%'){ /* escaped */
escape();
}else if(!pchar(buf[off])) {
break;
}
buf[pos++] = buf[off++];
}
value.len = pos - mark;
value.off = mark;
}
/**
* This method adds the name and value to a map so that the next
* name and value can be collected. The name and value are added
* to the map as string objects. Once added to the map the
*
* This will leave the next character to read from the buffer
* as the character encoded from the URI. If there is a fully
* valid escaped sequence, that is
* The WWW Consortium provides a reference implementation of a
* UTF-8 decoding for Java, in this the low order octets in the
* UCS-4 sequence are used for the character. So, in the
* absence of a defined behaviour, the W3C behaviour is assumed.
*
* @param peek this is the first escaped character from the URI
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek) {
if((peek & 0x80) == 0x00){
return unicode(peek, 0);
}
if((peek & 0xe0) == 0xc0){
return unicode(peek & 0x1f, 1);
}
if((peek & 0xf0) == 0xe0){
return unicode(peek & 0x0f, 2);
}
if((peek & 0xf8) == 0xf0){
return unicode(peek & 0x07, 3);
}
if((peek & 0xfc) == 0xf8){
return unicode(peek & 0x03, 4);
}
if((peek & 0xfe) == 0xfc){
return unicode(peek & 0x01, 5);
}
return false;
}
/**
* This method will decode the specified amount of escaped
* characters from the URI and convert them into a single Java
* UCS-2 character. If there are not enough characters within
* the URI then this will return false and leave the URI alone.
*
* The number of characters left is determined from the first
* UTF-8 octet, as specified in RFC 2279, and because this is
* a URI there must that number of
* If at any point during the accumulation of the UTF-8 bits
* there is a parsing error, then parsing is aborted an false
* is returned, as a result the URI is left unchanged.
*
* @param peek bytes that have been accumulated from the URI
* @param more this specifies the number of UTF octets left
* @param pos this specifies the position the parsing begins
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek, int more, int pos) {
while(more-- > 0) {
if(buf[pos] == '%'){
int next = pos + 3;
int hex = peek(next);
if((hex & 0xc0) == 0x80){
peek = (peek<<6)|(hex&0x3f);
pos = next;
continue;
}
}
return false;
}
if(pos + 2 < count) {
off = pos + 2;
buf[off]= bits(peek);
}
return true;
}
/**
* Defines behaviour for UCS-2 versus UCS-4 conversion from four
* octets. The UTF-8 encoding scheme enables UCS-4 characters to
* be encoded and decodeded. However, Java supports the 16-bit
* UCS-2 character set, and so the 32-bit UCS-4 character set is
* not compatable. This basically decides what to do with UCS-4.
*
* @param data up to four octets to be converted to UCS-2 format
*
* @return this returns a native UCS-2 character from the int
*/
private char bits(int data) {
return (char)data;
}
/**
* This will return the escape expression specified from the URI
* as an integer value of the hexidecimal sequence. This does
* not make any changes to the buffer it simply checks to see if
* the characters at the position specified are an escaped set
* characters of the form
* It can return
* The
* The definition of a literal for RFC 2616 is anything between 2
* quotes but excluding quotes that are prefixed with the backward
* slash character.
*/
private void pack() {
char old = buf[0];
int len = count;
int seek = 0;
int pos = 0;
while(seek < len){
char ch = buf[seek++];
if(ch == '"' && old != '\\'){ /* qd-text*/
buf[pos++] = ch;
while(seek < len){
old = buf[seek-1];
ch = buf[seek++];
buf[pos++] = ch;
if(ch =='"'&& old!='\\'){ /*qd-text*/
break;
}
}
}else if(!space(ch)){
old = buf[seek - 1];
buf[pos++] = old;
}
}
count = pos;
}
/**
* This reads the type from the MIME type. This will fill the
* type
* This will remove any parameters that preceed the charset parameter.
* Once the
* Each cookie has a
* This
* If there is no
* If there is no
* The path method reads the terminal found before it as does the
*
* This reads the terminal before the
* This reads the terminal before the
* This will read all digit
* To find out when there are no more cookies left use the
*
* This can also parse the date in ms as retrived from the
* This produces the same string as the
* This will then set this object to one that uses the RFC 1123 format
* for a date.
*
* @param date the date to be parsed
*/
public DateParser(long date){
this();
parse(date);
}
/** This constructor will conveniently parse the
* This will then set this object to one that uses the RFC 1123 format
* for a date.
*
* @param date the date to be parsed
*/
public DateParser(String date) {
this();
parse(date);
}
/**
* This is used to extract the date from a
* This saves time on parsing a
* This may parse more than 2 digits but if there are more than 2 digits
* in a row then the date format is incorrect anyway.
*/
private void year2(){
int mill = 2000; /* milleneum */
int cent = 0; /* century */
while(off < count){
if(!digit(buf[off])){
break;
}
cent *= 10;
cent += buf[off];
cent -= '0';
off++;
}
year= mill+cent; /* result 4 digits*/
}
/**
* This is used to get the year from a set of digit characters. This
* is used to parse years that are of the form of 4 digits (e.g 1982).
*
* This may parse more than 4 digits but if there are more than 2
* digits in a row then the date format is incorrect anyway.
*/
private void year4() {
while(off < count){
if(!digit(buf[off])){
break;
}
year *= 10;
year += buf[off];
year -= '0';
off++;
}
}
/**
* This is used to parse the time for a HTTP-date. The time for a
* HTTP-date is in the form
* This may parse more than 2 digits but if there are more than 2
* digits the date is already incorrect.
*/
private void hours(){
while(off < count){
if(!digit(buf[off])){
break;
}
hour *= 10;
hour += buf[off];
hour -= '0';
off++;
}
}
/**
* This is used to initialize the mins. This will read a consecutive
* sequence of digit characters and convert them into a decimal number
* to represent the mins that this date represents.
*
* This may parse more than 2 digits but if there are more than 2
* digits the date is already incorrect.
*/
private void mins(){
while(off < count){
if(!digit(buf[off])){
break;
}
mins *= 10;
mins += buf[off];
mins -= '0';
off++;
}
}
/**
* This is used to initialize the secs. This will read a consecutive
* sequence of digit characters and convert them into a decimal
* number to represent the secs that this date represents.
*
* This may parse more than 2 digits but if there are more than 2
* digits the date is already incorrect
*/
private void secs(){
while(off < count){
if(!digit(buf[off])){
break;
}
secs *= 10;
secs += buf[off];
secs -= '0';
off++;
}
}
/**
* This is used to read the week day of HTTP-date. The shorthand day
* (e.g Mon for Monday) is used by the RFC 1123 and asctime date formats.
* This will simply try to read each day from the buffer, when the day
* is read successfully then the index of that day is saved.
*/
private void wkday(){
for(int i =0; i < WKDAYS.length;i++){
if(skip(WKDAYS[i])){
weekday = i;
return;
}
}
}
/**
* This is used to read the week day of HTTP-date. This format is used
* by the RFC 850 date format. This will simply try to read each day from
* the buffer, when the day is read successfully then the index of that
* day is saved.
*/
private void weekday(){
for(int i =0; i < WKDAYS.length;i++){
if(skip(WEEKDAYS[i])){
weekday = i;
return;
}
}
}
/**
* This is used to read the month of HTTP-date. This will simply
* try to read each month from the buffer, when the month is read
* successfully then the index of that month is saved.
*/
private void month(){
for(int i =0; i < MONTHS.length;i++){
if(skip(MONTHS[i])){
month = i;
return;
}
}
}
/**
* This is used to append the date in RFC 1123 format to the given
* string builder. This will append the date and a trailing space
* character to the buffer. Dates like the following are appended.
*
* The HTTP date must be in the form of RFC 1123. The hours, minutes
* and seconds are appended with the 0 character if they are less than
* 9 i.e. if they do not have two digits.
*
* @return the date in RFC 1123 format
*/
public String toString(){
StringBuilder builder = new StringBuilder(30);
date(builder);
time(builder);
zone(builder);
return builder.toString();
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/LanguageParser.java 0000664 0000000 0000000 00000013027 12536602605 0026476 0 ustar 00root root 0000000 0000000 /*
* LanguageParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
* This uses the qvalues outlined by RFC 2616 to order the language tokens
* by preference. Typically the language tokens will not have qvalues with
* the language. However when a language tag has the qvalue parameter then
* this tag will be ordered based on the value of that parameter. A language
* tag without the qvalue parameter is considered to have a qvalue of 1 and
* is ordered accordingly.
*
* @author Niall Gallagher
*/
public class LanguageParser extends ListParser
* Each value within a list has an implicit quality value of 1.0.
* If the value is explicitly set with a the "q" parameter, then
* the values can range from 1.0 to 0.001. This parser ensures
* that the order of values returned from the
* One thing that should be noted is that this will not empty
* the priority queue on each string parsed. This ensures that
* if there are multiple strings they can be parsed quickly
* and also contribute to the final result.
*/
protected void init(){
if(text.length < count){
text = new char[count];
}
if(!build) {
list.clear();
}
pos = off = 0;
order.clear();
}
/**
* This is used to return the parser to a semi-initialized state.
* After extracting a token from the list the buffer will have
* accumulated bytes, this ensures that bytes previously written
* to the buffer do not interfere with the next token extracted.
*
* This also ensures the implicit qvalue is reset to the maximum
* long value, so that the next token parsed without a qvalue
* will have the highest priority and be placed at the top of
* the list. This ensures order is always maintained.
*/
private void clear() {
qvalue = MAX_VALUE;
pos = 0;
}
/**
* This method will extract a token from a comma separated list
* and write it to a buffer. This performs the extraction in such
* a way that it can tolerate literals, parameters, and quality
* value parameters. The only alterations made to the token by
* this method is the removal of quality values, that is, qvalue
* parameters which have the name "q". Below is an example of
* some of the lists that this can parse.
*
* If the path that this represents is
* Although RFC 2396 defines the path within a URI to have parameters this
* does not extract those parameters this will simply normalize the path and
* include the path parameters in the path. If the path is to be converted
* into a OS specific file system path that has the parameters extracted
* then the
* This will NOT parse an immediate back reference as this signifies
* a path that cannot exist. So a path such as
* This method ensures the if there are an illegal number of back
* references that the path will be evaluated as empty. This can
* evaluate any path configuration, this includes any references
* like
* This follows the parsing tree of RFC 2617. The goal of this parser
* is to decode the
* The definition of a literal for RFC 2616 is anything between 2
* quotes but excuding quotes that are prefixed with the backward
* slash character.
*/
private void pack() {
int len = count;
int seek = 0; /* read */
int pos = 0; /* write */
char ch = 0;
while(seek
* For information on the decoding scheme used for
* The table for translation the data can be found in RFC 2045 on
* MIME, Multipurpose Internet Mail Extensions.
*
* @param octet this is the octet ttat is to be translated
*
* @return this returns the translated octet
*/
private int translate(int octet) {
if(octet >= 'A' && octet <= 'Z') {
octet = octet - 'A';
} else if(octet >= 'a' && octet <= 'z') {
octet = (octet - 'a') + 26;
} else if(octet >= '0' && octet <= '9') {
octet = (octet - '0') + 52;
} else if(octet == '+') {
octet = 62;
} else if(octet == '/') {
octet = 63;
} else if(octet == '=') {
octet = 65;
} else {
octet = -1;
}
return octet;
}
/**
* This is used to extract the
* This method has to ensure that no escaped chars go unchecked.
* This ensures that the read offset does not go out of bounds
* and consequently throw an out of bounds exception.
*/
private void param() {
name();
if(skip("=")){ /* in case of error*/
value();
}
insert();
}
/**
* This extracts the name of the parameter from the character
* buffer. The name of a parameter is defined as a set of
* chars including escape sequences. This will extract the
* parameter name and buffer the chars. The name ends when a
* equals character, "=", is encountered.
*/
private void name(){
int mark = off;
int pos = off;
while(off < count){
if(buf[off]=='%'){ /* escaped */
escape();
}else if(buf[off]=='=') {
break;
}else if(buf[off]=='+'){
buf[off] = ' ';
}
buf[pos++] = buf[off++];
}
name.len = pos - mark;
name.off = mark;
}
/**
* This extracts a parameter value from a path segment. The
* parameter value consists of a sequence of chars and some
* escape sequences. The parameter value is buffered so that
* the name and values can be paired. The end of the value
* is determined as the end of the buffer or an ampersand.
*/
private void value(){
int mark = off;
int pos = off;
while(off < count){
if(buf[off]=='%'){ /* escaped */
escape();
}else if(buf[off]=='+'){
buf[off] = ' ';
}else if(buf[off]=='&'){
break;
}
buf[pos++] = buf[off++];
}
value.len = pos - mark;
value.off = mark;
}
/**
* This converts an encountered escaped sequence, that is all
* embedded hexidecimal characters into a native UCS character
* value. This does not take any characters from the stream it
* just prepares the buffer with the correct byte. The escaped
* sequence within the URI will be interpreded as UTF-8.
*
* This will leave the next character to read from the buffer
* as the character encoded from the URI. If there is a fully
* valid escaped sequence, that is
* The WWW Consortium provides a reference implementation of a
* UTF-8 decoding for Java, in this the low order octets in the
* UCS-4 sequence are used for the character. So, in the
* absence of a defined behaviour, the W3C behaviour is assumed.
*
* @param peek this is the first escaped character from the URI
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek) {
if((peek & 0x80) == 0x00){
return unicode(peek, 0);
}
if((peek & 0xe0) == 0xc0){
return unicode(peek & 0x1f, 1);
}
if((peek & 0xf0) == 0xe0){
return unicode(peek & 0x0f, 2);
}
if((peek & 0xf8) == 0xf0){
return unicode(peek & 0x07, 3);
}
if((peek & 0xfc) == 0xf8){
return unicode(peek & 0x03, 4);
}
if((peek & 0xfe) == 0xfc){
return unicode(peek & 0x01, 5);
}
return false;
}
/**
* This method will decode the specified amount of escaped
* characters from the URI and convert them into a single Java
* UCS-2 character. If there are not enough characters within
* the URI then this will return false and leave the URI alone.
*
* The number of characters left is determined from the first
* UTF-8 octet, as specified in RFC 2279, and because this is
* a URI there must that number of
* If at any point during the accumulation of the UTF-8 bits
* there is a parsing error, then parsing is aborted an false
* is returned, as a result the URI is left unchanged.
*
* @param peek bytes that have been accumulated fron the URI
* @param more this specifies the number of UTF octets left
* @param pos this specifies the position the parsing begins
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek, int more, int pos) {
while(more-- > 0) {
if(buf[pos] == '%'){
int next = pos + 3;
int hex = peek(next);
if((hex & 0xc0) == 0x80){
peek = (peek<<6)|(hex&0x3f);
pos = next;
continue;
}
}
return false;
}
if(pos + 2 < count) {
off = pos + 2;
buf[off]= bits(peek);
}
return true;
}
/**
* Defines behaviour for UCS-2 versus UCS-4 conversion from four
* octets. The UTF-8 encoding scheme enables UCS-4 characters to
* be encoded and decodeded. However, Java supports the 16-bit
* UCS-2 character set, and so the 32-bit UCS-4 character set is
* not compatable. This basically decides what to do with UCS-4.
*
* @param data up to four octets to be converted to UCS-2 format
*
* @return this returns a native UCS-2 character from the int
*/
private char bits(int data) {
return (char)data;
}
/**
* This will return the escape expression specified from the URI
* as an integer value of the hexadecimal sequence. This does
* not make any changes to the buffer it simply checks to see if
* the characters at the position specified are an escaped set
* characters of the form
* Each value within a list has an implicit quality value of 1.0.
* If the value is explicitly set with a the "q" parameter, then
* the values can range from 1.0 to 0.001. This parser ensures
* that the order of values returned from the
* This object essentially provides a mechanism that allows the file
* engine to convert the HTTP request URI into OS system paths and
* system objects such as the
* The meaning of HTTP URI in this instance is the request URI
* from a HTTP/x.x request, as RFC 2616 and RFC 2396 defines it
*
*
* Implementations of the
* This
* This
* This is similar in design to a
* This provides a very simple means to manage individual targets
* using separate resource implementations. It also provides an
* ideal location to introduce path mapping functionality.
*
* @author Niall Gallagher
*/
public class ResourceContainer implements Container {
/**
* The engine that resolves the resources to be used.
*/
private final ResourceEngine engine;
/**
* Constructor for the
* The meaning of HTTP URI in this instance is the request URI
* from a HTTP/x.x request, as RFC 2616 and RFC 2396 defines it
*
* http://domain/path1;x=y/path2;x=z
* the value for the parameter named x would be
* z.
*
* @return this will return the parameter names found in the URI
*/
public KeyMapString
* object. This will only convert the parts of the URI that exist, so
* the URI may not contain the domain or the query part and it will
* not contain the path parameters. If the URI contains all these
* parts then it will return something like
*
* scheme://host:port/path/path?querypart
*
* /path/path?querypart style relative
* URI's. If any of the parts are set to null then that part will be
* missing, for example if only the path is available then this will
* omit the domain, port and scheme. Showing a relative address.
*
* scheme://host:port/?querypart
*
*
* @return the URI address with the optional parts if available
*/
public String toString();
}
simple-http-4.1.21/src/org/simpleframework/http/ContentType.java 0000664 0000000 0000000 00000012074 12536602605 0024741 0 ustar 00root root 0000000 0000000 /*
* ContentType.java February 2001
*
* Copyright (C) 2001, Niall Gallagher charset parameter is one of many parameters that
* can be associated with a MIME type. This however this exposes this
* parameter with a typed method.
* getCharset will return the character encoding the
* content type is encoded within. This allows the user of the content
* to decode it correctly. Other parameters can be acquired from this
* by simply providing the name of the parameter.
*
* @author Niall Gallagher
*/
public interface ContentType {
/**
* This sets the primary type to whatever value is in the string
* provided is. If the string is null then this will contain a
* null string for the primary type of the parameter, which is
* likely invalid in most cases.
*
* @param type the type to set for the primary type of this
*/
public void setPrimary(String type);
/**
* This is used to retrieve the primary type of this MIME type. The
* primary type part within the MIME type defines the generic type.
* For example text/plain; charset=UTF-8. This will
* return the text value. If there is no primary type then this
* will return null otherwise the string value.
*
* @return the primary type part of this MIME type
*/
public String getPrimary();
/**
* This sets the secondary type to whatever value is in the string
* provided is. If the string is null then this will contain a
* null string for the secondary type of the parameter, which is
* likely invalid in most cases.
*
* @param type the type to set for the primary type of this
*/
public void setSecondary(String type);
/**
* This is used to retrieve the secondary type of this MIME type.
* The secondary type part within the MIME type defines the generic
* type. For example text/html; charset=UTF-8. This
* will return the HTML value. If there is no secondary type then
* this will return null otherwise the string value.
*
* @return the primary type part of this MIME type
*/
public String getSecondary();
/**
* This will set the charset to whatever value the
* string contains. If the string is null then this will not set
* the parameter to any value and the toString method
* will not contain any details of the parameter.
*
* @param charset parameter value to add to the MIME type
*/
public void setCharset(String charset);
/**
* This is used to retrieve the charset of this MIME
* type. This is a special parameter associated with the type, if
* the parameter is not contained within the type then this will
* return null, which typically means the default of ISO-8859-1.
*
* @return the value that this parameter contains
*/
public String getCharset();
/**
* This is used to retrieve an arbitrary parameter from the MIME
* type header. This ensures that values for boundary
* or other such parameters are not lost when the header is parsed.
* This will return the value, unquoted if required, as a string.
*
* @param name this is the name of the parameter to be retrieved
*
* @return this is the value for the parameter, or null if empty
*/
public String getParameter(String name);
/**
* This will add a named parameter to the content type header. If
* a parameter of the specified name has already been added to the
* header then that value will be replaced by the new value given.
* Parameters such as the boundary as well as other
* common parameters can be set with this method.
*
* @param name this is the name of the parameter to be added
* @param value this is the value to associate with the name
*/
public void setParameter(String name, String value);
/**
* This will return the value of the MIME type as a string. This
* will concatenate the primary and secondary type values and
* add the charset parameter to the type which will
* recreate the content type.
*
* @return this returns the string representation of the type
*/
public String toString();
}
simple-http-4.1.21/src/org/simpleframework/http/Cookie.java 0000664 0000000 0000000 00000034367 12536602605 0023707 0 ustar 00root root 0000000 0000000 /*
* Cookie.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Cookie is set to 1. The version can be configured
* using the setVersion method. The domain, path,
* security, and expiry of the cookie can also be set using their
* respective set methods.
* toString method allows the Cookie
* to be converted back into text form. This text form converts the
* cookie according to the Set-Cookie header form. This is done so
* that a created Cookie instance can be converted
* to a string which can be used as a a HTTP header.
*
* @author Niall Gallagher
*/
public class Cookie {
/**
* The name attribute of this cookie instance.
*/
private String name;
/**
* The value attribute of this cookie instance.
*/
private String value;
/**
* Represents the value of the path for this cookie.
*/
private String path;
/**
* Represents the value of the domain attribute.
*/
private String domain;
/**
* Determines whether the cookie should be secure.
*/
private boolean secure;
/**
* This is used to determine the the cookie is new.
*/
private boolean created;
/**
* Represents the value of the version attribute.
*/
private int version;
/**
* Represents the duration in seconds of the cookie.
*/
private int expiry;
/**
* Constructor of the Cookie that does not need
* the name or value to be set. This allows the object to be
* extended without the need to supply the name and value of
* the cookie. If this constructor is used then the name and
* values retrieved should not be null values.
*/
protected Cookie() {
super();
}
/**
* Constructor of the Cookie that uses a default
* version of 1, which is used by RFC 2109. This contains none
* of the optional attributes, such as domain and path. These
* optional attributes can be set using the set methods.
* Cookie that uses a default
* version of 1, which is used by RFC 2109. This contains none
* of the optional attributes, such as domain and path. These
* optional attributes can be set using the set methods.
* Cookie that uses a default
* version of 1, which is used by RFC 2109. This allows the
* path attribute to be specified for on construction. Other
* attributes can be set using the set methods provided.
* Cookie that uses a default
* version of 1, which is used by RFC 2109. This allows the
* path attribute to be specified for on construction. Other
* attributes can be set using the set methods provided.
* Cookie to be
* set. By default the version of the Cookie is
* set to 1. It is not advisable to set the version higher
* than 1, unless it is known that the client will accept it.
* Cookie
* is for, these values will always be present. These are
* mandatory for both the Cookie and Set-Cookie headers.
* Cookie
* is for, these values will always be present. These are
* mandatory for both the Cookie and Set-Cookie headers.
*
* @return the value from this cookie instance object
*/
public String getValue() {
return value;
}
/**
* This enables the value of the cookie to be changed. This
* can be set to any value the server wishes to send. Cookie
* values can contain space characters as they are transmitted
* in quotes. For example a value of some value
* is perfectly legal. However for maximum compatibility
* across the different plaforms such as PHP, JavaScript and
* others, quotations should be avoided. If quotations are
* required they must be added to the string. For example a
* quoted value could be created as "some value".
*
* @param value this is the new value of this cookie object
*/
public void setValue(String value) {
this.value = value;
}
/**
* This determines whether the cookie is secure. The cookie
* is secure if it has the "secure" token set, as defined
* by RFC 2109. If this token is set then the cookie is only
* sent over secure channels such as SSL and TLS and ensures
* that a third party cannot intercept and spoof the cookie.
*
* @return this returns true if the "secure" token is set
*/
public boolean getSecure() {
return secure;
}
/**
* This is used to determine if the client browser should send
* this cookie over a secure protocol. If this is true then
* the client browser should only send the cookie over secure
* channels such as SSL and TLS. This ensures that the value
* of the cookie cannot be intercepted by a third party.
*
* @param secure if true then the cookie should be protected
*/
public void setSecure(boolean secure) {
this.secure = secure;
}
/**
* This returns the number of seconds a cookie lives for. This
* determines how long the cookie will live on the client side.
* If the expiry is less than zero the cookie lifetime is the
* duration of the client browser session, if it is zero then
* the cookie will be deleted from the client browser.
*
* @return returns the duration in seconds the cookie lives
*/
public int getExpiry() {
return expiry;
}
/**
* This allows a lifetime to be specified for the cookie. This
* will make use of the "max-age" token specified by RFC 2109
* the specifies the number of seconds a browser should keep
* a cookie for. This is useful if the cookie is to be kept
* beyond the lifetime of the client session. If the valie of
* this is zero then this will remove the client cookie, if
* it is less than zero then the "max-age" field is ignored.
*
* @param expiry the duration in seconds the cookie lives
*/
public void setExpiry(int expiry){
this.expiry = expiry;
}
/**
* This returns the path for this cookie. The path is in both
* the Cookie and Set-Cookie headers and so may return null
* if there is no domain value. If the toString
* or toClientString is invoked the path will
* not be present if the path attribute is null.
*
* @return this returns the path value from this cookie
*/
public String getPath() {
return path;
}
/**
* This is used to set the cookie path for this cookie. This
* is set so that the cookie can specify the directories that
* the cookie is sent with. For example if the path attribute
* is set to /pub/bin, then requests for the
* resource http://hostname:port/pub/bin/README
* will be issued with this cookie. The cookie is issued for
* all resources in the path and all subdirectories.
*
* @param path this is the path value for this cookie object
*/
public void setPath(String path) {
this.path = path;
}
/**
* This returns the domain for this cookie. The domain is in
* both the Cookie and Set-Cookie headers and so may return
* null if there is no domain value. If either the
* toString or toClientString is
* invoked the domain will not be present if this is null.
*
* @return this returns the domain value from this cookie
*/
public String getDomain() {
return domain;
}
/**
* This enables the domain for this Cookie to be
* set. The form of the domain is specified by RFC 2109. The
* value can begin with a dot, like .host.com.
* This means that the cookie is visible within a specific
* DNS zone like www.host.com. By default this
* value is null which means it is sent back to its origin.
*
* @param domain this is the domain value for this cookie
*/
public void setDomain(String domain) {
this.domain = domain;
}
/**
* This will give the correct string value of this cookie. This
* will generate the cookie text with only the values that were
* given with this cookie. If there are no optional attributes
* like $Path or $Domain these are left blank. This returns the
* encoding as it would be for the HTTP Cookie header.
*
* @return this returns the Cookie header encoding of this
*/
public String toClientString(){
return "$Version="+version+"; "+name+"="+
value+ (path==null?"":"; $Path="+
path)+ (domain==null? "":"; $Domain="+
domain);
}
/**
* The toString method converts the cookie to the
* Set-Cookie value. This can be used to send the HTTP header
* to a client browser. This uses a format that has been tested
* with various browsers. This is required as some browsers
* do not perform flexible parsing of the Set-Cookie value.
* Path
* it must be path also Netscape can not handle
* the path in quotations such as "/path" it must
* be /path. This value is never in quotations.
* Form interface is used to represent the details
* submitted with a request. Typically this will be parameters given
* by a HTML form, however a form can also contain parts. Each part
* can represent either a file or a parameter. All parts can be
* acquired as Part objects from this Form.
*
* @author Niall Gallagher
*/
public interface Form extends Query {
/**
* This method is used to acquire a Part from the
* form using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name);
/**
* This method provides all parts for this Form. The
* parts for a form can contain text parameters or files. Each file
* part can contain headers, which take the form of HTTP headers to
* describe the payload. Typically headers describe the content.
*
* @return this returns a list of parts for this form
*/
public ListPart object is used to represent a part within
* a request message. Typically a part represents either a text
* parameter or a file, with associated headers. The contents of
* the part can be acquire as an InputStream or as a
* string encoded in the default HTTP encoding ISO-8859-1 or in
* the encoding specified with the Content-Type header.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.Form
*/
public interface Part {
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile();
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName();
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName();
/**
* This is used to acquire the header value for the specified
* header name. Providing the header values through this method
* ensures any special processing for a know content type can be
* handled by an application.
*
* @param name the name of the header to get the value for
*
* @return value of the header mapped to the specified name
*/
public String getHeader(String name);
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @return this returns a string representing the content
*
* @throws IOException thrown if the content can not be created
*/
public String getContent() throws IOException;
/**
* This is used to acquire an InputStream for the
* part. Acquiring the stream allows the content of the part to
* be consumed by reading the stream. Each invocation of this
* method will produce a new stream starting from the first byte.
*
* @return this returns the stream for this part object
*
* @throws IOException thrown if the stream can not be created
*/
public InputStream getInputStream() throws IOException;
/**
* This is used to acquire the content type for this part. This
* is typically the type of content for a file part, as provided
* by a MIME type from the HTTP "Content-Type" header.
*
* @return this returns the content type for the part object
*/
public ContentType getContentType();
}
simple-http-4.1.21/src/org/simpleframework/http/Path.java 0000664 0000000 0000000 00000015533 12536602605 0023364 0 ustar 00root root 0000000 0000000 /*
* Path.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Path represents the path part of a URI. This provides
* the various components of the URI path to the user. The normalization
* of the path is the conversion of the path given into it's actual path by
* removing the references to the parent directories and to the current dir.
* /usr/bin/../etc/./README
* then the actual path, normalized, is /usr/etc/README. Once
* the path has been normalized it is possible to acquire the segments as
* an array of strings, which allows simple manipulation of the path.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.parse.PathParser
*/
public interface Path {
/**
* This will return the extension that the file name contains.
* For example a file name file.en_US.extension
* will produce an extension of extension. This
* will return null if the path contains no file extension.
*
* @return this will return the extension this path contains
*/
public String getExtension();
/**
* This will return the full name of the file without the path.
* As regargs the definition of the path in RFC 2396 the name
* would be considered the last path segment. So if the path
* was /usr/README the name is README.
* Also for directorys the name of the directory in the last
* path segment is returned. This returns the name without any
* of the path parameters. As RFC 2396 defines the path to have
* path parameters after the path segments.
*
* @return this will return the name of the file in the path
*/
public String getName();
/**
* This will return the normalized path. The normalized path is
* the path without any references to its parent or itself. So
* if the path to be parsed is /usr/../etc/./ the
* path is /etc/. If the path that this represents
* is a path with an immediate back reference then this will
* return null. This is the path with all its information even
* the parameter information if it was defined in the path.
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath();
/**
* This will return the normalized path from the specified path
* segment. This allows various path parts to be acquired in an
* efficient means what does not require copy operations of the
* use of substring invocations. Of particular
* interest is the extraction of context based paths. This is
* the path with all its information even the parameter
* information if it was defined in the path.
*
* @param from this is the segment offset to get the path for
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath(int from);
/**
* This will return the normalized path from the specified path
* segment. This allows various path parts to be acquired in an
* efficient means what does not require copy operations of the
* use of substring invocations. Of particular
* interest is the extraction of context based paths. This is
* the path with all its information even the parameter
* information if it was defined in the path.
*
* @param from this is the segment offset to get the path for
* @param count this is the number of path segments to include
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath(int from, int count);
/**
* This method is used to break the path into individual parts
* called segments, see RFC 2396. This can be used as an easy
* way to compare paths and to examine the directory tree that
* the path points to. For example, if an path was broken from
* the string /usr/bin/../etc then the segments
* returned would be usr and etc as
* the path is normalized before the segments are extracted.
*
* @return return all the path segments within the directory
*/
public String[] getSegments();
/**
* This will return the highest directory that exists within
* the path. This is used to that files within the same path
* can be acquired. An example of that this would do given
* the path /pub/./bin/README would be to return
* the highest directory path /pub/bin/. The "/"
* character will allways be the last character in the path.
*
* @return this method will return the highest directory
*/
public String getDirectory();
/**
* This will return the path as it is relative to the issued
* path. This in effect will chop the start of this path if
* it's start matches the highest directory of the given path
* as of getDirectory. This is useful if paths
* that are relative to a specific location are required. To
* illustrate what this method will do the following example
* is provided. If this object represented the path string
* /usr/share/rfc/rfc2396.txt and the issued
* path was /usr/share/text.txt then this will
* return the path string /rfc/rfc2396.txt.
*
* @param path the path prefix to acquire a relative path
*
* @return returns a path relative to the one it is given
* otherwize this method will return null
*/
public String getRelative(String path);
/**
* This will return the normalized path. The normalized path is
* the path without any references to its parent or itself. So
* if the path to be parsed is /usr/../etc/./ the
* path is /etc/. If the path that this represents
* is a path with an immediate back reference then this will
* return null. This is the path with all its information even
* the parameter information if it was defined in the path.
*
* @return this returns the normalize path without
* ../ or ./
*/
public String toString();
}
simple-http-4.1.21/src/org/simpleframework/http/Principal.java 0000664 0000000 0000000 00000003065 12536602605 0024406 0 ustar 00root root 0000000 0000000 /*
* Principal.java November 2002
*
* Copyright (C) 2002, Niall Gallagher Principal interface is used to describe a
* user that has a name and password. This should not be
* confused with the java.security.Principal
* interface which does not provide getPassword.
*
* @author Niall Gallagher
*/
public interface Principal {
/**
* The getPassword method is used to retrieve
* the password of the principal. This is the password
* tag in the RFC 2616 Authorization credentials expression.
*
* @return this returns the password for this principal
*/
public String getPassword();
/**
* The getName method is used to retreive
* the name of the principal. This is the name tag in
* the RFC 2616 Authorization credentials expression.
*
* @return this returns the name of this principal
*/
public String getName();
}
simple-http-4.1.21/src/org/simpleframework/http/Query.java 0000664 0000000 0000000 00000007332 12536602605 0023573 0 ustar 00root root 0000000 0000000 /*
* Query.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Query object is used to represent HTTP query
* parameters. Parameters are acquired by name and can be either a
* string, float, int, or boolean value. This ensures that data can
* be conveniently extracted in the correct type. This stores the
* parameters in a map of key value pairs. Each parameter can be
* acquired using the name of the parameter, if the parameter is
* named twice then all values can be acquired.
*
* @author Niall Gallagher
*/
public interface Query extends MapList for all of
* the parameter values associated with the specified name. Using
* this method allows the query to expose many values taken from
* the query or HTTP form posting. Typically the first value in
* the list is the value from the get(String) method
* as this is the primary value from the ordered list of values.
*
* @param name this is the name used to search for the value
*
* @return this is the list of values associated with the key
*/
public Listtrue or
* false then those boolean values are returned.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as an float
*/
public boolean getBoolean(Object name);
/**
* This will return all parameters represented using the HTTP
* URL query format. The x-www-form-urlencoded
* format is used to encode the attributes, see RFC 2616.
* Request is used to provide an interface to the
* HTTP entity body and message header. This provides methods that
* allow the entity body to be acquired as a stream, string, or if
* the message is a multipart encoded body, then the individual
* parts of the request body can be acquired.
* Session is made available
* for convenience. It provides a means for the services to associate
* data with a given client session, which can be retrieved when
* there are subsequent requests sent to the server.
* getInputStream will
* start reading from the first byte in the body regardless of the
* number of times it is called. This allows POST parameters as well
* as multipart bodies to be read from the stream if desired.
*
* @author Niall Gallagher
*/
public interface Request extends RequestHeader {
/**
* This is used to determine if the request has been transferred
* over a secure connection. If the protocol is HTTPS and the
* content is delivered over SSL then the request is considered
* to be secure. Also the associated response will be secure.
*
* @return true if the request is transferred securely
*/
public boolean isSecure();
/**
* This is a convenience method that is used to determine whether
* or not this message has the Connection: close
* header. If the close token is present then this stream is not
* a keep-alive connection. If this has no Connection
* header then the keep-alive status is determined by the HTTP
* version, that is, HTTP/1.1 is keep-alive by default, HTTP/1.0
* is not keep-alive by default.
*
* @return returns true if this has a keep-alive stream
*/
public boolean isKeepAlive();
/**
* This is used to acquire all the form parameters from the
* HTTP request. This includes the query and POST data values
* as well as the parts of a multipart request. The form is
* a convenience object enabling easy access to state.
*
* @return this returns the form containing the state
*/
public Form getForm() throws IOException;
/**
* This is used to provide quick access to the parameters. This
* avoids having to acquire the request Form object.
* This basically acquires the parameters object and invokes
* the getParameters method with the given name.
*
* @param name this is the name of the parameter value
*/
public String getParameter(String name) throws IOException;
/**
* This method is used to acquire a Part from the
* form using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) throws IOException;
/**
* This can be used to retrieve the response attributes. These can
* be used to keep state with the response when it is passed to
* other systems for processing. Attributes act as a convenient
* model for storing objects associated with the response. This
* also inherits attributes associated with the client connection.
*
* @return the attributes of that have been set on the request
*/
public Map getAttributes();
/**
* This is used as a shortcut for acquiring attributes for the
* response. This avoids acquiring the attribute Map
* in order to retrieve the attribute directly from that object.
* The attributes contain data specific to the response.
*
* @param key this is the key of the attribute to acquire
*
* @return this returns the attribute for the specified name
*/
public Object getAttribute(Object key);
/**
* This is used to acquire the remote client address. This can
* be used to acquire both the port and the I.P address for the
* client. It allows the connected clients to be logged and if
* require it can be used to perform course grained security.
*
* @return this returns the client address for this request
*/
public InetSocketAddress getClientAddress();
/**
* This is used to get the content body. This will essentially get
* the content from the body and present it as a single string.
* The encoding of the string is determined from the content type
* charset value. If the charset is not supported this will throw
* an exception. Typically only text values should be extracted
* using this method if there is a need to parse that content.
*
* @return this returns the message bytes as an encoded string
*/
public String getContent() throws IOException;
/**
* This is used to read the content body. The specifics of the data
* that is read from this InputStream can be determined
* by the getContentLength method. If the data sent by
* the client is chunked then it is decoded, see RFC 2616 section
* 3.6. Also multipart data is available as Part objects
* however the raw content of the multipart body is still available.
*
* @return this returns an input stream containing the message body
*/
public InputStream getInputStream() throws IOException;
/**
* This is used to read the content body. The specifics of the data
* that is read from this ReadableByteChannel can be
* determined by the getContentLength method. If the
* data sent by the client is chunked then it is decoded, see RFC
* 2616 section 3.6. This stream will never provide empty reads as
* the content is internally buffered, so this can do a full read.
*
* @return this returns the byte channel used to read the content
*/
public ReadableByteChannel getByteChannel() throws IOException;
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @return returns an active session for the associated client
*/
public Session getSession() throws LeaseException;
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session for the associated client
*/
public Session getSession(boolean create) throws LeaseException;
}
simple-http-4.1.21/src/org/simpleframework/http/RequestHeader.java 0000664 0000000 0000000 00000016045 12536602605 0025230 0 ustar 00root root 0000000 0000000 /*
* RequestHeader.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Header object that is used to represent a
* basic form for the HTTP request message. This is used to extract
* values such as the request line and header values from the request
* message. Access to header values is done case insensitively.
* List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public ListCookie object. Otherwise this method will
* return null. Each cookie object will contain the name, value
* and path of the cookie as well as the optional domain part.
*
* @param name this is the name of the cookie object to acquire
*
* @return this returns a cookie object from the header or null
*/
public Cookie getCookie(String name);
/**
* This is used to acquire all cookies that were sent in the header.
* If any cookies exists within the HTTP header they are returned
* as Cookie objects. Otherwise this method will an
* empty list. Each cookie object will contain the name, value and
* path of the cookie as well as the optional domain part.
*
* @return this returns all cookie objects from the HTTP header
*/
public Listsubstring and trim calls.
* Accept-Language header.
* This provides an indication as to the languages that the client
* accepts. It provides the locales in preference order.
*
* @return this returns the locales preferred by the client
*/
public ListContent-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType();
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
public int getContentLength();
}
simple-http-4.1.21/src/org/simpleframework/http/RequestLine.java 0000664 0000000 0000000 00000006575 12536602605 0024736 0 ustar 00root root 0000000 0000000 /*
* RequestLine.java February 2001
*
* Copyright (C) 2001, Niall Gallagher RequestLine is used to represent a HTTP request
* line. The methods provided for this can be used to provide easy
* access to the components of a HTTP request line. For the syntax
* of a HTTP request line see RFC 2616.
*
* @author Niall Gallagher
*/
public interface RequestLine {
/**
* This can be used to get the HTTP method for this request. The
* HTTP specification RFC 2616 specifies the HTTP request methods
* in section 9, Method Definitions. Typically this will be a
* GET, POST or a HEAD method, although any string is possible.
*
* @return the request method for this request message
*/
public String getMethod();
/**
* This can be used to get the URI specified for this HTTP
* request. This corresponds to the /index part of a
* http://www.domain.com/index URL but may contain the full
* URL. This is a read only value for the request.
*
* @return the URI that this HTTP request is targeting
*/
public String getTarget();
/**
* This is used to acquire the address from the request line.
* An address is the full URI including the scheme, domain, port
* and the query parts. This allows various parameters to be
* acquired without having to parse the raw request target URI.
*
* @return this returns the address of the request line
*/
public Address getAddress();
/**
* This is used to acquire the path as extracted from the HTTP
* request URI. The Path object that is provided by
* this method is immutable, it represents the normalized path
* only part from the request uniform resource identifier.
*
* @return this returns the normalized path for the request
*/
public Path getPath();
/**
* This method is used to acquire the query part from the
* HTTP request URI target. This will return only the values
* that have been extracted from the request URI target.
*
* @return the query associated with the HTTP target URI
*/
public Query getQuery();
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @return the major version number for the request message
*/
public int getMajor();
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @return the major version number for the request message
*/
public int getMinor();
}
simple-http-4.1.21/src/org/simpleframework/http/RequestWrapper.java 0000664 0000000 0000000 00000044353 12536602605 0025463 0 ustar 00root root 0000000 0000000 /*
* RequestWrapper.java February 2001
*
* Copyright (C) 2001, Niall Gallagher RequestWrapper object is used so that the original
* Request object can be wrapped in a filtering proxy
* object. This allows a Container that interacts with
* a modified request object. To add functionality to the request it
* can be wrapped in a subclass of this and the overridden methods
* can provide modified functionality to the standard request.
*
* @author Niall Gallagher
*/
public class RequestWrapper implements Request {
/**
* This is the request instance that is being wrapped.
*/
protected Request request;
/**
* Constructor for RequestWrapper object. This allows
* the original Request object to be wrapped so that
* adjustments to the behavior of a request object handed to the
* container can be provided by a subclass implementation.
*
* @param request the request object that is being wrapped
*/
public RequestWrapper(Request request){
this.request = request;
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @return the major version number for the request message
*/
public int getMajor() {
return request.getMajor();
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @return the major version number for the request message
*/
public int getMinor() {
return request.getMinor();
}
/**
* This can be used to get the HTTP method for this request. The
* HTTP specification RFC 2616 specifies the HTTP request methods
* in section 9, Method Definitions. Typically this will be a
* GET, POST or a HEAD method, although any string is possible.
*
* @return the request method for this request message
*/
public String getMethod() {
return request.getMethod();
}
/**
* This can be used to get the URI specified for this HTTP request.
* This corresponds to the either the full HTTP URI or the path
* part of the URI depending on how the client sends the request.
*
* @return the URI address that this HTTP request is targeting
*/
public String getTarget() {
return request.getTarget();
}
/**
* This is used to acquire the address from the request line.
* An address is the full URI including the scheme, domain, port
* and the query parts. This allows various parameters to be
* acquired without having to parse the raw request target URI.
*
* @return this returns the address of the request line
*/
public Address getAddress() {
return request.getAddress();
}
/**
* This is used to acquire the path as extracted from the HTTP
* request URI. The Path object that is provided by
* this method is immutable, it represents the normalized path
* only part from the request uniform resource identifier.
*
* @return this returns the normalized path for the request
*/
public Path getPath() {
return request.getPath();
}
/**
* This method is used to acquire the query part from the
* HTTP request URI target. This will return only the values
* that have been extracted from the request URI target.
*
* @return the query associated with the HTTP target URI
*/
public Query getQuery() {
return request.getQuery();
}
/**
* This method is used to get a List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public ListCookie object. Otherwise this method will
* return null. Each cookie object will contain the name, value
* and path of the cookie as well as the optional domain part.
*
* @param name this is the name of the cookie object to acquire
*
* @return this returns a cookie object from the header or null
*/
public Cookie getCookie(String name) {
return request.getCookie(name);
}
/**
* This is used to acquire all cookies that were sent in the header.
* If any cookies exists within the HTTP header they are returned
* as Cookie objects. Otherwise this method will an
* empty list. Each cookie object will contain the name, value and
* path of the cookie as well as the optional domain part.
*
* @return this returns all cookie objects from the HTTP header
*/
public Listsubstring and trim calls.
* Accept-Language header.
* This provides an indication as to the languages that the client
* accepts. It provides the locales in preference order.
*
* @return this returns the locales preferred by the client
*/
public ListContent-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType() {
return request.getContentType();
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
public int getContentLength() {
return request.getContentLength();
}
/**
* This is used to determine if the request has been transferred
* over a secure connection. If the protocol is HTTPS and the
* content is delivered over SSL then the request is considered
* to be secure. Also the associated response will be secure.
*
* @return true if the request is transferred securely
*/
public boolean isSecure() {
return request.isSecure();
}
/**
* This is a convenience method that is used to determine whether
* or not this message has the Connection: close
* header. If the close token is present then this stream is not
* a keep-alive connection. If this has no Connection
* header then the keep-alive status is determined by the HTTP
* version, that is, HTTP/1.1 is keep-alive by default, HTTP/1.0
* is not keep-alive by default.
*
* @return returns true if this has a keep-alive stream
*/
public boolean isKeepAlive() {
return request.isKeepAlive();
}
/**
* This can be used to retrieve the response attributes. These can
* be used to keep state with the response when it is passed to
* other systems for processing. Attributes act as a convenient
* model for storing objects associated with the response. This
* also inherits attributes associated with the client connection.
*
* @return the attributes that have been set on this response
*/
public Map getAttributes() {
return request.getAttributes();
}
/**
* This is used as a shortcut for acquiring attributes for the
* response. This avoids acquiring the attribute Map
* in order to retrieve the attribute directly from that object.
* The attributes contain data specific to the response.
*
* @param key this is the key of the attribute to acquire
*
* @return this returns the attribute for the specified name
*/
public Object getAttribute(Object key) {
return request.getAttribute(key);
}
/**
* This is used to acquire the remote client address. This can
* be used to acquire both the port and the I.P address for the
* client. It allows the connected clients to be logged and if
* require it can be used to perform course grained security.
*
* @return this returns the client address for this request
*/
public InetSocketAddress getClientAddress() {
return request.getClientAddress();
}
/**
* This is used to get the content body. This will essentially get
* the content from the body and present it as a single string.
* The encoding of the string is determined from the content type
* charset value. If the charset is not supported this will throw
* an exception. Typically only text values should be extracted
* using this method if there is a need to parse that content.
*
* @exception IOException signifies that there is an I/O problem
*
* @return the body content as an encoded string value
*/
public String getContent() throws IOException {
return request.getContent();
}
/**
* This is used to read the content body. The specifics of the data
* that is read from this InputStream can be determined
* by the getContentLength method. If the data sent by
* the client is chunked then it is decoded, see RFC 2616 section
* 3.6. Also multipart data is available as Part objects
* however the raw content of the multipart body is still available.
*
* @exception Exception signifies that there is an I/O problem
*
* @return returns the input stream containing the message body
*/
public InputStream getInputStream() throws IOException {
return request.getInputStream();
}
/**
* This is used to read the content body. The specifics of the data
* that is read from this ReadableByteChannel can be
* determined by the getContentLength method. If the
* data sent by the client is chunked then it is decoded, see RFC
* 2616 section 3.6. This stream will never provide empty reads as
* the content is internally buffered, so this can do a full read.
*
* @return this returns the byte channel used to read the content
*/
public ReadableByteChannel getByteChannel() throws IOException {
return request.getByteChannel();
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @return returns an active session for the associated client
*/
public Session getSession() throws LeaseException {
return request.getSession();
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session for the associated client
*/
public Session getSession(boolean create) throws LeaseException {
return request.getSession(create);
}
/**
* This is used to acquire all the form parameters from the
* HTTP request. This includes the query and POST data values
* as well as the parts of a multipart request. The form is
* a convenience object enabling easy access to state.
*
* @return this returns the form containing the state
*
* @throws IOException thrown if it could not be acquired
*/
public Form getForm() throws IOException {
return request.getForm();
}
/**
* This is used to provide quick access to the parameters. This
* avoids having to acquire the request Form object.
* This basically acquires the parameters object and invokes
* the getParameters method with the given name.
*
* @param name this is the name of the parameter value
*
* @exception IOException thrown if there is an I/O problem
*/
public String getParameter(String name) throws IOException {
return request.getParameter(name);
}
/**
* This method is used to acquire a Part from the
* form using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) throws IOException {
return request.getPart(name);
}
}
simple-http-4.1.21/src/org/simpleframework/http/Response.java 0000664 0000000 0000000 00000024624 12536602605 0024267 0 ustar 00root root 0000000 0000000 /*
* Response.java February 2001
*
* Copyright (C) 2001, Niall Gallagher OutputStream can be acquired via this interface
* which can be used to write the response body. A buffer size can be
* specified when acquiring the output stream which allows data to
* be buffered until it over flows or is flushed explicitly. This
* buffering allows a partially written response body to be reset.
* Response controls
* the processing of the HTTP pipeline. The next HTTP request is
* not processed until the response has been sent. To ensure that
* the response is sent the close method of the response
* or the output stream should be used. This will notify the server
* to dispatch the next request in the pipeline for processing.
*
* @author Niall Gallagher
*/
public interface Response extends ResponseHeader {
/**
* This should be used when the size of the message body is known.
* This ensures that Persistent HTTP (PHTTP) connections can be
* maintained for both HTTP/1.0 and HTTP/1.1 clients. If the length
* of the output is not known HTTP/1.0 clients will require a
* connection close, which reduces performance (see RFC 2616).
* Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
*
* @return an output stream object with the specified semantics
*/
public OutputStream getOutputStream() throws IOException;
/**
* Used to write a message body with the Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @return an output stream object with the specified semantics
*/
public OutputStream getOutputStream(int size) throws IOException;
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a buffer size of zero.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
* Response must guarantee
* that this can be invoked repeatedly without effecting any issued
* OutputStream or PrintStream object.
*
* @return a print stream that provides convenience writing
*/
public PrintStream getPrintStream() throws IOException;
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a specified buffer size.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
* Response must guarantee
* that this can be invoked repeatedly without effecting any issued
* OutputStream or PrintStream object.
*
* @param size the minimum size that the response buffer must be
*
* @return a print stream that provides convenience writing
*/
public PrintStream getPrintStream(int size) throws IOException;
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel() throws IOException;
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @param size the minimum size that the response buffer must be
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel(int size) throws IOException;
/**
* This can be used to determine whether the Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @return true if the response headers have been committed
*/
public boolean isCommitted();
/**
* This is used to write the headers that where given to the
* Response. Any further attempts to give headers
* to the Response will be futile as only the headers
* that were given at the time of the first commit will be used
* in the message header.
* Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @throws IOException thrown if there is a problem resetting
*/
public void reset() throws IOException;
/**
* This is used to close the connection and commit the request.
* This provides the same semantics as closing the output stream
* and ensures that the HTTP response is committed. This will
* throw an exception if the response can not be committed.
*
* @throws IOException thrown if there is a problem writing
*/
public void close() throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/ResponseHeader.java 0000664 0000000 0000000 00000026463 12536602605 0025403 0 ustar 00root root 0000000 0000000 /*
* Response.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ResponseHeader object is used to manipulate the
* header information for a given response. Headers are stored and
* retrieved from this object in a case insensitive manner. This
* implements the StatusLine object, which exposes the
* protocol version and response status code.
* getValue in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, String value);
/**
* This can be used to add a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getInteger in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, int value);
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTPdate string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void addDate(String name, long date);
/**
* This can be used to set a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, String value);
/**
* This can be used to set a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, int value);
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTP date string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void setDate(String name, long date);
/**
* This is used to remove the named header from the response. This
* removes all header values assigned to the specified name. If it
* does not exist then this will return without modifying the HTTP
* response. Headers names removed are case insensitive.
*
* @param name the HTTP message header to remove from the response
*/
public void remove(String name);
/**
* This is used to see if there is a HTTP message header with the
* given name in this container. If there is a HTTP message header
* with the specified name then this returns true otherwise false.
*
* @param name the HTTP message header to get the value from
*
* @return this returns true if the HTTP message header exists
*/
public boolean contains(String name);
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the full string
* representing the named header value. If the named header does
* not exist then this will return a null value.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public String getValue(String name);
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the integer
* representing the named header value. If the named header does
* not exist then this will return a value of minus one, -1.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public int getInteger(String name);
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the long value
* representing the named header value. If the named header does
* not exist then this will return a value of minus one, -1.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public long getDate(String name);
/**
* This can be used to get the values of HTTP message headers
* that have the specified name. This is a convenience method that
* will present that values as tokens extracted from the header.
* This has obvious performance benefits as it avoids having to
* deal with substring and trim calls.
* setCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
*
* @param cookie this is the cookie to be added to the response
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(Cookie cookie);
/**
* The setCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
* This is a convenience method that avoids cookie creation.
*
* @param name this is the cookie to be added to the response
* @param value this is the cookie value that is to be used
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(String name, String value);
/**
* This returns the Cookie object stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If the cookie does
* not exist under the specified name this will return null.
*
* @param name this is the name of the cookie to be retrieved
*
* @return returns the Cookie by the given name
*/
public Cookie getCookie(String name);
/**
* This returns all Cookie objects stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If there are no
* cookies then this will return an empty list.
*
* @return returns all the Cookie in the response
*/
public ListContent-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType();
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Transfer-Encoding header, if there is
* then this will parse that header and return the first token in
* the comma separated list of values, which is the primary value.
*
* @return this returns the transfer encoding value if it exists
*/
public String getTransferEncoding();
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return content length, or -1 if it cannot be determined
*/
public int getContentLength();
}
simple-http-4.1.21/src/org/simpleframework/http/ResponseWrapper.java 0000664 0000000 0000000 00000062535 12536602605 0025633 0 ustar 00root root 0000000 0000000 /*
* ResponseWrapper.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ResponseWrapper object is used so that the original
* Response object can be wrapped in a filtering proxy
* object. This allows a container to interact with an implementation
* of this with overridden methods providing specific functionality.
* the Response object in a concurrent environment.
*
*
* public void handle(Request req, Response resp) {
* handler.handle(req, new ZipResponse(resp));
* }
*
*
* The above is an example of how the ResponseWrapper can
* be used to provide extra functionality to a Response
* in a transparent manner. Such an implementation could apply a
* Content-Encoding header and compress the response for performance
* over a slow network. Filtering can be applied with the use of
* layered Container objects.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Container
*/
public class ResponseWrapper implements Response {
/**
* This is the response instance that is being wrapped.
*/
protected Response response;
/**
* Constructor for ResponseWrapper object. This allows
* the original Response object to be wrapped so that
* adjustments to the behavior of a request object handed to the
* container can be provided by a subclass implementation.
*
* @param response the response object that is being wrapped
*/
public ResponseWrapper(Response response){
this.response = response;
}
/**
* This represents the status code of the HTTP response.
* The response code represents the type of message that is
* being sent to the client. For a description of the codes
* see RFC 2616 section 10, Status Code Definitions.
*
* @return the status code that this HTTP response has
*/
public int getCode() {
return response.getCode();
}
/**
* This method allows the status for the response to be
* changed. This MUST be reflected the the response content
* given to the client. For a description of the codes see
* RFC 2616 section 10, Status Code Definitions.
*
* @param code the new status code for the HTTP response
*/
public void setCode(int code) {
response.setCode(code);
}
/**
* This can be used to retrieve the text of a HTTP status
* line. This is the text description for the status code.
* This should match the status code specified by the RFC.
*
* @return the message description of the response
*/
public String getText() {
return response.getText();
}
/**
* This is used to set the text of the HTTP status line.
* This should match the status code specified by the RFC.
*
* @param text the descriptive text message of the status
*/
public void setText(String text) {
response.setText(text);
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @return the major version number for the request message
*/
public int getMajor() {
return response.getMajor();
}
/**
* This can be used to set the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @param major the major version number for the request message
*/
public void setMajor(int major) {
response.setMajor(major);
}
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @return the minor version number for the request message
*/
public int getMinor() {
return response.getMinor();
}
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @param minor the minor version number for the request message
*/
public void setMinor(int minor) {
response.setMinor(minor);
}
/**
* This is used to acquire the names of the of the headers that
* have been set in the response. This can be used to acquire all
* header values by name that have been set within the response.
* If no headers have been set this will return an empty list.
*
* @return a list of strings representing the set header names
*/
public ListgetValue in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, String value) {
response.add(name, value);
}
/**
* This can be used to add a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getInteger in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, int value) {
response.add(name, value);
}
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTPdate string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void addDate(String name, long date) {
response.addDate(name, date);
}
/**
* This can be used to set a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, String value) {
response.set(name, value);
}
/**
* This can be used to set a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, int value) {
response.set(name, value);
}
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTP date string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void setDate(String name, long date) {
response.setDate(name, date);
}
/**
* This is used to remove the named header from the response. This
* removes all header values assigned to the specified name. If it
* does not exist then this will return without modifying the HTTP
* response. Headers names removed are case insensitive.
*
* @param name the HTTP message header to remove from the response
*/
public void remove(String name) {
response.remove(name);
}
/**
* This is used to see if there is a HTTP message header with the
* given name in this container. If there is a HTTP message header
* with the specified name then this returns true otherwise false.
*
* @param name the HTTP message header to get the value from
*
* @return this returns true if the HTTP message header exists
*/
public boolean contains(String name) {
return response.contains(name);
}
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the full string
* representing the named header value. If the named header does
* not exist then this will return a null value.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public String getValue(String name) {
return response.getValue(name);
}
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the integer
* representing the named header value. If the named header does
* not exist then this will return a value of minus one, -1.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public int getInteger(String name) {
return response.getInteger(name);
}
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the long value
* representing the named header value. If the named header does
* not exist then this will return a value of minus one, -1.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public long getDate(String name) {
return response.getDate(name);
}
/**
* This can be used to get the values of HTTP message headers
* that have the specified name. This is a convenience method that
* will present that values as tokens extracted from the header.
* This has obvious performance benefits as it avoids having to
* deal with substring and trim calls.
* setCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
*
* @param cookie this is the cookie to be added to the response
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(Cookie cookie) {
return response.setCookie(cookie);
}
/**
* The setCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
* This is a convenience method that avoids cookie creation.
*
* @param name this is the cookie to be added to the response
* @param value this is the cookie value that is to be used
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(String name, String value) {
return response.setCookie(name, value);
}
/**
* This returns the Cookie object stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If the cookie does
* not exist under the specified name this will return null.
*
* @param name this is the name of the cookie to be retrieved
*
* @return returns the cookie object send with the request
*/
public Cookie getCookie(String name) {
return response.getCookie(name);
}
/**
* This returns all Cookie objects stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If there are no
* cookies then this will return an empty list.
*
* @return returns all the cookie objects for this response
*/
public ListContent-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType() {
return response.getContentType();
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Transfer-Encoding header, if there is
* then this will parse that header and return the first token in
* the comma separated list of values, which is the primary value.
*
* @return this returns the transfer encoding value if it exists
*/
public String getTransferEncoding() {
return response.getTransferEncoding();
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return content length, or -1 if it cannot be determined
*/
public int getContentLength() {
return response.getContentLength();
}
/**
* This should be used when the size of the message body is known. For
* performance reasons this should be used so the length of the output
* is known. This ensures that Persistent HTTP (PHTTP) connections
* can be maintained for both HTTP/1.0 and HTTP/1.1 clients. If the
* length of the output is not known HTTP/1.0 clients will require a
* connection close, which reduces performance (see RFC 2616).
* OutputStream.close is used.
*
* @param length this is the length of the HTTP message body
*/
public void setContentLength(int length) {
response.setContentLength(length);
}
/**
* Used to write a message body with the Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* The OutputStream issued must be thread safe so that
* it can be used in a concurrent environment.
*
* @exception IOException this is thrown if there was an I/O error
*
* @return an output stream used to write the response body
*/
public OutputStream getOutputStream() throws IOException {
return response.getOutputStream();
}
/**
* Used to write a message body with the Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* The OutputStream issued must be thread safe so that
* it can be used in a concurrent environment.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @param size the minimum size that the response buffer must be
*
* @return an output stream used to write the response body
*
* @exception IOException this is thrown if there was an I/O error
*/
public OutputStream getOutputStream(int size) throws IOException {
return response.getOutputStream(size);
}
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a buffer size of zero.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
* Response must guarantee
* that this can be invoked repeatedly without effecting any issued
* OutputStream or PrintStream object.
*
* @return a print stream used for writing the response body
*
* @exception IOException this is thrown if there was an I/O error
*/
public PrintStream getPrintStream() throws IOException {
return response.getPrintStream();
}
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a specified buffer size.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
* Response must guarantee
* that this can be invoked repeatedly without effecting any issued
* OutputStream or PrintStream object.
*
* @param size the minimum size that the response buffer must be
*
* @return a print stream used for writing the response body
*
* @exception IOException this is thrown if there was an I/O error
*/
public PrintStream getPrintStream(int size) throws IOException {
return response.getPrintStream(size);
}
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel() throws IOException {
return response.getByteChannel();
}
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @param size the minimum size that the response buffer must be
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel(int size) throws IOException {
return response.getByteChannel(size);
}
/**
* This can be used to determine whether the Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @return true if the response has been fully committed
*/
public boolean isCommitted() {
return response.isCommitted();
}
/**
* This is used to write the headers that where given to the
* Response. Any further attempts to give headers
* to the Response will be futile as only the headers
* that were given at the time of the first commit will be used
* in the message header.
* Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @throws IOException thrown if there is a problem resetting
*/
public void reset() throws IOException {
response.reset();
}
/**
* This is used to close the connection and commit the request.
* This provides the same semantics as closing the output stream
* and ensures that the HTTP response is committed. This will
* throw an exception if the response can not be committed.
*
* @throws IOException thrown if there is a problem writing
*/
public void close() throws IOException {
response.close();
}
}
simple-http-4.1.21/src/org/simpleframework/http/Status.java 0000664 0000000 0000000 00000020454 12536602605 0023751 0 ustar 00root root 0000000 0000000 /*
* Status.java February 2008
*
* Copyright (C) 2008, Niall Gallagher Status enumeration is used to specify status codes
* and the descriptions of those status codes. This is a convenience
* enumeration that allows users to acquire the descriptions of codes
* by simply providing the code. Also if the response state is known
* the code and description can be provided to the client.
* Status object. This will create
* a status object that is used to represent a response state. It
* contains a status code and a description of that code.
*
* @param code this is the code that is used for this status
* @param description this is the description used for the status
*/
private Status(int code, String description) {
this.description = description;
this.code = code;
}
/**
* This is used to acquire the code of the status object. This is
* used in the HTTP response message to tell the client what kind
* of response this represents. Typically this is used to get a
* code for a known response state for convenience.
*
* @return the code associated by this status instance
*/
public int getCode() {
return code;
}
/**
* This is used to provide the status description. The description
* is the textual description of the response state. It is used
* so that the response can be interpreted and is a required part
* of the HTTP response combined with the status code.
*
* @return the description associated by this status instance
*/
public String getDescription() {
return description;
}
/**
* This is used to provide the status description. The description
* is the textual description of the response state. It is used
* so that the response can be interpreted and is a required part
* of the HTTP response combined with the status code.
*
* @param code this is the code to resolve the description for
*
* @return the description associated by this status instance
*/
public static String getDescription(int code) {
Status[] list = values();
for(Status status : list) {
if(status.code == code)
return status.description;
}
return "Unknown";
}
}
simple-http-4.1.21/src/org/simpleframework/http/StatusLine.java 0000664 0000000 0000000 00000006351 12536602605 0024561 0 ustar 00root root 0000000 0000000 /*
* StatusLine.java February 2001
*
* Copyright (C) 2001, Niall Gallagher StatusLine is used to represent a HTTP status
* line. This provides several convenience methods that can be used
* to manipulate a HTTP status line. see the RFC (RFC 2616) for the
* syntax of a status line.
*
* @author Niall Gallagher
*/
public interface StatusLine {
/**
* This represents the status code of the HTTP response.
* The response code represents the type of message that is
* being sent to the client. For a description of the codes
* see RFC 2616 section 10, Status Code Definitions.
*
* @return the status code that this HTTP response has
*/
public int getCode();
/**
* This method allows the status for the response to be
* changed. This MUST be reflected the the response content
* given to the client. For a description of the codes see
* RFC 2616 section 10, Status Code Definitions.
*
* @param code the new status code for the HTTP response
*/
public void setCode(int code);
/**
* This can be used to retrieve the text of a HTTP status
* line. This is the text description for the status code.
* This should match the status code specified by the RFC.
*
* @return the message description of the response
*/
public String getText();
/**
* This is used to set the text of the HTTP status line.
* This should match the status code specified by the RFC.
*
* @param text the descriptive text message of the status
*/
public void setText(String text);
/**
* This can be used to get the major number from a HTTP
* version. The major version corresponds to the major
* type that is the 1 of a HTTP/1.0 version string.
*
* @return the major version number for the response
*/
public int getMajor();
/**
* This can be used to specify the major version. This
* should be the major version of the HTTP request.
*
* @param major this is the major number desired
*/
public void setMajor(int major);
/**
* This can be used to get the minor number from a HTTP
* version. The major version corresponds to the minor
* type that is the 0 of a HTTP/1.0 version string.
*
* @return the major version number for the response
*/
public int getMinor();
/**
* This can be used to specify the minor version. This
* should not be set to zero if the HTTP request was
* for HTTP/1.1. The response must be equal or higher.
*
* @param minor this is the minor number desired
*/
public void setMinor(int minor);
}
simple-http-4.1.21/src/org/simpleframework/http/core/ 0000775 0000000 0000000 00000000000 12536602605 0022546 5 ustar 00root root 0000000 0000000 simple-http-4.1.21/src/org/simpleframework/http/core/Accumulator.java 0000664 0000000 0000000 00000025551 12536602605 0025700 0 ustar 00root root 0000000 0000000 /*
* Accumulator.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Accumulator object is an output stream that can
* buffer bytes written up to a given size. This is used if a buffer
* is requested for the response output. Such a mechanism allows the
* response to be written without committing the response. Also it
* enables content that has been written to be reset, by simply
* clearing the accumulator buffer. Once the accumulator buffer has
* overflown then the response is committed.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Transfer
*/
class Accumulator extends OutputStream implements WritableByteChannel {
/**
* This is the transfer object used to transfer the response.
*/
private Transfer transfer;
/**
* This is the buffer used to accumulate the response bytes.
*/
private byte[] buffer;
/**
* This is used to determine if the accumulate was flushed.
*/
private boolean flushed;
/**
* This is used to determine if the accumulator was closed.
*/
private boolean closed;
/**
* This counts the number of bytes that have been accumulated.
*/
private int count;
/**
* Constructor for the Accumulator object. This will
* create a buffering output stream which will flush data to the
* underlying transport provided with the entity. All I/O events
* are reported to the monitor so the server can process other
* requests within the pipeline when the current one is finished.
*
* @param support this is used to determine the response semantics
* @param entity this is used to acquire the underlying transport
* @param monitor this is used to report I/O events to the kernel
*/
public Accumulator(Conversation support, Entity entity, Monitor monitor) {
this(support, entity.getChannel(), monitor);
}
/**
* Constructor for the Accumulator object. This will
* create a buffering output stream which will flush data to the
* underlying transport provided with the channel. All I/O events
* are reported to the monitor so the server can process other
* requests within the pipeline when the current one is finished.
*
* @param support this is used to determine the response semantics
* @param channel this is the channel used to write the data to
* @param monitor this is used to report I/O events to the kernel
*/
public Accumulator(Conversation support, Channel channel, Monitor monitor) {
this(support, channel.getSender(), monitor);
}
/**
* Constructor for the Accumulator object. This will
* create a buffering output stream which will flush data to the
* underlying transport using the sender provided. All I/O events
* are reported to the monitor so the server can process other
* requests within the pipeline when the current one is finished.
*
* @param support this is used to determine the response semantics
* @param sender this is used to write to the underlying transport
* @param monitor this is used to report I/O events to the kernel
*/
public Accumulator(Conversation support, Sender sender, Monitor monitor) {
this.transfer = new Transfer(support, sender, monitor);
this.buffer = new byte[] {};
}
/**
* This is used to determine if the accumulator is still open. If
* the accumulator is still open then data can still be written to
* it and this transmitted to the client. When the accumulator is
* closed the data is committed and this can not be used.
*
* @return this returns true if the accumulator object is open
*/
public boolean isOpen() {
return !closed;
}
/**
* This is used to reset the buffer so that it can be written to
* again. If the accumulator has already been flushed then the
* stream can not be reset. Resetting the stream is typically
* done if there is an error in writing the response and an error
* message is generated to replaced the partial response.
*/
public void reset() throws IOException {
if(flushed) {
throw new IOException("Response has been flushed");
}
count = 0;
}
/**
* This is used to write the provided octet to the buffer. If the
* buffer is full it will be flushed and the octet is appended to
* the start of the buffer. If however the buffer is zero length
* then this will write directly to the underlying transport.
*
* @param octet this is the octet that is to be written
*/
public void write(int octet) throws IOException {
byte value = (byte) octet;
if(closed) {
throw new IOException("Response has been transferred");
}
write(new byte[] { value });
}
/**
* This is used to write the provided array to the buffer. If the
* buffer is full it will be flushed and the array is appended to
* the start of the buffer. If however the buffer is zero length
* then this will write directly to the underlying transport.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param size this is the number of bytes that are to be sent
*/
public void write(byte[] array, int off, int size) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(array, off, size);
if(size > 0) {
write(buffer);
}
}
/**
* This is used to write the provided buffer to the buffer. If the
* buffer is full it will be flushed and the buffer is appended to
* the start of the buffer. If however the buffer is zero length
* then this will write directly to the underlying transport.
*
* @param source this is the byte buffer to send to the client
*
* @return this returns the number of bytes that have been sent
*/
public int write(ByteBuffer source) throws IOException {
int mark = source.position();
int size = source.limit();
if(mark > size) {
throw new TransferException("Buffer position greater than limit");
}
return write(source, 0, size - mark);
}
/**
* This is used to write the provided buffer to the buffer. If the
* buffer is full it will be flushed and the buffer is appended to
* the start of the buffer. If however the buffer is zero length
* then this will write directly to the underlying transport.
*
* @param source this is the byte buffer to send to the client
* @param off this is the offset within the array to send from
* @param size this is the number of bytes that are to be sent
*
* @return this returns the number of bytes that have been sent
*/
public int write(ByteBuffer source, int off, int size) throws IOException {
if(closed) {
throw new IOException("Response has been transferred");
}
int mark = source.position();
int limit = source.limit();
if(limit - mark < size) { // not enough data
size = limit - mark; // reduce expectation
}
if(count + size > buffer.length) {
flush(false);
}
if(size > buffer.length){
transfer.write(source);
} else {
source.get(buffer, count, size);
count += size;
}
return size;
}
/**
* This is used to expand the capacity of the internal buffer. If
* there is already content that has been appended to the buffer
* this will copy that data to the newly created buffer. This
* will not decrease the size of the buffer if it is larger than
* the requested capacity.
*
* @param capacity this is the capacity to expand the buffer to
*/
public void expand(int capacity) throws IOException {
if(buffer.length < capacity) {
int size = buffer.length * 2;
int resize = Math.max(capacity, size);
byte[] temp = new byte[resize];
System.arraycopy(buffer, 0, temp, 0, count);
buffer = temp;
}
}
/**
* This is used to flush the contents of the buffer to the
* underlying transport. Once the accumulator is flushed the HTTP
* headers are written such that the semantics of the connection
* match the protocol version and the existing response headers.
*/
public void flush() throws IOException {
flush(true);
}
/**
* This is used to flush the contents of the buffer to the
* underlying transport. Once the accumulator is flushed the HTTP
* headers are written such that the semantics of the connection
* match the protocol version and the existing response headers.
*
* @param flush indicates whether the transport should be flushed
*/
private void flush(boolean flush) throws IOException {
if(!flushed) {
transfer.start();
}
if(count > 0) {
transfer.write(buffer, 0, count);
}
if(flush) {
transfer.flush();
}
flushed = true;
count = 0;
}
/**
* This will flush the buffer to the underlying transport and
* close the stream. Once the accumulator is flushed the HTTP
* headers are written such that the semantics of the connection
* match the protocol version and the existing response headers.
* Closing this stream does not mean the connection is closed.
*/
public void close() throws IOException {
if(!closed) {
commit();
}
flushed = true;
closed = true;
}
/**
* This will close the underlying transfer object which will
* notify the server kernel that the next request is read to be
* processed. If the accumulator is unflushed then this will set
* a Content-Length header such that it matches the number of
* bytes that are buffered within the internal buffer.
*/
private void commit() throws IOException {
if(!flushed) {
transfer.start(count);
}
if(count > 0) {
transfer.write(buffer, 0, count);
}
transfer.close();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ArrayConsumer.java 0000664 0000000 0000000 00000014220 12536602605 0026202 0 ustar 00root root 0000000 0000000 /*
* ArrayConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher ArrayConsumer object is a consumer that consumes
* bytes in to an internal array before processing. This consumes
* all bytes read in to an internal array. Each read is met with an
* invocation of the scan method, which searches for
* the terminal token within the read chunk. Once the terminal token
* has been read the excess bytes are reset and the data can be
* processed by the subclass implementation. The internal array is
* expanded if the number of consumed bytes exceeds its capacity.
*
* @author Niall Gallagher
*/
abstract class ArrayConsumer extends BufferConsumer {
/**
* This is the array that is used to contain the read bytes.
*/
protected byte[] array;
/**
* This is the number of bytes that have been consumed so far.
*/
protected int count;
/**
* This is the size of the chunk of bytes to read each time.
*/
protected int chunk;
/**
* This determines whether the terminal token has been read.
*/
protected boolean done;
/**
* Constructor for the ArrayConsumer object. This is
* used to create a consumer that will consume all bytes in to an
* internal array until a terminal token has been read. If excess
* bytes are read by this consumer they are reset in the cursor.
*/
public ArrayConsumer() {
this(1024);
}
/**
* Constructor for the ArrayConsumer object. This is
* used to create a consumer that will consume all bytes in to an
* internal array until a terminal token has been read. If excess
* bytes are read by this consumer they are reset in the cursor.
*
* @param size this is the initial array and chunk size to use
*/
public ArrayConsumer(int size) {
this(size, 512);
}
/**
* Constructor for the ArrayConsumer object. This is
* used to create a consumer that will consume all bytes in to an
* internal array until a terminal token has been read. If excess
* bytes are read by this consumer they are reset in the cursor.
*
* @param size this is the initial array size that is to be used
* @param chunk this is the chunk size to read bytes as
*/
public ArrayConsumer(int size, int chunk) {
this.array = new byte[size];
this.chunk = chunk;
}
/**
* This method is used to consume bytes from the provided cursor.
* Each read performed is done in a specific chunk size to ensure
* that a sufficiently large or small amount of data is read from
* the Cursor object. After each read the byte array
* is scanned for the terminal token. When the terminal token is
* found the bytes are processed by the implementation.
*
* @param cursor this is the cursor to consume the bytes from
*/
public void consume(Cursor cursor) throws IOException {
if(!done) {
int ready = cursor.ready();
while(ready > 0) {
int size = Math.min(ready, chunk);
if(count + size > array.length) {
resize(count + size);
}
size = cursor.read(array, count, size);
count += size;
if(size > 0) {
int reset = scan();
if(reset > 0) {
cursor.reset(reset);
}
if(done) {
process();
break;
}
}
ready = cursor.ready();
}
}
}
/**
* This method is used to add an additional chunk size to the
* internal array. Resizing of the internal array is required as
* the consumed bytes may exceed the initial size of the array.
* In such a scenario the array is expanded the chunk size.
*
* @param size this is the minimum size to expand the array to
*/
private void resize(int size) {
if(array.length < size) {
int expand = array.length + chunk;
int max = Math.max(expand, size);
byte[] temp = new byte[max];
System.arraycopy(array, 0, temp, 0, count);
array = temp;
}
}
/**
* When the terminal token is read from the cursor this will be
* true. The scan method is used to determine the
* terminal token. It is invoked after each read, when the scan
* method returns a non-zero value then excess bytes are reset
* and the consumer has finished.
*
* @return this returns true when the terminal token is read
*/
public boolean isFinished() {
return done;
}
/**
* This method is invoked after the terminal token has been read.
* It is used to process the consumed data and is typically used to
* parse the input such that it can be used by the subclass for
* some useful purpose. This is called only once by the consumer.
*/
protected abstract void process() throws IOException;
/**
* This method is used to scan for the terminal token. It searches
* for the token and returns the number of bytes in the buffer
* after the terminal token. Returning the excess bytes allows the
* consumer to reset the bytes within the consumer object.
*
* @return this returns the number of excess bytes consumed
*/
protected abstract int scan() throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/Body.java 0000664 0000000 0000000 00000006777 12536602605 0024327 0 ustar 00root root 0000000 0000000 /*
* Body.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Body interface is used to represent the body of
* a HTTP entity. It contains the information that is delivered with
* the request. Typically this will be a form POST or an XML message
* from a SOAP request. However, it can be any stream of bytes. In
* order to access the entity body this interface provides a stream
* which can be used to read it. Also, should the message be encoded
* as a multipart message the individual parts can be read using the
* Part instance for it.
*
* @author Niall Gallagher
*/
interface Body {
/**
* This will acquire the contents of the body in UTF-8. If there
* is no content encoding and the user of the request wants to
* deal with the body as a string then this method can be used.
* It will simply create a UTF-8 string using the body bytes.
*
* @return returns a UTF-8 string representation of the body
*/
public String getContent() throws IOException;
/**
* This will acquire the contents of the body in the specified
* charset. Typically this will be given the charset as taken
* from the HTTP Content-Type header. Although any encoding can
* be specified to convert the body to a string representation.
*
* @return returns an encoded string representation of the body
*/
public String getContent(String charset) throws IOException;
/**
* This is used to acquire the contents of the body as a stream.
* Each time this method is invoked a new stream is created that
* will read the contents of the body from the first byte. This
* ensures that the stream can be acquired several times without
* any issues arising from previous reads.
*
* @return this returns a new string used to read the body
*/
public InputStream getInputStream() throws IOException;
/**
* This method is used to acquire a Part from the
* body using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name);
/**
* This method provides all parts for this body. The parts for a
* body can contain text parameters or files. Each file part can
* contain headers, which are the typical HTTP headers. Typically
* headers describe the content and any encoding if required.
*
* @return this returns a list of parts for this body
*/
public PartList getParts();
}
simple-http-4.1.21/src/org/simpleframework/http/core/BodyConsumer.java 0000664 0000000 0000000 00000007644 12536602605 0026035 0 ustar 00root root 0000000 0000000 /*
* BodyConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher BodyConsumer is used to consume the body of an
* HTTP message. Implementations of this consumer must provide the
* size of the content read and an InputStream to read
* that content. Providing these features in a consumer allows the
* server to treat the body as a simple stream source.
*
* @author Niall Gallagher
*/
abstract class BodyConsumer extends BufferConsumer implements Body {
/**
* Constructor for the BodyConsumer object. This
* will create a consumer that provides default implementations
* for the Body methods. This is a convenience
* implementation that can be extended body consumers.
*/
protected BodyConsumer() {
super();
}
/**
* This will acquire the contents of the body in UTF-8. If there
* is no content encoding and the user of the request wants to
* deal with the body as a string then this method can be used.
* It will simply create a UTF-8 string using the body bytes.
*
* @return returns a UTF-8 string representation of the body
*/
public String getContent() throws IOException {
return new String();
}
/**
* This will acquire the contents of the body in the specified
* charset. Typically this will be given the charset as taken
* from the HTTP Content-Type header. Although any encoding can
* be specified to convert the body to a string representation.
*
* @param charset this is the charset encoding to be used
*
* @return returns an encoded string representation of the body
*/
public String getContent(String charset) throws IOException {
return new String();
}
/**
* This is used to acquire the contents of the body as a stream.
* Each time this method is invoked a new stream is created that
* will read the contents of the body from the first byte. This
* ensures that the stream can be acquired several times without
* any issues arising from previous reads.
*
* @return this returns a new string used to read the body
*/
public InputStream getInputStream() throws IOException {
return new EmptyInputStream();
}
/**
* This method is used to acquire a Part from the
* body using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) {
return null;
}
/**
* This method provides all parts for this body. The parts for a
* body can contain text parameters or files. Each file part can
* contain headers, which are the typical HTTP headers. Typically
* headers describe the content and any encoding if required.
*
* @return this returns a list of parts for this body
*/
public PartList getParts() {
return new PartList();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/BoundaryConsumer.java 0000664 0000000 0000000 00000014634 12536602605 0026720 0 ustar 00root root 0000000 0000000 /*
* BoundaryConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher BoundaryConsumer is used to consume a boundary
* for a multipart message. This ensures that the boundary complies
* with the multipart specification in that it ends with a carriage
* return and line feed. This consumer implementation can be used
* multiple times as its internal buffer can be cleared and reset.
*
* @author Niall Gallagher
*/
class BoundaryConsumer extends ArrayConsumer {
/**
* This is the terminal token for a multipart boundary entity.
*/
private static final byte[] LAST = { '-', '-', '\r', '\n', };
/**
* This is the terminal token for a multipart boundary line.
*/
private static final byte[] LINE = { '\r', '\n' };
/**
* This represents the start of the boundary line for the part.
*/
private static final byte[] TOKEN = { '-', '-' };
/**
* This is used to allocate a buffer for for the boundary.
*/
private Allocator allocator;
/**
* This is used to consume the contents of the consumed buffer.
*/
private Buffer buffer;
/**
* This is the actual boundary value that is to be consumed.
*/
private byte[] boundary;
/**
* This counts the number of characters read from the start.
*/
private int seek;
/**
* Constructor for the BoundaryConsumer object. This
* is used to create a boundary consumer for validating boundaries
* and consuming them from a provided source. This is used to help
* in reading multipart messages by removing boundaries from the
* stream.
*
* @param boundary this is the boundary value to be consumed
*/
public BoundaryConsumer(Allocator allocator, byte[] boundary) {
this.chunk = boundary.length + 6;
this.allocator = allocator;
this.boundary = boundary;
}
/**
* This method is used to allocate the internal buffer. If there
* has already been a call to this method the previous instance
* is returned. If there is any issue allocating the buffer then
* this will throw an exception.
*
* @return this returns the buffer to append the bytes to
*/
@Override
protected Buffer allocate() throws IOException {
if(buffer == null) {
buffer = allocator.allocate(chunk);
}
return buffer;
}
/**
* This does not perform any processing after the boundary has
* been consumed. Because the boundary consumer is used only as a
* means to remove the boundary from the underlying stream there
* is no need to perform any processing of the value consumed.
*/
@Override
protected void process() throws IOException {
append(TOKEN);
append(boundary);
if(seek == chunk) {
append(TOKEN);
}
append(LINE);
}
/**
* This method is used to scan for the terminal token. It searches
* for the token and returns the number of bytes in the buffer
* after the terminal token. Returning the excess bytes allows the
* consumer to reset the bytes within the consumer object.
*
* @return this returns the number of excess bytes consumed
*/
@Override
protected int scan() throws IOException {
int size = boundary.length;
if(count >= size + 4) {
if(array[size + 2] == LAST[0]) {
return boundary(LAST);
}
return boundary(LINE);
}
return 0;
}
/**
* This is used to scan the boundary with an optional terminal. If
* the terminal token is scanned correctly then this will return
* the number of bytes of overflow that has been consumed.
*
* @param terminal this is the terminal token for the boundary
*
* @return this returns the number of bytes of overflow consumed
*/
private int boundary(byte[] terminal) throws IOException {
int size = boundary.length + 2;
if(count >= size + terminal.length) {
scan(TOKEN);
scan(boundary);
scan(terminal);
done = true;
return count - seek;
}
return 0;
}
/**
* This is used to scan the specified token from the consumed bytes.
* If the data scanned does not match the token provided then this
* will throw an exception to signify a bad boundary. This will
* return true only when the whole boundary has been consumed.
*
* @param data this is the token to scan from the consumed bytes
*
* @return this returns true of the token has been read
*/
private boolean scan(byte[] data) throws IOException {
int size = data.length;
int pos = 0;
while(seek < count) {
if(array[seek++] != data[pos++]) {
throw new IOException("Invalid boundary");
}
if(pos == data.length) {
return true;
}
}
return pos == size;
}
/**
* This is used to determine whether the boundary has been read
* from the underlying stream. This is true only when the very
* last boundary has been read. This will be the boundary value
* that ends with the two - characters.
*
* @return this returns true with the terminal boundary is read
*/
public boolean isEnd() {
return seek == chunk;
}
/**
* This is used to clear the state of the of boundary consumer
* such that it can be reused. This is required as the multipart
* body may contain many parts, all delimited with the same
* boundary. Clearing allows the next boundary to be consumed.
*/
public void clear() {
done = false;
count = seek = 0;
}
} simple-http-4.1.21/src/org/simpleframework/http/core/BufferConsumer.java 0000664 0000000 0000000 00000006426 12536602605 0026346 0 ustar 00root root 0000000 0000000 /*
* BufferConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher BufferConsumer is used to create a consumer that
* is used to consume data and append that data to a buffer. This is
* done so that the buffer can act as a data source for the content
* that has been consumed. For example, take the message body, this
* can be consumed in such a way that the internal buffer can be
* used acquire an InputStream to read the contents.
* Buffering in such a way provides an efficient means to store the
* contents of the message as only one read only copy is created.
*
* @author Niall Gallagher
*/
abstract class BufferConsumer implements Consumer {
/**
* Constructor for the BufferConsumer object. This
* will create a consumer that provides methods that can be
* used to buffer content consumed from the provided cursor.
* Such consumers can accumulate the transport data.
*/
protected BufferConsumer() {
super();
}
/**
* This method is used to append the contents of the array to the
* internal buffer. The appended bytes can be acquired from the
* internal buffer using an InputStream, or the text
* of the appended bytes can be acquired by encoding the bytes.
*
* @param array this is the array of bytes to be appended
*/
protected void append(byte[] array) throws IOException {
append(array, 0, array.length);
}
/**
* This method is used to append the contents of the array to the
* internal buffer. The appended bytes can be acquired from the
* internal buffer using an InputStream, or the text
* of the appended bytes can be acquired by encoding the bytes.
*
* @param array this is the array of bytes to be appended
* @param off this is the start offset in the array to read from
* @param len this is the number of bytes to write to the buffer
*/
protected void append(byte[] array, int off, int len) throws IOException {
Buffer buffer = allocate();
if(buffer != null) {
buffer.append(array, off, len);
}
}
/**
* This method is used to allocate the internal buffer. If there
* has already been a call to this method the previous instance
* is returned. If there is any issue allocating the buffer then
* this will throw an exception.
*
* @return this returns the buffer to append the bytes to
*/
protected Buffer allocate() throws IOException {
return new ArrayBuffer();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Builder.java 0000664 0000000 0000000 00000003515 12536602605 0025003 0 ustar 00root root 0000000 0000000 /*
* Builder.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Builder object is used to build and entity from
* its constituent parts. Each component of the entity is provided
* to the builder once they have been extracted from the connected
* pipeline. Once all parts have been acquired by the builder the
* entity is ready to used to process the request.
*
* @author Niall Gallagher
*/
interface Builder extends Entity {
/**
* Provides the Body object for the builder. This
* is used by the entity to read the content of the HTTP request.
* Also, if the entity body is a multipart upload then each of
* the individual parts of the body is available to read from.
*
* @param body this is the entity body provided by the request
*/
public void setBody(Body body);
/**
* Provides the Header object for the builder. This
* is used by the entity to determine the request URI and method
* type. The header also provides start in the form of cookies
* which can be used to track the client.
*
* @param header this is the header provided by the request
*/
public void setHeader(Header header);
}
simple-http-4.1.21/src/org/simpleframework/http/core/BuilderConsumer.java 0000664 0000000 0000000 00000010160 12536602605 0026511 0 ustar 00root root 0000000 0000000 /*
* BuilderConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher BuilderConsumer object is used to consume data
* from a cursor and build a request entity. Each constituent part of
* the entity is consumed from the pipeline, and passed to a builder
* which will use the parts to create an entry. Once all parts have
* been consumed and given to the builder then this is finished.
*
* @author Niall Gallagher
*/
class BuilderConsumer implements Consumer {
/**
* This is used to create a body consumer for the entity.
*/
protected ConsumerFactory factory;
/**
* This is used to consume the header for the request entity.
*/
protected RequestConsumer header;
/**
* This is used to consume the body for the request entity.
*/
protected BodyConsumer body;
/**
* This is used to determine if there a continue is expected.
*/
protected Expectation expect;
/**
* This is used to build the entity from the part and header.
*/
protected Builder builder;
/**
* Constructor for the BuilderConsumer object. This
* is used to build an entity from the constituent parts. Once
* all of the parts have been consumed they are passed to the
* builder and the consumer is considered finished.
*
* @param allocator this is used to allocate the memory used
* @param builder this is used to build the request entity
* @param channel this is the channel used to send a response
*/
public BuilderConsumer(Allocator allocator, Builder builder, Channel channel) {
this.header = new RequestConsumer();
this.expect = new Expectation(channel);
this.factory = new ConsumerFactory(allocator, header);
this.builder = builder;
}
/**
* This consumes the header and body from the cursor. The header
* is consumed first followed by the body if there is any. There
* is a body of there is a Content-Length or a Transfer-Encoding
* header present. If there is no body then a substitute body
* is given which has an empty input stream.
*
* @param cursor used to consumed the bytes for the entity
*/
public void consume(Cursor cursor) throws IOException {
while(cursor.isReady()) {
if(header.isFinished()) {
if(body == null) {
body = factory.getInstance();
}
body.consume(cursor);
if(body.isFinished()) {
break;
}
} else {
header.consume(cursor);
}
}
if(header.isFinished()) {
if(body == null) {
expect.execute(header);
body = factory.getInstance();
}
builder.setBody(body);
builder.setHeader(header);
}
}
/**
* This is determined finished when the body has been consumed.
* If only the header has been consumed then the body will be
* created using the header information, the body is then read
* from the cursor, which may read nothing for an empty body.
*
* @return this returns true if the entity has been built
*/
public boolean isFinished() {
if(header.isFinished()) {
if(body == null) {
body = factory.getInstance();
}
return body.isFinished();
}
return false;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Channel.java 0000664 0000000 0000000 00000010135 12536602605 0024761 0 ustar 00root root 0000000 0000000 /*
* Channel.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Channel interface represents a connected channel
* through which data can be sent and received. Typically a channel
* will have a connected TCP socket, which can be used to determine
* when the channel is read ready, and write ready. A channel can
* also contain a bag of attributes used to describe the connection.
* Cursor object which is
* used to read data from the channel in a non-blocking manner. This
* can also be used to reset data if it has read too much. To write
* the Sender can be used, this provides a blocking
* interface much like a conventional output stream.
*
* @author Niall Gallagher
*/
interface Channel {
/**
* This is used to determine if the channel is secure and that
* data read from and data written to the request is encrypted.
* Channels transferred over SSL are considered secure and will
* have this return true, otherwise it will return false.
*
* @return true if this is secure for reading and writing
*/
public boolean isSecure();
/**
* This is the connected socket channel associated with this. In
* order to determine if content can be read or written to or
* from the channel this socket can be used with a selector. This
* provides a means to react to I/O events as they occur rather
* than polling the channel which is generally less performant.
*
* @return this returns the connected socket channel
*/
public SocketChannel getSocket();
/**
* This provides the Cursor for this channel. The
* cursor provides a resettable view of the input buffer and will
* allow the server kernel to peek into the input buffer without
* having to take the data from the input. This allows overflow
* to be pushed back on to the cursor for subsequent reads.
*
* @return this returns the input cursor for the channel
*/
public Cursor getCursor();
/**
* This provides the Sender for the channel. This is
* used to provide a blocking output mechanism for the channel.
* Enabling blocking reads ensures that output buffering can be
* limited to an extent, which ensures that memory remains low at
* high load periods. Writes to the sender may result in the data
* being copied and queued until the socket is write ready.
*
* @return this returns the output sender for this channel
*/
public Sender getSender();
/**
* This returns the Map of attributes used to hold
* connection information for the channel. The attributes here
* are taken from the pipeline attributes and may contain details
* such as SSL certificates or other such useful information.
*
* @return returns the attributes associated with the channel
*/
public Map getAttributes();
/**
* Because the channel represents a duplex means of communication
* there needs to be a means to close it down. This provides such
* a means. By closing the channel the cursor and sender will no
* longer send or recieve data to or from the network. The client
* will also be signaled that the connection has been severed.
*/
public void close();
} simple-http-4.1.21/src/org/simpleframework/http/core/ChunkedConsumer.java 0000664 0000000 0000000 00000022342 12536602605 0026511 0 ustar 00root root 0000000 0000000 /*
* ChunkedConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher ChunkedConsumer is reads an decodes a stream
* using the chunked transfer coding. This is used so that any data
* sent in the chunked transfer coding can be decoded. All bytes are
* appended to an internal buffer so that they can be read without
* having to parse the encoding.
*
*
* length := 0
* read chunk-size, chunk-extension (if any) and CRLF
* while (chunk-size > 0) {
* read chunk-data and CRLF
* append chunk-data to entity-body
* length := length + chunk-size
* read chunk-size and CRLF
* }
* read entity-header
* while (entity-header not empty) {
* append entity-header to existing header fields
* read entity-header
* }
*
*
* The above algorithm is taken from RFC 2616 section 19.4.6. This
* coding scheme is used in HTTP pipelines so that dynamic content,
* that is, content with which a length cannot be determined does
* not require a connection close to delimit the message body.
*
* @author Niall Gallagher
*/
class ChunkedConsumer extends UpdateConsumer {
/**
* This is used to create the internal buffer for the body.
*/
private Allocator allocator;
/**
* This is the internal buffer used to capture the body read.
*/
private Buffer buffer;
/**
* This is used to determine whether a full chunk has been read.
*/
private boolean terminal;
/**
* This is used to determine if the zero length chunk was read.
*/
private boolean last;
/**
* This is used to accumulate the bytes of the chunk size line.
*/
private byte line[];
/**
* This is the number of bytes appended to the line buffer.
*/
private int count;
/**
* This is the number of bytes left in the current chunk.
*/
private int chunk;
/**
* Constructor for the ChunkedConsumer object. This
* is used to create a consumer that reads chunked encoded data and
* appended that data in decoded form to an internal buffer so that
* it can be read in a clean decoded fromat.
*
* @param allocator this is used to allocate the internal buffer
*/
public ChunkedConsumer(Allocator allocator) {
this(allocator, 1024);
}
/**
* Constructor for the ChunkedConsumer object. This
* is used to create a consumer that reads chunked encoded data and
* appended that data in decoded form to an internal buffer so that
* it can be read in a clean decoded fromat.
*
* @param allocator this is used to allocate the internal buffer
* @param chunk this is the maximum size line allowed
*/
private ChunkedConsumer(Allocator allocator, int chunk) {
this.line = new byte[chunk];
this.allocator = allocator;
}
/**
* This will acquire the contents of the body in UTF-8. If there
* is no content encoding and the user of the request wants to
* deal with the body as a string then this method can be used.
* It will simply create a UTF-8 string using the body bytes.
*
* @return returns a UTF-8 string representation of the body
*/
@Override
public String getContent() throws IOException {
if(buffer == null) {
return new String();
}
return buffer.encode();
}
/**
* This will acquire the contents of the body in the specified
* charset. Typically this will be given the charset as taken
* from the HTTP Content-Type header. Although any encoding can
* be specified to convert the body to a string representation.
*
* @param charset this is the charset encoding to be used
*
* @return returns an encoded string representation of the body
*/
@Override
public String getContent(String charset) throws IOException {
if(buffer == null) {
return new String();
}
return buffer.encode(charset);
}
/**
* This is used to acquire the contents of the body as a stream.
* Each time this method is invoked a new stream is created that
* will read the contents of the body from the first byte. This
* ensures that the stream can be acquired several times without
* any issues arising from previous reads.
*
* @return this returns a new string used to read the body
*/
@Override
public InputStream getInputStream() throws IOException {
if(buffer == null) {
return new EmptyInputStream();
}
return buffer.getInputStream();
}
/**
* This is used to process the bytes that have been read from the
* cursor. This will keep reading bytes from the stream until such
* time as the zero length chunk has been read from the stream. If
* the zero length chunk is encountered then the overflow count is
* returned so it can be used to reset the cursor.
*
* @param array this is a chunk read from the cursor
* @param off this is the offset within the array the chunk starts
* @param size this is the number of bytes within the array
*
* @return this returns the number of bytes overflow that is read
*/
@Override
protected int update(byte[] array, int off, int size) throws IOException {
int mark = off + size;
while(off < mark){
if(terminal || last) {
while(off < mark) {
if(array[off++] == '\n') { // CR[LF]
if(last) { // 0; CRLFCR[LF]
finished = true;
return mark - off;
}
terminal = false;
break;
}
}
} else if(chunk == 0) {
while(chunk == 0) {
if(off >= mark) {
break;
} else if(array[off++] == '\n') { // CR[LF]
parse();
if(chunk == 0) { // 0; CR[LF]CRLF
last = true;
break;
}
} else {
line[count++] = array[off-1];
}
}
} else {
int write = Math.min(mark - off, chunk);
append(array, off, write);
chunk -= write;
off += write;
if(chunk == 0) { // []CRLF
terminal = true;
}
}
}
return 0;
}
/**
* This method is used to allocate the internal buffer. If there
* has already been a call to this method the previous instance
* is returned. If there is any issue allocating the buffer then
* this will throw an exception.
*
* @return this returns the buffer to append the bytes to
*/
@Override
protected Buffer allocate() throws IOException {
if(buffer == null) {
buffer = allocator.allocate();
}
return buffer;
}
/**
* This method is used to convert the size in hexidecimal to a
* decimal int. This will use the specified number
* of bytes from the internal buffer and parse each character
* read as a hexidecimal character. This stops interpreting the
* size line when a non-hexidecimal character is encountered.
*/
private void parse() throws IOException {
int off = 0;
while(off < count) {
int octet = toDecimal(line[off]);
if(octet < 0){
if(off < 1) {
throw new IOException("Invalid chunk size line");
}
break;
}
chunk <<= 4;
chunk ^= octet;
off++;
}
count = 0;
}
/**
* This performs a conversion from a character to an integer. If
* the character given, as a byte, is a hexidecimal
* char this will convert it into its integer equivelant. So a
* char of A is converted into 10.
*
* @param octet this is an ISO 8869-1 hexidecimal character
*
* @return returns the hex character into its decinal value
*/
private int toDecimal(byte octet){
if(octet >= 'A' && octet <= 'Z') {
return (octet - (int)'A') + 10;
}
if(octet >= '0' && octet <= '9') {
return octet - (int)'0';
}
if(octet >= 'a' && octet <= 'f') {
return (octet - (int)'a') + 10;
}
return -1;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ChunkedProducer.java 0000664 0000000 0000000 00000017205 12536602605 0026503 0 ustar 00root root 0000000 0000000 /*
* ChunkedProducer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher ChunkedProducer object is used to encode data in
* the chunked encoding format. A chunked producer is required when
* the length of the emitted content is unknown. It enables the HTTP
* pipeline to remain open as it is a self delimiting format. This
* is preferred over the CloseProducer for HTTP/1.1 as
* it maintains the pipeline and thus the cost of creating it.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.ChunkedConsumer
*/
class ChunkedProducer implements Producer {
/**
* This is the size line which is used to generate the size.
*/
private byte[] size = { '0', '0', '0', '0', '0', '0', '0', '0', '\r', '\n' };
/**
* This is the hexadecimal alphabet used to translate the size.
*/
private byte[] index = { '0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'a', 'b', 'c', 'd','e', 'f' };
/**
* This is the zero length chunk sent when this is completed.
*/
private byte[] zero = { '0', '\r', '\n', '\r', '\n' };
/**
* This is the monitor used to notify the initiator of events.
*/
private Monitor monitor;
/**
* This is the underlying sender used to deliver the encoded data.
*/
private Sender sender;
/**
* Constructor for the ChunkedProducer object. This
* is used to create a producer that can sent data in the chunked
* encoding format. Once the data is encoded in the format it is
* handed to the provided Sender object which will
* then deliver it to the client using the underlying transport.
*
* @param sender this is the sender used to deliver the content
* @param monitor this is the monitor used to signal I/O events
*/
public ChunkedProducer(Sender sender, Monitor monitor) {
this.monitor = monitor;
this.sender = sender;
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
*/
public void produce(byte[] array) throws IOException {
produce(array, 0, array.length);
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(byte[] array, int off, int len) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(array, off, len);
if(len > 0) {
produce(buffer);
}
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void produce(ByteBuffer buffer) throws IOException {
int mark = buffer.position();
int size = buffer.limit();
if(mark > size) {
throw new ProducerException("Buffer position greater than limit");
}
produce(buffer, 0, size - mark);
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(ByteBuffer buffer, int off, int len) throws IOException {
int pos = 7;
if(monitor.isClosed()) {
throw new ProducerException("Stream has been closed");
}
if(len > 0) {
for(int num = len; num > 0; num >>>= 4){
size[pos--] = index[num & 0xf];
}
try {
sender.send(size, pos + 1, 9 - pos);
sender.send(buffer, off, len);
sender.send(size, 8, 2);
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error sending response", cause);
}
}
}
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException {
try {
if(!monitor.isClosed()) {
sender.flush();
}
} catch(Exception cause) {
if(sender != null) {
monitor.close(sender);
}
throw new ProducerException("Error sending response", cause);
}
}
/**
* This method is used to write the zero length chunk. Writing
* the zero length chunk tells the client that the response has
* been fully sent, and the next sequence of bytes from the HTTP
* pipeline is the start of the next response. This will signal
* to the server kernel that the next request is read to read.
*/
private void finish() throws IOException {
try {
sender.send(zero);
monitor.ready(sender);
} catch(Exception cause) {
if(sender != null) {
monitor.close(sender);
}
throw new ProducerException("Error flushing response", cause);
}
}
/**
* This is used to signal to the producer that all content has
* been written and the user no longer needs to write. This will
* either close the underlying transport or it will notify the
* monitor that the response has completed and the next request
* can begin. This ensures the content is flushed to the client.
*/
public void close() throws IOException {
if(!monitor.isClosed()) {
finish();
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/CloseProducer.java 0000664 0000000 0000000 00000014275 12536602605 0026173 0 ustar 00root root 0000000 0000000 /*
* CloseProducer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher CloseProducer is used to close a connection once
* all of the content has been produced. This is typically used if
* the connected client supports the HTTP/1.0 protocol and there is
* no Connection header with the keep-alive token. For reasons of
* performance this should not be used for HTTP/1.1 clients.
*
* @author Niall Gallagher
*/
class CloseProducer implements Producer {
/**
* This is the monitor used to notify the initiator of events.
*/
private final Monitor monitor;
/**
* This is the underlying sender used to deliver the raw data.
*/
private final Sender sender;
/**
* Constructor for the CloseProducer object. This is
* used to create a producer that will close the underlying socket
* as a means to signal that the response is fully sent. This is
* typically used with HTTP/1.0 connections.
*
* @param sender this is used to send to the underlying transport
* @param monitor this is used to deliver signals to the kernel
*/
public CloseProducer(Sender sender, Monitor monitor) {
this.monitor = monitor;
this.sender = sender;
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
*/
public void produce(byte[] array) throws IOException {
produce(array, 0, array.length);
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(byte[] array, int off, int len) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(array, off, len);
if(len > 0) {
produce(buffer);
}
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void produce(ByteBuffer buffer) throws IOException {
int mark = buffer.position();
int size = buffer.limit();
if(mark > size) {
throw new ProducerException("Buffer position greater than limit");
}
produce(buffer, 0, size - mark);
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(ByteBuffer buffer, int off, int len) throws IOException {
if(monitor.isClosed()) {
throw new ProducerException("Stream has been closed");
}
try {
sender.send(buffer, off, len);
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error sending response", cause);
}
}
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException {
try {
if(!monitor.isClosed()) {
sender.flush();
}
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error sending response", cause);
}
}
/**
* This is used to signal to the producer that all content has
* been written and the user no longer needs to write. This will
* close the underlying transport which tells the client that
* all of the content has been sent over the connection.
*/
public void close() throws IOException {
try {
if(!monitor.isClosed()) {
monitor.close(sender);
sender.close();
}
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error sending response", cause);
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Collector.java 0000664 0000000 0000000 00000005275 12536602605 0025350 0 ustar 00root root 0000000 0000000 /*
* Collector.java October 2002
*
* Copyright (C) 2002, Niall Gallagher Collector object is used to collect bytes from
* a channel in order to create the HTTP entity. In order to create
* the entity this makes use of a collection of consumer objects
* which will consume the data required to compose the header and
* body of the entity. Once the entity has been fully collected
* this object exposes the consumed data as typed objects, which
* can be used to examine the request sent by the client.
* Selector object, which it can used to
* hibernate until such time as there is data ready to read.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Channel
*/
interface Collector extends Entity {
/**
* This is used to collect the data from a Channel
* which is used to compose the entity. If at any stage there
* are no ready bytes on the socket the selector provided can be
* used to queue the collector until such time as the socket is
* ready to read. Also, should the entity have completed reading
* all required content it is handed to the selector as ready,
* which processes the entity as a new client HTTP request.
*
* @param selector this is the selector used to queue this
*/
public void collect(Selector selector) throws IOException;
/**
* This returns the socket channel that is used by the collector
* to read content from. This is a selectable socket, in that
* it can be registered with a Java NIO selector. This ensures
* that the system can be notified when the socket is ready.
*
* @return the socket channel used by this collector object
*/
public SocketChannel getSocket();
}
simple-http-4.1.21/src/org/simpleframework/http/core/Consumer.java 0000664 0000000 0000000 00000004607 12536602605 0025213 0 ustar 00root root 0000000 0000000 /*
* Consumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Consumer object is used to consume and process
* bytes from a cursor. This is used to consume bytes from a pipeline
* and process the content in order to produce a valid HTTP message.
* Using a consumer allows the server to gather and process the data
* from the stream bit by bit without blocking.
* CRLF bytes
* tokens to identify the end of the header, once this has been read
* any excess bytes are reset on the cursor and it has finished.
*
* @author Niall Gallagher
*
* @see org.simpleframework.transport.Cursor
*/
interface Consumer {
/**
* This method is used to consume bytes from the provided cursor.
* Consuming of bytes from the cursor should be done in such a
* way that it does not block. So typically only the number of
* ready bytes in the Cursor object should be read.
* If there are no ready bytes then this method should return.
*
* @param cursor used to consume the bytes from the HTTP pipeline
*/
public void consume(Cursor cursor) throws IOException;
/**
* This is used to determine whether the consumer has finished
* reading. The consumer is considered finished if it has read a
* terminal token or if it has exhausted the stream and can not
* read any more. Once finished the consumed bytes can be parsed.
*
* @return true if the consumer has finished reading its content
*/
public boolean isFinished();
}
simple-http-4.1.21/src/org/simpleframework/http/core/ConsumerFactory.java 0000664 0000000 0000000 00000014575 12536602605 0026550 0 ustar 00root root 0000000 0000000 /*
* ConsumerFactory.java February 2007
*
* Copyright (C) 2007, Niall Gallagher ConsumerFactory object is used to create a factory
* for creating consumers. This allows the request to determine the
* type of content sent and allows consumption of the request body in
* a the manner specified by the HTTP header. This will allow multipart
* and chunked content to be consumed from the pipeline.
*
* @author Niall Gallagher
*/
class ConsumerFactory {
/**
* This is used to allocate the memory associated with the body.
*/
protected Allocator allocator;
/**
* This is the header associated with the request body consumed.
*/
protected Segment segment;
/**
* Constructor for the ConsumerFactory object. This
* will create a factory that makes use of the HTTP header in order
* to determine the type of the body that is to be consumed.
*
* @param allocator this is the allocator used to allocate memory
* @param segment this is the HTTP header used to determine type
*/
public ConsumerFactory(Allocator allocator, Segment segment) {
this.allocator = allocator;
this.segment = segment;
}
/**
* This method is used to create a body consumer to read the body
* from the pipeline. This will examine the HTTP header associated
* with the body to determine how to consume the data. This will
* provide an empty consumer if no specific delimeter was provided.
*
* @return this returns the consumer used to consume the body
*/
public BodyConsumer getInstance() {
int length = getContentLength();
if(length < 0) {
return getInstance(8192);
}
return getInstance(length);
}
/**
* This method is used to create a body consumer to read the body
* from the pipeline. This will examine the HTTP header associated
* with the body to determine how to consume the data. This will
* provide an empty consumer if no specific delimeter was provided.
*
* @param length this is the length of the body to be consumed
*
* @return this returns the consumer used to consume the body
*/
public BodyConsumer getInstance(int length) {
byte[] boundary = getBoundary(segment);
if(isPart(segment)) {
return new PartListConsumer(allocator, boundary, length);
}
if(isChunked(segment)) {
return new ChunkedConsumer(allocator);
}
if(isFixed(segment)) {
return new FixedConsumer(allocator, length);
}
return new EmptyConsumer();
}
/**
* This is used to extract information from the HTTP header that
* can be used to determine the type of the body. This will look
* at the HTTP headers provided to find a specific token which
* enables it to determine how to consume the body.
*
* @param header this is the header associated with the body
*
* @return the boundary for a multipart upload body
*/
protected byte[] getBoundary(Segment header) {
ContentType type = header.getContentType();
if(type != null) {
String token = type.getParameter("boundary");
if(token != null) {
return token.getBytes();
}
}
return null;
}
/**
* This is used to extract information from the HTTP header that
* can be used to determine the type of the body. This will look
* at the HTTP headers provided to find a specific token which
* enables it to determine how to consume the body.
*
* @param segment this is the header associated with the body
*
* @return true if the content type is that of a multipart body
*/
protected boolean isPart(Segment segment) {
ContentType type = segment.getContentType();
if(type != null) {
String token = type.getPrimary();
if(token.equals("multipart")) {
return true;
}
}
return false;
}
/**
* This is used to extract information from the HTTP header that
* can be used to determine the type of the body. This will look
* at the HTTP headers provided to find a specific token which
* enables it to determine how to consume the body.
*
* @param segment this is the header associated with the body
*
* @return true if the body is to be consumed as a chunked body
*/
protected boolean isChunked(Segment segment) {
String encoding = segment.getTransferEncoding();
if(encoding != null) {
if(encoding.equals("chunked")) {
return true;
}
}
return false;
}
/**
* This is used to extract information from the HTTP header that
* can be used to determine the type of the body. This will look
* at the HTTP headers provided to find a specific token which
* enables it to determine how to consume the body.
*
* @param segment this is the header associated with the body
*
* @return true if there was a content length in the header
*/
protected boolean isFixed(Segment segment) {
int length = segment.getContentLength();
if(length > 0) {
return true;
}
return false;
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
protected int getContentLength() {
return segment.getContentLength();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Container.java 0000664 0000000 0000000 00000005065 12536602605 0025341 0 ustar 00root root 0000000 0000000 /*
* Container.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Container object is used to process HTTP requests
* and compose HTTP responses. The Request objects that
* are handed to this container contain all information relating to
* the received message. The responsibility of the container is to
* interpret the request and compose a suitable response.
* Response object used to
* deliver the HTTP response will only commit and send once it has
* its OutputStream closed.
* Container is entirely responsible for the HTTP
* message headers and body. It is up to the implementation to ensure
* that it complies to RFC 2616 or any previous specification. All
* headers and the status line can be modified by this object.
*
* @author Niall Gallagher
*/
public interface Container {
/**
* Used to pass the Request and Response
* to the container for processing. Any implementation of this
* must ensure that this is thread safe, as it will receive many
* concurrent invocations each with a unique HTTP request.
* Response object has been closed and committed.
*
* @param req the request that contains the client HTTP message
* @param resp the response used to deliver the server response
*/
public void handle(Request req, Response resp);
}
simple-http-4.1.21/src/org/simpleframework/http/core/ContainerProcessor.java 0000664 0000000 0000000 00000010315 12536602605 0027233 0 ustar 00root root 0000000 0000000 /*
* ContainerProcessor.java February 2007
*
* Copyright (C) 2007, Niall Gallagher ContainerProcessor object is used to create
* channels which can be used to consume and process requests. This
* is basically an adapter to the Selector which will
* convert the provided transport to a usable channel. Each of the
* connected pipelines will end up at this object, regardless of
* whether those connections are SSL or plain data.
*
* @author Niall Gallagher
*/
public class ContainerProcessor implements Processor {
/**
* This is the allocator used internally be this processor.
*/
private final Allocator allocator;
/**
* This is the selector used to process the created channels.
*/
private final Selector selector;
/**
* Constructor for the ContainerProcessor object.
* This is used to create a processor which will convert the
* provided transport objects to channels, which can then be
* processed by the selector and dispatched to the container.
*
* @param container the container to dispatch requests to
* @param allocator this is the allocator used to buffer data
* @param count this is the number of threads to be used
*/
public ContainerProcessor(Container container, Allocator allocator, int count) throws IOException {
this(container, allocator, count, 1);
}
/**
* Constructor for the ContainerProcessor object.
* This is used to create a processor which will convert the
* provided transport objects to channels, which can then be
* processed by the selector and dispatched to the container.
*
* @param container the container to dispatch requests to
* @param allocator this is the allocator used to buffer data
* @param count this is the number of threads to be used
* @param select this is the number of selector threads to use
*/
public ContainerProcessor(Container container, Allocator allocator, int count, int select) throws IOException {
this.selector = new ContainerSelector(container, allocator, count, select);
this.allocator = allocator;
}
/**
* This is used to process the requests from a provided transport
* and deliver a response to those requests. A transport can be
* a direct transport or a secure transport providing SSL.
* Processor such
* that it will accept no more pipelines. Stopping the processor
* ensures that all resources occupied will be released. This is
* required so that all threads are stopped and released.
* ContainerSelector object is essentially the core
* processing engine for the server. This is used to collect requests
* from the connected channels and dispatch those requests to the
* provided Container object. This contains two thread
* pools. The first is used to collect data from the channels and
* create request entities. The second is used to take the created
* entities and service them with the provided container.
*
* @author Niall Gallagher
*/
class ContainerSelector implements Selector {
/**
* This is the thread pool used for servicing the requests.
*/
private final PoolExecutor executor;
/**
* This is the thread pool used for collecting the requests.
*/
private final PoolExecutor collect;
/**
* This is the allocator used to create the buffers needed.
*/
private final Allocator allocator;
/**
* This is the container used to service the requests.
*/
private final Container handler;
/**
* This is the reactor used to schedule the collectors.
*/
private final Reactor reactor;
/**
* This is the tracker used to create the session objects.
*/
private final Tracker tracker;
/**
* Constructor for the ContainerSelector object. This
* is used to create a selector which will collect and dispatch
* requests using two thread pools. The first is used to collect
* the requests, the second is used to service those requests.
*
* @param handler this is the container used to service requests
* @param allocator this is used to allocate any buffers needed
* @param count this is the number of threads per thread pool
* @param select this is the number of selector threads to use
*/
public ContainerSelector(Container handler, Allocator allocator, int count, int select) throws IOException {
this.collect = new PoolExecutor(Reader.class, count);
this.reactor = new ExecutorReactor(collect, select);
this.executor = new PoolExecutor(Dispatcher.class, count);
this.tracker = new CookieTracker();
this.allocator = allocator;
this.handler = handler;
}
/**
* This is used to initiate the processing of the channel. Once
* the channel is passed in to the initiator any bytes ready on
* the HTTP pipeline will be processed and parsed in to a HTTP
* request. When the request has been built a callback is made
* to the Container to process the request. Also
* when the request is completed the channel is passed back in
* to the initiator so that the next request can be dealt with.
*
* @param channel the channel to process the request from
*/
public void start(Channel channel) throws IOException {
start(new EntityCollector(allocator, tracker, channel));
}
/**
* The start event is used to immediately consume bytes form the
* underlying transport, it does not require a select to check
* if the socket is read ready which improves performance. Also,
* when a response has been delivered the next request from the
* pipeline is consumed immediately.
*
* @param collector this is the collector used to collect data
*/
public void start(Collector collector) throws IOException {
reactor.process(new Reader(this, collector));
}
/**
* The select event is used to register the connected socket with
* a Java NIO selector which can efficiently determine when there
* are bytes ready to read from the socket.
*
* @param collector this is the collector used to collect data
*/
public void select(Collector collector) throws IOException {
reactor.process(new Reader(this, collector), OP_READ);
}
/**
* The ready event is used when a full HTTP entity has been
* collected from the underlying transport. On such an event the
* request and response can be handled by a container.
*
* @param collector this is the collector used to collect data
*/
public void ready(Collector collector) throws IOException {
executor.execute(new Dispatcher(handler, this, collector));
}
/**
* This method is used to stop the Selector so that
* all resources are released. As well as freeing occupied memory
* this will also stop all threads, which means that is can no
* longer be used to collect data from the pipelines.
* Reactor first, this ensures
* that there are no further selects performed if a given socket
* does not have enough data to fulfill a request. From there we
* stop the main dispatch Executor so that all of
* the currently executing tasks complete. The final stage of
* termination requires the collector thread pool to be stopped.
*/
public void stop() throws IOException {
try {
reactor.stop();
executor.stop();
collect.stop();
tracker.close();
} catch(Exception e) {
throw new IOException("Error stopping");
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ContainerServer.java 0000664 0000000 0000000 00000012551 12536602605 0026526 0 ustar 00root root 0000000 0000000 /*
* ContainerServer.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ContainerServer object provides a processor
* that dispatch requests from a connected pipeline. SSL connections
* and plain connections can be processed by this implementation. It
* collects data from the connected pipelines and constructs the
* requests and responses used to dispatch to the container.
* ContainerServer object. The
* processor created will collect HTTP requests from the pipelines
* provided and dispatch those requests to the provided container.
*
* @param container this is the container used to service requests
*/
public ContainerServer(Container container) throws IOException {
this(container, new FileAllocator(), 8);
}
/**
* Constructor for the ContainerServer object. The
* processor created will collect HTTP requests from the pipelines
* provided and dispatch those requests to the provided container.
*
* @param container this is the container used to service requests
* @param count this is the number of threads used for each pool
*/
public ContainerServer(Container container, int count) throws IOException {
this(container, new FileAllocator(), count);
}
/**
* Constructor for the ContainerServer object. The
* processor created will collect HTTP requests from the pipelines
* provided and dispatch those requests to the provided container.
*
* @param container this is the container used to service requests
* @param allocator this is the allocator used to create buffers
*/
public ContainerServer(Container container, Allocator allocator) throws IOException {
this(container, allocator, 8);
}
/**
* Constructor for the ContainerServer object. The
* processor created will collect HTTP requests from the pipelines
* provided and dispatch those requests to the provided container.
*
* @param container this is the container used to service requests
* @param allocator this is the allocator used to create buffers
* @param count this is the number of threads used for each pool
*/
public ContainerServer(Container container, Allocator allocator, int count) throws IOException {
this.processor = new ContainerProcessor(container, allocator, count);
this.server = new ProcessorServer(processor, count);
}
/**
* Used to process the Socket which is a full duplex
* communication link that may contain several HTTP requests. This
* will be used to read the requests from the Socket
* and to pass these requests to a Container for
* processing.
* Processor such that
* it will accept no more pipelines. Stopping the processor ensures
* that all resources occupied will be released. This is required
* so that all threads are stopped, and all memory is released.
* ContentConsumer object represents a consumer for
* a multipart body part. This will read the contents of the cursor
* until such time as it reads the terminal boundary token, which is
* used to frame the content. Once the boundary token has been read
* this will add itself as a part to a part list. This part list can
* then be used with the HTTP request to examine and use the part.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.PartConsumer
*/
class ContentConsumer extends UpdateConsumer implements Part {
/**
* This represents the start of the boundary token for the body.
*/
private static final byte[] START = { '\r', '\n', '-', '-' };
/**
* This is used to allocate the internal buffer when required.
*/
private Allocator allocator;
/**
* This is the internal buffer used to house the part body.
*/
private Buffer buffer;
/**
* Represents the HTTP headers that were provided for the part.
*/
private Segment segment;
/**
* This is the part list that this part is to be added to.
*/
private PartList list;
/**
* Represents the message boundary that terminates the part body.
*/
private byte[] boundary;
/**
* This is used to determine if the start token had been read.
*/
private int start;
/**
* This is used to determine how many boundary tokens are read.
*/
private int seek;
/**
* Constructor for the ContentConsumer object. This
* is used to create a consumer that reads the body of a part in
* a multipart request body. The terminal token must be provided
* so that the end of the part body can be determined.
*
* @param allocator this is used to allocate the internal buffer
* @param segment this represents the headers for the part body
* @param list this is the part list that this body belongs in
* @param boundary this is the message boundary for the body part
*/
public ContentConsumer(Allocator allocator, Segment segment, PartList list, byte[] boundary) {
this.allocator = allocator;
this.boundary = boundary;
this.segment = segment;
this.list = list;
}
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile() {
return segment.isFile();
}
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName() {
return segment.getName();
}
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName() {
return segment.getFileName();
}
/**
* This is used to acquire the header value for the specified
* header name. Providing the header values through this method
* ensures any special processing for a know content type can be
* handled by an application.
*
* @param name the name of the header to get the value for
*
* @return value of the header mapped to the specified name
*/
public String getHeader(String name) {
return segment.getValue(name);
}
/**
* This is used to acquire the content type for this part. This
* is typically the type of content for a file part, as provided
* by a MIME type from the HTTP "Content-Type" header.
*
* @return this returns the content type for the part object
*/
public ContentType getContentType() {
return segment.getContentType();
}
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @return this returns a string representing the content
*/
@Override
public String getContent() throws IOException {
return getContent("ISO-8859-1");
}
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @param charset this is the charset encoding to be used
*
* @return this returns a string representing the content
*/
@Override
public String getContent(String charset) throws IOException {
if(buffer == null) {
return new String();
}
return buffer.encode(charset);
}
/**
* This is used to acquire an InputStream for the
* part. Acquiring the stream allows the content of the part to
* be consumed by reading the stream. Each invocation of this
* method will produce a new stream starting from the first byte.
*
* @return this returns the stream for this part object
*/
@Override
public InputStream getInputStream() throws IOException {
if(buffer == null) {
return new EmptyInputStream();
}
return buffer.getInputStream();
}
/**
* This is used to push the start and boundary back on to the
* cursor. Pushing the boundary back on to the cursor is required
* to ensure that the next consumer will have valid data to
* read from it. Simply resetting the boundary is not enough as
* this can cause an infinite loop if the connection is bad.
*
* @param cursor this is the cursor used by this consumer
*/
@Override
protected void commit(Cursor cursor) throws IOException {
cursor.push(boundary);
cursor.push(START);
}
/**
* This is used to process the bytes that have been read from the
* cursor. This will search for the boundary token within the body
* of the message part, when it is found this will returns the
* number of bytes that represent the overflow.
*
* @param array this is a chunk read from the cursor
* @param off this is the offset within the array the chunk starts
* @param size this is the number of bytes within the array
*
* @return this returns the number of bytes overflow that is read
*/
@Override
protected int update(byte[] array, int off, int size) throws IOException {
int skip = start + seek; // did we skip previously
int last = off + size;
int next = start;
int mark = off;
while(off < last) {
if(start == START.length) { // search for boundary
if(array[off++] != boundary[seek++]) { // boundary not found
if(skip > 0) {
append(START, 0, next); // write skipped start
append(boundary, 0, skip - next); // write skipped boundary
}
skip = start = seek = 0; // reset scan position
}
if(seek == boundary.length) { // boundary found
int excess = seek + start; // boundary bytes read
int total = off - mark; // total bytes read
int valid = total - excess; // body bytes read
finished = true;
list.add(this);
if(valid > 0) {
append(array, mark, valid);
}
return size - total; // remaining excluding boundary
}
} else {
byte octet = array[off++]; // current
if(octet != START[start++]) {
if(skip > 0) {
append(START, 0, next); // write skipped start
}
skip = start = 0; // reset
if(octet == START[0]) { // is previous byte the start
start++;
}
}
}
}
int excess = seek + start; // boundary bytes read
int total = off - mark; // total bytes read
int valid = total - excess; // body bytes read
if(valid > 0) { // can we append processed data
append(array, mark, valid);
}
return 0;
}
/**
* This method is used to allocate the internal buffer. If there
* has already been a call to this method the previous instance
* is returned. If there is any issue allocating the buffer then
* this will throw an exception.
*
* @return this returns the buffer to append the bytes to
*/
@Override
protected Buffer allocate() throws IOException {
if(buffer == null) {
buffer = allocator.allocate();
}
return buffer;
}
/**
* This is used to provide a string representation of the header
* read. Providing a string representation of the header is used
* so that on debugging the contents of the delivered header can
* be inspected in order to determine a cause of error.
*
* @return this returns a string representation of the header
*/
@Override
public String toString() {
return segment.toString();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Conversation.java 0000664 0000000 0000000 00000021643 12536602605 0026071 0 ustar 00root root 0000000 0000000 /*
* Conversation.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Conversation object is used to set and interpret
* the semantics of the HTTP headers with regard to the encoding
* used for the response. This will ensure the the correct headers
* are used so that if chunked encoding or a connection close is
* needed that the headers are set accordingly. This allows both the
* server and client to agree on the best semantics to use.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Accumulator
* @see org.simpleframework.http.core.Transfer
*/
class Conversation {
/**
* This is the response object that requires HTTP headers set.
*/
private final Response response;
/**
* This contains the request headers and protocol version.
*/
private final Request request;
/**
* Constructor for the Conversation object. This is
* used to create an object that makes use of both the request
* and response HTTP headers to determine how best to deliver
* the response body. Depending on the protocol version and the
* existing response headers suitable semantics are determined.
*
* @param request this is the request from the client
* @param response this is the response that is to be sent
*/
public Conversation(Request request, Response response) {
this.response = response;
this.request = request;
}
/**
* This provides the Request object. This can be
* used to acquire the request HTTP headers and protocl version
* used by the client. Typically the conversation provides all
* the data needed to determine the type of response required.
*
* @return this returns the request object for the conversation
*/
public Request getRequest() {
return request;
}
/**
* This provides the Response object. This is used
* when the commit is required on the response. By committing
* the response the HTTP header is generated and delivered to
* the underlying transport.
*
* @return this returns the response for the conversation
*/
public Response getResponse() {
return response;
}
/**
* This is used to acquire the content length for the response.
* The content length is acquired fromt he Content-Length header
* if it has been set. If not then this will return a -1 value.
*
* @return this returns the value for the content length header
*/
public int getContentLength() {
return response.getContentLength();
}
/**
* This is used to determine if the Response has a
* message body. If this does not have a message body then true
* is returned. This is determined as of RFC 2616 rules for the
* presence of a message body. A message body must not be
* included with a HEAD request or with a 304 or a 204 response.
* If when this is called there is no message length delimiter
* as specified by section RFC 2616 4.4, then there is no body.
*
* @return true if there is no response body, false otherwise
*/
public boolean isEmpty() {
int code = response.getCode();
if(code == 204){
return true;
}
if(code == 304){
return true;
}
return false;
}
/**
* This is used to determine if the request method was HEAD. This
* is of particular interest in a HTTP conversation as it tells
* the response whether a response body is to be sent or not.
* If the method is head the delimeters for the response should
* be as they would be for a similar GET, however no body is sent.
*
* @return true if the request method was a HEAD method
*/
public boolean isHead() {
String method = request.getMethod();
if(method == null) {
return false;
}
return method.equalsIgnoreCase("HEAD");
}
/**
* This is used to set the content length for the response. If
* the HTTP version is HTTP/1.1 then the Content-Length header is
* used, if an earlier protocol version is used then connection
* close semantics are also used to ensure client compatibility.
*
* @param length this is the length to set HTTP header to
*/
public void setContentLength(int length) {
boolean keepAlive = isKeepAlive();
if(keepAlive) {
response.set("Connection", "keep-alive");
} else {
response.set("Connection", "close");
}
response.set("Content-Length", length);
}
/**
* This checks the protocol version used in the request to check
* whether it supports persistent HTTP connections. By default the
* HTTP/1.1 protocol supports persistent connnections, this can
* onlyy be overridden with a Connection header with the close
* token. Earlier protocol versions are connection close.
*
* @return this returns true if the protocol is HTTP/1.1 or above
*/
public boolean isPersistent() {
String token = request.getValue("Connection");
if(token != null) {
return token.equalsIgnoreCase("keep-alive");
}
int major = request.getMajor();
int minor = request.getMinor();
if(major >= 1) {
return minor >= 1;
}
return false;
}
/**
* The isKeepAlive method is used to determine if
* the connection semantics are set to maintain the connection.
* This checks to see if there is a Connection header with the
* keep-alive token, if so then the connection is keep alive, if
* however there is no connection header the version is used.
*
* @return true if the response connection is to be maintained
*/
public boolean isKeepAlive() {
String token = response.getValue("Connection");
if(token != null) {
return token.equalsIgnoreCase("keep-alive");
}
return isPersistent();
}
/**
* The isChunkable method is used to determine if
* the client supports chunked encoding. If the client does not
* support chunked encoding then a connection close should be used
* instead, this allows HTTP/1.0 clients to be supported properly.
*
* @return true if the client supports chunked transfer encoding
*/
public boolean isChunkable() {
int major = request.getMajor();
int minor = request.getMinor();
if(major >= 1) {
return minor >= 1;
}
return false;
}
/**
* This is used when the output is encoded in the chunked encoding.
* This should only be used if the protocol version is HTTP/1.1 or
* above. If the protocol version supports chunked encoding then it
* will encode the data as specified in RFC 2616 section 3.6.1.
*/
public void setChunkedEncoded() {
boolean keepAlive = isKeepAlive();
boolean chunkable = isChunkable();
if(keepAlive && chunkable) {
response.set("Transfer-Encoding", "chunked");
response.set("Connection", "keep-alive");
} else {
response.set("Connection", "close");
}
}
/**
* This will remove all explicit transfer encoding headers from
* the response header. By default the identity encoding is used
* for all connections, it basically means no encoding. So if the
* response uses a Content-Length it implicitly assumes tha the
* encoding of the response is identity encoding.
*/
public void setIdentityEncoded() {
response.remove("Transfer-Encoding");
}
/**
* The isChunkedEncoded is used to determine whether
* the chunked encoding scheme is desired. This is enables data to
* be encoded in such a way that a connection can be maintained
* without a Content-Length header. If the output is chunked then
* the connection is keep alive.
*
* @return true if the response output is chunked encoded
*/
public boolean isChunkedEncoded() {
String token = response.getValue("Transfer-Encoding");
if(token != null) {
return token.equalsIgnoreCase("chunked");
}
return false;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/CookieTracker.java 0000664 0000000 0000000 00000011506 12536602605 0026141 0 ustar 00root root 0000000 0000000 /*
* CookieTracker.java February 2007
*
* Copyright (C) 2007, Niall Gallagher CookieTracker object provides a tracker that is
* used to create and retrieve sessions based on a cookie. This will
* extract the session cookie object using a provided entity. If
* the entity header does not contain a cookie then it can be
* created. Once created all subsequent requests can acquire the
* same session using the unique session cookie value in the header.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.session.SessionManager
*/
class CookieTracker implements Tracker {
/**
* This is the provider used to manage all created sessions.
*/
private final SessionProvider provider;
/**
* Constructor for the CookieTracker object. This is
* an adapter for a session provider implementation, which uses
* a unique value provided in a cookie sent with the request. By
* default the idle life of a session is twenty minutes.
*/
public CookieTracker() {
this(1200, SECONDS);
}
/**
* Constructor for the CookieTracker object. This is
* an adapter for a session provider implementation, which uses
* a unique value provided in a cookie sent with the request. The
* idle life of a session can be specified in this constructor.
*
* @param duration this is the idle life of the sessions
* @param unit the time unit used to measure the duration
*/
public CookieTracker(long duration, TimeUnit unit) {
this.provider = new SessionManager(duration, unit);
}
/**
* This is used to acquire the Session object using
* the information within the HTTP entity. The entity contains all
* of the information that has been sent by the client and is the
* ideal means to differentiate clients.
*
* @param entity this is the entity consumed from the pipeline
*
* @return a session associated with the provided entity
*/
public Session getSession(Entity entity) throws LeaseException {
return getSession(entity, true);
}
/**
* This is used to acquire the Session object using
* the information within the HTTP entity. The entity contains all
* of the information that has been sent by the client and is the
* ideal means to differentiate clients.
*
* @param entity this is the entity consumed from the pipeline
* @param create determines if a session should be created
*
* @return a session associated with the provided entity
*/
public Session getSession(Entity entity, boolean create) throws LeaseException {
Header header = entity.getHeader();
Cookie cookie = header.getSession(create);
if(cookie == null) {
return null;
}
return getSession(cookie, create);
}
/**
* This is used to acquire the Session object using
* the provided cookie. The value of the cookies is used as a key
* to acquire the session from the session provider. If one does
* not exist then it can be created if required.
*
* @param cookie this is the cookie used to acquire the provider
* @param create determines if a session should be created
*
* @return a session associated with the provided cookie
*/
private Session getSession(Cookie cookie, boolean create) throws LeaseException {
String value = cookie.getValue();
if(value == null) {
return null;
}
return provider.open(value, create);
}
/**
* This close method is used to close the tracker and
* release all resources associated with it. This means canceling
* all active sessions and emptying the contents of those sessions.
* Threads and other such resources are released by this method.
*/
public void close() throws LeaseException {
provider.close();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Dispatcher.java 0000664 0000000 0000000 00000007321 12536602605 0025502 0 ustar 00root root 0000000 0000000 /*
* Dispatcher.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Dispatcher object is used to dispatch a request
* and response to the container. This is the root task that executes
* all transactions. A transaction is dispatched to the container
* which can deal with it asynchronously, however as a safeguard the
* dispatcher will catch any throwables from the contains and close
* the connection if required. Closing the connection if an exception
* is thrown ensures that CLOSE_WAIT issues do not arise with open
* connections that can not be closed within the container.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Container
*/
class Dispatcher implements Runnable {
/**
* This is the container that is used to handle the transactions.
*/
private final Container container;
/**
* This is the response object used to response to the request.
*/
private final Response response;
/**
* This is the request object which contains the request entity.
*/
private final Request request;
/**
* This is the monitor object used to signal completion events.
*/
private final Monitor monitor;
/**
* This is the entity containing the raw request details.
*/
private final Entity entity;
/**
* Constructor for the Dispatcher object. This creates
* a request and response object using the provided entity, these
* can then be passed to the container to handle the transaction.
*
* @param container this is the container to handle the request
* @param reactor the reactor used to handle the next request
* @param entity this contains the current request entity
*/
public Dispatcher(Container container, Initiator reactor, Entity entity) {
this.monitor = new FlushMonitor(reactor, entity);
this.request = new RequestEntity(entity, monitor);
this.response = new ResponseEntity(request, entity, monitor);
this.container = container;
this.entity = entity;
}
/**
* This run method will dispatch the created request
* and response objects to the container. This will interpret the
* target and semantics from the request object and compose a
* response for the request which is sent to the connected client.
*/
public void run() {
try {
dispatch();
} catch(Exception e) {
return;
}
}
/**
* This dispatch method will dispatch the request
* and response objects to the container. This will interpret the
* target and semantics from the request object and compose a
* response for the request which is sent to the connected client.
* If there is an exception this will close the socket channel.
*/
private void dispatch() throws Exception {
Channel channel = entity.getChannel();
try {
container.handle(request, response);
} catch(Throwable e) {
channel.close();
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Disposition.java 0000664 0000000 0000000 00000004125 12536602605 0025717 0 ustar 00root root 0000000 0000000 /*
* Disposition.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Disposition object is used to represent the HTTP
* Content-Disposition header of a request. A content disposition
* contains the name of the part and whether that part contains
* the contents of a file. If the part represents a parameter then
* the getName can be used to determine the name, if
* it represents a file then getFileName is preferred.
*
* @author Niall Gallagher
*/
interface Disposition {
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName();
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName();
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile();
}
simple-http-4.1.21/src/org/simpleframework/http/core/DispositionParser.java 0000664 0000000 0000000 00000021740 12536602605 0027076 0 ustar 00root root 0000000 0000000 /*
* DispositionParser.java February 2007
*
* Copyright (C) 2007, Niall Gallagher DispositionParser object is used to represent a
* parser used to parse the Content-Disposition header. Its used when
* there is a multipart form upload to the server and allows the
* server to determine the individual part types.
*
* @author Niall Gallagher
*/
class DispositionParser extends Parser implements Disposition {
/**
* This is the buffer used to acquire values from the header.
*/
private ParseBuffer skip;
/**
* This is used to capture the name of the file if it is provided.
*/
private ParseBuffer file;
/**
* This is used to capture the name of the part if it is provided.
*/
private ParseBuffer name;
/**
* This is used to determine if the disposition is a file or form.
*/
private boolean form;
/**
* Constructor for the DispositionParser object. This
* is used to create a parser that can parse a disposition header
* which is typically sent as part of a multipart upload. It can
* be used to determine the type of the upload.
*/
public DispositionParser() {
this.file = new ParseBuffer();
this.name = new ParseBuffer();
this.skip = new ParseBuffer();
}
/**
* Constructor for the DispositionParser object. This
* is used to create a parser that can parse a disposition header
* which is typically sent as part of a multipart upload. It can
* be used to determine the type of the upload.
*
* @param text this is the header value that is to be parsed
*/
public DispositionParser(String text) {
this();
parse(text);
}
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName() {
return file.toString();
}
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName() {
return name.toString();
}
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile() {
return !form || file.length() > 0;
}
/**
* This will initialize the Parser when it is ready
* to parse a new String. This will reset the
* parser to a ready state. This method is invoked by the parser
* before the parse method is invoked, it is used to pack the
* contents of the header and clear any previous tokens used.
*/
protected void init() {
if(count > 0) {
pack();
}
clear();
}
/**
* This is used to clear all previously collected tokens. This
* allows the parser to be reused when there are multiple source
* strings to be parsed. Clearing of the tokens is performed
* when the parser is initialized.
*/
protected void clear() {
file.clear();
name.clear();
form = false;
off = 0;
}
/**
* This is the method that should be implemented to read the
* buffer. This method will extract the type from the header and
* the tries to extract the optional parameters if they are in
* the header. The optional parts are the file name and name.
*/
protected void parse() {
type();
parameters();
}
/**
* This is used to remove all whitespace characters from the
* String excluding the whitespace within literals.
* The definition of a literal can be found in RFC 2616.
* filename parameter within the set of parameters
* which are given to the type. The filename param and the
* the name are tokenized by this method.
*/
private void parameters(){
while(skip(";")){
if(skip("filename=")){
value(file);
} else {
if(skip("name=")) {
value(name);
} else {
parameter();
}
}
}
}
/**
* This will read the parameters from the header value. This will search
* for the filename parameter within the set of parameters
* which are given to the type. The filename param and the
* the name are tokenized by this method.
*/
private void parameter() {
name();
off++;
value(skip);
}
/**
* This will simply read all characters from the buffer before the first '='
* character. This represents a parameter name (see RFC 2616 for token). The
* parameter name is not buffered it is simply read from the buffer. This will
* not cause an IndexOutOfBoundsException as each offset
* is checked before it is acccessed.
*/
private void name(){
while(off < count){
if(buf[off] =='='){
break;
}
off++;
}
}
/**
* This is used to read a parameters value from the buf. This will read all
* char's upto but excluding the first terminal char
* encountered from the off within the buf, or if the value is a literal
* it will read a literal from the buffer (literal is any data between
* quotes except if the quote is prefixed with a backward slash character).
*/
private void value(ParseBuffer value){
if(quote(buf[off])){
for(off++; off < count;){
if(quote(buf[off])){
if(buf[++off-2]!='\\'){
break;
}
}
value.append(buf[off++]);
}
}else{
while(off < count){
if(buf[off] ==';') {
break;
}
value.append(buf[off]);
off++;
}
}
}
/**
* This method is used to determine if the specified character is a quote
* character. The quote character is typically used as a boundary for the
* values within the header. This accepts a single or double quote.
*
* @param ch the character to determine if it is a quotation
*
* @return true if the character provided is a quotation character
*/
private boolean quote(char ch) {
return ch == '\'' || ch == '"';
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/EmptyConsumer.java 0000664 0000000 0000000 00000003345 12536602605 0026230 0 ustar 00root root 0000000 0000000 /*
* EmptyConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher EmptyConsumer object is used to represent a body
* of zero length. This is the most common body consumer created as
* it represents the body for GET messages that have nothing within
* the body part.
*
* @author Niall Gallagher
*/
class EmptyConsumer extends BodyConsumer {
/**
* This method will not consume any bytes from the cursor. This
* ensures that the next byte read from the stream is the first
* character of the next HTTP message within the pipeline.
*
* @param cursor this is the cursor which will not be read from
*/
public void consume(Cursor cursor) {
return;
}
/**
* This will return true immediately. Because the empty consumer
* represents a zero length body and no bytes are read from the
* cursor, this should not be processed and return finished.
*
* @return this will always return true for the zero length body
*/
public boolean isFinished() {
return true;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/EmptyInputStream.java 0000664 0000000 0000000 00000002575 12536602605 0026714 0 ustar 00root root 0000000 0000000 /*
* EmptyInputStream.java October 2002
*
* Copyright (C) 2002, Niall Gallagher EmptyInputStream object provides a stream that
* is immediately empty. Each read method with this input stream
* will return a -1 value indicating that the stream has come to an
* end and no more data can be read from it.
*
* @author Niall Gallagher
*/
class EmptyInputStream extends InputStream {
/**
* This is used to provide a -1 value when an attempt is made to
* read from the stream. Implementing this method as so also
* ensures that all the other read methods return a -1 value.
*
* @return this returns a -1 when an attempt is made to read
*/
public int read() {
return -1;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/EmptyProducer.java 0000664 0000000 0000000 00000011012 12536602605 0026206 0 ustar 00root root 0000000 0000000 /*
* EmptyProducer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher EmptyProducer object is a producer used if there
* is not response body to be delivered. Typically this is used when
* the HTTP request method is HEAD or if there is some status code
* sent to the client that does not require a response body.
*
* @author Niall Gallagher
*/
class EmptyProducer implements Producer {
/**
* This is the monitor that is used to process the pipeline.
*/
private final Monitor monitor;
/**
* This is the sender that is passed to the monitor when ready.
*/
private final Sender sender;
/**
* Constructor for the EmptyProducer object. Once
* created this producer will signal the kernel the the next
* request is ready to read from the HTTP pipeline as there is
* no content to be delivered with this producer object.
*
* @param sender this is used to send to the underlying transport
* @param monitor this is used to deliver signals to the kernel
*/
public EmptyProducer(Sender sender, Monitor monitor) {
this.monitor = monitor;
this.sender = sender;
}
/**
* This method performs no operation. Because this producer is
* not required to generate a response body this will ignore all
* data that is provided to sent to the underlying transport.
*
* @param array this is the array of bytes to send to the client
*/
public void produce(byte[] array) throws IOException {
return;
}
/**
* This method performs no operation. Because this producer is
* not required to generate a response body this will ignore all
* data that is provided to sent to the underlying transport.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param size this is the number of bytes that are to be sent
*/
public void produce(byte[] array, int off, int size) throws IOException {
return;
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void produce(ByteBuffer buffer) throws IOException {
return;
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param size this is the number of bytes that are to be sent
*/
public void produce(ByteBuffer buffer, int off, int size) throws IOException {
return;
}
/**
* This method performs no operation. Because this producer is
* not required to generate a response body this will ignore all
* data that is provided to sent to the underlying transport.
*/
public void flush() throws IOException {
return;
}
/**
* This method performs no operation. Because this producer is
* not required to generate a response body this will ignore all
* data that is provided to sent to the underlying transport.
*/
public void close() throws IOException {
monitor.ready(sender);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Entity.java 0000664 0000000 0000000 00000006114 12536602605 0024667 0 ustar 00root root 0000000 0000000 /*
* Entity.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Entity object is used to represent the HTTP entity
* received from the client. The entity contains a header and body as
* well as the underlying Channel for the connection. If
* there is no body with the entity this will provide an empty body
* object which provides a zero length sequence of bytes.
*
* @author Niall Gallagher
*/
interface Entity {
/**
* This is used to acquire the body for this HTTP entity. This
* will return a body which can be used to read the content of
* the message, also if the request is multipart upload then all
* of the parts are provided as Part objects. Each
* part can then be read as an individual message.
*
* @return the body provided by the HTTP request message
*/
public Body getBody();
/**
* This provides the HTTP request header for the entity. This is
* always populated and provides the details sent by the client
* such as the target URI and the query if specified. Also this
* can be used to determine the method and protocol version used.
*
* @return the header provided by the HTTP request message
*/
public Header getHeader();
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session object for the entity
*/
public Session getSession(boolean create) throws LeaseException;
/**
* This provides the connected channel for the client. This is
* used to send and receive bytes to and from an transport layer.
* Each channel provided with an entity contains an attribute
* map which contains information about the connection.
*
* @return the connected channel for this HTTP entity
*/
public Channel getChannel();
}
simple-http-4.1.21/src/org/simpleframework/http/core/EntityCollector.java 0000664 0000000 0000000 00000014416 12536602605 0026542 0 ustar 00root root 0000000 0000000 /*
* EntityCollector.java October 2002
*
* Copyright (C) 2002, Niall Gallagher EntityCollector object is used to collect all of
* the data used to form a request entity. This will collect the
* data fragment by fragment from the underlying transport. When
* all of the data is consumed and the entity is created and then
* it is sent to the Selector object for processing.
* When the request has completed the next request can be collected
* from the underlying transport using a new collector object.
*
* @author Niall Gallagher
*/
class EntityCollector implements Collector {
/**
* This is used to consume the request entity from the channel.
*/
private final Consumer entity;
/**
* This is used to build the entity for its constituent parts.
*/
private final Builder builder;
/**
* This is the channel used to acquire the underlying data.
*/
private final Channel channel;
/**
* This is the cursor used to read and reset the data.
*/
private final Cursor cursor;
/**
* The EntityCollector object used to collect the
* data from the underlying transport. In order to collect a body
* this must be given an Allocator which is used to
* create an internal buffer to store the consumed body.
*
* @param allocator this is the allocator used to buffer data
* @param tracker this is the tracker used to create sessions
* @param channel this is the channel used to read the data
*/
public EntityCollector(Allocator allocator, Tracker tracker, Channel channel) {
this.builder = new TrackerBuilder(tracker, channel);
this.entity = new BuilderConsumer(allocator, builder, channel);
this.cursor = channel.getCursor();
this.channel = channel;
}
/**
* This is used to collect the data from a Channel
* which is used to compose the entity. If at any stage there
* are no ready bytes on the socket the selector provided can be
* used to queue the collector until such time as the socket is
* ready to read. Also, should the entity have completed reading
* all required content it is handed to the selector as ready,
* which processes the entity as a new client HTTP request.
*
* @param selector this is the selector used to queue this
*/
public void collect(Selector selector) throws IOException {
while(cursor.isReady()) {
if(entity.isFinished()) {
break;
} else {
entity.consume(cursor);
}
}
// XXX What happens to the socket connection here
if(cursor.isOpen()) { // reject if closed from client side
if(entity.isFinished()) {
selector.ready(this);
} else {
selector.select(this);
}
}
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session object for the entity
*/
public Session getSession(boolean create) throws LeaseException {
return builder.getSession(create);
}
/**
* This provides the HTTP request header for the entity. This is
* always populated and provides the details sent by the client
* such as the target URI and the query if specified. Also this
* can be used to determine the method and protocol version used.
*
* @return the header provided by the HTTP request message
*/
public Header getHeader() {
return builder.getHeader();
}
/**
* This is used to acquire the body for this HTTP entity. This
* will return a body which can be used to read the content of
* the message, also if the request is multipart upload then all
* of the parts are provided as Part objects. Each
* part can then be read as an individual message.
*
* @return the body provided by the HTTP request message
*/
public Body getBody() {
return builder.getBody();
}
/**
* This provides the connected channel for the client. This is
* used to send and receive bytes to and from an transport layer.
* Each channel provided with an entity contains an attribute
* map which contains information about the connection.
*
* @return the connected channel for this HTTP entity
*/
public Channel getChannel() {
return builder.getChannel();
}
/**
* This returns the socket channel that is used by the collector
* to read content from. This is a selectable socket, in that
* it can be registered with a Java NIO selector. This ensures
* that the system can be notified when the socket is ready.
*
* @return the socket channel used by this collector object
*/
public SocketChannel getSocket() {
return channel.getSocket();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Expectation.java 0000664 0000000 0000000 00000004711 12536602605 0025677 0 ustar 00root root 0000000 0000000 /*
* Expectation.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Expectation object is used to send the expect
* continue status if required. This is delivered to the client to
* tell the client that the server is willing to accept the
* request body. Once this is sent the transport will likely wait
* until there is a read ready event.
*
* @author Niall Gallagher
*/
class Expectation {
/**
* This is the status code that is sent to prompt the client.
*/
private static final byte[] STATUS = { 'H', 'T','T', 'P', '/','1','.', '1',' ', '1','0','0',' '};
/**
* This is the optional description for the expect status code.
*/
private static final byte[] MESSAGE = {'C','o','n','t','i','n','u','e', '\r','\n','\r','\n'};
/**
* This is the sender that is used to deliver the continue.
*/
private final Sender sender;
/**
* Constructor for the Expectation object. This will
* create an object that will deliver the continue status code.
* Because the transport performs an asynchronous write this will
* not block the execution of this method and delay execution.
*
* @param channel this is the channel used to deliver the prompt
*/
public Expectation(Channel channel) {
this.sender = channel.getSender();
}
/**
* This will execute the continue if the header contains the
* expectation header. If there is no expectation then this will
* return without sending anything back to the connected client.
*
* @param header this is the header read from the channel
*/
public void execute(Header header) throws IOException {
if(header.isExpectContinue()) {
sender.send(STATUS);
sender.send(MESSAGE);
sender.flush();
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/FixedConsumer.java 0000664 0000000 0000000 00000012451 12536602605 0026167 0 ustar 00root root 0000000 0000000 /*
* FixedConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher FixedConsumer object reads a fixed number of bytes
* from the cursor. This is typically used when the Content-Length
* header is used as the body delimiter. In order to determine when
* the full body has been consumed this counts the bytes read. Once
* all the bytes have been read any overflow will be reset. All of the
* bytes read are appended to the internal buffer so they can be read.
*
* @author Niall Gallagher
*/
class FixedConsumer extends UpdateConsumer {
/**
* This is the allocator used to allocate the buffer used.
*/
private Allocator allocator;
/**
* This is the internal buffer used to accumulate the body.
*/
private Buffer buffer;
/**
* This is the number of bytes to be consumed from the cursor.
*/
private int limit;
/**
* Constructor for the FixedConsumer object. This is
* used to create a consumer that reads a fixed number of bytes
* from the cursor and accumulates those bytes in an internal
* buffer so that it can be read at a later stage.
*
* @param allocator this is used to allocate the internal buffer
* @param limit this is the number of bytes that are to be read
*/
public FixedConsumer(Allocator allocator, int limit) {
this.allocator = allocator;
this.limit = limit;
}
/**
* This will acquire the contents of the body in UTF-8. If there
* is no content encoding and the user of the request wants to
* deal with the body as a string then this method can be used.
* It will simply create a UTF-8 string using the body bytes.
*
* @return returns a UTF-8 string representation of the body
*/
@Override
public String getContent() throws IOException {
if(buffer == null) {
return new String();
}
return buffer.encode();
}
/**
* This will acquire the contents of the body in the specified
* charset. Typically this will be given the charset as taken
* from the HTTP Content-Type header. Although any encoding can
* be specified to convert the body to a string representation.
*
* @param charset this is the charset encoding to be used
*
* @return returns an encoded string representation of the body
*/
@Override
public String getContent(String charset) throws IOException {
if(buffer == null) {
return new String();
}
return buffer.encode(charset);
}
/**
* This is used to acquire the contents of the body as a stream.
* Each time this method is invoked a new stream is created that
* will read the contents of the body from the first byte. This
* ensures that the stream can be acquired several times without
* any issues arising from previous reads.
*
* @return this returns a new string used to read the body
*/
@Override
public InputStream getInputStream() throws IOException {
if(buffer == null) {
return new EmptyInputStream();
}
return buffer.getInputStream();
}
/**
* This is used to process the bytes that have been read from the
* cursor. This will count the number of bytes read, once all of
* the bytes that form the body have been read this returns the
* number of bytes that represent the overflow.
*
* @param array this is a chunk read from the cursor
* @param off this is the offset within the array the chunk starts
* @param count this is the number of bytes within the array
*
* @return this returns the number of bytes overflow that is read
*/
@Override
protected int update(byte[] array, int off, int count) throws IOException {
int mark = limit;
if(count >= limit) {
append(array, off, mark);
finished = true;
limit = 0;
return count - mark;
}
if(count > 0) {
append(array, off, count);
limit -= count;
}
return 0;
}
/**
* This method is used to allocate the internal buffer. If there
* has already been a call to this method the previous instance
* is returned. If there is any issue allocating the buffer then
* this will throw an exception.
*
* @return this returns the buffer to append the bytes to
*/
@Override
protected Buffer allocate() throws IOException {
if(buffer == null) {
buffer = allocator.allocate(limit);
}
return buffer;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/FixedProducer.java 0000664 0000000 0000000 00000015327 12536602605 0026164 0 ustar 00root root 0000000 0000000 /*
* FixedProducer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher FixedProducer object produces content without any
* encoding, but limited to a fixed number of bytes. This is used if
* the length of the content being delivered is know beforehand. It
* will simply count the number of bytes being send and signal the
* server kernel that the next request is ready to read once all of
* the bytes have been sent to the client.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.FixedConsumer
*/
class FixedProducer implements Producer{
/**
* This is the monitor used to notify the initiator of events.
*/
private Monitor monitor;
/**
* This is the underlying sender used to deliver the raw data.
*/
private Sender sender;
/**
* This is the number of bytes that have been sent so far.
*/
private int count;
/**
* This is the number of bytes this producer is limited to.
*/
private int limit;
/**
* Constructor for the FixedProducer object. This is
* used to create a producer that will count the number of bytes
* that are sent over the pipeline, once all bytes have been sent
* this will signal that the next request is ready to read.
*
* @param sender this is used to send to the underlying transport
* @param monitor this is used to deliver signals to the kernel
* @param limit this is used to limit the number of bytes sent
*/
public FixedProducer(Sender sender, Monitor monitor, int limit) {
this.monitor = monitor;
this.sender = sender;
this.limit = limit;
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
*/
public void produce(byte[] array) throws IOException {
produce(array, 0, array.length);
}
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 complaint format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(byte[] array, int off, int len) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(array, off, len);
if(len > 0) {
produce(buffer);
}
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void produce(ByteBuffer buffer) throws IOException {
int mark = buffer.position();
int size = buffer.limit();
if(mark > size) {
throw new ProducerException("Buffer position greater than limit");
}
produce(buffer, 0, size - mark);
}
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void produce(ByteBuffer buffer, int off, int len) throws IOException {
int size = Math.min(len, limit - count);
try {
if(monitor.isClosed()) {
throw new ProducerException("Response content complete");
}
sender.send(buffer, off, size);
if(count + size == limit) {
monitor.ready(sender);
}
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error sending response", cause);
}
count += size;
}
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException {
try {
if(!monitor.isClosed()) {
sender.flush();
}
} catch(Exception cause) {
if(sender != null) {
monitor.error(sender);
}
throw new ProducerException("Error flushing", cause);
}
}
/**
* This is used to signal to the producer that all content has
* been written and the user no longer needs to write. This will
* either close the underlying transport or it will notify the
* monitor that the response has completed and the next request
* can begin. This ensures the content is flushed to the client.
*/
public void close() throws IOException {
if(!monitor.isClosed()) {
if(count < limit) {
monitor.error(sender);
} else {
monitor.ready(sender);
}
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/FlushMonitor.java 0000664 0000000 0000000 00000012010 12536602605 0026034 0 ustar 00root root 0000000 0000000 /*
* FlushMonitor.java February 2007
*
* Copyright (C) 2007, Niall Gallagher FlushMonitor object is used to monitor response
* streams. If there is an error or a close requested this will
* close the underlying transport. If however there is a successful
* response then this will flush the transport and hand the channel
* for the pipeline back to the server kernel. This ensures that
* the next HTTP request can be consumed from the transport.
*
* @author Niall Gallagher
*/
class FlushMonitor implements Monitor {
/**
* This is the initiator used to initiate a new request.
*/
private Initiator reactor;
/**
* This is the channel associated with the client connection.
*/
private Channel channel;
/**
* This flag determines whether the connection was closed.
*/
private boolean closed;
/**
* This flag determines whether the was a response error.
*/
private boolean error;
/**
* Constructor for the FlushMonitor object. This is
* used to create a monitor using a HTTP request entity and an
* initiator which is used to reprocess a channel if there was a
* successful deliver of a response.
*
* @param reactor this is the reactor used to process channels
* @param entity this is the entity associated with the channel
*/
public FlushMonitor(Initiator reactor, Entity entity) {
this.channel = entity.getChannel();
this.reactor = reactor;
}
/**
* This is used to close the underlying transport. A closure is
* typically done when the response is to a HTTP/1.0 client
* that does not require a keep alive connection. Also, if the
* container requests an explicit closure this is used when all
* of the content for the response has been sent.
*
* @param sender this is the sender used to send the response
*/
public void close(Sender sender) {
try {
if(!isClosed()) {
closed = true;
sender.close();
}
} catch(Exception e) {
fail(sender);
}
}
/**
* This is used when there is an error sending the response. On
* error RFC 2616 suggests a connection closure is the best
* means to handle the condition, and the one clients should be
* expecting and support. All errors result in closure of the
* underlying transport and no more requests are processed.
*
* @param sender this is the sender used to send the response
*/
public void error(Sender sender) {
try {
if(!isClosed()) {
error = true;
sender.close();
}
} catch(Exception e) {
fail(sender);
}
}
/**
* This is used when the response has been sent correctly and
* the connection supports persisted HTTP. When ready the channel
* is handed back in to the server kernel where the next request
* on the pipeline is read and used to compose the next entity.
*
* @param sender this is the sender used to send the response
*/
public void ready(Sender sender) {
try {
if(!isClosed()) {
closed = true;
sender.flush();
reactor.start(channel);
}
} catch(Exception e) {
fail(sender);
}
}
/**
* This is used to purge the sender so that it closes the socket
* ensuring there is no connection leak on shutdown. This is used
* when there is an exception signaling the state of the sender.
*
* @param sender this is the sender that is to be purged
*/
private void fail(Sender sender) {
try {
sender.close();
} catch(Exception e) {
return;
}
}
/**
* This is used to determine if the response has completed or
* if there has been an error. This basically allows the sender
* of the response to take action on certain I/O events.
*
* @return this returns true if there was an error or close
*/
public boolean isClosed() {
return closed || error;
}
/**
* This is used to determine if the response was in error. If
* the response was in error this allows the sender to throw an
* exception indicating that there was a problem responding.
*
* @return this returns true if there was a response error
*/
public boolean isError(){
return error;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/FormCreator.java 0000664 0000000 0000000 00000014050 12536602605 0025634 0 ustar 00root root 0000000 0000000 /*
* FormCreator.java October 2002
*
* Copyright (C) 2002, Niall Gallagher FormCreator object is used to create the form.
* It is created using the request URI query and a form post body if
* sent, also if the request is a multipart upload the text parts
* are added to the form. Building a single object form multiple
* sources within the request ensures there is a single convenient
* means to access the data from the request.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.Form
*/
class FormCreator {
/**
* This is the request that is used to acquire the data.
*/
private final Request request;
/**
* This is used to acquire the content from the request body.
*/
private final Body body;
/**
* Constructor for the FormCreator object. This will
* create an object that can be used to construct a single form
* from the multiple sources of data within the request entity.
*
* @param request this is the request used to acquire the data
* @param entity this is the entity that contains the data
*/
public FormCreator(Request request, Entity entity) {
this.body = entity.getBody();
this.request = request;
}
/**
* This is used to acquire a Form using all of the
* parameters from the request URI as well as a form post if
* it exists, finally all the text parts from an upload are
* added to the form. This ensures that all data is accessible.
*
* @return this returns the form created from the request
*/
public Form getInstance() throws IOException {
PartList list = getParts();
Query form = getQuery();
for(Part part : list) {
String name = part.getName();
String value = part.getContent();
form.put(name, value);
}
return new PartForm(body, form);
}
/**
* This method is used to acquire the query part from the HTTP
* request URI target and a form post if it exists. Both the
* query and the form post are merge together in a single query.
*
* @return the query associated with the HTTP target URI
*/
private Query getQuery() throws IOException {
Query query = request.getQuery();
if(!isFormPost()) {
return query;
}
return getQuery(query); // only get if form
}
/**
* This method is used to acquire the query part from the HTTP
* request URI target and a form post if it exists. Both the
* query and the form post are merge together in a single query.
*
* @param query this is the URI query string to be used
*
* @return the query associated with the HTTP target URI
*/
private Query getQuery(Query query) throws IOException {
String body = request.getContent();
if(body == null) {
return query;
}
return new QueryForm(query, body);
}
/**
* This method provides all parts for this body. The parts for a
* body can contain text parameters or files. Each file part can
* contain headers, which are the typical HTTP headers. Typically
* headers describe the content and any encoding if required.
*
* @return this returns a list of parts for this body
*/
private PartList getParts() {
PartList list = body.getParts();
if(list.isEmpty()) {
return list;
}
return getParts(list);
}
/**
* This method provides all parts for this body. The parts for a
* body can contain text parameters or files. Each file part can
* contain headers, which are the typical HTTP headers. Typically
* headers describe the content and any encoding if required.
*
* @param body this is the part list taken from the body
*
* @return this returns a list of parts for this body
*/
private PartList getParts(PartList body) {
PartList list = new PartList();
for(Part part : body) {
if(!part.isFile()) {
list.add(part);
}
}
return list;
}
/**
* This is used to determine if the content type is a form POST
* of type application/x-www-form-urlencoded. Such a type is
* used when a HTML form is used to post data to the server.
*
* @return this returns true if content type is a form post
*/
private boolean isFormPost() {
ContentType type = request.getContentType();
if(type == null) {
return false;
}
return isFormPost(type);
}
/**
* This is used to determine if the content type is a form POST
* of type application/x-www-form-urlencoded. Such a type is
* used when a HTML form is used to post data to the server.
*
* @param type the type to determine if its a form post
*
* @return this returns true if content type is a form post
*/
private boolean isFormPost(ContentType type) {
String primary = type.getPrimary();
String secondary = type.getSecondary();
if(!primary.equals("application")) {
return false;
}
return secondary.equals("x-www-form-urlencoded");
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Header.java 0000664 0000000 0000000 00000017627 12536602605 0024616 0 ustar 00root root 0000000 0000000 /*
* Header.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Header object that is used to represent a
* basic form for the HTTP request message. This is used to extract
* values such as the request line and header values from the request
* message. Access to header values is done case insensitively.
* Path object that is
* provided by this method is immutable, it represents the
* normalized path only part from the request URI.
*
* @return this returns the normalized path for the request
*/
public Path getPath();
/**
* This method is used to acquire the query part from the
* HTTP request URI target. This will return only the values
* that have been extracted from the request URI target.
*
* @return the query associated with the HTTP target URI
*/
public Query getQuery();
/**
* This can be used to get the HTTP method for this request. The
* HTTP specification RFC 2616 specifies the HTTP request methods
* in section 9, Method Definitions. Typically this will be a
* GET or POST method, but can be any valid alphabetic token.
*
* @return the HTTP method that this request has specified
*/
public String getMethod();
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major protocol type, that
* is the 1 of a HTTP/1.1 version string. Typically the major
* type is 1, by can be 0 for HTTP/0.9 clients.
*
* @return the major version number for the HTTP message
*/
public int getMajor();
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corresponds to the minor protocol type, that
* is the 0 of a HTTP/1.0 version string. This number is typically
* used to determine whether persistent connections are supported.
*
* @return the minor version number for the HTTP message
*/
public int getMinor();
/**
* This method is used to get a List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public ListCookie object. Otherwise this method will
* return null. Each cookie object will contain the name, value
* and path of the cookie as well as the optional domain part.
*
* @param name this is the name of the cookie object to acquire
*
* @return this returns a cookie object from the header or null
*/
public Cookie getCookie(String name);
/**
* This is used to acquire all cookies that were sent in the header.
* If any cookies exists within the HTTP header they are returned
* as Cookie objects. Otherwise this method will an
* empty list. Each cookie object will contain the name, value and
* path of the cookie as well as the optional domain part.
*
* @return this returns all cookie objects from the HTTP header
*/
public ListAccept-Language header.
* This provides an indication as to the languages that the client
* accepts. It provides the locales in preference order.
*
* @return this returns the locales preferred by the client
*/
public ListHeaderConsumer object is used to consume a HTTP
* header from the cursor. This extends the segment consumer with
* methods specific to the header. Also this enables session cookies
* to be created using the cookies extracted from the header.
*
* @author Niall Gallagher
*/
abstract class HeaderConsumer extends SegmentConsumer implements Header {
/**
* This is the policy object used to create the session cookie.
*/
private Policy policy;
/**
* Constructor for the HeaderConsumer object. This
* is used to create a consumer capable of reading a header from
* a provided cursor. All methods of the Header
* interface are implemented in this object.
*/
protected HeaderConsumer() {
this.policy = new SecurePolicy(this);
}
/**
* This is used to see if there is a HTTP message header with the
* given name in this container. If there is a HTTP message header
* with the specified name then this returns true otherwise false.
*
* @param name the HTTP message header to get the value from
*
* @return this returns true if the HTTP message header exists
*/
public boolean contains(String name) {
return header.contains(name);
}
/**
* This can be used to get the date of the first message header
* that has the specified name. This is a convenience method that
* avoids having to deal with parsing the value of the requested
* HTTP message header. This returns -1 if theres no HTTP header
* value for the specified name.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the date as a long from the header value
*/
public long getDate(String name) {
return header.getDate(name);
}
/**
* This can be used to get the integer of the first message header
* that has the specified name. This is a convenience method that
* avoids having to deal with parsing the value of the requested
* HTTP message header. This returns -1 if theres no HTTP header
* value for the specified name.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the date as a long from the header value
*/
public int getInteger(String name) {
return header.getInteger(name);
}
/**
* This method is used to get a List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public ListCookie object. Otherwise this method will
* return null. Each cookie object will contain the name, value
* and path of the cookie as well as the optional domain part.
*
* @param name this is the name of the cookie object to acquire
*
* @return this returns a cookie object from the header or null
*/
public Cookie getCookie(String name) {
return header.getCookie(name);
}
/**
* This is used to acquire the session cookie for the request. The
* session cookie is either sent with the HTTP request header or
* it can be created if required. This ensures that if no cookie
* has been sent one can be created on demand.
*
* @param create if true the session cookie will be created
*
* @return the cookie associated with the session or null
*/
public Cookie getSession(boolean create) {
return policy.getSession(create);
}
/**
* This is used to acquire all cookies that were sent in the header.
* If any cookies exists within the HTTP header they are returned
* as Cookie objects. Otherwise this method will an
* empty list. Each cookie object will contain the name, value and
* path of the cookie as well as the optional domain part.
*
* @return this returns all cookie objects from the HTTP header
*/
public ListInitiator represents an interface in to the main
* processor for the server kernel. It is used to read and parse a
* new HTTP request from the connected socket and dispatch that
* request to the Container when ready. All channels
* begin at the initiator, and when a request has finished it is
* passed back in to the initiator to further process requests from
* the HTTP pipeline.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Monitor
*/
interface Initiator {
/**
* This is used to initiate the processing of the channel. Once
* the channel is passed in to the initiator any bytes ready on
* the HTTP pipeline will be processed and parsed in to a HTTP
* request. When the request has been built a callback is made
* to the Container to process the request. Also
* when the request is completed the channel is passed back in
* to the initiator so that the next request can be dealt with.
*
* @param channel the channel to process the request from
*/
public void start(Channel channel) throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/Message.java 0000664 0000000 0000000 00000040647 12536602605 0025010 0 ustar 00root root 0000000 0000000 /*
* Message.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Message object is used to store an retrieve the
* headers for both a request and response. Headers are stored and
* retrieved in a case insensitive manner according to RFC 2616.
* The message also allows multiple header values to be added to a
* single header name, headers such as Cookie and Set-Cookie can be
* added multiple times with different values.
*
* @author Niall Gallagher
*/
class Message {
/**
* This is used to store the cookies added to the HTTP header.
*/
private final KeyMapMessage object. This is used
* to create a case insensitive means for storing HTTP header
* names and values. Dates can also be added to message as a
* long value and is converted to RFC 1123 compliant date string.
*/
public Message() {
this.cookies = new KeyMapgetValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, String value) {
ListgetValue in combination with the get methods.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void set(String name, int value) {
set(name, String.valueOf(value));
}
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTP date string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
* This will perform a remove using the issued header
* name before the header value is set.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void setDate(String name, long date) {
set(name, parser.convert(date));
}
/**
* This can be used to add a HTTP message header to this object.
* The name and value of the HTTP message header will be used to
* create a HTTP message header object which can be retrieved using
* the getValue in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, String value) {
ListgetInteger in combination with the get methods.
*
* @param name the name of the HTTP message header to be added
* @param value the value the HTTP message header will have
*/
public void add(String name, int value) {
add(name, String.valueOf(value));
}
/**
* This is used as a convenience method for adding a header that
* needs to be parsed into a HTTPdate string. This will convert
* the date given into a date string defined in RFC 2616 sec 3.3.1.
*
* @param name the name of the HTTP message header to be added
* @param date the value constructed as an RFC 1123 date string
*/
public void addDate(String name, long date) {
add(name, parser.convert(date));
}
/**
* This can be used to get the value of the first message header
* that has the specified name. This will return the full string
* representing the named header value. If the named header does
* not exist then this will return a null value.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public String getValue(String name) {
ListCookie object stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If the cookie does
* not exist under the specified name this will return null.
*
* @param name this is the name of the cookie to be retrieved
*
* @return returns the Cookie by the given name
*/
public Cookie getCookie(String name) {
return cookies.get(name);
}
/**
* This returns all Cookie objects stored under the
* specified name. This is used to retrieve cookies that have been
* set with the setCookie methods. If there are no
* cookies then this will return an empty list.
*
* @return returns all the Cookie in the response
*/
public ListsetCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
* This is a convenience method that avoids cookie creation.
*
* @param name this is the cookie to be added to the response
* @param value this is the cookie value that is to be used
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(String name, String value) {
return setCookie(new Cookie(name, value, true));
}
/**
* The setCookie method is used to set a cookie value
* with the cookie name. This will add a cookie to the response
* stored under the name of the cookie, when this is committed it
* will be added as a Set-Cookie header to the resulting response.
*
* @param cookie this is the cookie to be added to the response
*
* @return returns the cookie that has been set in the response
*/
public Cookie setCookie(Cookie cookie) {
String name = cookie.getName();
if(name != null) {
cookies.put(name, cookie);
}
return cookie;
}
/**
* This can be used to get the values of HTTP message headers
* that have the specified name. This is a convenience method that
* will present that values as tokens extracted from the header.
* This has obvious performance benefits as it avoids having to
* deal with substring and trim calls.
* substring and trim calls.
* Entry object is used to represent a list of
* HTTP header value for a given name. It allows multiple values
* to exist for a given header, such as the Cookie header. Most
* entries will contain a single value.
*
* @author Niall Gallagher
*/
private class Entry {
/**
* Contains the header values that belong to the entry name.
*/
private ListEntry object. The entry is
* created using the name of the HTTP header. Values can be
* added to the entry list in order to build up the header.
*
* @param name this is the name of the HTTP header to use
*/
public Entry(String name) {
this.value = new ArrayListMonitor object is core to how the requests are
* processed from a pipeline. This monitors the progress of the
* response streams as they are written to the underlying transport
* which is typically TCP. If at any point there is an error in
* the delivery of the response the monitor is notified. It can
* then shutdown the connection, as RFC 2616 suggests on errors.
* Channel back to the server kernel so that
* the next request can be processed. This ensures ordering of the
* responses matches ordering of the requests.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Initiator
*/
interface Monitor {
/**
* This is used to close the underlying transport. A closure is
* typically done when the response is to a HTTP/1.0 client
* that does not require a keep alive connection. Also, if the
* container requests an explicit closure this is used when all
* of the content for the response has been sent.
*
* @param sender this is the sender used to send the response
*/
public void close(Sender sender);
/**
* This is used when there is an error sending the response. On
* error RFC 2616 suggests a connection closure is the best
* means to handle the condition, and the one clients should be
* expecting and support. All errors result in closure of the
* underlying transport and no more requests are processed.
*
* @param sender this is the sender used to send the response
*/
public void error(Sender sender);
/**
* This is used when the response has been sent correctly and
* the connection supports persisted HTTP. When ready the channel
* is handed back in to the server kernel where the next request
* on the pipeline is read and used to compose the next entity.
*
* @param sender this is the sender used to send the response
*/
public void ready(Sender sender);
/**
* This is used to determine if the response has completed or
* if there has been an error. This basically allows the sender
* of the response to take action on certain I/O events.
*
* @return this returns true if there was an error or close
*/
public boolean isClosed();
/**
* This is used to determine if the response was in error. If
* the response was in error this allows the sender to throw an
* exception indicating that there was a problem responding.
*
* @return this returns true if there was a response error
*/
public boolean isError();
} simple-http-4.1.21/src/org/simpleframework/http/core/PartBodyConsumer.java 0000664 0000000 0000000 00000011673 12536602605 0026661 0 ustar 00root root 0000000 0000000 /*
* PartBodyConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartBodyConsumer object is used to consume a part
* the contents of a multipart body. This will consume the part and
* add it to a part list, once the part has been consumed and added
* to the part list a terminal token is consumed, which is a carriage
* return and line feed.
*
* @author Niall Gallagher
*/
class PartBodyConsumer extends BodyConsumer {
/**
* This is the token that is consumed after the content body.
*/
private static final byte[] LINE = { '\r', '\n' };
/**
* This is used to consume the content from the multipart upload.
*/
private ContentConsumer content;
/**
* This is used to consume the final terminal token from the part.
*/
private Consumer token;
/**
* Constructor for the PartBodyConsumer object. This
* is used to create a consumer that reads the body of a part in
* a multipart request body. The terminal token must be provided
* so that the end of the part body can be determined.
*
* @param allocator this is used to allocate the internal buffer
* @param segment this represents the headers for the part body
* @param boundary this is the message boundary for the body part
*/
public PartBodyConsumer(Allocator allocator, Segment segment, byte[] boundary) {
this(allocator, segment, new PartList(), boundary);
}
/**
* Constructor for the PartBodyConsumer object. This
* is used to create a consumer that reads the body of a part in
* a multipart request body. The terminal token must be provided
* so that the end of the part body can be determined.
*
* @param allocator this is used to allocate the internal buffer
* @param segment this represents the headers for the part body
* @param list this is the part list that this body belongs in
* @param boundary this is the message boundary for the body part
*/
public PartBodyConsumer(Allocator allocator, Segment segment, PartList list, byte[] boundary) {
this.content = new ContentConsumer(allocator, segment, list, boundary);
this.token = new TokenConsumer(allocator, LINE);
}
/**
* This is used to consume the part body from the cursor. This
* initially reads the body of the part, which represents the
* actual payload exposed via the Part interface
* once the payload has been consumed the terminal is consumed.
*
* @param cursor this is the cursor to consume the body from
*/
public void consume(Cursor cursor) throws IOException {
while(cursor.isReady()) {
if(content.isFinished()) {
if(token.isFinished()) {
break;
}
token.consume(cursor);
} else {
content.consume(cursor);
}
}
}
/**
* This is used to determine whether the part body has been read
* from the cursor successfully. In order to determine if all of
* the bytes have been read successfully this will check to see
* of the terminal token had been consumed.
*
* @return true if the part body and terminal have been read
*/
public boolean isFinished() {
return token.isFinished();
}
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @return this returns a string representing the content
*/
@Override
public String getContent() throws IOException {
return content.getContent();
}
/**
* This is used to acquire an InputStream for the
* part. Acquiring the stream allows the content of the part to
* be consumed by reading the stream. Each invocation of this
* method will produce a new stream starting from the first byte.
*
* @return this returns the stream for this part object
*/
@Override
public InputStream getInputStream() throws IOException {
return content.getInputStream();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartConsumer.java 0000664 0000000 0000000 00000010332 12536602605 0026032 0 ustar 00root root 0000000 0000000 /*
* PartConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartConsumer object is used to consume a part
* from a part list. A part consists of a header and a body, which
* can be either a simple chunk of data or another part list. This
* must be able to cope with either a simple body or a part list.
*
* @author Niall Gallagher
*/
class PartConsumer implements Consumer {
/**
* This is used to consume the header message of the part.
*/
private SegmentConsumer header;
/**
* This is used to consume the body data from the part.
*/
private BodyConsumer body;
/**
* This is used to determine what type the body data is.
*/
private PartFactory factory;
/**
* This is the current consumer used to read from the cursor.
*/
private Consumer current;
/**
* This is used to add the consumed parts to when finished.
*/
private PartList list;
/**
* This is the terminal token that ends the part payload.
*/
private byte[] terminal;
/**
* Constructor for the PartConsumer object. This is
* used to create a consumer used to read the contents of a part
* and the boundary that terminates the content. Any parts that
* are created by this are added to the provided part list.
*
* @param allocator this is the allocator used to creat buffers
* @param list this is the part list used to store the parts
* @param terminal this is the terminal token for the part
*/
public PartConsumer(Allocator allocator, PartList list, byte[] terminal) {
this.header = new PartHeaderConsumer(allocator);
this.factory = new PartFactory(allocator, header);
this.terminal = terminal;
this.current = header;
this.list = list;
}
/**
* This is used to create a new body consumer used to consume the
* part body from for the list. This will ensure that the part
* data is created based on the part header consumed. The types
* of part supported are part lists and part body.
*
* @return this returns a consumed for the part content
*/
private BodyConsumer getConsumer() throws IOException {
return factory.getInstance(list, terminal);
}
/**
* This is used to consume the part body from the cursor. This
* initially reads the body of the part, which represents the
* actual payload exposed via the Part interface
* once the payload has been consumed the terminal is consumed.
*
* @param cursor this is the cursor to consume the body from
*/
public void consume(Cursor cursor) throws IOException {
while(cursor.isReady()) {
if(header.isFinished()) {
if(body == null) {
body = getConsumer();
current = body;
} else {
if(body.isFinished())
break;
}
}
current.consume(cursor);
}
}
/**
* This is used to determine whether the part body has been read
* from the cursor successfully. In order to determine if all of
* the bytes have been read successfully this will check to see
* of the terminal token had been consumed.
*
* @return true if the part body and terminal have been read
*/
public boolean isFinished() {
if(body != null) {
return body.isFinished();
}
return false;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartEntryConsumer.java 0000664 0000000 0000000 00000007322 12536602605 0027061 0 ustar 00root root 0000000 0000000 /*
* PartEntryConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartEntryConsumer object is used to consume each
* part from the part list. This is combines the task of consuming
* the part, which consists of a header and a body, and a boundary
* which identifies the end of the message content.
*
* @author Niall Gallagher
*/
class PartEntryConsumer implements Consumer {
/**
* This is used to consume the boundary at the end of a part.
*/
private BoundaryConsumer boundary;
/**
* This is used to consume the actual part from the list.
*/
private Consumer consumer;
/**
* Constructor for the PartEntryConsumer object. This
* is used to create a consumer that will read the message part
* and the boundary that terminates the part. All contents that
* are read are appended to an internal buffer.
*
* @param allocator this is the allocator used for the buffer
* @param list this is the list used to accumulate the parts
* @param terminal this is the terminal token for the part list
*/
public PartEntryConsumer(Allocator allocator, PartList list, byte[] terminal) {
this.consumer = new PartConsumer(allocator, list, terminal);
this.boundary = new BoundaryConsumer(allocator, terminal);
}
/**
* This is used to consume the part body from the cursor. This
* initially reads the body of the part, which represents the
* actual content exposed via the Part interface
* once the content has been consumed the terminal is consumed.
*
* @param cursor this is the cursor to consume the body from
*/
public void consume(Cursor cursor) throws IOException {
while(cursor.isReady()) {
if(!boundary.isFinished()) {
boundary.consume(cursor);
} else {
if(consumer.isFinished()) {
break;
}
if(boundary.isEnd()) {
break;
}
consumer.consume(cursor);
}
}
}
/**
* This is used to determine whether the part body has been read
* from the cursor successfully. In order to determine if all of
* the bytes have been read successfully this will check to see
* of the terminal token had been consumed.
*
* @return true if the part body and terminal have been read
*/
public boolean isFinished() {
if(boundary.isEnd()) {
return true;
}
return consumer.isFinished();
}
/**
* This is used to determine whether the terminal token read is
* the final terminal token. The final terminal token is a
* normal terminal token, however it ends with two hyphens and
* a carriage return line feed, this ends the part list.
*
* @return true if this was the last part within the list
*/
public boolean isEnd() {
return boundary.isEnd();
}
} simple-http-4.1.21/src/org/simpleframework/http/core/PartEntryFactory.java 0000664 0000000 0000000 00000004711 12536602605 0026674 0 ustar 00root root 0000000 0000000 /*
* PartEntryFactory.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartEntryFactory object provides a factory for
* creating part entry consumers. The part entry consumers created
* read individual entries from a list of parts within a stream.
* This is basically a convenience factory for the list consumer.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.PartListConsumer
*/
class PartEntryFactory {
/**
* This is used to allocate the buffers used by the entry.
*/
private Allocator allocator;
/**
* This is used to accumulate all the parts of the upload.
*/
private PartList list;
/**
* This is the terminal token used to delimiter the upload.
*/
private byte[] terminal;
/**
* Constructor for the PartEntryFactory object.
* This is used to create a factory for entry consumers that
* can be used to read an entry from a part list.
*
* @param allocator this is the allocator used for buffers
* @param list this is the list of parts that are extracted
* @param terminal this is the terminal buffer to be used
*/
public PartEntryFactory(Allocator allocator, PartList list, byte[] terminal) {
this.allocator = allocator;
this.terminal = terminal;
this.list = list;
}
/**
* This creates a new part entry consumer that can be used to
* read the next part from the list. The consumer instantiated
* by this factory acquires the allocator, list and boundary
* from the enclosing part list consumer instance.
*
* @return a part entry consumer for this part list consumer
*/
public PartEntryConsumer getInstance() {
return new PartEntryConsumer(allocator, list, terminal);
}
} simple-http-4.1.21/src/org/simpleframework/http/core/PartFactory.java 0000664 0000000 0000000 00000005220 12536602605 0025646 0 ustar 00root root 0000000 0000000 /*
* PartFactory.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartFactory represents a factory for creating the
* consumers that are used to read a multipart upload message. This
* supports two types of consumers for the multipart upload, lists
* and bodies. A part list is basically a collection of parts and or
* part lists. The part type is determined from the part header.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.PartListConsumer
* @see org.simpleframework.http.core.PartBodyConsumer
*/
class PartFactory extends ConsumerFactory {
/**
* Constructor for the PartFactory object. This is
* used to create a factory using a buffer allocator, which will
* create a buffer for accumulating the entire message body,
* also to ensure the correct part type is created this requires
* the header information for the part.
*
* @param allocator this is used to allocate the internal buffer
* @param header this is used to determine the part type
*/
public PartFactory(Allocator allocator, Segment header) {
super(allocator, header);
}
/**
* This method is used to create the consumer given the list and
* boundary for the part. In order to determine the part type
* this will consult the header consumed for the part. Depending
* on whether it is a list or body a suitable consumer is created.
*
* @param list this is the list used to collect the parts
* @param boundary this is the boundary used to terminate the part
*
* @return this will return the consumer for the part body
*/
public BodyConsumer getInstance(PartList list, byte[] boundary) throws IOException {
byte[] terminal = getBoundary(segment);
if(isPart(segment)) {
return new PartListConsumer(allocator, list, terminal);
}
return new PartBodyConsumer(allocator, segment, list, boundary);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartForm.java 0000664 0000000 0000000 00000025430 12536602605 0025147 0 ustar 00root root 0000000 0000000 /*
* PartForm.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartForm is a form that delegates to a body to
* get any parts requested. This combines both the query and the body
* in to a single object which can be used to acquire all data that
* has been sent by the client in a single convenient location. All
* changes made to this form will be made to the underlying query.
*
* @author Niall Gallagher
*/
class PartForm implements Form {
/**
* This is the query used to acquire the request parameters.
*/
private final Query query;
/**
* This is the body used to acquire the uploaded parts.
*/
private final Body body;
/**
* Constructor for the PartForm object. This is used
* to create a form using the parameters from the query and the
* parts from the specified body. Combining both objects under a
* single instance provides a convenient means to find data.
*
* @param body this is the body that contains all the parts
* @param query this is the query used to get parameters
*/
public PartForm(Body body, Query query) {
this.query = query;
this.body = body;
}
/**
* This extracts an integer parameter for the named value. If the
* named parameter does not exist this will return a zero value.
* If however the parameter exists but is not in the format of a
* decimal integer value then this will throw an exception.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as an integer
*/
public int getInteger(Object name) {
return query.getInteger(name);
}
/**
* This extracts a float parameter for the named value. If the
* named parameter does not exist this will return a zero value.
* If however the parameter exists but is not in the format of a
* floating point number then this will throw an exception.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as a float
*/
public float getFloat(Object name) {
return query.getFloat(name);
}
/**
* This extracts a boolean parameter for the named value. If the
* named parameter does not exist this will return false otherwise
* the value is evaluated. If it is either true or
* false then those boolean values are returned.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as an float
*/
public boolean getBoolean(Object name) {
return query.getBoolean(name);
}
/**
* This method is used to acquire a Part from the
* form using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) {
return body.getPart(name);
}
/**
* This method provides all parts for this Form. The
* parts for a form can contain text parameters or files. Each file
* part can contain headers, which take the form of HTTP headers to
* describe the payload. Typically headers describe the content.
*
* @return this returns a list of parts for this form
*/
public Listget method is used to acquire the value for
* a named pair. So if a pair of name=value has been parsed and
* inserted into the collection of values this will return the
* value given the name. The value returned will be a string.
*
* @param name this is a string used to search for the value
*
* @return this is the value, as a string, that has been found
*/
public String get(Object name) {
return query.get(name);
}
/**
* This method is used to acquire a List for all of
* the values that have been put in to the map. The list allows
* all values associated with the specified key. This enables a
* parser to collect a number of associated values.
*
* @param name this is the key used to search for the value
*
* @return this is the list of values associated with the key
*/
public Listsize is zero then the
* parser is empty and this returns true. The is acts as a
* proxy the the isEmpty of the internal map.
*
* @return this is true if there are no available values
*/
public boolean isEmpty() {
return query.isEmpty();
}
/**
* This is used to acquire the names for all the values that
* have currently been collected by this parser. This is used
* to determine which values have been extracted from the
* source. It is useful when the values have to be gathered.
*
* @return the set of name values that have been extracted
*/
public Setput method is used to insert the name and
* value provided into the collection of values. Although it is
* up to the parser to decide what values will be inserted it
* is generally the case that the inserted values will be text.
*
* @param name this is the name string from a name=value pair
* @param value this is the value string from a name=value pair
*
* @return this returns the previous value if there was any
*/
public String put(String name, String value) {
return query.put(name, value);
}
/**
* This method is used to insert a collection of values into
* the parsers map. This is used when another source of values
* is required to populate the connection currently maintained
* within this parsers internal map. Any values that currently
* exist with similar names will be overwritten by this.
*
* @param map this is the collection of values to be added
*/
public void putAll(Map map) {
query.putAll(map);
}
/**
* The remove method is used to remove the named
* value pair from the collection of values. This acts like a
* take, in that it will get the value string and remove if
* from the collection of values the parser has stored.
*
* @param name this is a string used to search for the value
*
* @return this is the value, as a string, that is removed
*/
public String remove(Object name) {
return query.remove(name);
}
/**
* This obviously enough provides the number of values that
* have been inserted into the internal map. This acts as
* a proxy method for the internal map size.
*
* @return this returns the number of values are available
*/
public int size() {
return query.size();
}
/**
* This method is used to acquire the value for all values that
* have currently been collected by this parser. This is used
* to determine which values have been extracted from the
* source. It is useful when the values have to be gathered.
*
* @return the list of value strings that have been extracted
*/
public Collectionclear method is used to wipe out all the
* currently existing values from the collection. This is used
* to recycle the parser so that it can be used to parse some
* other source of values without any lingering state.
*/
public void clear() {
query.clear();
}
/**
* This will return all parameters represented using the HTTP
* URL query format. The x-www-form-urlencoded
* format is used to encode the attributes, see RFC 2616.
* PartHeaderConsumer object is used to consume the
* header for a multipart message. This performs a parse of the
* HTTP headers within the message up to the terminal carriage return
* and line feed token. Once this had been read the contents of the
* header are appended to a buffer so they can be read later.
*
* @author Niall Gallagher
*/
class PartHeaderConsumer extends SegmentConsumer {
/**
* This is used to allocate the internal buffer for the header.
*/
private Allocator allocator;
/**
* This is the internal buffer used to store the header.
*/
private Buffer buffer;
/**
* Constructor for the PartHeaderConsumer object. An
* allocator is required so that the header consumer can create a
* buffer to store the contents of the consumed message.
*
* @param allocator this is the allocator used to create a buffer
*/
public PartHeaderConsumer(Allocator allocator) {
this.allocator = allocator;
}
/**
* This is used to process the header consumer once all of the
* headers have been read. This will simply parse all of the
* headers and append the consumed bytes to the internal buffer.
* Appending the bytes ensures that the whole upload can be
* put back together as a single byte stream if required.
*/
@Override
protected void process() throws IOException {
headers();
append();
}
/**
* This is used to allocate the internal buffer and append the
* consumed bytes to the buffer. Once the header is added to
* the internal buffer this is finished and the next part of
* the upload can be consumed.
*/
private void append() throws IOException {
if(buffer == null) {
buffer = allocator.allocate(count);
}
buffer.append(array, 0, count);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartList.java 0000664 0000000 0000000 00000005136 12536602605 0025160 0 ustar 00root root 0000000 0000000 /*
* PartList.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartList object represents an ordered list of
* parts that were uploaded within a HTTP entity body. This allows
* the parts to be iterated over, or if required accessed by name.
* In order to access the Part object by name it must
* have had a name within the Content-Disposition header.
*
* @author Niall Gallagher
*/
class PartList extends ArrayListPartList object. This is used
* to create an order list of parts that is used by the request
* to access the individual parts uploaded with a HTTP body.
*/
public PartList() {
this.map = new KeyMapPart from the
* list using a known name for the part. This is a convenient
* way to access a part when the name for the part is known.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) {
return map.get(name);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/PartListConsumer.java 0000664 0000000 0000000 00000017677 12536602605 0026711 0 ustar 00root root 0000000 0000000 /*
* PartListConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher PartListConsumer object is used to consume a list
* of parts encoded in the multipart format. This is can consume any
* number of parts from a cursor. Each part consumed is added to an
* internal part list which can be used to acquire the contents of the
* upload and inspect the headers provided for each uploaded part. To
* ensure that only a fixed number of bytes are consumed this uses a
* content length for an internal buffer.
*
* @author Niall Gallagher
*/
class PartListConsumer extends BodyConsumer {
/**
* This is used to consume individual parts from the part list.
*/
private PartEntryConsumer consumer;
/**
* This is the factory that is used to create the consumers used.
*/
private PartEntryFactory factory;
/**
* This is used to both allocate and buffer the part list body.
*/
private BufferAllocator buffer;
/**
* This is used to accumulate all the parts of the upload.
*/
private PartList list;
/**
* Constructor for the PartListConsumer object. This
* will create a consumer that is capable of breaking an upload in
* to individual parts so that they can be accessed and used by
* the receiver of the HTTP request message.
*
* @param allocator this is used to allocate the internal buffer
* @param boundary this is the boundary used for the upload
*/
public PartListConsumer(Allocator allocator, byte[] boundary) {
this(allocator, boundary, 8192);
}
/**
* Constructor for the PartListConsumer object. This
* will create a consumer that is capable of breaking an upload in
* to individual parts so that they can be accessed and used by
* the receiver of the HTTP request message.
*
* @param allocator this is used to allocate the internal buffer
* @param boundary this is the boundary used for the upload
* @param length this is the number of bytes the upload should be
*/
public PartListConsumer(Allocator allocator, byte[] boundary, int length) {
this(allocator, new PartList(), boundary, length);
}
/**
* Constructor for the PartListConsumer object. This
* will create a consumer that is capable of breaking an upload in
* to individual parts so that they can be accessed and used by
* the receiver of the HTTP request message.
*
* @param allocator this is used to allocate the internal buffer
* @param boundary this is the boundary used for the upload
* @param list this is the part list used to accumulate the parts
*/
public PartListConsumer(Allocator allocator, PartList list, byte[] boundary) {
this(allocator, list, boundary, 8192);
}
/**
* Constructor for the PartListConsumer object. This
* will create a consumer that is capable of breaking an upload in
* to individual parts so that they can be accessed and used by
* the receiver of the HTTP request message.
*
* @param allocator this is used to allocate the internal buffer
* @param boundary this is the boundary used for the upload
* @param length this is the number of bytes the upload should be
* @param list this is the part list used to accumulate the parts
*/
public PartListConsumer(Allocator allocator, PartList list, byte[] boundary, int length) {
this.buffer = new BufferAllocator(allocator, length);
this.consumer = new PartEntryConsumer(buffer, list, boundary);
this.factory = new PartEntryFactory(buffer, list, boundary);
this.list = list;
}
/**
* This is used to consume the part list from the cursor. This
* initially reads the list of parts, which represents the
* actual content exposed via the PartList object,
* once the content has been consumed the terminal is consumed.
*
* @param cursor this is the cursor to consume the list from
*/
public void consume(Cursor cursor) throws IOException {
while(cursor.isReady()) {
if(!consumer.isFinished()) {
consumer.consume(cursor);
} else {
if(!consumer.isEnd()) {
consumer = factory.getInstance();
} else {
break;
}
}
}
}
/**
* This is used to determine whether the part body has been read
* from the cursor successfully. In order to determine if all of
* the bytes have been read successfully this will check to see
* of the terminal token had been consumed.
*
* @return true if the part body and terminal have been read
*/
public boolean isFinished() {
return consumer.isEnd();
}
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @return this returns a string representing the content
*/
@Override
public String getContent() throws IOException {
return buffer.encode();
}
/**
* This is used to acquire the content of the part as a string.
* The encoding of the string is taken from the content type.
* If no content type is sent the content is decoded in the
* standard default of ISO-8859-1.
*
* @param charset this is the character encoding to be used
*
* @return this returns a string representing the content
*/
@Override
public String getContent(String charset) throws IOException {
return buffer.encode(charset);
}
/**
* This is used to acquire an InputStream for the
* part. Acquiring the stream allows the content of the part to
* be consumed by reading the stream. Each invocation of this
* method will produce a new stream starting from the first byte.
*
* @return this returns the stream for this part object
*/
@Override
public InputStream getInputStream() throws IOException {
return buffer.getInputStream();
}
/**
* This method is used to acquire a Part from the
* body using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
@Override
public Part getPart(String name) {
return list.getPart(name);
}
/**
* This method provides all parts for this body. The parts for a
* body can contain text parameters or files. Each file part can
* contain headers, which are the typical HTTP headers. Typically
* headers describe the content and any encoding if required.
*
* @return this returns a list of parts for this body
*/
@Override
public PartList getParts() {
return list;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Policy.java 0000664 0000000 0000000 00000003075 12536602605 0024655 0 ustar 00root root 0000000 0000000 /*
* Policy.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Policy object represents a policy for creating
* session cookies. This governs the cookie name used and the value
* that is created for the cookie. Typically the cookie value needs
* to be a unique identifier such as the time of creation or an
* incrementing number.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Header
*/
interface Policy {
/**
* This is used to acquire the session cookie for the request. The
* session cookie is either sent with the HTTP request header or
* it can be created if required. This ensures that if no cookie
* has been sent one can be created on demand.
*
* @param create if true the session cookie will be created
*
* @return the cookie associated with the session or null
*/
public Cookie getSession(boolean create);
}
simple-http-4.1.21/src/org/simpleframework/http/core/Producer.java 0000664 0000000 0000000 00000010470 12536602605 0025176 0 ustar 00root root 0000000 0000000 /*
* Producer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Producer object is used to produce content from
* the HTTP response. This acts in much the same way as an output
* stream would. As a requirement of RFC 2616 any HTTP/1.1 compliant
* server must support a set of transfer types. These are fixed size,
* chunked encoded, and connection close. A producer implementation
* is required to implement one of this formats for delivery of the
* response message.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Monitor
*/
interface Producer {
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
*/
public void produce(byte[] array) throws IOException;
/**
* This method is used to encode the provided array of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param size this is the number of bytes that are to be sent
*/
public void produce(byte[] array, int off, int size) throws IOException;
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void produce(ByteBuffer buffer) throws IOException;
/**
* This method is used to encode the provided buffer of bytes in
* a HTTP/1.1 compliant format and sent it to the client. Once
* the data has been encoded it is handed to the transport layer
* within the server, which may choose to buffer the data if the
* content is too small to send efficiently or if the socket is
* not write ready.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param size this is the number of bytes that are to be sent
*/
public void produce(ByteBuffer buffer, int off, int size) throws IOException;
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException;
/**
* This is used to signal to the producer that all content has
* been written and the user no longer needs to write. This will
* either close the underlying transport or it will notify the
* monitor that the response has completed and the next request
* can begin. This ensures the content is flushed to the client.
*/
public void close() throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/ProducerException.java 0000664 0000000 0000000 00000004017 12536602605 0027055 0 ustar 00root root 0000000 0000000 /*
* ProducerException.java February 2007
*
* Copyright (C) 2001, Niall Gallagher ProducerException object is used to represent an
* exception that is thrown when there is a problem producing the
* response body. This can be used to wrap IOException
* objects that are thrown from the underlying transport.
*
* @author Niall Gallagher
*/
class ProducerException extends IOException {
/**
* Constructor for the ProducerException object. This
* is used to represent an exception that is thrown when producing
* the response body. The producer exception is an I/O exception
* and thus exceptions can propagate out of stream methods.
*
* @param message this is the message describing the exception
*/
public ProducerException(String message) {
super(message);
}
/**
* Constructor for the ProducerException object. This
* is used to represent an exception that is thrown when producing
* the response body. The producer exception is an I/O exception
* and thus exceptions can propagate out of stream methods.
*
* @param message this is the message describing the exception
* @param cause this is the cause of the producer exception
*/
public ProducerException(String message, Throwable cause) {
super(message);
initCause(cause);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ProducerFactory.java 0000664 0000000 0000000 00000007756 12536602605 0026543 0 ustar 00root root 0000000 0000000 /*
* ProducerFactory.java February 2007
*
* Copyright (C) 2001, Niall Gallagher ProducerFactory is used to create a producer to
* match the HTTP header sent with the response. This interprets the
* headers within the response and composes a producer that will
* match those. Producers can be created to send in chunked encoding
* format, as well as fixed length and connection close for HTTP/1.0.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Transfer
*/
class ProducerFactory {
/**
* This is used to determine the semantics of the HTTP pipeline.
*/
private final Conversation support;
/**
* This is the monitor used to notify the initiator of events.
*/
private final Monitor monitor;
/**
* This is the underlying sender used to deliver the raw data.
*/
private final Sender sender;
/**
* Constructor for the ProducerFactory object. This
* is used to create producers that can encode data in a HTTP
* compliant format. Each producer created will produce its data
* and deliver it to the specified sender, should an I/O events
* occur such as an error, or completion of the response then
* the monitor is notified and the server kernel takes action.
*
* @param support this contains details regarding the semantics
* @param sender this is used to send to the underlying transport
* @param monitor this is used to deliver signals to the kernel
*/
public ProducerFactory(Conversation support, Sender sender, Monitor monitor) {
this.support = support;
this.sender = sender;
this.monitor = monitor;
}
/**
* This is used to create an a Producer object that
* can be used to produce content according to the HTTP header.
* If the request was from a HTTP/1.0 client that did not ask
* for keep alive connection semantics a simple close producer
* is created. Otherwise the content is chunked encoded or sent
* according the the Content-Length.
*
* @return this returns the producer used to send the response
*/
public Producer getInstance() throws IOException {
boolean keepAlive = support.isKeepAlive();
boolean chunkable = support.isChunkedEncoded();
if(!keepAlive) {
return new CloseProducer(sender, monitor);
}
return getInstance(chunkable);
}
/**
* This is used to create an a Producer object that
* can be used to produce content according to the HTTP header.
* If the request was from a HTTP/1.0 client that did not ask
* for keep alive connection semantics a simple close producer
* is created. Otherwise the content is chunked encoded or sent
* according the the Content-Length.
*
* @param chunkable does the connected client support chunked
*
* @return this returns the producer used to send the response
*/
private Producer getInstance(boolean chunkable) throws IOException {
int length = support.getContentLength();
if(!support.isHead()) {
if(length > 0) {
return new FixedProducer(sender, monitor, length);
}
if(chunkable) {
return new ChunkedProducer(sender, monitor);
}
}
return new EmptyProducer(sender, monitor);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/QueryForm.java 0000664 0000000 0000000 00000011214 12536602605 0025341 0 ustar 00root root 0000000 0000000 /*
* QueryForm.java May 2003
*
* Copyright (C) 2003, Niall Gallagher QueryForm is used to parse several text strings
* as a complete URL encoded parameter string. This will do the
* following concatenations.
*
*
* null + "a=b&c=d&e=f" = "a=b&c=d&e=f"
* "a=b" + "e=f&g=h" = "a=b&e=f&g=h";
* "a=b&c=d&e=f" + "" = "a=b&c=d&e=f"
*
*
* This ensures that the QueryForm can parse the list
* of strings as a single URL encoded parameter string. This can
* parse any number of parameter strings.
*
* @author Niall Gallagher
*/
class QueryForm extends QueryParser {
/**
* Constructor that allows a list of string objects to be
* parsed as a single parameter string. This will check
* each string to see if it is empty, that is, is either
* null or the zero length string.
*
* @param list this is a list of query values to be used
*/
public QueryForm(String... list) {
this.parse(list);
}
/**
* Constructor that allows an array of string objects to
* be parsed as a single parameter string. This will check
* each string to see if it is empty, that is, is either
* null or the zero length string.
*
* @param query this is the query from the HTTP header
* @param list this is the list of strings to be parsed
*/
public QueryForm(Query query, String... list) {
this.add(query);
this.parse(list);
}
/**
* Constructor that allows an array of string objects to
* be parsed as a single parameter string. This will check
* each string to see if it is empty, that is, is either
* null or the zero length string.
*
* @param query this is the query from the HTTP header
* @param post this is the query from the HTTP post body
*/
public QueryForm(Query query, Query post) {
this.add(query);
this.add(post);
}
/**
* This will concatenate the list of parameter strings as a
* single parameter string, before handing it to be parsed
* by the parse(String) method. This method
* will ignore any null or zero length strings in the array.
*
* @param list this is the list of strings to be parsed
*/
public void parse(String[] list) {
StringBuilder text = new StringBuilder();
for(int i = 0; i < list.length; i++) {
if(list[i] == null) {
continue;
} else if(list[i].length()==0){
continue;
} else if(text.length() > 0){
text.append("&");
}
text.append(list[i]);
}
parse(text);
}
/**
* This is used to perform a parse of the form data that is in
* the provided string builder. This will simply convert the
* data in to a string and parse it in the normal fashion.
*
* @param text this is the buffer to be converted to a string
*/
private void parse(StringBuilder text) {
if(text != null){
ensureCapacity(text.length());
count = text.length();
text.getChars(0, count, buf,0);
parse();
}
}
/**
* This method is used to insert a collection of tokens into
* the parsers map. This is used when another source of tokens
* is required to populate the connection currently maintained
* within this parsers internal map. Any tokens that currently
* exist with similar names will be overwritten by this.
*
* @param query this is the collection of tokens to be added
*/
private void add(Query query) {
SetReader object is used to read the bytes to form
* a request entity. In order to execute a read operation the socket
* must be read ready. This is determined using the socket object,
* which is registered with a selector. If at any point the reading
* results in an error the operation is canceled and the collector
* is closed, which shuts down the connection.
*
* @author Niall Gallagher
*
* @see org.simpleframework.transport.reactor.Reactor
*/
class Reader implements Operation {
/**
* This is the selector used to process the collection events.
*/
private final Selector source;
/**
* This is the collector used to consume the entity bytes.
*/
private final Collector task;
/**
* This is the channel object associated with the collector.
*/
private final Channel channel;
/**
* Constructor for the Reader object. This requires
* a selector and a collector object in order to consume the data
* from the connected socket which forms a HTTP request entity.
*
* @param source the selector object used to process events
* @param task this is the task used to collect the entity
*/
public Reader(Selector source, Collector task){
this.channel = task.getChannel();
this.source = source;
this.task = task;
}
/**
* This is the SocketChannel used to determine if the
* connection has some bytes that can be read. If it contains any
* data then that data is read from and is used to compose the
* request entity, which consists of a HTTP header and body.
*
* @return this returns the socket for the connected pipeline
*/
public SocketChannel getChannel() {
return task.getSocket();
}
/**
* This run method is used to collect the bytes from
* the connected channel. If a sufficient amount of data is read
* from the socket to form a HTTP entity then the collector uses
* the Selector object to dispatch the request. This
* is sequence of events that occur for each transaction.
*/
public void run() {
try {
task.collect(source);
}catch(Throwable e){
cancel();
}
}
/**
* This is used to cancel the operation if it has timed out. If
* the retry is waiting too long to read content from the socket
* then the retry is canceled and the underlying transport is
* closed. This helps to clean up occupied resources.
*/
public void cancel() {
try {
channel.close();
} catch(Throwable e) {
return;
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/RequestConsumer.java 0000664 0000000 0000000 00000031651 12536602605 0026563 0 ustar 00root root 0000000 0000000 /*
* RequestConsumer.java February 2001
*
* Copyright (C) 2001, Niall Gallagher RequestConsumer object is used to parse the HTTP
* request line followed by the HTTP message headers. This parses the
* request URI such that the query parameters and path are extracted
* and normalized. It performs this using external parsers, which
* will remove and escaped characters and normalize the path segments.
* Finally this exposes the HTTP version used using the major and
* minor numbers sent with the HTTP request.
*
* @author Niall Gallagher
*/
class RequestConsumer extends HeaderConsumer {
/**
* This is the address parser used to parse the request URI.
*/
protected AddressParser parser;
/**
* This is the method token send with the HTTP request header.
*/
protected String method;
/**
* This represents the raw request URI in an unparsed form.
*/
protected String target;
/**
* This is the major version number of the HTTP request header.
*/
protected int major;
/**
* This is the minor version number of the HTTP request header.
*/
protected int minor;
/**
* Constructor for the RequestConsumer object. This
* is used to create a consumer which can consume a HTTP request
* header and provide the consumed contents via a known interface.
* This also further breaks down the request URI for convenience.
*/
public RequestConsumer() {
super();
}
/**
* This can be used to get the target specified for this HTTP
* request. This corrosponds to the URI sent in the request
* line. Typically this will be the path part of the URI, but
* can be the full URI if the request is a proxy request.
*
* @return the target URI that this HTTP request specifies
*/
public String getTarget() {
return target;
}
/**
* This is used to acquire the address from the request line.
* An address is the full URI including the scheme, domain,
* port and the query parts. This allows various parameters
* to be acquired without having to parse the target.
*
* @return this returns the address of the request line
*/
public Address getAddress() {
if(parser == null) {
parser = new AddressParser(target);
}
return parser;
}
/**
* This method is used to acquire the query part from the
* HTTP request URI target. This will return only the values
* that have been extracted from the request URI target.
*
* @return the query associated with the HTTP target URI
*/
public Query getQuery() {
return getAddress().getQuery();
}
/**
* This is used to acquire the path as extracted from the
* the HTTP request URI. The Path object that is
* provided by this method is immutable, it represents the
* normalized path only part from the request URI.
*
* @return this returns the normalized path for the request
*/
public Path getPath() {
return getAddress().getPath();
}
/**
* This can be used to get the HTTP method for this request. The
* HTTP specification RFC 2616 specifies the HTTP request methods
* in section 9, Method Definitions. Typically this will be a
* GET or POST method, but can be any valid alphabetic token.
*
* @return the HTTP method that this request has specified
*/
public String getMethod() {
return method;
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corrosponds to the major protocol type, that
* is the 1 of a HTTP/1.0 version string. Typically the major
* type is 1, by can be 0 for HTTP/0.9 clients.
*
* @return the major version number for the HTTP message
*/
public int getMajor() {
return major;
}
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corrosponds to the minor protocol type, that
* is the 0 of a HTTP/1.0 version string. This number is typically
* used to determine whether persistent connections are supported.
*
* @return the minor version number for the HTTP message
*/
public int getMinor() {
return minor;
}
/**
* This is used to see if there is a HTTP message header with the
* given name in this container. If there is a HTTP message header
* with the specified name then this returns true otherwise false.
*
* @param name the HTTP message header to get the value from
*
* @return this returns true if the HTTP message header exists
*/
public boolean contains(String name) {
return header.contains(name);
}
/**
* This can be used to get the date of the first message header
* that has the specified name. This is a convenience method that
* avoids having to deal with parsing the value of the requested
* HTTP message header. This returns -1 if theres no HTTP header
* value for the specified name.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the date as a long from the header value
*/
public long getDate(String name) {
return header.getDate(name);
}
/**
* This can be used to get the integer of the first message header
* that has the specified name. This is a convenience method that
* avoids having to deal with parsing the value of the requested
* HTTP message header. This returns -1 if theres no HTTP header
* value for the specified name.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the date as a long from the header value
*/
public int getInteger(String name) {
return header.getInteger(name);
}
/**
* This method is used to get a List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public ListAddress object which provides
* all the details of the target including the query part.
*/
private void target() {
Token token = new Token(pos, 0);
while(pos < count){
if(space(array[pos])){
pos++;
break;
}
token.size++;
pos++;
}
target = token.text();
}
/**
* This will parse HTTP method from the first line of the header
* and store the parsed string internally. The method is used to
* determine what action to take with the request, it also acts
* as a means to determine the semantics of the request.
*/
private void method() {
Token token = new Token(pos, 0);
while(pos < count){
if(space(array[pos])){
pos++;
break;
}
token.size++;
pos++;
}
method = token.text();
}
/**
* This will parse HTTP version from the first line of the header
* and store the parsed string internally. The method is used to
* determine what version of HTTP is being used. Typically this
* will be HTTP/1.1 however HTTP/1.0 must be supported and this
* has different connection semantics with regards to pipelines.
*/
protected void version() {
pos += 5; /* "HTTP/" */
major(); /* "1" */
pos++; /* "." */
minor(); /* "1" */
}
/**
* This will parse the header from the current offset and convert
* the bytes found into an int as it parses the digits it comes
* accross. This will cease to parse bytes when it encounters a
* non digit byte or the end of the readable bytes.
*/
private void major() {
while(pos < count){
if(!digit(array[pos])){
break;
}
major *= 10;
major += array[pos];
major -= '0';
pos++;
}
}
/**
* This will parse the header from the current offset and convert
* the bytes found into an int as it parses the digits it comes
* accross. This will cease to parse bytes when it encounters a
* non digit byte or the end of the readable bytes.
*/
private void minor() {
while(pos < count){
if(!digit(array[pos])){
break;
}
minor *= 10;
minor += array[pos];
minor -= '0';
pos++;
}
}
/**
* This is used to determine if a given ISO-8859-1 byte is a digit
* character, between an ISO-8859-1 0 and 9. If it is, this will
* return true otherwise it returns false.
*
* @param octet this is to be checked to see if it is a digit
*
* @return true if the byte is a digit character, false otherwise
*/
protected boolean digit(byte octet) {
return octet >= '0' && octet <= '9';
}
/**
* This is used to determine if a given ISO-8859-1 byte is a white
* space character, such as a tab or space. If it is, this will
* return true otherwise it returns false.
*
* @param octet this is to be checked to see if it is a space
*
* @return true if the byte is a space character, false otherwise
*/
protected boolean space(byte octet) {
switch(octet) {
case ' ': case '\r':
case '\n': case '\t':
return true;
default:
return false;
}
}
/**
* This is used to track the boundaries of a token so that it can
* be converted in to a usable string. This will track the length
* and offset within the consumed array of the token. When the
* token is to be used it can be converted in to a string.
*
* @author Niall Gallagher
*/
private class Token {
/**
* This is used to track the number of bytes within the array.
*/
public int size;
/**
* This is used to mark the start offset within the array.
*/
public int off;
/**
* Constructor for the Token object. This is used
* to create a new token to track the range of bytes that will
* be used to create a string representing the parsed value.
*
* @param off the starting offset for the token range
* @param size the number of bytes used for the token
*/
public Token(int off, int size) {
this.off = off;
this.size = size;
}
/**
* This is used to convert the byte range to a string. This
* will use UTF-8 encoding for the string which is compatible
* with the HTTP default header encoding of ISO-8859-1.
*
* @return the encoded string representing the token
*/
public String text() {
return text("UTF-8");
}
/**
* This is used to convert the byte range to a string. This
* will use specified encoding, if that encoding is not
* supported then this will return null for the token value.
*
* @return the encoded string representing the token
*/
public String text(String charset) {
try {
return new String(array, off, size, charset);
} catch(IOException e) {
return null;
}
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/RequestEntity.java 0000664 0000000 0000000 00000032361 12536602605 0026243 0 ustar 00root root 0000000 0000000 /*
* RequestEntity.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Request is used to provide an interface to the
* HTTP InputStream and message header. The stream can
* have certain characteristics, these characteristics are available
* by this object. The Request provides methods that
* allow the InputStream's semantics to be known, for
* example if the stream is keep-alive or if the stream has a length.
* Request origin is also retrievable from the
* Request as is the attributes Map object
* which defines specific connection attributes. And acts as a
* simple model for the request transaction.
* Request controls
* the processing of the HTTP pipeline. The next HTTP request is
* not processed until the request has read all of the content body
* within the InputStream. The stream must be fully
* read or closed for the next request to be processed.
*
* @author Niall Gallagher
*/
class RequestEntity extends RequestMessage implements Request {
/**
* This will create the form object using the query and body.
*/
private FormCreator builder;
/**
* This channel represents the connected pipeline used.
*/
private Channel channel;
/**
* The entity contains all the constituent request parts.
*/
private Entity entity;
/**
* The body contains the message content sent by the client.
*/
private Body body;
/**
* This is used to contain the values for this request.
*/
private Map map;
/**
* The form contains the parts and parameters of the request.
*/
private Form form;
/**
* Constructor for the RequestEntity object. This is
* used to create a request that contains all the parts sent by
* the client, including the headers and the request body. Each of
* the request elements are accessible through this object in a
* convenient manner, all parts and parameters, as well as cookies
* can be accessed and used without much effort.
*
* @param entity this is the entity that was sent by the client
* @param monitor this is the monitor used to monitor events
*/
public RequestEntity(Entity entity, Monitor monitor) {
this.builder = new FormCreator(this, entity);
this.channel = entity.getChannel();
this.header = entity.getHeader();
this.body = entity.getBody();
this.entity = entity;
}
/**
* This is used to determine if the request has been transferred
* over a secure connection. If the protocol is HTTPS and the
* content is delivered over SSL then the request is considered
* to be secure. Also the associated response will be secure.
*
* @return true if the request is transferred securely
*/
public boolean isSecure() {
return channel.isSecure();
}
/**
* This is a convenience method that is used to determine whether
* or not this message has the Connection header with the close
* token. If the close token is present then this stream is not a
* keep-alive connection. However if this has no Connection header
* then the keep alive status is determined by the HTTP version,
* that is HTTP/1.1 is keep alive by default, HTTP/1.0 has the
* connection close by default.
*
* @return returns true if this is keep alive connection
*/
public boolean isKeepAlive(){
if(contains("Connection")) {
return !contains("Connection", "close");
} else if(getMajor() > 1) {
return true;
} else if(getMajor() == 1) {
return getMinor() > 0;
}
return false;
}
/**
* This is used to acquire the remote client address. This can
* be used to acquire both the port and the I.P address for the
* client. It allows the connected clients to be logged and if
* require it can be used to perform course grained security.
*
* @return this returns the client address for this request
*/
public InetSocketAddress getClientAddress() {
SocketChannel socket = channel.getSocket();
Socket client = socket.socket();
return getClientAddress(client);
}
/**
* This is used to acquire the remote client address. This can
* be used to acquire both the port and the I.P address for the
* client. It allows the connected clients to be logged and if
* require it can be used to perform course grained security.
*
* @param socket this is the socket to get the address for
*
* @return this returns the client address for this request
*/
private InetSocketAddress getClientAddress(Socket socket) {
InetAddress address = socket.getInetAddress();
int port = socket.getPort();
return new InetSocketAddress(address, port);
}
/**
* This is used to get the content body. This will essentially get
* the content from the body and present it as a single string.
* The encoding of the string is determined from the content type
* charset value. If the charset is not supported this will throw
* an exception. Typically only text values should be extracted
* using this method if there is a need to parse that content.
*
* @return the body content containing the message body
*/
public String getContent() throws IOException {
ContentType type = getContentType();
if(type == null) {
return body.getContent("UTF-8");
}
return getContent(type);
}
/**
* This is used to get the content body. This will essentially get
* the content from the body and present it as a single string.
* The encoding of the string is determined from the content type
* charset value. If the charset is not supported this will throw
* an exception. Typically only text values should be extracted
* using this method if there is a need to parse that content.
*
* @param type this is the content type used with the request
*
* @return the input stream containing the message body
*/
public String getContent(ContentType type) throws IOException {
String charset = type.getCharset();
if(charset == null) {
charset = "UTF-8";
}
return body.getContent(charset);
}
/**
* This is used to read the content body. The specifics of the data
* that is read from this InputStream can be determined
* by the getContentLength method. If the data sent by
* the client is chunked then it is decoded, see RFC 2616 section
* 3.6. Also multipart data is available as Part objects
* however the raw content of the multipart body is still available.
*
* @return the input stream containing the message body
*/
public InputStream getInputStream() throws IOException {
return body.getInputStream();
}
/**
* This is used to read the content body. The specifics of the data
* that is read from this ReadableByteChannel can be
* determined by the getContentLength method. If the
* data sent by the client is chunked then it is decoded, see RFC
* 2616 section 3.6. This stream will never provide empty reads as
* the content is internally buffered, so this can do a full read.
*
* @return this returns the byte channel used to read the content
*/
public ReadableByteChannel getByteChannel() throws IOException {
InputStream source = getInputStream();
if(source != null) {
return Channels.newChannel(source);
}
return null;
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @return returns an active session object for the client
*/
public Session getSession() throws LeaseException {
return getSession(true);
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session object for the client
*/
public Session getSession(boolean create) throws LeaseException {
return entity.getSession(create);
}
/**
* This can be used to retrieve the response attributes. These can
* be used to keep state with the response when it is passed to
* other systems for processing. Attributes act as a convenient
* model for storing objects associated with the response. This
* also inherits attributes associated with the client connection.
*
* @return the attributes that have been added to this request
*/
public Map getAttributes() {
Map common = channel.getAttributes();
if(map == null) {
map = new HashMap(common);
}
return map;
}
/**
* This is used as a shortcut for acquiring attributes for the
* response. This avoids acquiring the attribute Map
* in order to retrieve the attribute directly from that object.
* The attributes contain data specific to the response.
*
* @param key this is the key of the attribute to acquire
*
* @return this returns the attribute for the specified name
*/
public Object getAttribute(Object key) {
return getAttributes().get(key);
}
/**
* This is used to provide quick access to the parameters. This
* avoids having to acquire the request Form object.
* This basically acquires the parameters object and invokes
* the getParameters method with the given name.
*
* @param name this is the name of the parameter value
*/
public String getParameter(String name) throws IOException {
if(form == null) {
form = builder.getInstance();
}
return form.get(name);
}
/**
* This method is used to acquire a Part from the
* form using a known name for the part. This is typically used
* when there is a file upload with a multipart POST request.
* All parts that are not files are added to the query values
* as strings so that they can be used in a convenient way.
*
* @param name this is the name of the part to acquire
*
* @return the named part or null if the part does not exist
*/
public Part getPart(String name) throws IOException {
if(form == null) {
form = builder.getInstance();
}
return form.getPart(name);
}
/**
* This is used to acquire all the form parameters from the
* HTTP request. This includes the query and POST data values
* as well as the parts of a multipart request. The form is
* a convenience object enabling easy access to state.
*
* @return this returns the form containing the state
*/
public Form getForm() throws IOException {
if(form == null) {
form = builder.getInstance();
}
return form;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/RequestMessage.java 0000664 0000000 0000000 00000030542 12536602605 0026352 0 ustar 00root root 0000000 0000000 /*
* RequestMessage.java February 2001
*
* Copyright (C) 2001, Niall Gallagher RequestMessage object is used to create a HTTP
* request header representation. All requests for details within a
* request message delegates to an underlying header, which contains
* all of the header names and values sent by the client. The header
* names are case insensitively mapped as required by RFC 2616.
*
* @author Niall Gallagher
*/
class RequestMessage implements RequestHeader {
/**
* This is the underlying header used to house the headers.
*/
protected Header header;
/**
* Constructor for the RequestMessage object. This
* is used to create a request message without an underlying
* header. In such an event it is up to the subclass to provide
* the instance, this is useful for testing the request.
*/
public RequestMessage() {
super();
}
/**
* Constructor for the RequestMessage object. This
* is used to create a request with a header instance. In such
* a case the header provided will be queried for headers and is
* used to store headers added to this message instance.
*
* @param header this is the backing header for the message
*/
public RequestMessage(Header header) {
this.header = header;
}
/**
* This can be used to get the URI specified for this HTTP
* request. This corresponds to the /index part of a
* http://www.domain.com/index URL but may contain the full
* URL. This is a read only value for the request.
*
* @return the URI that this HTTP request is targeting
*/
public String getTarget() {
return header.getTarget();
}
/**
* This is used to acquire the address from the request line.
* An address is the full URI including the scheme, domain, port
* and the query parts. This allows various parameters to be
* acquired without having to parse the raw request target URI.
*
* @return this returns the address of the request line
*/
public Address getAddress() {
return header.getAddress();
}
/**
* This is used to acquire the path as extracted from the HTTP
* request URI. The Path object that is provided by
* this method is immutable, it represents the normalized path
* only part from the request uniform resource identifier.
*
* @return this returns the normalized path for the request
*/
public Path getPath() {
return header.getPath();
}
/**
* This method is used to acquire the query part from the
* HTTP request URI target. This will return only the values
* that have been extracted from the request URI target.
*
* @return the query associated with the HTTP target URI
*/
public Query getQuery() {
return header.getQuery();
}
/**
* This can be used to get the HTTP method for this request. The
* HTTP specification RFC 2616 specifies the HTTP request methods
* in section 9, Method Definitions. Typically this will be a
* GET, POST or a HEAD method, although any string is possible.
*
* @return the request method for this request message
*/
public String getMethod() {
return header.getMethod();
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @return the major version number for the request message
*/
public int getMajor() {
return header.getMajor();
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @return the major version number for the request message
*/
public int getMinor() {
return header.getMinor();
}
/**
* This method is used to get a List of the names
* for the headers. This will provide the original names for the
* HTTP headers for the message. Modifications to the provided
* list will not affect the header, the list is a simple copy.
*
* @return this returns a list of the names within the header
*/
public Listsubstring and trim calls.
* Accept-Language header.
* This provides an indication as to the languages that the client
* accepts. It provides the locales in preference order.
*
* @return this returns the locales preferred by the client
*/
public ListCookie object. Otherwise this method will
* return null. Each cookie object will contain the name, value
* and path of the cookie as well as the optional domain part.
*
* @param name this is the name of the cookie object to acquire
*
* @return this returns a cookie object from the header or null
*/
public Cookie getCookie(String name) {
return header.getCookie(name);
}
/**
* This is used to acquire all cookies that were sent in the header.
* If any cookies exists within the HTTP header they are returned
* as Cookie objects. Otherwise this method will an
* empty list. Each cookie object will contain the name, value and
* path of the cookie as well as the optional domain part.
*
* @return this returns all cookie objects from the HTTP header
*/
public ListContent-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType() {
return header.getContentType();
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
public int getContentLength() {
return header.getContentLength();
}
/**
* This is used to provide a string representation of the header
* read. Providing a string representation of the header is used
* so that on debugging the contents of the delivered header can
* be inspected in order to determine a cause of error.
*
* @return this returns a string representation of the header
*/
public String toString() {
return header.toString();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ResponseEntity.java 0000664 0000000 0000000 00000040266 12536602605 0026414 0 ustar 00root root 0000000 0000000 /*
* ResponseEntity.java February 2001
*
* Copyright (C) 2001, Niall Gallagher OutputStream of the Response can be
* retrieved from this interface as can the I.P address of the client
* that will be receiving the Response. The attributes
* of the connection can be retrieved also. This provides a set of
* methods that can be used to set the attributes of the stream so
* the Response can be transported properly. The headers
* can be set and will be sent once a commit is made, or when there
* is content sent over the output stream.
* Response controls
* the processing of the HTTP pipeline. The next HTTP request is
* not processed until the response has committed. The response is
* committed once the commit method is invoked if there
* is NO content body. Committing with a content body is done only if
* correct content is given. The OutputStream acts as
* a client and commits the response once the specified content has
* been written to the issued OutputStream.
*
* @author Niall Gallagher
*/
class ResponseEntity extends ResponseMessage implements Response {
/**
* This is the conversation used to determine connection type.
*/
private Conversation support;
/**
* This is used to buffer the bytes that are sent to the client.
*/
private Accumulator buffer;
/**
* This is the underlying channel for the connected pipeline.
*/
private Channel channel;
/**
* This is the sender object used to deliver to response data.
*/
private Sender sender;
/**
* This is the header which contains the session cookie used.
*/
private Header header;
/**
* This is used to determine if the response has been committed.
*/
private boolean committed;
/**
* Constructor for the ResponseEntity object. This is
* used to create a response instance using the provided request,
* entity, and monitor object. To ensure that the response is
* compatible with client the Request is used. Also
* to ensure the next request can be processed the provided monitor
* is used to signal response events to the server kernel.
*
* @param request this is the request that was sent by the client
* @param entity this is the entity that contains the channel
* @param monitor this is the monitor used to signal events
*/
public ResponseEntity(Request request, Entity entity, Monitor monitor) {
this.support = new Conversation(request, this);
this.buffer = new Accumulator(support, entity, monitor);
this.channel = entity.getChannel();
this.sender = channel.getSender();
this.header = entity.getHeader();
}
/**
* This is used as a shortcut for acquiring attributes for the
* response. This avoids acquiring the Attributes
* in order to retrieve the attribute directly from that object.
* The attributes contain data specific to the response.
*
* @param name this is the name of the attribute to acquire
*
* @return this returns the attribute for the specified name
*/
public Object getAttribute(Object name) {
return getAttributes().get(name);
}
/**
* This can be used to retrieve certain attributes about
* this Response. The attributes contains certain
* properties about the Response. For example if
* this Response goes over a secure line then there may be any
* arbitrary attributes.
*
* @return the response attributes of that have been set
*/
public Map getAttributes() {
return channel.getAttributes();
}
/**
* This should be used when the size of the message body is known. For
* performance reasons this should be used so the length of the output
* is known. This ensures that Persistent HTTP (PHTTP) connections
* can be maintained for both HTTP/1.0 and HTTP/1.1 clients. If the
* length of the output is not known HTTP/1.0 clients will require a
* connection close, which reduces performance (see RFC 2616).
* OutputStream.close is used.
*
* @param length this is the length of the HTTP message body
*/
public void setContentLength(int length) {
set("Content-Length", length);
}
/**
* This determines the charset for PrintStream objects
* returned from the getPrintStream method. This will
* return a valid charset regardless of whether the Content-Type
* header has been set, set without a charset, or not set at all.
* If unspecified, the charset returned is ISO-8859-1,
* as suggested by RFC 2616, section 3.7.1.
*
* @return returns the charset used by this response object
*/
private String getCharset() {
ContentType type = getContentType();
if(type == null) {
return "iso-8859-1";
}
if(type.getCharset()==null){
return "iso-8859-1";
}
return type.getCharset();
}
/**
* Used to write a message body with the Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
*
* @return an output stream object used to write the message body
*/
public OutputStream getOutputStream() throws IOException {
return buffer;
}
/**
* Used to write a message body with the Response. The
* semantics of this OutputStream will be determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @param size the minimum size that the response buffer must be
*
* @return an output stream object used to write the message body
*/
public OutputStream getOutputStream(int size) throws IOException {
if(size > 0) {
buffer.expand(size);
}
return buffer;
}
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a buffer size of zero.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
*
* @return a print stream object used to write the message body
*/
public PrintStream getPrintStream() throws IOException {
return getPrintStream(0, getCharset());
}
/**
* This method is provided for convenience so that the HTTP content
* can be written using the print methods provided by
* the PrintStream. This will basically wrap the
* getOutputStream with a specified buffer size.
* PrintStream uses the charset used to
* describe the content, with the Content-Type header. This will
* check the charset parameter of the contents MIME type. So if
* the Content-Type was text/plain; charset=UTF-8 the
* resulting PrintStream would encode the written data
* using the UTF-8 encoding scheme. Care must be taken to ensure
* that bytes written to the stream are correctly encoded.
*
* @param size the minimum size that the response buffer must be
*
* @return a print stream object used to write the message body
*/
public PrintStream getPrintStream(int size) throws IOException {
return getPrintStream(size, getCharset());
}
/**
* This is used to wrap the getOutputStream object in
* a PrintStream, which will write content using a
* specified charset. The PrintStream created will not
* buffer the content, it will write directly to the underlying
* OutputStream where it is buffered (if there is a
* buffer size greater than zero specified). In future the buffer
* of the PrintStream may be usable.
*
* @param size the minimum size that the response buffer must be
* @param charset this is the charset used by the resulting stream
*
* @return a print stream that encodes in the given charset
*/
private PrintStream getPrintStream(int size, String charset) throws IOException {
if(size > 0) {
buffer.expand(size);
}
return new PrintStream(buffer, false, charset);
}
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel() throws IOException {
return buffer;
}
/**
* Used to write a message body with the Response. The
* semantics of this WritableByteChannel are determined
* by the HTTP version of the client, and whether or not the content
* length has been set, through the setContentLength
* method. If the length of the output is not known then the output
* is chunked for HTTP/1.1 clients and closed for HTTP/1.0 clients.
* reset method. This will
* enable the specified number of bytes to be written without
* committing the response. This specified size is the minimum size
* that the response buffer must be.
*
* @param size the minimum size that the response buffer must be
*
* @return a writable byte channel used to write the message body
*/
public WritableByteChannel getByteChannel(int size) throws IOException {
if(size > 0) {
buffer.expand(size);
}
return buffer;
}
/**
* This can be used to determine whether the Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @return true if the response has been fully committed
*/
public boolean isCommitted() {
return committed;
}
/**
* This is used to write the headers that where given to the
* Response. Any further attempts to give headers
* to the Response will be futile as only the headers
* that were given at the time of the first commit will be used
* in the message header.
* Response
* has been committed. This is true if the Response
* was committed, either due to an explicit invocation of the
* commit method or due to the writing of content. If
* the Response has committed the reset
* method will not work in resetting content already written.
*
* @throws IOException thrown if there is a problem resetting
*/
public void reset() throws IOException {
buffer.reset();
}
/**
* This is used to close the connection and commit the request.
* This provides the same semantics as closing the output stream
* and ensures that the HTTP response is committed. This will
* throw an exception if the response can not be committed.
*
* @throws IOException thrown if there is a problem writing
*/
public void close() throws IOException {
buffer.close();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/ResponseMessage.java 0000664 0000000 0000000 00000017733 12536602605 0026527 0 ustar 00root root 0000000 0000000 /*
* ResponseMessage.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ResponseMessage object represents the header used
* for a response. This is used to get and set the headers in a case
* insensitive manner. It is also used to manage the cookies that are
* send and received. Also, the status code and description can also
* be set through this object as well as the protocol version.
*
* @author Niall Gallagher
*/
class ResponseMessage extends Message implements ResponseHeader {
/**
* This is the text description used for the response status.
*/
private String text;
/**
* This is the major protocol version used for the response.
*/
private int major;
/**
* This is the minor protocol version used for the response.
*/
private int minor;
/**
* This is the status code used to identify the response type.
*/
private int code;
/**
* Constructor for the ResponseMessage object. This
* is used to create a response message with a default status code
* of 200 and a a protocol version of HTTP/1.1. If the response is
* a different status code or version these can be modified.
*/
public ResponseMessage() {
this.text = "OK";
this.code = 200;
this.major = 1;
this.minor = 1;
}
/**
* This represents the status code of the HTTP response.
* The response code represents the type of message that is
* being sent to the client. For a description of the codes
* see RFC 2616 section 10, Status Code Definitions.
*
* @return the status code that this HTTP response has
*/
public int getCode() {
return code;
}
/**
* This method allows the status for the response to be
* changed. This MUST be reflected the the response content
* given to the client. For a description of the codes see
* RFC 2616 section 10, Status Code Definitions.
*
* @param code the new status code for the HTTP response
*/
public void setCode(int code) {
this.code = code;
}
/**
* This can be used to retrieve the text of a HTTP status
* line. This is the text description for the status code.
* This should match the status code specified by the RFC.
*
* @return the message description of the response
*/
public String getText() {
return text;
}
/**
* This is used to set the text of the HTTP status line.
* This should match the status code specified by the RFC.
*
* @param text the descriptive text message of the status
*/
public void setText(String text) {
this.text = text;
}
/**
* This can be used to get the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @return the major version number for the request message
*/
public int getMajor() {
return major;
}
/**
* This can be used to set the major number from a HTTP version.
* The major version corresponds to the major type that is the 1
* of a HTTP/1.0 version string.
*
* @param major the major version number for the request message
*/
public void setMajor(int major) {
this.major = major;
}
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @return the minor version number for the request message
*/
public int getMinor() {
return minor;
}
/**
* This can be used to get the minor number from a HTTP version.
* The minor version corresponds to the major type that is the 0
* of a HTTP/1.0 version string. This is used to determine if
* the request message has keep alive semantics.
*
* @param minor the minor version number for the request message
*/
public void setMinor(int minor) {
this.minor = minor;
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Content-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType() {
String value = getValue("Content-Type");
if(value == null) {
return null;
}
return new ContentParser(value);
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return content length, or -1 if it cannot be determined
*/
public int getContentLength() {
return getInteger("Content-Length");
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Transfer-Encoding header, if there is
* then this will parse that header and return the first token in
* the comma separated list of values, which is the primary value.
*
* @return this returns the transfer encoding value if it exists
*/
public String getTransferEncoding() {
return getValue("Transfer-Encoding");
}
/**
* This is used to convert the representation of the response to
* an ISO-8850-1 encoded array of bytes. The array is composed
* from the toString method an then converted to a
* byte array.
*
* @return this returns a byte array representing the header
*/
protected byte[] getMessage() throws IOException {
return toString().getBytes("ISO-8859-1");
}
/**
* This is used to compose the HTTP response header. All of the
* headers added to the response are added, as well as the cookies
* to form the response message header. To ensure that the text
* produces is as required the header names are in the same case
* as they were added to the response message.
*
* @return a string representation of the response message
*/
public String toString() {
StringBuilder head = new StringBuilder(256);
head.append("HTTP/").append(major);
head.append('.').append(minor);
head.append(' ').append(code);
head.append(' ').append(text);
head.append("\r\n");
for(String name : getNames()) {
for(String value : getAll(name)) {
head.append(name);
head.append(": ");
head.append(value);
head.append("\r\n");
}
}
for(Cookie cookie : getCookies()) {
head.append("Set-Cookie: ");
head.append(cookie);
head.append("\r\n");
}
return head.append("\r\n").toString();
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/SecurePolicy.java 0000664 0000000 0000000 00000006147 12536602605 0026027 0 ustar 00root root 0000000 0000000 /*
* SecurePolicy.java February 2007
*
* Copyright (C) 2007, Niall Gallagher SecurePolicy object is used to create a policy
* that can create cookies that are secure. This ensures that the
* cookies can not be predicted and thus hijacked. Because there is
* no standard for session cookies, this uses the Java Servlet API
* naming convention, which names cookie JSESSIONID.
*
* @author Niall Gallagher
*/
class SecurePolicy implements Policy {
/**
* This provides the name of the cookies that are created.
*/
private static final String NAME = "JSESSIONID";
/**
* This is the header to acquire the cookie value from.
*/
private Header header;
/**
* This is the cookie created for the session identifier.
*/
private Cookie cookie;
/**
* Constructor for the SecurePolicy object. This is
* used to create a policy that will generate cookies which have
* secure value, which ensures session hijacking is not possible.
*
* @param header this is the header to search for the cookie
*/
public SecurePolicy(Header header) {
this.header = header;
}
/**
* This is used to acquire the session cookie for the request. The
* session cookie is either sent with the HTTP request header or
* it can be created if required. This ensures that if no cookie
* has been sent one can be created on demand.
*
* @param create if true the session cookie will be created
*
* @return the cookie associated with the session or null
*/
public Cookie getSession(boolean create) {
if(cookie != null) {
return cookie;
}
cookie = header.getCookie(NAME);
if(cookie == null) {
if(create) {
cookie = getCookie(NAME);
}
}
return cookie;
}
/**
* This is used to create the cookie value to be used. The value
* used for the cookie is created using a random number generator.
* This ensures that the cookie names created are secure to a
* point that they can not be hijacked by another used.
*
* @param name this is the name of the cookie to be created
*
* @return a session cookie with a secure cookie value
*/
private Cookie getCookie(String name) {
UUID identity = UUID.randomUUID();
String value = identity.toString();
return new Cookie(name, value, true);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Segment.java 0000664 0000000 0000000 00000013176 12536602605 0025023 0 ustar 00root root 0000000 0000000 /*
* Segment.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Segment object represents a collection of header
* values that is followed by a body. This is used to represent the
* header of a multipart upload part. The raw value of each header
* for the part can be acquired using this interface, also the type
* and the disposition of the body can be determined from this.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.Part
*/
interface Segment {
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile();
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName();
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName();
/**
* This can be used to get the value of the first message header
* that has the specified name. The value provided from this will
* be trimmed so there is no need to modify the value, also if
* the header name specified refers to a comma separated list of
* values the value returned is the first value in that list.
* This returns null if there is no HTTP message header.
*
* @param name the HTTP message header to get the value from
*
* @return this returns the value that the HTTP message header
*/
public String getValue(String name);
/**
* This can be used to get the values of HTTP message headers
* that have the specified name. This is a convenience method that
* will present that values as tokens extracted from the header.
* This has obvious performance benefits as it avoids having to
* deal with substring and trim calls.
* Content-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType();
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Content-Disposition header, if there is
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content disposition value if it exists
*/
public Disposition getDisposition();
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Transfer-Encoding header, if there is
* then this will parse that header and return the first token in
* the comma separated list of values, which is the primary value.
*
* @return this returns the transfer encoding value if it exists
*/
public String getTransferEncoding();
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
public int getContentLength();
}
simple-http-4.1.21/src/org/simpleframework/http/core/SegmentConsumer.java 0000664 0000000 0000000 00000052317 12536602605 0026537 0 ustar 00root root 0000000 0000000 /*
* SegmentConsumer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher SegmentConsumer object provides a consumer that is
* used to consume a HTTP header. This will read all headers within a
* HTTP header message until the carriage return line feed empty line
* is encountered. Once all headers are consumed they are available
* using the case insensitive header name. This will remove leading
* and trailing whitespace from the names and values parsed.
*
* @author Niall Gallagher
*/
class SegmentConsumer extends ArrayConsumer implements Segment {
/**
* This is the terminal carriage return and line feed end line.
*/
private static final byte[] TERMINAL = { 13, 10, 13, 10 };
/**
* This is used to parse the languages accepted in the request.
*/
protected LanguageParser language;
/**
* This is used to parse the cookie headers that are consumed.
*/
protected CookieParser cookies;
/**
* This is used to parse the content type header consumed.
*/
protected ContentType type;
/**
* This is used to represent the content disposition header.
*/
protected Disposition part;
/**
* This represents the transfer encoding value of the body.
*/
protected String encoding;
/**
* This is used to store all consumed headers by the header name.
*/
protected Message header;
/**
* During parsing this is used to store the parsed header name,
*/
protected String name;
/**
* During parsing this is used to store the parsed header value.
*/
protected String value;
/**
* This is used to determine if there is a continue expected.
*/
protected boolean expect;
/**
* Represents the length of the body from the content length.
*/
protected int length;
/**
* This is used to track the read offset within the header.
*/
protected int pos;
/**
* This is used to track how much of the terminal is read.
*/
protected int scan;
/**
* Constructor for the SegmentConsumer object. This
* is used to create a segment consumer used to consume and parse
* a HTTP message header. This delegates parsing of headers if
* they represent special headers, like content type or cookies.
*/
public SegmentConsumer() {
this.language = new LanguageParser();
this.cookies = new CookieParser();
this.header = new Message();
this.length = -1;
}
/**
* This method is used to determine the type of a part. Typically
* a part is either a text parameter or a file. If this is true
* then the content represented by the associated part is a file.
*
* @return this returns true if the associated part is a file
*/
public boolean isFile() {
if(part == null) {
return false;
}
return part.isFile();
}
/**
* This method is used to acquire the name of the part. Typically
* this is used when the part represents a text parameter rather
* than a file. However, this can also be used with a file part.
*
* @return this returns the name of the associated part
*/
public String getName() {
if(part == null) {
return null;
}
return part.getName();
}
/**
* This method is used to acquire the file name of the part. This
* is used when the part represents a text parameter rather than
* a file. However, this can also be used with a file part.
*
* @return this returns the file name of the associated part
*/
public String getFileName() {
if(part == null) {
return null;
}
return part.getFileName();
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Content-Type header, if there is then
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content type value if it exists
*/
public ContentType getContentType() {
return type;
}
/**
* This is a convenience method that can be used to determine
* the length of the message body. This will determine if there
* is a Content-Length header, if it does then the
* length can be determined, if not then this returns -1.
*
* @return the content length, or -1 if it cannot be determined
*/
public int getContentLength() {
return length;
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Transfer-Encoding header, if there is
* then this will parse that header and return the first token in
* the comma separated list of values, which is the primary value.
*
* @return this returns the transfer encoding value if it exists
*/
public String getTransferEncoding() {
return encoding;
}
/**
* This is a convenience method that can be used to determine the
* content type of the message body. This will determine whether
* there is a Content-Disposition header, if there is
* this will parse that header and represent it as a typed object
* which will expose the various parts of the HTTP header.
*
* @return this returns the content disposition value if it exists
*/
public Disposition getDisposition() {
return part;
}
/**
* This is used to acquire the locales from the request header. The
* locales are provided in the Accept-Language header.
* This provides an indication as to the languages that the client
* accepts. It provides the locales in preference order.
*
* @return this returns the locales preferred by the client
*/
public Listsubstring and trim calls.
* Cookie objects
* and made available as typed objects. If the value can not be
* parsed this will not add the cookie value.
*
* @param value this is the value of the cookie to be parsed
*/
protected void cookie(String value) {
cookies.parse(value);
for(Cookie cookie : cookies) {
header.setCookie(cookie);
}
}
/**
* This is used to parse the Accept-Language header
* value. This allows the locales the client is interested in to
* be provided in preference order and allows the client do alter
* and response based on the locale the client has provided.
*
* @param value this is the value that is to be parsed
*/
protected void language(String value) {
language = new LanguageParser(value);
}
/**
* This is used to parse the content type header header so that
* the MIME type is available to the segment. This provides an
* instance of the ContentType object to represent
* the content type header, which exposes the charset value.
*
* @param value this is the content type value to parse
*/
protected void type(String value) {
type = new ContentParser(value);
}
/**
* This is used to parse the content disposition header header so
* that the MIME type is available to the segment. This provides
* an instance of the Disposition object to represent
* the content disposition, this exposes the upload type.
*
* @param value this is the content type value to parse
*/
protected void disposition(String value) {
part = new DispositionParser(value);
}
/**
* This is used to store the transfer encoding header value. This
* is used to determine the encoding of the body this segment
* represents. Typically this will be the chunked encoding.
*
* @param value this is the value representing the encoding
*/
protected void encoding(String value) {
encoding = value;
}
/**
* This is used to parse a provided header value for the content
* length. If the string provided is not an integer value this will
* throw a number format exception, by default length is -1.
*
* @param value this is the header value of the content length
*/
protected void length(String value) {
try {
length = Integer.parseInt(value);
}catch(Exception e) {
length = -1;
}
}
/**
* This updates the token for the header name. The name is parsed
* according to the presence of a colon ':'. Once a colon character
* is encountered then this header name is considered to be read
* from the buffer and is used to key the value after the colon.
*/
private void name() {
Token token = new Token(pos, 0);
while(pos < count){
if(array[pos] == ':') {
pos++;
break;
}
token.size++;
pos++;
}
name = token.text();
}
/**
* This is used to parse the HTTP header value. This will parse it
* in such a way that the line can be folded over several lines
* see RFC 2616 for the syntax of a folded line. The folded line
* is basically a way to wrap a single HTTP header into several
* lines using a tab at the start of the following line to indicate
* that the header flows onto the next line.
*/
private void value() {
Token token = new Token(pos, 0);
scan: for(int mark = 0; pos < count;){
if(terminal(array[pos])) { /* CR or LF */
for(int i = 0; pos < count; i++){
if(array[pos++] == 10) { /* skip the LF */
if(space(array[pos])) {
mark += i + 1; /* account for bytes examined */
break; /* folding line */
}
break scan; /* not a folding line */
}
}
} else {
if(!space(array[pos])){
token.size = ++mark;
} else {
mark++;
}
pos++;
}
}
value = token.text();
}
/**
* This will update the offset variable so that the next read will
* be of a non whitespace character. According to RFC 2616 a white
* space character is a tab or a space. This will remove multiple
* occurrences of whitespace characters until an non-whitespace
* character is encountered.
*/
protected void adjust() {
while(pos < count) {
if(!space(array[pos])){
break;
}
pos++;
}
}
/**
* This method is used to scan for the terminal token. It searches
* for the token and returns the number of bytes in the buffer
* after the terminal token. Returning the excess bytes allows the
* consumer to reset the bytes within the consumer object.
*
* @return this returns the number of excess bytes consumed
*/
@Override
protected int scan() {
int length = count;
while(pos < count) {
if(array[pos++] != TERMINAL[scan++]) {
scan = 0;
}
if(scan == TERMINAL.length) {
done = true;
count = pos;
pos = 0;
return length - count;
}
}
return 0;
}
/**
* This is used to determine if two header names are equal, this is
* done to ensure that the case insensitivity of HTTP header names
* is observed. Special headers are processed using this consumer
* and this is used to ensure the correct header is always matched.
*
* @param name this is the name to compare the parsed token with
* @param token this is the header name token to examine
*
* @return true of the header name token is equal to the name
*/
protected boolean equal(String name, String token) {
return name.equalsIgnoreCase(token);
}
/**
* This identifies a given ISO-8859-1 byte as a space character. A
* space is either a space or a tab character in ISO-8859-1.
*
* @param octet the byte to determine whether it is a space
*
* @return true if it is a space character, false otherwise
*/
protected boolean space(byte octet) {
return octet == ' ' || octet == '\t';
}
/**
* This determines if an ISO-8859-1 byte is a terminal character. A
* terminal character is a carriage return or a line feed character.
*
* @param octet the byte to determine whether it is a terminal
*
* @return true if it is a terminal character, false otherwise
*/
protected boolean terminal(byte octet){
return octet == 13 || octet == 10;
}
/**
* This is used to provide a string representation of the header
* read. Providing a string representation of the header is used
* so that on debugging the contents of the delivered header can
* be inspected in order to determine a cause of error.
*
* @return this returns a string representation of the header
*/
@Override
public String toString() {
return new String(array, 0, count);
}
/**
* This is used to track the boundaries of a token so that it can
* be converted in to a usable string. This will track the length
* and offset within the consumed array of the token. When the
* token is to be used it can be converted in to a string.
*
* @author Niall Gallagher
*/
private class Token {
/**
* This is used to track the number of bytes within the array.
*/
public int size;
/**
* This is used to mark the start offset within the array.
*/
public int off;
/**
* Constructor for the Token object. This is used
* to create a new token to track the range of bytes that will
* be used to create a string representing the parsed value.
*
* @param off the starting offset for the token range
* @param size the number of bytes used for the token
*/
public Token(int off, int size) {
this.off = off;
this.size = size;
}
/**
* This is used to convert the byte range to a string. This
* will use UTF-8 encoding for the string which is compatible
* with the HTTP default header encoding of ISO-8859-1.
*
* @return the encoded string representing the token
*/
public String text() {
return text("UTF-8");
}
/**
* This is used to convert the byte range to a string. This
* will use specified encoding, if that encoding is not
* supported then this will return null for the token value.
*
* @return the encoded string representing the token
*/
public String text(String charset) {
try {
return new String(array, off, size, charset);
} catch(IOException e) {
return null;
}
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Selector.java 0000664 0000000 0000000 00000006463 12536602605 0025202 0 ustar 00root root 0000000 0000000 /*
* Selector.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Selector interface represents an object which is
* used to process collection events. The sequence of events that
* typically take place is for the collection to start, if not all
* of the bytes can be consumed it selects, and finally when all of
* the bytes within the entity have been consumed it is ready.
* Selector so that
* all resources are released. As well as freeing occupied memory
* this will also stop all threads, which means that is can no
* longer be used to collect data from the pipelines.
*/
public void stop() throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/Sender.java 0000664 0000000 0000000 00000007371 12536602605 0024641 0 ustar 00root root 0000000 0000000 /*
* Sender.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Sender object is used to send data over the TCP
* transport. This provides direct contact with the connected socket.
* Delivery over a sender implementation can be either SSL based or
* direct as with plain HTTP connections. It is the responsibility
* of the implementation to provide such behavior as required.
*
* @author Niall Gallagher
*/
interface Sender {
/**
* This method is used to deliver the provided array of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param array this is the array of bytes to send to the client
*/
public void send(byte[] array) throws IOException;
/**
* This method is used to deliver the provided array of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void send(byte[] array, int off, int len) throws IOException;
/**
* This method is used to deliver the provided buffer of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void send(ByteBuffer buffer) throws IOException;
/**
* This method is used to deliver the provided buffer of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void send(ByteBuffer buffer, int off, int len) throws IOException;
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException;
/**
* This is used to close the sender and the underlying transport.
* If a close is performed on the sender then no more bytes can
* be read from or written to the transport and the client will
* received a connection close on their side.
*/
public void close() throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/TokenConsumer.java 0000664 0000000 0000000 00000006431 12536602605 0026211 0 ustar 00root root 0000000 0000000 /*
* TokenConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher TokenConsumer object is used to consume a token
* from the cursor. Once the token has been consumed the consumer
* is finished and the contents of the consumed token is appended
* to an allocated buffer so that it can be extracted.
*
* @author Niall Gallagher
*/
class TokenConsumer extends ArrayConsumer {
/**
* This is used to allocate a buffer to append the contents.
*/
private Allocator allocator;
/**
* This is used to append the contents of consumed token.
*/
private Buffer buffer;
/**
* This is the token that is to be consumed from the cursor.
*/
private byte[] token;
/**
* This tracks the number of bytes that are read from the token.
*/
private int seek;
/**
* This is the length of the token that is to be consumed.
*/
private int length;
/**
* The TokenConsumer object is used to read a token
* from the cursor. This tracks the bytes read from the cursor,
* when it has fully read the token bytes correctly it will
* finish and append the consumed bytes to a buffer.
*
* @param allocator the allocator used to create a buffer
* @param token this is the token that is to be consumed
*/
public TokenConsumer(Allocator allocator, byte[] token) {
this.allocator = allocator;
this.length = token.length;
this.token = token;
this.chunk = length;
}
/**
* This is used to append the consumed bytes to a created buffer
* so that it can be used when he is finished. This allows the
* contents to be read from an input stream or as a string.
*/
@Override
protected void process() throws IOException {
if(buffer == null) {
buffer = allocator.allocate(length);
}
buffer.append(token);
}
/**
* This is used to scan the token from the array. Once the bytes
* have been read from the consumed bytes this will return the
* number of bytes that need to be reset within the buffer.
*
* @return this returns the number of bytes to be reset
*/
@Override
protected int scan() throws IOException {
int size = token.length;
int pos = 0;
if(count >= size) {
while(seek < count) {
if(array[seek++] != token[pos++]) {
throw new IOException("Invalid token");
}
}
done = true;
return count - seek;
}
return 0;
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Tracker.java 0000664 0000000 0000000 00000005203 12536602605 0025004 0 ustar 00root root 0000000 0000000 /*
* Tracker.java February 2007
*
* Copyright (C) 2007, Niall Gallagher Tracker interface represents an object that is
* used to track a given client using some identifier. Typically the
* client is tracked using a cookie or encoded URI. However it is
* left up to the implementation to determine how the client will be
* tracked. In order to acquire the information to determine what
* client is connected the request entity is used.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.session.SessionProvider
*/
interface Tracker {
/**
* This is used to acquire the Session object using
* the information within the HTTP entity. The entity contains all
* of the information that has been sent by the client and is the
* ideal means to differentiate clients.
*
* @param entity this is the entity consumed from the pipeline
*
* @return a session associated with the provided entity
*/
public Session getSession(Entity entity) throws LeaseException;
/**
* This is used to acquire the Session object using
* the information within the HTTP entity. The entity contains all
* of the information that has been sent by the client and is the
* ideal means to differentiate clients.
*
* @param entity this is the entity consumed from the pipeline
* @param create determines if a session should be created
*
* @return a session associated with the provided entity
*/
public Session getSession(Entity entity, boolean create) throws LeaseException;
/**
* This close method is used to close the tracker and
* release all resources associated with it. This means canceling
* all active sessions and emptying the contents of those sessions.
* Threads and other such resources are released by this method.
*/
public void close() throws LeaseException;
}
simple-http-4.1.21/src/org/simpleframework/http/core/TrackerBuilder.java 0000664 0000000 0000000 00000011723 12536602605 0026317 0 ustar 00root root 0000000 0000000 /*
* TrackerBuilder.java February 2007
*
* Copyright (C) 2007, Niall Gallagher TrackerBuilder object is used to build an entity
* with the aid of a session tracker implementation. This basically
* accepts the header and body for the entity and delegates the
* session creation to the tracker.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.CookieTracker
*/
class TrackerBuilder implements Builder {
/**
* This is the tracker object used to create the sessions.
*/
private Tracker tracker;
/**
* This is the channel that represents the underlying transport.
*/
private Channel channel;
/**
* This is the header object that holds the request headers.
*/
private Header header;
/**
* This is the body object used to hold the body delivered.
*/
private Body body;
/**
* Constructor for the TrackerBuilder object. This
* is used to create a builder that delegates creation of the
* session object to a tracker implementation. Also the channel
* for the entity must also be provided.
*
* @param tracker this is the tracker used to create sessions
* @param channel this is the channel representing the transport
*/
public TrackerBuilder(Tracker tracker, Channel channel) {
this.tracker = tracker;
this.channel = channel;
}
/**
* Provides the Body object for the builder. This
* is used by the entity to read the content of the HTTP request.
* Also, if the entity body is a multipart upload then each of
* the individual parts of the body is available to read from.
*
* @param body this is the entity body provided by the request
*/
public void setBody(Body body) {
this.body = body;
}
/**
* Provides the Header object for the builder. This
* is used by the entity to determine the request URI and method
* type. The header also provides start in the form of cookies
* which can be used to track the client.
*
* @param header this is the header provided by the request
*/
public void setHeader(Header header) {
this.header = header;
}
/**
* This is used to acquire the body for this HTTP entity. This
* will return a body which can be used to read the content of
* the message, also if the request is multipart upload then all
* of the parts are provided as Part objects. Each
* part can then be read as an individual message.
*
* @return the body provided by the HTTP request message
*/
public Body getBody() {
return body;
}
/**
* This provides the connected channel for the client. This is
* used to send and receive bytes to and from an transport layer.
* Each channel provided with an entity contains an attribute
* map which contains information about the connection.
*
* @return the connected channel for this HTTP entity
*/
public Channel getChannel() {
return channel;
}
/**
* This provides the HTTP request header for the entity. This is
* always populated and provides the details sent by the client
* such as the target URI and the query if specified. Also this
* can be used to determine the method and protocol version used.
*
* @return the header provided by the HTTP request message
*/
public Header getHeader() {
return header;
}
/**
* This method is used to acquire a Session for the
* request. The object retrieved provides a container for data
* associated to the connected client. This allows the request
* to perform more complex operations based on knowledge that is
* built up through a series of requests. The session is known
* to the system using a Cookie, which contains
* the session reference. This cookie value should not be
* modified as it used to reference the active session object.
*
* @param create creates the session if it does not exist
*
* @return returns an active session object for the entity
*/
public Session getSession(boolean create) throws LeaseException {
return tracker.getSession(this, create);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/Transfer.java 0000664 0000000 0000000 00000024764 12536602605 0025212 0 ustar 00root root 0000000 0000000 /*
* Transfer.java February 2007
*
* Copyright (C) 2001, Niall Gallagher Transfer object acts as a means to determine the
* transfer encoding for the response body. This will ensure that the
* correct HTTP headers are used when the transfer of the body begins.
* In order to determine what headers to use this can be provided
* with a content length value. If the start method is
* provided with the content length then the HTTP headers will use a
* Content-Length header as the message delimiter. If there is no
* content length provided then the chunked encoding is used for
* HTTP/1.1 and connection close is used for HTTP/1.0.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.core.Producer
*/
class Transfer {
/**
* This is used to create a producer based on the HTTP headers.
*/
private ProducerFactory factory;
/**
* This is used to determine the type of transfer required.
*/
private Conversation support;
/**
* This is the response message that is to be committed.
*/
private Response response;
/**
* Once the header is committed this is used to produce data.
*/
private Producer producer;
/**
* Constructor for the Transfer object, this is used
* to create an object used to transfer a response body. This must
* be given a Conversation that can be used to set
* and get information regarding the type of transfer required.
*
* @param support this is used to determine the semantics
* @param sender this is used to send data over the transport
* @param monitor this is used to signal I/O events to the kernel
*/
public Transfer(Conversation support, Sender sender, Monitor monitor) {
this.factory = new ProducerFactory(support, sender, monitor);
this.response = support.getResponse();
this.support = support;
}
/**
* This is used to determine if the transfer has started. It has
* started when a producer is created and the HTTP headers have
* been sent, or at least handed to the underlying transport.
* Once started the semantics of the connection can not change.
*
* @return this returns whether the transfer has started
*/
public boolean isStarted() {
return producer != null;
}
/**
* This starts the transfer with no specific content length set.
* This is typically used when dynamic data is emitted ans will
* require chunked encoding for HTTP/1.1 and connection close
* for HTTP/1.0. Once invoked the HTTP headers are committed.
*/
public void start() throws IOException {
if(producer != null) {
throw new TransferException("Transfer has already started");
}
clear();
configure();
commit();
}
/**
* This starts the transfer with a known content length. This is
* used when there is a Content-Length header set. This will not
* encode the content for HTTP/1.1 however, HTTP/1.0 may need
* a connection close if it does not have keep alive semantics.
*
* @param length this is the length of the response body
*/
public void start(int length) throws IOException {
if(producer != null) {
throw new TransferException("Transfer has already started");
}
clear();
configure(length);
commit();
}
/**
* This method is used to write content to the underlying socket.
* This will make use of the Producer object to
* encode the response body as required. If the producer has not
* been created then this will throw an exception.
*
* @param array this is the array of bytes to send to the client
*/
public void write(byte[] array) throws IOException {
write(array, 0, array.length);
}
/**
* This method is used to write content to the underlying socket.
* This will make use of the Producer object to
* encode the response body as required. If the producer has not
* been created then this will throw an exception.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void write(byte[] array, int off, int len) throws IOException {
if(producer == null) {
throw new TransferException("Conversation details not ready");
}
producer.produce(array, off, len);
}
/**
* This method is used to write content to the underlying socket.
* This will make use of the Producer object to
* encode the response body as required. If the producer has not
* been created then this will throw an exception.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void write(ByteBuffer buffer) throws IOException {
int mark = buffer.position();
int size = buffer.limit();
if(mark > size) {
throw new TransferException("Buffer position greater than limit");
}
write(buffer, 0, size - mark);
}
/**
* This method is used to write content to the underlying socket.
* This will make use of the Producer object to
* encode the response body as required. If the producer has not
* been created then this will throw an exception.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void write(ByteBuffer buffer, int off, int len) throws IOException {
if(producer == null) {
throw new TransferException("Conversation details not ready");
}
producer.produce(buffer, off, len);
}
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException {
if(producer == null) {
throw new TransferException("Conversation details not ready");
}
producer.flush();
}
/**
* This is used to signal to the producer that all content has
* been written and the user no longer needs to write. This will
* either close the underlying transport or it will notify the
* monitor that the response has completed and the next request
* can begin. This ensures the content is flushed to the client.
*/
public void close() throws IOException {
if(producer == null) {
throw new TransferException("Conversation details not ready");
}
producer.close();
}
/**
* This method is used to set the required HTTP headers on the
* response. This will check the existing HTTP headers, and if
* there is insufficient data chunked encoding will be used for
* HTTP/1.1 and connection close will be used for HTTP/1.0.
*/
private void configure() throws IOException {
int length = support.getContentLength();
boolean empty = support.isEmpty();
if(empty) {
support.setContentLength(0);
} else if(length >= 0) {
support.setContentLength(length);
} else {
support.setChunkedEncoded();
}
producer = factory.getInstance();
}
/**
* This method is used to set the required HTTP headers on the
* response. This will check the existing HTTP headers, and if
* there is insufficient data chunked encoding will be used for
* HTTP/1.1 and connection close will be used for HTTP/1.0.
*
* @param count this is the number of bytes to be transferred
*/
private void configure(int count) throws IOException {
int length = support.getContentLength();
if(support.isHead()) {
if(count > 0) {
configure(count, count);
} else {
configure(count, length);
}
} else {
configure(count, count);
}
}
/**
* This method is used to set the required HTTP headers on the
* response. This will check the existing HTTP headers, and if
* there is insufficient data chunked encoding will be used for
* HTTP/1.1 and connection close will be used for HTTP/1.0.
*
* @param count this is the number of bytes to be transferred
* @param length this is the actual length value to be used
*/
private void configure(int count, int length) throws IOException {
boolean empty = support.isEmpty();
if(empty) {
support.setContentLength(0);
} else if(length >= 0) {
support.setContentLength(length);
} else {
support.setChunkedEncoded();
}
producer = factory.getInstance();
}
/**
* This is used to clear any previous encoding that has been set
* in the event that content length may be used instead. This is
* used so that an override can be made to the transfer encoding
* such that content length can be used instead.
*/
private void clear() throws IOException {
support.setIdentityEncoded();
}
/**
* This is used to compose the HTTP header and send it over the
* transport to the client. Once done the response is committed
* and no more headers can be set, also the semantics of the
* response have been committed and the producer is created.
*/
private void commit() throws IOException {
try {
response.commit();
} catch(Exception cause) {
throw new TransferException("Unable to commit", cause);
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/TransferException.java 0000664 0000000 0000000 00000004017 12536602605 0027056 0 ustar 00root root 0000000 0000000 /*
* TransferException.java February 2007
*
* Copyright (C) 2001, Niall Gallagher TransferException object is used to represent an
* exception that is thrown when there is a problem producing the
* response body. This can be used to wrap IOException
* objects that are thrown from the underlying transport.
*
* @author Niall Gallagher
*/
class TransferException extends IOException {
/**
* Constructor for the TransferException object. This
* is used to represent an exception that is thrown when producing
* the response body. The producer exception is an I/O exception
* and thus exceptions can propagate out of stream methods.
*
* @param message this is the message describing the exception
*/
public TransferException(String message) {
super(message);
}
/**
* Constructor for the TransferException object. This
* is used to represent an exception that is thrown when producing
* the response body. The producer exception is an I/O exception
* and thus exceptions can propagate out of stream methods.
*
* @param message this is the message describing the exception
* @param cause this is the cause of the producer exception
*/
public TransferException(String message, Throwable cause) {
super(message);
initCause(cause);
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/TransportChannel.java 0000664 0000000 0000000 00000012400 12536602605 0026673 0 ustar 00root root 0000000 0000000 /*
* TransportChannel.java February 2007
*
* Copyright (C) 2007, Niall Gallagher TransportChannel provides a means to deliver and
* receive content over a transport. This essentially provides two
* adapters which enable simpler communication with the underlying
* transport. They hide the complexities involved with buffering and
* resetting data written to and read from the socket.
*
* @author Niall Gallagher
*
* @see org.simpleframework.transport.Processor
*/
class TransportChannel implements Channel {
/**
* This represents the underlying transport that is to be used.
*/
private final Transport transport;
/**
* This is the engine that is used to secure the transport.
*/
private final SSLEngine engine;
/**
* This is used to provide a cursor view on the input.
*/
private final Cursor cursor;
/**
* This is used to provide a blocking means for sending data.
*/
private final Sender sender;
/**
* Constructor for the TransportChannel object. The
* transport channel basically wraps a channel and provides a
* means to send and receive data using specialized adapters.
* These adapters provide a simpler means for communicating over
* the network to the connected client.
*
* @param transport this is the underlying transport to be used
*/
public TransportChannel(Transport transport) {
this.cursor = new TransportCursor(transport);
this.sender = new TransportSender(transport);
this.engine = transport.getEngine();
this.transport = transport;
}
/**
* This is used to determine if the channel is secure and that
* data read from and data written to the request is encrypted.
* Channels transferred over SSL are considered secure and will
* have this return true, otherwise it will return false.
*
* @return true if this is secure for reading and writing
*/
public boolean isSecure() {
return engine != null;
}
/**
* This is the connected socket channel associated with this. In
* order to determine if content can be read or written to or
* from the channel this socket can be used with a selector. This
* provides a means to react to I/O events as they occur rather
* than polling the channel which is generally less performant.
*
* @return this returns the connected socket channel
*/
public SocketChannel getSocket() {
return transport.getChannel();
}
/**
* This returns the Map of attributes used to hold
* connection information for the channel. The attributes here
* are taken from the pipeline attributes and may contain details
* such as SSL certificates or other such useful information.
*
* @return returns the attributes associated with the channel
*/
public Map getAttributes() {
return transport.getAttributes();
}
/**
* This provides the Cursor for this channel. The
* cursor provides a resettable view of the input buffer and will
* allow the server kernel to peek into the input buffer without
* having to take the data from the input. This allows overflow
* to be pushed back on to the cursor for subsequent reads.
*
* @return this returns the input cursor for the channel
*/
public Cursor getCursor() {
return cursor;
}
/**
* This provides the Sender for the channel. This is
* used to provide a blocking output mechanism for the channel.
* Enabling blocking reads ensures that output buffering can be
* limited to an extent, which ensures that memory remains low at
* high load periods. Writes to the sender may result in the data
* being copied and queued until the socket is write ready.
*
* @return this returns the output sender for this channel
*/
public Sender getSender() {
return sender;
}
/**
* Because the channel represents a duplex means of communication
* there needs to be a means to close it down. This provides such
* a means. By closing the channel the cursor and sender will no
* longer send or recieve data to or from the network. The client
* will also be signaled that the connection has been severed.
*/
public void close() {
try {
transport.close();
}catch(Exception e) {
return;
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/TransportSender.java 0000664 0000000 0000000 00000012305 12536602605 0026547 0 ustar 00root root 0000000 0000000 /*
* TransportSender.java February 2007
*
* Copyright (C) 2001, Niall Gallagher TransportSender object is used to send bytes to
* and underlying transport. This is essentially an adapter between
* an OutputStream and the underlying transport. Each
* byte array segment written to the underlying transport is wrapped
* in a bytes buffer so that it can be sent by the transport layer.
*
* @author Niall Gallagher
*
* @see org.simpleframework.transport.Transport
*/
class TransportSender implements Sender {
/**
* This is the underlying transport to write the bytes to.
*/
private Transport transport;
/**
* This is used to determine if the transport has been closed.
*/
private volatile boolean closed;
/**
* Constructor for the TransportSender object. This
* is used to create an adapter for the transport such that a
* byte array can be used to write bytes to the array.
*
* @param transport the underlying transport to send bytes to
*/
public TransportSender(Transport transport) {
this.transport = transport;
}
/**
* This method is used to deliver the provided array of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param array this is the array of bytes to send to the client
*/
public void send(byte[] array) throws IOException {
send(array, 0, array.length);
}
/**
* This method is used to deliver the provided array of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param array this is the array of bytes to send to the client
* @param off this is the offset within the array to send from
* @param len this is the number of bytes that are to be sent
*/
public void send(byte[] array, int off, int len) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(array, off, len);
if(len > 0) {
send(buffer);
}
}
/**
* This method is used to deliver the provided buffer of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param buffer this is the buffer of bytes to send to the client
*/
public void send(ByteBuffer buffer) throws IOException {
int mark = buffer.position();
int size = buffer.limit();
if(mark > size) {
throw new IOException("Buffer position greater than limit");
}
send(buffer, 0, size - mark);
}
/**
* This method is used to deliver the provided buffer of bytes to
* the underlying transport. Depending on the connection type the
* array may be encoded for SSL transport or send directly. Any
* implementation may choose to buffer the bytes for performance.
*
* @param buffer this is the buffer of bytes to send to the client
* @param off this is the offset within the buffer to send from
* @param len this is the number of bytes that are to be sent
*/
public void send(ByteBuffer buffer, int off, int len) throws IOException {
int mark = buffer.position();
int limit = buffer.limit();
if(limit - mark > len) {
buffer.limit(mark + len); // reduce usable size
}
transport.write(buffer);
buffer.limit(limit);
}
/**
* This method is used to flush the contents of the buffer to
* the client. This method will block until such time as all of
* the data has been sent to the client. If at any point there
* is an error sending the content an exception is thrown.
*/
public void flush() throws IOException {
transport.flush();
}
/**
* This is used to close the sender and the underlying transport.
* If a close is performed on the sender then no more bytes can
* be read from or written to the transport and the client will
* received a connection close on their side.
*/
public void close() throws IOException {
if(!closed) {
transport.close();
closed = true;
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/core/UpdateConsumer.java 0000664 0000000 0000000 00000011612 12536602605 0026350 0 ustar 00root root 0000000 0000000 /*
* UpdateConsumer.java February 2007
*
* Copyright (C) 2007, Niall Gallagher UpdateConsumer object is used to create a consumer
* that is used to consume and process large bodies. Typically a large
* body will be one that is delivered as part of a multipart upload
* or as a large form POST. The task of the large consumer is to
* consume all the bytes for the body, and reset the cursor after the
* last byte that has been send with the body. This ensures that the
* next character read from the cursor is the first character of a
* HTTP header within the pipeline.
*
* @author Niall Gallagher
*/
abstract class UpdateConsumer extends BodyConsumer {
/**
* This is an external array used to copy data between buffers.
*/
protected byte[] array;
/**
* This is used to determine whether the consumer has finished.
*/
protected boolean finished;
/**
* Constructor for the UpdateConsumer object. This is
* used to create a consumer with a one kilobyte buffer used to
* read the contents from the cursor and transfer it to the buffer.
*/
protected UpdateConsumer() {
this(1024);
}
/**
* Constructor for the UpdateConsumer object. This is
* used to create a consumer with a variable size buffer used to
* read the contents from the cursor and transfer it to the buffer.
*
* @param chunk this is the size of the buffer used to read bytes
*/
protected UpdateConsumer(int chunk) {
this.array = new byte[chunk];
}
/**
* This is used to determine whether the consumer has finished
* reading. The consumer is considered finished if it has read a
* terminal token or if it has exhausted the stream and can not
* read any more. Once finished the consumed bytes can be parsed.
*
* @return true if the consumer has finished reading its content
*/
public boolean isFinished() {
return finished;
}
/**
* This method is used to consume bytes from the provided cursor.
* Consuming of bytes from the cursor should be done in such a
* way that it does not block. So typically only the number of
* ready bytes in the Cursor object should be read.
* If there are no ready bytes then this method should return.
*
* @param cursor used to consume the bytes from the HTTP pipeline
*/
public void consume(Cursor cursor) throws IOException {
int ready = cursor.ready();
while(ready > 0) {
int size = Math.min(ready, array.length);
int count = cursor.read(array, 0, size);
if(count > 0) {
int reset = update(array, 0, count);
if(reset > 0) {
cursor.reset(reset);
}
}
if(finished) {
commit(cursor);
break;
}
ready = cursor.ready();
}
}
/**
* This method can be used to commit the consumer when all data
* has been consumed. It is often used to push back some data on
* to the cursor so that the next consumer can read valid tokens
* from the stream of bytes. If no commit is required then the
* default implementation of this will simply return quietly.
*
* @param cursor this is the cursor used by this consumer
*/
protected void commit(Cursor cursor) throws IOException {
if(!finished) {
throw new IOException("Consumer not finished");
}
}
/**
* This is used to process the bytes that have been read from the
* cursor. Depending on the delimiter used this knows when the
* end of the body has been encountered. If the end is encountered
* this method must return the number of bytes overflow, and set
* the state of the consumer to finished.
*
* @param array this is a chunk read from the cursor
* @param off this is the offset within the array the chunk starts
* @param count this is the number of bytes within the array
*
* @return this returns the number of bytes overflow that is read
*/
protected abstract int update(byte[] array, int off, int count) throws IOException;
}
simple-http-4.1.21/src/org/simpleframework/http/parse/ 0000775 0000000 0000000 00000000000 12536602605 0022730 5 ustar 00root root 0000000 0000000 simple-http-4.1.21/src/org/simpleframework/http/parse/AddressParser.java 0000664 0000000 0000000 00000126240 12536602605 0026342 0 ustar 00root root 0000000 0000000 /*
* AddressParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
*
* URI = (absoluteURI | relativeURI)
* absoluteURI = scheme ":" ("//" netpath | relativeURI)
* relativeURI = path ["?" querypart]
* netpath = domain [":" port] relativeURI
* path = *("/" segment)
* segment = *pchar *( ";" param )
*
*
* This implements the Address interface and provides
* methods that access the various parts of the URI. The parameters
* in the path segments of the uniform resource identifier are
* stored in name value pairs. If parameter names are not unique
* across the path segments then only the deepest parameter will be
* stored from the path segment. For example if the URI represented
* was http://domain/path1;x=y/path2;x=z the value for
* the parameter named x would be z.
* setPath method is used to reset the path this
* uniform resource identifier has, it also resets the parameters.
* The parameters are extracted from the new path given.
*
* @author Niall Gallagher
*/
public class AddressParser extends Parser implements Address {
/**
* Parameters are stored so that the can be viewed.
*/
private ParameterMap param;
/**
* This is the path used to represent the address path.
*/
private Path normal;
/**
* This contains the query parameters for the address.
*/
private Query data;
/**
* Used to track the characters that form the path.
*/
private Token path;
/**
* Used to track the characters that form the domain.
*/
private Token domain;
/**
* Used to track the characters that form the query.
*/
private Token query;
/**
* Used to track the name characters of a parameter.
*/
private Token name;
/**
* Used to track the value characters of a parameter.
*/
private Token value;
/**
* References the scheme that this URI contains.
*/
private Token scheme;
/**
* Contains the port number if it was specified.
*/
private int port;
/**
* Default constructor will create a AddressParser
* that contains no specifics. The instance will return
* null for all the get methods. The parsers
* get methods are populated by using the parse
* method.
*/
public AddressParser(){
this.param = new ParameterMap();
this.path = new Token();
this.domain = new Token();
this.query = new Token();
this.scheme = new Token();
this.name = new Token();
this.value = new Token();
}
/**
* This is primarily a convenience constructor. This will parse
* the String given to extract the specifics. This
* could be achieved by calling the default no-arg constructor
* and then using the instance to invoke the parse
* method on that String to extract the parts.
*
* @param text a String containing a URI value
*/
public AddressParser(String text){
this();
parse(text);
}
/**
* This allows the scheme of the URL given to be returned.
* If the URI does not contain a scheme then this will
* return null. The scheme of the URI is the part that
* specifies the type of protocol that the URI is used
* for, an example gopher://domain/path is
* a URI that is intended for the gopher protocol. The
* scheme is the string gopher.
*
* @return this returns the scheme tag for the URI if
* there is one specified for it
*/
public String getScheme(){
return scheme.toString();
}
/**
* This is used to retrive the domain of this URI. The
* domain part in the URI is an optional part, an example
* http://domain/path?querypart. This will
* return the value of the domain part. If there is no
* domain part then this will return null otherwise the
* domain value found in the uniform resource identifier.
*
* @return the domain part of this uniform resource
* identifier this represents
*/
public String getDomain(){
return domain.toString();
}
/**
* This is used to retrive the path of this URI. The path part
* is the most fundemental part of the URI. This will return
* the value of the path. If there is no path part then this
* will return / to indicate the root.
* Path object returned by this will contain
* no path parameters. The path parameters are available using
* the Address methods. The reason that this does not
* contain any of the path parameters is so that if the path is
* needed to be converted into ab OS specific path then the path
* parameters will not need to be separately parsed out.
*
* @return the path that this URI contains, this value will not
* contain any back references such as "./" and "../" or any
* path parameters
*/
public Path getPath(){
String text = path.toString();
if(text == null) {
normal = new PathParser("/");
}
if(normal == null){
normal = new PathParser(text);
}
return normal;
}
/**
* This is used to retrieve the query of this URI. The query part
* in the URI is an optional part. This will return the value
* of the query part. If there is no query part then this will
* return an empty Query object. The query is
* an optional member of a URI and comes after the path part, it
* is preceded by a question mark, ? character.
* For example the following URI contains query for
* its query part, http://host:port/path?query.
* org.simpleframework.http.Query
* object that can be used to interact directly with the query
* values. The Query object is a read-only interface
* to the query parameters, and so will not affect the URI.
*
* @return a Query object for the query part
*/
public Query getQuery(){
String text = query.toString();
if(text == null) {
data = new QueryParser();
}
if(data == null){
data = new QueryParser(text);
}
return data;
}
/**
* This is used to retrive the port of the uniform resource
* identifier. The port part in this is an optional part, an
* example http://host:port/path?querypart. This
* will return the value of the port. If there is no port then
* this will return -1 because this represents
* an impossible uniform resource identifier port. The port
* is an optional part.
*
* @return this returns the port of the uniform resource
* identifier
*/
public int getPort(){
return port <= 0? -1 : port;
}
/**
* This extracts the parameter values from the uniform resource
* identifier represented by this object. The parameters that a
* uniform resource identifier contains are embedded in the path
* part of the URI. If the path contains no parameters then this
* will return an empty Map instance.
* http://domain/path1;x=y/path2;x=z
* the value for the parameter named x would be
* z.
*
* @return this will return the parameter names found in the URI
*/
public KeyMap:// identifier
* to ensure that the Address.toString will
* produce the correct syntax.
* http://domain:80/path and the scheme
* was changed to ftp the port number that
* remains is the standard HTTP port not the FTP port.
*
* @param value this specifies the protocol this URI
* is intended for
*/
public void setScheme(String value){
scheme.value = value;
}
/**
* This will set the domain to whatever value is in the
* string parameter. If the string is null then this URI
* objects toString method will not contain
* the domain. The result of the toString
* method will be /path/path?query. If the
* path is non-null this URI will contain the path.
*
* @param value this will be the new domain of this
* uniform resource identifier, if it is not null
*/
public void setDomain(String value){
domain.value = value;
}
/**
* This will set the port to whatever value it is given. If
* the value is 0 or less then the toString will
* will not contain the optional port. If port number is above
* 0 then the toString method will produce a URI
* like http://host:123/path but only if there is
* a valid domain.
*
* @param port the port value that this URI is to have
*/
public void setPort(int port) {
this.port = port;
}
/**
* This will set the path to whatever value it is given. If the
* value is null then this Address.toString method will
* not contain the path, that is if path is null then it will be
* interpreted as /.
* getPath produces. The path
* will have all back references and parameters stripped.
*
* @param text the path that this URI is to be set with
*/
public void setPath(String text) {
if(!text.startsWith("/")){
text = "/" + text;
}
param.clear();
path.clear();
parsePath(text); /*extract params*/
}
/**
* This will set the path to whatever value it is given. If the
* value is null then this Address.toString method
* will not contain the path, that is if path is null then it will
* be interpreted as /.
* getPath produces. The path
* will have all back references and parameters stripped.
*
* @param path the path that this URI is to be set with
*/
public void setPath(Path path) {
if(path != null){
normal = path;
}else {
setPath("/");
}
}
/**
* This is used to parse the path given with the setPath
* method. The path contains name and value pairs. These parameters
* are embedded into the path segments using a semicolon character,
* ';'. Since the parameters to not form part of the actual path
* mapping they are removed from the path and stored. Each parameter
* can then be extracted from this parser using the methods provided
* by the Address interface.
*
* @param path this is the path that is to be parsed and have the
* parameter values extracted
*/
private void parsePath(String path){
count = path.length();
ensureCapacity(count);
path.getChars(0, count, buf, 0);
normal = null;
off = 0;
path();
}
/**
* This will set the query to whatever value it is given. If the
* value is null then this Address.toString method
* will not contain the query. If the query was abc
* then the toString method would produca a string
* like http://host:port/path?abc. If the query is
* null this URI would have no query part. The query must not
* contain the ? character.
*
* @param value the query that this uniform resource identifier
* is to be set to if it is non-null
*/
public void setQuery(String value) {
query.value = value;
data = null;
}
/**
* This will set the query to whatever value it is given. If the
* value is null then this Address.toString method
* will not contain the query. If the Query.toString
* returns null then the query will be empty. This is basically
* the setQuery(String) method with the string value
* from the issued Query.toString method.
*
* @param query a Query object that contains
* the name value parameters for the query
*/
public void setQuery(Query query) {
if(value != null) {
data = query;
}else {
setQuery("");
}
}
/**
* This will check to see what type of URI this is if it is an
* absoluteURI or a relativeURI. To
* see the definition of a URI see RFC 2616 for the definition
* of a URL and for more specifics see RFC 2396 for the
* expressions.
*/
protected void parse(){
if(count > 0){
if(buf[0] == '/'){
relativeURI();
}else{
absoluteURI();
}
}
}
/**
* This will empty each tokens cache. A tokens cache is used
* to represent a token once the token's toString
* method has been called. Thus when the toString
* method is called then the token depends on the value of the
* cache alone in further calls to toString.
* However if a URI has just been parsed and that method has
* not been invoked then the cache is created from the buf if
* its length is greater than zero.
*/
protected void init(){
param.clear();
domain.clear();
path.clear();
query.clear();
scheme.clear();
off =port = 0;
normal = null;
data = null;
}
/**
* This is a specific definition of a type of URI. An absolute
* URI is a URI that contains a host and port. It is the most
* frequently used type of URI. This will define the host and
* the optional port part. As well as the relative URI part.
* This uses a simpler syntax than the one specified in RFC 2396
*
*
* absoluteURI = scheme ":" ("//" netpath | relativeURI)
* relativeURI = path ["?" querypart]
* netpath = domain [":" port] relativeURI
* path = *("/" segment)
* segment = *pchar *( ";" param )
*
* absoluteURI.
*/
private void absoluteURI(){
scheme();
netPath();
}
/**
* This will check to see if there is a scheme in the URI. If
* there is a scheme found in the URI this returns true and
* removes that scheme tag of the form "ftp:" or "http:"
* or whatever the protocol scheme tag may be for the URI.
*
*
* scheme = alpha *( alpha | digit | "+" | "-" | "." )
*
* gopher://domain/path then
* the URI would be domain/path afterwards.
*/
private void scheme(){
int mark = off;
int pos = off;
if(alpha(buf[off])){
while(off < count){
char next = buf[off++];
if(schemeChar(next)){
pos++;
}else if(next == ':'){
if(!skip("//")) {
off = mark;
pos = mark;
}
break;
}else{
off = mark;
pos = mark;
break;
}
}
scheme.len = pos - mark;
scheme.off = mark;
}
}
/**
* This method is used to assist the scheme method. This will
* check to see if the type of the character is the same as
* those described in RFC 2396 for a scheme character. The
* scheme tag can contain an alphanumeric of the following
* "+", "-", ".".
*
* @param c this is the character that is being checked
*
* @return this returns true if the character is a valid
* scheme character
*/
private boolean schemeChar(char c){
switch(c){
case '+': case '-':
case '.':
return true;
default:
return alphanum(c);
}
}
/**
* The network path is the path that contains the network
* address of the host that this URI is targeted at. This
* will parse the domain name of the host and also a port
* number before parsing a relativeURI
*
*
* netpath = domain [":" port] relativeURI
*
* relativeURI.
*/
private void relativeURI(){
path();
if(skip("?")){
query();
}
}
/**
* This is used to extract the optional port from a given URI.
* This will read a sequence of digit characters and convert
* the String of digit characters into a decimal
* number. The digits will be added to the port variable. If
* there is no port number this will not update the read offset.
*/
private void port() {
while(off < count){
if(!digit(buf[off])){
break;
}
port *= 10;
port += buf[off];
port -= '0';
off++;
}
}
/**
* This is used to extract the domain from the given URI. This
* will firstly initialize the token object that represents the
* domain. This allows the token's toString method to
* return the extracted value of the token rather than getting
* confused with previous values set by a previous parse method.
* ?,: and /. This
* ensures that the read offset does not go out of bounds and
* consequently throw an pair that was given. This
* will take all data up to the first occurence of a
* ':' character as the users name and all data after the
* colon as the users password.
*/
private void userpass(){
userid();
off++;
password();
}
/**
* Extracts the user name from the buffer. This will read up to
* the first occurence of a colon, ':', character as the user
* name. For the BNF syntax of this see RFC 2617.
*/
private void userid(){
while(off < count){
char ch = buf[off];
if(!text(ch) || ch ==':'){
break;
}
user.append(ch);
off++;
}
}
/**
* Extracts the password from the buffer. This will all characters
* from the current offset to the first non text character as the
* password. For the BNF syntax of this see RFC 2617.
*/
private void password() {
while(off < count){
char ch = buf[off];
if(!text(ch)){
break;
}
password.append(ch);
off++;
}
}
/**
* This is used to remove decode the IndexOutOfBoundsException.
*/
private void domain(){
int mark = off;
loop: while(off < count){
switch(buf[off]){
case '/': case ':':
case '?':
break loop;
default:
off++;
}
}
domain.len = off - mark;
domain.off = mark;
}
/**
* This is used to extract the segments from the given URI. This
* will firstly initialize the token object that represents the
* path. This allows the token's toString method to
* return the extracted value of the token rather than getting
* confused with previous values set by a previous parse method.
* IndexOutOfBoundsException.
*/
private void path(){
int mark = off;
int pos = off;
while(skip("/")) {
buf[pos++] = '/';
while(off < count){
if(buf[off]==';'){
while(skip(";")){
param();
insert();
}
break;
}
if(buf[off]=='%'){
escape();
}else if(!pchar(buf[off])){
break;
}
buf[pos++]=buf[off++];
}
}
path.len = pos -mark;
path.off = mark;
}
/**
* This is used to extract the query from the given URI. This
* will firstly initialize the token object that represents the
* query. This allows the token's toString method
* to return the extracted value of the token rather than getting
* confused with previous values set by a previous parse method.
* The calculation of the query part of a URI is basically the
* end of the URI.
*/
private void query() {
query.len = count - off;
query.off = off;
}
/**
* This is an expression that is defined by RFC 2396 it is used
* in the definition of a segment expression. This is basically
* a list of pchars.
* Token objects are set to have zero length so they
* can be reused to collect further values. This will add the
* values to the map as an array of type string. This is done so
* that if there are multiple values that they can be stored.
*/
private void insert(){
if(value.length() > 0){
if(name.length() > 0)
insert(name,value);
}
name.clear();
value.clear();
}
/**
* This will add the given name and value to the parameters map.
* This will only store a single value per parameter name, so
* only the parameter that was latest encountered will be saved.
* The getQuery method can be used to collect
* the parameter values using the parameter name.
*
* @param name this is the name of the value to be inserted
* @param value this is the value of a that is to be inserted
*/
private void insert(Token name, Token value){
insert(name.toString(), value.toString());
}
/**
* This will add the given name and value to the parameters map.
* This will only store a single value per parameter name, so
* only the parameter that was latest encountered will be saved.
* The getQuery method can be used to collect
* the parameter values using the parameter name.
*
* @param name this is the name of the value to be inserted
* @param value this is the value of a that is to be inserted
*/
private void insert(String name, String value) {
param.put(name, value);
}
/**
* This converts an encountered escaped sequence, that is all
* embedded hexidecimal characters into a native UCS character
* value. This does not take any characters from the stream it
* just prepares the buffer with the correct byte. The escaped
* sequence within the URI will be interpreded as UTF-8.
* "%" HEX HEX.
* This decodes the escaped sequence using UTF-8 encoding, all
* encoded sequences should be in UCS-2 to fit in a Java char.
*/
private void escape() {
int peek = peek(off);
if(!unicode(peek)) {
binary(peek);
}
}
/**
* This method determines, using a peek character, whether the
* sequence of escaped characters within the URI is binary data.
* If the data within the escaped sequence is binary then this
* will ensure that the next character read from the URI is the
* binary octet. This is used strictly for backward compatible
* parsing of URI strings, binary data should never appear.
*
* @param peek this is the first escaped character from the URI
*
* @return currently this implementation always returns true
*/
private boolean binary(int peek) {
if(off + 2 < count) {
off += 2;
buf[off]= bits(peek);
}
return true;
}
/**
* This method determines, using a peek character, whether the
* sequence of escaped characters within the URI is in UTF-8. If
* a UTF-8 character can be successfully decoded from the URI it
* will be the next character read from the buffer. This can
* check for both UCS-2 and UCS-4 characters. However, because
* the Java char can only hold UCS-2, the UCS-4
* characters will have only the low order octets stored.
* "%" HEX HEX
* sequences left. If successful the next character read is
* the UTF-8 sequence decoded into a native UCS-2 character.
*
* @param peek contains the bits read from the first UTF octet
* @param more this specifies the number of UTF octets left
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek, int more) {
if(off + more * 3 >= count) {
return false;
}
return unicode(peek,more,off);
}
/**
* This will decode the specified amount of trailing UTF-8 bits
* from the URI. The trailing bits are those following the first
* UTF-8 octet, which specifies the length, in octets, of the
* sequence. The trailing octets are if the form 10xxxxxx, for
* each of these octets only the last six bits are valid UCS
* bits. So a conversion is basically an accumulation of these.
* "%" HEX HEX, if so, then
* it will convert that hexidecimal string in to an integer
* value, or -1 if the expression is not hexidecimal.
*
* @param pos this is the position the expression starts from
*
* @return the integer value of the hexidecimal expression
*/
private int peek(int pos) {
if(buf[pos] == '%'){
if(count <= pos + 2) {
return -1;
}
char high = buf[pos + 1];
char low = buf[pos + 2];
return convert(high, low);
}
return -1;
}
/**
* This will convert the two hexidecimal characters to a real
* integer value, which is returned. This requires characters
* within the range of 'A' to 'F' and 'a' to 'f', and also
* the digits '0' to '9'. The characters encoded using the
* ISO-8859-1 encoding scheme, if the characters are not with
* in the range specified then this returns -1.
*
* @param high this is the high four bits within the integer
* @param low this is the low four bits within the integer
*
* @return this returns the indeger value of the conversion
*/
private int convert(char high, char low) {
int hex = 0x00;
if(hex(high) && hex(low)){
if('A' <= high && high <= 'F'){
high -= 'A' - 'a';
}
if(high >= 'a') {
hex ^= (high-'a')+10;
} else {
hex ^= high -'0';
}
hex <<= 4;
if('A' <= low && low <= 'F') {
low -= 'A' - 'a';
}
if(low >= 'a') {
hex ^= (low-'a')+10;
} else {
hex ^= low-'0';
}
return hex;
}
return -1;
}
/**
* This is used to determine wheather a char is a hexidecimal
* char or not. A hexidecimal character is consdered
* to be a character within the range of 0 - 9 and
* between a - f and A - F. This will
* return true if the character is in this range.
*
* @param ch this is the character which is to be determined here
*
* @return true if the character given has a hexidecimal value
*/
private boolean hex(char ch) {
if(ch >= '0' && ch <= '9') {
return true;
} else if(ch >='a' && ch <= 'f') {
return true;
} else if(ch >= 'A' && ch <= 'F') {
return true;
}
return false;
}
/**
* This is a character set defined by RFC 2396 it is used to
* determine the valididity of cetain chars
* within a Uniform Resource Identifier. RFC 2396 defines
* an unreserverd char as alphanum | mark.
*
* @param c the character value that is being checked
*
* @return true if the character has an unreserved value
*/
private boolean unreserved(char c){
return mark(c) || alphanum(c);
}
/**
* This is used to determine wheather or not a given unicode
* character is an alphabetic character or a digit character.
* That is withing the range 0 - 9 and between
* a - z it uses iso-8859-1 to
* compare the character.
*
* @param c the character value that is being checked
*
* @return true if the character has an alphanumeric value
*/
private boolean alphanum(char c){
return digit(c) || alpha(c);
}
/**
* This is used to determine wheather or not a given unicode
* character is an alphabetic character. This uses encoding
* iso-8859-1 to compare the characters.
*
* @param c the character value that is being checked
*
* @return true if the character has an alphabetic value
*/
private boolean alpha(char c){
return (c <= 'z' && 'a' <= c) ||
(c <= 'Z' && 'A' <= c);
}
/**
* This is a character set defined by RFC 2396 it checks
* the valididity of cetain chars within a uniform resource
* identifier. The RFC 2396 defines a mark char as "-",
* "_", ".", "!", "~", "*", "'", "(", ")".
*
* @param c the character value that is being checked
*
* @return true if the character is a mark character
*/
private boolean mark(char c){
switch(c){
case '-': case '_': case '.':
case '!': case '~': case '*':
case '\'': case '(': case ')':
return true;
default:
return false;
}
}
/**
* This is a character set defined by RFC 2396 it is used to check
* the valididity of cetain chars within a generic uniform resource
* identifier. The RFC 2396 defines a pchar char as unreserved or
* escaped or one of the following characters ":", "@", "=",
* "&", "+", "$", "," this will not check to see if the
* char is an escaped char, that is % HEX HEX. Because
* this takes 3 chars.
*
* @param c the character value that is being checked
*
* @return true if the character is a pchar character
*/
private boolean pchar(char c){
switch(c){
case '@': case '&': case '=':
case '+': case '$': case ',':
case ':':
return true;
default:
return unreserved(c);
}
}
/**
* This is a character set defined by RFC 2396, it checks the
* valididity of certain chars in a uniform resource identifier.
* The RFC 2396 defines a reserved char as ";", "/", "?",
* ":", "@", "&", "=", "+", "$", ",".
*
* @param c the character value that is being checked
*
* @return true if the character is a reserved character
*/
private boolean reserved(char c){
switch(c){
case ';': case '/': case '?':
case '@': case '&': case ':':
case '=': case '+': case '$':
case ',':
return true;
default:
return false;
}
}
/**
* This is used to convert this URI object into a String
* object. This will only convert the parts of the URI that exist, so
* the URI may not contain the domain or the query part and it will
* not contain the path parameters. If the URI contains all these
* parts then it will return somthing like
*
* scheme://host:port/path/path?querypart
*
* /path/path?querypart style relative
* URI's. If any of the parts are set to null then that part will be
* missing, for example if setDomain method is invoked
* with a null parameter then the domain and port will be missing
* from the resulting URI. If the path part is set to null using the
* setPath then the path will be /. An
* example URI with the path part of null would be
*
* scheme://host:port/?querypart
*
*
* @return the URI with only the path part and the non-null optional
* parts of the uniform resource identifier
*/
public String toString() {
return (scheme.length() > 0 ? scheme +"://": "") +
(domain.length() > 0 ? domain +
(port > 0 ? ":"+port : "") : "")+ getPath() +
(param.size() > 0 ? param : "")+
(query.length()>0?"?"+query :"");
}
/**
* The ParameterMap is uses to store the parameters
* that are to be encoded in to the address. This will append all
* of the parameters to the end of the path. These can later be
* extracted by parsing the address.
*
* @author Niall Gallagher
*/
private class ParameterMap extends KeyMapParseBuffer
* for extracting tokens from the URI without allocating memory.
* This will basically mark out regions within the buffer which are
* used to represent the token. When the token value is required
* the region is used to create a String object.
*/
private class Token implements Serializable {
/**
* This can be used to override the value for this token.
*/
public String value;
/**
* This represents the start offset within the buffer.
*/
public int off;
/**
* This represents the number of charters in the token.
*/
public int len;
/**
* If the Token is to be reused this will clear
* all previous data. Clearing the buffer allows it to be
* reused if there is a new URI to be parsed. This ensures
* that a null is returned if the token length is zero.
*/
public void clear() {
value = null;
len = 0;
}
/**
* This is used to determine the number of characters this
* token contains. This is used rather than accessing the
* length directly so that the value the token represents
* can be overridden easily without upsetting the token.
*
* @return this returns the number of characters this uses
*/
public int length() {
if(value == null){
return len;
}
return value.length();
}
/**
* This method will convert the Token into it's
* String equivelant. This will firstly check
* to see if there is a value, for the string representation,
* if there is the value is returned, otherwise the region
* is converted into a String and returned.
*
* @return this returns a value representing the token
*/
public String toString() {
if(value != null) {
return value;
}
if(len > 0) {
value = new String(buf,off,len);
}
return value;
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/ContentParser.java 0000664 0000000 0000000 00000041400 12536602605 0026361 0 ustar 00root root 0000000 0000000 /*
* ContentParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher charset parameter is one of many parameters that
* can be associated with a MIME type. This however this exposes this
* parameter with a typed method.
* getCharset will return the character encoding the
* content type is encoded within. This allows the user of the content
* to decode it correctly. Other parameters can be acquired from this
* by simply providing the name of the parameter.
*
* @author Niall Gallagher
*/
public class ContentParser extends Parser implements ContentType {
/**
* Used to store the characters consumed for the subtype.
*/
private ParseBuffer subtype;
/**
* Used to store the characters for the charset.
*/
private ParseBuffer charset;
/**
* Used to store the characters consumed for the type.
*/
private ParseBuffer type;
/**
* Used to collect the name of a content type parameter.
*/
private ParseBuffer name;
/**
* Used to collect the value of the content type parameter.
*/
private ParseBuffer value;
/**
* Used to store the name value pairs of the parameters.
*/
private KeyMapContentParser
* that contains no charset, type or subtype. This can be used to
* extract the type, subtype and the optional charset
* parameter by using the parser's parse(String)
* method.
*/
public ContentParser(){
this.subtype = new ParseBuffer();
this.charset = new ParseBuffer();
this.value = new ParseBuffer();
this.name = new ParseBuffer();
this.type = new ParseBuffer();
this.map = new KeyMapString given to extract the MIME type. This
* could be achived by calling the default no-arg constructor
* and then using the instance to invoke the parse
* method on that String.
*
* @param header String containing a MIME type value
*/
public ContentParser(String header){
this();
parse(header);
}
/**
* This sets the primary type to whatever value is in the string
* provided is. If the string is null then this will contain a
* null string for the primary type of the parameter, which is
* likely invalid in most cases.
*
* @param primary the type to set for the primary type of this
*/
public void setPrimary(String primary) {
type.reset(primary);
}
/**
* This is used to retrieve the primary type of this MIME type. The
* primary type part within the MIME type defines the generic type.
* For example text/plain; charset=UTF-8. This will
* return the text value. If there is no primary type then this
* will return null otherwise the string value.
*
* @return the primary type part of this MIME type
*/
public String getPrimary() {
return type.toString();
}
/**
* This sets the secondary type to whatever value is in the string
* provided is. If the string is null then this will contain a
* null string for the secondary type of the parameter, which is
* likely invalid in most cases.
*
* @param type the type to set for the primary type of this
*/
public void setSecondary(String type) {
subtype.reset(type);
}
/**
* This is used to retrieve the secondary type of this MIME type.
* The secondary type part within the MIME type defines the generic
* type. For example text/html; charset=UTF-8. This
* will return the HTML value. If there is no secondary type then
* this will return null otherwise the string value.
*
* @return the primary type part of this MIME type
*/
public String getSecondary(){
return subtype.toString();
}
/**
* This will set the charset to whatever value the
* string contains. If the string is null then this will not set
* the parameter to any value and the toString method
* will not contain any details of the parameter.
*
* @param enc parameter value to add to the MIME type
*/
public void setCharset(String enc) {
charset.reset(enc);
}
/**
* This is used to retrieve the charset of this MIME
* type. This is a special parameter associated with the type, if
* the parameter is not contained within the type then this will
* return null, which typically means the default of ISO-8859-1.
*
* @return the value that this parameter contains
*/
public String getCharset() {
return charset.toString();
}
/**
* This is used to retrieve an arbitrary parameter from the MIME
* type header. This ensures that values for boundary
* or other such parameters are not lost when the header is parsed.
* This will return the value, unquoted if required, as a string.
*
* @param name this is the name of the parameter to be retrieved
*
* @return this is the value for the parameter, or null if empty
*/
public String getParameter(String name) {
return map.get(name);
}
/**
* This will add a named parameter to the content type header. If
* a parameter of the specified name has already been added to the
* header then that value will be replaced by the new value given.
* Parameters such as the boundary as well as other
* common parameters can be set with this method.
*
* @param name this is the name of the parameter to be added
* @param value this is the value to associate with the name
*/
public void setParameter(String name, String value) {
map.put(name, value);
}
/**
* This will initialize the parser when it is ready to parse
* a new String. This will reset the parser to a
* ready state. The init method is invoked by the parser when
* the Parser.parse method is invoked.
*/
protected void init(){
if(count > 0) {
pack();
}
clear();
}
/**
* This is used to clear all previously collected tokens. This
* allows the parser to be reused when there are multiple source
* strings to be parsed. Clearing of the tokens is performed
* when the parser is initialized.
*/
private void clear() {
type.clear();
subtype.clear();
charset.clear();
name.clear();
value.clear();
map.clear();
off = 0;
}
/**
* Reads and parses the MIME type from the given String
* object. This uses the syntax defined by RFC 2616 for the media-type
* syntax. This parser is only concerned with one parameter, the
* charset parameter. The syntax for the media type is
*
* media-type = token "/" token *( ";" parameter )
* parameter = token | literal
*
*/
protected void parse(){
type();
off++;
subtype();
parameters();
}
/**
* This is used to remove all whitespace characters from the
* String excluding the whitespace within literals.
* The definition of a literal can be found in RFC 2616.
* ParseBuffer. This will read all chars
* upto but not including the first instance of a '/'. The type
* of a media-type as defined by RFC 2616 is
* type/subtype;param=val;param2=val.
*/
private void type(){
while(off < count){
if(buf[off] =='/'){
break;
}
type.append(buf[off]);
off++;
}
}
/**
* This reads the subtype from the MIME type. This will fill the
* subtype ParseBuffer. This will read all chars
* upto but not including the first instance of a ';'. The subtype
* of a media-type as defined by RFC 2616 is
* type/subtype;param=val;param2=val.
*/
private void subtype(){
while(off < count){
if(buf[off] ==';'){
break;
}
subtype.append(buf[off]);
off++;
}
}
/**
* This will read the parameters from the MIME type. This will search
* for the charset parameter within the set of parameters
* which are given to the type. The charset param is the
* only parameter that this parser will tokenize.
* charset is retrived the MIME type is considered
* to be parsed.
*/
private void parameters(){
while(skip(";")){
if(skip("charset=")){
charset();
break;
}else{
parameter();
insert();
}
}
}
/**
* This will add the name and value tokens to the parameters map.
* If any previous value of the given name has been inserted
* into the map then this will overwrite that value. This is
* used to ensure that the string value is inserted to the map.
*/
private void insert() {
insert(name, value);
}
/**
* This will add the given name and value to the parameters map.
* If any previous value of the given name has been inserted
* into the map then this will overwrite that value. This is
* used to ensure that the string value is inserted to the map.
*
* @param name this is the name of the value to be inserted
* @param value this is the value of a that is to be inserted
*/
private void insert(ParseBuffer name, ParseBuffer value) {
map.put(name.toString(), value.toString());
}
/**
* This is a parameter as defined by RFC 2616. The parameter is added to a
* MIME type e.g. type/subtype;param=val etc. The parameter
* name and value are not stored. This is used to simply update the read
* offset past the parameter. The reason for reading the parameters is to
* search for the charset parameter which will indicate the
* encoding.
*/
private void parameter(){
name();
off++; /* = */
value();
}
/**
* This will simply read all characters from the buffer before the first '='
* character. This represents a parameter name (see RFC 2616 for token). The
* parameter name is not buffered it is simply read from the buffer. This will
* not cause an IndexOutOfBoundsException as each offset
* is checked before it is acccessed.
*/
private void name(){
while(off < count){
if(buf[off] =='='){
break;
}
name.append(buf[off]);
off++;
}
}
/**
* This is used to read a parameters value from the buf. This will read all
* char's upto but excluding the first terminal char
* encountered from the off within the buf, or if the value is a literal
* it will read a literal from the buffer (literal is any data between
* quotes except if the quote is prefixed with a backward slash character).
*/
private void value(){
if(quote(buf[off])){
for(off++; off < count;){
if(quote(buf[off])){
if(buf[++off-2]!='\\'){
break;
}
}
value.append(buf[off++]);
}
}else{
while(off < count){
if(buf[off] ==';') {
break;
}
value.append(buf[off]);
off++;
}
}
}
/**
* This method is used to determine if the specified character is a quote
* character. The quote character is typically used as a boundary for the
* values within the header. This accepts a single or double quote.
*
* @param ch the character to determine if it is a quotation
*
* @return true if the character provided is a quotation character
*/
private boolean quote(char ch) {
return ch == '\'' || ch == '"';
}
/**
* This is used to read the value from the charset param.
* This will fill the charset ParseBuffer and with
* the charset value. This will read a literal or a token as
* the charset value. If the charset is a literal
* then the quotes will be read as part of the charset.
*/
private void charset(){
if(buf[off] == '"'){
charset.append('"');
for(off++; off < count;){
charset.append(buf[off]);
if(buf[off++]=='"')
if(buf[off-2]!='\\'){
break;
}
}
}else{
while(off < count){
if(buf[off]==';') {
break;
}
charset.append(buf[off]);
off++;
}
}
}
/**
* This will return the value of the MIME type as a string. This
* will concatenate the primary and secondary type values and
* add the charset parameter to the type which will
* recreate the content type.
*
* @return this returns the string representation of the type
*/
private String encode() {
StringBuilder text = new StringBuilder();
if(type != null) {
text.append(type);
text.append("/");
text.append(subtype);
}
if(charset.length() > 0) {
text.append("; charset=");
text.append(charset);
}
return encode(text);
}
/**
* This will return the value of the MIME type as a string. This
* will concatenate the primary and secondary type values and
* add the charset parameter to the type which will
* recreate the content type.
*
* @param text this is the buffer to encode the parameters to
*
* @return this returns the string representation of the type
*/
private String encode(StringBuilder text) {
for(String name : map) {
String value = map.get(name);
text.append("; ");
text.append(name);
if(value != null) {
text.append("=");
text.append(value);;
}
}
return text.toString();
}
/**
* This will return the value of the MIME type as a string. This
* will concatenate the primary and secondary type values and
* add the charset parameter to the type which will
* recreate the content type.
*
* @return this returns the string representation of the type
*/
public String toString() {
return encode();
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/CookieParser.java 0000664 0000000 0000000 00000046061 12536602605 0026170 0 ustar 00root root 0000000 0000000 /*
* CookieParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
*
* cookie = "Cookie:" cookie-version
* 1*((";" | ",") cookie-value)
* cookie-value = NAME "=" VALUE [";" path] [";" domain]
* cookie-version = "$Version" "=" value
* NAME = attr
* VALUE = value
* path = "$Path" "=" value
* domain = "$Domain" "=" value
*
*
* The cookie header may consist of several cookies. Each cookie can be
* extracted from the header by examining the it syntax of the cookie
* header. The syntax of the cookie header is defined in RFC 2109.
* $Version attribute followed by multiple
* cookies. Each contains a name and a value, followed by an optional
* $Path and $Domain attribute. This will parse
* a given cookie header and return each cookie extracted as a
* Cookie object.
*
* @author Niall Gallagher
*/
public class CookieParser extends Parser implements IterableParser has finished.
*/
private boolean finished;
/**
* Used so the Parser does not parse twice.
*/
private boolean parsed;
/**
* Version of the Cookie being parsed.
*/
private int version;
/**
* Used to store the name of the Cookie.
*/
private Token name;
/**
* Used to store the value of the Cookie.
*/
private Token value;
/**
* Used to store the $Path values.
*/
private Token path;
/**
* Used to store the $Domain values.
*/
private Token domain;
/**
* Create a CookieParser that contains no cookies.
* the instance will return false for the
* hasNext method. cookies may be parsed using
* this instance by using the parse method.
*/
public CookieParser(){
this.path = new Token();
this.domain = new Token();
this.name = new Token();
this.value = new Token();
this.finished = true;
}
/**
* This is primarily a convineance constructor. This will parse the
* String given to extract the cookies. This could be
* achived by calling the default no-arg constructor and then using
* the instance to invoke the parse method on that
* String.
*
* @param header a String containing a cookie value
*/
public CookieParser(String header){
this();
parse(header);
}
/**
* Resets the cookie and the buffer variables for this
* CookieParser. It is used to set the
* state of the parser to start parsing a new cookie.
*/
protected void init() {
finished = false;
parsed =false;
version = 0;
off = 0;
version();
}
/**
* This will extract the next Cookie from the
* buffer. If all the characters in the buffer have already
* been examined then this method will simply do nothing.
* Otherwise this will parse the remainder of the buffer
* and (if it follows RFC 2109) produce a Cookie.
*/
protected void parse() {
if(!finished){
cookie();
parsed=true;
}
}
/**
* This is used to skip an arbitrary String within the
* char buf. It checks the length of the String
* first to ensure that it will not go out of bounds. A comparison
* is then made with the buffers contents and the String
* if the reigon in the buffer matched the String then the
* offset within the buffer is increased by the String's
* length so that it has effectively skipped it.
* skip method will ignore all of the whitespace text.
* This will also skip trailing spaces within the the input text and
* all spaces within the source text. For example if the input was
* the string "s omete xt" and the source was "some text to skip" then
* the result of a skip ignoring spaces would be "to skip" in the
* source string, as the trailing spaces are also eaten by this.
*
* @param text this is the String value to be skipped
*
* @return true if the String was skipped
*/
protected boolean skip(String text){
int size = text.length();
int seek = off;
int read = 0;
if(off + size > count){
return false;
}
while(read < size) {
char a = text.charAt(read);
char b = buf[seek];
if(space(b)){
if(++seek >= count){
return false;
}
}else if(space(a)){
if(++read >= size) {
continue;
}
}else {
if(toLower(a) != toLower(b)){
return false;
}
read++;
seek++;
}
}
for(off = seek; off < count; off++){
if(!space(buf[off]))
break;
}
return true;
}
/**
* This is used to acquire the cookie values from the provided
* the provided source text. This allows the cookie parser to be
* used within a for each loop to parse out the values of a
* cookie one by one so that they may be used or stored.
*
* @return this returns an iterator for extracting cookie value
*/
public IteratorCookies
* can be reiterated. This allows the collection to be reused.
* The reset method will invoke the super classes
* init method. This will reinitialize this
* Parser so the cookie will be reparsed.
*/
public void reset() {
init();
parse();
}
/**
* Creates the Cookie from the token objects. It is
* assumed that the Cookie String has
* been parsed when this is called. This should only be used after
* the parse method has been called.
* $Domain or $Path
* within the Cookie String then the
* getDomain and getPath are null.
*
* @return the Cookie that was just parsed
*/
private Cookie getCookie() {
return getCookie(name.toString(),
value.toString());
}
/**
* Creates the Cookie from the token objects. It is
* assumed that the Cookie String has
* been parsed when this is called. This should only be used after
* the parse method has been called.
* $Domain or $Path
* within the Cookie String then the
* getDomain and getPath are null.
*
* @param name the name that the Cookie contains
* @param value the value that the Cookie contains
*
* @return the Cookie that was just parsed
*/
private Cookie getCookie(String name, String value) {
Cookie cookie = new Cookie(name, value, false);
if(domain.len > 0) {
cookie.setDomain(domain.toString());
}
if(path.len > 0) {
cookie.setPath(path.toString());
}
cookie.setVersion(version);
return cookie;
}
/**
* This is used to parse a Cookie from the buffer
* that contains the Cookie values. This will first
* try to remove any trailing value after the version/prev
* Cookie once this is removed it will extract the
* name/value pair from the Cookie. The name and
* value of the Cookie will be saved by the name
* and value tokens.
*/
private void cookie(){
if(!skip(",")){ /* ,|; */
skip(";");
}
name();
skip("="); /* = */
value();
}
/**
* This initializes the name token and extracts the name of this
* Cookie. The offset and length of the name will be
* saved in the name token. This will read all char's
* upto but excluding the first '=' char encountered
* from the off within the buffer.
*/
private void name() {
name.off = off;
name.len = 0;
while(off < count){
if(buf[off] == '='){
break;
}
name.len++;
off++;
}
}
/**
* Used to extract everything found after the NAME '='
* within a Cookie. This extracts the Cookie
* value the $Path and $Domain attributes
* if they exist (i.e. $Path and $Domain
* are optional in a cookie see RFC 2109).
* domain method that is ";$Path" is read as the first
* part of the path method. This is because if there is no path the
* parser should not read data it does not know belongs to a specific
* part of the Cookie.
*/
private void value() {
data();
path();
domain();
}
/**
* This initializes the value token and extracts the value of this
* Cookie. The offset and length of the value will be
* saved in the value token. This will read all char's
* upto but excluding the first terminal char encountered from the
* off within the buffer, or if the value is a literal it will read
* a literal from the buffer (literal is any data between quotes
* except if the quote is prefixed with a backward slash character
* that is '\').
*/
private void data() {
value.off = off;
value.len = 0;
if(off < count && buf[off] == '"'){
value.len++;
for(off++; off < count;){
value.len++;
if(buf[off++]=='"')
if(buf[off-2]!='\\'){
break;
}
}
value.len-=2; /* remove " */
value.off++; /* remove " */
}else {
while(off < count){
if(terminal(buf[off]))
break;
value.len++;
off++;
}
}
}
/**
* This initializes the path token and extracts the $Path
* of this Cookie. The offset and length of the path will
* be saved in the path token. This will read all char's
* up to but excluding the first terminal char encountered
* from the off within the buffer, or if the value is a
* literal it will read a literal from the buffer (literal is any data
* between quotes except if the quote is prefixed with a backward slash
* character, that is '\').
* $Path so that if
* there is no $Path for the Cookie then
* the character before it will not be read needlessly.
*/
private void path() {
path.len = 0; /* reset */
if(skip(";$Path=")){
path.off = off;
if(buf[off] == '"'){
path.len++;
for(off++; off < count;){
path.len++;
if(buf[off++]=='"')
if(buf[off-2]!='\\'){
break;
}
}
path.len-=2; /* remove " */
path.off++; /* remove " */
}else{
while(off < count){
if(terminal(buf[off]))
break;
path.len++;
off++;
}
}
}
}
/**
* Initializes the domain token and extracts the $Domain
* of this Cookie. The offset and length of the domain
* will be saved in the path token. This will read all characters up
* to but excluding the first terminal char encountered
* from the off within the buffer, or if the value is a literal it
* will read a literal from the buffer (literal is any data between
* quotes except if the quote is prefixed with a backward slash
* character, that is '\').
* $Domain so that
* if there is no $Domain for the Cookie
* then the character before it will not be read needlessly.
*/
private void domain(){
domain.len = 0; /* reset */
if(skip(";$Domain=")) {
domain.off = off;
if(buf[off] == '"'){
domain.len++;
for(off++; off < count;){
domain.len++;
if(buf[off++]=='"')
if(buf[off-2]!='\\'){
break;
}
}
domain.len-=2; /* remove " */
domain.off++; /* remove " */
}else{
while(off < count){
if(terminal(buf[off]))
break;
domain.len++;
off++;
}
}
}
}
/**
* This extracts the $Version of this Cookie.
* The version is parsed and converted into a decimal int from the digit
* characters that make up a version.
* char's up to but excluding the
* first non digit char that it encounters from the offset
* within the buffer, or if the value is a literal it will read a literal
* from the buffer (literal is any data between quotes except if the quote
* is prefixed with a backward slash character i.e. '\').
*/
private void version(){
if(skip("$Version=")) {
if(buf[off] == '"'){
off++;
}
while(off < count){
if(!digit(buf[off])){
break;
}
version *= 10;
version += buf[off];
version -= '0';
off++;
}
if(buf[off] == '"'){
off++;
}
}else{
version = 1;
}
}
/**
* This is used to determine if a given iso8859-1 character is
* a terminal character. That is either the ';' or ','
* characters. Although the RFC 2109 says the terminal can be
* either a comma, it is not used by any browsers.
*
* @param ch the character that is to be compared
*
* @return true if this is a semicolon character
*/
private boolean terminal(char ch) {
return ch == ';';
}
/**
* This is used to represent an Iterator that will
* iterate over the available cookies within the provided source
* text. This allows the cookie parser to be used as an iterable
* with for each loops. Cookies can not be removed with this.
*
* @author Niall Gallagher
*/
private class Sequence implements IteratorCookie object from the string
* given. This will return null when there are no
* more cookies left in the String being parsed.
* hasNext method. This will only set the name,
* value, path, domain name version of the cookie
* because as of RFC 2109 these are the only attributes a
* Cookie may have, the path and domain are
* optional.
*
* @return an initialized Cookie object
*/
public Cookie next(){
if(!hasNext()) {
return null;
}
parsed = false;
return getCookie();
}
/**
* Determine whether or not there are any Cookies
* left in the String. This will attempt to extract
* another Cookie from the String and
* cache the result so the next method will produce
* this Cookie. If another Cookie cannot
* be parsed from the remainder of the String then
* this will return false otherwise it will return
* true.
*
* @return true if there are more cookies false otherwise
*/
public boolean hasNext(){
if(finished) {
return false;
}
if(parsed) {
return true;
}
parse();
if(name.len <=0){
finished = true;
return false;
}
return true;
}
/**
* This method is used to remove items from the iterator. This
* however performs no action as the act of parsing should not
* modify the underlying source text value so that it can be
* reset with the reset method and used again.
*/
public void remove() {
return;
}
}
/**
* This is a token object that is used to store the offset and
* length of a region of chars in the CookieParser.buf
* array. The toString method of this token will
* produce the String value of the region it
* represents.
*/
private class Token {
/**
* The numer of characters that were consumed by this token.
*/
public int len;
/**
* The offset within the buffer that this token starts from.
*/
public int off;
/**
* This converts region within the buffer to a String.
* This converts the region only if there is a sufficient length.
*
* @return the String value of the region
*/
public String toString(){
return new String(buf,off,len);
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/DateParser.java 0000664 0000000 0000000 00000046354 12536602605 0025641 0 ustar 00root root 0000000 0000000 /*
* DateParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Parser for the HTTP date format.
* This will parse the 3 formats that are acceptable for the HTTP/1.1 date.
* The three formats that are acceptable for the HTTP-date are
*
* Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
* Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
* Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
*
* System's
* System.currentTimeMillis method. This has a parse method for a
* long which will do the same as the parse(String).
* Once the date has been parsed there are two methods that allow the date
* to be represented, the toLong method converts the date to a
* long and the toString method will convert the date
* into a String.
* SimpleDateFormat.format
* using the pattern "EEE, dd MMM yyyy hh:mm:ss 'GMT'". This will
* however do the job faster as it does not take arbitrary inputs.
*
* @author Niall Gallagher
*/
public class DateParser extends Parser {
/**
* Ensure that the time zone for dates if set to GMT.
*/
private static final TimeZone ZONE = TimeZone.getTimeZone("GMT");
/**
* Contains the possible days of the week for RFC 1123.
*/
private static final String WKDAYS[] =
{ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
/**
* Contains the possible days of the week for RFC 850.
*/
private static final String WEEKDAYS[] =
{ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };
/**
* Contains the possible months in the year for HTTP-date.
*/
private static final String MONTHS[] =
{ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
/**
* Used as an index into the months array to get the month.
*/
private int month;
/**
* Represents the decimal value of the date such as 1977.
*/
private int year;
/**
* Represents the decimal value of the date such as 18.
*/
private int day;
/**
* Used as an index into the weekdays array to get the weekday.
*/
private int weekday;
/**
* Represents the decimal value of the hour such as 24.
*/
private int hour;
/**
* Represents the decimal value of the minute.
*/
private int mins;
/**
* Represents the decimal value for the second.
*/
private int secs;
/**
* The parser contains this method so that the a date does not
* have to be parsed from System.currentTimeMillis.
* This returns a date using a DataParser.parse(long)
* method invocation.
*
* @return this returns a RFC 1123 date for the current time
*/
public static String getDate() {
long time = System.currentTimeMillis();
return new DateParser(time).toString();
}
/**
* The default constructor will create a parser that can parse
* Strings that contain dates in the form of RFC 1123,
* RFC 850 or asctime. If the dates that are to be parsed are not in
* the form of one of these date encodings the results of this
* parser will be random.
*/
public DateParser(){
this.init();
}
/**
* This constructor will conveniently parse the long argument
* in the constructor. This can also be done by first calling the no-arg
* constructor and then using the parse method.
* String
* argument in the constructor. This can also be done by first calling
* the no-arg constructor and then using the parse method.
* long. If this
* method is given the value of the date as a long it will
* construct the RFC 1123 date as required by RFC 2616 sec 3.3.
* String that is encoded in
* the HTTP-date format. The date given must be positive, if the date
* given is not a positive 'long' then the results
* of this method is random/unknown.
*
* @param date the date to be parsed
*/
public void parse(long date){
Calendar calendar = Calendar.getInstance(ZONE);
calendar.setTimeInMillis(date);
weekday = calendar.get(Calendar.DAY_OF_WEEK);
year = calendar.get(Calendar.YEAR);
month = calendar.get(Calendar.MONTH);
day = calendar.get(Calendar.DAY_OF_MONTH);
hour = calendar.get(Calendar.HOUR_OF_DAY);
mins = calendar.get(Calendar.MINUTE);
secs = calendar.get(Calendar.SECOND);
month = month > 11 ? 11: month;
weekday = (weekday+5) % 7;
}
/**
* Convenience method used to convert the specified HTTP date in to a
* long representing the time. This is used when a single method is
* required to convert a HTTP date format to a usable long value for
* use in creating Date objects.
*
* @param date the date specified in on of the HTTP date formats
*
* @return the date value as a long value in milliseconds
*/
public long convert(String date) {
parse(date);
return toLong();
}
/**
* Convenience method used to convert the specified long date in to a
* HTTP date format. This is used when a single method is required to
* convert a long data value in milliseconds to a HTTP date value.
*
* @param date the date specified as a long of milliseconds
*
* @return the date represented in the HTTP date format RFC 1123
*/
public String convert(long date) {
parse(date);
return toString();
}
/**
* This is used to reset the date and the buffer variables
* for this DateParser. Every in is set to the
* value of 0.
*/
protected void init() {
month = year = day =
weekday = hour = mins =
secs = off = 0;
}
/**
* This is used to parse the contents of the buf. This
* checks the fourth char of the buffer to see what it contains. Invariably
* a date format belonging to RFC 1123 will have a ',' character in position 4,
* a date format belonging to asctime will have a ' ' character in position 4
* and if neither of these characters are found at position 4 then it is
* assumed that the date is in the RFC 850 fromat, however it may not be.
*/
protected void parse(){
if(buf.length<4)return;
if(buf[3]==','){
rfc1123();
}else if(buf[3]==' '){
asctime();
}else{
rfc850();
}
}
/**
* This will parse a date that is in the form of an RFC 1123 date. This
* date format is the date format that is to be used with all applications
* that are HTTP/1.1 compliant. The RFC 1123 date format is
*
* rfc1123 = 'wkday "," SP date1 SP time SP GMT'.
* date1 = '2DIGIT SP month SP 4DIGIT' and finally
* time = '2DIGIT ":" 2DIGIT ":" 2DIGIT'.
*
*/
private void rfc1123(){
wkday();
off+=2;
date1();
off++;
time();
}
/**
* This will parse a date that is in the form of an RFC 850 date. This date
* format is the date format that is to be used with some applications that
* are HTTP/1.0 compliant. The RFC 1123 date format is
*
* rfc850 = 'weekday "," SP date2 SP time SP GMT'.
* date2 = '2DIGIT "-" month "-" 2DIGIT' and finally
* time = '2DIGIT ":" 2DIGIT ":" 2DIGIT'.
*
*/
private void rfc850() {
weekday();
off+=2;
date2();
off++;
time();
}
/**
* This will parse a date that is in the form of an asctime date. This date
* format is the date format that is to be used with some applications that
* are HTTP/1.0 compliant. The RFC 1123 date format is
*
* asctime = 'weekday SP date3 SP time SP 4DIGIT'.
* date3 = 'month SP (2DIGIT | (SP 1DIGIT))' and
* time = '2DIGIT ":" 2DIGIT ":" 2DIGIT'.
*
*/
private void asctime(){
wkday();
off++;
date3();
off++;
time();
off++;
year4();
}
/**
* This is the date1 format of a date that is used by the RFC 1123
* date format. This date is
*
* date1 = '2DIGIT SP month SP 4DIGIT'.
* example '02 Jun 1982'.
*
*/
private void date1(){
day();
off++;
month();
off++;
year4();
}
/**
* This is the date2 format of a date that is used by the RFC 850
* date format. This date is
*
* date2 = '2DIGIT "-" month "-" 2DIGIT'
* example '02-Jun-82'.
*
*/
private void date2(){
day();
off++;
month();
off++;
year2();
}
/**
* This is the date3 format of a date that is used by the asctime
* date format. This date is
*
* date3 = 'month SP (2DIGIT | (SP 1DIGIT))'
* example 'Jun 2'.
*
*/
private void date3(){
month();
off++;
day();
}
/**
* This is used to parse a consecutive set of digit characters to create
* the day of the week. This will tolerate a space on front of the digits
* thiswill allow all date formats including asctime to use this to get
* the day. This may parse more than 2 digits, however if there are more
* than 2 digits the date format is incorrect anyway.
*/
private void day(){
if(space(buf[off])){
off++;
}
while(off < count){
if(!digit(buf[off])){
break;
}
day *= 10;
day += buf[off];
day -= '0';
off++;
}
}
/**
* This is used to get the year from a set of digit characters. This is
* used to parse years that are of the form of 2 digits (e.g 82) however
* this will assume that any dates that are in 2 digit format are dates
* for the 2000 th milleneum so 01 will be 2001.
* 00:00:00 that is
*
* time = '2DIGIT ":" 2DIGIT ":" 2DIGIT' so this will
* read only a time of that form, although this will
* parse time = '2DIGIT CHAR 2DIGIT CHAR 2DIGIT'.
*
*/
private void time(){
hours();
off++;
mins();
off++;
secs();
}
/**
* This is used to initialize the hour. This will read a consecutive
* sequence of digit characters and convert them into a decimal number
* to represent the hour that this date represents.
*
* Tue, 02 Jun 1982
* .
* For performance reasons a string builder is used. This avoids
* an unneeded synchronization caused by the string buffers.
*
* @param builder this is the builder to append the date to
*/
private void date(StringBuilder builder) {
builder.append(WKDAYS[weekday]);
builder.append(", ");
if(day <= 9) {
builder.append('0');
}
builder.append(day);
builder.append(' ');
builder.append(MONTHS[month]);
builder.append(' ');
builder.append(year);
builder.append(' ');
}
/**
* This is used to append the time in RFC 1123 format to the given
* string builder. This will append the time and a trailing space
* character to the buffer. Times like the following are appended.
*
* 23:59:59
* .
* For performance reasons a string builder is used. This avoids
* an unneeded synchronization caused by the string buffers.
*
* @param builder this is the builder to write the time to
*/
private void time(StringBuilder builder) {
if(hour <= 9) {
builder.append('0');
}
builder.append(hour);
builder.append(':');
if(mins <= 9) {
builder.append('0');
}
builder.append(mins);
builder.append(':');
if(secs <= 9) {
builder.append('0');
}
builder.append(secs);
builder.append(' ');
}
/**
* This is used to append the time zone to the provided appender.
* For HTTP the dates should always be in GMT format. So this will
* simply append the "GMT" string to the end of the builder.
*
* @param builder this builder to append the time zone to
*/
private void zone(StringBuilder builder) {
builder.append("GMT");
}
/**
* This returns the date in as a long, given the exact
* time this will use the java.util.Date to parse this date
* into a long. The GregorianCalendar uses
* the method getTime which produces the Date
* object from this the getTime returns the long
*
* @return the date parsed as a long
*/
public long toLong() {
Calendar calendar = Calendar.getInstance(ZONE); /* GMT*/
calendar.set(year,month, day, hour, mins, secs);
return calendar.getTime().getTime();
}
/**
* This prints the date in the format of a RFC 1123 date. Example
*
* Tue, 02 Jun 1982 23:59:59 GMT
* .
* This uses a StringBuffer to accumulate the various
* Strings/ints to form the resulting date
* value. The resulting date value is the one required by RFC 2616.
* Accept-Language
* header. This takes in an Accept-Language header and parses
* it according the RFC 2616 BNF for the Accept-Language header.
* This also has the ability to sequence the language tokens in terms of
* the most preferred and the least preferred.
* LanguageParser for the
* Accept-Language HTTP header value. This will
* parse a set of language tokens and there parameters. The
* languages will be ordered on preference. This constructor
* will parse the value given using parse(String).
*/
public LanguageParser() {
super();
}
/**
* This is used to create a LanguageParser for the
* Accept-Language HTTP header value. This will
* parse a set of language tokens and there parameters. The
* languages will be ordered on preference. This constructor
* will parse the value given using parse(String).
*
* @param text value of a Accept-Language header
*/
public LanguageParser(String text) {
super(text);
}
/**
* This is used to create a LanguageParser for the
* Accept-Language HTTP header value. This will
* parse a set of language tokens and there parameters. The
* languages will be ordered on preference. This constructor
* will parse the value given using parse(String).
*
* @param list value of a Accept-Language header
*/
public LanguageParser(ListLocale object created.
*
* @param text this is the text buffer to acquire the value from
* @param start the offset within the array to take characters
* @param len this is the number of characters within the token
*/
private String language(char[] text, int start, int len) {
int mark = start;
int size = 0;
while(start < len) {
char next = text[start];
if(terminal(next)) {
return new String(text, mark, size);
}
size++;
start++;
}
return new String(text, mark, len);
}
/**
* This will extract the primary country tag from the header.
* This token is used to represent the country that will be
* available in the Locale object created.
*
* @param text this is the text buffer to acquire the value from
* @param start the offset within the array to take characters
* @param len this is the number of characters within the token
*/
private String country(char[] text, int start, int len) {
int size = len;
while(start < len) {
if(text[start++] == '-') {
return new String(text, start, --size);
}
size--;
}
return "";
}
/**
* This is used to determine whether the character provided is
* a terminal character. The terminal token is the value that is
* used to separate the country from the language and also any
* character the marks the end of the language token.
*
* @param ch this is the character that is to be evaluated
*
* @return true if the character represents a terminal token
*/
private boolean terminal(char ch) {
return ch ==' ' || ch == '-' || ch == ';';
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/ListParser.java 0000664 0000000 0000000 00000036155 12536602605 0025675 0 ustar 00root root 0000000 0000000 /*
* ListParser.java September 2003
*
* Copyright (C) 2003, Niall Gallagher ListParser is used to extract a comma separated
* list of HTTP header values. This will extract values without
* any leading or trailing spaces, which enables the values to be
* used. Listing the values that appear in the header also requires
* that the values are ordered. This orders the values using the
* values that appear with any quality parameter associated with it.
* The quality value is a special parameter that often found in a
* comma separated value list to specify the client preference.
*
*
* image/gif, image/jpeg, text/html
* image/gif;q=1.0, image/jpeg;q=0.8, image/png; q=1.0,*;q=0.1
* gzip;q=1.0, identity; q=0.5, *;q=0
*
*
* The above lists taken from RFC 2616 provides an example of the
* common form comma separated values take. The first illustrates
* a simple comma delimited list, here the ordering of values is
* determined from left to right. The second and third list have
* quality values associated with them, these are used to specify
* a preference and thus order.
* list
* method adheres to the optional quality parameters and ensures
* that the quality parameters a removed from the resulting text.
*
* @author Niall Gallagher
*/
public abstract class ListParserListParser. This creates a
* parser with no initial parse data, if there are headers to
* be parsed then the parse(String) method or
* parse(List) method can be used. This will
* parse a delimited list according so RFC 2616 section 4.2.
*/
public ListParser(){
this.order = new PriorityQueueListParser. This creates a
* parser with the text supplied. This will parse the comma
* separated list according to RFC 2616 section 2.1 and 4.2.
* The tokens can be extracted using the list
* method, which will also sort and trim the tokens.
*
* @param text this is the comma separated list to be parsed
*/
public ListParser(String text) {
this();
parse(text);
}
/**
* Constructor for the ListParser. This creates a
* parser with the text supplied. This will parse the comma
* separated list according to RFC 2616 section 2.1 and 4.2.
* The tokens can be extracted using the list
* method, which will also sort and trim the tokens.
*
* @param list a list of comma separated lists to be parsed
*/
public ListParser(ListString tokens from
* the priority queue and place those tokens in an array. The
* The String tokens are placed into the array
* in an ordered manner so that the most preferred token is
* inserted into the start of the list.
*/
private void build() {
while(!order.isEmpty()) {
Entry entry = order.remove();
T value = entry.getValue();
list.add(value);
}
}
/**
* This ensures that tokens are taken from the comma separated
* list as long as there bytes left to be examined within the
* source text. This also makes sure that the implicit qvalue
* is decreased each time a token is extracted from the list.
*/
protected void parse() {
while(off < count) {
clear();
value();
save();
}
build();
}
/**
* Initializes the parser so that tokens can be extracted from
* the list. This creates a write buffer so that a if there is
* only one token as long as the source text, then that token
* can be accommodated, also this starts of the initial qvalue
* implicit to tokens within the list as the maximum long value.
*
*
* token; quantity=1;q=0.001, token; text="a, b, c, d";q=0
* image/gif, , image/jpeg, image/png;q=0.8, *
* token="\"a, b, c, d\", a, b, c, d", token="a";q=0.9,,
*
*
* This will only interpret a comma delimiter outside quotes of
* a literal. So if there are comma separated tokens that have
* quoted strings, then commas within those quoted strings will
* not upset the extraction of the token. Also escaped strings
* are tolerated according to RFC 2616 section 2.
*/
private void value() {
parse: while(off < count) {
if(buf[off++] == '"'){ /* "[t]ext" */
text[pos++] = buf[off-1]; /* ["]text"*/
while(++off < count){ /* "text"[] */
if(buf[off -1] =='"'){ /* "text["] */
if(buf[off -2] !='\\')
break;
}
text[pos++] = buf[off-1]; /* "tex[t]"*/
}
} else if(buf[off -1] == ';'){ /* [;] q=0.1 */
for(int seek = off; seek+1 < count;){/* ;[ ]q=0.1 */
if(!space(buf[seek])){ /* ;[ ]q=0.1*/
if(buf[seek] =='q'){ /* ; [q]=0.1*/
if(buf[seek+1] =='='){ /* ; q[=]0.1*/
off = seek;
qvalue();
continue parse;
}
}
break;
}
seek++;
}
}
if(buf[off-1] ==','){
break;
}
text[pos++] = buf[off-1];
}
}
/**
* This method will trim whitespace from the extracted token and
* store that token within the PriorityQueue. This
* ensures that the tokens parsed from the comma separated list
* can be used. Trimming the whitespace is something that will be
* done to the tokens so that they can be examined, so this
* ensures that the overhead of the String.trim
* method is not required to remove trailing or leading spaces.
* This also ensures that empty tokens are not saved.
*/
private void save() {
int size = pos;
int start = 0;
while(size > 0){
if(!space(text[size-1])){
break;
}
size--;
}
while(start < pos){
if(space(text[start])){
start++;
size--;
}else {
break;
}
}
if(size > 0) {
T value = create(text, start, size);
if(value != null) {
save(value);
}
}
}
/**
* This stores the string in the PriorityQueue. If
* the qvalue extracted from the header value is less that 0.001
* then this will not store the token. This ensures that client
* applications can specify tokens that are unacceptable to it.
*
* @param value this is the token to be enqueued into the queue
*/
private void save(T value) {
int size = order.size();
if(qvalue > 0) {
order.offer(new Entry(value, qvalue, size));
}
}
/**
* This is used to extract the qvalue parameter from the header.
* The qvalue parameter is identified by a parameter with the
* name "q" and a numeric floating point number. The number can
* be in the range of 0.000 to 1.000. The qvalue
* is parsed byte bit shifting a byte in to a value in to a
* long, this may cause problems with varying accuracy.
*/
private void qvalue() {
if(skip("q=")){
char digit = 0;
for(qvalue = 0; off < count;){
if(buf[off] == '.'){
off++;
continue;
}
if(!digit(buf[off])){
break;
}
digit = buf[off];
digit -= '0';
qvalue |= digit;
qvalue <<= 4;
off++;
}
}
}
/**
* This creates an value object using the range of characters
* that have been parsed as an item within the list of values. It
* is up to the implementation to create a value to insert in to
* the list. A null value will be ignored if returned.
*
* @param text this is the text buffer to acquire the value from
* @param start the offset within the array to take characters
* @param len this is the number of characters within the token
*/
protected abstract T create(char[] text, int start, int len);
/**
* The Entry object provides a comparable object to
* insert in to a priority queue. This will sort the value using
* the quality value parameter parsed from the list. If there
* are values with the same quality value this this will sort
* the values by a secondary order parameter.
*
* @author Niall Gallagher
*/
private class Entry implements ComparableEntry object. This is used
* to create a comparable value that can be inserted in to a
* priority queue and extracted in order of the priority value.
*
* @param value this is the value that is represented by this
* @param priority this is the priority value for sorting
* @param order this is the secondary priority value used
*/
public Entry(T value, long priority, int order) {
this.priority = priority;
this.order = order;
this.value = value;
}
/**
* This acquires the value represented by this entry. This is
* can be used to place the value within a list as it is taken
* from the priority queue. Acquiring the values in this way
* facilitates a priority ordered list of values.
*
* @return this returns the value represented by this
*/
public T getValue() {
return value;
}
/**
* This is used to sort the entries within the priority queue
* using the provided priority of specified. If the entries
* have the same priority value then they are sorted using a
* secondary order value, which is the insertion index.
*
* @param entry this is the entry to be compared to
*
* @return this returns the result of the entry comparison
*/
public int compareTo(Entry entry) {
long value = entry.priority - priority;
if(value > 0) {
return 1;
}
if(value < 0) {
return -1;
}
return order - entry.order;
}
}
} simple-http-4.1.21/src/org/simpleframework/http/parse/PathParser.java 0000664 0000000 0000000 00000061666 12536602605 0025663 0 ustar 00root root 0000000 0000000 /*
* PathParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher /usr/bin/../etc/./README
* then the actual path, normalized, is /usr/etc/README. Once
* the path has been normalized it is possible to acquire the segments as
* an array of strings, which allows simple manipulation of the path.
* AddressParser should be used.
*
* @author Niall Gallagher
*/
public class PathParser extends Parser implements Path{
/**
* Used to store the individual path segments.
*/
private TokenList list;
/**
* Used to store consumed name characters.
*/
private Token name;
/**
* Used to store consumed file extension.
*/
private Token ext;
/**
* Used to store the highest directory path.
*/
private Token dir;
/**
* Used to store consumed normalized path name.
*/
private Token path;
/**
* The default constructor will create a PathParser that
* contains no specifics. The instance will return null
* for all the get methods. The PathParser's get methods
* may be populated by using the parse method.
*/
public PathParser() {
this.list = new TokenList();
this.ext = new Token();
this.dir = new Token();
this.path = new Token();
this.name = new Token();
}
/**
* This is primarily a convineance constructor. This will parse the
* String given to extract the specifics. This could be
* achived by calling the default no-arg constructor and then using
* the instance to invoke the parse method on that
* String to extract the parts.
*
* @param path a String containing a path value
*/
public PathParser(String path){
this();
parse(path);
}
/**
* This will parse the path in such a way that it ensures that at no
* stage there are trailing back references, using path normalization.
* The need to remove the back references is so that this
* PathParser will create the same String
* path given a set of paths that have different back references. For
* example the paths /path/../path and /path
* are the same path but different String's.
* /../ will
* result in a null for all methods. Paths such as ../bin
* will not be allowed.
*/
protected void parse() {
normalize();
path();
segments();
name();
extension();
}
/**
* This will initialize the parser so that it is in a ready state.
* This allows the parser to be used to parse many paths. This will
* clear the parse buffer objects and reset the offset to point to
* the start of the char buffer. The count variable is reset by the
* Parser.parse method.
*/
protected void init() {
list.clear();
ext.clear();
dir.clear();
name.clear();
path.clear();
off = 0;
}
/**
* This will return the extension that the file name contains.
* For example a file name file.en_US.extension
* will produce an extension of extension. This
* will return null if the path contains no file extension.
*
* @return this will return the extension this path contains
*/
public String getExtension() {
return ext.toString();
}
/**
* This will return the full name of the file without the path.
* As regargs the definition of the path in RFC 2396 the name
* would be considered the last path segment. So if the path
* was /usr/README the name is README.
* Also for directorys the name of the directory in the last
* path segment is returned. This returns the name without any
* of the path parameters. As RFC 2396 defines the path to have
* path parameters after the path segments.
*
* @return this will return the name of the file in the path
*/
public String getName(){
return name.toString();
}
/**
* This will return the normalized path. The normalized path is
* the path without any references to its parent or itself. So
* if the path to be parsed is /usr/../etc/./ the
* path is /etc/. If the path that this represents
* is a path with an immediate back reference then this will
* return null. This is the path with all its information even
* the parameter information if it was defined in the path.
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath() {
return path.toString();
}
/**
* This will return the normalized path from the specified path
* segment. This allows various path parts to be acquired in an
* efficient means what does not require copy operations of the
* use of substring invocations. Of particular
* interest is the extraction of context based paths. This is
* the path with all its information even the parameter
* information if it was defined in the path.
*
* @param from this is the segment offset to get the path for
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath(int from) {
return list.segment(from);
}
/**
* This will return the normalized path from the specified path
* segment. This allows various path parts to be acquired in an
* efficient means what does not require copy operations of the
* use of substring invocations. Of particular
* interest is the extraction of context based paths. This is
* the path with all its information even the parameter
* information if it was defined in the path.
*
* @param from this is the segment offset to get the path for
* @param count this is the number of path segments to include
*
* @return this returns the normalize path without
* ../ or ./
*/
public String getPath(int from, int count) {
return list.segment(from, count);
}
/**
* This will return the highest directory that exists within
* the path. This is used to that files within the same path
* can be acquired. An example of that this would do given
* the path /pub/./bin/README would be to return
* the highest directory path /pub/bin/. The "/"
* character will allways be the last character in the path.
*
* @return this method will return the highest directory
*/
public String getDirectory(){
return dir.toString();
}
/**
* This method is used to break the path into individual parts
* called segments, see RFC 2396. This can be used as an easy
* way to compare paths and to examine the directory tree that
* the path points to. For example, if an path was broken from
* the string /usr/bin/../etc then the segments
* returned would be usr and etc as
* the path is normalized before the segments are extracted.
*
* @return return all the path segments within the directory
*/
public String[] getSegments(){
return list.list();
}
/**
* This will return the path as it is relative to the issued
* path. This in effect will chop the start of this path if
* it's start matches the highest directory of the given path
* as of getDirectory. This is useful if paths
* that are relative to a specific location are required. To
* illustrate what this method will do the following example
* is provided. If this object represented the path string
* /usr/share/rfc/rfc2396.txt and the issued
* path was /usr/share/text.txt then this will
* return the path string /rfc/rfc2396.txt.
*
* @param path the path prefix to acquire a relative path
*
* @return returns a path relative to the one it is given
* otherwize this method will return null
*/
public String getRelative(String path){
return getRelative(new PathParser(path));
}
/**
* This is used by the getRelative(String) to
* normalize the path string and determine if it contains a
* highest directory which is shared with the path that is
* represented by this object. If the path has leading back
* references, such as ../, then the result of
* this is null. The returned path begins with a '/'.
*
* @param path the path prefix to acquire a relative path
*
* @return returns a path relative to the one it is given
* otherwize this method will return null
*/
private String getRelative(PathParser path){
char[] text = path.buf;
int off = path.dir.off;
int len = path.dir.len;
return getRelative(text, off, len);
}
/**
* This will return the path as it is relative to the issued
* path. This in effect will chop the start of this path if
* it's start matches the highest directory of the given path
* as of getDirectory. This is useful if paths
* that are relative to a specific location are required. To
* illustrate what this method will do the following example
* is provided. If this object represented the path string
* /usr/share/rfc/rfc2396.txt and the issued
* path was /usr/share/text.txt then this will
* return the path string /rfc/rfc2396.txt.
*
* @param text the path prefix to acquire a relative path
* @param off this is the offset within the text to read
* @param len this is the number of characters in the path
*
* @return returns a path relative to the one it is given
* otherwize this method will return null
*/
private String getRelative(char[] text, int off, int len){
int size = path.len - len + 1; /* '/' */
int pos = path.off + len - 1;
for(int i = 0; i < len; i++){
if(text[off++] != buf[path.off+i]){
return null;
}
}
if(pos < 0) { /* ../ */
return null;
}
return new String(buf,pos,size);
}
/**
* This will extract the path of the given String
* after it has been normalized. If the path can not be normalized
* then the count is set to -1 and the path cannot be extracted.
* When this happens then the path parameter is null.
*/
private void path() {
if(count > 0){
path.len = count;
path.off = 0;
}
}
/**
* This will simply read the characters from the end of the
* buffer until it encounters the first peroid character. When
* this is read it will store the file extension and remove the
* characters from the buffer.
*/
private void extension() {
int pos = off + count; /* index.html[]*/
int len = 0;
while(pos-1 >= off) { /* index.htm[l]*/
if(buf[--pos]=='.'){ /* index[.]html*/
ext.off = pos+1;
ext.len = len;
count = pos;
break;
}
len++;
}
}
/**
* This wil extract each individual segment from the path and
* also extract the highest directory. The path segments are
* basically the strings delimited by the '/' character of a
* normalized path. As well as extracting the path segments
* this will also extract the directory of path, that is, the
* the path up to the last occurance of the '/' character.
*/
private void segments() {
int pos = count - 1;
int len = 1;
if(count > 0){
if(buf[pos] == '/'){ /* /pub/bin[/] */
dir.len = pos+1;
dir.off = 0;
pos--; /* /pub/bi[n]/ */
}
while(pos >= off){
if(buf[pos] == '/'){ /* /pub[/]bin/*/
if(dir.len == 0){
dir.len = pos+1; /* [/] is 0*/
dir.off = 0;
}
list.add(pos+1,len-1);
len = 0;
}
len++;
pos--;
}
}
}
/**
* The normalization of the path is the conversion of the path
* given into it's actual path by removing the references to
* the parent directorys and to the current dir. So if the path
* given was /usr/bin/../etc/./README then the actual
* path, the normalized path, is /usr/etc/README.
* ../ or /.. within the path.
* This will also remove empty segments like //.
*/
private void normalize(){
int size = count + off;
int pos = off;
for(off = count = 0; pos < size; pos++) {
buf[count++] = buf[pos];
if(buf[pos] == '/') {
if(count -1 > 0){
if(buf[count -2] == '/') /* [/]/./path/ */
count--; /* /[/]./path/ */
}
} else if(buf[pos] == '.') { /* //[.]/path/ */
if(count -1 > 0) { /* /[/]./path/ */
if(buf[count - 2] !='/') /* /[/]./path./ */
continue; /* /path.[/] */
}
if(pos + 2 > size){ /* /path/[.] */
count--;
} else {
if(buf[pos + 1] =='/'){ /* /.[/]path */
pos++;/* /[/]. */
count--; /* /.[/]path */
}
if(buf[pos] !='.'){ /* /.[/]path */
continue;
}
if(pos + 2< size){
if(buf[pos + 2]!='/') /* /..[p]ath */
continue; /* /[.].path */
}
if(count - 2 > 0) {
for(count -= 2; count - 1 > 0;){ /* /path[/]..*/
if(buf[count - 1]=='/') { /* [/]path/..*/
break;
}
count--;
}
}else { /* /../ */
count = 0;
off = 0;
break;
}
pos += 2; /* /path/.[.]/ */
}
}
}
}
/**
* This will extract the full name of the file without the path.
* As regards the definition of the path in RFC 2396 the name
* would be considered the last path segment. So if the path
* was /usr/README the name is README.
* Also for directorys the name of the directory in the last
* path segment is returned. This returns the name without any
* of the path parameters. As RFC 2396 defines the path to have
* path parameters after the path segments. So the path for the
* directory "/usr/bin;param=value/;param=value" would result
* in the name "bin". If the path given was "/" then there will
* be nothing in the buffer because extract will
* have removed it.
*/
private void name(){
int pos = count;
int len = 0;
while(pos-- > off) { /* /usr/bin/;para[m] */
if(buf[pos]==';'){ /* /usr/bin/[;]param */
if(buf[pos-1]=='/'){ /* /usr/bin[/];param */
pos--; /* /usr/bin[/];param */
}
len = 0; /* /usr/bin[/]*/
}else if(buf[pos]=='/'){ /* /usr[/]bin*/
off = pos + 1; /* /usr/[b]in*/
count = len; /* [b]in */
break;
}else{
len++;
}
}
name.len = count;
name.off = off;
}
/**
* This will return the normalized path. The normalized path is
* the path without any references to its parent or itself. So
* if the path to be parsed is /usr/../etc/./ the
* path is /etc/. If the path that this represents
* is a path with an immediate back reference then this will
* return null. This is the path with all its information even
* the parameter information if it was defined in the path.
*
* @return this returns the normalize path without
* ../ or ./
*/
public String toString(){
return getPath();
}
/**
* This is used so that the PathParser can speed
* up the parsing of the data. Rather than using a buffer like
* a ParseBuffer or worse a StringBuffer
* this just keeps an index into the character array from the
* start and end of the token. Also this enables a cache to be
* kept so that a String does not need to be made
* again after the first time it is created.
*/
private class Token implements Serializable {
/**
* Provides a quick retrieval of the token value.
*/
public String value;
/**
* Offset within the buffer that the token starts.
*/
public int off;
/**
* Length of the region that the token consumes.
*/
public int len;
/**
* If the Token is to be reused this will clear
* all previous data. Clearing the buffer allows it to be
* reused if there is a new URI to be parsed. This ensures
* that a null is returned if the token length is zero.
*/
public void clear() {
value = null;
len = 0;
}
/**
* This method will convert the Token into it's
* String equivelant. This will firstly check
* to see if there is a value, for the string representation,
* if there is the value is returned, otherwise the region
* is converted into a String and returned.
*
* @return this returns a value representing the token
*/
public String toString() {
if(value != null) {
return value;
}
if(len > 0) {
value = new String(buf,off,len);
}
return value;
}
}
/**
* The TokenList class is used to store a list of
* tokens. This provides an add method which can
* be used to store an offset and length of a token within
* the buffer. Once the tokens have been added to they can be
* examined, in the order they were added, using the provided
* list method. This has a scalable capacity.
*/
private class TokenList implements Serializable {
/**
* This is used to cache the segments that are created.
*/
private String[] cache;
/**
* Contains the offsets and lengths of the tokens.
*/
private int[] list;
/**
* Determines the write offset into the array.
*/
private int count;
/**
* Constructor for the TokenList is used to
* create a scalable list to store tokens. The initial
* list is created with an array of sixteen ints, which
* is enough to store eight tokens.
*/
private TokenList(){
list = new int[16];
}
/**
* This is used to acquire the path from the segment that
* is specified. This provides an efficient means to get
* the path without having to perform expensive copy of
* substring operations.
*
* @param from this is the path segment to get the path
*
* @return the string that is the path segment created
*/
public String segment(int from) {
int total = count / 2;
int left = total - from;
return segment(from, left);
}
/**
* This is used to acquire the path from the segment that
* is specified. This provides an efficient means to get
* the path without having to perform expensive copy of
* substring operations.
*
* @param from this is the path segment to get the path
* @param total this is the number of segments to use
*
* @return the string that is the path segment created
*/
public String segment(int from, int total) {
int last = list[0] + list[1] + 1;
if(from + total < count / 2) {
last = offset(from + total);
}
int start = offset(from);
int length = last - start;
return new String(buf, start-1, length);
}
/**
* This is used to acquire the offset within the buffer
* of the specified segment. This allows a path to be
* created that is constructed from a given segment.
*
* @param segment this is the segment offset to use
*
* @return this returns the offset start for the segment
*/
private int offset(int segment) {
int last = count - 2;
int shift = segment * 2;
int index = last - shift;
return list[index];
}
/**
* This is used to add a new token to the list. Tokens
* will be available from the list method in
* the order it was added, so the first to be added will
* at index zero and the last with be in the last index.
*
* @param off this is the read offset within the buffer
* @param len the number of characters within the token
*/
public void add(int off, int len){
if(count+1 > list.length) {
resize(count *2);
}
list[count++] = off;
list[count++] = len;
}
/**
* This is used to retrieve the list of tokens inserted
* to this list using the add method. The
* indexes of the tokens represents the order that the
* tokens were added to the list.
*
* @return returns an ordered list of token strings
*/
public String[] list(){
if(cache == null) {
cache = build();
}
return cache;
}
/**
* This is used to retrieve the list of tokens inserted
* to this list using the add method. The
* indexes of the tokens represents the order that the
* tokens were added to the list.
*
* @return returns an ordered list of token strings
*/
private String[] build(){
String[] value = new String[count/2];
for(int i =0, j = count/2; i< count; i+=2){
int index = j - (i/2) - 1;
int off = list[i];
int size = list[i + 1];
value[index] = new String(buf, off, size);
}
return value;
}
/**
* This is used to clear all tokens previously stored
* in the list. This is required so that initialization
* of the parser with the init method can
* ensure that there are no tokens from previous data.
*/
public void clear(){
cache =null;
count =0;
}
/**
* Scales the internal array used should the number of
* tokens exceed the initial capacity. This will just
* copy across the ints used to represent the token.
*
* @param size length the capacity is to increase to
*/
private void resize(int size){
int[] copy = new int[size];
System.arraycopy(list,0,copy,0,count);
list = copy;
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/PrincipalParser.java 0000664 0000000 0000000 00000025212 12536602605 0026673 0 ustar 00root root 0000000 0000000 /*
* PrincipalParser.java February 2001
*
* Copyright (C) 2001, Niall Gallagher base64 encoding of the user and
* password pair.
* base64 encoding of the user name and
* password. After the string has been decoded then the user name and
* password are extracted. This will only parse headers that are from
* the Basic authorization scheme. The format of the basic
* scheme can be found in RFC 2617 and is of the form
*
* Basic SP base64-encoding.
*
*
* @author Niall Gallagher
*/
public class PrincipalParser extends Parser implements Principal {
/**
* Keeps the characters consumed for the password token.
*/
private ParseBuffer password;
/**
* Keeps the characters consumed for the user name token.
*/
private ParseBuffer user;
/**
* Keeps the bytes used for decoding base64.
*/
private byte[] four;
/**
* Tracks the write offset for the buffer.
*/
private int write;
/**
* Tracks the ready offset for the four buffer.
*/
private int ready;
/**
* Tracks the read offset for the buffer.
*/
private int read;
/**
* Creates a Parser for the basic authorization
* scheme. This allows headers that are of this scheme to be
* broken into its component parts i.e. user name and password.
*/
public PrincipalParser() {
this.password = new ParseBuffer();
this.user = new ParseBuffer();
this.four = new byte[4];
}
/**
* Creates a Parser for the basic authorization
* scheme. This allows headers that are of this scheme to be
* broken into its component parts i.e. user name and password.
* This constructor will parse the String given as
* the header.
*
* @param header this is a header value from the basic scheme
*/
public PrincipalParser(String header){
this();
parse(header);
}
/**
* Gets the users password parsed from the Authorization
* header value. If there was not password parsed from the
* base64 value of the header this returns null
*
* @return the password for the user or null
*/
public String getPassword(){
if(password.length() == 0){
return null;
}
return password.toString();
}
/**
* Gets the users name from the Authorization header value.
* This will return null if there is no user
* name extracted from the base64 header value.
*
* @return this returns the name of the user
*/
public String getName(){
if(user.length() == 0){
return null;
}
return user.toString();
}
/**
* Used to parse the actual header data. This will attempt to
* read the "Basic" token from the set of characters given, if
* this is successful then the username and password is
* extracted.
*/
protected void parse(){
if(skip("Basic ")){
decode();
userpass();
}
}
/**
* This will initialize the Parser when it is ready
* to parse a new String. This will reset the
* Parser to a ready state. The init method
* is invoked by the Parser when the parse
* method is invoked.
*/
protected void init() {
password.clear();
user.clear();
write = ready =
read = off = 0;
pack();
}
/**
* This is used to remove all whitespace characters from the
* String excluding the whitespace within literals.
* The definition of a literal can be found in RFC 2616.
* base64 encoding of
* the user name and password. This uses a standart base64
* decoding scheme.
* base64
* see the RFC 2045 on MIME, Multipurpose Internet Mail Extensions.
*/
private void decode() {
for(write = read = off; read + 3 < count;) {
while(ready < 4) {
int ch = translate(buf[read++]);
if(ch >= 0) {
four[ready++] = (byte)ch;
}
}
if(four[2] == 65) {
buf[write++] = first(four);
break;
} else if(four[3] == 65) {
buf[write++] = first(four);
buf[write++] = second(four);
break;
} else {
buf[write++] = first(four);
buf[write++] = second(four);
buf[write++] = third(four);
}
ready = 0;
}
count = write;
}
/**
* This uses a basic translation from the byte character to the
* byte number.
* byte from the set of four
* bytes given. This method is used to isolate the correct
* bits that corrospond to an actual character withing the
* base64 data.
*
* @param four this is the four bytes that the character
* is to be extracted from
*
* @return this returns the character extracted
*/
private char first(byte[] four) {
return (char)(((four[0] & 0x3f) << 2) | ((four[1] & 0x30) >>> 4));
}
/**
* This is used to extract the byte from the set of four
* bytes given. This method is used to isolate the correct
* bits that corrospond to an actual character withing the
* base64 data.
*
* @param four this is the four bytes that the character
* is to be extracted from
*
* @return this returns the character extracted
*/
private char second(byte[] four) {
return (char)(((four[1] & 0x0f) << 4) | ((four[2] &0x3c) >>> 2));
}
/**
* This is used to extract the byte from the set of four
* bytes given. This method is used to isolate the correct
* bits that corrospond to an actual character withing the
* base64 data.
*
* @param four this is the four bytes that the character
* is to be extracted from
*
* @return this returns the character extracted
*/
private char third(byte[] four) {
return (char)(((four[2] & 0x03) << 6) | (four[3] & 0x3f));
}
/**
* This is used to determine wheather or not a character is a
* TEXT character according to the HTTP specification,
* that is RFC 2616 specifies a TEXT character as one
* that is any octet except those less than 32 and not 127.
*
* @param c this is the character that is to be determined
*
* @return this returns true if the character is a TEXT
*/
private boolean text(char c){
return c > 31 && c != 127 && c <= 0xffff;
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/QueryParser.java 0000664 0000000 0000000 00000052242 12536602605 0026062 0 ustar 00root root 0000000 0000000 /*
* QueryParser.java December 2002
*
* Copyright (C) 2002, Niall Gallagher ParameterParser is used to parse data encoded in
* the application/x-www-form-urlencoded MIME type. It
* is also used to parse a query string from a HTTP URL, see RFC 2616.
* The parsed parameters are available through the various methods of
* the org.simpleframework.http.net.Query interface. The
* syntax of the parsed parameters is described below in BNF.
*
*
* params = *(pair [ "&" params])
* pair = name "=" value
* name = *(text | escaped)
* value = *(text | escaped)
* escaped = % HEX HEX
*
*
* This will consume all data found as a name or value, if the data
* is a "+" character then it is replaced with a space character.
* This regards only "=", "&", and "%" as having special values.
* The "=" character delimits the name from the value and the "&"
* delimits the name value pair. The "%" character represents the
* start of an escaped sequence, which consists of two hex digits.
* All escaped sequences are converted to its character value.
*
* @author Niall Gallagher
*/
public class QueryParser extends MapParserParameterParser. This creates
* an instance that can be use to parse HTML form data and URL
* query strings encoded as application/x-www-form-urlencoded.
* The parsed parameters are made available through the interface
* org.simpleframework.util.net.Query.
*/
public QueryParser(){
this.name = new Token();
this.value = new Token();
}
/**
* Constructor for the ParameterParser. This creates
* an instance that can be use to parse HTML form data and URL
* query strings encoded as application/x-www-form-urlencoded.
* The parsed parameters are made available through the interface
* org.simpleframework.util.net.Query.
*
* @param text this is the text to parse for the parameters
*/
public QueryParser(String text){
this();
parse(text);
}
/**
* This extracts an integer parameter for the named value. If the
* named parameter does not exist this will return a zero value.
* If however the parameter exists but is not in the format of a
* decimal integer value then this will throw an exception.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as an integer
*/
public int getInteger(Object name) {
String value = get(name);
if(value != null) {
return Integer.parseInt(value);
}
return 0;
}
/**
* This extracts a float parameter for the named value. If the
* named parameter does not exist this will return a zero value.
* If however the parameter exists but is not in the format of a
* floating point number then this will throw an exception.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as a float
*/
public float getFloat(Object name) {
String value = get(name);
if(value != null) {
return Float.parseFloat(value);
}
return 0.0f;
}
/**
* This extracts a boolean parameter for the named value. If the
* named parameter does not exist this will return false otherwise
* the value is evaluated. If it is either true or
* false then those boolean values are returned.
*
* @param name the name of the parameter value to retrieve
*
* @return this returns the named parameter value as an float
*/
public boolean getBoolean(Object name) {
Boolean flag = Boolean.FALSE;
String value = get(name);
if(value != null) {
flag = Boolean.valueOf(value);
}
return flag.booleanValue();
}
/**
* This initializes the parser so that it can be used several
* times. This clears any previous parameters extracted. This
* ensures that when the next parse(String) is
* invoked the status of the Query is empty.
*/
protected void init(){
all.clear();
map.clear();
name.len = 0;
value.len = 0;
off = 0;
}
/**
* This performs the actual parsing of the parameter text. The
* parameters parsed from this are taken as "name=value" pairs.
* Multiple pairs within the text are separated by an "&".
* This will parse and insert all parameters into a hashtable.
*/
protected void parse() {
param();
while(skip("&")){
param();
}
}
/**
* This method adds the name and value to a map so that the next
* name and value can be collected. The name and value are added
* to the map as string objects. Once added to the map the
* Token objects are set to have zero length so they
* can be reused to collect further values. This will add the
* values to the map as an array of type string. This is done so
* that if there are multiple values that they can be stored.
*/
private void insert(){
if(name.len > 0){
insert(name,value);
}
name.len = 0;
value.len = 0;
}
/**
* This will add the given name and value to the parameters map.
* If any previous value of the given name has been inserted
* into the map then this will overwrite that value. This is
* used to ensure that the string value is inserted to the map.
*
* @param name this is the name of the value to be inserted
* @param value this is the value of a that is to be inserted
*/
private void insert(Token name, Token value){
put(name.toString(), value.toString());
}
/**
* This is an expression that is defined by RFC 2396 it is used
* in the definition of a segment expression. This is basically
* a list of chars with escaped sequences.
* "%" HEX HEX.
* This decodes the escaped sequence using UTF-8 encoding, all
* encoded sequences should be in UCS-2 to fit in a Java char.
*/
private void escape() {
int peek = peek(off);
if(!unicode(peek)) {
binary(peek);
}
}
/**
* This method determines, using a peek character, whether the
* sequence of escaped characters within the URI is binary data.
* If the data within the escaped sequence is binary then this
* will ensure that the next character read from the URI is the
* binary octet. This is used strictly for backward compatible
* parsing of URI strings, binary data should never appear.
*
* @param peek this is the first escaped character from the URI
*
* @return currently this implementation always returns true
*/
private boolean binary(int peek) {
if(off + 2 < count) {
off += 2;
buf[off] =bits(peek);
}
return true;
}
/**
* This method determines, using a peek character, whether the
* sequence of escaped characters within the URI is in UTF-8. If
* a UTF-8 character can be successfully decoded from the URI it
* will be the next character read from the buffer. This can
* check for both UCS-2 and UCS-4 characters. However, because
* the Java char can only hold UCS-2, the UCS-4
* characters will have only the low order octets stored.
* "%" HEX HEX
* sequences left. If successful the next character read is
* the UTF-8 sequence decoded into a native UCS-2 character.
*
* @param peek contains the bits read from the first UTF octet
* @param more this specifies the number of UTF octets left
*
* @return this returns true if a UTF-8 character is decoded
*/
private boolean unicode(int peek, int more) {
if(off + more * 3 >= count) {
return false;
}
return unicode(peek,more,off);
}
/**
* This will decode the specified amount of trailing UTF-8 bits
* from the URI. The trailing bits are those following the first
* UTF-8 octet, which specifies the length, in octets, of the
* sequence. The trailing octets are of the form 10xxxxxx, for
* each of these octets only the last six bits are valid UCS
* bits. So a conversion is basically an accumulation of these.
* "%" HEX HEX, if so, then
* it will convert that hexadecimal string in to an integer
* value, or -1 if the expression is not hexadecimal.
*
* @param pos this is the position the expression starts from
*
* @return the integer value of the hexadecimal expression
*/
private int peek(int pos) {
if(buf[pos] == '%'){
if(count <= pos + 2) {
return -1;
}
char high = buf[pos + 1];
char low = buf[pos + 2];
return convert(high, low);
}
return -1;
}
/**
* This will convert the two hexidecimal characters to a real
* integer value, which is returned. This requires characters
* within the range of 'A' to 'F' and 'a' to 'f', and also
* the digits '0' to '9'. The characters encoded using the
* ISO-8859-1 encoding scheme, if the characters are not with
* in the range specified then this returns -1.
*
* @param high this is the high four bits within the integer
* @param low this is the low four bits within the integer
*
* @return this returns the indeger value of the conversion
*/
private int convert(char high, char low) {
int hex = 0x00;
if(hex(high) && hex(low)){
if('A' <= high && high <= 'F'){
high -= 'A' - 'a';
}
if(high >= 'a') {
hex ^= (high-'a')+10;
} else {
hex ^= high -'0';
}
hex <<= 4;
if('A' <= low && low <= 'F') {
low -= 'A' - 'a';
}
if(low >= 'a') {
hex ^= (low-'a')+10;
} else {
hex ^= low-'0';
}
return hex;
}
return -1;
}
/**
* This is used to determine whether a char is a hexadecimal
* char or not. A hexadecimal character is considered
* to be a character within the range of 0 - 9 and
* between a - f and A - F. This will
* return true if the character is in this range.
*
* @param ch this is the character which is to be determined here
*
* @return true if the character given has a hexadecimal value
*/
private boolean hex(char ch) {
if(ch >= '0' && ch <= '9') {
return true;
} else if(ch >='a' && ch <= 'f') {
return true;
} else if(ch >= 'A' && ch <= 'F') {
return true;
}
return false;
}
/**
* This encode method will escape the text that
* is provided. This is used to that the parameter pairs can
* be encoded in such a way that it can be transferred over
* HTTP/1.1 using the ISO-8859-1 character set.
*
* @param text this is the text that is to be escaped
*
* @return the text with % HEX HEX UTF-8 escape sequences
*/
private String encode(String text) {
try {
return URLEncoder.encode(text, "UTF-8");
}catch(Exception e){
return text;
}
}
/**
* This encode method will escape the name=value
* pair provided using the UTF-8 character set. This method
* will ensure that the parameters are encoded in such a way
* that they can be transferred via HTTP in ISO-8859-1.
*
* @param name this is the name of that is to be escaped
* @param value this is the value that is to be escaped
*
* @return the pair with % HEX HEX UTF-8 escape sequences
*/
private String encode(String name, String value) {
return encode(name) + "=" + encode(value);
}
/**
* This toString method is used to compose an string
* in the application/x-www-form-urlencoded MIME type.
* This will encode the tokens specified in the Set.
* Each name=value pair acquired is converted into a UTF-8 escape
* sequence so that the parameters can be sent in the IS0-8859-1
* format required via the HTTP/1.1 specification RFC 2616.
*
* @param set this is the set of parameters to be encoded
*
* @return returns a HTTP parameter encoding for the pairs
*/
public String toString(Set set) {
Object[] list = set.toArray();
String text = "";
for(int i = 0; i < list.length; i++){
String name = list[i].toString();
String value = get(name);
if(i > 0) {
text += "&";
}
text += encode(name, value);
}
return text;
}
/**
* This toString method is used to compose an string
* in the application/x-www-form-urlencoded MIME type.
* This will iterate over all tokens that have been added to this
* object, either during parsing, or during use of the instance.
* Each name=value pair acquired is converted into a UTF-8 escape
* sequence so that the parameters can be sent in the IS0-8859-1
* format required via the HTTP/1.1 specification RFC 2616.
*
* @return returns a HTTP parameter encoding for the pairs
*/
public String toString() {
Set set = map.keySet();
if(map.size() > 0) {
return toString(set);
}
return "";
}
/**
* This is used to mark regions within the buffer that represent
* a valid token for either the name of a parameter or its value.
* This is used as an alternative to the ParseBuffer
* which requires memory to be allocated for storing the data
* read from the buffer. This requires only two integer values.
*/
private class Token {
/**
* This represents the number of characters in the token.
*/
public int len;
/**
* This represents the start offset within the buffer.
*/
public int off;
/**
* In order to represent the Token as a value
* that can be used this converts it to a String.
* If the length of the token is less than or equal to zero
* this will return and empty string for the value.
*
* @return this returns a value representing the token
*/
public String toString() {
if(len <= 0) {
return "";
}
return new String(buf,off,len);
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/parse/ValueParser.java 0000664 0000000 0000000 00000010137 12536602605 0026026 0 ustar 00root root 0000000 0000000 /*
* ValueParser.java September 2003
*
* Copyright (C) 2003, Niall Gallagher ValueParser is used to extract a comma separated
* list of HTTP header values. This will extract values without
* any leading or trailing spaces, which enables the values to be
* used. Listing the values that appear in the header also requires
* that the values are ordered. This orders the values using the
* values that appear with any quality parameter associated with it.
* The quality value is a special parameter that often found in a
* comma separated value list to specify the client preference.
*
*
* image/gif, image/jpeg, text/html
* image/gif;q=1.0, image/jpeg;q=0.8, image/png; q=1.0,*;q=0.1
* gzip;q=1.0, identity; q=0.5, *;q=0
*
*
* The above lists taken from RFC 2616 provides an example of the
* common form comma separated values take. The first illustrates
* a simple comma delimited list, here the ordering of values is
* determined from left to right. The second and third list have
* quality values associated with them, these are used to specify
* a preference and thus order.
* list
* method adheres to the optional quality parameters and ensures
* that the quality parameters a removed from the resulting text.
*
* @author Niall Gallagher
*/
public class ValueParser extends ListParserValueParser. This creates
* a parser with no initial parse data, if there are headers to
* be parsed then the parse(String) method or
* parse(List) method can be used. This will
* parse a delimited list according so RFC 2616 section 4.2.
*/
public ValueParser(){
super();
}
/**
* Constructor for the ValueParser. This creates
* a parser with the text supplied. This will parse the comma
* separated list according to RFC 2616 section 2.1 and 4.2.
* The tokens can be extracted using the list
* method, which will also sort and trim the tokens.
*
* @param text this is the comma separated list to be parsed
*/
public ValueParser(String text) {
super(text);
}
/**
* Constructor for the ValueParser. This creates
* a parser with the text supplied. This will parse the comma
* separated list according to RFC 2616 section 2.1 and 4.2.
* The tokens can be extracted using the list
* method, which will also sort and trim the tokens.
*
* @param list a list of comma separated lists to be parsed
*/
public ValueParser(ListContext interface is used to give a view of the
* file system to the ResourceEngine. This provides the
* information to the ResourceEngine that it needs in
* order to serve content to the client browser. This provides the
* path translations for the HTTP request URI.
* File object. A context
* is rooted a a certain directory in the system. This directory is
* where the resources are gathered from. For example suppose that
* a Context implementation is rooted at the directory
* "c:\web\html\" on a DOS system. Now if the target of the browser
* was "http://some.host/web/pub/README". The context needs to be
* consulted to convert "/web/pub/README" into the real path within
* the system. So Context.getRealPath is invoked with
* the path "/web/pub/README", which responds with the system path
* "c:\web\html\web\pub\README". Also if this was a UNIX system
* with the same context rooted at "/home/user/html" then the same
* URL would result in "/home/user/html/web/pub/README".
*
* Request-Line = Method SP Request-URI SP HTTP-Version CRLF
*
* Request-URI = "*" | absoluteURI | abs_path | authority
* absoluteURI = "http:" "//" host [":" port] [abs_path ["?" query]]
* abs_path = "/" path_segments
* path_segments = segment *( "/" segment )
*
*
* So the Context object must be prepared to accept
* the request URI that come in the form outlined above. These can
* include formats like
*
*
* http://some.host/pub;param=value/bin/index.html?name=value
* http://some.host:8080/index.en_US.html
* some.host:8080/index.html
* /usr/bin;param=value/README.txt
* /usr/bin/compress.tar.gz
*
*
* The Context implementation should be able to
* directly take a Request-URI as defined in RFC 2616 and translate
* this into a path compatible with the OS specific file system.
* This keeps the objects semantics simple and explicit, although
* at the expense of performance.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.parse.AddressParser
* @see org.simpleframework.http.parse.PathParser
*/
public interface Context {
/**
* This is used to retrieve the base path of the context. The
* base path of the context is that path that that this will
* retrieve system information from. This represents a base
* that the request URI paths are served from on the system.
* For instance a base of "c:\path" would translate a URI
* path of "/index.html" into "c:\path\index.html". Every
* resource request must be relative to the context path
* this allows the ResourceEngine to map the URIs
* onto the specific OS. The base path is the OS file system
* specific path. So on UNIX it could be "/home/user/" and
* on a DOS system it could be "c:\web\html" for example.
*
* @return this returns the base path of the context
*/
public String getBasePath();
/**
* This is used to translate the HTTP request URI into the OS
* specific path that it represents. This will convert the
* URI to a format that the system can use and also represents
* the resource path on that system. So if for example the
* context path was "c:\path" on a DOS system and the HTTP URI
* given was "/index.html" this returns "c:\path\index.html".
* If a UNIX system was running the VM and the context base
* was for example "/home/" then this would return the UNIX
* path "/home/index.html" for the same request URI.
*
* @param target this is the HTTP request URI path that is to
* be translated into the OS specific path
*
* @return this returns the OS specific path name for the
* translate request URI
*/
public String getRealPath(String target);
/**
* This is used to translate the HTTP request URI into the URI
* path normalized and without query or parameter parts. This
* is used so that the resource requested by the client can be
* discovered. For example this will convert the HTTP request
* URI "http://hostname/bin;param=value/../index.html?query"
* into the relative URI path /index.html. This is useful if
* a logging mechanism requires the name of the resource that
* was requested, it can also be used help find the resource.
*
* @param target this is the HTTP request URI that is to be
* converted into a normalized relative URI path
*
* @return the HTTP request URI as a normalized relative path
*/
public String getRequestPath(String target);
/**
* This is used to translate the HTTP request URI into the
* Path object that it represents. This enables the
* HTTP request URI to be examined thoroughly an allows various
* other files to be examined relative to it. For example if the
* URI referenced a path "/usr/bin/file" and some resource
* in the same directory is required then the Path
* can be used to acquire the relative path. This is useful if
* links within a HTML page are to be dynamically generated. The
* Path.getRelative provides this functionality.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the Path object
*
* @return returns the Path for the given path
*/
public Path getPath(String target);
/**
* This is used to translate the HTTP request URI into the
* File object that it represents. This will convert
* the URI to a format that the system can use and then create
* the File object for that path. So if for example
* the context path was "c:\path" on a DOS system and the HTTP
* URI given was "/index.html" this returns the File
* "c:\path\index.html". This is basically for convenience as the
* same could be achieved using the getRealPath and
* then creating the File from that OS specific path.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the File object
*
* @return returns the File for the given path
*/
public File getFile(String target);
/**
* This is used to translate the HTTP request URI into the
* File object that it represent the parent directory
* of the URI. This will convert the URI to a format that the host
* system can use and then create the File object for
* that path. So if for example the context path was "c:\path" on
* a DOS system and the HTTP URI given was "/index.html" this
* returns the File "c:\path\". This is basically
* for convenience as the same could be achieved using the file
* retrieved from getFile and acquiring the parent.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the File object
*
* @return returns the File for the directory
*/
public File getDirectory(String target);
/**
* This method will extract the type attribute of this URI. The
* MIME type of the request URI is extracted from the name of the
* target. The name for the Context is the last path
* segment is the token defined by RFC 2396 as path_segments. So
* for example if the target was "some.host:8080/bin/index.html"
* then the name for that resource would be "index.html". Once
* the name has been extracted the MIME is defined by the file
* extension which, for the example is text/html.
* Context may also choose to
* implement a method that consults the underlying resource and
* inspect its contents to determine its MIME type. Or for a MAC
* it may contain its MIME type. If the MIME type cannot be found
* by any of the above methods RFC 2616 suggests that the resource
* be given the MIME type application/octetstream. This should also
* make not predictions as to how the file will be served.
*
* @param target the request URI to be parsed for its type
*
* @return the type of the file this path refers to
*/
public String getContentType(String target);
/**
* This will parse and return the file name that this request URI
* references. The name for the Context is the last
* path segment is the token defined by RFC 2396 as path_segments.
* So for example if the target was "some.host:8080/home/user/"
* then the name for that resource would be "user". If the path
* references the root path "/" then null should be returned.
*
* @param target the request URI to be parsed for its name
*
* @return this will return the name that this references
*/
public String getName(String target);
/**
* This is an all in one method that allows all the information
* on the target URI to be gathered at once. The motivation for
* this method is primarily convenience. However it is also used
* to increase the performance of the ResourceEngine
* when the Context implementation is synchronized.
* This will enable the ResourceEngine to gather the
* information on the target by acquiring the lock for the object
* instance only once.
*
* @param target this is the request URI that is to be parsed
*/
public Index getIndex(String target);
}
simple-http-4.1.21/src/org/simpleframework/http/resource/FileContext.java 0000664 0000000 0000000 00000023712 12536602605 0026541 0 ustar 00root root 0000000 0000000 /*
* FileContext.java March 2002
*
* Copyright (C) 2002, Niall Gallagher FileContext provides an implementation of the
* Context object that provides a direct mapping from
* a request URI as defined in RFC 2616 to an OS specific target.
* This uses a File object to define the mapping
* for the request URI paths. Using a File object
* allows the FileContext to be easily used with both
* DOS and UNIX systems.
* Indexer implementation uses an MIME database
* to obtain mappings for the getContentType method.
* The file used is acquired from the class path as a mapping from
* file extension to MIME type. This file can be modified if any
* additional types are required. However it is more advisable to
* simple extend this object and override the content type method.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.resource.FileIndexer
*/
public class FileContext implements Context {
/**
* This is used to extract any user specified MIME types.
*/
private final FileIndexer indexer;
/**
* This will be used to fetch the real OS system paths.
*/
private final File base;
/**
* Constructor for creating an instance that operates from
* the given current working path. This instance will use
* the current path to translate the HTTP request URIs
* into the OS specific path. This will load configuration
* files from the current working directory.
*/
public FileContext() {
this(new File("."));
}
/**
* Constructor for creating an instance that operates from
* the given OS specific base path. This instance will use
* the given base path to translate the HTTP request URIs
* into the OS specific path. This will load configuration
* files from the specified directory path.
*
* @param base this is the OS specific base path for this
*/
public FileContext(File base) {
this.indexer = new FileIndexer(base);
this.base = base;
}
/**
* This is used to retrieve the base path of the context. The
* base path of the context is that path that that this will
* retrieve system information from. This represents a base
* that the request URI paths are served from on the system.
* For instance a base of "c:\path" would translate a URI
* path of "/index.html" into "c:\path\index.html". Every
* resource request must be relative to the context path
* this allows the FileEngine to map the URIs
* onto the specific OS. The base path is the OS file system
* specific path. So on UNIX it could be "/home/user/" and
* on a DOS system it could be "c:\web\html" for example.
*
* @return this returns the base path of the context
*/
public String getBasePath() {
return base.getAbsolutePath();
}
/**
* This is used to translate the HTTP request URI into the OS
* specific path that it represents. This will convert the
* URI to a format that the system can use and also represents
* the resource path on that system. So if for example the
* context path was "c:\path" on a DOS system and the HTTP URI
* given was "/index.html" this returns "c:\path\index.html".
* If a UNIX system was running the VM and the context base
* was for example "/home/" then this would return the UNIX
* path "/home/index.html" for the same request URI.
*
* @param target this is the HTTP request URI path that is to
* be translated into the OS specific path
*
* @return this returns the OS specific path name for the
* translate request URI
*/
public String getRealPath(String target){
return getIndex(target).getRealPath();
}
/**
* This is used to translate the HTTP request URI into the URI
* path normalized and without query or parameter parts. This
* is used so that the resource requested by the client can be
* discovered. For example this will convert the HTTP request
* URI "http://hostname/bin;param=value/../index.html?query"
* into the relative URI path /index.html. This is useful if
* a logging mechanism requires the name of the resource that
* was requested, it can also be used help find the resource.
*
* @param target this is the HTTP request URI that is to be
* converted into a normalized relative URI path
*
* @return the HTTP request URI as a normalized relative path
*/
public String getRequestPath(String target){
return getIndex(target).getRequestPath();
}
/**
* This is used to translate the HTTP request URI into the
* File object that it represents. This will convert
* the URI to a format that the system can use and then create
* the File object for that path. So if for example
* the context path was "c:\path" on a DOS system and the HTTP
* URI given was "/index.html" this returns the File
* "c:\path\index.html". This is basically for convenience as the
* same could be achieved using the getRealPath and
* then creating the File from that OS specific path.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the File object
*
* @return returns the File for the given path
*/
public File getFile(String target) {
return getIndex(target).getFile();
}
/**
* This is used to translate the HTTP request URI into the
* File object that it represent the parent directory
* of the URI. This will convert the URI to a format that the host
* system can use and then create the File object for
* that path. So if for example the context path was "c:\path" on
* a DOS system and the HTTP URI given was "/index.html" this
* returns the File "c:\path\". This is basically
* for convenience as the same could be achieved using the file
* retrieved from getFile and acquiring the parent.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the File object
*
* @return returns the File for the directory
*/
public File getDirectory(String target) {
return getIndex(target).getDirectory();
}
/**
* This is used to translate the HTTP request URI into the
* Path object that it represents. This enables the
* HTTP request URI to be examined thoroughly an allows various
* other files to be examined relative to it. For example if the
* URI referenced a path "/usr/bin/file" and some resource
* in the same directory is required then the Path
* can be used to acquire the relative path. This is useful if
* links within a HTML page are to be dynamically generated. The
* Path.getRelative provides this functionality.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the Path object
*
* @return returns the Path for the given path
*/
public Path getPath(String target){
return getIndex(target).getPath();
}
/**
* This method will extract the type attribute of this URI. The
* MIME type of the request URI is extracted from the name of the
* target. The name for the Context is the last path
* segment in the token defined by RFC 2396 as path_segments. So
* for example if the target was "some.host:8080/bin/index.html"
* then the name for that resource would be "index.html". Once
* the name has been extracted the MIME is defined by the file
* extension, which for the example is text/html.
*
* @param target the request URI to be parsed for its type
*
* @return the type of the given request URI path refers to
*/
public String getContentType(String target){
return getIndex(target).getContentType();
}
/**
* This will parse and return the file name that this request URI
* references. The name for the Context is the last
* path segment is the token defined by RFC 2396 as path_segments.
* So for example if the target was "some.host:8080/home/user/"
* then the name for that resource would be "user". If the path
* references the root path "/" then null should be returned.
*
* @param target the request URI to be parsed for its name
*
* @return this will return the name that this references
*/
public String getName(String target){
return getIndex(target).getName();
}
/**
* This is an all in one method that allows all the information
* on the target URI to be gathered at once. The motivation for
* this method is primarily convenience. However it is also used
* to increase the performance of the FileEngine
* when the Context implementation is synchronized.
* This will enable the FileEngine to gather the
* information on the target by acquiring the lock for the object
* instance only once.
*
* @param target this is the request URI that is to be parsed
*/
public Index getIndex(String target){
return indexer.getIndex(target);
}
}
simple-http-4.1.21/src/org/simpleframework/http/resource/FileIndex.java 0000664 0000000 0000000 00000016626 12536602605 0026172 0 ustar 00root root 0000000 0000000 /*
* FileIndex.java December 2005
*
* Copyright (C) 2005, Niall Gallagher FileIndex provides an implementation of an index
* that makes use of the OS file system to acquire meta data. This
* will acquire information directly from the URI target, as well as
* a MIME database maintained in the FileIndexer.properties
* file. This caches all meta data acquired so that there is no expense
* in re-acquiring the data. This allows for faster meta data retrieval
* and facilitates the implementation of the meta data cache used.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.resource.FileIndexer
*/
class FileIndex implements Index {
/**
* This is the source indexer used to acquire the meta data.
*/
private Indexer indexer;
/**
* This is the path portion of the specified URI target.
*/
private Path path;
/**
* This is the OS specific file referencing the resource.
*/
private File file;
/**
* This is the MIME type resolved for the resource.
*/
private String type;
/**
* This contains all the information regarding the URI.
*/
private Address target;
/**
* Constructor for the FileIndex object. This uses a
* URI target to acquire the meta data for the resource. The URI
* provides the resource name and path and also provides a hint
* for the MIME type of the resource from the file extension.
*
* @param indexer this is the source indexer for this instance
* @param target this is the URI target that is to be indexed
*/
public FileIndex(Indexer indexer, String target) {
this(indexer, new AddressParser(target));
}
/**
* Constructor for the FileIndex object. This uses a
* URI target to acquire the meta data for the resource. The URI
* provides the resource name and path and also provides a hint
* for the MIME type of the resource from the file extension.
*
* @param indexer this is the source indexer for this instance
* @param target this is the URI target that is to be indexed
*/
public FileIndex(Indexer indexer, Address target) {
this.indexer = indexer;
this.target = target;
}
/**
* This is used to get the path that this object refers to.
* This should be the fully qualified normalized path. This
* refers to the OS system specific path that this represents.
*
* @return this returns the OS specific path for the target
*/
public String getContentType() {
if(type == null) {
type = getContentType(target);
}
return type;
}
/**
* This is used to get the path that this object refers to.
* This should be the fully qualified normalized path. This
* refers to the OS system specific path that this represents.
*
* @param target the index target to get the real path for
*
* @return this returns the OS specific path for the target
*/
public String getContentType(Address target) {
return indexer.getContentType(target);
}
/**
* This is used to acquire the File reference
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows the file to be opened,
* deleted, or read should the need arise in a service.
*
* @return this returns the OS file for the resource
*/
public File getFile() {
if(file == null) {
file = getFile(target);
}
return file;
}
/**
* This is used to acquire the File reference
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows the file to be opened,
* deleted, or read should the need arise in a service.
*
* @param target the index target to get the OS file for
*
* @return this returns the OS file for the resource
*/
public File getFile(Address target) {
return indexer.getFile(target);
}
/**
* This is used to acquire the Path object that
* exposes various parts of the URI path. This can be used
* to extract the individual path segments as strings as
* well as the file extension and various other details.
*
* @return this returns a path object with various details
*/
public Path getPath() {
if(path == null) {
path = getPath(target);
}
return path;
}
/**
* This is used to acquire the Path object that
* exposes various parts of the URI path. This can be used
* to extract the individual path segments as strings as
* well as the file extension and various other details.
*
* @param target the index target to get the URI path for
*
* @return this returns a path object with various details
*/
public Path getPath(Address target) {
return indexer.getPath(target);
}
/**
* This is used to get the path that this object refers to.
* This should be the fully qualified normalized path. This
* refers to the OS system specific path that this represents.
*
* @return this returns the OS specific path for the target
*/
public String getRealPath() {
return getFile().getAbsolutePath();
}
/**
* This is used to acquire the File directory
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows resources within the
* same directory to be acquired easily.
*
* @return this returns the OS file for the directory
*/
public File getDirectory() {
return getFile().getParentFile();
}
/**
* This is used to acquire the normalized URI style path for
* the index target. This allows the path to be used within
* the Context and other such objects that need
* a normalized URI style path to resolve resources.
*
* @return this returns the normalized path for the target
*/
public String getRequestPath() {
return getPath().getPath();
}
/**
* This allows the name for this object to be acquired. The
* name usually refers to the last entry in the path. So if
* the index target path was "/usr/bin/" the name is "bin".
*
* @return this returns the name of this index target
*/
public String getName() {
return getPath().getName();
}
}
simple-http-4.1.21/src/org/simpleframework/http/resource/FileIndexer.java 0000664 0000000 0000000 00000027160 12536602605 0026514 0 ustar 00root root 0000000 0000000 /*
* FileIndexer.java December 2005
*
* Copyright (C) 2005, Niall Gallagher FileIndexer provides an implementation of the
* Indexer object that provides a direct mapping from
* a request URI as defined in RFC 2616 to the resources meta data.
* This uses a File object to define the mapping
* for the request URI paths. Using a File object
* allows the FileIndexer to be easily used with both
* DOS and UNIX systems.
* Indexer implementation uses a MIME database
* to obtain mappings for the getContentType method.
* The file used is FileIndexer.properties, which is
* packaged within org.simpleframework.http.resource.
* This determines the MIME type of the request URI by matching file
* extension of the resource with the MIME type as defined in the
* "FileIndexer.properties" file.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.parse.AddressParser
* @see org.simpleframework.http.parse.PathParser
*/
class FileIndexer implements Indexer {
/**
* This is used to extract any user specified MIME types.
*/
private ResourceBundle resolver;
/**
* This is used to cache the meta information acquired.
*/
private Cache cache;
/**
* This will be used to fetch the real OS system paths.
*/
private File base;
/**
* Constructor for the FileIndexer object. This is
* used to create a centralized store for meta data. The meta
* data created by this is acquired from the context frequently,
* so in order to improve performance all indexes are cached,
* except those URI targets that contain query parameters.
*
* @param base this is the root of the context that is used
*/
public FileIndexer(File base) {
this.cache = new Cache();
this.base = base;
}
/**
* This is an all in one method that allows all the information
* on the target URI to be gathered at once. The motivation for
* this method is primarily convenience. However it is also used
* to increase the performance of the FileIndexer
* by using a cache of the most recently used indexes. This will
* help to reduce the amount or parsing and memory required.
*
* @param target this is the request URI that is to be parsed
*
* @return this is the index of meta data for the URI target
*/
public Index getIndex(String target) {
Index index = cache.get(target);
if(index == null) {
index = getIndex(this, target);
}
return index;
}
/**
* This is an all in one method that allows all the information
* on the target URI to be gathered at once. The motivation for
* this method is primarily convenience. However it is also used
* to increase the performance of the FileIndexer
* by using a cache of the most recently used indexes. This will
* help to reduce the amount or parsing and memory required.
* This is used as a convinience method for caching indexes.
*
* @param indexer this is typically the current indexer object
* @param target this is the request URI that is to be parsed
*
* @return this is the index of meta data for the URI target
*/
public Index getIndex(Indexer indexer, String target) {
Index index = new FileIndex(indexer, target);
if(target.indexOf('?') < 0) {
cache.put(target, index);
}
return index;
}
/**
* This is used to translate the HTTP request URI into the
* File object that it represents. This will convert
* the URI to a format that the system can use and then create
* the File object for that path. So if for example
* the context path was "c:\path" on a DOS system and the HTTP
* URI given was "/index.html" this returns the File
* "c:\path\index.html". This is basically for convenience as the
* same could be achieved using the getRealPath and
* then creating the File from that OS specific path.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the File object
*
* @return returns the File for the given path
*/
public File getFile(Address target) {
return getFile(target.getPath());
}
/**
* This is used to translate the HTTP request URI into the
* Path object that it represents. This enables the
* HTTP request URI to be examined thoroughly an allows various
* other files to be examined relative to it. For example if the
* URI referenced a path "/usr/bin/file" and some resource
* in the same directory is required then the Path
* can be used to acquire the relative path. This is useful if
* links within a HTML page are to be dynamically generated. The
* Path.getRelative provides this functionality.
*
* @param target this is the HTTP request URI path that is used
* to retrieve the Path object
*
* @return returns the Path for the given path
*/
public Path getPath(Address target){
return target.getPath();
}
/**
* This is used to translate the request URI path into the
* File object that it represents. This will convert
* the path to a format that the system can use and then create
* the File object for that path. So if for example
* the context path was "c:\path" on a DOS system and the request
* URI given was "/index.html" this returns the File
* "c:\path\index.html". This is basically for convenience as the
* same could be achieved using the getRealPath and
* then creating the File from that OS specific path.
*
* @param path this is the URI path that is used to retrieve the
* File object
*
* @return returns the File for the given path
*/
private File getFile(Path path) {
String file = path.toString();
if(file != null) {
file = file.replace('/', File.separatorChar);
}
return new File(base, file);
}
/**
* This method will extract the type attribute of this URI. The
* MIME type of the request URI is extracted from the name of the
* target. The name for the Context is the last path
* segment in the token defined by RFC 2396 as path_segments. So
* for example if the target was "some.host:8080/bin/index.html"
* then the name for that resource would be "index.html". Once
* the name has been extracted the MIME is defined by the file
* extension, which for the example is text/html.
*
* @param target the request URI to be parsed for its type
*
* @return the type of the given request URI path refers to
*/
public String getContentType(Address target){
return getContentType(target.getPath());
}
/**
* This method will extract the type attribute of this path. The
* MIME type of the request path is extracted from the name of the
* target. The name for the Context is the last path
* segment in the token defined by RFC 2396 as path_segments. So
* for example if the target was "some.host:8080/bin/index.html"
* then the name for that resource would be "index.html". Once
* the name has been extracted the MIME is defined by the file
* extension, which for the example is text/html.
*
* @param path path that is to have its MIME type determined
*
* @return the type of the given resource path refers to
*/
private String getContentType(Path path){
String ext = path.getExtension();
String target = path.getPath();
return getContentType(target, ext);
}
/**
* This method will extract the type attribute of this path. The
* MIME type of the request path is extracted from the name of the
* target. The name for the Context is the last path
* segment is the token defined by RFC 2396 as path_segments. So
* for example if the target was "some.host:8080/bin/index.html"
* then the name for that resource would be "index.html". Once
* the name has been extracted the MIME is defined by the file
* extension, which for the example is text/html.
*
* @param path path that is to have its MIME type determined
* @param ext this is the file extension for the given path
*
* @return the type of the given resource path refers to
*/
private String getContentType(String path, String ext) {
try {
ResourceBundle bundle = getBundle();
if(bundle != null) {
return bundle.getString(ext);
}
}catch(MissingResourceException e){
}
return "application/octetstream";
}
/**
* This is used to acquire the resource bundle used to map all of
* the MIME types for the indexer. By default this will acquire
* a properties file named FileIndexer.properties. If
* this file is not found then every content type will be the
* default application/octetstream type.
*
* @return the resource bundle to used for this file indexer
*/
private ResourceBundle getBundle() {
if(resolver == null) {
resolver = getClassBundle();
}
return resolver;
}
/**
* This is used to acquire the resource bundle used to map all of
* the MIME types for the indexer. By default this will acquire
* a properties file named FileIndexer.properties. If
* this file is not found then every content type will be the
* default application/octetstream type.
*
* @return the resource bundle to used for this file indexer
*/
private ResourceBundle getClassBundle() {
Class type = FileIndexer.class;
String name = type.getName();
return ResourceBundle.getBundle(name);
}
/**
* The Cache object essentially acts as a convenient
* typedef for caching addresses to their index. This allows the
* index to be retrieved much quicker when requested again. Each
* address key contains the query parameters and path parameters.
*
* @author Niall Gallagher
*/
private class Cache extends ConcurrentHashMapCache object. This acts
* as a quick means to lookup data on a resource by taking
* an unparsed address and mapping that to an index object.
*/
public Cache() {
super();
}
}
}
simple-http-4.1.21/src/org/simpleframework/http/resource/FileIndexer.properties 0000664 0000000 0000000 00000035267 12536602605 0027776 0 ustar 00root root 0000000 0000000 3dm=x-world/x-3dmf
3dmf=x-world/x-3dmf
a=application/octet-stream
aab=application/x-authorware-bin
aam=application/x-authorware-map
aas=application/x-authorware-seg
abc=text/vnd.abc
acgi=text/html
afl=video/animaflex
ai=application/postscript
aif=audio/aiff
aif=audio/x-aiff
aifc=audio/aiff
aifc=audio/x-aiff
aiff=audio/aiff
aiff=audio/x-aiff
aim=application/x-aim
aip=text/x-audiosoft-intra
ani=application/x-navi-animation
aos=application/x-nokia-9000-communicator-add-on-software
aps=application/mime
arc=application/octet-stream
arj=application/arj
arj=application/octet-stream
art=image/x-jg
asf=video/x-ms-asf
asm=text/x-asm
asp=text/asp
asx=application/x-mplayer2
asx=video/x-ms-asf
asx=video/x-ms-asf-plugin
au=audio/basic
au=audio/x-au
avi=application/x-troff-msvideo
avi=video/avi
avi=video/msvideo
avi=video/x-msvideo
avs=video/avs-video
bcpio=application/x-bcpio
bin=application/mac-binary
bin=application/macbinary
bin=application/octet-stream
bin=application/x-binary
bin=application/x-macbinary
bm=image/bmp
bmp=image/bmp
bmp=image/x-windows-bmp
boo=application/book
book=application/book
boz=application/x-bzip2
bsh=application/x-bsh
bz=application/x-bzip
bz2=application/x-bzip2
c=text/plain
c=text/x-c
c++=text/plain
cat=application/vnd.ms-pki.seccat
cc=text/plain
cc=text/x-c
ccad=application/clariscad
cco=application/x-cocoa
cdf=application/cdf
cdf=application/x-cdf
cdf=application/x-netcdf
cer=application/pkix-cert
cer=application/x-x509-ca-cert
cha=application/x-chat
chat=application/x-chat
class=application/java
class=application/java-byte-code
class=application/x-java-class
com=application/octet-stream
com=text/plain
conf=text/plain
cpio=application/x-cpio
cpp=text/x-c
cpt=application/mac-compactpro
cpt=application/x-compactpro
cpt=application/x-cpt
crl=application/pkcs-crl
crl=application/pkix-crl
crt=application/pkix-cert
crt=application/x-x509-ca-cert
crt=application/x-x509-user-cert
csh=application/x-csh
csh=text/x-script.csh
css=application/x-pointplus
css=text/css
cxx=text/plain
dcr=application/x-director
deepv=application/x-deepv
def=text/plain
der=application/x-x509-ca-cert
dif=video/x-dv
dir=application/x-director
dl=video/dl
dl=video/x-dl
doc=application/msword
dot=application/msword
dp=application/commonground
drw=application/drafting
dump=application/octet-stream
dv=video/x-dv
dvi=application/x-dvi
dwf=drawing/x-dwf (old)
dwf=model/vnd.dwf
dwg=application/acad
dwg=image/vnd.dwg
dwg=image/x-dwg
dxf=application/dxf
dxf=image/vnd.dwg
dxf=image/x-dwg
dxr=application/x-director
el=text/x-script.elisp
elc=application/x-bytecode.elisp (compile elisp)
elc=application/x-elc
env=application/x-envoy
eps=application/postscript
es=application/x-esrehber
etx=text/x-setext
evy=application/envoy
evy=application/x-envoy
exe=application/octet-stream
f=text/plain
f=text/x-fortran
f77=text/x-fortran
f90=text/plain
f90=text/x-fortran
fdf=application/vnd.fdf
fif=application/fractals
fif=image/fif
fli=video/fli
fli=video/x-fli
flo=image/florian
flx=text/vnd.fmi.flexstor
fmf=video/x-atomic3d-feature
for=text/plain
for=text/x-fortran
fpx=image/vnd.fpx
fpx=image/vnd.net-fpx
frl=application/freeloader
funk=audio/make
g=text/plain
g3=image/g3fax
gif=image/gif
gl=video/gl
gl=video/x-gl
gsd=audio/x-gsm
gsm=audio/x-gsm
gsp=application/x-gsp
gss=application/x-gss
gtar=application/x-gtar
gz=application/x-compressed
gz=application/x-gzip
gzip=application/x-gzip
gzip=multipart/x-gzip
h=text/plain
h=text/x-h
hdf=application/x-hdf
help=application/x-helpfile
hgl=application/vnd.hp-hpgl
hh=text/plain
hh=text/x-h
hlb=text/x-script
hlp=application/hlp
hlp=application/x-helpfile
hlp=application/x-winhelp
hpg=application/vnd.hp-hpgl
hpgl=application/vnd.hp-hpgl
hqx=application/binhex
hqx=application/binhex4
hqx=application/mac-binhex
hqx=application/mac-binhex40
hqx=application/x-binhex40
hqx=application/x-mac-binhex40
hta=application/hta
htc=text/x-component
htm=text/html
html=text/html
htmls=text/html
htt=text/webviewhtml
htx=text/html
ice=x-conference/x-cooltalk
ico=image/x-icon
idc=text/plain
ief=image/ief
iefs=image/ief
iges=application/iges
iges=model/iges
igs=application/iges
igs=model/iges
ima=application/x-ima
imap=application/x-httpd-imap
inf=application/inf
ins=application/x-internett-signup
ip=application/x-ip2
isu=video/x-isvideo
it=audio/it
iv=application/x-inventor
ivr=i-world/i-vrml
ivy=application/x-livescreen
jam=audio/x-jam
jav=text/plain
jav=text/x-java-source
java=text/plain
java=text/x-java-source
jcm=application/x-java-commerce
jfif=image/jpeg
jfif=image/pjpeg
jfif-tbnl=image/jpeg
jpe=image/jpeg
jpe=image/pjpeg
jpeg=image/jpeg
jpeg=image/pjpeg
jpg=image/jpeg
jpg=image/pjpeg
jps=image/x-jps
js=application/x-javascript
jut=image/jutvision
kar=audio/midi
kar=music/x-karaoke
ksh=application/x-ksh
ksh=text/x-script.ksh
la=audio/nspaudio
la=audio/x-nspaudio
lam=audio/x-liveaudio
latex=application/x-latex
lha=application/lha
lha=application/octet-stream
lha=application/x-lha
lhx=application/octet-stream
list=text/plain
lma=audio/nspaudio
lma=audio/x-nspaudio
log=text/plain
lsp=application/x-lisp
lsp=text/x-script.lisp
lst=text/plain
lsx=text/x-la-asf
ltx=application/x-latex
lzh=application/octet-stream
lzh=application/x-lzh
lzx=application/lzx
lzx=application/octet-stream
lzx=application/x-lzx
m=text/plain
m=text/x-m
m1v=video/mpeg
m2a=audio/mpeg
m2v=video/mpeg
m3u=audio/x-mpequrl
man=application/x-troff-man
map=application/x-navimap
mar=text/plain
mbd=application/mbedlet
mc$=application/x-magic-cap-package-1.0
mcd=application/mcad
mcd=application/x-mathcad
mcf=image/vasa
mcf=text/mcf
mcp=application/netmc
me=application/x-troff-me
mht=message/rfc822
mhtml=message/rfc822
mid=application/x-midi
mid=audio/midi
mid=audio/x-mid
mid=audio/x-midi
mid=music/crescendo
mid=x-music/x-midi
midi=application/x-midi
midi=audio/midi
midi=audio/x-mid
midi=audio/x-midi
midi=music/crescendo
midi=x-music/x-midi
mif=application/x-frame
mif=application/x-mif
mime=message/rfc822
mime=www/mime
mjf=audio/x-vnd.audioexplosion.mjuicemediafile
mjpg=video/x-motion-jpeg
mm=application/base64
mm=application/x-meme
mme=application/base64
mod=audio/mod
mod=audio/x-mod
moov=video/quicktime
mov=video/quicktime
movie=video/x-sgi-movie
mp2=audio/mpeg
mp2=audio/x-mpeg
mp2=video/mpeg
mp2=video/x-mpeg
mp2=video/x-mpeq2a
mp3=audio/mpeg3
mp3=audio/x-mpeg-3
mp3=video/mpeg
mp3=video/x-mpeg
mpa=audio/mpeg
mpa=video/mpeg
mpc=application/x-project
mpe=video/mpeg
mpeg=video/mpeg
mpg=audio/mpeg
mpg=video/mpeg
mpga=audio/mpeg
mpp=application/vnd.ms-project
mpt=application/x-project
mpv=application/x-project
mpx=application/x-project
mrc=application/marc
ms=application/x-troff-ms
mv=video/x-sgi-movie
my=audio/make
mzz=application/x-vnd.audioexplosion.mzz
nap=image/naplps
naplps=image/naplps
nc=application/x-netcdf
ncm=application/vnd.nokia.configuration-message
nif=image/x-niff
niff=image/x-niff
nix=application/x-mix-transfer
nsc=application/x-conference
nvd=application/x-navidoc
o=application/octet-stream
oda=application/oda
omc=application/x-omc
omcd=application/x-omcdatamaker
omcr=application/x-omcregerator
p=text/x-pascal
p10=application/pkcs10
p10=application/x-pkcs10
p12=application/pkcs-12
p12=application/x-pkcs12
p7a=application/x-pkcs7-signature
p7c=application/pkcs7-mime
p7c=application/x-pkcs7-mime
p7m=application/pkcs7-mime
p7m=application/x-pkcs7-mime
p7r=application/x-pkcs7-certreqresp
p7s=application/pkcs7-signature
part=application/pro_eng
pas=text/pascal
pbm=image/x-portable-bitmap
pcl=application/vnd.hp-pcl
pcl=application/x-pcl
pct=image/x-pict
pcx=image/x-pcx
pdb=chemical/x-pdb
pdf=application/pdf
pfunk=audio/make
pfunk=audio/make.my.funk
pgm=image/x-portable-graymap
pgm=image/x-portable-greymap
pic=image/pict
pict=image/pict
pkg=application/x-newton-compatible-pkg
pko=application/vnd.ms-pki.pko
pl=text/plain
pl=text/x-script.perl
plx=application/x-pixclscript
pm=image/x-xpixmap
pm=text/x-script.perl-module
pm4=application/x-pagemaker
pm5=application/x-pagemaker
png=image/png
pnm=application/x-portable-anymap
pnm=image/x-portable-anymap
pot=application/mspowerpoint
pot=application/vnd.ms-powerpoint
pov=model/x-pov
ppa=application/vnd.ms-powerpoint
ppm=image/x-portable-pixmap
pps=application/mspowerpoint
pps=application/vnd.ms-powerpoint
ppt=application/mspowerpoint
ppt=application/powerpoint
ppt=application/vnd.ms-powerpoint
ppt=application/x-mspowerpoint
ppz=application/mspowerpoint
pre=application/x-freelance
prt=application/pro_eng
ps=application/postscript
psd=application/octet-stream
pvu=paleovu/x-pv
pwz=application/vnd.ms-powerpoint
py=text/x-script.phyton
pyc=applicaiton/x-bytecode.python
qcp=audio/vnd.qcelp
qd3=x-world/x-3dmf
qd3d=x-world/x-3dmf
qif=image/x-quicktime
qt=video/quicktime
qtc=video/x-qtc
qti=image/x-quicktime
qtif=image/x-quicktime
ra=audio/x-pn-realaudio
ra=audio/x-pn-realaudio-plugin
ra=audio/x-realaudio
ram=audio/x-pn-realaudio
ras=application/x-cmu-raster
ras=image/cmu-raster
ras=image/x-cmu-raster
rast=image/cmu-raster
rexx=text/x-script.rexx
rf=image/vnd.rn-realflash
rgb=image/x-rgb
rm=application/vnd.rn-realmedia
rm=audio/x-pn-realaudio
rmi=audio/mid
rmm=audio/x-pn-realaudio
rmp=audio/x-pn-realaudio
rmp=audio/x-pn-realaudio-plugin
rng=application/ringing-tones
rng=application/vnd.nokia.ringing-tone
rnx=application/vnd.rn-realplayer
roff=application/x-troff
rp=image/vnd.rn-realpix
rpm=audio/x-pn-realaudio-plugin
rt=text/richtext
rt=text/vnd.rn-realtext
rtf=application/rtf
rtf=application/x-rtf
rtf=text/richtext
rtx=application/rtf
rtx=text/richtext
rv=video/vnd.rn-realvideo
s=text/x-asm
s3m=audio/s3m
saveme=application/octet-stream
sbk=application/x-tbook
scm=application/x-lotusscreencam
scm=text/x-script.guile
scm=text/x-script.scheme
scm=video/x-scm
sdml=text/plain
sdp=application/sdp
sdp=application/x-sdp
sdr=application/sounder
sea=application/sea
sea=application/x-sea
set=application/set
sgm=text/sgml
sgm=text/x-sgml
sgml=text/sgml
sgml=text/x-sgml
sh=application/x-bsh
sh=application/x-sh
sh=application/x-shar
sh=text/x-script.sh
shar=application/x-bsh
shar=application/x-shar
shtml=text/html
shtml=text/x-server-parsed-html
sid=audio/x-psid
sit=application/x-sit
sit=application/x-stuffit
skd=application/x-koan
skm=application/x-koan
skp=application/x-koan
skt=application/x-koan
sl=application/x-seelogo
smi=application/smil
smil=application/smil
snd=audio/basic
snd=audio/x-adpcm
sol=application/solids
spc=application/x-pkcs7-certificates
spc=text/x-speech
spl=application/futuresplash
spr=application/x-sprite
sprite=application/x-sprite
src=application/x-wais-source
ssi=text/x-server-parsed-html
ssm=application/streamingmedia
sst=application/vnd.ms-pki.certstore
step=application/step
stl=application/sla
stl=application/vnd.ms-pki.stl
stl=application/x-navistyle
stp=application/step
sv4cpio=application/x-sv4cpio
sv4crc=application/x-sv4crc
svf=image/vnd.dwg
svf=image/x-dwg
svr=application/x-world
svr=x-world/x-svr
swf=application/x-shockwave-flash
t=application/x-troff
talk=text/x-speech
tar=application/x-tar
tbk=application/toolbook
tbk=application/x-tbook
tcl=application/x-tcl
tcl=text/x-script.tcl
tcsh=text/x-script.tcsh
tex=application/x-tex
texi=application/x-texinfo
texinfo=application/x-texinfo
text=application/plain
text=text/plain
tgz=application/gnutar
tgz=application/x-compressed
tif=image/tiff
tif=image/x-tiff
tiff=image/tiff
tiff=image/x-tiff
tr=application/x-troff
tsi=audio/tsp-audio
tsp=application/dsptype
tsp=audio/tsplayer
tsv=text/tab-separated-values
turbot=image/florian
txt=text/plain
uil=text/x-uil
uni=text/uri-list
unis=text/uri-list
unv=application/i-deas
uri=text/uri-list
uris=text/uri-list
ustar=application/x-ustar
ustar=multipart/x-ustar
uu=application/octet-stream
uu=text/x-uuencode
uue=text/x-uuencode
vcd=application/x-cdlink
vcs=text/x-vcalendar
vda=application/vda
vdo=video/vdo
vew=application/groupwise
viv=video/vivo
viv=video/vnd.vivo
vivo=video/vivo
vivo=video/vnd.vivo
vmd=application/vocaltec-media-desc
vmf=application/vocaltec-media-file
voc=audio/voc
voc=audio/x-voc
vos=video/vosaic
vox=audio/voxware
vqe=audio/x-twinvq-plugin
vqf=audio/x-twinvq
vql=audio/x-twinvq-plugin
vrml=application/x-vrml
vrml=model/vrml
vrml=x-world/x-vrml
vrt=x-world/x-vrt
vsd=application/x-visio
vst=application/x-visio
vsw=application/x-visio
w60=application/wordperfect6.0
w61=application/wordperfect6.1
w6w=application/msword
wav=audio/wav
wav=audio/x-wav
wb1=application/x-qpro
wbmp=image/vnd.wap.wbmp
web=application/vnd.xara
wiz=application/msword
wk1=application/x-123
wmf=windows/metafile
wml=text/vnd.wap.wml
wmlc=application/vnd.wap.wmlc
wmls=text/vnd.wap.wmlscript
wmlsc=application/vnd.wap.wmlscriptc
word=application/msword
wp=application/wordperfect
wp5=application/wordperfect
wp5=application/wordperfect6.0
wp6=application/wordperfect
wpd=application/wordperfect
wpd=application/x-wpwin
wq1=application/x-lotus
wri=application/mswrite
wri=application/x-wri
wrl=application/x-world
wrl=model/vrml
wrl=x-world/x-vrml
wrz=model/vrml
wrz=x-world/x-vrml
wsc=text/scriplet
wsrc=application/x-wais-source
wtk=application/x-wintalk
xbm=image/x-xbitmap
xbm=image/x-xbm
xbm=image/xbm
xdr=video/x-amt-demorun
xgz=xgl/drawing
xif=image/vnd.xiff
xl=application/excel
xla=application/excel
xla=application/x-excel
xla=application/x-msexcel
xlb=application/excel
xlb=application/vnd.ms-excel
xlb=application/x-excel
xlc=application/excel
xlc=application/vnd.ms-excel
xlc=application/x-excel
xld=application/excel
xld=application/x-excel
xlk=application/excel
xlk=application/x-excel
xll=application/excel
xll=application/vnd.ms-excel
xll=application/x-excel
xlm=application/excel
xlm=application/vnd.ms-excel
xlm=application/x-excel
xls=application/excel
xls=application/vnd.ms-excel
xls=application/x-excel
xls=application/x-msexcel
xlt=application/excel
xlt=application/x-excel
xlv=application/excel
xlv=application/x-excel
xlw=application/excel
xlw=application/vnd.ms-excel
xlw=application/x-excel
xlw=application/x-msexcel
xm=audio/xm
xml=application/xml
xml=text/xml
xmz=xgl/movie
xpix=application/x-vnd.ls-xpix
xpm=image/x-xpixmap
xpm=image/xpm
x-png=image/png
xsr=video/x-amt-showrun
xwd=image/x-xwd
xwd=image/x-xwindowdump
xyz=chemical/x-pdb
z=application/x-compress
z=application/x-compressed
zip=application/x-compressed
zip=application/x-zip-compressed
zip=application/zip
zip=multipart/x-zip
zoo=application/octet-stream
zsh=text/x-script.zsh
simple-http-4.1.21/src/org/simpleframework/http/resource/Index.java 0000664 0000000 0000000 00000007433 12536602605 0025366 0 ustar 00root root 0000000 0000000 /*
* Index.java December 2005
*
* Copyright (C) 2005, Niall Gallagher Index object is used to represent the properties
* a URI can contain. This is used so that properties relating to a
* file can be quickly extracted from an Indexer. This
* will contain all necessary meta data for a file or resource. With
* this the File reference to a resource as well as the
* locale, MIME type, name and other such data can be accessed.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.resource.Indexer
*/
public interface Index {
/**
* This allows the name for this object to be acquired. The
* name usually refers to the last entry in the path. So if
* the index target path was "/usr/bin/" the name is "bin".
*
* @return this returns the name of this index target
*/
public String getName();
/**
* This allows the MIME type of this Index to
* be acquired. The MIME type of a file is retrieved by the
* Context.getContentType method for a specific
* request URI. This should have a value and perhaps some
* parameters like the charset, "text/html; charset=UTF-8".
*
* @return the MIME type this object has been set to
*/
public String getContentType();
/**
* This is used to get the path that this object refers to.
* This should be the fully qualified normalized path. This
* refers to the OS system specific path that this represents.
*
* @return this returns the OS specific path for the target
*/
public String getRealPath();
/**
* This is used to acquire the normalized URI style path for
* the index target. This allows the path to be used within
* the Mapper and other such objects that need
* a normalized URI style path to resolve resources.
*
* @return this returns the normalized path for the target
*/
public String getRequestPath();
/**
* This is used to acquire the File directory
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows resources within the
* same directory to be acquired easily.
*
* @return this returns the OS file for the directory
*/
public File getDirectory();
/**
* This is used to acquire the File reference
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows the file to be opened,
* deleted, or read should the need arise in a service.
*
* @return this returns the OS file for the resource
*/
public File getFile();
/**
* This is used to acquire the Path object that
* exposes various parts of the URI path. This can be used
* to extract the individual path segments as strings as
* well as the file extension and various other details.
*
* @return this returns a path object with various details
*/
public Path getPath();
}
simple-http-4.1.21/src/org/simpleframework/http/resource/Indexer.java 0000664 0000000 0000000 00000005532 12536602605 0025713 0 ustar 00root root 0000000 0000000 /*
* Indexer.java December 2005
*
* Copyright (C) 2005, Niall Gallagher Indexer object is used to acquire meta data for
* a address target. This provides a centralized source for meta data
* within the server. The need to acquire information such as MIME
* type, locale, and various other details for a Address frequently
* arises. In order to provide a consistent set of details for a
* specific target an Indexer implementation is used.
* This helps various services and resources acquire meta data
* quickly by facilitating a meta data cache for a context.
*
* @author Niall Gallagher
*
* @see org.simpleframework.http.resource.Index
*/
interface Indexer {
/**
* This is used to acquire the File reference
* for the index target. This is typically rooted at a
* base path, for instance the Context root
* is typically used. This allows the file to be opened,
* deleted, or read should the need arise in a service.
*
* @param target the index target to get the OS file for
*
* @return this returns the OS file for the resource
*/
public File getFile(Address target);
/**
* This is used to acquire the Path object that
* exposes various parts of the address path. This can be used
* to extract the individual path segments as strings as
* well as the file extension and various other details.
*
* @param target the index target to get the Address path for
*
* @return this returns a path object with various details
*/
public Path getPath(Address target);
/**
* This allows the MIME type of this Index to
* be acquired. The MIME type of a file is retrieved by the
* Context.getContentType method for a specific
* request address. This should have a value and perhaps some
* parameters like the charset, "text/html; charset=UTF-8".
*
* @param target the index target to get the MIME type for
*
* @return the MIME type this object has been set to
*/
public String getContentType(Address target);
} simple-http-4.1.21/src/org/simpleframework/http/resource/Resource.java 0000664 0000000 0000000 00000004000 12536602605 0026071 0 ustar 00root root 0000000 0000000 /*
* Resource.java February 2001
*
* Copyright (C) 2001, Niall Gallagher Resource provides an abstraction of any given
* object that can be retrieved using a HTTP request. The reason
* for having this abstraction is to simplify the interface with
* any given Resource.
* Container, however
* this is intended to handle a single resource. At any time a
* container may manage many resources all of which are resolved
* using a ResourceEngine implementation. So in
* essence this is used to identify a component that can handle
* a HTTP request routed by a resource engine.
*
* @author Niall Gallagher
*/
public interface Resource {
/**
* This acts as the main processing method for the resources.
* Implementations are required to provide the functions that
* will process the Request and generate a suitable
* response for that request. This method is also responsible
* for closing and comitting the Response unless
* handed (chained) to another Resource.
*
* @param req the Request to be processed
* @param resp the Response to be processed
*/
public void handle(Request req, Response resp);
}
simple-http-4.1.21/src/org/simpleframework/http/resource/ResourceContainer.java 0000664 0000000 0000000 00000005072 12536602605 0027746 0 ustar 00root root 0000000 0000000 /*
* ResourceProcessor.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ResourceContainer is an implementation of the
* Container interface for handling an arbitrary set
* of resources. This container will accept any HTTP transaction
* and delegate the processing of that transation to a resource.
* This resolves the resource to use using an implementation of
* the ResourceEngine interface.
* ResourceContainer object.
* This requires a resource engine which it uses to map the
* request targets to a given implementation or instance.
* This is essentially a router to the Resource
* objects that have been mapped to a given request path.
*
* @param engine the engine used to resolve resources
*/
public ResourceContainer(ResourceEngine engine){
this.engine = engine;
}
/**
* This method is where most of the work is done to retrieve
* the Resource and process the HTTP request. This
* will basically use the resolve method of the
* issued ResourceEngine to acquire resources.
*
* @param req the Request to be processed
* @param resp the Response to be processed
*/
public void handle(Request req, Response resp){
engine.resolve(req.getAddress()).handle(req,resp);
}
}
simple-http-4.1.21/src/org/simpleframework/http/resource/ResourceEngine.java 0000664 0000000 0000000 00000005231 12536602605 0027226 0 ustar 00root root 0000000 0000000 /*
* ResourceEngine.java February 2001
*
* Copyright (C) 2001, Niall Gallagher ResourceEngine is used to create implementations
* of the Resource interface that suit the targeted
* resource. Different Resource objects may be needed to
* handle different files/directories or even applications. The request
* URI specified must be a HTTP request URI as of RFC 2616.
*
* Request-Line = Method SP Request-URI SP HTTP-Version CRLF
*
* Request-URI = "*" | absoluteURI | abs_path | authority
* absoluteURI = "http:" "//" host [":" port] [abs_path ["?" query]]
* abs_path = "/" path_segments
* path_segments = segment *( "/" segment )
*
*
* The ResourceEngine object must be prepared to accept
* the request URI that come in the form outlined above. These can
* include formats like
*
*
* http://some.host/pub;param=value/bin/index.html?name=value
* http://some.host:8080/index.en_US.html
* some.host:8080/index.html
* /usr/bin;param=value/README.txt
* /usr/bin/compress.tar.gz
*
*
* The ResourceEngine implementation should be able to
* directly take a Request-URI as defined in RFC 2616 and translate
* this into a Resource. This keeps the objects semantics
* simple and explicit, although at the expense of performance.
*
* @author Niall Gallagher
*/
public interface ResourceEngine {
/**
* This will look for and retrieve the requested resource. The
* target given must be in the form of a request URI. This will
* locate the resource and return the Resource
* implementation that will handle the target.
*
* @param target the address used to identify the resource
*
* @return this returns the resource used to handle the request
*/
public Resource resolve(Address target);
}
simple-http-4.1.21/src/org/simpleframework/http/session/ 0000775 0000000 0000000 00000000000 12536602605 0023301 5 ustar 00root root 0000000 0000000 simple-http-4.1.21/src/org/simpleframework/http/session/Composer.java 0000664 0000000 0000000 00000015344 12536602605 0025742 0 ustar 00root root 0000000 0000000 /*
* Composer.java May 2007
*
* Copyright (C) 2007, Niall Gallagher Composer object is used to create an object that
* is used to create, store, and find session objects. This is also
* used to dispose of sessions once they have expired. Creating a
* new session is done with the compose method. This
* will create a lease for the session for a fixed duration of time.
*
* @author Niall Gallagher
*/
class ComposerComposer object. This is used
* create an object to compose session objects, and to manage the
* leasing of those sessions. This makes use of the existing lease
* framework to manage the lifecycle of the session instances.
*
* @param observer this is used to observe the session manager
* @param duration this is the idle duration for each session
* @param unit this is the duration time unit measurement used
*/
public Composer(Observerclose method is used to close the provider
* and release all resources associated with it. This includes
* canceling all active sessions. All resources held by this are
* released by this method and all can be garbage collected.
*
* @exception Exception if the composer can not be closed
*/
public void close() throws LeaseException {
if(!closed) {
manager.close();
}
closed = true;
}
/**
* This is used to remove the keyed session from the composer. If
* the session does not exist then this will throw an exception.
* Once this method has been executed the session is no longer
* available and a new one is required for the specified key.
*
* @exception if the session does not exist or has expired
*/
public void clean(T key) throws Exception {
SessionController object is used to manage all life cycle
* events for sessions. This is used to start and renew all leases
* issued. The start life cycle event is used when the session is first
* created, this will lease the new session for some fixed duration.
* The renew event is performed when an existing session is accessed
* again so that the session can be maintained for the default period.
*
* @author Niall Gallagher
*/
interface Controllerstart method is used when a session is to
* be created for the first time. This will ensure that the key
* specified is used to dispose of the session when its idle
* timeout has expired.
*
* @param key this is the unique key identifying the session
*/
public Leaserenew method is used when a session has been
* accessed for a again. This ensures that the key specified is
* used to dispose of the session when its idle timeout expires.
*
* @param key this is the unique key identifying the session
*/
public void renew(T key) throws LeaseException;
/**
* The cancel method is used when a session is no
* longer required and is to be disposed of. This is typically
* invoked by a web application to release occupied resources.
*
* @param key this is the unique key identifying the session
*/
public void cancel(T key) throws LeaseException;
} simple-http-4.1.21/src/org/simpleframework/http/session/LeaseSession.java 0000664 0000000 0000000 00000004050 12536602605 0026540 0 ustar 00root root 0000000 0000000 /*
* Delegate.java May 2007
*
* Copyright (C) 2007, Niall Gallagher LeaseSession object is used to provide a session
* instance that is created from a concurrent hash map. This makes
* use of a Lease to handle all life cycle events such
* as canceling and renewing the lease maintaining the session.
*
* @author Niall Gallagher
*/
class LeaseSessionLeaseSession object. This will
* create an instance using the provided lease for the session.
* The lease is used to handle all session life cycle events.
*
* @param lease this is used to manage all the life cycle events
*/
public LeaseSession(LeaseLease object to control
* the session. The lease is responsible for maintaining this map
* within the application. Once the lease expires the session will
* be removed and its mapped values will be available for recovery.
*
* @return this returns the lease used to manage this session
*/
public LeaseMaintainer object is used to manage all life cycle
* events for sessions. This is used to start and renew all leases
* issued. The start life cycle event is used when the session is first
* created, this will lease the new session for some fixed duration.
* The renew event is performed when an existing session is accessed
* again so that the session can be maintained for the default period.
*
* @author Niall Gallagher
*/
class MaintainerMaintainer object. This is used
* to maintain a lease for a resource using only the key for that
* resource. Each renewal of the lease is performed using a fixed
* duration so that the the time does not need to be specified.
*
* @param manager this is the manager used to create the leases
* @param duration this is the fixed duration to renew for
* @param unit this is the unit of measurement for the duration
*/
public Maintainer(LeaseManagerstart method is used when a session is to
* be created for the first time. This will ensure that the key
* specified is used to dispose of the session when its idle
* timeout has expired.
*
* @param key this is the unique key identifying the session
*/
public Lease