OSCommand.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// OSCommand.cpp: implementation of the OSCommand class.
//
//////////////////////////////////////////////////////////////////////

#include "OSCommand.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

OSCommand::OSCommand() {
        init();
}

OSCommand::OSCommand(const JString& cmdline, const JString& startupdir) {
        command = cmdline;
        startupDir = startupdir;
        init();
}

OSCommand::~OSCommand() {
        cleanUp();
        delete [] outbuffer;
        delete [] errbuffer;
}

bool OSCommand::init() {
//      printf("[init %d] fdopen %d %d %d\n", (int) this, (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
        binary = false;
        consoleOutput = false;
        autoRestart = false;
        startedTime.setInvalid();
        endedTime.setInvalid();
        #ifdef WIN32
                procInfo.hProcess = NULL;
                procInfo.hThread = NULL;
                procInfo.dwProcessId = 0;
                procInfo.dwThreadId = 0;
        #else
                stdin_pipe[0] = 0;
                stdin_pipe[1] = 0;
                stdout_pipe[0] = 0;
                stdout_pipe[1] = 0;
                stderr_pipe[0] = 0;
                stderr_pipe[1] = 0;
        #endif
        outbuffer = NULL;
        outbuffercount = 0;
        outbuffermax = 0;
        resizeOutputBuffer(10000);
        errbuffer = NULL;
        errbuffercount = 0;
        errbuffermax = 0;
        resizeErrorBuffer(10000);
        proc_stdin = NULL;
        proc_stdout = NULL;
        proc_stderr = NULL;
        procID = -1;
        returncode = -1;
        return true;
}

bool OSCommand::restart() {
        terminate();
        cleanUp();
        delete [] outbuffer;
        delete [] errbuffer;
        startedTime.setInvalid();
        endedTime.setInvalid();
        #ifdef WIN32
                procInfo.hProcess = NULL;
                procInfo.hThread = NULL;
                procInfo.dwProcessId = 0;
                procInfo.dwThreadId = 0;
        #else
                stdin_pipe[0] = 0;
                stdin_pipe[1] = 0;
                stdout_pipe[0] = 0;
                stdout_pipe[1] = 0;
                stderr_pipe[0] = 0;
                stderr_pipe[1] = 0;
        #endif
        outbuffer = NULL;
        outbuffercount = 0;
        outbuffermax = 0;
        resizeOutputBuffer(10000);
        errbuffer = NULL;
        errbuffercount = 0;
        errbuffermax = 0;
        resizeErrorBuffer(10000);
        proc_stdin = NULL;
        proc_stdout = NULL;
        proc_stderr = NULL;
        procID = -1;
        returncode = -1;
        return start();
}

bool OSCommand::setBinary() {
        binary = true;
        return true;
}

bool OSCommand::setASCII() {
        binary = false;
        return true;
}

JString OSCommand::getCommand() {
        return command;
}

int OSCommand::getReturnCode() {
        if (isRunning())
                return -1;
        return returncode;
}

bool OSCommand::hasTerminated() {
        if (!hasBeenStarted())
                return false;
        return (!isRunning());
}

JTime OSCommand::getStartedTime() {
        return startedTime;
}

JTime OSCommand::getEndedTime() {
        return endedTime;
}


JString OSCommand::getStartupDir() {
        return startupDir;
}

int OSCommand::getProcID() {
        return procID;
}

bool OSCommand::hasOutput() {
        return (getOutputCharCount() > 0);
}

bool OSCommand::hasErrors() {
        return (getErrorCharCount() > 0);
}

int OSCommand::getOutputCharCount() {
        readIntoBuffers();
        return outbuffercount;
}

int OSCommand::getErrorCharCount() {
        readIntoBuffers();
        return errbuffercount;
}

bool OSCommand::writeToStandardInput(const JString& text) {
        return writeToStandardInput(text, text.length());
}

JString OSCommand::getCurrentOutput() {
        getNewOutput();
        return outputHistory;
}

