package javaxt.http.servlet;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.StringTokenizer;

//******************************************************************************

//** CGI Servlet

//******************************************************************************

/**

* Http Servlet used to run CGI programs. Based on CgiServlet.java, v1.8

* developed by Jef Poskanzer (acme.com).

*

******************************************************************************/

public class CgiServlet extends HttpServlet {

private java.io.File executable;

//**************************************************************************

//** Constructor

//**************************************************************************

public CgiServlet(java.io.File executable){

this.executable = executable;

}

//**************************************************************************

//** getServletInfo

//**************************************************************************

/** Returns a string containing information about the author, version, and

* copyright of the servlet.

*/

public String getServletInfo() {

return "JavaXT CGI Servlet";

}

//**************************************************************************

//** getParameters

//**************************************************************************

/** Returns a list of parameters that are used to instantiate the CGI

* application.

*/

protected java.util.ArrayList<String> getParameters(HttpServletRequest request){

java.util.ArrayList<String> env = new java.util.ArrayList<String>();

//env.add("PATH=" + "/usr/local/bin:/usr/ucb:/bin:/usr/bin");

env.add("GATEWAY_INTERFACE=" + "CGI/1.1");

env.add("SERVER_SOFTWARE=" + getServletContext().getServerInfo());

env.add("SERVER_PROTOCOL=" + request.getProtocol());

env.add("SERVER_NAME=" + request.getServerName());

env.add("SERVER_PORT=" + request.getServerPort());

env.add("REMOTE_ADDR=" + request.getRemoteAddr());

env.add("REMOTE_HOST=" + request.getRemoteHost());

env.add("REQUEST_METHOD=" + request.getMethod());

env.add("SCRIPT_NAME=" + request.getServletPath());

int contentLength = request.getContentLength();

if (contentLength!=-1) env.add("CONTENT_LENGTH=" + contentLength);

String contentType = request.getContentType();

if (contentType!=null) env.add("CONTENT_TYPE=" + contentType);

String pathInfo = request.getPathInfo();

if (pathInfo!=null) env.add("PATH_INFO=" + pathInfo);

String pathTranslated = request.getPathTranslated();

if (pathTranslated!=null) env.add("PATH_TRANSLATED=" + pathTranslated);

String queryString = request.getQueryString();

if (queryString!=null) env.add("QUERY_STRING=" + queryString);

String remoteUser = request.getRemoteUser();

if (remoteUser!=null) env.add("REMOTE_USER=" + remoteUser);

String authType = request.getAuthType();

if (authType!=null) env.add("AUTH_TYPE=" + authType);

java.util.Enumeration<String> hnEnum = request.getHeaderNames();

while (hnEnum.hasMoreElements()) {

String name = hnEnum.nextElement();

String value = request.getHeader(name);

if (value == null) value = "";

env.add("HTTP_" + name.toUpperCase().replace('-', '_') + "=" + value);

}

return env;

}

//**************************************************************************

//** processRequest

//**************************************************************************

/** Services a single request from the client.

* @param request the servlet request

* @param response the servlet response

* @exception ServletException when an exception has occurred

*/

public void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

String method = request.getMethod().toUpperCase();

if (!(method.equals("GET") || method.equals("POST"))) {

response.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

return;

}

//Generate a list of parameters used to instantiate the CGI application

java.util.ArrayList<String> env = getParameters(request);

String[] parameters = new String[env.size()+1];

parameters[0] = executable.toString();

for (int i=0; i<parameters.length; i++){

if (i>0) parameters[i] = env.get(i-1);

}

try{

//Run executable via Command Line

Runtime runtime = Runtime.getRuntime();

Process process = runtime.exec(parameters, null, executable.getParentFile());

//If this is a POST, pass the body of the request to the process

if (method.equals("POST")) {

OutputStream outputStream = process.getOutputStream();

InputStream inputStream = request.getInputStream();

byte[] b = new byte[1024];

int x=0;

while ( (x = inputStream.read(b)) != -1) {

outputStream.write(b,0,x);

}

inputStream.close();

outputStream.close();

}

//Parse output streams

StreamReader s1 = new StreamReader(process.getInputStream(), response);

ErrorStreamReader s2 = new ErrorStreamReader(process.getErrorStream());

s1.start();

s2.start();

process.waitFor();

s1.join();

s2.join();

//Explicitly clean up every the process by calling close on each stream

try{process.getInputStream().close();} catch(Exception ex){}

try{process.getErrorStream().close();} catch(Exception ex){}

try{process.getOutputStream().close();} catch(Exception ex){}

//Explicitly destroy the process even if the process is already terminated

try{process.destroy();} catch(Exception ex){}

process = null;

}

catch(IOException e){

throw e;

}

catch(InterruptedException e){

//throw e;

return;

}

}

