root/trunk/Executor.cpp

#include "stdafx.h"
#include "executor.h"

#define dim(x) (sizeof(x) / sizeof((x)[0]))

#define MAX_LINE_LENGTH 1024

unsigned long Executor::Run()
{
    hreadFromChild = NULL;
    HANDLE hwriteToParent = NULL;
    HANDLE hwriteToParent2 = NULL;

    SECURITY_ATTRIBUTES sa = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; // inheritable handle

    if ( lib != "" ) {
        _putenv( string("LIB=" + lib ).c_str() ); // set the lib path!
        
    }

    LPTSTR cmd = command.GetBuffer(command.GetLength() + 1);


    if(!::CreatePipe(&hreadFromChild, &hwriteToParent, &sa, 0))
    { /* pipe failed */
        // ::GetLastError() will reveal the cause
//      delete this;
        return FALSE;
    } /* pipe failed */

    if(!::DuplicateHandle(GetCurrentProcess(),     // duplicate from this process
                  hwriteToParent,       // this handle 
                  GetCurrentProcess(),     // into this process
                  &hwriteToParent2,        // as this handle
                  0,                // no access flags (subsumed by DUPLICATE_SAME_ACCESS)
                  TRUE,             // create inheritable
                  DUPLICATE_SAME_ACCESS))  // create duplicate access
    { /* duplicate failed */
        DWORD err = ::GetLastError();
        ::CloseHandle(hreadFromChild);
        ::CloseHandle(hwriteToParent);
        ::SetLastError(err);
//      delete this;
        return FALSE;
    } /* duplicate failed */

    STARTUPINFO startup;
    PROCESS_INFORMATION procinfo;

    ::ZeroMemory(&startup, sizeof(startup));

    startup.cb = sizeof(startup);
    startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
    startup.wShowWindow = SW_HIDE; // hidden console window
    startup.hStdInput = NULL; // not used
    startup.hStdOutput = hwriteToParent;
    startup.hStdError = hwriteToParent2;

    // We want a non-inherited read handle. DuplicateHandle with a
    // NULL target fixes the read side to be non-inheritable
    ::DuplicateHandle(::GetCurrentProcess(),    // in this process
              hreadFromChild,           // child read handle
              ::GetCurrentProcess(),    // to this process
              NULL,                     // modify existing handle
              0,                        // flags
              FALSE,                    // not inheritable
              DUPLICATE_SAME_ACCESS);   // same handle access

    // We need a writeable buffer for the command (silly Windows restriction)


    BOOL started = ::CreateProcess(NULL,        // command is part of input string
                       cmd,         // (writeable) command string
                       NULL,        // process security
                       NULL,        // thread security
                       TRUE,        // inherit handles flag
                       0,           // flags
                       NULL,        // inherit environment
                       NULL,        // inherit directory
                       &startup,    // STARTUPINFO
                       &procinfo);  // PROCESS_INFORMATION
    command.ReleaseBuffer();

    if(!started)
    { /* failed to start */
        DWORD err = ::GetLastError(); // preserve across CloseHandle calls
        ::CloseHandle(hreadFromChild);
        ::CloseHandle(hwriteToParent);
        ::CloseHandle(hwriteToParent2);
        ::SetLastError(err);
//   target->PostMessage(UPM_FINISHED, (WPARAM)err, (LPARAM)pid);
//      delete this;
        return FALSE;
    } /* failed to start */

//     target->PostMessage(UPM_PROCESS_HANDLE, (WPARAM)procinfo.hProcess, (LPARAM)pid);
     
// Now close the output pipes so we get true EOF/broken pipe
    ::CloseHandle(hwriteToParent);
    ::CloseHandle(hwriteToParent2);
     
    // We have to create a listener thread. We create a worker
    // thread that handles this

    if ( waitToComplete ) {


        TCHAR buffer[MAX_LINE_LENGTH + 1];

        CString * line;
        line = new CString;

        DWORD bytesRead;
     
        while(::ReadFile(hreadFromChild, buffer, sizeof(buffer) - sizeof(TCHAR), &bytesRead, NULL))
        { /* got data */
            if(bytesRead == 0)
                break; // EOF condition
     
            buffer[bytesRead] = _T('\0');
            // Convert to lines
            LPTSTR b = buffer;
            while(TRUE)
            { /* convert and send */
                LPTSTR p = _tcschr(b, _T('\n'));
                if(p == NULL)
                { /* incomplete line */
                    *line += b;
                    break; // leave assembly loop
                } /* incomplete line */
                else
                { /* complete line */
                    int offset = 0;
                    if(p - b > 0)
                    { /* get rid of \r */
                        if(p[-1] == _T('\r'))
                            offset = 1;
                    } /* get rid of \r */
                    *line += CString(b, (p - b) - offset);
                    output += line->GetBuffer(0) ;
                    output += '\r\n';

                    b = p + 1;
                    line = new CString;
                } /* complete line */
            } /* convert and send */
        } /* got data */

        DWORD err = ::GetLastError();

        ::CloseHandle(hreadFromChild);


        if(line->GetLength() > 0) {
            output += line->GetBuffer(0) ;
            output += '\r\n';
        }

        else
            delete line;
     
        DWORD status = 0;
        if(err != ERROR_BROKEN_PIPE)
            status = err;

//      ::CloseHandle(hreadFromChild);
//      ::CloseHandle(hwriteToParent);
//      ::CloseHandle(hwriteToParent2);

    }
    else {

        CWinThread * thread = AfxBeginThread(Listener, (LPVOID)this);
        if(thread == NULL)
        { /* failed */
            DWORD err = ::GetLastError();
            ::CloseHandle(hreadFromChild);
            ::CloseHandle(hwriteToParent);
            ::CloseHandle(hwriteToParent2);
//          delete this;
            return FALSE;
        }
        return 0;

    }
    
    unsigned long exitCode;
    WaitForSingleObject(procinfo.hProcess,1000 );
    GetExitCodeProcess(procinfo.hProcess, &exitCode);
    return exitCode;
}