JString OSCommand::getCurrentError() {
        getNewError();
        return errorHistory;
}

JString OSCommand::getNewOutput() {
        readIntoBuffers();
        if (getOutputCharCount() <= 0)
                return "";
        JString str = outbuffer;
        outbuffercount = 0;
        outputHistory += str;
        if (outputHistory.length() > 10000)
                outputHistory = outputHistory.getLast(10000);
        return str;
}

JString OSCommand::getNewError() {
        readIntoBuffers();
        if (getErrorCharCount() <= 0)
                return "";
        JString str = errbuffer;
        errbuffercount = 0;
        errorHistory += str;
        if (errorHistory.length() > 10000)
                errorHistory = errorHistory.getLast(10000);
        return str;
}

JString OSCommand::readOutputLine(int timeout) {

        JTime start;
        // JTime now;
        readIntoBuffers();

        char* str = strchr(outbuffer, 10);
        if (str == NULL) {
                if (timeout == 0)
                        return "";

                while ( (str = strchr(outbuffer, 10)) == NULL ) {
                        readIntoBuffers();
                        // now = JTime();
                        if (start.getAge() >= timeout)
                                return "";
                        this->wait(5);
                }
        }

        int len = (int)(str - outbuffer);
        if (len > outbuffermax)
                return "";
        str[0] = 0;
        JString s = outbuffer;
        s = s.trim();
        memmove(outbuffer, str+1, len+1);
        return s;
}

Collection OSCommand::readCurrentLines() {
        readIntoBuffers();
        Collection lines;
        if (getOutputCharCount() <= 0)
                return lines;
        JString str = outbuffer;
        lines = str.splitIntoLines();
        outbuffercount = 0;
        return lines;
}

JString OSCommand::waitForProcessToFinishAndGetOutput(int timeout) {
        readIntoBuffers();
        if (!waitForProcessToFinish(timeout))
                return "";
        readIntoBuffers();
        JString str = outbuffer;
        outbuffercount = 0;
        return str;
}

JString OSCommand::waitForProcessToFinishAndGetError(int timeout) {
        readIntoBuffers();
        if (!waitForProcessToFinish(timeout))
                return "";
        readIntoBuffers();
        JString str = errbuffer;
        errbuffercount = 0;
        return str;
}


char* OSCommand::readOutputBytes(int length, int* readcount, int timeout) {
        
        *readcount = 0;
        if (length > outbuffermax) {
                if (!resizeOutputBuffer(length))
                        return NULL;
        }
        
        JTime start;
        // JTime now;
        readIntoBuffers();

        if (timeout > 0) {
                while (outbuffercount < length) {
                        readIntoBuffers();
                        // now = JTime();
                        if (start.getAge() >= timeout)
                                break;
                        this->wait(5);
                }
        }

        int len = 0;
        if (outbuffercount <= length)
                len = outbuffercount;
        else
                len = length;

        *readcount = len;
        char* buf = new char[len+1];
        memcpy(buf, outbuffer, len);
        outbuffercount -= len;

        if (outbuffercount > 0)
                memmove(outbuffer, outbuffer+len, outbuffercount);

        return buf;
}

bool OSCommand::resizeOutputBuffer(int max) {

        if (max <= outbuffermax)
                return true;

        char* newbuffer = new char[max+1];
        if (outbuffercount > 0) {
                memcpy(newbuffer, outbuffer, outbuffercount);
        }
        delete [] outbuffer;
        outbuffer = newbuffer;
        outbuffer[outbuffermax] = 0;
        outbuffermax = max;
        outbuffer[outbuffermax] = 0;
        return true;
}

bool OSCommand::resizeErrorBuffer(int max) {

        if (max <= errbuffermax)
                return true;

        char* newbuffer = new char[max+1];
        if (errbuffercount > 0) {
                memcpy(newbuffer, errbuffer, errbuffercount);
        }
        delete [] errbuffer;
        errbuffer = newbuffer;
        errbuffer[errbuffermax] = 0;
        errbuffermax = max;
        errbuffer[errbuffermax] = 0;
        return true;
}



