You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@felix.apache.org by er...@apache.org on 2005/12/08 21:56:08 UTC
svn commit: r355208 [2/3] - in /incubator/felix/trunk/javax.servlet: ./ src/
src/main/ src/main/java/ src/main/java/javax/ src/main/java/javax/servlet/
src/main/java/javax/servlet/http/ src/main/resources/
Added: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/UnavailableException.java
URL: http://svn.apache.org/viewcvs/incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/UnavailableException.java?rev=355208&view=auto
==============================================================================
--- incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/UnavailableException.java (added)
+++ incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/UnavailableException.java Thu Dec 8 12:55:55 2005
@@ -0,0 +1,149 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet;
+
+
+/**
+ * Defines an exception that a servlet throws to indicate
+ * that it is permanently or temporarily unavailable.
+ *
+ * <p>When a servlet is permanently unavailable, something is wrong
+ * with the servlet, and it cannot handle
+ * requests until some action is taken. For example, the servlet
+ * might be configured incorrectly, or its state may be corrupted.
+ * A servlet should log both the error and the corrective action
+ * that is needed.
+ *
+ * <p>A servlet is temporarily unavailable if it cannot handle
+ * requests momentarily due to some system-wide problem. For example,
+ * a third-tier server might not be accessible, or there may be
+ * insufficient memory or disk storage to handle requests. A system
+ * administrator may need to take corrective action.
+ *
+ * <p>Servlet containers can safely treat both types of unavailable
+ * exceptions in the same way. However, treating temporary unavailability
+ * effectively makes the servlet container more robust. Specifically,
+ * the servlet container might block requests to the servlet for a period
+ * of time suggested by the exception, rather than rejecting them until
+ * the servlet container restarts.
+ *
+ *
+ * @author Various
+ * @version $Version$
+ *
+ */
+
+public class UnavailableException
+extends ServletException {
+
+ private Servlet servlet; // what's unavailable
+ private boolean permanent; // needs admin action?
+ private int seconds; // unavailability estimate
+
+ /**
+ *
+ * @param servlet the <code>Servlet</code> instance that is
+ * unavailable
+ *
+ * @param msg a <code>String</code> specifying the
+ * descriptive message
+ *
+ */
+
+ public UnavailableException(Servlet servlet, String msg) {
+ super(msg);
+ this.servlet = servlet;
+ permanent = true;
+ }
+
+ /**
+ *
+ * @param seconds an integer specifying the number of seconds
+ * the servlet expects to be unavailable; if
+ * zero or negative, indicates that the servlet
+ * can't make an estimate
+ *
+ * @param servlet the <code>Servlet</code> that is unavailable
+ *
+ * @param msg a <code>String</code> specifying the descriptive
+ * message, which can be written to a log file or
+ * displayed for the user.
+ *
+ */
+
+ public UnavailableException(int seconds, Servlet servlet, String msg) {
+ super(msg);
+ this.servlet = servlet;
+ if (seconds <= 0)
+ this.seconds = -1;
+ else
+ this.seconds = seconds;
+ permanent = false;
+ }
+
+ /**
+ *
+ * Returns a <code>boolean</code> indicating
+ * whether the servlet is permanently unavailable.
+ * If so, something is wrong with the servlet, and the
+ * system administrator must take some corrective action.
+ *
+ * @return <code>true</code> if the servlet is
+ * permanently unavailable; <code>false</code>
+ * if the servlet is available or temporarily
+ * unavailable
+ *
+ */
+
+ public boolean isPermanent() {
+ return permanent;
+ }
+
+ /**
+ *
+ * Returns the servlet that is reporting its unavailability.
+ *
+ * @return the <code>Servlet</code> object that is
+ * throwing the <code>UnavailableException</code>
+ *
+ */
+
+ public Servlet getServlet() {
+ return servlet;
+ }
+
+ /**
+ * Returns the number of seconds the servlet expects to
+ * be temporarily unavailable.
+ *
+ * <p>If this method returns a negative number, the servlet
+ * is permanently unavailable or cannot provide an estimate of
+ * how long it will be unavailable. No effort is
+ * made to correct for the time elapsed since the exception was
+ * first reported.
+ *
+ * @return an integer specifying the number of seconds
+ * the servlet will be temporarily unavailable,
+ * or a negative number if the servlet is permanently
+ * unavailable or cannot make an estimate
+ *
+ */
+
+ public int getUnavailableSeconds() {
+ return permanent ? -1 : seconds;
+ }
+}
Propchange: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/UnavailableException.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/Cookie.java
URL: http://svn.apache.org/viewcvs/incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/Cookie.java?rev=355208&view=auto
==============================================================================
--- incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/Cookie.java (added)
+++ incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/Cookie.java Thu Dec 8 12:55:55 2005
@@ -0,0 +1,536 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+
+/**
+ *
+ * Creates a cookie, a small amount of information sent by a servlet to
+ * a Web browser, saved by the browser, and later sent back to the server.
+ * A cookie's value can uniquely
+ * identify a client, so cookies are commonly used for session management.
+ *
+ * <p>A cookie has a name, a single value, and optional attributes
+ * such as a comment, path and domain qualifiers, a maximum age, and a
+ * version number. Some Web browsers have bugs in how they handle the
+ * optional attributes, so use them sparingly to improve the interoperability
+ * of your servlets.
+ *
+ * <p>The servlet sends cookies to the browser by using the
+ * {@link HttpServletResponse#addCookie} method, which adds
+ * fields to HTTP response headers to send cookies to the
+ * browser, one at a time. The browser is expected to
+ * support 20 cookies for each Web server, 300 cookies total, and
+ * may limit cookie size to 4 KB each.
+ *
+ * <p>The browser returns cookies to the servlet by adding
+ * fields to HTTP request headers. Cookies can be retrieved
+ * from a request by using the {@link HttpServletRequest#getCookies} method.
+ * Several cookies might have the same name but different path attributes.
+ *
+ * <p>Cookies affect the caching of the Web pages that use them.
+ * HTTP 1.0 does not cache pages that use cookies created with
+ * this class. This class does not support the cache control
+ * defined with HTTP 1.1.
+ *
+ * <p>This class supports both the Version 0 (by Netscape) and Version 1
+ * (by RFC 2109) cookie specifications. By default, cookies are
+ * created using Version 0 to ensure the best interoperability.
+ *
+ *
+ * @author Various
+ * @version $Version$
+ *
+ */
+
+// XXX would implement java.io.Serializable too, but can't do that
+// so long as sun.servlet.* must run on older JDK 1.02 JVMs which
+// don't include that support.
+
+public class Cookie implements Cloneable {
+
+ private static final String LSTRING_FILE =
+ "javax.servlet.http.LocalStrings";
+ private static ResourceBundle lStrings =
+ ResourceBundle.getBundle(LSTRING_FILE);
+
+ //
+ // The value of the cookie itself.
+ //
+
+ private String name; // NAME= ... "$Name" style is reserved
+ private String value; // value of NAME
+
+ //
+ // Attributes encoded in the header's cookie fields.
+ //
+
+ private String comment; // ;Comment=VALUE ... describes cookie's use
+ // ;Discard ... implied by maxAge < 0
+ private String domain; // ;Domain=VALUE ... domain that sees cookie
+ private int maxAge = -1; // ;Max-Age=VALUE ... cookies auto-expire
+ private String path; // ;Path=VALUE ... URLs that see the cookie
+ private boolean secure; // ;Secure ... e.g. use SSL
+ private int version = 0; // ;Version=1 ... means RFC 2109++ style
+
+
+
+ /**
+ * Constructs a cookie with a specified name and value.
+ *
+ * <p>The name must conform to RFC 2109. That means it can contain
+ * only ASCII alphanumeric characters and cannot contain commas,
+ * semicolons, or white space or begin with a $ character. The cookie's
+ * name cannot be changed after creation.
+ *
+ * <p>The value can be anything the server chooses to send. Its
+ * value is probably of interest only to the server. The cookie's
+ * value can be changed after creation with the
+ * <code>setValue</code> method.
+ *
+ * <p>By default, cookies are created according to the Netscape
+ * cookie specification. The version can be changed with the
+ * <code>setVersion</code> method.
+ *
+ *
+ * @param name a <code>String</code> specifying the name of the cookie
+ *
+ * @param value a <code>String</code> specifying the value of the cookie
+ *
+ * @throws IllegalArgumentException if the cookie name contains illegal characters
+ * (for example, a comma, space, or semicolon)
+ * or it is one of the tokens reserved for use
+ * by the cookie protocol
+ * @see #setValue
+ * @see #setVersion
+ *
+ */
+
+ public Cookie(String name, String value) {
+ if (!isToken(name)
+ || name.equalsIgnoreCase("Comment") // rfc2019
+ || name.equalsIgnoreCase("Discard") // 2019++
+ || name.equalsIgnoreCase("Domain")
+ || name.equalsIgnoreCase("Expires") // (old cookies)
+ || name.equalsIgnoreCase("Max-Age") // rfc2019
+ || name.equalsIgnoreCase("Path")
+ || name.equalsIgnoreCase("Secure")
+ || name.equalsIgnoreCase("Version")
+ ) {
+ String errMsg = lStrings.getString("err.cookie_name_is_token");
+ Object[] errArgs = new Object[1];
+ errArgs[0] = name;
+ errMsg = MessageFormat.format(errMsg, errArgs);
+ throw new IllegalArgumentException(errMsg);
+ }
+
+ this.name = name;
+ this.value = value;
+ }
+
+
+
+
+
+ /**
+ *
+ * Specifies a comment that describes a cookie's purpose.
+ * The comment is useful if the browser presents the cookie
+ * to the user. Comments
+ * are not supported by Netscape Version 0 cookies.
+ *
+ * @param purpose a <code>String</code> specifying the comment
+ * to display to the user
+ *
+ * @see #getComment
+ *
+ */
+
+ public void setComment(String purpose) {
+ comment = purpose;
+ }
+
+
+
+
+ /**
+ * Returns the comment describing the purpose of this cookie, or
+ * <code>null</code> if the cookie has no comment.
+ *
+ * @return a <code>String</code> containing the comment,
+ * or <code>null</code> if none
+ *
+ * @see #setComment
+ *
+ */
+
+ public String getComment() {
+ return comment;
+ }
+
+
+
+
+
+ /**
+ *
+ * Specifies the domain within which this cookie should be presented.
+ *
+ * <p>The form of the domain name is specified by RFC 2109. A domain
+ * name begins with a dot (<code>.foo.com</code>) and means that
+ * the cookie is visible to servers in a specified Domain Name System
+ * (DNS) zone (for example, <code>www.foo.com</code>, but not
+ * <code>a.b.foo.com</code>). By default, cookies are only returned
+ * to the server that sent them.
+ *
+ *
+ * @param pattern a <code>String</code> containing the domain name
+ * within which this cookie is visible;
+ * form is according to RFC 2109
+ *
+ * @see #getDomain
+ *
+ */
+
+ public void setDomain(String pattern) {
+ domain = pattern.toLowerCase(); // IE allegedly needs this
+ }
+
+
+
+
+
+ /**
+ * Returns the domain name set for this cookie. The form of
+ * the domain name is set by RFC 2109.
+ *
+ * @return a <code>String</code> containing the domain name
+ *
+ * @see #setDomain
+ *
+ */
+
+ public String getDomain() {
+ return domain;
+ }
+
+
+
+
+ /**
+ * Sets the maximum age of the cookie in seconds.
+ *
+ * <p>A positive value indicates that the cookie will expire
+ * after that many seconds have passed. Note that the value is
+ * the <i>maximum</i> age when the cookie will expire, not the cookie's
+ * current age.
+ *
+ * <p>A negative value means
+ * that the cookie is not stored persistently and will be deleted
+ * when the Web browser exits. A zero value causes the cookie
+ * to be deleted.
+ *
+ * @param expiry an integer specifying the maximum age of the
+ * cookie in seconds; if negative, means
+ * the cookie is not stored; if zero, deletes
+ * the cookie
+ *
+ *
+ * @see #getMaxAge
+ *
+ */
+
+ public void setMaxAge(int expiry) {
+ maxAge = expiry;
+ }
+
+
+
+
+ /**
+ * Returns the maximum age of the cookie, specified in seconds,
+ * By default, <code>-1</code> indicating the cookie will persist
+ * until browser shutdown.
+ *
+ *
+ * @return an integer specifying the maximum age of the
+ * cookie in seconds; if negative, means
+ * the cookie persists until browser shutdown
+ *
+ *
+ * @see #setMaxAge
+ *
+ */
+
+ public int getMaxAge() {
+ return maxAge;
+ }
+
+
+
+
+ /**
+ * Specifies a path for the cookie
+ * to which the client should return the cookie.
+ *
+ * <p>The cookie is visible to all the pages in the directory
+ * you specify, and all the pages in that directory's subdirectories.
+ * A cookie's path must include the servlet that set the cookie,
+ * for example, <i>/catalog</i>, which makes the cookie
+ * visible to all directories on the server under <i>/catalog</i>.
+ *
+ * <p>Consult RFC 2109 (available on the Internet) for more
+ * information on setting path names for cookies.
+ *
+ *
+ * @param uri a <code>String</code> specifying a path
+ *
+ *
+ * @see #getPath
+ *
+ */
+
+ public void setPath(String uri) {
+ path = uri;
+ }
+
+
+
+
+ /**
+ * Returns the path on the server
+ * to which the browser returns this cookie. The
+ * cookie is visible to all subpaths on the server.
+ *
+ *
+ * @return a <code>String</code> specifying a path that contains
+ * a servlet name, for example, <i>/catalog</i>
+ *
+ * @see #setPath
+ *
+ */
+
+ public String getPath() {
+ return path;
+ }
+
+
+
+
+
+ /**
+ * Indicates to the browser whether the cookie should only be sent
+ * using a secure protocol, such as HTTPS or SSL.
+ *
+ * <p>The default value is <code>false</code>.
+ *
+ * @param flag if <code>true</code>, sends the cookie from the browser
+ * to the server using only when using a secure protocol;
+ * if <code>false</code>, sent on any protocol
+ *
+ * @see #getSecure
+ *
+ */
+
+ public void setSecure(boolean flag) {
+ secure = flag;
+ }
+
+
+
+
+ /**
+ * Returns <code>true</code> if the browser is sending cookies
+ * only over a secure protocol, or <code>false</code> if the
+ * browser can send cookies using any protocol.
+ *
+ * @return <code>true</code> if the browser uses a secure protocol;
+ * otherwise, <code>true</code>
+ *
+ * @see #setSecure
+ *
+ */
+
+ public boolean getSecure() {
+ return secure;
+ }
+
+
+
+
+
+ /**
+ * Returns the name of the cookie. The name cannot be changed after
+ * creation.
+ *
+ * @return a <code>String</code> specifying the cookie's name
+ *
+ */
+
+ public String getName() {
+ return name;
+ }
+
+
+
+
+
+ /**
+ *
+ * Assigns a new value to a cookie after the cookie is created.
+ * If you use a binary value, you may want to use BASE64 encoding.
+ *
+ * <p>With Version 0 cookies, values should not contain white
+ * space, brackets, parentheses, equals signs, commas,
+ * double quotes, slashes, question marks, at signs, colons,
+ * and semicolons. Empty values may not behave the same way
+ * on all browsers.
+ *
+ * @param newValue a <code>String</code> specifying the new value
+ *
+ *
+ * @see #getValue
+ * @see Cookie
+ *
+ */
+
+ public void setValue(String newValue) {
+ value = newValue;
+ }
+
+
+
+
+ /**
+ * Returns the value of the cookie.
+ *
+ * @return a <code>String</code> containing the cookie's
+ * present value
+ *
+ * @see #setValue
+ * @see Cookie
+ *
+ */
+
+ public String getValue() {
+ return value;
+ }
+
+
+
+
+ /**
+ * Returns the version of the protocol this cookie complies
+ * with. Version 1 complies with RFC 2109,
+ * and version 0 complies with the original
+ * cookie specification drafted by Netscape. Cookies provided
+ * by a browser use and identify the browser's cookie version.
+ *
+ *
+ * @return 0 if the cookie complies with the
+ * original Netscape specification; 1
+ * if the cookie complies with RFC 2109
+ *
+ * @see #setVersion
+ *
+ */
+
+ public int getVersion() {
+ return version;
+ }
+
+
+
+
+ /**
+ * Sets the version of the cookie protocol this cookie complies
+ * with. Version 0 complies with the original Netscape cookie
+ * specification. Version 1 complies with RFC 2109.
+ *
+ * <p>Since RFC 2109 is still somewhat new, consider
+ * version 1 as experimental; do not use it yet on production sites.
+ *
+ *
+ * @param v 0 if the cookie should comply with
+ * the original Netscape specification;
+ * 1 if the cookie should comply with RFC 2109
+ *
+ * @see #getVersion
+ *
+ */
+
+ public void setVersion(int v) {
+ version = v;
+ }
+
+ // Note -- disabled for now to allow full Netscape compatibility
+ // from RFC 2068, token special case characters
+ //
+ // private static final String tspecials = "()<>@,;:\\\"/[]?={} \t";
+
+ private static final String tspecials = ",;";
+
+
+
+
+ /*
+ * Tests a string and returns true if the string counts as a
+ * reserved token in the Java language.
+ *
+ * @param value the <code>String</code> to be tested
+ *
+ * @return <code>true</code> if the <code>String</code> is
+ * a reserved token; <code>false</code>
+ * if it is not
+ */
+
+ private boolean isToken(String value) {
+ int len = value.length();
+
+ for (int i = 0; i < len; i++) {
+ char c = value.charAt(i);
+
+ if (c < 0x20 || c >= 0x7f || tspecials.indexOf(c) != -1)
+ return false;
+ }
+ return true;
+ }
+
+
+
+
+
+
+ /**
+ *
+ * Overrides the standard <code>java.lang.Object.clone</code>
+ * method to return a copy of this cookie.
+ *
+ *
+ */
+
+ public Object clone() {
+ try {
+ return super.clone();
+ } catch (CloneNotSupportedException e) {
+ throw new RuntimeException(e.getMessage());
+ }
+ }
+}
+
Propchange: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/Cookie.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServlet.java
URL: http://svn.apache.org/viewcvs/incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServlet.java?rev=355208&view=auto
==============================================================================
--- incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServlet.java (added)
+++ incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServlet.java Thu Dec 8 12:55:55 2005
@@ -0,0 +1,979 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package javax.servlet.http;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Method;
+import java.text.MessageFormat;
+import java.util.Enumeration;
+import java.util.ResourceBundle;
+
+import javax.servlet.GenericServlet;
+import javax.servlet.ServletException;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+
+/**
+ *
+ * Provides an abstract class to be subclassed to create
+ * an HTTP servlet suitable for a Web site. A subclass of
+ * <code>HttpServlet</code> must override at least
+ * one method, usually one of these:
+ *
+ * <ul>
+ * <li> <code>doGet</code>, if the servlet supports HTTP GET requests
+ * <li> <code>doPost</code>, for HTTP POST requests
+ * <li> <code>doPut</code>, for HTTP PUT requests
+ * <li> <code>doDelete</code>, for HTTP DELETE requests
+ * <li> <code>init</code> and <code>destroy</code>,
+ * to manage resources that are held for the life of the servlet
+ * <li> <code>getServletInfo</code>, which the servlet uses to
+ * provide information about itself
+ * </ul>
+ *
+ * <p>There's almost no reason to override the <code>service</code>
+ * method. <code>service</code> handles standard HTTP
+ * requests by dispatching them to the handler methods
+ * for each HTTP request type (the <code>do</code><i>XXX</i>
+ * methods listed above).
+ *
+ * <p>Likewise, there's almost no reason to override the
+ * <code>doOptions</code> and <code>doTrace</code> methods.
+ *
+ * <p>Servlets typically run on multithreaded servers,
+ * so be aware that a servlet must handle concurrent
+ * requests and be careful to synchronize access to shared resources.
+ * Shared resources include in-memory data such as
+ * instance or class variables and external objects
+ * such as files, database connections, and network
+ * connections.
+ * See the
+ * <a href="http://java.sun.com/Series/Tutorial/java/threads/multithreaded.html">
+ * Java Tutorial on Multithreaded Programming</a> for more
+ * information on handling multiple threads in a Java program.
+ *
+ * @author Various
+ * @version $Version$
+ *
+ */
+
+
+
+public abstract class HttpServlet extends GenericServlet
+ implements java.io.Serializable
+{
+ private static final String METHOD_DELETE = "DELETE";
+ private static final String METHOD_HEAD = "HEAD";
+ private static final String METHOD_GET = "GET";
+ private static final String METHOD_OPTIONS = "OPTIONS";
+ private static final String METHOD_POST = "POST";
+ private static final String METHOD_PUT = "PUT";
+ private static final String METHOD_TRACE = "TRACE";
+
+ private static final String HEADER_IFMODSINCE = "If-Modified-Since";
+ private static final String HEADER_LASTMOD = "Last-Modified";
+
+ private static final String LSTRING_FILE =
+ "javax.servlet.http.LocalStrings";
+ private static ResourceBundle lStrings =
+ ResourceBundle.getBundle(LSTRING_FILE);
+
+
+
+
+ /**
+ * Does nothing, because this is an abstract class.
+ *
+ */
+
+ public HttpServlet() { }
+
+
+
+ /**
+ *
+ * Called by the server (via the <code>service</code> method) to
+ * allow a servlet to handle a GET request.
+ *
+ * <p>Overriding this method to support a GET request also
+ * automatically supports an HTTP HEAD request. A HEAD
+ * request is a GET request that returns no body in the
+ * response, only the request header fields.
+ *
+ * <p>When overriding this method, read the request data,
+ * write the response headers, get the response's writer or
+ * output stream object, and finally, write the response data.
+ * It's best to include content type and encoding. When using
+ * a <code>PrintWriter</code> object to return the response,
+ * set the content type before accessing the
+ * <code>PrintWriter</code> object.
+ *
+ * <p>The servlet container must write the headers before
+ * committing the response, because in HTTP the headers must be sent
+ * before the response body.
+ *
+ * <p>Where possible, set the Content-Length header (with the
+ * {@link javax.servlet.ServletResponse#setContentLength} method),
+ * to allow the servlet container to use a persistent connection
+ * to return its response to the client, improving performance.
+ * The content length is automatically set if the entire response fits
+ * inside the response buffer.
+ *
+ * <p>The GET method should be safe, that is, without
+ * any side effects for which users are held responsible.
+ * For example, most form queries have no side effects.
+ * If a client request is intended to change stored data,
+ * the request should use some other HTTP method.
+ *
+ * <p>The GET method should also be idempotent, meaning
+ * that it can be safely repeated. Sometimes making a
+ * method safe also makes it idempotent. For example,
+ * repeating queries is both safe and idempotent, but
+ * buying a product online or modifying data is neither
+ * safe nor idempotent.
+ *
+ * <p>If the request is incorrectly formatted, <code>doGet</code>
+ * returns an HTTP "Bad Request" message.
+ *
+ *
+ * @param req an {@link HttpServletRequest} object that
+ * contains the request the client has made
+ * of the servlet
+ *
+ * @param resp an {@link HttpServletResponse} object that
+ * contains the response the servlet sends
+ * to the client
+ *
+ * @exception IOException if an input or output error is
+ * detected when the servlet handles
+ * the GET request
+ *
+ * @exception ServletException if the request for the GET
+ * could not be handled
+ *
+ *
+ * @see javax.servlet.ServletResponse#setContentType
+ *
+ */
+
+ protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ String protocol = req.getProtocol();
+ String msg = lStrings.getString("http.method_get_not_supported");
+ if (protocol.endsWith("1.1")) {
+ resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+ } else {
+ resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+ }
+ }
+
+
+
+
+
+ /**
+ *
+ * Returns the time the <code>HttpServletRequest</code>
+ * object was last modified,
+ * in milliseconds since midnight January 1, 1970 GMT.
+ * If the time is unknown, this method returns a negative
+ * number (the default).
+ *
+ * <p>Servlets that support HTTP GET requests and can quickly determine
+ * their last modification time should override this method.
+ * This makes browser and proxy caches work more effectively,
+ * reducing the load on server and network resources.
+ *
+ *
+ * @param req the <code>HttpServletRequest</code>
+ * object that is sent to the servlet
+ *
+ * @return a <code>long</code> integer specifying
+ * the time the <code>HttpServletRequest</code>
+ * object was last modified, in milliseconds
+ * since midnight, January 1, 1970 GMT, or
+ * -1 if the time is not known
+ *
+ */
+
+ protected long getLastModified(HttpServletRequest req) {
+ return -1;
+ }
+
+
+
+
+ /**
+ *
+ *
+ * <p>Receives an HTTP HEAD request from the protected
+ * <code>service</code> method and handles the
+ * request.
+ * The client sends a HEAD request when it wants
+ * to see only the headers of a response, such as
+ * Content-Type or Content-Length. The HTTP HEAD
+ * method counts the output bytes in the response
+ * to set the Content-Length header accurately.
+ *
+ * <p>If you override this method, you can avoid computing
+ * the response body and just set the response headers
+ * directly to improve performance. Make sure that the
+ * <code>doHead</code> method you write is both safe
+ * and idempotent (that is, protects itself from being
+ * called multiple times for one HTTP HEAD request).
+ *
+ * <p>If the HTTP HEAD request is incorrectly formatted,
+ * <code>doHead</code> returns an HTTP "Bad Request"
+ * message.
+ *
+ *
+ * @param req the request object that is passed
+ * to the servlet
+ *
+ * @param resp the response object that the servlet
+ * uses to return the headers to the clien
+ *
+ * @exception IOException if an input or output error occurs
+ *
+ * @exception ServletException if the request for the HEAD
+ * could not be handled
+ */
+
+ protected void doHead(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ NoBodyResponse response = new NoBodyResponse(resp);
+
+ doGet(req, response);
+ response.setContentLength();
+ }
+
+
+
+
+
+ /**
+ *
+ * Called by the server (via the <code>service</code> method)
+ * to allow a servlet to handle a POST request.
+ *
+ * The HTTP POST method allows the client to send
+ * data of unlimited length to the Web server a single time
+ * and is useful when posting information such as
+ * credit card numbers.
+ *
+ * <p>When overriding this method, read the request data,
+ * write the response headers, get the response's writer or output
+ * stream object, and finally, write the response data. It's best
+ * to include content type and encoding. When using a
+ * <code>PrintWriter</code> object to return the response, set the
+ * content type before accessing the <code>PrintWriter</code> object.
+ *
+ * <p>The servlet container must write the headers before committing the
+ * response, because in HTTP the headers must be sent before the
+ * response body.
+ *
+ * <p>Where possible, set the Content-Length header (with the
+ * {@link javax.servlet.ServletResponse#setContentLength} method),
+ * to allow the servlet container to use a persistent connection
+ * to return its response to the client, improving performance.
+ * The content length is automatically set if the entire response fits
+ * inside the response buffer.
+ *
+ * <p>When using HTTP 1.1 chunked encoding (which means that the response
+ * has a Transfer-Encoding header), do not set the Content-Length header.
+ *
+ * <p>This method does not need to be either safe or idempotent.
+ * Operations requested through POST can have side effects for
+ * which the user can be held accountable, for example,
+ * updating stored data or buying items online.
+ *
+ * <p>If the HTTP POST request is incorrectly formatted,
+ * <code>doPost</code> returns an HTTP "Bad Request" message.
+ *
+ *
+ * @param req an {@link HttpServletRequest} object that
+ * contains the request the client has made
+ * of the servlet
+ *
+ * @param resp an {@link HttpServletResponse} object that
+ * contains the response the servlet sends
+ * to the client
+ *
+ * @exception IOException if an input or output error is
+ * detected when the servlet handles
+ * the request
+ *
+ * @exception ServletException if the request for the POST
+ * could not be handled
+ *
+ *
+ * @see javax.servlet.ServletOutputStream
+ * @see javax.servlet.ServletResponse#setContentType
+ *
+ *
+ */
+
+ protected void doPost(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ String protocol = req.getProtocol();
+ String msg = lStrings.getString("http.method_post_not_supported");
+ if (protocol.endsWith("1.1")) {
+ resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+ } else {
+ resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+ }
+ }
+
+
+
+
+ /**
+ * Called by the server (via the <code>service</code> method)
+ * to allow a servlet to handle a PUT request.
+ *
+ * The PUT operation allows a client to
+ * place a file on the server and is similar to
+ * sending a file by FTP.
+ *
+ * <p>When overriding this method, leave intact
+ * any content headers sent with the request (including
+ * Content-Length, Content-Type, Content-Transfer-Encoding,
+ * Content-Encoding, Content-Base, Content-Language, Content-Location,
+ * Content-MD5, and Content-Range). If your method cannot
+ * handle a content header, it must issue an error message
+ * (HTTP 501 - Not Implemented) and discard the request.
+ * For more information on HTTP 1.1, see RFC 2068
+ * <a href="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc2068.txt"></a>.
+ *
+ * <p>This method does not need to be either safe or idempotent.
+ * Operations that <code>doPut</code> performs can have side
+ * effects for which the user can be held accountable. When using
+ * this method, it may be useful to save a copy of the
+ * affected URL in temporary storage.
+ *
+ * <p>If the HTTP PUT request is incorrectly formatted,
+ * <code>doPut</code> returns an HTTP "Bad Request" message.
+ *
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ * @param resp the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * PUT request
+ *
+ * @exception ServletException if the request for the PUT
+ * cannot be handled
+ *
+ */
+
+ protected void doPut(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ String protocol = req.getProtocol();
+ String msg = lStrings.getString("http.method_put_not_supported");
+ if (protocol.endsWith("1.1")) {
+ resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+ } else {
+ resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+ }
+ }
+
+
+
+
+ /**
+ *
+ * Called by the server (via the <code>service</code> method)
+ * to allow a servlet to handle a DELETE request.
+ *
+ * The DELETE operation allows a client to remove a document
+ * or Web page from the server.
+ *
+ * <p>This method does not need to be either safe
+ * or idempotent. Operations requested through
+ * DELETE can have side effects for which users
+ * can be held accountable. When using
+ * this method, it may be useful to save a copy of the
+ * affected URL in temporary storage.
+ *
+ * <p>If the HTTP DELETE request is incorrectly formatted,
+ * <code>doDelete</code> returns an HTTP "Bad Request"
+ * message.
+ *
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ *
+ * @param resp the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * DELETE request
+ *
+ * @exception ServletException if the request for the
+ * DELETE cannot be handled
+ *
+ */
+
+ protected void doDelete(HttpServletRequest req,
+ HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ String protocol = req.getProtocol();
+ String msg = lStrings.getString("http.method_delete_not_supported");
+ if (protocol.endsWith("1.1")) {
+ resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
+ } else {
+ resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
+ }
+ }
+
+
+
+
+
+ private Method[] getAllDeclaredMethods(Class c) {
+ if (c.getName().equals("javax.servlet.http.HttpServlet"))
+ return null;
+
+ int j=0;
+ Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
+ Method[] thisMethods = c.getDeclaredMethods();
+
+ if (parentMethods!=null) {
+ Method[] allMethods =
+ new Method[parentMethods.length + thisMethods.length];
+ for (int i=0; i<parentMethods.length; i++) {
+ allMethods[i]=parentMethods[i];
+ j=i;
+ }
+ j++;
+ for (int i=j; i<thisMethods.length+j; i++) {
+ allMethods[i] = thisMethods[i-j];
+ }
+ return allMethods;
+ }
+ return thisMethods;
+ }
+
+
+
+
+
+
+ /**
+ * Called by the server (via the <code>service</code> method)
+ * to allow a servlet to handle a OPTIONS request.
+ *
+ * The OPTIONS request determines which HTTP methods
+ * the server supports and
+ * returns an appropriate header. For example, if a servlet
+ * overrides <code>doGet</code>, this method returns the
+ * following header:
+ *
+ * <p><code>Allow: GET, HEAD, TRACE, OPTIONS</code>
+ *
+ * <p>There's no need to override this method unless the
+ * servlet implements new HTTP methods, beyond those
+ * implemented by HTTP 1.1.
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ *
+ * @param resp the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * OPTIONS request
+ *
+ * @exception ServletException if the request for the
+ * OPTIONS cannot be handled
+ *
+ */
+
+ protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ Method[] methods = getAllDeclaredMethods(this.getClass());
+
+ boolean ALLOW_GET = false;
+ boolean ALLOW_HEAD = false;
+ boolean ALLOW_POST = false;
+ boolean ALLOW_PUT = false;
+ boolean ALLOW_DELETE = false;
+ boolean ALLOW_TRACE = true;
+ boolean ALLOW_OPTIONS = true;
+
+ for (int i=0; i<methods.length; i++) {
+ Method m = methods[i];
+
+ if (m.getName().equals("doGet")) {
+ ALLOW_GET = true;
+ ALLOW_HEAD = true;
+ }
+ if (m.getName().equals("doPost"))
+ ALLOW_POST = true;
+ if (m.getName().equals("doPut"))
+ ALLOW_PUT = true;
+ if (m.getName().equals("doDelete"))
+ ALLOW_DELETE = true;
+
+ }
+
+ String allow = null;
+ if (ALLOW_GET)
+ if (allow==null) allow=METHOD_GET;
+ if (ALLOW_HEAD)
+ if (allow==null) allow=METHOD_HEAD;
+ else allow += ", " + METHOD_HEAD;
+ if (ALLOW_POST)
+ if (allow==null) allow=METHOD_POST;
+ else allow += ", " + METHOD_POST;
+ if (ALLOW_PUT)
+ if (allow==null) allow=METHOD_PUT;
+ else allow += ", " + METHOD_PUT;
+ if (ALLOW_DELETE)
+ if (allow==null) allow=METHOD_DELETE;
+ else allow += ", " + METHOD_DELETE;
+ if (ALLOW_TRACE)
+ if (allow==null) allow=METHOD_TRACE;
+ else allow += ", " + METHOD_TRACE;
+ if (ALLOW_OPTIONS)
+ if (allow==null) allow=METHOD_OPTIONS;
+ else allow += ", " + METHOD_OPTIONS;
+
+ resp.setHeader("Allow", allow);
+ }
+
+
+
+
+ /**
+ * Called by the server (via the <code>service</code> method)
+ * to allow a servlet to handle a TRACE request.
+ *
+ * A TRACE returns the headers sent with the TRACE
+ * request to the client, so that they can be used in
+ * debugging. There's no need to override this method.
+ *
+ *
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ *
+ * @param resp the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * TRACE request
+ *
+ * @exception ServletException if the request for the
+ * TRACE cannot be handled
+ *
+ */
+
+ protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+
+ int responseLength;
+
+ String CRLF = "\r\n";
+ String responseString = "TRACE "+ req.getRequestURI()+
+ " " + req.getProtocol();
+
+ Enumeration reqHeaderEnum = req.getHeaderNames();
+
+ while( reqHeaderEnum.hasMoreElements() ) {
+ String headerName = (String)reqHeaderEnum.nextElement();
+ responseString += CRLF + headerName + ": " +
+ req.getHeader(headerName);
+ }
+
+ responseString += CRLF;
+
+ responseLength = responseString.length();
+
+ resp.setContentType("message/http");
+ resp.setContentLength(responseLength);
+ ServletOutputStream out = resp.getOutputStream();
+ out.print(responseString);
+ out.close();
+ return;
+ }
+
+
+
+
+
+ /**
+ *
+ * Receives standard HTTP requests from the public
+ * <code>service</code> method and dispatches
+ * them to the <code>do</code><i>XXX</i> methods defined in
+ * this class. This method is an HTTP-specific version of the
+ * {@link javax.servlet.Servlet#service} method. There's no
+ * need to override this method.
+ *
+ *
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ *
+ * @param resp the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * TRACE request
+ *
+ * @exception ServletException if the request for the
+ * TRACE cannot be handled
+ *
+ * @see javax.servlet.Servlet#service
+ *
+ */
+
+ protected void service(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException
+ {
+ String method = req.getMethod();
+
+ if (method.equals(METHOD_GET)) {
+ long lastModified = getLastModified(req);
+ if (lastModified == -1) {
+ // servlet doesn't support if-modified-since, no reason
+ // to go through further expensive logic
+ doGet(req, resp);
+ } else {
+ long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
+ if (ifModifiedSince < (lastModified / 1000 * 1000)) {
+ // If the servlet mod time is later, call doGet()
+ // Round down to the nearest second for a proper compare
+ // A ifModifiedSince of -1 will always be less
+ maybeSetLastModified(resp, lastModified);
+ doGet(req, resp);
+ } else {
+ resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
+ }
+ }
+
+ } else if (method.equals(METHOD_HEAD)) {
+ long lastModified = getLastModified(req);
+ maybeSetLastModified(resp, lastModified);
+ doHead(req, resp);
+
+ } else if (method.equals(METHOD_POST)) {
+ doPost(req, resp);
+
+ } else if (method.equals(METHOD_PUT)) {
+ doPut(req, resp);
+
+ } else if (method.equals(METHOD_DELETE)) {
+ doDelete(req, resp);
+
+ } else if (method.equals(METHOD_OPTIONS)) {
+ doOptions(req,resp);
+
+ } else if (method.equals(METHOD_TRACE)) {
+ doTrace(req,resp);
+
+ } else {
+ //
+ // Note that this means NO servlet supports whatever
+ // method was requested, anywhere on this server.
+ //
+
+ String errMsg = lStrings.getString("http.method_not_implemented");
+ Object[] errArgs = new Object[1];
+ errArgs[0] = method;
+ errMsg = MessageFormat.format(errMsg, errArgs);
+
+ resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
+ }
+ }
+
+
+
+
+
+ /*
+ * Sets the Last-Modified entity header field, if it has not
+ * already been set and if the value is meaningful. Called before
+ * doGet, to ensure that headers are set before response data is
+ * written. A subclass might have set this header already, so we
+ * check.
+ */
+
+ private void maybeSetLastModified(HttpServletResponse resp,
+ long lastModified) {
+ if (resp.containsHeader(HEADER_LASTMOD))
+ return;
+ if (lastModified >= 0)
+ resp.setDateHeader(HEADER_LASTMOD, lastModified);
+ }
+
+
+
+
+ /**
+ *
+ * Dispatches client requests to the protected
+ * <code>service</code> method. There's no need to
+ * override this method.
+ *
+ *
+ * @param req the {@link HttpServletRequest} object that
+ * contains the request the client made of
+ * the servlet
+ *
+ *
+ * @param res the {@link HttpServletResponse} object that
+ * contains the response the servlet returns
+ * to the client
+ *
+ *
+ * @exception IOException if an input or output error occurs
+ * while the servlet is handling the
+ * TRACE request
+ *
+ * @exception ServletException if the request for the
+ * TRACE cannot be handled
+ *
+ *
+ * @see javax.servlet.Servlet#service
+ *
+ */
+
+ public void service(ServletRequest req, ServletResponse res)
+ throws ServletException, IOException
+ {
+ HttpServletRequest request;
+ HttpServletResponse response;
+
+ try {
+ request = (HttpServletRequest) req;
+ response = (HttpServletResponse) res;
+ } catch (ClassCastException e) {
+ throw new ServletException("non-HTTP request or response");
+ }
+ service(request, response);
+ }
+}
+
+
+
+
+/*
+ * A response that includes no body, for use in (dumb) "HEAD" support.
+ * This just swallows that body, counting the bytes in order to set
+ * the content length appropriately. All other methods delegate directly
+ * to the HTTP Servlet Response object used to construct this one.
+ */
+// file private
+class NoBodyResponse implements HttpServletResponse {
+ private HttpServletResponse resp;
+ private NoBodyOutputStream noBody;
+ private PrintWriter writer;
+ private boolean didSetContentLength;
+
+ // file private
+ NoBodyResponse(HttpServletResponse r) {
+ resp = r;
+ noBody = new NoBodyOutputStream();
+ }
+
+ // file private
+ void setContentLength() {
+ if (!didSetContentLength)
+ resp.setContentLength(noBody.getContentLength());
+ }
+
+
+ // SERVLET RESPONSE interface methods
+
+ public void setContentLength(int len) {
+ resp.setContentLength(len);
+ didSetContentLength = true;
+ }
+
+ public void setContentType(String type)
+ { resp.setContentType(type); }
+
+ public ServletOutputStream getOutputStream() throws IOException
+ { return noBody; }
+
+ public String getCharacterEncoding()
+ { return resp.getCharacterEncoding(); }
+
+ public PrintWriter getWriter() throws UnsupportedEncodingException
+ {
+ if (writer == null) {
+ OutputStreamWriter w;
+
+ w = new OutputStreamWriter(noBody, getCharacterEncoding());
+ writer = new PrintWriter(w);
+ }
+ return writer;
+ }
+
+ public void addCookie(Cookie cookie)
+ { resp.addCookie(cookie); }
+
+ public boolean containsHeader(String name)
+ { return resp.containsHeader(name); }
+
+ /** @deprecated */
+ public void setStatus(int sc, String sm)
+ { resp.setStatus(sc, sm); }
+
+ public void setStatus(int sc)
+ { resp.setStatus(sc); }
+
+ public void setHeader(String name, String value)
+ { resp.setHeader(name, value); }
+
+ public void setIntHeader(String name, int value)
+ { resp.setIntHeader(name, value); }
+
+ public void setDateHeader(String name, long date)
+ { resp.setDateHeader(name, date); }
+
+ public void sendError(int sc, String msg) throws IOException
+ { resp.sendError(sc, msg); }
+
+ public void sendError(int sc) throws IOException
+ { resp.sendError(sc); }
+
+ public void sendRedirect(String location) throws IOException
+ { resp.sendRedirect(location); }
+
+ public String encodeURL(String url)
+ { return resp.encodeURL(url); }
+
+ public String encodeRedirectURL(String url)
+ { return resp.encodeRedirectURL(url); }
+
+ /**
+ * @deprecated As of Version 2.1, replaced by
+ * {@link HttpServletResponse#encodeURL}.
+ *
+ */
+
+
+ public String encodeUrl(String url)
+ { return this.encodeURL(url); }
+
+
+
+
+
+
+
+
+ /**
+ * @deprecated As of Version 2.1, replaced by
+ * {@link HttpServletResponse#encodeRedirectURL}.
+ *
+ */
+
+
+ public String encodeRedirectUrl(String url)
+ { return this.encodeRedirectURL(url); }
+
+}
+
+
+
+
+
+
+
+/*
+ * Servlet output stream that gobbles up all its data.
+ */
+
+// file private
+class NoBodyOutputStream extends ServletOutputStream {
+
+ private static final String LSTRING_FILE =
+ "javax.servlet.http.LocalStrings";
+ private static ResourceBundle lStrings =
+ ResourceBundle.getBundle(LSTRING_FILE);
+
+ private int contentLength = 0;
+
+ // file private
+ NoBodyOutputStream() {}
+
+ // file private
+ int getContentLength() {
+ return contentLength;
+ }
+
+ public void write(int b) {
+ contentLength++;
+ }
+
+ public void write(byte buf[], int offset, int len)
+ throws IOException
+ {
+ if (len >= 0) {
+ contentLength += len;
+ } else {
+ // XXX
+ // isn't this really an IllegalArgumentException?
+
+ String msg = lStrings.getString("err.io.negativelength");
+ throw new IOException(msg);
+ }
+ }
+}
Propchange: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServlet.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletRequest.java
URL: http://svn.apache.org/viewcvs/incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletRequest.java?rev=355208&view=auto
==============================================================================
--- incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletRequest.java (added)
+++ incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletRequest.java Thu Dec 8 12:55:55 2005
@@ -0,0 +1,514 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package javax.servlet.http;
+
+import javax.servlet.ServletRequest;
+import java.util.Enumeration;
+
+/**
+ *
+ * Extends the {@link javax.servlet.ServletRequest} interface
+ * to provide request information for HTTP servlets.
+ *
+ * <p>The servlet container creates an <code>HttpServletRequest</code>
+ * object and passes it as an argument to the servlet's service
+ * methods (<code>doGet</code>, <code>doPost</code>, etc).
+ *
+ *
+ * @author Various
+ * @version $Version$
+ *
+ *
+ */
+
+public interface HttpServletRequest extends ServletRequest {
+
+ /**
+ * Returns the name of the authentication scheme used to protect
+ * the servlet, for example, "BASIC" or "SSL".
+ * If the servlet is not authenticated <code>null</code> is returned.
+ *
+ * <p>Same as the value of the CGI variable AUTH_TYPE.
+ *
+ *
+ * @return a <code>String</code> specifying the name of
+ * the authentication scheme, or
+ * <code>null</code> if the request was not
+ * authenticated
+ *
+ */
+
+ public String getAuthType();
+
+
+
+
+ /**
+ *
+ * Returns an array containing all of the <code>Cookie</code>
+ * objects the client sent with this request.
+ * This method returns <code>null</code> if no cookies were sent.
+ *
+ * @return an array of all the <code>Cookies</code>
+ * included with this request, or <code>null</code>
+ * if the request has no cookies
+ *
+ *
+ */
+
+ public Cookie[] getCookies();
+
+
+
+
+ /**
+ *
+ * Returns the value of the specified request header
+ * as a <code>long</code> value that represents a
+ * <code>Date</code> object. Use this method with
+ * headers that contain dates, such as
+ * <code>If-Modified-Since</code>.
+ *
+ * <p>The date is returned as
+ * the number of milliseconds since January 1, 1970 GMT.
+ * The header name is case insensitive.
+ *
+ * <p>If the request did not have a header of the
+ * specified name, this method returns -1. If the header
+ * can't be converted to a date, the method throws
+ * an <code>IllegalArgumentException</code>.
+ *
+ * @param name a <code>String</code> specifying the
+ * name of the header
+ *
+ * @return a <code>long</code> value
+ * representing the date specified
+ * in the header expressed as
+ * the number of milliseconds
+ * since January 1, 1970 GMT,
+ * or -1 if the named header
+ * was not included with the
+ * reqest
+ *
+ * @exception IllegalArgumentException If the header value
+ * can't be converted
+ * to a date
+ *
+ */
+
+ public long getDateHeader(String name);
+
+
+
+
+ /**
+ *
+ * Returns the value of the specified request header
+ * as a <code>String</code>. If the request did not include a header
+ * of the specified name, this method returns <code>null</code>.
+ * The header name is case insensitive. You can use
+ * this method with any request header.
+ *
+ * @param name a <code>String</code> specifying the
+ * header name
+ *
+ * @return a <code>String</code> containing the
+ * value of the requested
+ * header, or <code>null</code>
+ * if the request does not
+ * have a header of that name
+ *
+ */
+
+ public String getHeader(String name);
+
+
+
+
+ /**
+ *
+ * Returns an enumeration of all the header names
+ * this request contains. If the request has no
+ * headers, this method returns an empty enumeration.
+ *
+ * <p>Some servlet containers do not allow do not allow
+ * servlets to access headers using this method, in
+ * which case this method returns <code>null</code>
+ *
+ * @return an enumeration of all the
+ * header names sent with this
+ * request; if the request has
+ * no headers, an empty enumeration;
+ * if the servlet container does not
+ * allow servlets to use this method,
+ * <code>null</code>
+ *
+ *
+ */
+
+ public Enumeration getHeaderNames();
+
+
+
+
+ /**
+ *
+ * Returns the value of the specified request header
+ * as an <code>int</code>. If the request does not have a header
+ * of the specified name, this method returns -1. If the
+ * header cannot be converted to an integer, this method
+ * throws a <code>NumberFormatException</code>.
+ *
+ * <p>The header name is case insensitive.
+ *
+ * @param name a <code>String</code> specifying the name
+ * of a request header
+ *
+ * @return an integer expressing the value
+ * of the request header or -1
+ * if the request doesn't have a
+ * header of this name
+ *
+ * @exception NumberFormatException If the header value
+ * can't be converted
+ * to an <code>int</code>
+ */
+
+ public int getIntHeader(String name);
+
+
+
+
+ /**
+ *
+ * Returns the name of the HTTP method with which this
+ * request was made, for example, GET, POST, or PUT.
+ * Same as the value of the CGI variable REQUEST_METHOD.
+ *
+ * @return a <code>String</code>
+ * specifying the name
+ * of the method with which
+ * this request was made
+ *
+ */
+
+ public String getMethod();
+
+
+
+
+ /**
+ *
+ * Returns any extra path information associated with
+ * the URL the client sent when it made this request.
+ * The extra path information follows the servlet path
+ * but precedes the query string.
+ * This method returns <code>null</code> if there
+ * was no extra path information.
+ *
+ * <p>Same as the value of the CGI variable PATH_INFO.
+ *
+ *
+ * @return a <code>String</code>, decoded by the
+ * web container, specifying
+ * extra path information that comes
+ * after the servlet path but before
+ * the query string in the request URL;
+ * or <code>null</code> if the URL does not have
+ * any extra path information
+ *
+ */
+
+ public String getPathInfo();
+
+
+
+
+ /**
+ *
+ * Returns any extra path information after the servlet name
+ * but before the query string, and translates it to a real
+ * path. Same as the value of the CGI variable PATH_TRANSLATED.
+ *
+ * <p>If the URL does not have any extra path information,
+ * this method returns <code>null</code>.
+ *
+ * The web container does not decode this string.
+ *
+ *
+ * @return a <code>String</code> specifying the
+ * real path, or <code>null</code> if
+ * the URL does not have any extra path
+ * information
+ *
+ *
+ */
+
+ public String getPathTranslated();
+
+
+
+
+ /**
+ *
+ * Returns the query string that is contained in the request
+ * URL after the path. This method returns <code>null</code>
+ * if the URL does not have a query string. Same as the value
+ * of the CGI variable QUERY_STRING.
+ *
+ * @return a <code>String</code> containing the query
+ * string or <code>null</code> if the URL
+ * contains no query string. The value is not
+ * decoded by the container.
+ *
+ */
+
+ public String getQueryString();
+
+
+
+
+ /**
+ *
+ * Returns the login of the user making this request, if the
+ * user has been authenticated, or <code>null</code> if the user
+ * has not been authenticated.
+ * Whether the user name is sent with each subsequent request
+ * depends on the browser and type of authentication. Same as the
+ * value of the CGI variable REMOTE_USER.
+ *
+ * @return a <code>String</code> specifying the login
+ * of the user making this request, or <code>null</code
+ * if the user login is not known
+ *
+ */
+
+ public String getRemoteUser();
+
+
+
+
+ /**
+ *
+ * Returns the session ID specified by the client. This may
+ * not be the same as the ID of the actual session in use.
+ * For example, if the request specified an old (expired)
+ * session ID and the server has started a new session, this
+ * method gets a new session with a new ID. If the request
+ * did not specify a session ID, this method returns
+ * <code>null</code>.
+ *
+ *
+ * @return a <code>String</code> specifying the session
+ * ID, or <code>null</code> if the request did
+ * not specify a session ID
+ *
+ * @see #isRequestedSessionIdValid
+ *
+ */
+
+ public String getRequestedSessionId();
+
+
+
+
+ /**
+ *
+ * Returns the part of this request's URL from the protocol
+ * name up to the query string in the first line of the HTTP request.
+ * The web container does not decode this String.
+ * For example:
+ *
+ *
+
+ * <table>
+ * <tr align=left><th>First line of HTTP request </th>
+ * <th> Returned Value</th>
+ * <tr><td>POST /some/path.html HTTP/1.1<td><td>/some/path.html
+ * <tr><td>GET http://foo.bar/a.html HTTP/1.0
+ * <td><td>/a.html
+ * <tr><td>HEAD /xyz?a=b HTTP/1.1<td><td>/xyz
+ * </table>
+ *
+ * <p>To reconstruct an URL with a scheme and host, use
+ * {@link HttpUtils#getRequestURL}.
+ *
+ * @return a <code>String</code> containing
+ * the part of the URL from the
+ * protocol name up to the query string
+ *
+ * @see HttpUtils#getRequestURL
+ *
+ */
+
+ public String getRequestURI();
+
+ /**
+ *
+ * Returns the part of this request's URL that calls
+ * the servlet. This includes either the servlet name or
+ * a path to the servlet, but does not include any extra
+ * path information or a query string. Same as the value
+ * of the CGI variable SCRIPT_NAME.
+ *
+ *
+ * @return a <code>String</code> containing
+ * the name or path of the servlet being
+ * called, as specified in the request URL,
+ * decoded.
+ *
+ *
+ */
+
+ public String getServletPath();
+
+
+
+
+ /**
+ *
+ * Returns the current <code>HttpSession</code>
+ * associated with this request or, if if there is no
+ * current session and <code>create</code> is true, returns
+ * a new session.
+ *
+ * <p>If <code>create</code> is <code>false</code>
+ * and the request has no valid <code>HttpSession</code>,
+ * this method returns <code>null</code>.
+ *
+ * <p>To make sure the session is properly maintained,
+ * you must call this method before
+ * the response is committed. If the container is using cookies
+ * to maintain session integrity and is asked to create a new session
+ * when the response is committed, an IllegalStateException is thrown.
+ *
+ *
+ *
+ *
+ * @param create <code>true</code> to create
+ * a new session for this request if necessary;
+ * <code>false</code> to return <code>null</code>
+ * if there's no current session
+ *
+ *
+ * @return the <code>HttpSession</code> associated
+ * with this request or <code>null</code> if
+ * <code>create</code> is <code>false</code>
+ * and the request has no valid session
+ *
+ * @see #getSession()
+ *
+ *
+ */
+
+ public HttpSession getSession(boolean create);
+
+
+
+
+
+ /**
+ *
+ * Returns the current session associated with this request,
+ * or if the request does not have a session, creates one.
+ *
+ * @return the <code>HttpSession</code> associated
+ * with this request
+ *
+ * @see #getSession(boolean)
+ *
+ */
+
+ public HttpSession getSession();
+
+
+
+
+
+
+ /**
+ *
+ * Checks whether the requested session ID is still valid.
+ *
+ * @return <code>true</code> if this
+ * request has an id for a valid session
+ * in the current session context;
+ * <code>false</code> otherwise
+ *
+ * @see #getRequestedSessionId
+ * @see #getSession(boolean)
+ * @see HttpSessionContext
+ *
+ */
+
+ public boolean isRequestedSessionIdValid();
+
+
+
+
+ /**
+ *
+ * Checks whether the requested session ID came in as a cookie.
+ *
+ * @return <code>true</code> if the session ID
+ * came in as a
+ * cookie; otherwise, <code>false</code>
+ *
+ *
+ * @see #getSession(boolean)
+ *
+ */
+
+ public boolean isRequestedSessionIdFromCookie();
+
+
+
+
+ /**
+ *
+ * Checks whether the requested session ID came in as part of the
+ * request URL.
+ *
+ * @return <code>true</code> if the session ID
+ * came in as part of a URL; otherwise,
+ * <code>false</code>
+ *
+ *
+ * @see #getSession(boolean)
+ *
+ */
+
+ public boolean isRequestedSessionIdFromURL();
+
+
+
+
+
+ /**
+ *
+ * @deprecated As of Version 2.1 of the Java Servlet
+ * API, use {@link #isRequestedSessionIdFromURL}
+ * instead.
+ *
+ */
+
+ public boolean isRequestedSessionIdFromUrl();
+
+
+
+}
Propchange: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletRequest.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletResponse.java
URL: http://svn.apache.org/viewcvs/incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletResponse.java?rev=355208&view=auto
==============================================================================
--- incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletResponse.java (added)
+++ incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletResponse.java Thu Dec 8 12:55:55 2005
@@ -0,0 +1,547 @@
+/*
+ * Copyright 1999,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package javax.servlet.http;
+
+import javax.servlet.ServletResponse;
+import java.io.IOException;
+
+/**
+ *
+ * Extends the {@link ServletResponse} interface to provide HTTP-specific
+ * functionality in sending a response. For example, it has methods
+ * to access HTTP headers and cookies.
+ *
+ * <p>The servlet container creates an <code>HttpServletRequest</code> object
+ * and passes it as an argument to the servlet's service methods
+ * (<code>doGet</code>, <code>doPost</code>, etc).
+ *
+ *
+ * @author Various
+ * @version $Version$
+ *
+ * @see javax.servlet.ServletResponse
+ *
+ */
+
+
+
+public interface HttpServletResponse extends ServletResponse {
+
+ /**
+ * Adds the specified cookie to the response. This method can be called
+ * multiple times to set more than one cookie.
+ *
+ * @param cookie the Cookie to return to the client
+ *
+ */
+
+ public void addCookie(Cookie cookie);
+
+ /**
+ * Returns a boolean indicating whether the named response header
+ * has already been set.
+ *
+ * @param name the header name
+ * @return <code>true</code> if the named response header
+ * has already been set;
+ * <code>false</code> otherwise
+ */
+
+ public boolean containsHeader(String name);
+
+ /**
+ * Encodes the specified URL by including the session ID in it,
+ * or, if encoding is not needed, returns the URL unchanged.
+ * The implementation of this method includes the logic to
+ * determine whether the session ID needs to be encoded in the URL.
+ * For example, if the browser supports cookies, or session
+ * tracking is turned off, URL encoding is unnecessary.
+ *
+ * <p>For robust session tracking, all URLs emitted by a servlet
+ * should be run through this
+ * method. Otherwise, URL rewriting cannot be used with browsers
+ * which do not support cookies.
+ *
+ * @param url the url to be encoded.
+ * @return the encoded URL if encoding is needed;
+ * the unchanged URL otherwise.
+ */
+
+ public String encodeURL(String url);
+
+ /**
+ * Encodes the specified URL for use in the
+ * <code>sendRedirect</code> method or, if encoding is not needed,
+ * returns the URL unchanged. The implementation of this method
+ * includes the logic to determine whether the session ID
+ * needs to be encoded in the URL. Because the rules for making
+ * this determination can differ from those used to decide whether to
+ * encode a normal link, this method is seperate from the
+ * <code>encodeURL</code> method.
+ *
+ * <p>All URLs sent to the <code>HttpServletResponse.sendRedirect</code>
+ * method should be run through this method. Otherwise, URL
+ * rewriting cannot be used with browsers which do not support
+ * cookies.
+ *
+ * @param url the url to be encoded.
+ * @return the encoded URL if encoding is needed;
+ * the unchanged URL otherwise.
+ *
+ * @see #sendRedirect
+ * @see #encodeUrl
+ */
+
+ public String encodeRedirectURL(String url);
+
+ /**
+ * @deprecated As of version 2.1, use encodeURL(String url) instead
+ *
+ * @param url the url to be encoded.
+ * @return the encoded URL if encoding is needed;
+ * the unchanged URL otherwise.
+ */
+
+ public String encodeUrl(String url);
+
+ /**
+ * @deprecated As of version 2.1, use
+ * encodeRedirectURL(String url) instead
+ *
+ * @param url the url to be encoded.
+ * @return the encoded URL if encoding is needed;
+ * the unchanged URL otherwise.
+ */
+
+ public String encodeRedirectUrl(String url);
+
+ /**
+ * Sends an error response to the client using the specified
+ * status clearing the buffer. The server defaults to creating the
+ * response to look like an HTML-formatted server error page containing the specified message, setting the content type
+ * to "text/html", leaving cookies and other headers unmodified.
+ *
+ * If an error-page declaration has been made for the web application
+ * corresponding to the status code passed in, it will be served back in
+ * preference to the suggested msg parameter.
+ *
+ * <p>If the response has already been committed, this method throws
+ * an IllegalStateException.
+ * After using this method, the response should be considered
+ * to be committed and should not be written to.
+ *
+ * @param sc the error status code
+ * @param msg the descriptive message
+ * @exception IOException If an input or output exception occurs
+ * @exception IllegalStateException If the response was committed
+ */
+
+ public void sendError(int sc, String msg) throws IOException;
+
+ /**
+ * Sends an error response to the client using the specified status
+ * code and clearing the buffer.
+ * <p>If the response has already been committed, this method throws
+ * an IllegalStateException.
+ * After using this method, the response should be considered
+ * to be committed and should not be written to.
+ *
+ * @param sc the error status code
+ * @exception IOException If an input or output exception occurs
+ * @exception IllegalStateException If the response was committed
+ * before this method call
+ */
+
+ public void sendError(int sc) throws IOException;
+
+ /**
+ * Sends a temporary redirect response to the client using the
+ * specified redirect location URL. This method can accept relative URLs;
+ * the servlet container must convert the relative URL to an absolute URL
+ * before sending the response to the client. If the location is relative
+ * without a leading '/' the container interprets it as relative to
+ * the current request URI. If the location is relative with a leading
+ * '/' the container interprets it as relative to the servlet container root.
+ *
+ * <p>If the response has already been committed, this method throws
+ * an IllegalStateException.
+ * After using this method, the response should be considered
+ * to be committed and should not be written to.
+ *
+ * @param location the redirect location URL
+ * @exception IOException If an input or output exception occurs
+ * @exception IllegalStateException If the response was committed
+ */
+
+ public void sendRedirect(String location) throws IOException;
+
+ /**
+ *
+ * Sets a response header with the given name and
+ * date-value. The date is specified in terms of
+ * milliseconds since the epoch. If the header had already
+ * been set, the new value overwrites the previous one. The
+ * <code>containsHeader</code> method can be used to test for the
+ * presence of a header before setting its value.
+ *
+ * @param name the name of the header to set
+ * @param date the assigned date value
+ *
+ * @see #containsHeader
+ */
+
+ public void setDateHeader(String name, long date);
+
+ /**
+ *
+ * Sets a response header with the given name and value.
+ * If the header had already been set, the new value overwrites the
+ * previous one. The <code>containsHeader</code> method can be
+ * used to test for the presence of a header before setting its
+ * value.
+ *
+ * @param name the name of the header
+ * @param value the header value
+ *
+ * @see #containsHeader
+ */
+
+ public void setHeader(String name, String value);
+
+ /**
+ * Sets a response header with the given name and
+ * integer value. If the header had already been set, the new value
+ * overwrites the previous one. The <code>containsHeader</code>
+ * method can be used to test for the presence of a header before
+ * setting its value.
+ *
+ * @param name the name of the header
+ * @param value the assigned integer value
+ *
+ * @see #containsHeader
+ */
+
+ public void setIntHeader(String name, int value);
+
+ /**
+ * Sets the status code for this response. This method is used to
+ * set the return status code when there is no error (for example,
+ * for the status codes SC_OK or SC_MOVED_TEMPORARILY). If there
+ * is an error, the <code>sendError</code> method should be used
+ * instead.
+ * <p> The container clears the buffer and sets the Location header, preserving
+ * cookies and other headers.
+ *
+ * @param sc the status code
+ *
+ * @see #sendError(int, String)
+ */
+
+ public void setStatus(int sc);
+
+ /**
+ * @deprecated As of version 2.1, due to ambiguous meaning of the
+ * message parameter. To set a status code
+ * use <code>setStatus(int)</code>, to send an error with a description
+ * use <code>sendError(int, String)</code>.
+ *
+ * Sets the status code and message for this response.
+ *
+ * @param sc the status code
+ * @param sm the status message
+ */
+
+ public void setStatus(int sc, String sm);
+
+
+ /*
+ * Server status codes; see RFC 2068.
+ */
+
+ /**
+ * Status code (100) indicating the client can continue.
+ */
+
+ public static final int SC_CONTINUE = 100;
+
+
+ /**
+ * Status code (101) indicating the server is switching protocols
+ * according to Upgrade header.
+ */
+
+ public static final int SC_SWITCHING_PROTOCOLS = 101;
+
+ /**
+ * Status code (200) indicating the request succeeded normally.
+ */
+
+ public static final int SC_OK = 200;
+
+ /**
+ * Status code (201) indicating the request succeeded and created
+ * a new resource on the server.
+ */
+
+ public static final int SC_CREATED = 201;
+
+ /**
+ * Status code (202) indicating that a request was accepted for
+ * processing, but was not completed.
+ */
+
+ public static final int SC_ACCEPTED = 202;
+
+ /**
+ * Status code (203) indicating that the meta information presented
+ * by the client did not originate from the server.
+ */
+
+ public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;
+
+ /**
+ * Status code (204) indicating that the request succeeded but that
+ * there was no new information to return.
+ */
+
+ public static final int SC_NO_CONTENT = 204;
+
+ /**
+ * Status code (205) indicating that the agent <em>SHOULD</em> reset
+ * the document view which caused the request to be sent.
+ */
+
+ public static final int SC_RESET_CONTENT = 205;
+
+ /**
+ * Status code (206) indicating that the server has fulfilled
+ * the partial GET request for the resource.
+ */
+
+ public static final int SC_PARTIAL_CONTENT = 206;
+
+ /**
+ * Status code (300) indicating that the requested resource
+ * corresponds to any one of a set of representations, each with
+ * its own specific location.
+ */
+
+ public static final int SC_MULTIPLE_CHOICES = 300;
+
+ /**
+ * Status code (301) indicating that the resource has permanently
+ * moved to a new location, and that future references should use a
+ * new URI with their requests.
+ */
+
+ public static final int SC_MOVED_PERMANENTLY = 301;
+
+ /**
+ * Status code (302) indicating that the resource has temporarily
+ * moved to another location, but that future references should
+ * still use the original URI to access the resource.
+ */
+
+ public static final int SC_MOVED_TEMPORARILY = 302;
+
+ /**
+ * Status code (303) indicating that the response to the request
+ * can be found under a different URI.
+ */
+
+ public static final int SC_SEE_OTHER = 303;
+
+ /**
+ * Status code (304) indicating that a conditional GET operation
+ * found that the resource was available and not modified.
+ */
+
+ public static final int SC_NOT_MODIFIED = 304;
+
+ /**
+ * Status code (305) indicating that the requested resource
+ * <em>MUST</em> be accessed through the proxy given by the
+ * <code><em>Location</em></code> field.
+ */
+
+ public static final int SC_USE_PROXY = 305;
+
+ /**
+ * Status code (400) indicating the request sent by the client was
+ * syntactically incorrect.
+ */
+
+ public static final int SC_BAD_REQUEST = 400;
+
+ /**
+ * Status code (401) indicating that the request requires HTTP
+ * authentication.
+ */
+
+ public static final int SC_UNAUTHORIZED = 401;
+
+ /**
+ * Status code (402) reserved for future use.
+ */
+
+ public static final int SC_PAYMENT_REQUIRED = 402;
+
+ /**
+ * Status code (403) indicating the server understood the request
+ * but refused to fulfill it.
+ */
+
+ public static final int SC_FORBIDDEN = 403;
+
+ /**
+ * Status code (404) indicating that the requested resource is not
+ * available.
+ */
+
+ public static final int SC_NOT_FOUND = 404;
+
+ /**
+ * Status code (405) indicating that the method specified in the
+ * <code><em>Request-Line</em></code> is not allowed for the resource
+ * identified by the <code><em>Request-URI</em></code>.
+ */
+
+ public static final int SC_METHOD_NOT_ALLOWED = 405;
+
+ /**
+ * Status code (406) indicating that the resource identified by the
+ * request is only capable of generating response entities which have
+ * content characteristics not acceptable according to the accept
+ * headerssent in the request.
+ */
+
+ public static final int SC_NOT_ACCEPTABLE = 406;
+
+ /**
+ * Status code (407) indicating that the client <em>MUST</em> first
+ * authenticate itself with the proxy.
+ */
+
+ public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
+
+ /**
+ * Status code (408) indicating that the client did not produce a
+ * requestwithin the time that the server was prepared to wait.
+ */
+
+ public static final int SC_REQUEST_TIMEOUT = 408;
+
+ /**
+ * Status code (409) indicating that the request could not be
+ * completed due to a conflict with the current state of the
+ * resource.
+ */
+
+ public static final int SC_CONFLICT = 409;
+
+ /**
+ * Status code (410) indicating that the resource is no longer
+ * available at the server and no forwarding address is known.
+ * This condition <em>SHOULD</em> be considered permanent.
+ */
+
+ public static final int SC_GONE = 410;
+
+ /**
+ * Status code (411) indicating that the request cannot be handled
+ * without a defined <code><em>Content-Length</em></code>.
+ */
+
+ public static final int SC_LENGTH_REQUIRED = 411;
+
+ /**
+ * Status code (412) indicating that the precondition given in one
+ * or more of the request-header fields evaluated to false when it
+ * was tested on the server.
+ */
+
+ public static final int SC_PRECONDITION_FAILED = 412;
+
+ /**
+ * Status code (413) indicating that the server is refusing to process
+ * the request because the request entity is larger than the server is
+ * willing or able to process.
+ */
+
+ public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;
+
+ /**
+ * Status code (414) indicating that the server is refusing to service
+ * the request because the <code><em>Request-URI</em></code> is longer
+ * than the server is willing to interpret.
+ */
+
+ public static final int SC_REQUEST_URI_TOO_LONG = 414;
+
+ /**
+ * Status code (415) indicating that the server is refusing to service
+ * the request because the entity of the request is in a format not
+ * supported by the requested resource for the requested method.
+ */
+
+ public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;
+
+ /**
+ * Status code (500) indicating an error inside the HTTP server
+ * which prevented it from fulfilling the request.
+ */
+
+ public static final int SC_INTERNAL_SERVER_ERROR = 500;
+
+ /**
+ * Status code (501) indicating the HTTP server does not support
+ * the functionality needed to fulfill the request.
+ */
+
+ public static final int SC_NOT_IMPLEMENTED = 501;
+
+ /**
+ * Status code (502) indicating that the HTTP server received an
+ * invalid response from a server it consulted when acting as a
+ * proxy or gateway.
+ */
+
+ public static final int SC_BAD_GATEWAY = 502;
+
+ /**
+ * Status code (503) indicating that the HTTP server is
+ * temporarily overloaded, and unable to handle the request.
+ */
+
+ public static final int SC_SERVICE_UNAVAILABLE = 503;
+
+ /**
+ * Status code (504) indicating that the server did not receive
+ * a timely response from the upstream server while acting as
+ * a gateway or proxy.
+ */
+
+ public static final int SC_GATEWAY_TIMEOUT = 504;
+
+ /**
+ * Status code (505) indicating that the server does not support
+ * or refuses to support the HTTP protocol version that was used
+ * in the request message.
+ */
+
+ public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
+}
Propchange: incubator/felix/trunk/javax.servlet/src/main/java/javax/servlet/http/HttpServletResponse.java
------------------------------------------------------------------------------
svn:eol-style = native