command_line_program.cpp

Go to the documentation of this file.

//ok -- so this is a hack of the MFC code on codeguru, which is in turn claims 
//to be a hack of some MSDN example code -- though the article never made it
//clear /what/ example it came from (my best guess is INHERIT.C)..
//http://www.codeguru.com/Cpp/misc/misc/article.php/c277

//a broad warning to those of you who may want to port this code to your own projects:
//there is, as best as i can tell, no way to do something like this without using 
//multithreading, as well as the (arcane and poorly designed) win32 process 
//mannagement API.  if this worries you, 
//stop here and go take a long hard look at _popen() -- chances are, it's good 
//enough for whatever you are trying to do.

//(10/23/05) The phantom window problem has finally been fixed:
//      Using DETACHED_PROCESS, as in the codeguru demo, caused
//      grandchildren of your programs to make their own window,
//      (not the effect I had wanted; the phantom windows could become 
//      really annoying in GUI programs that had a lot of grandchildren).
//      After a moderatly painful hunt through MSDN, I discovered that changing 
//      dwCreationFlags to CREATE_NO_WINDOW fixs the issue.  Notice that this
//  is a major win over _popen(), which, when used in a gui program, will creates 
//      phantom windows for both children
//      and grandchildren.

//(7/22/06) I've made various fixes and updates, the most notable being the new
//  pipe_read() function, which is less prone to hanging at odd times than the 
//  origional implementation, and the complete_reading() functions, which can
//  be used to ensure that all the output of a given process will, in fact, be
//  read.

#pragma warning(disable: 4355) // 'this' used in base member initializer list 
#pragma warning(disable: 4800) // conversion from int to bool
#pragma warning(disable: 4267) // conversion from unsigned to signed
#pragma warning(disable: 4244) // conversion to int from double

#include <windows.h> 
#include <atlbase.h>
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sven/fs_addons.h>

#include <stdexcept>
#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>

#include <Winuser.h>

#include <string>
#include <sven_ui/commands.h>
#include <sven/except_macros.h>
#include <sven/string_addons.h>

//disable warnings which some skimming of the boost forums suggests
//are mostly unavoidable results of msvc having crappy template handling.
#pragma warning(disable: 4275) 
#pragma warning(disable: 4251) 

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>
#include <boost/thread/condition.hpp>

#include <sven_ui/command_line_program.h>
#include <sven/message_boxes.h>
#include <sven/timer.h>
#include <com_helpers.h>


using namespace std;
using namespace sven;

namespace sven_ui { 

void thread_sleep(double seconds) {
        boost::xtime xt;
        boost::xtime_get(&xt, boost::TIME_UTC);

        //while thread::sleep takes a time in an integer number of nanoseconds,
        //i prefer a floating point second representation.
        xt.nsec += pow(10.0,9.0)*seconds; 
        boost::thread::sleep(xt); 
}

namespace cmdline_prog_imp {

size_t tstrlen(TCHAR * str) {
#ifdef _UNICODE
        return wcslen(str);
#else 
        return strlen(str);
#endif
}

bool pipe_read(HANDLE pipe, const int BUFSIZE, TCHAR chBuf[]) {

        DWORD dwRead,dwRead2,avail,bytes_left;
        if(!PeekNamedPipe (pipe,chBuf,BUFSIZE,&dwRead,&avail,&bytes_left))
                return false;
        if(!bytes_left && !dwRead) return false;
        if( !ReadFile( pipe, chBuf, 
                dwRead, &dwRead2, NULL) || dwRead == 0) {
                return false;                   
        }

        chBuf[dwRead2]='\0';
        return true;
}




struct CommandLineProgram {

        bool dying;     

        boost::mutex read_mutex;
        ostringstream read_buf;
        
        boost::mutex read_error_mutex;
        ostringstream read_error_buf;

        boost::mutex write_mutex;
        ostringstream write_buf;

        boost::thread * cmd_watch_thread;
        boost::thread * cmd_watch_error_thread;
        boost::thread * cmd_write_thread;

        HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup, 
                hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup, 
                hChildStderrorRd, hChildStderrorWr, hChildStderrorRdDup, 
                hSaveStdin, hSaveStdout, hSaveStderror;  
        DWORD dwProcessId;