//////////////////////////////////////////////////////////////////////
// Win32 specific stuff 
#if defined(WIN32_DESKTOP)
//////////////////////////////////////////////////////////////////////


bool OSCommand::start() {

        startedTime = JTime();
        if (command.length() == 0) {
                returncode = 0;
                endedTime = JTime();
                return false;
        }

        STARTUPINFO si;
//      ULONG status;
        SECURITY_ATTRIBUTES sa;

        ZeroMemory(&si, sizeof(si));
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
//      si.dwFlags = STARTF_USESTDHANDLES;
        si.wShowWindow = SW_HIDE;

        // Set up the security attributes struct.
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.lpSecurityDescriptor = NULL;
        sa.bInheritHandle = TRUE;

        // Temporary handles
        HANDLE hStdinRead,hStdinWrite;
        HANDLE hStdoutRead,hStdoutWrite;
        HANDLE hStderrRead,hStderrWrite;


        // Create the child output pipe.
        if (!CreatePipe(&hStdinRead,&hStdinWrite,&sa,0)) {
                endedTime = JTime();
                return false;
        }
        // Create the child error pipe.
        if (!CreatePipe(&hStdoutRead,&hStdoutWrite,&sa,0)) {
                endedTime = JTime();
                return false;
        }
        // Create the child input pipe.
        if (!CreatePipe(&hStderrRead,&hStderrWrite,&sa,0)) {
                endedTime = JTime();
                return false;
        }

        // Create new output read, error read handle and the input write handles. Set
        // the Properties to FALSE. Otherwise, the child inherits the
        // properties and, as a result, non-closeable handles to the pipes
        // are created.
        if (!DuplicateHandle(GetCurrentProcess(),hStdinWrite,
                                                GetCurrentProcess(),
                                                &proc_stdin, // Address of new handle.
                                                0,FALSE, // Make it uninheritable.
                                                DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)) {
                endedTime = JTime();
                return false;
        }

        if (!DuplicateHandle(GetCurrentProcess(),hStdoutRead,
                                                GetCurrentProcess(),
                                                &proc_stdout, // Address of new handle.
                                                0,FALSE, // Make it uninheritable.
                                                DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)) {
                endedTime = JTime();
                return false;
        }
        if (!DuplicateHandle(GetCurrentProcess(),hStderrRead,
                                                GetCurrentProcess(),
                                                &proc_stderr, // Address of new handle.
                                                0,FALSE, // Make it uninheritable.
                                                DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)) {
                endedTime = JTime();
                return false;
        }

        si.hStdInput = hStdinRead;
        si.hStdOutput = hStdoutWrite;
        si.hStdError = hStderrWrite;

        JString winCommand = command;
        winCommand.replace("/", "\\");
        char* cmd = new char[winCommand.length() + 10];
        strcpy(cmd, winCommand);

        char* initdir = NULL;
        if (startupDir.length() > 0) {
                JString winStartupDir = startupDir;
                winStartupDir.replace("/", "\\");
                if (!JFile::doesAFileExist(winStartupDir))
                        printf("Warning: Startup directory '%s' does not appear to exist, using default...\n", (char*) winStartupDir);
                else {
                        initdir = new char[winStartupDir.length() + 10];
                        strcpy(initdir, winStartupDir);
                }
        }

        int res = CreateProcess(
                NULL,
                cmd,
                NULL,
                NULL,
                TRUE,
        //      false,
                0,
                NULL,
                initdir,
                &si,
                &procInfo);
        
        delete [] cmd;

        if (res == 0) {
                char msg[256];
                int length = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 
                   NULL, GetLastError(), 0, msg, sizeof(msg), NULL);
                msg[length] = '\0';
                if (DEBUGLEVEL(STATUS))
                        printf("CreateProcess Error: %s\n", msg);
                endedTime = JTime();
                return false;
        }
        if (DEBUGLEVEL(DEBUG))
                printf("CreateProcess Success: %s\n", (char*)command);

        // Close inheritable copies of the handles you do not want to be
        // inherited.
        if (!CloseHandle(hStdinRead)) {
                endedTime = JTime();
                return false;
        }
        if (!CloseHandle(hStdoutWrite)) {
                endedTime = JTime();
                return false;
        }
        if (!CloseHandle(hStderrWrite)) {
                endedTime = JTime();
                return false;
        }

        procID = procInfo.dwProcessId;

        return true;
}

