1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/utilsexec.cpp
3 // Purpose: wxExecute implementation for MSW
4 // Author: Julian Smart
8 // Copyright: (c) 1998-2002 wxWindows dev team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
39 #include "wx/stream.h"
40 #include "wx/process.h"
43 #include "wx/apptrait.h"
45 #include "wx/msw/private.h"
49 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) && !defined(__WXMICROWIN__)
56 #if defined(__GNUWIN32__)
57 #include <sys/unistd.h>
61 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
75 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
82 #include "wx/dde.h" // for WX_DDE hack in wxExecute
85 // ----------------------------------------------------------------------------
87 // ----------------------------------------------------------------------------
89 // this message is sent when the process we're waiting for terminates
90 #define wxWM_PROC_TERMINATED (WM_USER + 10000)
92 // ----------------------------------------------------------------------------
93 // this module globals
94 // ----------------------------------------------------------------------------
96 // we need to create a hidden window to receive the process termination
97 // notifications and for this we need a (Win) class name for it which we will
98 // register the first time it's needed
99 static const wxChar
*gs_classForHiddenWindow
= NULL
;
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 // structure describing the process we're being waiting for
112 if ( !::CloseHandle(hProcess
) )
114 wxLogLastError(wxT("CloseHandle(hProcess)"));
119 HWND hWnd
; // window to send wxWM_PROC_TERMINATED to
120 HANDLE hProcess
; // handle of the process
121 DWORD dwProcessId
; // pid of the process
123 DWORD dwExitCode
; // the exit code of the process
124 bool state
; // set to FALSE when the process finishes
127 #if defined(__WIN32__) && wxUSE_STREAMS
129 // ----------------------------------------------------------------------------
131 // ----------------------------------------------------------------------------
133 class wxPipeInputStream
: public wxInputStream
136 wxPipeInputStream(HANDLE hInput
);
137 virtual ~wxPipeInputStream();
139 // returns TRUE if the pipe is still opened
140 bool IsOpened() const { return m_hInput
!= INVALID_HANDLE_VALUE
; }
142 // returns TRUE if there is any data to be read from the pipe
143 virtual bool CanRead() const;
146 size_t OnSysRead(void *buffer
, size_t len
);
151 DECLARE_NO_COPY_CLASS(wxPipeInputStream
)
154 class wxPipeOutputStream
: public wxOutputStream
157 wxPipeOutputStream(HANDLE hOutput
);
158 virtual ~wxPipeOutputStream();
161 size_t OnSysWrite(const void *buffer
, size_t len
);
166 DECLARE_NO_COPY_CLASS(wxPipeOutputStream
)
169 // define this to let wxexec.cpp know that we know what we're doing
170 #define _WX_USED_BY_WXEXECUTE_
171 #include "../common/execcmn.cpp"
173 // ----------------------------------------------------------------------------
174 // wxPipe represents a Win32 anonymous pipe
175 // ----------------------------------------------------------------------------
180 // the symbolic names for the pipe ends
187 // default ctor doesn't do anything
188 wxPipe() { m_handles
[Read
] = m_handles
[Write
] = INVALID_HANDLE_VALUE
; }
190 // create the pipe, return TRUE if ok, FALSE on error
193 // default secutiry attributes
194 SECURITY_ATTRIBUTES security
;
196 security
.nLength
= sizeof(security
);
197 security
.lpSecurityDescriptor
= NULL
;
198 security
.bInheritHandle
= TRUE
; // to pass it to the child
200 if ( !::CreatePipe(&m_handles
[0], &m_handles
[1], &security
, 0) )
202 wxLogSysError(_("Failed to create an anonymous pipe"));
210 // return TRUE if we were created successfully
211 bool IsOk() const { return m_handles
[Read
] != INVALID_HANDLE_VALUE
; }
213 // return the descriptor for one of the pipe ends
214 HANDLE
operator[](Direction which
) const
216 wxASSERT_MSG( which
>= 0 && (size_t)which
< WXSIZEOF(m_handles
),
217 _T("invalid pipe index") );
219 return m_handles
[which
];
222 // detach a descriptor, meaning that the pipe dtor won't close it, and
224 HANDLE
Detach(Direction which
)
226 wxASSERT_MSG( which
>= 0 && (size_t)which
< WXSIZEOF(m_handles
),
227 _T("invalid pipe index") );
229 HANDLE handle
= m_handles
[which
];
230 m_handles
[which
] = INVALID_HANDLE_VALUE
;
235 // close the pipe descriptors
238 for ( size_t n
= 0; n
< WXSIZEOF(m_handles
); n
++ )
240 if ( m_handles
[n
] != INVALID_HANDLE_VALUE
)
242 ::CloseHandle(m_handles
[n
]);
243 m_handles
[n
] = INVALID_HANDLE_VALUE
;
248 // dtor closes the pipe descriptors
249 ~wxPipe() { Close(); }
255 #endif // wxUSE_STREAMS
257 // ============================================================================
259 // ============================================================================
263 // ----------------------------------------------------------------------------
264 // process termination detecting support
265 // ----------------------------------------------------------------------------
267 // thread function for the thread monitoring the process termination
268 static DWORD __stdcall
wxExecuteThread(void *arg
)
270 wxExecuteData
* const data
= (wxExecuteData
*)arg
;
272 if ( ::WaitForSingleObject(data
->hProcess
, INFINITE
) != WAIT_OBJECT_0
)
274 wxLogDebug(_T("Waiting for the process termination failed!"));
278 if ( !::GetExitCodeProcess(data
->hProcess
, &data
->dwExitCode
) )
280 wxLogLastError(wxT("GetExitCodeProcess"));
283 wxASSERT_MSG( data
->dwExitCode
!= STILL_ACTIVE
,
284 wxT("process should have terminated") );
286 // send a message indicating process termination to the window
287 ::SendMessage(data
->hWnd
, wxWM_PROC_TERMINATED
, 0, (LPARAM
)data
);
292 // window procedure of a hidden window which is created just to receive
293 // the notification message when a process exits
294 LRESULT APIENTRY _EXPORT
wxExecuteWindowCbk(HWND hWnd
, UINT message
,
295 WPARAM wParam
, LPARAM lParam
)
297 if ( message
== wxWM_PROC_TERMINATED
)
299 DestroyWindow(hWnd
); // we don't need it any more
301 wxExecuteData
* const data
= (wxExecuteData
*)lParam
;
304 data
->handler
->OnTerminate((int)data
->dwProcessId
,
305 (int)data
->dwExitCode
);
310 // we're executing synchronously, tell the waiting thread
311 // that the process finished
316 // asynchronous execution - we should do the clean up
324 return ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
328 // ============================================================================
329 // implementation of IO redirection support classes
330 // ============================================================================
334 // ----------------------------------------------------------------------------
335 // wxPipeInputStreams
336 // ----------------------------------------------------------------------------
338 wxPipeInputStream::wxPipeInputStream(HANDLE hInput
)
343 wxPipeInputStream::~wxPipeInputStream()
345 if ( m_hInput
!= INVALID_HANDLE_VALUE
)
346 ::CloseHandle(m_hInput
);
349 bool wxPipeInputStream::CanRead() const
356 // function name is misleading, it works with anon pipes as well
357 DWORD rc
= ::PeekNamedPipe
360 NULL
, 0, // ptr to buffer and its size
361 NULL
, // [out] bytes read
362 &nAvailable
, // [out] bytes available
363 NULL
// [out] bytes left
368 if ( ::GetLastError() != ERROR_BROKEN_PIPE
)
371 wxLogLastError(_T("PeekNamedPipe"));
374 // don't try to continue reading from a pipe if an error occured or if
375 // it had been closed
376 ::CloseHandle(m_hInput
);
378 wxPipeInputStream
*self
= wxConstCast(this, wxPipeInputStream
);
380 self
->m_hInput
= INVALID_HANDLE_VALUE
;
381 self
->m_lasterror
= wxSTREAM_EOF
;
386 return nAvailable
!= 0;
389 size_t wxPipeInputStream::OnSysRead(void *buffer
, size_t len
)
393 m_lasterror
= wxSTREAM_EOF
;
399 if ( !::ReadFile(m_hInput
, buffer
, len
, &bytesRead
, NULL
) )
401 m_lasterror
= ::GetLastError() == ERROR_BROKEN_PIPE
403 : wxSTREAM_READ_ERROR
;
406 // bytesRead is set to 0, as desired, if an error occured
410 // ----------------------------------------------------------------------------
411 // wxPipeOutputStream
412 // ----------------------------------------------------------------------------
414 wxPipeOutputStream::wxPipeOutputStream(HANDLE hOutput
)
419 wxPipeOutputStream::~wxPipeOutputStream()
421 ::CloseHandle(m_hOutput
);
424 size_t wxPipeOutputStream::OnSysWrite(const void *buffer
, size_t len
)
428 m_lasterror
= wxSTREAM_NO_ERROR
;
429 if ( !::WriteFile(m_hOutput
, buffer
, len
, &bytesWritten
, NULL
) )
431 m_lasterror
= ::GetLastError() == ERROR_BROKEN_PIPE
433 : wxSTREAM_WRITE_ERROR
;
439 #endif // wxUSE_STREAMS
443 // ============================================================================
444 // wxExecute functions family
445 // ============================================================================
449 // connect to the given server via DDE and ask it to execute the command
450 static bool wxExecuteDDE(const wxString
& ddeServer
,
451 const wxString
& ddeTopic
,
452 const wxString
& ddeCommand
)
457 wxConnectionBase
*conn
= client
.MakeConnection(wxEmptyString
,
464 else // connected to DDE server
466 // the added complication here is that although most
467 // programs use XTYP_EXECUTE for their DDE API, some
468 // important ones - like IE and other MS stuff - use
471 // so we try one first and then the other one if it
475 ok
= conn
->Execute(ddeCommand
);
480 // now try request - but show the errors
481 ok
= conn
->Request(ddeCommand
) != NULL
;
490 long wxExecute(const wxString
& cmd
, int flags
, wxProcess
*handler
)
492 wxCHECK_MSG( !!cmd
, 0, wxT("empty command in wxExecute") );
495 // for many reasons, the code below breaks down if it's called from another
496 // thread -- this could be fixed, but as Unix versions don't support this
497 // neither I don't want to waste time on this now
498 wxASSERT_MSG( wxThread::IsMain(),
499 _T("wxExecute() can be called only from the main thread") );
500 #endif // wxUSE_THREADS
505 // DDE hack: this is really not pretty, but we need to allow this for
506 // transparent handling of DDE servers in wxMimeTypesManager. Usually it
507 // returns the command which should be run to view/open/... a file of the
508 // given type. Sometimes, however, this command just launches the server
509 // and an additional DDE request must be made to really open the file. To
510 // keep all this well hidden from the application, we allow a special form
511 // of command: WX_DDE#<command>#DDE_SERVER#DDE_TOPIC#DDE_COMMAND in which
512 // case we execute just <command> and process the rest below
513 wxString ddeServer
, ddeTopic
, ddeCommand
;
514 static const size_t lenDdePrefix
= 7; // strlen("WX_DDE:")
515 if ( cmd
.Left(lenDdePrefix
) == _T("WX_DDE#") )
517 // speed up the concatenations below
518 ddeServer
.reserve(256);
519 ddeTopic
.reserve(256);
520 ddeCommand
.reserve(256);
522 const wxChar
*p
= cmd
.c_str() + 7;
523 while ( *p
&& *p
!= _T('#') )
535 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
538 while ( *p
&& *p
!= _T('#') )
550 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
553 while ( *p
&& *p
!= _T('#') )
565 wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
573 // if we want to just launch the program and not wait for its
574 // termination, try to execute DDE command right now, it can succeed if
575 // the process is already running - but as it fails if it's not
576 // running, suppress any errors it might generate
577 if ( !(flags
& wxEXEC_SYNC
) )
580 if ( wxExecuteDDE(ddeServer
, ddeTopic
, ddeCommand
) )
582 // a dummy PID - this is a hack, of course, but it's well worth
583 // it as we don't open a new server each time we're called
584 // which would be quite bad
596 // the IO redirection is only supported with wxUSE_STREAMS
597 BOOL redirect
= FALSE
;
600 wxPipe pipeIn
, pipeOut
, pipeErr
;
602 // we'll save here the copy of pipeIn[Write]
603 HANDLE hpipeStdinWrite
= INVALID_HANDLE_VALUE
;
605 // open the pipes to which child process IO will be redirected if needed
606 if ( handler
&& handler
->IsRedirected() )
608 // create pipes for redirecting stdin, stdout and stderr
609 if ( !pipeIn
.Create() || !pipeOut
.Create() || !pipeErr
.Create() )
611 wxLogSysError(_("Failed to redirect the child process IO"));
613 // indicate failure: we need to return different error code
614 // depending on the sync flag
615 return flags
& wxEXEC_SYNC
? -1 : 0;
620 #endif // wxUSE_STREAMS
622 // create the process
630 si
.dwFlags
= STARTF_USESTDHANDLES
;
632 si
.hStdInput
= pipeIn
[wxPipe::Read
];
633 si
.hStdOutput
= pipeOut
[wxPipe::Write
];
634 si
.hStdError
= pipeErr
[wxPipe::Write
];
636 // when the std IO is redirected, we don't show the (console) process
637 // window by default, but this can be overridden by the caller by
638 // specifying wxEXEC_NOHIDE flag
639 if ( !(flags
& wxEXEC_NOHIDE
) )
641 si
.dwFlags
|= STARTF_USESHOWWINDOW
;
642 si
.wShowWindow
= SW_HIDE
;
645 // we must duplicate the handle to the write side of stdin pipe to make
646 // it non inheritable: indeed, we must close the writing end of pipeIn
647 // before launching the child process as otherwise this handle will be
648 // inherited by the child which will never close it and so the pipe
649 // will never be closed and the child will be left stuck in ReadFile()
650 HANDLE pipeInWrite
= pipeIn
.Detach(wxPipe::Write
);
651 if ( !::DuplicateHandle
653 ::GetCurrentProcess(),
655 ::GetCurrentProcess(),
657 0, // desired access: unused here
658 FALSE
, // not inherited
659 DUPLICATE_SAME_ACCESS
// same access as for src handle
662 wxLogLastError(_T("DuplicateHandle"));
665 ::CloseHandle(pipeInWrite
);
667 #endif // wxUSE_STREAMS
669 PROCESS_INFORMATION pi
;
670 DWORD dwFlags
= CREATE_DEFAULT_ERROR_MODE
| CREATE_SUSPENDED
;
672 bool ok
= ::CreateProcess
674 NULL
, // application name (use only cmd line)
676 command
.c_str(), // full command line
677 NULL
, // security attributes: defaults for both
678 NULL
, // the process and its main thread
679 redirect
, // inherit handles if we use pipes
680 dwFlags
, // process creation flags
681 NULL
, // environment (use the same)
682 NULL
, // current directory (use the same)
683 &si
, // startup info (unused here)
688 // we can close the pipe ends used by child anyhow
691 ::CloseHandle(pipeIn
.Detach(wxPipe::Read
));
692 ::CloseHandle(pipeOut
.Detach(wxPipe::Write
));
693 ::CloseHandle(pipeErr
.Detach(wxPipe::Write
));
695 #endif // wxUSE_STREAMS
700 // close the other handles too
703 ::CloseHandle(pipeOut
.Detach(wxPipe::Read
));
704 ::CloseHandle(pipeErr
.Detach(wxPipe::Read
));
706 #endif // wxUSE_STREAMS
708 wxLogSysError(_("Execution of command '%s' failed"), command
.c_str());
710 return flags
& wxEXEC_SYNC
? -1 : 0;
714 // the input buffer bufOut is connected to stdout, this is why it is
715 // called bufOut and not bufIn
716 wxStreamTempInputBuffer bufOut
,
721 // We can now initialize the wxStreams
723 outStream
= new wxPipeInputStream(pipeOut
.Detach(wxPipe::Read
));
725 errStream
= new wxPipeInputStream(pipeErr
.Detach(wxPipe::Read
));
727 inStream
= new wxPipeOutputStream(hpipeStdinWrite
);
729 handler
->SetPipeStreams(outStream
, inStream
, errStream
);
731 bufOut
.Init(outStream
);
732 bufErr
.Init(errStream
);
734 #endif // wxUSE_STREAMS
736 // register the class for the hidden window used for the notifications
737 if ( !gs_classForHiddenWindow
)
739 gs_classForHiddenWindow
= _T("wxHiddenWindow");
742 wxZeroMemory(wndclass
);
743 wndclass
.lpfnWndProc
= (WNDPROC
)wxExecuteWindowCbk
;
744 wndclass
.hInstance
= wxGetInstance();
745 wndclass
.lpszClassName
= gs_classForHiddenWindow
;
747 if ( !::RegisterClass(&wndclass
) )
749 wxLogLastError(wxT("RegisterClass(hidden window)"));
753 // create a hidden window to receive notification about process
755 HWND hwnd
= ::CreateWindow(gs_classForHiddenWindow
, NULL
,
758 (HMENU
)NULL
, wxGetInstance(), 0);
759 wxASSERT_MSG( hwnd
, wxT("can't create a hidden window for wxExecute") );
762 wxExecuteData
*data
= new wxExecuteData
;
763 data
->hProcess
= pi
.hProcess
;
764 data
->dwProcessId
= pi
.dwProcessId
;
766 data
->state
= (flags
& wxEXEC_SYNC
) != 0;
767 if ( flags
& wxEXEC_SYNC
)
769 // handler may be !NULL for capturing program output, but we don't use
770 // it wxExecuteData struct in this case
771 data
->handler
= NULL
;
775 // may be NULL or not
776 data
->handler
= handler
;
780 HANDLE hThread
= ::CreateThread(NULL
,
787 // resume process we created now - whether the thread creation succeeded or
789 if ( ::ResumeThread(pi
.hThread
) == (DWORD
)-1 )
791 // ignore it - what can we do?
792 wxLogLastError(wxT("ResumeThread in wxExecute"));
795 // close unneeded handle
796 if ( !::CloseHandle(pi
.hThread
) )
797 wxLogLastError(wxT("CloseHandle(hThread)"));
801 wxLogLastError(wxT("CreateThread in wxExecute"));
806 // the process still started up successfully...
807 return pi
.dwProcessId
;
810 ::CloseHandle(hThread
);
813 // second part of DDE hack: now establish the DDE conversation with the
814 // just launched process
815 if ( !ddeServer
.empty() )
819 // give the process the time to init itself
821 // we use a very big timeout hoping that WaitForInputIdle() will return
822 // much sooner, but not INFINITE just in case the process hangs
823 // completely - like this we will regain control sooner or later
824 switch ( ::WaitForInputIdle(pi
.hProcess
, 10000 /* 10 seconds */) )
827 wxFAIL_MSG( _T("unexpected WaitForInputIdle() return code") );
831 wxLogLastError(_T("WaitForInputIdle() in wxExecute"));
834 wxLogDebug(_T("Timeout too small in WaitForInputIdle"));
840 // ok, process ready to accept DDE requests
841 ok
= wxExecuteDDE(ddeServer
, ddeTopic
, ddeCommand
);
846 if ( !(flags
& wxEXEC_SYNC
) )
848 // clean up will be done when the process terminates
851 return pi
.dwProcessId
;
854 wxAppTraits
*traits
= wxTheApp
? wxTheApp
->GetTraits() : NULL
;
855 wxCHECK_MSG( traits
, -1, _T("no wxAppTraits in wxExecute()?") );
857 // disable all app windows while waiting for the child process to finish
858 void *cookie
= traits
->BeforeChildWaitLoop();
860 // wait until the child process terminates
861 while ( data
->state
)
866 #endif // wxUSE_STREAMS
868 // don't eat 100% of the CPU -- ugly but anything else requires
869 // real async IO which we don't have for the moment
872 // we must process messages or we'd never get wxWM_PROC_TERMINATED
873 traits
->AlwaysYield();
876 traits
->AfterChildWaitLoop(cookie
);
878 DWORD dwExitCode
= data
->dwExitCode
;
881 // return the exit code
885 long wxExecute(wxChar
**argv
, int flags
, wxProcess
*handler
)
898 return wxExecute(command
, flags
, handler
);