Quadcap Embeddable Server

com/quadcap/http/server22/HttpResponse.java

Go to the documentation of this file.

package com.quadcap.http.server22;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.TimeZone;
import java.util.Vector;

import java.text.DateFormat;
import java.text.SimpleDateFormat;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;

import com.quadcap.net.server.WorkerOutputStream;

import com.quadcap.util.Debug;

/**
 * An HTTP servlet response.  This interface allows a servlet's
 * <code>service</code> method to manipulate HTTP-protocol specified
 * header information and return data to its client.  It is implemented
 * by network service developers for use within servlets.
 * 
 * @author Stan Bailes
 */
public class HttpResponse implements HttpServletResponse {
    WebWorker                   w;
    Hashtable                   headers         = new Hashtable();
    String                      protocol;
    int                         sc              = SC_OK;
    String                      sm              = "Request Completed";
    boolean                     changedCode     = false;
    Locale                      defaultLocale   = Locale.getDefault();
    Locale                      locale          = defaultLocale;

    int                         contentLength   = -1;
    String                      contentType     = null;
    StringBuffer                headerBuf       = new StringBuffer();
    boolean                     headerBufValid  = true;
    boolean                     anyHeaders      = false;
    boolean                     keepAlive       = false;
    public boolean                     getWriterCalled = false;
    public boolean                     getOutputStreamCalled = false;

    byte[]                      fixedHeaders    = null;
    ByteArrayOutputStream       fixedH          = new ByteArrayOutputStream();
    
    HttpOutputStream            os;
    PrintWriter                 writer          = null;
    JspWriter                   jWriter         = new JspWriter(8192, true);
    boolean                     jWriterInit     = false;

    Vector                      cookies         = null;
    long                        calbase         = -1;
    byte[]                      curTime         = null;

    static DateFormat           cookieDateFormat;
    static TimeZone             GMT;
    static SimpleDateFormat     df;
    static SimpleDateFormat     df2;

    static {
        GMT = TimeZone.getTimeZone("GMT");
        cookieDateFormat = new SimpleDateFormat("E, dd-MMM-yy HH:mm:ss 'GMT'");
        cookieDateFormat.setTimeZone(GMT);
        df = new SimpleDateFormat("'Date: 'EEE, dd MMM yyyy HH:mm:ss 'GMT\r\n'");
        df.setTimeZone(GMT);
        df2 = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'");
        df2.setTimeZone(GMT);
    }

    /**
     * Construct a new HttpResponse for the specified worker.
     *
     * @param w the worker handling this http request
     */
    public HttpResponse(WebWorker w) {
        this.w = w;
    }

    public void reset(HttpOutputStream os) {
        this.os = os;
        this.os.setResponse(this);
        headers.clear();
        sc = SC_OK;
        jWriterInit = false;
        sm = "Request Completed";
        changedCode = false;
        locale = defaultLocale;
        contentLength = -1;
        contentType = null;
        headerBuf.setLength(0);
        headerBufValid = true;
        writer = null;
        cookies = null;
        anyHeaders = false;
        getWriterCalled = false;
        getOutputStreamCalled = false;
    }

    void setProtocol(String p) {
        this.protocol = p;
    }

    void setKeepAlive(boolean v) {
        this.keepAlive = v;
    }

    static final void write(OutputStream out, String s) throws IOException {
        for (int i = 0; i < s.length(); i++) {
            out.write((byte)s.charAt(i));
        }
    }

    static final byte[] headerSep = { (byte)':', (byte)' ' };
    static final byte[] CRLF = { (byte)'\r', (byte)'\n' };
    static final byte[] OKRESPONSE =
    " 200 Request Completed\r\n".getBytes();
    static final byte[] CONTENT_TYPE = "Content-Type: ".getBytes();
    static final byte[] CONTENT_LENGTH = "Content-Length: ".getBytes();
    static final byte[] CONNECTION_KEEPALIVE =
    "Connection: Keep-Alive\r\n".getBytes();
    static final byte[] CONNECTION_CLOSE =
    "Connection: Close\r\n".getBytes();
    static final byte[] DEFAULT_CONTENT_TYPE =
    "Content-Type: text/plain\r\n".getBytes();