bool OSCommand::terminate() {
        if (!isRunning())
                return true;
        if (procInfo.hProcess == NULL)
                return false;
        
        if (TerminateProcess(procInfo.hProcess, 10) == 0)
                return false;

        if (!endedTime.isValid())
                endedTime = JTime();
        return true;
}

bool OSCommand::cleanUp() {
        terminate();
        CloseHandle(proc_stdin);
        CloseHandle(proc_stdout);
        CloseHandle(proc_stderr);
        CloseHandle(procInfo.hProcess);
        CloseHandle(procInfo.hThread);
        return true;
}

bool OSCommand::waitForProcessToFinish(int timeout) {
/*      JTime start;
        JTime now;

        while (isRunning()) {
                now = JTime();
                if (now - start >= timeout)
                        return false;
                this->wait(5);
        }
        return true;
*/
        if (procInfo.hProcess == NULL)
                return false;
        return (WaitForSingleObject(procInfo.hProcess, timeout) == WAIT_OBJECT_0);
}

bool OSCommand::hasBeenStarted() {
        return (proc_stdout != NULL);
}

bool OSCommand::isRunning() {
        if (!hasBeenStarted())
                return false;
        if (procInfo.hProcess <= 0) {
                if (!endedTime.isValid())
                        endedTime = JTime();
                return false;
        }
        if (returncode != -1) {
                if (!endedTime.isValid())
                        endedTime = JTime();
                return false;
        }

        DWORD exitCode;
        if (GetExitCodeProcess(procInfo.hProcess, &exitCode) == 0) {
                returncode = -999;
                if (!endedTime.isValid())
                        endedTime = JTime();
                return false;
        }

        if (exitCode == STILL_ACTIVE) {
                if (DEBUGLEVEL(HEARTBEAT))
                        printf("ProcID %d still running...\n", procID);
                return true;
        }
        
        returncode = (int)exitCode;
        if (DEBUGLEVEL(DEBUG))
                printf("ProcID %d exited with %d...\n", procID, returncode);
        if (!endedTime.isValid())
                endedTime = JTime();
        return false;
}

bool OSCommand::writeToStandardInput(char* bytes, int len) {
        if (proc_stdin == NULL)
                return false;
        DWORD nBytesWrote;
        if (WriteFile(proc_stdin,bytes,len,&nBytesWrote,NULL) == 0) {
                isRunning();
                return false;
        }
        return true;
}

int OSCommand::readIntoBuffers() {

        if (proc_stdout == NULL)
                return -1;

        if (outbuffercount > (outbuffermax*0.90))
                resizeOutputBuffer(outbuffermax*2);
        if (errbuffercount > (errbuffermax*0.90))
                resizeErrorBuffer(errbuffermax*2);

        DWORD outBytesRead = 0;
        DWORD outBytesToRead = 0;
        DWORD errBytesRead = 0;
        DWORD errBytesToRead = 0;

        outBytesToRead = (outbuffermax-outbuffercount);
        // First test that there is data to be read
        if ( (PeekNamedPipe(proc_stdout, NULL, 0, NULL, &outBytesToRead, NULL) != 0) &&
                 (outBytesToRead > 0) ) {

                if (outBytesToRead > (DWORD)(outbuffermax-outbuffercount)) {
                        outBytesToRead = (DWORD)(outbuffermax-outbuffercount);
                }
                if (ReadFile(proc_stdout,outbuffer+outbuffercount,outBytesToRead, &outBytesRead, NULL) != 0) {
                        outbuffercount += outBytesRead;
                        outbuffer[outbuffercount] = 0;
                }
        }

        errBytesToRead = (errbuffermax-errbuffercount);
        // First test that there is data to be read
        if ( (PeekNamedPipe(proc_stderr, NULL, 0, NULL, &errBytesToRead, NULL) != 0) &&
                 (errBytesToRead > 0) ) {

                if (errBytesToRead > (DWORD)(errbuffermax-errbuffercount)) {
                        errBytesToRead = (DWORD)(errbuffermax-errbuffercount);
                }
                if (ReadFile(proc_stderr,errbuffer+errbuffercount, errBytesToRead, &errBytesRead, NULL) != 0) {
                        errbuffercount += errBytesRead;
                        errbuffer[errbuffercount] = 0;
                }
        }

        isRunning();

        return outBytesRead+errBytesRead;
}