UINT Executor::Listener(LPVOID me)
{
    ((Executor *)me)->Listener();
    return 0;
} // Executor::listener


void Executor::Listener()
{
    TCHAR buffer[MAX_LINE_LENGTH + 1];

    CString * line;
    line = new CString;

    DWORD bytesRead;
     
    while(::ReadFile(hreadFromChild, buffer, sizeof(buffer) - sizeof(TCHAR), &bytesRead, NULL))
    { /* got data */
        if(bytesRead == 0)
            break; // EOF condition
     
        buffer[bytesRead] = _T('\0');
        // Convert to lines
        LPTSTR b = buffer;
        while(TRUE)
        { /* convert and send */
            LPTSTR p = _tcschr(b, _T('\n'));
            if(p == NULL)
            { /* incomplete line */
                *line += b;
                break; // leave assembly loop
            } /* incomplete line */
            else
            { /* complete line */
                int offset = 0;
                if(p - b > 0)
                { /* get rid of \r */
                    if(p[-1] == _T('\r'))
                        offset = 1;
                } /* get rid of \r */
                *line += CString(b, (p - b) - offset);
                output += line->GetBuffer(0) ;
                if ( onLine ) onLine(line->GetBuffer(0) );
                b = p + 1;
                line = new CString;
            } /* complete line */
        } /* convert and send */
    } /* got data */

    DWORD err = ::GetLastError();

    ::CloseHandle(hreadFromChild);


    if(line->GetLength() > 0) {
        output += line->GetBuffer(0) ;
        if ( onLine ) onLine(line->GetBuffer(0) );
    }

    else
        delete line;
     
    DWORD status = 0;
    if(err != ERROR_BROKEN_PIPE)
        status = err;
     
//  target->PostMessage(UPM_FINISHED, status, (LPARAM)pid);
    if ( onFinished ) onFinished(output);
//  delete this;
} // Executor::listener


DWORD RunSilent(char* strFunct, char* strstrParams, const string& outputFile )
{
    
    STARTUPINFO StartupInfo;
    PROCESS_INFORMATION ProcessInfo;
    char Args[4096];
    char *pEnvCMD = NULL;
    char *pDefaultCMD = "CMD.EXE";
    ULONG rc;
    
    memset(&StartupInfo, 0, sizeof(StartupInfo));
    StartupInfo.cb = sizeof(STARTUPINFO);
    StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
    StartupInfo.wShowWindow = SW_HIDE;
    
    Args[0] = 0;
    
    pEnvCMD = getenv("COMSPEC");
    
    if(pEnvCMD){
        
        strcpy(Args, pEnvCMD);
    }
    else{
        strcpy(Args, pDefaultCMD);
    }
    
    // "/c" option - Do the command then terminate the command window
    strcat(Args, " /c "); 
    //the application you would like to run from the command window
    strcat(Args, strFunct);  
    strcat(Args, " "); 
    //the parameters passed to the application being run from the command window.
    strcat(Args, strstrParams); 
    
    if (outputFile != "none") {
        
        strcat(Args," > ");
        //      AfxMessageBox(outputFile.c);
        strcat(Args,outputFile.c_str());
    }
    
    //      ofstream out("C:\\args.txt");
    //      out << Args;
    //  out.close();
    //      AfxMessageBox(Args);
    
    
    
    if (!CreateProcess( NULL, Args, NULL, NULL, FALSE,
        CREATE_NEW_CONSOLE, 
        NULL, 
        NULL,
        &StartupInfo,
        &ProcessInfo))
    {
        return GetLastError();      
    }
    
    WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    
    
    
    
    
    
    if(!GetExitCodeProcess(ProcessInfo.hProcess, &rc))
        rc = 0;
    
    /*  CloseHandle(ProcessInfo.hThread); */
    /*  CloseHandle(ProcessInfo.hProcess); */
    
    return rc;
    
}

DWORD RunLoud(char* strFunct, char* strParams) {
    

    STARTUPINFO StartupInfo;
    PROCESS_INFORMATION ProcessInfo;
    char Args[4096];
    char *pEnvCMD = NULL;
    char *pDefaultCMD = "CMD.EXE";
    ULONG rc;
    
    memset(&StartupInfo, 0, sizeof(StartupInfo));
    StartupInfo.cb = sizeof(STARTUPINFO);
    StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
    StartupInfo.wShowWindow = SW_HIDE;
    
    Args[0] = 0;
    
    pEnvCMD = getenv("COMSPEC");
    
    if(pEnvCMD){
        
        strcpy(Args, pEnvCMD);
    }
    else{
        strcpy(Args, pDefaultCMD);
    }
    
    // "/c" option - Do the command then terminate the command window
    strcat(Args, " /k "); 
    //the application you would like to run from the command window
    strcat(Args, strFunct);  
    strcat(Args, " "); 
    //the parameters passed to the application being run from the command window.
    strcat(Args, strParams); 
    
    
    
    if (!CreateProcess( NULL, Args, NULL, NULL, FALSE,
        CREATE_NEW_CONSOLE, 
        NULL, 
        NULL,
        &StartupInfo,
        &ProcessInfo))
    {
        return GetLastError();      
    }
    
    
    
    
    
    
    if(!GetExitCodeProcess(ProcessInfo.hProcess, &rc))
        rc = 0;
    
    /*  CloseHandle(ProcessInfo.hThread); */
    /*  CloseHandle(ProcessInfo.hProcess); */
    
    return rc;
}