amyroh      01/05/31 17:21:15

  Added:       catalina/src/share/org/apache/catalina/util
                        ProcessHelper.java ProcessEnvironment.java
                        CGIProcessEnvironment.java
  Log:
  Add CGI supporting classes submitted by Martin Dengler.
  
  Revision  Changes    Path
  1.1                  
jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/ProcessHelper.java
  
  Index: ProcessHelper.java
  ===================================================================
  /*
   * ProcessHelper.java $Header: 
/home/cvs/jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/ProcessHelper.java,v
 1.1 2001/06/01 00:21:14 amyroh Exp $
   * $Revision: 1.1 $, $Date: 2001/06/01 00:21:14 $
   *
   * ====================================================================
   *
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 1999 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution, if
   *    any, must include the following acknowlegement:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowlegement may appear in the software itself,
   *    if and wherever such third-party acknowlegements normally appear.
   *
   * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
   *    Foundation" must not be used to endorse or promote products derived
   *    from this software without prior written permission. For written
   *    permission, please contact [EMAIL PROTECTED]
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Group.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   *
   */
  
  
  package org.apache.catalina.util;
  
  import java.lang.Process;
  import java.io.File;
  import java.io.Writer;
  import java.io.Reader;
  import java.io.PrintWriter;
  import java.io.BufferedWriter;
  import java.io.BufferedReader;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.IOException;
  import java.net.URLEncoder;
  import java.util.Hashtable;
  import java.util.Vector;
  import java.util.Enumeration;
  import java.util.StringTokenizer;
  import java.util.Locale;
  import java.util.Date;
  import javax.servlet.ServletException;
  import javax.servlet.ServletOutputStream;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletConfig;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.Cookie;
  import org.apache.catalina.Context;
  import org.apache.catalina.Wrapper;
  // import org.apache.catalina.util.StringManager;
  
  
  //class CGIServlet
      
  
  /**
       * Encapsulates the knowledge of how to run a CGI script, given the
       * script's desired environment and (optionally) input/output streams
       *
       * <p>
       *
       * Exposes a <code>run</code> method used to actually invoke the
       * CGI.
       *
       * </p>
       * <p>
       *
       * The CGI environment and settings are derived from the information
       * passed to the constuctor.
       *
       * </p>
       * <p>
       *
       * The input and output streams can be set by the <code>setInput</code> 
       * and <code>setResponse</code> methods, respectively.
       * </p>
       *
       * @author    Martin Dengler [[EMAIL PROTECTED]]
       * @version   $Revision: 1.1 $, $Date: 2001/06/01 00:21:14 $
       */
  public class ProcessHelper {
  
  /** script/command to be executed */
  private String command = null;
  
  /** environment used when invoking the cgi script */
  private Hashtable env = null;
  
  /** working directory used when invoking the cgi script */
  private File wd = null;
  
  /** query parameters to be passed to the invoked script */
  private Hashtable params = null;
  
  /** stdin to be passed to cgi script */
  private InputStream stdin = null;
  
  /** response object used to set headers & get output stream */
  private HttpServletResponse response = null;
  
  /** boolean tracking whether this object has enough info to run() */
  private boolean readyToRun = false;
  
  /** the debugging detail level for this instance. */
  private int debug = 0;
  
  /** the time in ms to wait for the client to send us CGI input data */
  private int iClientInputTimeout;
  
  /**
   *  Creates a ProcessHelper and initializes its environment, working
   *  directory, and query parameters.
   *  <BR>
   *  Input/output streams (optional) are set using the
   *  <code>setInput</code> and <code>setResponse</code> methods,
   *  respectively.
   *
   * @param  command  string full path to command to be executed
   * @param  env      Hashtable with the desired script environment
   * @param  wd       File with the script's desired working directory
   * @param  params   Hashtable with the script's query parameters
   *
   * @param  res       HttpServletResponse object for setting headers
   *                   based on CGI script output
   * 
   */
  public ProcessHelper(String command, Hashtable env, File wd,
                    Hashtable params) {
      this.command = command;
      this.env = env;
      this.wd = wd;
      this.params = params;
      updateReadyStatus();
  }
  
  
  
  /**
   * Checks & sets ready status
   */
  protected void updateReadyStatus() {
      if (command != null
        && env != null
        && wd != null
        && params != null
        && response != null) {
        readyToRun = true;
      } else {
        readyToRun = false;
      }
  }
  
  
  
  /**
   * Gets ready status
   *
   * @return   false if not ready (<code>run</code> will throw
   *           an exception), true if ready
   */
  public boolean isReady() {
      return readyToRun;
  }
  
  
  
  /**
   * Sets HttpServletResponse object used to set headers and send
   * output to
   *
   * @param  response   HttpServletResponse to be used
   *
   */
  public void setResponse(HttpServletResponse response) {
      this.response = response;
      updateReadyStatus();
  }
  
  
  
  /**
   * Sets standard input to be passed on to the invoked cgi script
   *
   * @param  stdin   InputStream to be used
   *
   */
  public void setInput(InputStream stdin) {
      this.stdin = stdin;
      updateReadyStatus();
  }
  
  
  
  /**
   * Converts a Hashtable to a String array by converting each
   * key/value pair in the Hashtable to a String in the form
   * "key=value" (hashkey + "=" + hash.get(hashkey).toString())
   *
   * @param  h   Hashtable to convert
   *
   * @return     converted string array
   *
   * @exception  NullPointerException   if a hash key has a null value
   *
   */
  private String[] hashToStringArray(Hashtable h)
      throws NullPointerException {
      Vector v = new Vector();
      Enumeration e = h.keys();
      while (e.hasMoreElements()) {
        String k = e.nextElement().toString();
        v.add(k + "=" + h.get(k));
      }
      String[] strArr = new String[v.size()];
      v.copyInto(strArr);
      return strArr;
  }
  
  
  
  /**
   * Executes a process script with the desired environment, current working
   * directory, and input/output streams
   *
   * <p>
   * This implements the following CGI specification recommedations:
   * <UL>
   * <LI> Servers SHOULD provide the "<code>query</code>" component of
   *      the script-URI as command-line arguments to scripts if it
   *      does not contain any unencoded "=" characters and the
   *      command-line arguments can be generated in an unambiguous
   *      manner.
   * <LI> Servers SHOULD set the AUTH_TYPE metavariable to the value
   *      of the "<code>auth-scheme</code>" token of the
   *      "<code>Authorization</code>" if it was supplied as part of the
   *      request header.  See <code>getCGIEnvironment</code> method.
   * <LI> Where applicable, servers SHOULD set the current working
   *      directory to the directory in which the script is located
   *      before invoking it.
   * <LI> Server implementations SHOULD define their behavior for the
   *      following cases:
   *     <ul>
   *     <LI> <u>Allowed characters in pathInfo</u>:  This implementation
   *             does not allow ASCII NUL nor any character which cannot
   *             be URL-encoded according to internet standards;
   *     <LI> <u>Allowed characters in path segments</u>: This
   *             implementation does not allow non-terminal NULL
   *             segments in the the path -- IOExceptions may be thrown;
   *     <LI> <u>"<code>.</code>" and "<code>..</code>" path
   *             segments</u>:
   *             This implementation does not allow "<code>.</code>" and
   *             "<code>..</code>" in the the path, and such characters
   *             will result in an IOException being thrown;
   *     <LI> <u>Implementation limitations</u>: This implementation
   *             does not impose any limitations except as documented
   *             above.  This implementation may be limited by the
   *             servlet container used to house this implementation.
   *             In particular, all the primary CGI variable values
   *             are derived either directly or indirectly from the
   *             container's implementation of the Servlet API methods.
   *     </ul>
   * </UL>
   * </p>
   *
   * @exception IOException if problems during reading/writing occur
   * 
   * @see    java.lang.Runtime#exec(String command, String[] envp,
   *                                File dir)
   */
  public void run() throws IOException {
  
      /*
       * REMIND:  this method feels too big; should it be re-written?
       */
  
      if (!isReady()) {
        throw new IOException(this.getClass().getName()
                              + ": not ready to run.");
      }
  
      if (debug >= 1 ) {
        log("runCGI(envp=[" + env + "], command=" + command + ")");
      }
  
      if ((command.indexOf(File.separator + "." + File.separator) >= 0)
        || (command.indexOf(File.separator + "..") >= 0)
        || (command.indexOf(".." + File.separator) >= 0)) {
        throw new IOException(this.getClass().getName()
                              + "Illegal Character in CGI command "
                              + "path ('.' or '..') detected.  Not "
                              + "running CGI [" + command + "].");
      }
  
      /* original content/structure of this section taken from
       * http://developer.java.sun.com/developer/
       *                               bugParade/bugs/4216884.html
       * with major modifications by Martin Dengler
       */
      Runtime rt = null;
      BufferedReader commandsStdOut = null;
      BufferedReader commandsStdErr = null;
      BufferedOutputStream commandsStdIn = null;
      Process proc = null;
      byte[] bBuf = new byte[1024];
      char[] cBuf = new char[1024];
      int bufRead = -1;
  
      //create query arguments
      Enumeration paramNames = params.keys();
      StringBuffer cmdAndArgs = new StringBuffer(command);
      if (paramNames != null && paramNames.hasMoreElements()) {
        cmdAndArgs.append(" ");
        while (paramNames.hasMoreElements()) {
            String k = (String) paramNames.nextElement();
            String v = params.get(k).toString();
            if ((k.indexOf("=") < 0) && (v.indexOf("=") < 0)) {
                cmdAndArgs.append(k);
                cmdAndArgs.append("=");
                v = java.net.URLEncoder.encode(v);
                cmdAndArgs.append(v);
                cmdAndArgs.append(" ");
            }
        }
      }
  
      String postIn = getPostInput(params);
      int contentLength = (postIn.length()
            + System.getProperty("line.separator").length());
      if ("POST".equals(env.get("REQUEST_METHOD"))) {
        env.put("CONTENT_LENGTH", new Integer(contentLength));
      }
  
      rt = Runtime.getRuntime();
      proc = rt.exec(cmdAndArgs.toString(), hashToStringArray(env), wd);
  
  
      /*
       * provide input to cgi
       * First  -- parameters
       * Second -- any remaining input
       */
      commandsStdIn = new BufferedOutputStream(proc.getOutputStream());
      if (debug >= 2 ) {
        log("runCGI stdin=[" + stdin + "], qs="
            + env.get("QUERY_STRING"));
      }
      if ("POST".equals(env.get("REQUEST_METHOD"))) {
        if (debug >= 2) {
            log("runCGI: writing ---------------\n");
            log(postIn);
            log("runCGI: new content_length=" + contentLength 
                + "---------------\n");
        }
        commandsStdIn.write(postIn.getBytes());
      }
      if (stdin != null) {
        //REMIND: document this
        /* assume if nothing is available after a time, that nothing is
         * coming...
         */
        if (stdin.available() <= 0) {
            if (debug >= 2 ) {
                log("runCGI stdin is NOT available ["
                    + stdin.available() + "]");
            }
            try {
                Thread.currentThread().sleep(iClientInputTimeout);
            } catch (InterruptedException ignored) {
            }
        }
        if (stdin.available() > 0) {
            if (debug >= 2 ) {
                log("runCGI stdin IS available ["
                    + stdin.available() + "]");
            }
            bBuf = new byte[1024];
            bufRead = -1;
            try {
                while ((bufRead = stdin.read(bBuf)) != -1) {
                    if (debug >= 2 ) {
                        log("runCGI: read [" + bufRead
                            + "] bytes from stdin");
                    }
                    commandsStdIn.write(bBuf, 0, bufRead);
                }
                if (debug >= 2 ) {
                    log("runCGI: DONE READING from stdin");
                }
            } catch (IOException ioe) {
                //REMIND: replace with logging
                //REMIND: should I throw this exception?
                log("runCGI: couldn't write all bytes.");
                ioe.printStackTrace();
            }
        }
      }
      commandsStdIn.flush();
      commandsStdIn.close();
  
      /* we want to wait for the process to exit,  Process.waitFor()
       * is useless in our situation; see
       * http://developer.java.sun.com/developer/
       *                               bugParade/bugs/4223650.html
       */
  
      boolean isRunning = true;
      commandsStdOut = new BufferedReader
        (new InputStreamReader(proc.getInputStream()));
      commandsStdErr = new BufferedReader
        (new InputStreamReader(proc.getErrorStream()));
      BufferedWriter servletContainerStdout = null;
  
      try {
        if (response.getOutputStream() != null) {
            servletContainerStdout =
                new BufferedWriter(new OutputStreamWriter
                    (response.getOutputStream()));
        }
      } catch (IOException ignored) {
        //NOOP: no output will be written
      }
  
      while (isRunning) {
  
        try {
            //read stderr first
            cBuf = new char[1024];
            while ((bufRead = commandsStdErr.read(cBuf)) != -1) {
                if (servletContainerStdout != null) {
                    servletContainerStdout.write(cBuf, 0, bufRead);
                }
            }
  
            //set headers
            String line = null;
            while (((line = commandsStdOut.readLine()) != null)
                   && !("".equals(line))) {
                if (debug >= 2) {
                    log("runCGI: addHeader(\"" + line + "\")");
                }
                if (line.startsWith("HTTP")) {
                    //TODO: should set status codes (NPH support)
                    /*
                     * response.setStatus(getStatusCode(line));
                     */
                } else {
                    response.addHeader
                        (line.substring(0, line.indexOf(":")).trim(),
                         line.substring(line.indexOf(":") + 1).trim());
                }
            }
  
            //write output
            cBuf = new char[1024];
            while ((bufRead = commandsStdOut.read(cBuf)) != -1) {
                if (servletContainerStdout != null) {
                    if (debug >= 4) {
                        log("runCGI: write(\"" + cBuf + "\")");
                    }
                    servletContainerStdout.write(cBuf, 0, bufRead);
                }
            }
  
            if (servletContainerStdout != null) {
                servletContainerStdout.flush();
            }
  
            proc.exitValue(); // Throws exception if alive
        
            isRunning = false;
  
        } catch (IllegalThreadStateException e) {
            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException ignored) {
            }
        }
      } //replacement for Process.waitFor()
  
  
  }
  
  
  /**
   * Gets a string for input to a POST cgi script
   *
   * @param  params   Hashtable of query parameters to be passed to
   *                  the CGI script
   * @return          for use as input to the CGI script
   */
  
  protected String getPostInput(Hashtable params) {
      String lineSeparator = System.getProperty("line.separator");
      Enumeration paramNames = params.keys();
      StringBuffer postInput = new StringBuffer("");
      StringBuffer qs = new StringBuffer("");
      if (paramNames != null && paramNames.hasMoreElements()) {
        while (paramNames.hasMoreElements()) {
            String k = (String) paramNames.nextElement();
            String v = params.get(k).toString();
            if ((k.indexOf("=") < 0) && (v.indexOf("=") < 0)) {
                postInput.append(k);
                qs.append(k);
                postInput.append("=");
                qs.append("=");
                postInput.append(v);
                qs.append(v);
                postInput.append(lineSeparator);
                qs.append("&");
            }
        }
      }
      qs.append(lineSeparator);
      return qs.append(postInput).toString();
  }
  
  
  private void log(String s) {
      System.out.println(s);
  }
  
  
  public int getIClientInputTimeout(){
          return iClientInputTimeout;
      }
  
  
  public void setIClientInputTimeout(int iClientInputTimeout){
          this.iClientInputTimeout = iClientInputTimeout;
      }
  }
  
  
  
  
  
  1.1                  
jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/ProcessEnvironment.java
  
  Index: ProcessEnvironment.java
  ===================================================================
  /*
  * ProcessEnvironment.java $Header: 
/home/cvs/jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/ProcessEnvironment.java,v
 1.1 2001/06/01 00:21:15 amyroh Exp $
  * $Revision: 1.1 $, $Date: 2001/06/01 00:21:15 $
  *
  * ====================================================================
  *
  * The Apache Software License, Version 1.1
  *
  * Copyright (c) 1999 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution, if
  *    any, must include the following acknowlegement:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowlegement may appear in the software itself,
  *    if and wherever such third-party acknowlegements normally appear.
  *
  * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
  *    Foundation" must not be used to endorse or promote products derived
  *    from this software without prior written permission. For written
  *    permission, please contact [EMAIL PROTECTED]
  *
  * 5. Products derived from this software may not be called "Apache"
  *    nor may "Apache" appear in their names without prior written
  *    permission of the Apache Group.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  *
  *
  */
  
  package org.apache.catalina.util;
  
  import java.lang.Process;
  import java.io.File;
  import java.io.Writer;
  import java.io.Reader;
  import java.io.PrintWriter;
  import java.io.BufferedWriter;
  import java.io.BufferedReader;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.IOException;
  import java.net.URLEncoder;
  import java.util.Hashtable;
  import java.util.Vector;
  import java.util.Enumeration;
  import java.util.StringTokenizer;
  import java.util.Locale;
  import java.util.Date;
  import javax.servlet.ServletException;
  import javax.servlet.ServletOutputStream;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletConfig;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.Cookie;
  import org.apache.catalina.Context;
  import org.apache.catalina.Wrapper;
  // import org.apache.catalina.util.StringManager;
  
  
  
  /**
   * Encapsulates the Process environment and rules to derive
   * that environment from the servlet container and request information.
   * @author   Martin Dengler [[EMAIL PROTECTED]]
   * @version  $Revision: 1.1 $, $Date: 2001/06/01 00:21:15 $
   * @since    Tomcat 4.0
   */
  public class ProcessEnvironment {
      /** context of the enclosing servlet */
      private ServletContext context = null;
  
      /** real file system directory of the enclosing servlet's web app */
      private String webAppRootDir = null;
  
      /** context path of enclosing servlet */
      private String contextPath = null;
  
      /** pathInfo for the current request */
      protected String pathInfo = null;
  
      /** servlet URI of the enclosing servlet */
      private String servletPath = null;
  
      /** derived process environment */
      protected Hashtable env = null;
  
      /** command to be invoked */
      protected String command = null;
  
      /** whether or not this object is valid or not */
      protected boolean valid = false;
  
      /** the debugging detail level for this instance. */
      protected int debug = 0;
  
      /** process' desired working directory */
      protected File workingDirectory = null;
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.
       * @param  req       HttpServletRequest for information provided by
       *                   the Servlet API
       * @param  context   ServletContext for information provided by
       *                   the Servlet API
       */
      public ProcessEnvironment(HttpServletRequest req,
          ServletContext context) {
          this(req, context, 0);
      }
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.
       * @param  req       HttpServletRequest for information provided by
       *                   the Servlet API
       * @param  context   ServletContext for information provided by
       *                   the Servlet API
       * @param  debug     int debug level (0 == none, 4 == medium, 6 == lots)
       */
      public ProcessEnvironment(HttpServletRequest req,
          ServletContext context, int debug) {
            this.debug = debug;
              setupFromContext(context);
              setupFromRequest(req);
              this.valid = deriveProcessEnvironment(req);
            log(this.getClass().getName() + "() ctor, debug level " + debug);
      }
  
  
      /**
       * Uses the ServletContext to set some process variables
       * @param  context   ServletContext for information provided by
       *                   the Servlet API
       */
      protected void setupFromContext(ServletContext context) {
          this.context = context;
          this.webAppRootDir = context.getRealPath("/");
      }
  
  
      /**
       * Uses the HttpServletRequest to set most process variables
       * @param  req   HttpServletRequest for information provided by
       *               the Servlet API
       */
      protected void setupFromRequest(HttpServletRequest req) {
          this.contextPath = req.getContextPath();
          this.pathInfo = req.getPathInfo();
          this.servletPath = req.getServletPath();
      }
  
  
      /**
       * Print important process environment information in an
       * easy-to-read HTML table
       * @return  HTML string containing process environment info
       */
      public String toString() {
          StringBuffer sb = new StringBuffer();
          sb.append("<TABLE border=2>");
          sb.append("<tr><th colspan=2 bgcolor=grey>");
          sb.append("ProcessEnvironment Info</th></tr>");
          sb.append("<tr><td>Debug Level</td><td>");
          sb.append(debug);
          sb.append("</td></tr>");
          sb.append("<tr><td>Validity:</td><td>");
          sb.append(isValid());
          sb.append("</td></tr>");
          if (isValid()) {
              Enumeration envk = env.keys();
              while (envk.hasMoreElements()) {
                  String s = (String)envk.nextElement();
                  sb.append("<tr><td>");
                  sb.append(s);
                  sb.append("</td><td>");
                  sb.append(blanksToString((String)env.get(s),
                      "[will be set to blank]"));
                      sb.append("</td></tr>");
              }
          }
          sb.append("<tr><td colspan=2><HR></td></tr>");
          sb.append("<tr><td>Derived Command</td><td>");
          sb.append(nullsToBlanks(command));
          sb.append("</td></tr>");
          sb.append("<tr><td>Working Directory</td><td>");
          if (workingDirectory != null) {
              sb.append(workingDirectory.toString());
          }
          sb.append("</td></tr>");
          sb.append("</TABLE><p>end.");
          return sb.toString();
      }
  
  
      /**
       * Gets derived command string
       * @return  command string
       */
      public String getCommand() {
          return command;
      }
  
  
      /**
       * Sets the desired command string
       * @param   String command as desired
       * @return  command string
       */
      protected String setCommand(String command) {
          return command;
      }
  
  
      /**
       * Gets this process' derived working directory
       * @return  working directory
       */
      public File getWorkingDirectory() {
          return workingDirectory;
      }
  
  
      /**
       * Gets process' environment
       * @return   process' environment
       */
      public Hashtable getEnvironment() {
          return env;
      }
  
  
      /**
       * Sets process' environment
       * @param    process' environment
       * @return   Hashtable to which the process' environment was set
       */
      public Hashtable setEnvironment(Hashtable env) {
          this.env = env;
          return this.env;
      }
  
  
      /**
       * Gets validity status
       * @return   true if this environment is valid, false otherwise
       */
      public boolean isValid() {
          return valid;
      }
  
  
      /**
       * Converts null strings to blank strings ("")
       * @param    string to be converted if necessary
       * @return   a non-null string, either the original or the empty string
       *           ("") if the original was <code>null</code>
       */
      protected String nullsToBlanks(String s) {
          return nullsToString(s, "");
      }
  
  
      /**
       * Converts null strings to another string
       * @param    string to be converted if necessary
       * @param    string to return instead of a null string
       * @return   a non-null string, either the original or the substitute
       *           string if the original was <code>null</code>
       */
      protected String nullsToString(String couldBeNull, String subForNulls) {
          return (couldBeNull == null ? subForNulls : couldBeNull);
      }
  
  
      /**
       * Converts blank strings to another string
       * @param    string to be converted if necessary
       * @param    string to return instead of a blank string
       * @return   a non-null string, either the original or the substitute
       *           string if the original was <code>null</code> or empty ("")
       */
      protected String blanksToString(String couldBeBlank,
          String subForBlanks) {
              return (("".equals(couldBeBlank) || couldBeBlank == null) ?
                  subForBlanks : couldBeBlank);
      }
  
  
      protected void log(String s) {
          System.out.println(s);
      }
  
  
      /**
       * Constructs the Process environment to be supplied to the invoked
       * process.  Defines an environment no environment variables.
       * <p>
       * Should be overriden by subclasses to perform useful setup.
       * </p>
       *
       * @param    HttpServletRequest request associated with the
       *           Process' invocation
       * @return   true if environment was set OK, false if there was a problem
       *           and no environment was set
       */
      protected boolean deriveProcessEnvironment(HttpServletRequest req) {
  
          Hashtable envp = new Hashtable();
          command = getCommand();
          if (command != null) {
              workingDirectory = new
                  File(command.substring(0,
                  command.lastIndexOf(File.separator)));
                  envp.put("X_TOMCAT_COMMAND_PATH", command); //for kicks
          }
          this.env = envp;
          return true;
      }
  
  
      /**
       * Gets the root directory of the web application to which this process\
       * belongs
       * @return  root directory
       */
      public String getWebAppRootDir() {
          return webAppRootDir;
      }
  
  
      public String getContextPath(){
              return contextPath;
          }
  
  
      public ServletContext getContext(){
              return context;
          }
  
  
      public String getServletPath(){
              return servletPath;
          }
  }
  
  
  
  1.1                  
jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/CGIProcessEnvironment.java
  
  Index: CGIProcessEnvironment.java
  ===================================================================
  /*
  * CGIProcessEnvironment.java $Header: 
/home/cvs/jakarta-tomcat-4.0/catalina/src/share/org/apache/catalina/util/CGIProcessEnvironment.java,v
 1.1 2001/06/01 00:21:15 amyroh Exp $
  * $Revision: 1.1 $, $Date: 2001/06/01 00:21:15 $
  *
  * ====================================================================
  *
  * The Apache Software License, Version 1.1
  *
  * Copyright (c) 1999 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution, if
  *    any, must include the following acknowlegement:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowlegement may appear in the software itself,
  *    if and wherever such third-party acknowlegements normally appear.
  *
  * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
  *    Foundation" must not be used to endorse or promote products derived
  *    from this software without prior written permission. For written
  *    permission, please contact [EMAIL PROTECTED]
  *
  * 5. Products derived from this software may not be called "Apache"
  *    nor may "Apache" appear in their names without prior written
  *    permission of the Apache Group.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  *
  *
  */
  
  
  package org.apache.catalina.util;
  
  import java.lang.Process;
  import java.io.File;
  import java.io.Writer;
  import java.io.Reader;
  import java.io.PrintWriter;
  import java.io.BufferedWriter;
  import java.io.BufferedReader;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.IOException;
  import java.net.URLEncoder;
  import java.util.Hashtable;
  import java.util.Vector;
  import java.util.Enumeration;
  import java.util.StringTokenizer;
  import java.util.Locale;
  import java.util.Date;
  import javax.servlet.ServletException;
  import javax.servlet.ServletOutputStream;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletConfig;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.Cookie;
  import org.apache.catalina.Context;
  import org.apache.catalina.Wrapper;
  
  
  
  // import org.apache.catalina.util.StringManager;
  
  
  
  /**
   * Encapsulates the CGI Process' environment and rules to derive
   * that environment from the servlet container and request information.
   * @author   Martin Dengler [[EMAIL PROTECTED]]
   * @version  $Revision: 1.1 $, $Date: 2001/06/01 00:21:15 $
   * @since    Tomcat 4.0
   */
  
  public class CGIProcessEnvironment extends ProcessEnvironment {
  
  
  
      /** cgi command's query parameters */
      private Hashtable queryParameters = null;
  
      /**
       *  The CGI search path will start at
       *    webAppRootDir + File.separator + cgiPathPrefix
       *    (or webAppRootDir alone if cgiPathPrefix is
       *    null)
       */
      private String cgiPathPrefix = null;
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.  The cgi path prefix is initialized
       * to "" (the empty string).
       *
       * @param  req       HttpServletRequest for information provided by
       *                   the Servlet API
       * @param  context   ServletContext for information provided by
       *                   the Servlet API
       */
      public CGIProcessEnvironment(HttpServletRequest req,
          ServletContext context) {
              this(req, context, "");
      }
  
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.
       * @param req             HttpServletRequest for information provided by
       *                        the Servlet API
       * @param context         ServletContext for information provided by
       *                        the Servlet API
       * @param cgiPathPrefix   subdirectory of webAppRootDir below which the
       *                        web app's CGIs may be stored; can be null or "".
       */
      public CGIProcessEnvironment(HttpServletRequest req,
          ServletContext context, String cgiPathPrefix) {
              this(req, context, cgiPathPrefix, 0);
      }
  
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.
       * @param req             HttpServletRequest for information provided by
       *                        the Servlet API
       * @param context         ServletContext for information provided by
       *                        the Servlet API
       * @param  debug          int debug level (0 == none, 6 == lots)
       */
      public CGIProcessEnvironment(HttpServletRequest req,
          ServletContext context, int debug) {
              this(req, context, "", 0);
      }
  
  
  
  
      /**
       * Creates a ProcessEnvironment and derives the necessary environment,
       * working directory, command, etc.
       * @param req             HttpServletRequest for information provided by
       *                        the Servlet API
       * @param context         ServletContext for information provided by
       *                        the Servlet API
       * @param cgiPathPrefix   subdirectory of webAppRootDir below which the
       *                        web app's CGIs may be stored; can be null or "".
       * @param  debug          int debug level (0 == none, 6 == lots)
       */
      public CGIProcessEnvironment(HttpServletRequest req,
          ServletContext context, String cgiPathPrefix, int debug) {
              super(req, context, debug);
              this.cgiPathPrefix = cgiPathPrefix;
              queryParameters = new Hashtable();
              Enumeration paramNames = req.getParameterNames();
              while (paramNames != null && paramNames.hasMoreElements()) {
                  String param = paramNames.nextElement().toString();
                  if (param != null) {
                      queryParameters.put(param,
                          URLEncoder.encode(req.getParameter(param)));
                  }
              }
              this.valid = deriveProcessEnvironment(req);
      }
  
  
  
      /**
       * Constructs the CGI environment to be supplied to the invoked CGI
       * script; relies heavliy on Servlet API methods and findCGI
       * @param    HttpServletRequest request associated with the CGI invokation
       * @return   true if environment was set OK, false if there was a problem
       *           and no environment was set
       */
      protected boolean deriveProcessEnvironment(HttpServletRequest req) {
          /*
           * This method is slightly ugly; c'est la vie.
           * "You cannot stop [ugliness], you can only hope to contain [it]"
           * (apologies to Marv Albert regarding MJ)
           */
  
          Hashtable envp;
          super.deriveProcessEnvironment(req);
          envp = getEnvironment();
  
          String sPathInfoOrig = null;
          String sPathTranslatedOrig = null;
          String sPathInfoCGI = null;
          String sPathTranslatedCGI = null;
          String sCGIFullPath = null;
          String sCGIScriptName = null;
          String sCGIFullName = null;
          String sCGIName = null;
          String[] sCGINames;
          sPathInfoOrig = this.pathInfo;
          sPathInfoOrig = sPathInfoOrig == null ? "" : sPathInfoOrig;
          sPathTranslatedOrig = req.getPathTranslated();
          sPathTranslatedOrig = sPathTranslatedOrig == null ? "" :
              sPathTranslatedOrig;
              sCGINames =
                  findCGI(sPathInfoOrig, getWebAppRootDir(), getContextPath(),
                  getServletPath(), cgiPathPrefix);
          sCGIFullPath = sCGINames[0];
          sCGIScriptName = sCGINames[1];
          sCGIFullName = sCGINames[2];
          sCGIName = sCGINames[3];
          if (sCGIFullPath == null || sCGIScriptName == null
              || sCGIFullName == null || sCGIName == null) {
                  return false;
          }
          envp.put("SERVER_SOFTWARE", "TOMCAT");
          envp.put("SERVER_NAME", nullsToBlanks(req.getServerName()));
          envp.put("GATEWAY_INTERFACE", "CGI/1.1");
          envp.put("SERVER_PROTOCOL", nullsToBlanks(req.getProtocol()));
          int port = req.getServerPort();
          Integer iPort = (port == 0 ? new Integer(-1) : new Integer(port));
          envp.put("SERVER_PORT", iPort.toString());
          envp.put("REQUEST_METHOD", nullsToBlanks(req.getMethod()));
  
          /*-
          * PATH_INFO should be determined by using sCGIFullName:
          * 1) Let sCGIFullName not end in a "/" (see method findCGI)
          * 2) Let sCGIFullName equal the pathInfo fragment which
          *    corresponds to the actual cgi script.
          * 3) Thus, PATH_INFO = request.getPathInfo().substring(
          *                      sCGIFullName.length())
          *
          * (see method findCGI, where the real work is done)
          *
          */
  
          if (pathInfo == null ||
              (pathInfo.substring(sCGIFullName.length()).length() <= 0)) {
                  sPathInfoCGI = "";
          } else {
              sPathInfoCGI = pathInfo.substring(sCGIFullName.length());
          }
          envp.put("PATH_INFO", sPathInfoCGI);
  
          /*-
          * PATH_TRANSLATED must be determined after PATH_INFO (and the
          * implied real cgi-script) has been taken into account.
          *
          * The following example demonstrates:
          *
          * servlet info   = /servlet/cgigw/dir1/dir2/cgi1/trans1/trans2
          * cgifullpath    = /servlet/cgigw/dir1/dir2/cgi1
          * path_info      = /trans1/trans2
          * webAppRootDir  = servletContext.getRealPath("/")
          *
          * path_translated = servletContext.getRealPath("/trans1/trans2")
          *
          * That is, PATH_TRANSLATED = webAppRootDir + sPathInfoCGI
          * (unless sPathInfoCGI is null or blank, then the CGI
          * specification dictates that the PATH_TRANSLATED metavariable
          * SHOULD NOT be defined.
          *
          */
  
          if (sPathInfoCGI != null && !("".equals(sPathInfoCGI))) {
              sPathTranslatedCGI = getContext().getRealPath(sPathInfoCGI);
          } else {
              sPathTranslatedCGI = null;
          }
          if (sPathTranslatedCGI == null || "".equals(sPathTranslatedCGI)) {
              //NOOP
          } else {
              envp.put("PATH_TRANSLATED", nullsToBlanks(sPathTranslatedCGI));
          }
          envp.put("SCRIPT_NAME", nullsToBlanks(sCGIScriptName));
          envp.put("QUERY_STRING", nullsToBlanks(req.getQueryString()));
          envp.put("REMOTE_HOST", nullsToBlanks(req.getRemoteHost()));
          envp.put("REMOTE_ADDR", nullsToBlanks(req.getRemoteAddr()));
          envp.put("AUTH_TYPE", nullsToBlanks(req.getAuthType()));
          envp.put("REMOTE_USER", nullsToBlanks(req.getRemoteUser()));
          envp.put("REMOTE_IDENT", ""); //not necessary for full compliance
          envp.put("CONTENT_TYPE", nullsToBlanks(req.getContentType()));
  
          /* Note CGI spec says CONTENT_LENGTH must be NULL ("") or undefined
          * if there is no content, so we cannot put 0 or -1 in as per the
          * Servlet API spec.
          */
  
          int contentLength = req.getContentLength();
          String sContentLength = (contentLength <= 0 ? "" : (
              new Integer(contentLength)).toString());
          envp.put("CONTENT_LENGTH", sContentLength);
          Enumeration headers = req.getHeaderNames();
          String header = null;
          while (headers.hasMoreElements()) {
              header = null;
              header = ((String)headers.nextElement()).toUpperCase();
              //REMIND: rewrite multiple headers as if received as single
              //REMIND: change character set
              //REMIND: I forgot what the previous REMIND means
              if ("AUTHORIZATION".equalsIgnoreCase(header)
                  || "PROXY_AUTHORIZATION".equalsIgnoreCase(header)) {
                      //NOOP per CGI specification section 11.2
              } else if ("HOST".equalsIgnoreCase(header)) {
                  String host = req.getHeader(header);
                  envp.put("HTTP_" + header.replace('-', '_'),
                      host.substring(0, host.indexOf(":")));
              } else {
                  envp.put("HTTP_" + header.replace('-', '_'),
                      req.getHeader(header));
              }
          }
          command = sCGIFullPath;
          workingDirectory = new File(command.substring(0,
              command.lastIndexOf(File.separator)));
          envp.put("X_TOMCAT_COMMAND_PATH", command); //for kicks
          this.setEnvironment(envp);
          return true;
      }
  
  
      /**
       * Resolves core information about the cgi script. <p> Example URI:
       * <PRE> /servlet/cgigateway/dir1/realCGIscript/pathinfo1 </PRE> <ul>
       * <LI><b>path</b> = $TOMCAT_HOME/mywebapp/dir1/realCGIscript
       * <LI><b>scriptName</b> = /servlet/cgigateway/dir1/realCGIscript</LI>
       * <LI><b>cgiName</b> = /dir1/realCGIscript
       * <LI><b>name</b> = realCGIscript
       * </ul>
       * </p>
       * <p>
       * CGI search algorithm: search the real path below
       * &lt;my-webapp-root&gt; and find the first non-directory in
       * the getPathTranslated("/"), reading/searching from left-to-right.
       * </p>
       * <p>
       * The CGI search path will start at
       * webAppRootDir + File.separator + cgiPathPrefix (or webAppRootDir
       * alone if cgiPathPrefix is null).
       * </p>
       * <p>
       * cgiPathPrefix is usually set by the calling servlet to the servlet's
       * cgiPathPrefix init parameter
       * </p>
       *
       * @param pathInfo       String from HttpServletRequest.getPathInfo()
       * @param webAppRootDir  String from context.getRealPath("/")
       * @param contextPath    String as from HttpServletRequest.getContextPath()
       * @param servletPath    String as from HttpServletRequest.getServletPath()
       * @param cgiPathPrefix  subdirectory of webAppRootDir below which the
       *                       web app's CGIs may be stored; can be null.
       * @return
       * <ul> <li> <code>path</code>  -    full file-system path to valid cgi
       *                                   script, or null if no cgi was found
       * <li> <code>scriptName</code> -    CGI variable SCRIPT_NAME; the full
       *                                   URL path to valid cgi script or
       *                                   null if no cgi was found
       * <li> <code>cgiName</code>    -    servlet pathInfo fragment
       *                                   corresponding to the cgi script
       *                                   itself, or null if not found
       * <li> <code>name</code>       -    simple name (no directories) of
       *                                   the cgi script, or null if no cgi
       *                                   was found
       * </ul>
       * @author Martin Dengler [[EMAIL PROTECTED]]
       * @since Tomcat 4.0
       */
      protected String[] findCGI(String pathInfo, String webAppRootDir,
          String contextPath, String servletPath, String cgiPathPrefix) {
              String path = null;
              String name = null;
              String scriptname = null;
              String cginame = null;
              if ((webAppRootDir != null)
                  && (webAppRootDir.lastIndexOf("/")
                  == (webAppRootDir.length() - 1))) {
                      //strip the trailing "/" from the webAppRootDir
                      webAppRootDir =
                          webAppRootDir.substring(0,
                          (webAppRootDir.length() - 1));
              }
              if (cgiPathPrefix != null) {
                  webAppRootDir = webAppRootDir + File.separator
                      + cgiPathPrefix;
              }
              if (debug >= 2) {
                  log("findCGI: start = [" + webAppRootDir 
                    + "], pathInfo = [" + pathInfo + "] ");
              }
              File currentLocation = new File(webAppRootDir);
              StringTokenizer dirWalker = new StringTokenizer(pathInfo, "/");
              while (!currentLocation.isFile() && dirWalker.hasMoreElements()) {
                  currentLocation = new
                      File(currentLocation, (String) dirWalker.nextElement());
                  if (debug >= 3) {
                      log("findCGI: traversing to [" + currentLocation + "]");
                  }
              }
              if (!currentLocation.isFile()) {
                  return new String[] { null, null, null, null };
              } else {
                  if (debug >= 2) {
                      log("findCGI: FOUND cgi at [" + currentLocation + "]");
                  }
                  path = currentLocation.getAbsolutePath();
                  name = currentLocation.getName();
                  cginame = currentLocation.getParent()
                      .substring(webAppRootDir.length())
                      + File.separator + name;
                      if (".".equals(contextPath)) {
                          scriptname = servletPath + cginame;
                  } else {
                      scriptname = contextPath + servletPath + cginame;
                  }
              }
              if (debug >= 1) {
                  log("findCGI calc: name=" + name + ", path=" + path
                      + ", scriptname=" + scriptname + ", cginame=" + cginame);
              }
              return new String[] { path, scriptname, cginame, name };
      }
  
  
      /**
       * Print important CGI environment information in an
       * easy-to-read HTML table
       * @return  HTML string containing CGI environment info
       */
      public String toString() {
          StringBuffer sb = new StringBuffer();
          sb.append("<TABLE border=2>");
          sb.append("<tr><th colspan=2 bgcolor=grey>");
          sb.append("ProcessEnvironment Info</th></tr>");
          sb.append("<tr><td>Debug Level</td><td>");
          sb.append(debug);
          sb.append("</td></tr>");
          sb.append("<tr><td>Validity:</td><td>");
          sb.append(isValid());
          sb.append("</td></tr>");
          if (isValid()) {
              Enumeration envk = env.keys();
              while (envk.hasMoreElements()) {
                  String s = (String)envk.nextElement();
                  sb.append("<tr><td>");
                  sb.append(s);
                  sb.append("</td><td>");
                  sb.append(blanksToString((String)env.get(s),
                      "[will be set to blank]"));
                      sb.append("</td></tr>");
              }
          }
          sb.append("<tr><td colspan=2><HR></td></tr>");
          sb.append("<tr><td>Derived Command</td><td>");
          sb.append(nullsToBlanks(command));
          sb.append("</td></tr>");
          sb.append("<tr><td>Working Directory</td><td>");
          if (workingDirectory != null) {
              sb.append(workingDirectory.toString());
          }
          sb.append("</td></tr>");
          sb.append("<tr><td colspan=2>Query Params</td></tr>");
          Enumeration paramk = queryParameters.keys();
          while (paramk.hasMoreElements()) {
              String s = paramk.nextElement().toString();
              sb.append("<tr><td>");
              sb.append(s);
              sb.append("</td><td>");
              sb.append(queryParameters.get(s).toString());
              sb.append("</td></tr>");
          }
  
          sb.append("</TABLE><p>end.");
          return sb.toString();
      }
  
  
      /**
       * Gets process' derived query parameters
       * @return   process' query parameters
       */
      public Hashtable getParameters() {
          return queryParameters;
      }
  
  }
  
  
  

Reply via email to