1 /*
   2  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 4763384
  26  * @summary Ensure that piped input always works with exec'd processes
  27  */
  28 
  29 import java.io.*;
  30 
  31 
  32 /**
  33  * This class demonstrates a regression in java1.4.1 in the handling of the
  34  * Process OutputStream (exec'd process stdin).  The subprocess completes 100%
  35  * of the time in 1.4, but about only about 50% of the time under 1.4.1.  Issue
  36  * exists for client JVM, Linux Redhat 6.2 not sure about other variants of
  37  * Linux or other OSes, or server JVM.
  38  */
  39 
  40 public class ExecWithInput {
  41 
  42     static final boolean isLinux =
  43             System.getProperty("os.name", "unknown").startsWith("Linux");
  44     private static final int N = 200;
  45 
  46     static int go(int i) throws Exception {
  47         /*
  48          * Execute /bin/cat supplying two lines of input. cat should
  49          * read the input lines and copy them to stdout. On completion,
  50          * p.waitFor should return and the exit status is printed and this
  51          * program exits. Under 1.4.1, cat sometimes gets stuck on a pipe
  52          * read and never terminates.
  53          */
  54         Process p = Runtime.getRuntime().exec("cat");
  55 
  56         String input = i + ": line 1\n" + i + ": line 2\n";
  57         StringBufferInputStream in = new StringBufferInputStream(input);
  58         // create threads to handle I/O streams
  59         IO ioIn = new IO("stdin", in, p.getOutputStream());
  60         IO ioOut = new IO("stdout", p.getInputStream(), System.out);
  61         IO ioErr = new IO("stderr", p.getErrorStream(), System.err);
  62 
  63         // wait for process to exit
  64         return p.waitFor();
  65     }
  66 
  67     public static void main(String[] args) throws Exception {
  68         if (! isLinux) {
  69             System.err.println("Only for Linux");
  70             return;
  71         }
  72         for (int i = 0; i < N; i++)
  73             go(i);
  74     }
  75 
  76     /**
  77      * Handle IO. Thread is started in constructor.
  78      */
  79     static class IO extends Thread {
  80 
  81         private InputStream in;
  82         private OutputStream out;
  83 
  84         IO(String name, InputStream in, OutputStream out)
  85         {
  86             this.in = in;
  87             this.out = out;
  88             setName(name);
  89             start();
  90         }
  91 
  92         public void run() {
  93             try {
  94                 int c;
  95                 byte[] buf = new byte[8192];
  96                 int n;
  97                 while ((n = in.read(buf)) != -1) {
  98                     out.write(buf, 0, n);
  99                     out.flush();
 100                 }
 101                 /*
 102                 while ((c = in.read()) != -1) {
 103                     out.write(c);
 104                     if (c == '\n')
 105                         out.flush();
 106                 }
 107                 out.flush();
 108                 */
 109             } catch (IOException e) {
 110                 e.printStackTrace();
 111             } finally {
 112                 if (!System.out.equals(out) && !System.err.equals(out)) {
 113                     // Note: in order to get an exec'd java process to
 114                     // see EOF on input, it is necessary to close stdin
 115                     if (out != null) {
 116                         try { out.close(); } catch (Exception e) {
 117                             e.printStackTrace();
 118                         }
 119                     }
 120                 }
 121             }
 122         }
 123     }
 124 
 125 }