    final void writeHeader(WorkerOutputStream out, String name, String val)
        throws IOException
    {
        //#ifdef DEBUG
        if (Trace.level() > 1) {
            Debug.println("header: " + name + ": " + val);
        }
        //#endif
        out.write(name);
        out.write(headerSep);
        out.write(val); // XXX folding?
        out.write(CRLF);
    }
    
    /**
     * Write the result code and the message headers for the response
     */
    public void writeHeaders() throws IOException {
        WorkerOutputStream out = os.getOutputStream();
        out.write(protocol);
        if (changedCode) {
            out.write(' ');
            out.writeInt(sc);
            out.write(' ');
            out.write(sm);
            out.write(CRLF);
        } else {
            out.write(OKRESPONSE);
        }

        if (keepAlive) {
            out.write(CONNECTION_KEEPALIVE);
        } else {
            out.write(CONNECTION_CLOSE);
        }

        if (contentType != null) {
            out.write(CONTENT_TYPE);
            out.write(contentType);
            out.write(CRLF);
        } else {
            out.write(DEFAULT_CONTENT_TYPE);
        }
        
        if (contentLength >= 0) {
            out.write(CONTENT_LENGTH);
            out.writeInt(contentLength);
            out.write(CRLF);
        }
        if (fixedHeaders == null) {
            if (fixedH != null) {
                fixedHeaders = fixedH.toByteArray();
                fixedH = null;
            }
            out.write(fixedHeaders);
        }

        if (headerBufValid) {
            out.write(headerBuf.toString());
        } else if (anyHeaders) {
            Enumeration hdrs = headers.keys();
            while (hdrs.hasMoreElements()) {
                String headerName = (String)hdrs.nextElement();
                Object headerVal = headers.get(headerName);
                if (headerVal instanceof String) {
                    writeHeader(out, headerName, headerVal.toString());
                } else {
                    Vector v = (Vector)headerVal;
                    for (int i = 0; i < v.size(); i++) {
                        writeHeader(out, headerName, v.elementAt(i).toString());
                    }
                }
            }
        }
        
        if (cookies != null) {
            writeCookies(out);
        }
        writeDateHeader(out);
        out.write(CRLF);
    }

    static byte[] digits = "0123456789".getBytes();
    static byte[] GMTString = " GMT\r\n".getBytes();
    
    final void writeDateHeader(WorkerOutputStream out) throws IOException {
        long now = System.currentTimeMillis();
        long msec = now - calbase;
        if (msec >= 60000) {
            Calendar c = Calendar.getInstance(GMT);
            c.setTime(new Date(now));
            c.set(Calendar.SECOND, 0);
            c.set(Calendar.MILLISECOND, 0);
            Date d = c.getTime();
            calbase = d.getTime();
            curTime = df.format(d).getBytes();
            msec = now - calbase;
            if (msec < 0) msec = 0;
        }
        int sec = (int)(msec / 1000);
        curTime[29] = digits[sec / 10];
        curTime[30] = digits[sec % 10];
        out.write(curTime);
    }

    void writeAttr(WorkerOutputStream out, String name, String val)
        throws IOException
    {
        if (val != null) {
            out.write(';');
            out.write(name);
            out.write('=');
            out.write(val);
        }
    }

    // from RFC 2068, token special case characters
    private static final String tspecials = "()<>@,;:\\\"/[]?={} \t";

    /**
     * Return true iff the string counts as an HTTP/1.1 "token".
     */
    private static boolean isToken (String value) {
        final 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;
    }

    private final void writeTok(WorkerOutputStream out, String val, int v)
        throws IOException
    {
        if (v == 0 || isToken(val)) {
            out.write(val);
        } else {
            out.write('"');
            out.write(val);
            out.write('"');
        }
    }
    
