Quadcap Embeddable Server

com/quadcap/http/server22/WebWorker.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.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;

import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.servlet.RequestDispatcher;
import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.SingleThreadModel;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletResponse;

import com.quadcap.io.LogInputStream;
import com.quadcap.io.LogOutputStream;
import com.quadcap.io.IO;

import com.quadcap.util.Config;
import com.quadcap.util.Debug;

import com.quadcap.net.server.Server;
import com.quadcap.net.server.Worker;

/**
 * A Worker is a thread spawned by the server to handle a single client
 * connection.
 *
 * @author Stan Bailes
 */
public class WebWorker extends Worker {
    WebServer                   s;

    HttpInputStream             is              = new HttpInputStream();
    HttpOutputStream            os              = new HttpOutputStream();
    HttpRequest                 req             = new HttpRequest(this);
    HttpResponse                res             = new HttpResponse(this);

    /** Construct a Worker attached to the specified socket. */
    public void init(Server server, Object context) {
        super.init(server, context);
        this.s = (WebServer)context;
        res.setFixedHeader("Server", s.getServerInfo());
        req.setResponse(res);
    }

    /**
     * Handle the client session.       
     */
    public void doSession() {
        checkPermission();
        boolean close = true;
        //Jni j1 = new Jni("WebWorker");
        int cnt = 0;
        do {
            String uri = "";
            String proto = HttpRequest.proto_10;
            try {
                //j1.reset();
                //Debug.println("[" + this + "].doSession(" + cnt + ")");
                cnt++;
                is.reset(getInputStream());
                //j1.dump("is.reset");
                os.reset(getOutputStream());
                //j1.dump("os.reset");
                try {
                    req.reset(is);
                } catch (SocketException e) {
                    try {
                        os.reallyClose();
                    } catch (Throwable t) {}
                    return;
                }
                //j1.dump("req.reset");
                if (req.badRequest()) {
                    try {
                        os.reallyClose();
                    } catch (Throwable t) {}
                    return;
                }
                res.reset(os);
                //j1.dump("res.reset");
                req.setResponse(res);
                //j1.dump("req.setResponse");

                uri = req.getRequestURI();
                //j1.dump("getRequestURI");
                WebApplication app = s.getContext(uri);
                //j1.dump("getContext(uri)");
                //j1.dump("getHeader(Connection)");
                proto = req.getProtocol();
                //j1.dump("getProtocol");
                if (proto == HttpRequest.proto_11) {
                    String conn = req.getHeader("Connection");
                    close = false;
                    if (conn != null) {
                        //Debug.println("conn = " + conn);
                        close = conn.equalsIgnoreCase("Close");
                    }
                }
                //j1.dump("proto check");

                // XXX but res.reset will trash this!!!!
                res.setProtocol(proto);
                res.setKeepAlive(!close);
                //j1.dump("set Connection Header");
                if (app != null) {
                    String subPath = uri.substring(app.getContextPath().length());
                    HttpDispatcher rd = (HttpDispatcher)app.getRequestDispatcher(subPath);
                    if (rd != null) {
                        try {
                            rd.service(req, res);
                        } catch (Throwable th) {
                            Debug.print(th);
                            showException(th, req, res);
                        } finally {
                            if (res.getContentLength() < 0) close = true;
                            if (Trace.level() > 0) {
                                Debug.println("[" + req.getMethod() + " " +
                                              req.getRequestURI() + "] " +
                                              res.sc + " " + res.sm);
                            }
                            //j1.dump("rd.service()");
                            res.flush();
                            //j1.dump("res.flush()");
                        }
                    } else {
                        res.sendError(HttpServletResponse.SC_NOT_FOUND, 
                                      "Not Found (request dispatcher)");
                    }
                } else {
                    res.sendError(HttpServletResponse.SC_NOT_FOUND, 
                                  "Not Found (webapp)");
                }
            } catch (SocketException e) {
                close = true;
            } catch (Throwable e) {
                Debug.println(1, e.toString());
                e.printStackTrace(Debug.debugStream);
                close = true;
            } finally {
                String qs = req.getQueryString();
                if (qs == null) {
                    qs = "";
                } else {
                    qs = "?" + qs;
                }
                s.requestLog(getRemoteHost() + " " + getRemoteAddr() + " " +
                             req.getMethod() + " " + uri + qs + " " + res.sc);
            }
                
        } while (!close);

        //j1.dump("loop done");
        if (os != null) {
            try {
                os.close();
            } catch (Exception e1) {}
        }
        //j1.dump("os.close()");
    }

    final void showException(Throwable t, HttpRequest req, HttpResponse res) {
        try {
            res.reset();
            res.setContentType("text/html");
            PrintWriter pw = null;
            if (res.getOutputStreamCalled) {
                OutputStream os1 = res.getOutputStream();
                OutputStreamWriter w = new OutputStreamWriter(os1);
                pw = new PrintWriter(w);
            } else {
                pw = res.getWriter();
            }
            pw.println("<h3>Servlet Exception Report</h3>");
            pw.println("<pre>");
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            PrintStream p = new PrintStream(bos);
            t.printStackTrace(p);
            if (t instanceof ServletException) {
                Throwable t1 = ((ServletException)t).getRootCause();
                if (t1 != null) {
                    p.println("");
                    p.println("<b>Root Cause</b>:");
                    t1.printStackTrace(p);
                }
            }
                                  
            p.flush();
            pw.println(bos.toString());
            bos = null;
            p = null;
            pw.println("contextPath = " + req.getContextPath());
            pw.println("servletPath = " + req.getServletPath());
            pw.println("pathInfo    = " + req.getPathInfo());
            pw.println("Headers:");
            Enumeration e1 = req.getHeaderNames();
            while (e1.hasMoreElements()) {
                String name = e1.nextElement().toString();
                Enumeration e2 = req.getHeaders(name);
                while (e2.hasMoreElements()) {
                    String val = e2.nextElement().toString();
                    pw.println(name + ": " + val);
                }
            }
            pw.println("</pre>");
        } catch (Throwable th) {
            Debug.print(th);
        }
    }

    /**
     * Get the output stream.
     */
    public HttpOutputStream getHttpOutputStream() { return os; }

    /**
     * Get the input stream.
     */
    public HttpInputStream getHttpInputStream() { return is; }

    /**
     * Who is my http server?
     */
    public WebServer getHttpServer() { return s; }

    void checkPermission() {
        if (String.valueOf(System.getProperty("public")).equals("true")) {
            return;
        }
        if (String.valueOf(Config.getProperty("public")).equals("true")) {
            return;
        }
        InetAddress ia = socket.getInetAddress();
        if (ia.toString().equals("/127.0.0.1")) return;
        try {
            if (ia.equals(InetAddress.getLocalHost())) {
                return;
            }
        } catch (Throwable t) {}
        throw new RuntimeException("No permission: " + ia);
    }
}