//////////////////////////////////////////////////////////////////////
// PocketPC specific stuff 
#elif defined(WIN32_POCKETPC)
//////////////////////////////////////////////////////////////////////

bool OSCommand::start() {
        return false;
}

bool OSCommand::terminate() {
        return true;
}

bool OSCommand::cleanUp() {
        return true;
}

bool OSCommand::waitForProcessToFinish(int timeout) {
        return false;
}

bool OSCommand::hasBeenStarted() {
        return false;
}

bool OSCommand::isRunning() {
        return false;
}

bool OSCommand::writeToStandardInput(char* bytes, int len) {
        return false;
}

int OSCommand::readIntoBuffers() {
        return 0;
}




//////////////////////////////////////////////////////////////////////
// Unix specific stuff 
#else // WIN32
//////////////////////////////////////////////////////////////////////

bool OSCommand::start() {

        if (hasBeenStarted())
                return true;

        startedTime = JTime();
        if (command.length() == 0) {
                returncode = 0;
                endedTime = JTime();
                return false;
        }

        if ( (pipe(stdin_pipe) != 0) || (pipe(stdout_pipe) != 0) || (pipe(stderr_pipe) != 0) ) {
                endedTime = JTime();
            return false;
        }

        int pid = fork();

        if (pid < 0) {
                endedTime = JTime();
                return false;
        }

        // We are the child process
        else if (pid == 0) {
                // printf("Child redirecting outputs "); fflush(stdout);

/*              dup2(stdin_pipe[1],0);
                dup2(stdout_pipe[0],1);
                dup2(stderr_pipe[0],2);
*/

                // Close the Child process' STDIN
                close(0);

                // Duplicate the Child's STDIN to the stdin_pipe file descriptor
                dup2(stdin_pipe[0], 0);

                // Close the read and write to for the pipe for the child.  The child will now only be able to read from it's STDIN (which is our pipe). 
                close(stdin_pipe[0]);
                close(stdin_pipe[1]);

                // Close the Child process' STDOUT
                close(1);
                dup(stdout_pipe[1]);
                close(stdout_pipe[0]);
                close(stdout_pipe[1]);

                // Close the Child process' STDERR
                close(2);
                dup(stderr_pipe[1]);
                close(stderr_pipe[0]);
                close(stderr_pipe[1]);

                // Make the argument list
                Collection args = command.splitOnWhiteSpaces();
                int argc = args.getCount();
                char** argv = new char*[argc+1];
                int len;
                JString s;
                for (int n=0; n<argc; n++) {
                        s = args.get(n);
                        s.replace("\\ ", " ");
                        argv[n] = s.getCharCopy(len);
                }
                argv[argc] = NULL;

                if (startupDir.length() > 0) {
                        JString myStartupDir = startupDir;
                        myStartupDir.replace("\\", "/");
                        if (!JFile::doesAFileExist(myStartupDir))
                                printf("Warning: Startup directory '%s' does not appear to exist, using default...\n", (char*) myStartupDir);
                        else {
                                if (chdir(myStartupDir) != 0)
                                        printf("Warning: Startup directory '%s' does not appear to be valid, using default...\n", (char*) myStartupDir);
                        }
                }

                if (DEBUGLEVEL(DEBUG))
                        printf("OSCommand running: %s (%d args) %s...\n", (char*) command, argc, (char*)args.printListLine("|")); fflush(stdout);
                //  Make the exec call to run the program. 
                execvp(argv[0],argv);

                int res = errno;
                //  If program didn't take over the exec call failed.
                if (DEBUGLEVEL(DEBUG))
                        printf("OSCommand: Fork failed with error: %d!\n", res);
                exit(0);
        }

        // We are our own process
        else {
                procID = pid;
                // Close STDIN for read and close STDOUT and STDERR for write
                close(stdin_pipe[0]);
                close(stdout_pipe[1]);
                close(stderr_pipe[1]);

                long parm = fcntl(stdout_pipe[0], F_GETFL);
                parm |= O_NONBLOCK;
                fcntl(stdout_pipe[0], F_SETFL, parm);
                parm = fcntl(stderr_pipe[0], F_GETFL);
                parm |= O_NONBLOCK;
                fcntl(stderr_pipe[0], F_SETFL, parm);

                if (binary) {
                        if ( (proc_stdin = fdopen(stdin_pipe[1], "wb")) == NULL)
                                printf("Error: stdin creation...\n");
                        if ( (proc_stdout = fdopen(stdout_pipe[0], "rb")) == NULL)
                                printf("Error: stdin creation...\n");
                        if ( (proc_stderr = fdopen(stderr_pipe[0], "rb")) == NULL)
                                printf("Error: stdin creation...\n");
                }
                else {
                        if ( (proc_stdin = fdopen(stdin_pipe[1], "w")) == NULL)
                                printf("Error: stdin creation...\n");
                        if ( (proc_stdout = fdopen(stdout_pipe[0], "r")) == NULL)
                                printf("Error: stdin creation...\n");
                        if ( (proc_stderr = fdopen(stderr_pipe[0], "r")) == NULL)
                                printf("Error: stdin creation...\n");
                }
        }

//      printf("[fdopen %d] fdopen %d %d %d\n", this, (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
        return true;
}