    void writeCookies(WorkerOutputStream out) throws IOException {
        out.write("Set-Cookie: ");
        for (int i = 0; i < cookies.size(); i++) {
            Cookie cookie = (Cookie)cookies.elementAt(i);
            final int version = cookie.getVersion();
            if (i > 0) out.write('\t');
            out.write(cookie.getName());
            String val = cookie.getValue();
            if (val != null) {
                out.write('=');
                writeTok(out, val, version);
            }

            writeAttr(out, "Path", cookie.getPath());
            if (version == 0) {
                writeAttr(out, "Domain", cookie.getDomain());
                if (cookie.getMaxAge() >= 0) {
                    Date d = new Date();
                    long ms = d.getTime() + cookie.getMaxAge() * 1000;
                    d.setTime(ms);
                    writeAttr(out, "Expires",
                              cookieDateFormat.format(d));
                }
            } else {
                out.write(";Version=1");
                out.write(";Domain=");
                writeTok(out, cookie.getDomain(), version);
                if (cookie.getMaxAge() >= 0) {
                    writeAttr(out, "Max-Age", "" + cookie.getMaxAge());
                } else {
                    out.write(";Discard");
                }
                writeAttr(out, "Comment", cookie.getComment());
            }
            if (cookie.getSecure()) out.write(";Ssecure");
            out.write(CRLF);
        }
    }

    final void setFixedHeader(String name, String val) {
        try {
            write(fixedH, name);
            write(fixedH, ": ");
            write(fixedH, val);
            fixedH.write(CRLF);
        } catch (Exception e) {}
    }
    
    /**
     * ----- SerlvetResponse methods -----
     */
    
    /**
     * Sets the content length for this response.
     *
     * @param len the content length
     */
    public void setContentLength(int len) {
        contentLength = len;
    }

    final void maybeSetContentLength(int len) {
        if (contentLength == -1) {
            contentLength = len;
        }
    }

    int getContentLength() { return contentLength; }

    /**
     * Sets the content type for this response.  This type may later
     * be implicitly modified by addition of properties such as the MIME
     * <em>charset=&lt;value&gt;</em> if the service finds it necessary,
     * and the appropriate media type property has not been set.
     *
     * <p>This response property may only be assigned one time.  If a
     * writer is to be used to write a text response, this method must
     * be called before the method <code>getWriter</code>.  If an
     * output stream will be used to write a response, this method must
     * be called before the output stream is used to write response
     * data.
     *
     * @param type the content's MIME type
     */
    public void setContentType(String type) {
        contentType = type;
    }

    /**
     * Returns an output stream for writing binary response data.
     *
     * @exception IllegalStateException if getWriter has been
     *  called on this same request.
     * @exception IOException if an I/O exception has occurred
     */
    public ServletOutputStream getOutputStream() throws IOException {
        if (getWriterCalled) {
            throw new IllegalStateException("getWriter() already called");
        }
        getOutputStreamCalled = true;
        return os;
    }

    /**
     * Returns a print writer for writing formatted text responses.  The
     * MIME type of the response will be modified, if necessary, to reflect
     * the character encoding used, through the <em>charset=...</em>
     * property.  This means that the content type must be set before
     * calling this method.
     *
     *
     * @exception UnsupportedEncodingException if no such encoding can
     * be provided
     * @exception IllegalStateException if getOutputStream has been
     *  called on this same request.
     * @exception IOException on other errors.
     */
    public PrintWriter getWriter() throws IOException {
        if (getOutputStreamCalled) {
            throw new
                IllegalStateException("getOutputStream() already called");
        }
        if (writer == null) {
            String encoding = getCharacterEncoding();
            OutputStreamWriter ww = null;
            OutputStream os = getOutputStream();
            if (encoding != null) {
                ww = new OutputStreamWriter(os, encoding);
            } else {
                ww = new OutputStreamWriter(os);
            }
            writer = new PrintWriter(ww);
            getWriterCalled = true;
        }
        return writer;
    }

    public JspWriter getJspWriter(int bufferSize, boolean autoFlush)
        throws IOException
    {
        if (!jWriterInit) {
            jWriterInit = true;
            jWriter.setHttpOutputStream(os);
            jWriter.setBufferSize(bufferSize);
            jWriter.setAutoFlush(autoFlush);
        }
        return jWriter;
    }

