Capturing stdout from JVM process

Question

Hi,
Using JNI native methods I call functions in a shared C library from my Java program. I do not have access to the shared library source code. The shared library writes informational messages to stdout. I want to be able to capture these messages and display them in my Java GUI as they occur. I need a cross-platform solution because the Java program needs to run on both Windows and Linux.
I have googled and searched the JavaSoft forums but I cannot find an answer to what I am trying to do. I have seen answers on how to do it if you are using Runtime.exec methods, but I am not doing that. Also, redirection on the command line will not work since I want to show these messages as they occur in my GUI.
I have thought of redirecting stdout to a pipe in the JNI code and using select to read the bytes off the pipe. Then sending the bytes up to a Java object. All this would run in a separate thread. But this seems overly complicated.
Any suggestions?
charlie

Answer 1

I developed a solution to this problem using named pipes. It works well on Linux (2.6 kernel) and it may work on Windows but I don't know. Example code follows. I would be most interested in any feedback on this solution or on the code itself.
There are 2 files, StdoutRedirect.java and StdoutRedirect.c.
1) Compile the java file and run javah on it to get StdoutRedirect.h.
2) Compile the C file into a shared library, here's a makefile:
StdoutRedirect: StdoutRedirect.o
gcc -shared -o libStdoutRedirect.so StdoutRedirect.o
3) Run the java class file.
charlie
**** StdoutRedirect.java ****
import java.io.FileNotFoundException;
import java.io.IOException;
* This class, along with its JNI library, demonstrates a method of redirecting stdout of the JVM process to a Java
* Reader thread. Using this method the stdout bytes can be sent anywhere in the Java program; e.g., displayed in a GUI.
* This has only been tested on a Linux 2.6 kernel.
public class StdoutRedirect {
    static {
        System.loadLibrary("StdoutRedirect");
    final static public String NAMED_PIPE = "/tmp/stdoutRedirect";
    native private void setupNamedPipe();
    native private void redirectStdout();
    native public void someRoutine();
    // Flag to indicate to Reader thread when to terminate
    protected boolean keepReading = true;
    public static void main(String[] args) throws IOException {
        StdoutRedirect redir = new StdoutRedirect();
        redir.setupNamedPipe();
        // The first reader or writer to connect to the named pipe will block. So, the reader
        // must be opened first and must be in a new thread. We want it to be in a separate
        // thread anyways so we can receive data asynchronously.
        redir.openReader();
        // At this point, the reader thread is blocked on creating the FileInputStream
        // because it is the first thing to connect to the named pipe. We grab the lock
        // here and redirect stdout to the named pipe. This opens a writer on the named
        // pipe and the reader thread will unblock. We want to wait for the reader thread
        // to unblock and be ready to receive data before continuing.
        synchronized (redir) {
            redir.redirectStdout();
            try {
                // wait for the reader thread to be ready to receive data
                redir.wait();
            } catch (InterruptedException e) {
        // write some data to stdout in our C routine
        redir.someRoutine();
        // All done now, so indicate this with our flag
        redir.keepReading = false;
        // The reader thread may be blocked waiting for something to read and not see
        // the flag. So, wake it up.
        System.out.println("Shut down");
        // Make sure everything is out of stdout and then close it.
        System.out.flush();
        System.out.close();
        // stdout is closed. This will not be visible.
        System.out.println("Won't see this.");
     * Starts the reader thread which listens to the named pipe and spits the data
     * it receives out to stderr.
    private void openReader() {
        new Thread() {
            public void run() {
                try {
                    int BUFF_SIZE = 256;
                    byte[] bytes = new byte[BUFF_SIZE];
                    int numRead = 0;
                    // At this point there is no writer connected to the named pipe so this statement
                    // will block until there is.
                    FileInputStream fis = new FileInputStream(NAMED_PIPE);
                    // The reader thread is ready to accept data. Notify the main thread.
                    synchronized (StdoutRedirect.this) {
                        StdoutRedirect.this.notify();
                    // Keep reading data until EOF or we're told to quit and there is no more data to read
                    while (numRead != -1 && (StdoutRedirect.this.keepReading || fis.available() != 0)) {
                        numRead = fis.read(bytes, 0, BUFF_SIZE);
                        System.err.print("Received - " + new String(bytes, 0, numRead));
                    if (fis != null) {
                        fis.close();
                    System.err.println("Receiver shut down");
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
        }.start();
} // class StdoutRedirect**** StdoutRedirect.c ****
#include "StdoutRedirect.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
// The filesystem location for the named pipe
const char *namedPipe = "/tmp/stdoutRedirect";
* Create the named pipe we're going to redirect stdout through. After this
* method completes, the pipe will exist but nothing will be connected to it.
JNIEXPORT void JNICALL Java_StdoutRedirect_setupNamedPipe(JNIEnv *env, jobject obj) {
  // make sure there is no pre-existing file in our way
  remove(namedPipe);
  // create the named pipe for reading and writing
  mkfifo(namedPipe, S_IRWXU);
* Redirect stdout to our named pipe. After this method completes, stdout
* and the named pipe will be identical.
JNIEXPORT void JNICALL Java_StdoutRedirect_redirectStdout(JNIEnv *env, jobject obj) {
  // Open the write end of the named pipe
  int  namedPipeFD = open(namedPipe, O_WRONLY);
  printf("Before redirection...\n");
  // make sure there is nothing left in stdout
  fflush(stdout);
  // duplicate stdout onto our named pipe
  if ( dup2(namedPipeFD, fileno(stdout)) == -1 ) {
    fprintf(stderr, "errno %s.\n", strerror(errno));
    fprintf(stderr, "Couldn't dup stdout\n");
  printf("After redirection.\n");
  // flushing is necessary, otherwise output does not stay in sync with Java layer
  fflush(stdout);
* Do some random writing to stdout.
JNIEXPORT void JNICALL Java_StdoutRedirect_someRoutine(JNIEnv *env, jobject obj) {
  int i;
  for ( i = 0; i < 3; i++ ) {
    printf("Message %d\n", i);
  printf("End of messages\n");
  // flushing is necessary, otherwise output does not stay in sync with Java layer
  fflush(stdout);
}