        double write_tick;
        
        double read_tick;

        double finish_tick;

        double finish_timeout;


        bool seperate_std_error;

        bool writeable;

        fs::wpath starting_dir; 

        /*
        //
        // functions and variables used to notify the parent that the
        // write thread is done.
        //
        boost::mutex write_dead_mutex;
        bool write_is_dead;
        bool write_dead() {
                boost::mutex::scoped_lock lock(write_dead_mutex);
                return write_is_dead;
        }
        void make_write_dead() {
                boost::mutex::scoped_lock lock(write_dead_mutex);
                write_is_dead=true;
        }*/


        struct read_function {
                CommandLineProgram * parent;

                read_function(CommandLineProgram * parent) : parent(parent) {}

                void complete_reading() {
                        
                        const int BUFSIZE = 32;
                        TCHAR chBuf[BUFSIZE+1];

                        while(true) {

                                if(!pipe_read(parent->hChildStdoutRdDup, BUFSIZE,chBuf)) break;
                                
                                if(tstrlen(chBuf)) {
                                        boost::mutex::scoped_lock lock(parent->read_mutex);
                                        parent->read_buf << chBuf;
                                }

                                thread_sleep(parent->read_tick);                
                        }
                }



                void operator()() {
                
                        const int BUFSIZE =32;

                        DWORD dwRead;
                        TCHAR chBuf[BUFSIZE+1]; 

                        //cout << "starting read.." << endl;
                        while(true) { 

                                if(pipe_read(parent->hChildStdoutRdDup, BUFSIZE, chBuf)) {
                                        if(tstrlen(chBuf)) {
                                                boost::mutex::scoped_lock lock(parent->read_mutex);
                                                parent->read_buf << chBuf;
                                        }
                                }

                                {
                                        boost::mutex::scoped_lock lock(parent->write_mutex);
                                        if(parent->dying) {
                                                break;
                                        }
                                }

                                if(parent->read_tick) thread_sleep(parent->read_tick);
                        
                        }

                        complete_reading() ;
                }
        };

        struct read_error_function {
                CommandLineProgram * parent;

                read_error_function(CommandLineProgram * parent) : parent(parent) {}


                void complete_reading() {
                        
                        const int BUFSIZE = 32;
                        TCHAR chBuf[BUFSIZE+1];

                        while(true) {

                                boost::mutex::scoped_lock lock(parent->read_error_mutex);
                                if(!pipe_read(parent->hChildStderrorRdDup, BUFSIZE,chBuf)) break;
                                
                                if(tstrlen(chBuf)) {
                                        boost::mutex::scoped_lock lock(parent->read_error_mutex);
                                        parent->read_error_buf << chBuf;
                                }

                                thread_sleep(parent->read_tick);                
                        }
                }

                void operator()() {
                
                        const int BUFSIZE =32;

                        DWORD dwRead;
                        TCHAR chBuf[BUFSIZE+1]; 

                        //cout << "starting read.." << endl;
                        while(true) { 

                                if(pipe_read(parent->hChildStderrorRdDup, BUFSIZE, chBuf)) {
                                        if(tstrlen(chBuf)) {
                                                boost::mutex::scoped_lock lock(parent->read_error_mutex);
                                                parent->read_error_buf << chBuf;
                                        }
                                }

                                {
                                        boost::mutex::scoped_lock lock(parent->write_mutex);
                                        if(parent->dying) {
                                                break;
                                        }
                                }

                                if(parent->read_tick) thread_sleep(parent->read_tick);
                        
                        }

                        complete_reading() ;
                }

        };

        struct write_function {
                CommandLineProgram * parent;
                write_function(CommandLineProgram * parent) : parent(parent) {}