//**************************************************************************

//** StreamReader Class

//**************************************************************************

/** Thread used to process the standard output stream. */

private class StreamReader implements Runnable {

private InputStream is;

private HttpServletResponse response;

private Thread thread;

private byte[] b = new byte[1];

public StreamReader(InputStream is, HttpServletResponse response){

this.is = is;

this.response = response;

}

public void start() {

thread = new Thread(this);

thread.start();

}

public void run() {

try {

//Parse the list few lines returned from the executable. These

//may contain HTTP response headers

boolean firstLine = true;

while (true) {

String line = readLine();

if (line==null) break;

line = line.trim();

if (line.equals("")) break;

int colon = line.indexOf(":");

if (colon == -1) {

// No colon. If it's the first line, parse it for status.

if (firstLine) {

StringTokenizer tok = new StringTokenizer(line, " ");

try {

switch (tok.countTokens()) {

case 2:

tok.nextToken();

response.setStatus(Integer.parseInt(tok.nextToken()));

break;

case 3:

tok.nextToken();

response.setStatus(Integer.parseInt(tok.nextToken()), tok.nextToken());

break;

}

} catch (NumberFormatException ignore) {

}

} else {

// No colon and it's not the first line? Ignore.

}

} else {

// There's a colon. Check for certain special headers.

String name = line.substring(0, colon);

String value = line.substring(colon + 1).trim();

if (name.equalsIgnoreCase("Status")) {

StringTokenizer tok = new StringTokenizer(value, " ");

try {

switch (tok.countTokens()) {

case 1:

response.setStatus(Integer.parseInt(tok.nextToken()));

break;

case 2:

response.setStatus(Integer.parseInt(tok.nextToken()), tok.nextToken());

break;

}

} catch (NumberFormatException ignore) {

}

} else if (name.equalsIgnoreCase("Content-type")) {

response.setContentType(value);

} else if (name.equalsIgnoreCase("Content-length")) {

try {

response.setContentLength(Integer.parseInt(value));

} catch (NumberFormatException ignore) {

}

} else if (name.equalsIgnoreCase("Location")) {

response.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);

response.setHeader(name, value);

} else if (name.equalsIgnoreCase("Set-Cookie")) {

int x = value.indexOf("=");

if (x > 0) {

String n = value.substring(0, x);

String v = value.substring(x + 1).trim();

response.addCookie(new Cookie(n, v));

}

} else {

// Not a special header. Just set it.

response.setHeader(name, value);

}

}

}

//Set transfer encoding

response.setHeader("Transfer-Encoding", "Chunked");

//Tranfer remaining bytes from the standard output stream to

//the servlet output stream

OutputStream outputStream = response.getOutputStream();

byte[] b = new byte[1024];

int x=0;

while ( (x = is.read(b)) != -1) {

outputStream.write(b,0,x);

}

//Close the input and output streams

outputStream.close();

is.close();

}

catch (IOException e) {

// response.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR );

// There's some weird bug in Java, when reading from a Process

// you get a spurious IOException. We have to ignore it.

}

catch (Exception e) {

e.printStackTrace();

return;

}

}

private String readLine() throws IOException {

StringBuffer str = new StringBuffer();

while (true){

if (is.read(b)==-1) break;

byte c = b[0];

if (c=='\n') break;

str.append((char) c);

}

return str.toString();

}

public void join() throws InterruptedException {

thread.join();

}

} //End StreamReader Class

//**************************************************************************

//** ErrorStreamReader Class

//**************************************************************************

/** Thread used to read the standard output streams. */

private class ErrorStreamReader implements Runnable {

private InputStream is;

private Thread thread;

private byte[] b = new byte[1];

public ErrorStreamReader(InputStream is){

this.is = is;

}

public void start() {

thread = new Thread(this);

thread.start();

}

public void run() {

try {

while (true) {

if (is.read(b)==-1) break;

}

is.close();

}

catch (Exception e) {

//System.out.println ("Problem reading stream... :" + ex);

e.printStackTrace();

return;

}

}

public void join() throws InterruptedException {

thread.join();

}

} //End ErrorStreamReader Class

}