    /**
     * Returns the character set encoding used for this MIME body.
     * The character encoding is either the one specified in the
     * assigned content type, or one which the client understands.
     * If no content type has yet been assigned, it is implicitly
     * set to <em>text/plain</em>
     */
    public String getCharacterEncoding () {
        String s = contentType;
        if (s == null) return null;
        
        int idx = s.indexOf(';');
        while (idx > 0) {
            s = s.substring(idx+1).trim();
            idx = s.indexOf(';');
            String c = s;
            if (idx > 0) {
                c = s.substring(0, idx).trim();
            }
            if (c.startsWith("charset=")) {
                return c.substring(8);
            }
        }
        return null;
    }

    /**
     * ----- HttpServletResponse methods -----
     */
    
    
    /**
     * Adds the specified cookie to the response.  It 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) {
        //#ifdef DEBUG
        if (Trace.level() > 7) {
            Debug.println("addCookie(" + cookie + ")");
        }
        //#endif
        if (cookies == null) {
            cookies = new Vector();
        }
        cookies.addElement(cookie);
    }

    /**
     * Checks whether the response message header has a field with
     * the specified name.
     * 
     * @param name the header field name
     * @return true if the response message header has a field with
     * the specified name; false otherwise
     */
    public boolean containsHeader(String name) {
        return headers.get(name) != null;
    }

    /**
     * Sets the status code and message for this response.  If the
     * field had already been set, the new value overwrites the
     * previous one.  The message is sent as the body of an HTML
     * page, which is returned to the user to describe the problem.
     * The page is sent with a default HTML header; the message
     * is enclosed in simple body tags (&lt;body&gt;&lt;/body&gt;).
     * 
     * @param sc the status code
     * @param sm the status message
     */
    public void setStatus(int sc, String sm) {
        this.changedCode = true;
        this.sc = sc;
        this.sm = sm;
    }

    /**
     * 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.
     *
     * @param sc the status code
     *
     */
    public void setStatus(int sc) {
        this.changedCode = true;
        this.sc = sc;
        this.sm = "";
    }

    /**
     *
     * Adds a field to the response header with the given name and value.
     * If the field 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 field
     * @param value the header field's value
     *
     */
    public void setHeader(String name, String value) {
        if (name.charAt(0) == 'C') {
            if (name.equals("Content-Type")) {
                contentType = value;
                return;
            } else if (name.equals("Content-Length")) {
                contentLength = Integer.parseInt(value);
                return;
            }
        }
        if (headerBufValid) {
            if (headers.get(name) == null) {
                appendHeader(name, value);
            } else {
                headerBufValid = false;
            }
        }
        anyHeaders = true;
        headers.put(name, value);
    }

    final void appendHeader(String name, String value) {
        headerBuf.append(name);
        headerBuf.append(": ");
        headerBuf.append(value);
        headerBuf.append("\r\n");
    }

    /**
     * Add a new header value -- this method allows multiple headers with
     * the same name.
     */
    public void addHeader(String name, String value) {
        Object obj = headers.get(name);
        Vector v = null;
        boolean mustInsert = true;
        if (obj instanceof String) {
            v = new Vector();
            v.addElement(obj.toString());
        } else if (obj == null) {
            v = new Vector();
        } else {
            v = (Vector)obj;
            mustInsert = false;
        }
        v.addElement(value);
        if (mustInsert) {
            anyHeaders = true;
            headers.put(name, v);
        }
        appendHeader(name, value);
    }
        

    /**
     * Adds a field to the response header with the given name and
     * integer value.  If the field 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 field
     * @param value the header field's integer value
     *
     */
    public void setIntHeader(String name, int value) {
        setHeader(name, "" + value);
    }
        
    public void addIntHeader(String name, int value) {
        addHeader(name, "" + value);
    }
        
    /**
     * 
     * Adds a field to the response header with the given name and
     * date-valued field.  The date is specified in terms of
     * milliseconds since the epoch.  If the date field 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 field
     * @param value the header field's date value
     * 
     */
    public void setDateHeader(String name, long date) {
        Date d = new Date(date);
        setHeader(name, df2.format(d));
    }