                void operator()() {

                        while(true) {
                                DWORD dwWritten;

                                string to_write;
                                to_write="";
                                {
                                        boost::mutex::scoped_lock lock(parent->write_mutex);
                                        to_write=parent->write_buf.str();
                                        parent->write_buf.str("");
                                }
                                if(to_write.size()) {

                                        bool bSuccess = 
                                                WriteFile( parent->hChildStdinWrDup, to_write.c_str(),to_write.size(), &dwWritten, NULL );
                                        
                                        
                                        if(!bSuccess) {
                                                DWORD write_error= GetLastError();

                                                sven::error_msg(fmt("Could not write \"%s\" to thread.\n%s") % to_write % com_help::format_error_string(write_error));
                                                 
                                                //terminate this thread
                                                break;
                                        }

                                        
                                }

                                if(parent->write_tick) thread_sleep(parent->write_tick);
                                
                                {
                                        boost::mutex::scoped_lock lock(parent->write_mutex);
                                        if(parent->dying) break;
                                }                       
                        }

                }
        };

        read_function reader;
        read_error_function read_error_er;
        write_function writer;

        CommandLineProgram() 
                : reader(this), writer(this), read_error_er(this), 
                
                write_tick(.05), read_tick(.01), 
                finish_tick(.03), finish_timeout(0), 

                seperate_std_error(false), writeable(true),
                dying(false)
        {}

        boost::mutex handle_mutex;



        void create_process(cstring name) {

                USES_CONVERSION;

                SECURITY_ATTRIBUTES saAttr;
                BOOL fSuccess;

                // Set the bInheritHandle flag so pipe handles are inherited.
                saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
                saAttr.bInheritHandle = TRUE;
                saAttr.lpSecurityDescriptor = NULL;

                // The steps for redirecting child process's STDOUT:
                // 1. Save current STDOUT, to be restored later.
                // 2. Create anonymous pipe to be STDOUT for child process.
                // 3. Set STDOUT of the parent process to be write handle to
                // the pipe, so it is inherited by the child process.
                // 4. Create a noninheritable duplicate of the read handle and
                // close the inheritable read handle.

                // Save the handle to the current STDOUT.
                hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);

                // Create a pipe for the child process's STDOUT.
                if( !CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0) )
                {
                        throw std::runtime_error("Stdout pipe creation failed");
                }

                // Set a write handle to the pipe to be STDOUT.
                if( !SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr) )
                {
                        throw std::runtime_error("Redirecting STDOUT failed");
                }

                // Create noninheritable read handle and close the inheritable read handle.
                fSuccess = DuplicateHandle( GetCurrentProcess(), hChildStdoutRd,
                GetCurrentProcess(), &hChildStdoutRdDup ,
                0, FALSE,
                DUPLICATE_SAME_ACCESS );
                if( !fSuccess )
                {
                throw std::runtime_error("DuplicateHandle failed");
                }
                CloseHandle( hChildStdoutRd );

                if(seperate_std_error) {
                        // Save the handle to the current STDERR.
                        hSaveStderror = GetStdHandle(STD_ERROR_HANDLE);

                        // Create a pipe for the child process's STDOUT.
                        if( !CreatePipe( &hChildStderrorRd, &hChildStderrorWr, &saAttr, 0) )
                        {
                                throw std::runtime_error("Stderror pipe creation failed");
                        }

                        // Set a write handle to the pipe to be STDOUT.
                        if( !SetStdHandle(STD_ERROR_HANDLE, hChildStderrorWr) )
                        {
                                throw std::runtime_error("Redirecting STDERROR failed");
                        }

                        // Create noninheritable read handle and close the inheritable read handle.
                        fSuccess = DuplicateHandle( GetCurrentProcess(), hChildStderrorRd,
                        GetCurrentProcess(), &hChildStderrorRdDup ,
                        0, FALSE,
                        DUPLICATE_SAME_ACCESS );
                        if( !fSuccess )
                        {
                        throw std::runtime_error("DuplicateHandle failed");
                        }
                        CloseHandle( hChildStderrorRd );
                }


                // The steps for redirecting child process's STDIN:
                // 1. Save current STDIN, to be restored later.
                // 2. Create anonymous pipe to be STDIN for child process.
                // 3. Set STDIN of the parent to be the read handle to the
                // pipe, so it is inherited by the child process.
                // 4. Create a noninheritable duplicate of the write handle,
                // and close the inheritable write handle.