bool OSCommand::terminate() {
        if (!isRunning())
                return true;
        if (procID <= 0)
                return false;

        if (kill(procID, SIGKILL) != 0)
                return false;

        if (!endedTime.isValid())
                endedTime = JTime();
        return true;
}

bool OSCommand::cleanUp() {
//      printf("[cleanup %d] fdopen %d %d %d\n", (int) this, (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
        terminate();
//      close(stdin_pipe[1]);
//      close(stdout_pipe[0]);
//      close(stderr_pipe[0]);
        if (proc_stdout) {
                fclose(proc_stdout);
        }
        if (proc_stderr) {
                fclose(proc_stderr);
        }
        if (proc_stdin) {
                fclose(proc_stdin);
        }
        return true;
}

bool OSCommand::waitForProcessToFinish(int timeout) {
//      printf("[finish] fdopen %d %d %d\n", (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
        JTime start;
        // JTime now;

        while (isRunning()) {
                // now = JTime();
                if (start.getAge() >= timeout)
                        return false;
                this->wait(5);
        }
        return true;
}

bool OSCommand::hasBeenStarted() {
        return (proc_stdout != NULL);
}

bool OSCommand::isRunning() {
        if (!hasBeenStarted())
                return false;
        if (returncode >= 0) {
                if (!endedTime.isValid())
                        endedTime = JTime();
                return false;
        }
        int status;
//      printf("[isrunning %d] fdopen %d %d %d\n", (int) this, (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
        int res = waitpid(procID, &status, WNOHANG);
        if (res == procID) {
                returncode = WEXITSTATUS(status);
                if (DEBUGLEVEL(DEBUG))
                        printf("ProcID %d exited with %d...\n", procID, returncode);
                if (!endedTime.isValid())
                        endedTime = JTime();
                return false;
        }
        else if (res == 0) {
                if (DEBUGLEVEL(HEARTBEAT))
                        printf("ProcID %d still running...\n", procID);
                return true;
        }

        // kill it again, just to be sure...
        kill(procID, SIGKILL);
        returncode = 99;
        if (DEBUGLEVEL(DEBUG))
                printf("ProcID %d error %d...\n", procID, errno);
        if (!endedTime.isValid())
                endedTime = JTime();
        return false;
}

