Quadcap Embeddable Server

com/quadcap/http/servlets/cgi/CgiScript.java

Go to the documentation of this file.

package com.quadcap.http.servlets.cgi;

/* Copyright 1998 - 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.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;

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

import java.net.URLEncoder;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.quadcap.http.util.HeaderParser;

import com.quadcap.io.LogInputStream;

import com.quadcap.util.text.Scanner;

import com.quadcap.util.Debug;

/**
 * Handle a single CGI script execution.
 *
 * @author Stan Bailes
 */
public class CgiScript {
    CgiServlet                  servlet;
    File                        script;
    String                      interp;

    static final String FORM_ENCODED = "application/x-www-form-urlencoded";
    
    public CgiScript(CgiServlet servlet, String interp, File script) {
        this.servlet = servlet;
        this.interp = interp;
        this.script = script;
    }

    final String ns(String s) {
        return s == null ? "" : s;
    }
    
    public synchronized void service(HttpServletRequest req,
                                     HttpServletResponse res)
        throws IOException, ServletException
    {
        boolean form = false;
        byte[] formData = null;
        if (req.getMethod().equalsIgnoreCase("POST") &&
            req.getContentType().equalsIgnoreCase(FORM_ENCODED)) {
            form = true;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            Enumeration ed = req.getParameterNames();
            boolean first = true;
            while (ed.hasMoreElements()) {
                String name = ed.nextElement().toString();
                String [] vals = req.getParameterValues(name);
                for (int i = 0; i < vals.length; i++) {
                    if (!first) bos.write('&');
                    first = false;
                    bos.write(URLEncoder.encode(name).getBytes());
                    bos.write('=');
                    bos.write(URLEncoder.encode(vals[i]).getBytes());
                }
            }
            formData = bos.toByteArray();
        } else {
            formData = new byte[0];
        }
        //#ifdef DEBUG
        if (Trace.bit(2)) {
            Debug.println("formData = " + new String(formData));
        }
        //#endif
        

        Vector env = new Vector();
        if (form) {
            env.addElement("CONTENT_LENGTH=" + formData.length);
        } else {
            env.addElement("CONTENT_LENGTH=" + req.getContentLength());
        }
        env.addElement("CONTENT_TYPE=" + req.getContentType());
        env.addElement("DOCUMENT_ROOT=" + 
                       servlet.getServletConfig().getServletContext().getRealPath("."));
        env.addElement("GATEWAY_INTERFACE=1.1");
        env.addElement("HTTP_ACCEPT=" + req.getHeader("Http-Accept"));
        env.addElement("HTTP_USER_AGENT=" + req.getHeader("User-Agent"));
        env.addElement("PATH_INFO=" + ns(req.getPathInfo()));
        env.addElement("QUERY_STRING=" + req.getQueryString());
        env.addElement("REQUEST_METHOD=" + req.getMethod());
        env.addElement("SCRIPT_NAME=" + req.getServletPath());
        env.addElement("SERVER_NAME=" + req.getServerName());
        env.addElement("SERVER_PORT=" + req.getServerPort());
        env.addElement("SERVER_PROTOCOL=" + req.getProtocol());

        String[] envp = new String[env.size()];
        for (int i = 0; i < env.size(); i++) {
            envp[i] = env.elementAt(i).toString();
            //#ifdef DEBUG
            if (Trace.bit(2)) {
                Debug.println("     " + envp[i]);
            }
            //#endif
        }

        String[] cmdp = new String[2];

        cmdp[0] = interp;
        cmdp[1] = script.getAbsolutePath();

        res.setContentType("text/html");

        //#ifdef DEBUG
        if (Trace.bit(0)) {
            Debug.println("Invoking: " + cmdp[0] + " " + cmdp[1]);
        }
        //#endif
        Process cgi = Runtime.getRuntime().exec(cmdp, envp);
        InputStream pi = cgi.getInputStream();

//          FileOutputStream fos = new FileOutputStream("cgi.log");
//          LogInputStream lis = new LogInputStream(pi, fos, "");
//          pi = lis;

        OutputStream po = cgi.getOutputStream();
        InputStream pe = cgi.getErrorStream();

        OutputStream so = res.getOutputStream();
        ByteArrayOutputStream se = new ByteArrayOutputStream();

        Thread t1 = makeInputThread(formData, po);
        Thread t2 = makeOutputThread(pi, so, res);
        Thread t3 = makeCopyThread(pe, se);

        t1.start();
        t2.start();
        t3.start();
        int ret = 0;

        try { ret = cgi.waitFor(); } catch (Exception e) {}
        try { t1.join(); } catch (Exception e) {}
        try { t2.join(); } catch (Exception e) {}
        try { t3.join(); } catch (Exception e) {}

        //#ifdef DEBUG
        if (Trace.bit(1)) {
            Debug.println("stderr: " + se.toString());
        }
        //#endif

        //fos.flush();
        if (ret != 0) {
            throw new ServletException("Script failed: " + se.toString());
        }
    }

    /**
     * Create a thread which copies bytes from an input stream to
     * an output stream until end of file is reached.
     */
    public static Thread makeInputThread(final byte[] formData,
                                        final OutputStream out) {
        Thread t = new Thread() {
            public void run() {
                int c;
                try {
                    out.write(formData);
                    out.close();
                } catch (IOException e) {
                    Debug.print(e);
                }
            }
        };
        return t;
    }

    public static Thread makeOutputThread(final InputStream in,
                                          final OutputStream out,
                                          final HttpServletResponse res) {
        Thread t = new Thread() {
            Hashtable headers = new Hashtable();
            Scanner scanner = new Scanner(in);
            boolean terminate = false;
            public void run() {
                int c;
                try {
                    try {
                        HeaderParser.parseHeaders(scanner, headers);
                    } catch (Throwable e) {
                        Debug.print(e);
                        //#ifdef DEBUG
                        Debug.println("scanner = " + scanner.getLog());
                        //#endif
                    }
                    Enumeration e = headers.keys();
                    while (e.hasMoreElements()) {
                        String hdr = (String)e.nextElement();
                        String val = (String)headers.get(hdr);
                        if (hdr.equals("status")) {
                            int code = Integer.parseInt(val.substring(0,3));
                            String reason = val.substring(4);
                            if (code == 303) {
                                res.sendRedirect(reason);
                                return;
                            } else {
                                res.setStatus(code, reason);
                            }
                        } else if (hdr.equals("content-type")) {
                            res.setContentType(val);
                        } else if (hdr.equals("location")) {
                            res.sendRedirect(val);
                        } else {
                            res.setHeader(hdr, val);
                        }
                    }
                        
                    while (!terminate && (c = in.read()) >= 0) {
                        out.write(c);
                    }
                } catch (IOException e) {
                    Debug.print(e);
                }
            }
            public void terminate() {
                this.terminate = true;
            }
        };
        return t;
    }
        
    /**
     * Create a thread which copies bytes from an input stream to
     * an output stream until end of file is reached.
     */
    public static Thread makeCopyThread(final InputStream in,
                                        final OutputStream out) {
        Thread t = new Thread() {
            boolean terminate = false;
            public void run() {
                int c;
                try {
                    while (!terminate && (c = in.read()) >= 0) out.write(c);
                } catch (IOException e) {
                    Debug.print(e);
                }
            }
            public void terminate() {
                this.terminate = true;
            }
        };
        return t;
    }

}