                // Save the handle to the current STDIN.
                hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);

                // Create a pipe for the child process's STDIN.
                if( !CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0) )
                        throw std::runtime_error("Stdin pipe creation failed");

                
                // Set a read handle to the pipe to be STDIN.
                if( !SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd) )
                        throw std::runtime_error("Redirecting Stdin failed");
                
                // Duplicate the write handle to the pipe so it is not inherited.
                fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,
                GetCurrentProcess(), &hChildStdinWrDup,
                0, FALSE, // not inherited
                DUPLICATE_SAME_ACCESS );
                if( !fSuccess )
                        throw std::runtime_error("DuplicateHandle failed");
                
                CloseHandle(hChildStdinWr);

                //prepare to start the process....              
                PROCESS_INFORMATION piProcInfo;
                STARTUPINFOW siStartInfo;

                // Set up members of STARTUPINFO structure.
                ZeroMemory( &siStartInfo, sizeof(STARTUPINFOW) );
                siStartInfo.cb = sizeof(STARTUPINFOW);

//              siStartInfo.wShowWindow = SW_HIDE;
                siStartInfo.dwFlags = STARTF_USESTDHANDLES;
                siStartInfo.hStdInput = hChildStdinRd;
                siStartInfo.hStdOutput = hChildStdoutWr;
                siStartInfo.hStdError = seperate_std_error ?
                                                        hChildStderrorWr : hChildStdoutWr;

                wchar_t * cmd_name=new wchar_t[name.size()+1];
                swprintf(cmd_name,L"%s",a2w(name).c_str());

                wstring absolute_starting_dir = (fs::wpath(get_current_directory_w(), fs::native) / starting_dir).native_directory_string();
                if(!starting_dir.empty()) sven_ui::report("starting dir is : " + qwp(w2a(absolute_starting_dir)) );
                
                // a dirty hack to make unicode conversion to TCHAR's work
                // in the two cases i care about.
        /*      #ifdef _UNICODE
                #define mA2T(str) A2T(str)
                #else
                #define mA2T(str) (str)
                #endif
        */                      
                // Create the child process.
                BOOL ret = CreateProcessW( NULL,
                cmd_name, // applicatin name
                NULL, // process security attributes
                NULL, // primary thread security attributes
                TRUE, // handles are inherited
                //DETACHED_PROCESS //was the code project default, proved troublesome
                CREATE_NO_WINDOW /*| HIGH_PRIORITY_CLASS*/, // creation flags
                NULL, //use the parent's enviornment
                absolute_starting_dir.empty() ? NULL : absolute_starting_dir.c_str(), // set the path
                &siStartInfo, // STARTUPINFO pointer
                &piProcInfo); // receives PROCESS_INFORMATION
                delete [] cmd_name;

                if( ret )
                dwProcessId = piProcInfo.dwProcessId;
                if(!ret) RT_ERROR_ARGS("CreateChildProcess failed with cmd = %s", sven::qw(w2a(cmd_name)));
                

                // After process creation, restore the saved STDIN and STDOUT.
                if( !SetStdHandle(STD_INPUT_HANDLE, hSaveStdin) )
                        throw std::runtime_error("Re-redirecting Stdin failed" );

                if( !SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout) )
                        throw std::runtime_error("Re-redirecting Stdout failed");

                if( seperate_std_error && !SetStdHandle(STD_ERROR_HANDLE, hSaveStderror) )
                        throw std::runtime_error("Re-redirecting Stderror failed");
        
                cmd_watch_thread=new boost::thread(reader);
                if(seperate_std_error )
                        cmd_watch_error_thread=new boost::thread(read_error_er);
                cmd_write_thread=new boost::thread(writer);

        }


        void write_line(string s) {
                if(!writeable) {
                        RT_ERROR_ARGS("can't write \"%s\" to process, because the process has not been declared as writeable.",s);
                }
                boost::mutex::scoped_lock lock(write_mutex);
                write_buf << s << endl;
        }

        string read() {
                boost::mutex::scoped_lock lock(read_mutex);
                string rval = read_buf.str();
                sven::delete_carriage_returns(rval);
                read_buf.str("");
                return rval;
        }
        string read_error() {
                boost::mutex::scoped_lock lock(read_error_mutex);
                string rval = read_error_buf.str();
                sven::delete_carriage_returns(rval);
                read_error_buf.str("");
                return rval;
        }


        ~CommandLineProgram() {
                //i think this should kill the threads and the process...
        
                //ExitProcess();

                //write_line("exit");
                //thread_sleep_sec(10*(write_tick + read_tick));

                //      terminate_threads();
        }

        //need a "process is dead" function...
        bool process_is_dead() {
                DWORD status;
                HANDLE hProcess=OpenProcess(PROCESS_QUERY_INFORMATION,FALSE,dwProcessId);
                if(!hProcess) throw std::runtime_error("tried to query idle for a process that doesn't seem to exist at all...");
                GetExitCodeProcess(hProcess,&status);
                CloseHandle( hProcess );
                return status!=STILL_ACTIVE;
        }

        void terminate_threads() {
                
                {
                                boost::mutex::scoped_lock lock2(read_mutex);
                                boost::mutex::scoped_lock lock3(write_mutex);
                                dying =true;
                }


                //for reasons that i completly fail to understand,
                //joing the write thread seems to prevent scope badness,
                //while joining the watch thread seems to provoke a crash.
                //(for reasons that i still fail completly to understand, this seems to fix it...)

                cmd_watch_thread->join();
                if(seperate_std_error) cmd_watch_error_thread->join();
                cmd_write_thread->join();

                delete cmd_watch_thread;
                if(seperate_std_error) delete cmd_watch_error_thread;
                delete cmd_write_thread;



                {
                        boost::mutex::scoped_lock lock(handle_mutex);   
                
                        if(!process_is_dead()) {
                                HANDLE hProcess = OpenProcess( PROCESS_TERMINATE, FALSE, dwProcessId );
                                if( hProcess )
                                {
                                        //cout << "had to do a kill" << endl;
                                        TerminateProcess( hProcess,0 );
                                }
                        }

                        CloseHandle( hChildStdinRd);
                        CloseHandle( hChildStdoutWr);
                        CloseHandle( hChildStdinWrDup );
                        CloseHandle( hChildStdoutRdDup );

                        if(seperate_std_error) {        
                                CloseHandle( hChildStderrorWr);
                                CloseHandle( hChildStderrorRdDup );
                        }
                }
        }

        void wait_for_complete() {
                if(finish_timeout>0) {
                        sven::timer t;
                        while(!process_is_dead()) {
                                thread_sleep(finish_tick);
                                if(t.elapsed()>finish_timeout) RT_ERROR_ARGS("process did not complete within specified time (%s).", t.human_readable());
                        }
                }
                else {
                        while(!process_is_dead()) thread_sleep(finish_tick);
                }
        }

        void finish() {
                wait_for_complete();
                terminate_threads();
        }
};

}

