* @todo We need to clearly say that we are out of threads when we are out of threads.

*/

// We keep open buffers and streams that write and read from them

// We keep active processes

//

// Writing/reading operations may not be implemented ideally in the current implementation

// There should probably be a BufferObjectReader/BufferObjectWriter in between . We should create it on demand and store it in Process.extra

// for bytes [] we would use BufferInputStream/BufferOutputStream

//

// There can be multiple RemoteShellImpl instances using the same ShellImpl object, so

// concurrent calls can be made on close(), read(), write() methods

//

// The result may be some other concurrent calls on this object.

//

  private String uid;

  private boolean interactive;

  private UserCtx uctx;

  private SystemShellImpl sshell;

  private VFS vfs;

  //private Cache cache;

  private Context ctx;

  private Process active = null;

  private Buffer shellout;

  private MultiBufferObjectReader outreader;

//  private int STD_BUF_SIZE=5;  // should be read from some ENV var.

  private static final String EVENT_SOURCE = "ShellImpl";

  private static final String EVENT_CLASS = "Shell";

  public static final long SESS_TIMEOUT = 1800000L;    // 30 min       //36000000L;  // 10 hrs

  public static final long PROC_TIMEOUT = 1200000L;    // 20 mins

  public static final long BUFFER_TIMEOUT = 1200000L;    // 20 mins

  public static final String STDINPROC_ID = "-1";

  public static final String STDIN_ID = "0";

  // Buffer limits

  public static final int BUF_MAX_SIZE = 10;  // should be read from some environment variable ... no executable can have it's setting for in or out greater than this

  public static final int IN_BUF_SIZE = 5, OUT_BUF_SIZE = 5; // test case only, should be determined by exe specific info

  // Timeout limits

  public static final long PROC_TIMEOUT_MAX = 300000L; // 5 min - should be read from some global variable ... no executable can have it's setting greater - meaning if non-zero value specified, no zero allowed on individual ...

  public static final long PROC_INST_TIMEOUT = 150000L; // test case only, should be determined by exe specific info

  // we could save this setting in a wrapped around stream/writer/reader

  // or we could save this satting with the process...

  private ShellRuntime runtime;

   private ExecutableRegistry registry;

  //private HashMap procmap=new HashMap();

  private Map procmap = Collections.synchronizedMap(new HashMap());

  private long startTime;

  private long lastUsed;

  private boolean closed = false;

    private long closureTime;

    private String closureReason;

    private static final Logger log = Logger.getLogger("org.jboss.fresh.shell.impl.ShellImpl");

  private static final Logger cmdlog = Logger.getLogger("org.jboss.fresh.shell.impl.ShellImpl.CMD");

  private EventBroadcaster eb;

  private EventCentral ec;

  private EnvProperties props = new EnvProperties();

    SimpleDateFormat sdf_date = new SimpleDateFormat("yyyy-MM-dd");

  SimpleDateFormat sdf_time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    SimpleDateFormat sdf_time_millis = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    private static ThreadLocal preparedProcess = new ThreadLocal();

   

  // SysShell assigned shell session id

  public ShellImpl(String id, boolean interactive, SystemShellImpl sysshell, UserCtx uctx, VFS vfs) {

    this.interactive = interactive;

    uid = id;

    this.uctx = uctx;

    sshell = sysshell;

    this.vfs = vfs;

    props = new EnvProperties(System.getProperties());

    // I don't really see when shellin would be of any use.

    //shellin=new BufferImpl();

    //shellin.setMaxSize(STD_BUF_SIZE);

    if (interactive) {

      ProcessGroup stdproc = new ProcessGroup(STDINPROC_ID, null, null);

      shellout = new BufferImpl();

      // CAREFUL HERE: If you print too much to out at the very beginning - in terms of objects

      // you will deadlock

      //shellout.setMaxSize(1);

      shellout.setMaxSize(20);

      stdproc.setOutputBuffer(shellout);

      stdproc.setIOTimeout(PROC_INST_TIMEOUT);

      procmap.put(STDINPROC_ID, stdproc);

      outreader = new MultiBufferObjectReader(null, shellout);

    }

    runtime = new ShellRuntime(this, interactive);

    runtime.setOutBuffer(shellout);

    // we need user, we need to set pwd

    String home = "/home/mare";

    props.setProperty("PWD", home);

    runtime.setPWD(home);

    props.setProperty("SystemShell.startTime", new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(sshell.getStartTime()));

    // we had to set path first. Without it exes run without FileInfo in the init() phase.

    runtime.init(shellout);

    runtime.started();

    runtime.prompt();

    startTime = System.currentTimeMillis();

  }

   public void setRegistry(ExecutableRegistry registry)

   {

      if (registry != null)

      {

         runtime.setRegistry(registry);

      }

   }

   private EventBroadcaster getEventBroadcaster() {

    Context ctx = getContext();

    EventCentral evc = (EventCentral) ctx.get("EventCentral");

    if (evc == ec) {

      return eb;

    }

    synchronized(this) {

      if (evc == ec) {

        return eb;

      }

      if(evc == null) {

        // we cause unregister event

        if (eb != null) {

          eb.close();

        }

        eb = null;

        ec = null;

        return null;

      }

      String compid = null;

      if(eb!=null) {

        // we don't cause unregister event - just another register event

        compid = eb.getComponentID();

        eb.close();

        eb = new ShellEventBroadcaster(evc, this, EVENT_SOURCE, eb.getComponentID());

      } else {

        eb = new ShellEventBroadcaster(evc, this, EVENT_SOURCE);

      }

      ec = evc;

    }

    return eb;

  }

  public void setVFS(VFS vfs) {

    this.vfs = vfs;

  }

  public String getSessionID() {

    return uid;

  }

  public Process getProcess(Object id) {

    return (Process) procmap.get(id);

  }

  public SystemShell getSystemShell() {

    return sshell;

  }

  public String getClientInfo() throws ShellException {

    String cuser = _getEnvProperty("cp2.client.user");

    String capp = _getEnvProperty("cp2.client.app");

    String chost = _getEnvProperty("cp2.client.host");

    if (cuser == null) {

      cuser = "cuser_unknown";

    }

    if (chost == null) {

      chost = "chost_unknown";

    }

    if (capp == null) {

      capp = "capp_unknown";

    }

    return cuser + "@" + chost + " [" + capp + "] ";

  }

  public String getClientAndProjectInfo() throws ShellException {

    String cuser = _getEnvProperty("cp2.client.user");

    String capp = _getEnvProperty("cp2.client.app");

    String chost = _getEnvProperty("cp2.client.host");

    if (cuser == null) {

      cuser = "cuser_unknown";

    }

    if (chost == null) {

      chost = "chost_unknown";

    }

    if (capp == null) {

      capp = "capp_unknown";

    }

    String project = _getEnvProperty("PROJECT");

    if (project == null) {

      project = "";

    }

    return cuser + "@" + chost + " [" + capp + "] [" + project + "] ";

  }

  public ProcessInfo execute(String cmdline) throws ShellException {

    preStartTimeoutCheck();

    return _execute(cmdline, true, true, false);

  }

  public ProcessInfo prepareExecution(String cmdline) throws ShellException {

    preStartTimeoutCheck();

    return _execute(cmdline, null, true, true, false, true);

  }

  public ProcessInfo execute(String cmdline, List input) throws ShellException {

    preStartTimeoutCheck();

    return _execute(cmdline, input, true, true, false, false);

  }

  public ProcessInfo _execute(String cmdline) throws ShellException {

    return _execute(cmdline, true, true, false);

  }

  public ProcessInfo execute(String cmdline, boolean ui) throws ShellException {

    preStartTimeoutCheck();

    return _execute(cmdline, true, true, ui);

  }

  public ProcessInfo execute(String cmdline, List input, boolean ui) throws ShellException {

    preStartTimeoutCheck();

    return _execute(cmdline, input, true, true, ui, false);

  }

  public ProcessInfo _execute(String cmdline, boolean ui) throws ShellException {

    return _execute(cmdline, true, true, ui);

  }

  public ProcessInfo execute(String cmdline, boolean hasin, boolean hasout) throws ShellException {

    return _execute(cmdline, hasin, hasout, false);

  }

  public ProcessInfo execute(String cmdline, boolean hasin, boolean hasout, boolean ui) throws ShellException {

    return _execute(cmdline, hasin, hasout, ui);

  }

  public ProcessInfo _execute(String cmdline, boolean hasin, boolean hasout, boolean ui) throws ShellException {

    return _execute(cmdline, null, hasin, hasout, ui, false);

  }

 

  public ProcessInfo _execute(String cmdline, List input, boolean hasin, boolean hasout, boolean ui, boolean prepareOnly) throws ShellException {

    try {

            preStartTimeoutCheck();

            if (cmdline == null || cmdline.length() == 0) {

        runtime.prompt();

        return null;

      }

            cmdline = convertCharset(cmdline);

            if (cmdline.equals("exit")) {

                closureReason = "Client issued 'exit'";

                close();

        return null;

      } else if(cmdline.equals("tsingle")) {

        _setEnvProperty("TMODE", "SINGLE");

        return null;

      } else if(cmdline.equals("tmulti")) {

        _setEnvProperty("TMODE", null);

        return null;

      }

            String [] lines = cutInput(cmdline);

            cmdline = lines[0];

           

      cmdline = cmdline.trim();

      String cuser = _getEnvProperty("cp2.client.user");

      String chost = _getEnvProperty("cp2.client.host");

      String capp = null;

      String project = _getEnvProperty("PROJECT");

      if (project == null) {

        project = "";

      }

      if(cuser != null || chost != null) {

        capp = _getEnvProperty("cp2.client.app");

        if (cuser == null) {

          cuser = "cuser_unknown";

        }

        if (chost == null) {

          chost = "chost_unknown";

        }

        if (capp == null) {

          capp = "capp_unknown";

        }

        cmdlog.info(cuser + "@" + chost + " [" + capp + "] [" + project + "] " + cmdline);

      } else {

        cmdlog.info("[" + project + "] " + cmdline);

      }

      HistoryItem hi = addHistory(_getEnvProperty("PROJECT"), cuser, capp, chost, cmdline);

            cmdline = StringUtils.unescapeJavaX(cmdline);

            cmdline = runtime.unaliasCmdLine(cmdline);

            ShellCmdParser parser = new ShellCmdParser(cmdline);

      LinkedList job = new LinkedList();

      CmdLines cmdLines = parser.parse();

      cmdLines = resolveVars(cmdLines);

      cmdLines.setStdInLines(lines[1]);

      cmdLines.setStdInput(input);

     

      Iterator it = cmdLines.iterator();

      while (it.hasNext()) {

        Cmd cmd = (Cmd) it.next();

        makeProcess(cmdLines, cmd, job, hasin, hasout, ui);

      }

      if (job.size() > 1) {

        ProcessGroup p = sshell.createProcessGroup(job);

        if (p == null) {

          throw new ShellException("[ShellImpl][execute] Failed to create ProcessGroup.");

        }

        InBuffer ib = ((Process) job.getFirst()).getInputBuffer();

        OutBuffer ob = ((Process) job.getLast()).getOutputBuffer();

        p.setRedirected(((Process) job.getLast()).isRedirected());

//log.debug("PRocessGroup ob: " + ob);

        p.setInputBuffer(ib);

        p.setOutputBuffer(ob);

        p.setCommandLine(cmdline);

        if (active == null) {

          active = p;

        }

//        outreader.replacePrimaryBuffer(ob);

//      }

        procmap.put(p.getID(), p);

        p.setUserInitiated(ui);

        hi.setProcessID(p.getID());

                // We don't use it anywhere - WRONG - we use it when NoProcessForID Exceptions occur

                LinkedList chs = hi.getChildren();

        LinkedList ls = p.getProcessList();

        it = ls.iterator();

        while(it.hasNext()) {

          Process cp = (Process) it.next();

          chs.add(cp);

        }

        if (!prepareOnly) {

          p.start(); // We have a problem with concurrent modification on job

        } else {

          preparedProcess.set(p);

        }

       

        ProcessInfo pinfo = new ProcessInfo();

        pinfo.procid = p.getID();

        pinfo.inbuf_maxsize = ib.getMaxSize();

        pinfo.outbuf_maxsize = ob.getMaxSize();

        return pinfo;

      } else {

        Process p = (Process) job.getFirst();

        InBuffer ib = p.getInputBuffer();

        OutBuffer ob = p.getOutputBuffer();

//log.debug("PRocess ob: " + ob);

        if (active == null) {

          active = p;

        }

//        outreader.replacePrimaryBuffer(ob);

//      }

//      System.out.println("ACTIVE SET: " + active);

        procmap.put(p.getID(), p);

        log.debug("Created process " + p.getID());

        p.setUserInitiated(ui);

        hi.setProcessID(p.getID());

        hi.getChildren().add(p);

        if (!prepareOnly) {

          p.start();

        } else {

          preparedProcess.set(p);

        }

       

        ProcessInfo pinfo = new ProcessInfo();

        pinfo.procid = p.getID();

        pinfo.inbuf_maxsize = ib.getMaxSize();

        pinfo.outbuf_maxsize = ob.getMaxSize();

        return pinfo;

      }

    } catch (SessionTimeoutException ex) {

            throw new SessionTimeoutException("Exception executing: " + cmdline + " - " + ex.getMessage());

        } catch (ParseException ex) {

      log.error("Exception occured during parsing of the command line!", ex);

      throw new ShellException("Exception occured during parsing of the command line!", ex, cmdline);

    }

    // now we have several processes in the job list.

    // we still need to run them all.

    // If

    // we need to interpret the command line

    // that is - we need to parse it

    // first command can be an internal command like cd

    // or it can be an executable

    // If not internal command:

    // we need to determine if executable with the specified name exists

    // executable name is a relative name or an absolute name

    // if absolute name we resolve it relative to all components of the PATH

    // until we find the first one that matches the pattern.

    // It's clear that we need VFS to be able to give us the list of all executables in the specified directory.

    //

    // (For starters we can put them all in the /bin directory and expect only name.)

    //

    // When we locate an executable, we need to allocate stdin and stdout Buffers for it.

    // Then we need to set ENV to it

    // We need to allocate a Process

    // We then put the Process in the process map allocating an uid along the way.

    // We then start a process and return an uid to the process.

    // --------------------

    // Let's just run an executable

    // ok, we associate it with the exepath, we set user

    // we allocate in/out buffers

    // we set Buffers on the exe

    // we store it in the Process

    // we store the process in our process map

    // we run the process/executable

    // we return process id. (process id is what? shouldn't SystemShell create a process for us?)

    // (If we create processes ourselves then there is no way to go to one central place and say

    // kill process number 10. Which is a process started by some user in his shell.)

    // To have this sort of control, we need the central to have access to the Process and say kill

    // on it.

  }

  /**

   * To be used in conjunction with prepareExecution

   * @throws ShellException

   */

  public void completeExecution() throws ShellException {

    preStartTimeoutCheck();

    //System.out.println("        completeExecution 1");

    Process p = (Process) preparedProcess.get();

    //System.out.println("        completeExecution 2    p == " + p);

    if(p == null) {

      //new Exception("No prepared process found").printStackTrace();

      throw new ShellException("No prepared process found - was prepareExecution() called in this thread?");

    }

    //System.out.println("        completeExecution 3");

    preparedProcess.remove();

    p.start();

  }

 

    private String[] cutInput(String cmdline) {

      int idx = cmdline.indexOf("\n");

     

      if(idx != -1) {

          int e1 = idx;

        for(int i=idx-1; i>=0; i--) {

          char c = cmdline.charAt(i);

          if(c != '\r') {

            e1 = i+1;

            break;

          }

        }

        return new String[] {cmdline.substring(0, e1), (idx == cmdline.length()-1) ? "" : cmdline.substring(idx+1)};

      }

     

      return new String[] {cmdline, null};

  }

  private String convertCharset(String cmdline) throws ShellException {

        // check environment settings

        String enc = getEnvProperty("TERMINAL_ENC");

    if (enc == null) {

      return cmdline;

    }

        try {

            return new String(new String(cmdline).getBytes("ISO8859_1"), enc);

        } catch(IOException ex) {

            setEnvProperty("TERMINAL_ENC_ERROR", "Unsupported charset: " + enc);

        }

        return cmdline;

    }

    public HistoryItem addHistory(String project, String cuser, String capp, String chost, String cmdline) {

        HistoryItem hitem = new HistoryItem(project, cuser, capp, chost, cmdline);

        History h = (History) ctx.get("History");

        if(h == null) {

            h = new History();

            ctx.put("History", h);

        }

        h.add(hitem);

        Context actx = (Context) ctx.get("AppContext");

        if(actx == null) {

            log.debug("AppContext not available");

        } else {

            h = (History) actx.get("History");

            if(h == null) {

                h = new History();

                actx.put("History", h);

            }

            h.add(hitem);

        }

        // would be nice to have a wrapper that returns null and throws no exceptions

        try {

            actx = (Context) new RegistryContext().lookup("java:/FRESH/GlobalContext");

        } catch(Exception ex) {

        }

        if(actx == null) {

            log.debug("GlobalContext not available");

        } else {

            h = (History) actx.get("History");

            if(h == null) {

                h = new History();

                actx.put("History", h);

            }

            h.add(hitem);

        }

        return hitem;

    }

  public HistoryItem getHistoryItem(String id) {

    HistoryItem ti = null;

    Context c = ctx;

    for(int i=0; i<3; i++) {

          HashMap map = new HashMap();

          c.loadMappings(map);

          java.util.TreeMap sm = new java.util.TreeMap(map);

          Iterator it0 = sm.entrySet().iterator();

          while (it0.hasNext()) {

            Map.Entry ent = (Map.Entry) it0.next();

            log.info(ent.getKey() + "\t=\t" + ent.getValue() + "\t" + ent.getValue().getClass().getName());

          }

      History h = (History) c.get("History");

      Iterator it = h.list().iterator();

      while(it.hasNext()) {

        HistoryItem hi = (HistoryItem) it.next();

        log.info("compare: " + hi.getProcessID() + "  vs. " + id);

        if(hi.getProcessID().equals(id)) {

          ti = hi;

          break;

          //Iterator it2 = hi.getChildren().iterator;

          //while(it2.hasNext()) {

          //  Process p = (Process) it.next();

          //}

        }

      }

      if(ti == null) {

        if(i==0) {

          c = (Context) ctx.get("AppContext");

          if(c == null) {

            try {

              c = (Context) new RegistryContext().lookup("java:/FRESH/GlobalContext");

            } catch(Exception ex) {}

            i++;

          }

        } else if(i==1) {

          try {

            c = (Context) new RegistryContext().lookup("java:/FRESH/GlobalContext");

          } catch(Exception ex) {}

          if (c == null) {

            i++;

          }

        }

      }

    }

    return ti;

  }

  public ProcessInfo execute(Executable exe, String exepath, String[] params) throws ShellException {

        try {

            preStartTimeoutCheck();

        } catch(SessionTimeoutException ex) {

            StringBuffer sb = new StringBuffer(exepath);

            if(params != null) {

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

                    sb.append(" \'").append(params[i]).append('\'');

                }

            }

            throw new SessionTimeoutException("Exception executing: " + sb + " - " + ex.getMessage() );

        }

        Process p = sshell.createProcess(this);

    long ptimeout = PROC_INST_TIMEOUT;

    p.setIOTimeout(ptimeout);

    p.setExecutable(exe);

    exe.setProcess(p);

    exe.setShell(this);

    p.setCommandLine(null);    // don't know what to do with this

    p.setParams(params);

    p.setExePath(exepath);

    p.setInputBuffer(exe.getStdIn());

    p.setOutputBuffer(exe.getStdOut());

    procmap.put(p.getID(), p);

    log.debug("Created process " + p.getID());

    p.setUserInitiated(false); // what does it mean again ?

    p.start();

    //log.debug("Started the process.");

    ProcessInfo pinfo = new ProcessInfo();

    pinfo.procid = p.getID();

    pinfo.inbuf_maxsize = exe.getStdIn().getMaxSize();

    pinfo.outbuf_maxsize = exe.getStdOut().getMaxSize();

    return pinfo;

  }

  public Process createProcess(Executable exe, String [] params, String path, boolean useThreadPool) throws ShellException {

        try {

            preStartTimeoutCheck();

        } catch(SessionTimeoutException ex) {

            StringBuffer sb = new StringBuffer(path);

            if(params != null) {

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

                    sb.append(" \'").append(params[i]).append('\'');

                }

            }

            throw new SessionTimeoutException("Exception executing: " + sb + " - " + ex.getMessage() );

        }

        Process p = sshell.createProcess(this, useThreadPool);

    long ptimeout = PROC_INST_TIMEOUT;

    p.setIOTimeout(ptimeout);

    p.setExecutable(exe);

    exe.setProcess(p);

    StringBuffer cmdline = new StringBuffer();

    cmdline.append(path == null ? "<cmd>" : path);

    if(params!=null) {

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

        cmdline.append(" ").append(params[i]);

      }

    }

    p.setCommandLine(cmdline.toString());

    p.setParams(params);

    p.setExePath(path);

    p.setInputBuffer(exe.getStdIn());

    p.setOutputBuffer(exe.getStdOut());

    procmap.put(p.getID(), p);

    log.debug("Created process " + p.getID());

    p.setUserInitiated(false); // what does it mean again ?

    return p;

  }

  private CmdLines resolveVars(CmdLines cmds) throws ShellException {

    LinkedList cmdsl = new LinkedList();

    Iterator it = cmds.iterator();

    while (it.hasNext()) {

      Cmd cmd = (Cmd) it.next();

      String scmd = cmd.getExec();

      // we leave cmd as it is.

      String[] params = cmd.getParams();

      LinkedList ops = new LinkedList();

      // we process each one - look for $ then look for eof or space.

      // we try resolve $ if can't then leave it as it is.

//log.debug("cmdline parameters: ");

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

        String c = params[i];

// in here we do several things. We resolve env vars only if " or without

// we do pathname expansion if not " or ' and *, ? or [ is present

        if(c.startsWith("'")) {

          if(c.endsWith("'")) {

            ops.add(c.substring(1, c.length()-1));

            continue;

          } else {

            ops.add(c.substring(1, c.length()));

            continue;

          }

        }

        if(c.endsWith("'")) {

          ops.add(c.substring(0, c.length()-1));

          continue;

        }

*/

// if it does not end with " then we treat it as if it is not within quotes

        if (c.startsWith("'") && c.endsWith("'") && c.length() > 1) {

          ops.add(c.substring(1, c.length() - 1));

          continue;

        }

        StringBuffer outc = new StringBuffer();

        StringTokenizer st = new StringTokenizer(c, "$ ", true);

        boolean isVar = false;

        while (st.hasMoreTokens()) {

          String t = st.nextToken();

          if (t.equals("$")) {

            isVar = true;

          } else {

            if (isVar) {

              // lookup t

              String p = null;

              int j = 0;

              StringBuffer psmp = new StringBuffer();

              for (j = 0; j < t.length() && p == null; j++) {

                psmp.append(t.charAt(j));

                p = getEnvProperty(cmd, psmp.toString());

              }

              if (p == null) {

                outc.append("$").append(t);

              } else {

                outc.append(p);

                if (j < t.length()) {

                  outc.append(t.substring(j, t.length()));

                }

              }

              isVar = false;

            } else {

              outc.append(t);

            }

          }

        }

        c = outc.toString();

        if (c.startsWith("\"") && c.endsWith("\"") && c.length() > 1) {

          ops.add(c.substring(1, c.length() - 1));

          continue;

        }

        if (c.indexOf("?") != -1 || c.indexOf("*") != -1 || (c.indexOf("[") != -1 && c.indexOf("]") != -1)) {

          try {

            FPExpand fpe = new FPExpand(this);

            fpe.expand(c);

            Vector vx = fpe.getMatches();

            Iterator itx = vx.iterator();

            while (itx.hasNext()) {

              ops.add(((FileInfo) itx.next()).getFileName().toString());

            }

          } catch (Exception ex) {

            log.error("Could not expand", ex);

          }

          continue;

        }

        ops.add(c);

      }

      String[] pout = new String[ops.size()];

      Iterator it2 = ops.iterator();

      for (int i = 0; it2.hasNext(); i++) {

        pout[i] = (String) it2.next();

      }

      //cmdsl.add(new Cmd(scmd, pout, null, null));

      cmd.setParams(pout);

      cmdsl.add(cmd);

    }

    cmds.setCmds(cmdsl);

    return cmds;

  }

    private void makeProcess(CmdLines cmdl, Cmd cmd, LinkedList joblist, boolean hasin, boolean hasout, boolean ui) throws ShellException {

    String command = cmd.getExec();

    String exepath = "/bin/" + command;

    String[] params = cmd.getParams();

    int inbufmax = IN_BUF_SIZE;

    int outbufmax = OUT_BUF_SIZE;

    Properties env = _getEnvProperties();

    String ibs = getEnvProperty("IN_BUF_SIZE");

    if (ibs != null) {

      try {

        inbufmax = Integer.parseInt(ibs);

      } catch (Exception ex) {

        log.error("Problem while reading buffer", ex);

      }

    }

    String obs = getEnvProperty("OUT_BUF_SIZE");

    if (obs != null) {

      try {

        outbufmax = Integer.parseInt(obs);

      } catch (Exception ex) {

        log.error("Problem while wrinting buffer", ex);

      }

    }

    long ptimeout = PROC_INST_TIMEOUT;

    if (inbufmax > BUF_MAX_SIZE) {

      inbufmax = BUF_MAX_SIZE;

    }

    if (PROC_TIMEOUT_MAX != 0) {

      if (ptimeout == 0 || ptimeout > PROC_TIMEOUT_MAX) {

        ptimeout = PROC_TIMEOUT_MAX;

      }

    }

    Executable exe = runtime.loadExe(command);

    // Exe is ok, we have created it.

//    System.out.println("Successfully loaded executable.");

    // Now we ask sysshell to create process.

//    System.out.println("Creating new process ...");

    Process p = sshell.createProcess(this);

    setupEnv(cmd, p);

    p.setIOTimeout(ptimeout);

    // We only create in buffer if we are the first, otherwise we simply use

    // previous exe's output buffer. To know if we are first it would help to have

    // access to job list

    InBuffer in = null;

    if (joblist.size() == 0) {

      if (cmdl.getSLStdInRedir() != null) {

        try {

          InputStreamBuffer bin = new InputStreamBuffer(new FileInputStream(cmdl.getSLStdInRedir()), cmdl.isSLInObjMode());

          bin.setProperties(env);

          in = bin;

        } catch (IOException ex) {

          throw new ShellException("Exception occured while initializing input buffer: " + ex.toString());

        }

      } else if (cmdl.getStdInRedir() != null) {

        try {

          //in=new InputStreamBuffer(new VFSInputStream(new SecureVFS(vfs, uctx), cmdl.getStdInRedir()), cmdl.isInObjMode());

          if(cmdl.getStdInLines() != null) {

            String enc = env.getProperty("ENC");

            ByteArrayInputStream bain;

            if(enc != null) {

              bain = new ByteArrayInputStream(cmdl.getStdInLines().getBytes("ENC"));

            } else {

              bain = new ByteArrayInputStream(cmdl.getStdInLines().getBytes());

            }

            InputStreamBuffer bin = new InputStreamBuffer(bain, false);

            bin.setProperties(env);

            in = bin;

           

          } else {

            FileName fname = new FileName(cmdl.getStdInRedir());

            if (fname.isRelative()) {

              fname = new FileName(getEnvProperty("PWD")).absolutize(fname);