bool OSCommand::writeToStandardInput(char* bytes, int len) {

        if (proc_stdin == NULL)
                return -1;

        int nBytesWrote;
        if ( (nBytesWrote = fwrite(bytes, 1, len, proc_stdin)) <= len) {
                isRunning();
                return false;
        }
        return true;
}

int OSCommand::readIntoBuffers() {

//      printf("[read %d] fdopen %d %d %d\n", (int) this, (int) proc_stdin, (int) proc_stdout, (int) proc_stderr);
//      printf("start readIntoBuffer...\n");
        if (proc_stdout == NULL)
                return -1;
        
        int res = 0;
//      printf("reading out readIntoBuffer...\n");
        int outBytesRead = fread(outbuffer+outbuffercount, 1, outbuffermax-outbuffercount, proc_stdout);

/*      while (!feof(proc_stdout)) {
                if (fread(outbuffer+outbuffercount, 1, 1, proc_stdout) == 1) {
                //      printf("read 1 \n");
                        outBytesRead++;
                        outbuffercount++;
                }
                else break;
        }
*/
        if (outBytesRead < 0) {
        }
        // printf("readIntoOut: %d\n", outBytesRead);
        outbuffercount += outBytesRead;
        outbuffer[outbuffercount] = 0;

        //printf("reading err readIntoBuffer...\n");
//      int errBytesRead = fread_unlocked(errbuffer+errbuffercount, 1, errbuffermax-errbuffercount, proc_stderr);
        int errBytesRead = fread(errbuffer+errbuffercount, 1, errbuffermax-errbuffercount, proc_stderr);

/*      while (!feof(proc_stderr)) {
                if (fread(errbuffer+errbuffercount, 1, 1, proc_stderr) == 1) {
                        errBytesRead++;
                        errbuffercount++;
                }
                else break;
        }
*/
        if (errBytesRead < 0) {
        }
        // printf("readIntoErr: %d\n", errBytesRead);
        errbuffercount += errBytesRead;
        errbuffer[errbuffercount] = 0;
        isRunning();

        return outBytesRead+errBytesRead;
}



//////////////////////////////////////////////////////////////////////
// End OS specific stuff 
#endif // WIN32
//////////////////////////////////////////////////////////////////////



bool OSCommand::unitTest() {

        JString cmd;
        #ifdef WIN32
                cmd = "notepad";
        #else //WIN32
                cmd = "ls / /bla";
        //      cmd = "/bin/echo `/bin/date` > /tmp/bla; /bin/ls";
        #endif //WIN32

        OSCommand* com = new OSCommand(cmd);
        if (!com->start())
                return false;
        
        JTime start;
        JString out = com->waitForProcessToFinishAndGetOutput(3000);
        JString err = com->waitForProcessToFinishAndGetError(3000);
        JTime end;

//      printf("In %d us got Output [%d]:\n%s\n\nand Error [%d]:\n%s\n\n", end.microDifference(start), out.length(), (char*) out, err.length(), (char*) err);
        delete(com);
        return true;

/*      this->wait(100);

        if (!com->hasOutput())
                return false;

        if (com->getOutputCharCount() <= 0)
                return false;

        if (com->getReturnCode() < 0)
                return false;

//      ch = new char[800];
        Collection lines = com->readCurrentLines();
        if (lines.getCount() == 0)
                return false;

        delete(com);
        return true;*/
}
















} // namespace cmlabs

---