// for this to work, we need to be sure that the initilization of
// wrapped will take place prior to the initilization of the double 
// references (read_tick, write_tick, et alius).
//
// according to the 2003 C++ standard ( ISO/IEC 14882:2003(E) )
// section 12.6.2:5, the order in which the initilizers will be called
// is termined by the position of their declaration in the class.
//
CommandLineProgram::CommandLineProgram() : 
        wrapped(new cmdline_prog_imp::CommandLineProgram()),
        #define REF(x) x(wrapped->x)
        REF(write_tick), REF(read_tick), REF(finish_tick), REF(finish_timeout), 
        REF(seperate_std_error), REF(writeable), REF(starting_dir)
        #undef REF
{}

CommandLineProgram::~CommandLineProgram() { delete wrapped;}

void CommandLineProgram::write_line(cstring s) { wrapped->write_line(s); }

string CommandLineProgram::read() { return wrapped->read(); }
string CommandLineProgram::read_error() { return wrapped->read_error(); }

bool  CommandLineProgram::process_is_dead() { return wrapped->process_is_dead(); }

void CommandLineProgram::finish() { return wrapped->finish(); }
void CommandLineProgram::create_process(cstring name) { return wrapped->create_process(name); }
void CommandLineProgram::terminate_threads() { wrapped->terminate_threads(); }

}

---