    public void addDateHeader(String name, long date) {
        Date d = new Date(date);
        addHeader(name, df2.format(d));
    }

    /**
     * Sends an error response to the client using the specified status
     * code and descriptive message.  If setStatus has previously been
     * called, it is reset to the error status code.  The message is
     * sent as the body of an HTML page, which is returned to the user
     * to describe the problem.  The page is sent with a default HTML
     * header; the message is enclosed in simple body tags
     * (&lt;body&gt;&lt;/body&gt;).
     * 
     * @param sc the status code
     * @param msg the detail message
     * @exception IOException If an I/O error has occurred.  */
    public void sendError(int scode, String msg) throws IOException {
        setStatus(scode, msg);
        if (os.discard()) {
            writer = null;
        }
        getWriterCalled = getOutputStreamCalled = false;
        setContentType("text/html");
        PrintWriter p = getWriter();
        p.println("<HEAD><TITLE>" + scode + " " + msg + "</TITLE></HEAD>");
        p.print("<BODY><H1>");
        p.print(msg);
        p.println("</H1>");
        if (scode == HttpServletResponse.SC_NOT_FOUND) {
            p.print("The requested URL was not found on this server");
            p.println("<P>");
        }
        p.println("</BODY>");
        flush();
    }

    /**
     * Sends an error response to the client using the specified
     * status code and a default message.
     * @param scode the status code
     * @exception IOException If an I/O error has occurred.
     */
    public void sendError(int scode) throws IOException {
        sm = "Error " + scode;
        setStatus(scode);
        if (os.discard()) {
            writer = null;
        }
        getWriterCalled = getOutputStreamCalled = false;
        PrintWriter p = getWriter();
        p.println("<html><head><title>" + sm + "</title></head>");
        p.println("<body>");
        p.println(sm);
        p.println("</body></html>");
        flush();
    }

    /**
     * Flush the underlying output stream
     */
    void flush() throws IOException {
        if (writer != null) writer.flush();
        os.flush();
    }

    /**
     * Sends a temporary redirect response to the client using the
     * specified redirect location URL.  The URL must be absolute (for
     * example, <code><em>https://hostname/path/file.html</em></code>).
     * Relative URLs are not permitted here.
     *
     * @param location the redirect location URL
     * @exception IOException If an I/O error has occurred.
     */
    public void sendRedirect(String location) throws IOException {
        setHeader("Location", location);
        sendError(SC_MOVED_TEMPORARILY,
                  "<a href=\"" + location + "\">" + location + "</A>");
    }

    /**
     * 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 should include 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>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) {
        return url;
    }
    public String encodeURL(String url) {
        return 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
     * should include the logic to determine whether the session ID
     * needs to be encoded in the URL.  Because the rules for making
     * this determination 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 HttpServletResponse.sendRedirect
     * method should be run through this method.  Otherwise, URL
     * rewriting canont 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 encodeRedirectUrl (String url) {
        return url;
    }
    public String encodeRedirectURL(String url) {
        return url;
    }

    public void flushBuffer() throws IOException {
        if (writer != null) writer.flush();
        os.flushBuffered();
    }

    public void setBufferSize(int size) throws IllegalStateException {
        os.setBufferSize(size);
    }

    public int getBufferSize() {
        return os.getBufferSize();
    }

    public boolean isCommitted() {
        return os.isCommitted();
    }

    public void reset() throws IllegalStateException {
        os.reset();    // checks for committed, may throw IllegalStateException
        sc = SC_OK;
        headers.clear();
        sm = "Request Completed";
        changedCode = false;
        locale = defaultLocale;
        contentLength = -1;
        contentType = null;
        headerBuf.setLength(0);
        headerBufValid = true;
        writer = null;
        cookies = null;
        anyHeaders = false;
        getWriterCalled = false;
        jWriterInit = false;
        getOutputStreamCalled = false;
    }

    public void setLocale(Locale locale) {
        this.locale = locale;
        if (locale != null) {
            String lang = locale.getLanguage();
            if (lang != null) {
                setHeader("Content-Language", lang);
            }
        }
                
    }

    public Locale getLocale() {
        return locale;
    }
}