]> git.saurik.com Git - wxWidgets.git/blame - src/unix/utilsunx.cpp
Use gdk_window_invalidate instead of gtk_widget_queue_draw as the latter doesn't...
[wxWidgets.git] / src / unix / utilsunx.cpp
CommitLineData
518b5d2f 1/////////////////////////////////////////////////////////////////////////////
7520f3da 2// Name: src/unix/utilsunx.cpp
7e86b10b 3// Purpose: generic Unix implementation of many wx functions (for wxBase)
518b5d2f
VZ
4// Author: Vadim Zeitlin
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
65571936 7// Licence: wxWindows licence
518b5d2f
VZ
8/////////////////////////////////////////////////////////////////////////////
9
10// ============================================================================
11// declarations
12// ============================================================================
13
14// ----------------------------------------------------------------------------
15// headers
16// ----------------------------------------------------------------------------
17
14f355c2
VS
18// for compilers that support precompilation, includes "wx.h".
19#include "wx/wxprec.h"
20
88a7a4e1
WS
21#include "wx/utils.h"
22
c0472c7c
VZ
23#define USE_PUTENV (!defined(HAVE_SETENV) && defined(HAVE_PUTENV))
24
7520f3da
WS
25#ifndef WX_PRECOMP
26 #include "wx/string.h"
88a7a4e1 27 #include "wx/intl.h"
e4db172a 28 #include "wx/log.h"
670f9935 29 #include "wx/app.h"
0cb7e05c 30 #include "wx/wxcrtvararg.h"
c0472c7c
VZ
31 #if USE_PUTENV
32 #include "wx/module.h"
33 #include "wx/hashmap.h"
34 #endif
7520f3da 35#endif
518b5d2f 36
46446cc2 37#include "wx/apptrait.h"
518b5d2f 38
518b5d2f 39#include "wx/process.h"
bdc72a22 40#include "wx/thread.h"
518b5d2f 41
fae71206
VZ
42#include "wx/cmdline.h"
43
80d6dc0a 44#include "wx/wfstream.h"
8b33ae2d 45
33343395 46#include "wx/private/selectdispatcher.h"
1d043598 47#include "wx/private/fdiodispatcher.h"
e2478fde 48#include "wx/unix/execute.h"
17a1ebd1
VZ
49#include "wx/unix/private.h"
50
46c7e1a1
VS
51#ifdef wxHAS_GENERIC_PROCESS_CALLBACK
52#include "wx/private/fdiodispatcher.h"
53#endif
54
17a1ebd1 55#include <pwd.h>
bc855d09 56#include <sys/wait.h> // waitpid()
e2478fde 57
bc023abb
MW
58#ifdef HAVE_SYS_SELECT_H
59# include <sys/select.h>
60#endif
61
1f3b2af0
VS
62#define HAS_PIPE_INPUT_STREAM (wxUSE_STREAMS && wxUSE_FILE)
63
64#if HAS_PIPE_INPUT_STREAM
2887179b
VZ
65
66// define this to let wxexec.cpp know that we know what we're doing
67#define _WX_USED_BY_WXEXECUTE_
68#include "../common/execcmn.cpp"
69
1f3b2af0 70#endif // HAS_PIPE_INPUT_STREAM
2887179b 71
74c719ed
VZ
72#if defined(__MWERKS__) && defined(__MACH__)
73 #ifndef WXWIN_OS_DESCRIPTION
74 #define WXWIN_OS_DESCRIPTION "MacOS X"
75 #endif
76 #ifndef HAVE_NANOSLEEP
77 #define HAVE_NANOSLEEP
78 #endif
79 #ifndef HAVE_UNAME
80 #define HAVE_UNAME
81 #endif
82
83 // our configure test believes we can use sigaction() if the function is
84 // available but Metrowekrs with MSL run-time does have the function but
85 // doesn't have sigaction struct so finally we can't use it...
86 #ifdef __MSL__
87 #undef wxUSE_ON_FATAL_EXCEPTION
88 #define wxUSE_ON_FATAL_EXCEPTION 0
89 #endif
8d4f85ce
SC
90#endif
91
85da04e9
VZ
92// not only the statfs syscall is called differently depending on platform, but
93// one of its incarnations, statvfs(), takes different arguments under
94// different platforms and even different versions of the same system (Solaris
95// 7 and 8): if you want to test for this, don't forget that the problems only
96// appear if the large files support is enabled
eadd7bd2 97#ifdef HAVE_STATFS
85da04e9
VZ
98 #ifdef __BSD__
99 #include <sys/param.h>
100 #include <sys/mount.h>
101 #else // !__BSD__
102 #include <sys/vfs.h>
103 #endif // __BSD__/!__BSD__
104
105 #define wxStatfs statfs
84ae7ca4
VZ
106
107 #ifndef HAVE_STATFS_DECL
108 // some systems lack statfs() prototype in the system headers (AIX 4)
109 extern "C" int statfs(const char *path, struct statfs *buf);
110 #endif
eadd7bd2
VZ
111#endif // HAVE_STATFS
112
9952adac
VZ
113#ifdef HAVE_STATVFS
114 #include <sys/statvfs.h>
115
85da04e9
VZ
116 #define wxStatfs statvfs
117#endif // HAVE_STATVFS
118
119#if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
120 // WX_STATFS_T is detected by configure
121 #define wxStatfs_t WX_STATFS_T
122#endif
9952adac 123
f6bcfd97
BP
124// SGI signal.h defines signal handler arguments differently depending on
125// whether _LANGUAGE_C_PLUS_PLUS is set or not - do set it
126#if defined(__SGI__) && !defined(_LANGUAGE_C_PLUS_PLUS)
127 #define _LANGUAGE_C_PLUS_PLUS 1
128#endif // SGI hack
129
518b5d2f
VZ
130#include <stdarg.h>
131#include <dirent.h>
132#include <string.h>
133#include <sys/stat.h>
134#include <sys/types.h>
518b5d2f 135#include <sys/wait.h>
e2478fde 136#include <unistd.h>
518b5d2f
VZ
137#include <errno.h>
138#include <netdb.h>
139#include <signal.h>
140#include <fcntl.h> // for O_WRONLY and friends
141#include <time.h> // nanosleep() and/or usleep()
fad866f4 142#include <ctype.h> // isspace()
b12915c1 143#include <sys/time.h> // needed for FD_SETSIZE
7bcb11d3 144
0fcdf6dc 145#ifdef HAVE_UNAME
518b5d2f
VZ
146 #include <sys/utsname.h> // for uname()
147#endif // HAVE_UNAME
148
9ad34f61
VZ
149// Used by wxGetFreeMemory().
150#ifdef __SGI__
151 #include <sys/sysmp.h>
152 #include <sys/sysinfo.h> // for SAGET and MINFO structures
153#endif
154
518b5d2f
VZ
155// ----------------------------------------------------------------------------
156// conditional compilation
157// ----------------------------------------------------------------------------
158
159// many versions of Unices have this function, but it is not defined in system
160// headers - please add your system here if it is the case for your OS.
161// SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
1363811b 162#if !defined(HAVE_USLEEP) && \
d67fee71 163 ((defined(__SUN__) && !defined(__SunOs_5_6) && \
518b5d2f 164 !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
d67fee71 165 defined(__osf__) || defined(__EMX__))
518b5d2f
VZ
166 extern "C"
167 {
1a5e269b
VZ
168 #ifdef __EMX__
169 /* I copied this from the XFree86 diffs. AV. */
170 #define INCL_DOSPROCESS
171 #include <os2.h>
172 inline void usleep(unsigned long delay)
173 {
174 DosSleep(delay ? (delay/1000l) : 1l);
175 }
176 #else // Unix
1363811b 177 int usleep(unsigned int usec);
1a5e269b 178 #endif // __EMX__/Unix
518b5d2f 179 };
bdc72a22
VZ
180
181 #define HAVE_USLEEP 1
518b5d2f
VZ
182#endif // Unices without usleep()
183
518b5d2f
VZ
184// ============================================================================
185// implementation
186// ============================================================================
187
188// ----------------------------------------------------------------------------
189// sleeping
190// ----------------------------------------------------------------------------
191
192void wxSleep(int nSecs)
193{
194 sleep(nSecs);
195}
196
66cd9d7f 197void wxMicroSleep(unsigned long microseconds)
518b5d2f 198{
b12915c1 199#if defined(HAVE_NANOSLEEP)
518b5d2f 200 timespec tmReq;
66cd9d7f
VZ
201 tmReq.tv_sec = (time_t)(microseconds / 1000000);
202 tmReq.tv_nsec = (microseconds % 1000000) * 1000;
518b5d2f
VZ
203
204 // we're not interested in remaining time nor in return value
d3b9f782 205 (void)nanosleep(&tmReq, NULL);
b12915c1 206#elif defined(HAVE_USLEEP)
518b5d2f
VZ
207 // uncomment this if you feel brave or if you are sure that your version
208 // of Solaris has a safe usleep() function but please notice that usleep()
209 // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
210 // documented as MT-Safe
ea18eed9 211 #if defined(__SUN__) && wxUSE_THREADS
518b5d2f
VZ
212 #error "usleep() cannot be used in MT programs under Solaris."
213 #endif // Sun
214
66cd9d7f 215 usleep(microseconds);
b12915c1
VZ
216#elif defined(HAVE_SLEEP)
217 // under BeOS sleep() takes seconds (what about other platforms, if any?)
66cd9d7f 218 sleep(microseconds * 1000000);
518b5d2f 219#else // !sleep function
66cd9d7f 220 #error "usleep() or nanosleep() function required for wxMicroSleep"
518b5d2f
VZ
221#endif // sleep function
222}
223
66cd9d7f
VZ
224void wxMilliSleep(unsigned long milliseconds)
225{
226 wxMicroSleep(milliseconds*1000);
227}
228
518b5d2f
VZ
229// ----------------------------------------------------------------------------
230// process management
231// ----------------------------------------------------------------------------
232
e0f6b731 233int wxKill(long pid, wxSignal sig, wxKillError *rc, int flags)
518b5d2f 234{
e0f6b731 235 int err = kill((pid_t) (flags & wxKILL_CHILDREN) ? -pid : pid, (int)sig);
50567b69
VZ
236 if ( rc )
237 {
f0bce4d4 238 switch ( err ? errno : 0 )
50567b69
VZ
239 {
240 case 0:
241 *rc = wxKILL_OK;
242 break;
243
244 case EINVAL:
245 *rc = wxKILL_BAD_SIGNAL;
246 break;
247
248 case EPERM:
249 *rc = wxKILL_ACCESS_DENIED;
250 break;
251
252 case ESRCH:
253 *rc = wxKILL_NO_PROCESS;
254 break;
255
256 default:
257 // this goes against Unix98 docs so log it
258 wxLogDebug(_T("unexpected kill(2) return value %d"), err);
259
260 // something else...
261 *rc = wxKILL_ERROR;
262 }
263 }
264
265 return err;
518b5d2f
VZ
266}
267
05718a98 268// Shutdown or reboot the PC
c1baf4b5 269bool wxShutdown(int flags)
518b5d2f 270{
c1baf4b5
VZ
271 flags &= ~wxSHUTDOWN_FORCE;
272
05718a98 273 wxChar level;
c1baf4b5 274 switch ( flags )
05718a98
VZ
275 {
276 case wxSHUTDOWN_POWEROFF:
277 level = _T('0');
278 break;
647b8e37 279
05718a98
VZ
280 case wxSHUTDOWN_REBOOT:
281 level = _T('6');
282 break;
518b5d2f 283
c1baf4b5
VZ
284 case wxSHUTDOWN_LOGOFF:
285 // TODO: use dcop to log off?
286 return false;
287
05718a98
VZ
288 default:
289 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
290 return false;
291 }
0ed9a934 292
c1baf4b5 293 return system(wxString::Format("init %c", level).mb_str()) == 0;
05718a98 294}
0ed9a934 295
05718a98
VZ
296// ----------------------------------------------------------------------------
297// wxStream classes to support IO redirection in wxExecute
298// ----------------------------------------------------------------------------
0ed9a934 299
05718a98 300#if HAS_PIPE_INPUT_STREAM
0ed9a934 301
05718a98
VZ
302bool wxPipeInputStream::CanRead() const
303{
304 if ( m_lasterror == wxSTREAM_EOF )
305 return false;
0ed9a934 306
05718a98
VZ
307 // check if there is any input available
308 struct timeval tv;
309 tv.tv_sec = 0;
310 tv.tv_usec = 0;
0ed9a934 311
05718a98 312 const int fd = m_file->fd();
0ed9a934 313
05718a98 314 fd_set readfds;
0ed9a934 315
05718a98
VZ
316 wxFD_ZERO(&readfds);
317 wxFD_SET(fd, &readfds);
0ed9a934 318
05718a98
VZ
319 switch ( select(fd + 1, &readfds, NULL, NULL, &tv) )
320 {
321 case -1:
322 wxLogSysError(_("Impossible to get child process input"));
323 // fall through
62705a27 324
05718a98
VZ
325 case 0:
326 return false;
518b5d2f 327
05718a98
VZ
328 default:
329 wxFAIL_MSG(_T("unexpected select() return value"));
330 // still fall through
518b5d2f 331
05718a98
VZ
332 case 1:
333 // input available -- or maybe not, as select() returns 1 when a
334 // read() will complete without delay, but it could still not read
335 // anything
336 return !Eof();
337 }
518b5d2f
VZ
338}
339
05718a98
VZ
340#endif // HAS_PIPE_INPUT_STREAM
341
2c8e4738
VZ
342// ----------------------------------------------------------------------------
343// wxShell
344// ----------------------------------------------------------------------------
345
346static wxString wxMakeShellCommand(const wxString& command)
518b5d2f
VZ
347{
348 wxString cmd;
cd6ce4a9 349 if ( !command )
2c8e4738
VZ
350 {
351 // just an interactive shell
cd6ce4a9 352 cmd = _T("xterm");
2c8e4738 353 }
518b5d2f 354 else
2c8e4738
VZ
355 {
356 // execute command in a shell
357 cmd << _T("/bin/sh -c '") << command << _T('\'');
358 }
359
360 return cmd;
361}
362
363bool wxShell(const wxString& command)
364{
fbf456aa 365 return wxExecute(wxMakeShellCommand(command), wxEXEC_SYNC) == 0;
2c8e4738
VZ
366}
367
368bool wxShell(const wxString& command, wxArrayString& output)
369{
9d8aca48 370 wxCHECK_MSG( !command.empty(), false, _T("can't exec shell non interactively") );
518b5d2f 371
2c8e4738 372 return wxExecute(wxMakeShellCommand(command), output);
518b5d2f
VZ
373}
374
05718a98 375namespace
f6ba47d9 376{
05718a98
VZ
377
378// helper class for storing arguments as char** array suitable for passing to
379// execvp(), whatever form they were passed to us
380class ArgsArray
381{
382public:
383 ArgsArray(const wxArrayString& args)
f6ba47d9 384 {
05718a98 385 Init(args.size());
f6ba47d9 386
05718a98
VZ
387 for ( int i = 0; i < m_argc; i++ )
388 {
389 m_argv[i] = wxStrdup(args[i]);
390 }
391 }
f6ba47d9 392
d7ef641d 393#if wxUSE_UNICODE
05718a98
VZ
394 ArgsArray(wchar_t **wargv)
395 {
396 int argc = 0;
397 while ( *wargv++ )
398 argc++;
399
400 Init(argc);
401
402 for ( int i = 0; i < m_argc; i++ )
403 {
404 m_argv[i] = wxSafeConvertWX2MB(wargv[i]).release();
405 }
f6ba47d9 406 }
d7ef641d 407#endif // wxUSE_UNICODE
f6ba47d9 408
05718a98
VZ
409 ~ArgsArray()
410 {
411 for ( int i = 0; i < m_argc; i++ )
412 {
413 free(m_argv[i]);
414 }
415
416 delete [] m_argv;
417 }
418
419 operator char**() const { return m_argv; }
420
421private:
422 void Init(int argc)
423 {
424 m_argc = argc;
425 m_argv = new char *[m_argc + 1];
426 m_argv[m_argc] = NULL;
427 }
428
429 int m_argc;
430 char **m_argv;
431
c0c133e1 432 wxDECLARE_NO_COPY_CLASS(ArgsArray);
05718a98
VZ
433};
434
435} // anonymous namespace
f6ba47d9 436
cd6ce4a9 437// ----------------------------------------------------------------------------
05718a98 438// wxExecute implementations
cd6ce4a9 439// ----------------------------------------------------------------------------
6dc6fda6 440
05718a98
VZ
441#if defined(__DARWIN__)
442bool wxMacLaunch(char **argv);
443#endif
1e6feb95 444
05718a98 445long wxExecute(const wxString& command, int flags, wxProcess *process)
8b33ae2d 446{
fae71206
VZ
447 ArgsArray argv(wxCmdLineParser::ConvertStringToArgs(command,
448 wxCMD_LINE_SPLIT_UNIX));
05718a98 449
05718a98 450 return wxExecute(argv, flags, process);
8b33ae2d
GL
451}
452
d7ef641d
VZ
453#if wxUSE_UNICODE
454
05718a98
VZ
455long wxExecute(wchar_t **wargv, int flags, wxProcess *process)
456{
457 ArgsArray argv(wargv);
1e6feb95 458
05718a98
VZ
459 return wxExecute(argv, flags, process);
460}
79066131 461
d7ef641d
VZ
462#endif // wxUSE_UNICODE
463
05718a98
VZ
464// wxExecute: the real worker function
465long wxExecute(char **argv, int flags, wxProcess *process)
518b5d2f 466{
f6bcfd97 467 // for the sync execution, we return -1 to indicate failure, but for async
accb3257
VZ
468 // case we return 0 which is never a valid PID
469 //
470 // we define this as a macro, not a variable, to avoid compiler warnings
471 // about "ERROR_RETURN_CODE value may be clobbered by fork()"
fbf456aa 472 #define ERROR_RETURN_CODE ((flags & wxEXEC_SYNC) ? -1 : 0)
f6bcfd97 473
accb3257 474 wxCHECK_MSG( *argv, ERROR_RETURN_CODE, wxT("can't exec empty command") );
518b5d2f 475
05718a98
VZ
476#if wxUSE_THREADS
477 // fork() doesn't mix well with POSIX threads: on many systems the program
478 // deadlocks or crashes for some reason. Probably our code is buggy and
479 // doesn't do something which must be done to allow this to work, but I
480 // don't know what yet, so for now just warn the user (this is the least we
481 // can do) about it
482 wxASSERT_MSG( wxThread::IsMain(),
483 _T("wxExecute() can be called only from the main thread") );
484#endif // wxUSE_THREADS
05079acc 485
052e5ec5 486#if defined(__WXCOCOA__) || ( defined(__WXOSX_MAC__) && wxOSX_USE_COCOA_OR_CARBON )
05718a98
VZ
487 // wxMacLaunch() only executes app bundles and only does it asynchronously.
488 // It returns false if the target is not an app bundle, thus falling
489 // through to the regular code for non app bundles.
490 if ( !(flags & wxEXEC_SYNC) && wxMacLaunch(argv) )
e90c1d2a 491 {
05718a98
VZ
492 // we don't have any PID to return so just make up something non null
493 return -1;
05079acc 494 }
05718a98
VZ
495#endif // __DARWIN__
496
497
498 // this struct contains all information which we use for housekeeping
e2478fde
VZ
499 wxExecuteData execData;
500 execData.flags = flags;
501 execData.process = process;
502
518b5d2f 503 // create pipes
3bbd09c3 504 if ( !execData.pipeEndProcDetect.Create() )
518b5d2f 505 {
cd6ce4a9 506 wxLogError( _("Failed to execute '%s'\n"), *argv );
e90c1d2a 507
accb3257 508 return ERROR_RETURN_CODE;
518b5d2f
VZ
509 }
510
f6bcfd97 511 // pipes for inter process communication
b477f956
VZ
512 wxPipe pipeIn, // stdin
513 pipeOut, // stdout
514 pipeErr; // stderr
cd6ce4a9
VZ
515
516 if ( process && process->IsRedirected() )
8b33ae2d 517 {
b477f956 518 if ( !pipeIn.Create() || !pipeOut.Create() || !pipeErr.Create() )
8b33ae2d 519 {
cd6ce4a9 520 wxLogError( _("Failed to execute '%s'\n"), *argv );
8b33ae2d 521
accb3257 522 return ERROR_RETURN_CODE;
8b33ae2d
GL
523 }
524 }
8b33ae2d 525
518b5d2f 526 // fork the process
ef5f8ab6
VZ
527 //
528 // NB: do *not* use vfork() here, it completely breaks this code for some
529 // reason under Solaris (and maybe others, although not under Linux)
b2ddee86
JJ
530 // But on OpenVMS we do not have fork so we have to use vfork and
531 // cross our fingers that it works.
532#ifdef __VMS
533 pid_t pid = vfork();
534#else
535 pid_t pid = fork();
536#endif
537 if ( pid == -1 ) // error?
518b5d2f
VZ
538 {
539 wxLogSysError( _("Fork failed") );
e90c1d2a 540
accb3257 541 return ERROR_RETURN_CODE;
518b5d2f 542 }
cd6ce4a9 543 else if ( pid == 0 ) // we're in child
518b5d2f 544 {
5ddfa074
VZ
545 // NB: we used to close all the unused descriptors of the child here
546 // but this broke some programs which relied on e.g. FD 1 being
547 // always opened so don't do it any more, after all there doesn't
548 // seem to be any real problem with keeping them opened
e1082c9f 549
e8e776aa 550#if !defined(__VMS) && !defined(__EMX__)
0c9c4401
VZ
551 if ( flags & wxEXEC_MAKE_GROUP_LEADER )
552 {
553 // Set process group to child process' pid. Then killing -pid
554 // of the parent will kill the process and all of its children.
555 setsid();
518b5d2f 556 }
0c9c4401
VZ
557#endif // !__VMS
558
0c9c4401 559 // reading side can be safely closed but we should keep the write one
3bbd09c3
VZ
560 // opened, it will be only closed when the process terminates resulting
561 // in a read notification to the parent
562 execData.pipeEndProcDetect.Detach(wxPipe::Write);
563 execData.pipeEndProcDetect.Close();
518b5d2f 564
80d6dc0a 565 // redirect stdin, stdout and stderr
b477f956 566 if ( pipeIn.IsOk() )
cd6ce4a9 567 {
b477f956
VZ
568 if ( dup2(pipeIn[wxPipe::Read], STDIN_FILENO) == -1 ||
569 dup2(pipeOut[wxPipe::Write], STDOUT_FILENO) == -1 ||
570 dup2(pipeErr[wxPipe::Write], STDERR_FILENO) == -1 )
cd6ce4a9 571 {
f6bcfd97 572 wxLogSysError(_("Failed to redirect child process input/output"));
cd6ce4a9 573 }
518b5d2f 574
b477f956
VZ
575 pipeIn.Close();
576 pipeOut.Close();
577 pipeErr.Close();
cd6ce4a9 578 }
518b5d2f 579
05718a98 580 execvp(*argv, argv);
17a1ebd1 581
d264d709 582 fprintf(stderr, "execvp(");
05718a98
VZ
583 for ( char **a = argv; *a; a++ )
584 fprintf(stderr, "%s%s", a == argv ? "" : ", ", *a);
d264d709
VZ
585 fprintf(stderr, ") failed with error %d!\n", errno);
586
518b5d2f 587 // there is no return after successful exec()
518b5d2f 588 _exit(-1);
1d8dd65e
VZ
589
590 // some compilers complain about missing return - of course, they
591 // should know that exit() doesn't return but what else can we do if
592 // they don't?
b477f956
VZ
593 //
594 // and, sure enough, other compilers complain about unreachable code
595 // after exit() call, so we can just always have return here...
1d8dd65e
VZ
596#if defined(__VMS) || defined(__INTEL_COMPILER)
597 return 0;
598#endif
518b5d2f 599 }
cd6ce4a9 600 else // we're in parent
518b5d2f 601 {
7764f973
VZ
602 // save it for WaitForChild() use
603 execData.pid = pid;
604
80d6dc0a
VZ
605 // prepare for IO redirection
606
1f3b2af0 607#if HAS_PIPE_INPUT_STREAM
80d6dc0a
VZ
608 // the input buffer bufOut is connected to stdout, this is why it is
609 // called bufOut and not bufIn
610 wxStreamTempInputBuffer bufOut,
611 bufErr;
0e300ddd 612
cd6ce4a9
VZ
613 if ( process && process->IsRedirected() )
614 {
80d6dc0a
VZ
615 wxOutputStream *inStream =
616 new wxFileOutputStream(pipeIn.Detach(wxPipe::Write));
b477f956 617
33343395
VZ
618 const int fdOut = pipeOut.Detach(wxPipe::Read);
619 wxPipeInputStream *outStream = new wxPipeInputStream(fdOut);
b477f956 620
33343395
VZ
621 const int fdErr = pipeErr.Detach(wxPipe::Read);
622 wxPipeInputStream *errStream = new wxPipeInputStream(fdErr);
f6bcfd97 623
80d6dc0a 624 process->SetPipeStreams(outStream, inStream, errStream);
0e300ddd 625
80d6dc0a 626 bufOut.Init(outStream);
b477f956 627 bufErr.Init(errStream);
e2478fde
VZ
628
629 execData.bufOut = &bufOut;
630 execData.bufErr = &bufErr;
33343395
VZ
631
632 execData.fdOut = fdOut;
633 execData.fdErr = fdErr;
b477f956 634 }
33343395 635#endif // HAS_PIPE_INPUT_STREAM
1e6feb95 636
b477f956
VZ
637 if ( pipeIn.IsOk() )
638 {
639 pipeIn.Close();
640 pipeOut.Close();
641 pipeErr.Close();
cd6ce4a9
VZ
642 }
643
05718a98
VZ
644 // we want this function to work even if there is no wxApp so ensure
645 // that we have a valid traits pointer
646 wxConsoleAppTraits traitsConsole;
647 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
648 if ( !traits )
649 traits = &traitsConsole;
650
e2478fde 651 return traits->WaitForChild(execData);
518b5d2f 652 }
79656e30 653
17a1ebd1 654#if !defined(__VMS) && !defined(__INTEL_COMPILER)
79656e30 655 return ERROR_RETURN_CODE;
ef0ed19e 656#endif
17a1ebd1 657}
518b5d2f 658
accb3257 659#undef ERROR_RETURN_CODE
f6bcfd97 660
518b5d2f
VZ
661// ----------------------------------------------------------------------------
662// file and directory functions
663// ----------------------------------------------------------------------------
664
05079acc 665const wxChar* wxGetHomeDir( wxString *home )
518b5d2f 666{
14d63513 667 *home = wxGetUserHome();
79066131 668 wxString tmp;
8ea92b4d 669 if ( home->empty() )
223d09f6 670 *home = wxT("/");
181cbcf4 671#ifdef __VMS
79066131
VZ
672 tmp = *home;
673 if ( tmp.Last() != wxT(']'))
674 if ( tmp.Last() != wxT('/')) *home << wxT('/');
181cbcf4 675#endif
518b5d2f
VZ
676 return home->c_str();
677}
678
14d63513 679wxString wxGetUserHome( const wxString &user )
518b5d2f
VZ
680{
681 struct passwd *who = (struct passwd *) NULL;
682
0fb67cd1 683 if ( !user )
518b5d2f 684 {
e90c1d2a 685 wxChar *ptr;
518b5d2f 686
223d09f6 687 if ((ptr = wxGetenv(wxT("HOME"))) != NULL)
518b5d2f
VZ
688 {
689 return ptr;
690 }
14d63513
VZ
691
692 if ((ptr = wxGetenv(wxT("USER"))) != NULL ||
693 (ptr = wxGetenv(wxT("LOGNAME"))) != NULL)
518b5d2f 694 {
69c928ef 695 who = getpwnam(wxSafeConvertWX2MB(ptr));
518b5d2f
VZ
696 }
697
14d63513
VZ
698 // make sure the user exists!
699 if ( !who )
518b5d2f
VZ
700 {
701 who = getpwuid(getuid());
702 }
703 }
704 else
705 {
05079acc 706 who = getpwnam (user.mb_str());
518b5d2f
VZ
707 }
708
69c928ef 709 return wxSafeConvertMB2WX(who ? who->pw_dir : 0);
518b5d2f
VZ
710}
711
712// ----------------------------------------------------------------------------
0fb67cd1 713// network and user id routines
518b5d2f
VZ
714// ----------------------------------------------------------------------------
715
8bb6b2c0
VZ
716// private utility function which returns output of the given command, removing
717// the trailing newline
718static wxString wxGetCommandOutput(const wxString &cmd)
719{
720 FILE *f = popen(cmd.ToAscii(), "r");
721 if ( !f )
722 {
723 wxLogSysError(_T("Executing \"%s\" failed"), cmd.c_str());
724 return wxEmptyString;
725 }
726
727 wxString s;
728 char buf[256];
729 while ( !feof(f) )
730 {
731 if ( !fgets(buf, sizeof(buf), f) )
732 break;
733
734 s += wxString::FromAscii(buf);
735 }
736
737 pclose(f);
738
739 if ( !s.empty() && s.Last() == _T('\n') )
740 s.RemoveLast();
741
742 return s;
743}
744
0fb67cd1
VZ
745// retrieve either the hostname or FQDN depending on platform (caller must
746// check whether it's one or the other, this is why this function is for
747// private use only)
05079acc 748static bool wxGetHostNameInternal(wxChar *buf, int sz)
518b5d2f 749{
9d8aca48 750 wxCHECK_MSG( buf, false, wxT("NULL pointer in wxGetHostNameInternal") );
518b5d2f 751
223d09f6 752 *buf = wxT('\0');
518b5d2f
VZ
753
754 // we're using uname() which is POSIX instead of less standard sysinfo()
755#if defined(HAVE_UNAME)
cc743a6f 756 struct utsname uts;
518b5d2f
VZ
757 bool ok = uname(&uts) != -1;
758 if ( ok )
759 {
e408bf52 760 wxStrlcpy(buf, wxSafeConvertMB2WX(uts.nodename), sz);
518b5d2f
VZ
761 }
762#elif defined(HAVE_GETHOSTNAME)
1870f50b
RD
763 char cbuf[sz];
764 bool ok = gethostname(cbuf, sz) != -1;
765 if ( ok )
766 {
e408bf52 767 wxStrlcpy(buf, wxSafeConvertMB2WX(cbuf), sz);
1870f50b 768 }
0fb67cd1 769#else // no uname, no gethostname
223d09f6 770 wxFAIL_MSG(wxT("don't know host name for this machine"));
518b5d2f 771
9d8aca48 772 bool ok = false;
0fb67cd1 773#endif // uname/gethostname
518b5d2f
VZ
774
775 if ( !ok )
776 {
777 wxLogSysError(_("Cannot get the hostname"));
778 }
779
780 return ok;
781}
782
05079acc 783bool wxGetHostName(wxChar *buf, int sz)
0fb67cd1
VZ
784{
785 bool ok = wxGetHostNameInternal(buf, sz);
786
787 if ( ok )
788 {
789 // BSD systems return the FQDN, we only want the hostname, so extract
790 // it (we consider that dots are domain separators)
223d09f6 791 wxChar *dot = wxStrchr(buf, wxT('.'));
0fb67cd1
VZ
792 if ( dot )
793 {
794 // nuke it
223d09f6 795 *dot = wxT('\0');
0fb67cd1
VZ
796 }
797 }
798
799 return ok;
800}
801
05079acc 802bool wxGetFullHostName(wxChar *buf, int sz)
0fb67cd1
VZ
803{
804 bool ok = wxGetHostNameInternal(buf, sz);
805
806 if ( ok )
807 {
223d09f6 808 if ( !wxStrchr(buf, wxT('.')) )
0fb67cd1 809 {
69c928ef 810 struct hostent *host = gethostbyname(wxSafeConvertWX2MB(buf));
0fb67cd1
VZ
811 if ( !host )
812 {
813 wxLogSysError(_("Cannot get the official hostname"));
814
9d8aca48 815 ok = false;
0fb67cd1
VZ
816 }
817 else
818 {
819 // the canonical name
e408bf52 820 wxStrlcpy(buf, wxSafeConvertMB2WX(host->h_name), sz);
0fb67cd1
VZ
821 }
822 }
823 //else: it's already a FQDN (BSD behaves this way)
824 }
825
826 return ok;
827}
828
05079acc 829bool wxGetUserId(wxChar *buf, int sz)
518b5d2f
VZ
830{
831 struct passwd *who;
832
223d09f6 833 *buf = wxT('\0');
518b5d2f
VZ
834 if ((who = getpwuid(getuid ())) != NULL)
835 {
e408bf52 836 wxStrlcpy (buf, wxSafeConvertMB2WX(who->pw_name), sz);
9d8aca48 837 return true;
518b5d2f
VZ
838 }
839
9d8aca48 840 return false;
518b5d2f
VZ
841}
842
05079acc 843bool wxGetUserName(wxChar *buf, int sz)
518b5d2f 844{
69c928ef 845#ifdef HAVE_PW_GECOS
518b5d2f 846 struct passwd *who;
518b5d2f 847
223d09f6 848 *buf = wxT('\0');
b12915c1
VZ
849 if ((who = getpwuid (getuid ())) != NULL)
850 {
b12915c1 851 char *comma = strchr(who->pw_gecos, ',');
518b5d2f
VZ
852 if (comma)
853 *comma = '\0'; // cut off non-name comment fields
e408bf52 854 wxStrlcpy(buf, wxSafeConvertMB2WX(who->pw_gecos), sz);
9d8aca48 855 return true;
518b5d2f
VZ
856 }
857
9d8aca48 858 return false;
69c928ef
VZ
859#else // !HAVE_PW_GECOS
860 return wxGetUserId(buf, sz);
861#endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
518b5d2f
VZ
862}
863
c655557f
VZ
864bool wxIsPlatform64Bit()
865{
2f6aa043
VZ
866 const wxString machine = wxGetCommandOutput(wxT("uname -m"));
867
868 // the test for "64" is obviously not 100% reliable but seems to work fine
869 // in practice
870 return machine.Contains(wxT("64")) ||
871 machine.Contains(wxT("alpha"));
c655557f
VZ
872}
873
50a2e26f 874// these functions are in src/osx/utilsexc_base.cpp for wxMac
c655557f
VZ
875#ifndef __WXMAC__
876
8bb6b2c0
VZ
877wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin)
878{
879 // get OS version
880 int major, minor;
881 wxString release = wxGetCommandOutput(wxT("uname -r"));
86501081
VS
882 if ( release.empty() ||
883 wxSscanf(release.c_str(), wxT("%d.%d"), &major, &minor) != 2 )
8bb6b2c0 884 {
e1379e29 885 // failed to get version string or unrecognized format
8bb6b2c0
VZ
886 major =
887 minor = -1;
888 }
889
890 if ( verMaj )
891 *verMaj = major;
892 if ( verMin )
893 *verMin = minor;
894
895 // try to understand which OS are we running
896 wxString kernel = wxGetCommandOutput(wxT("uname -s"));
897 if ( kernel.empty() )
898 kernel = wxGetCommandOutput(wxT("uname -o"));
899
900 if ( kernel.empty() )
901 return wxOS_UNKNOWN;
902
903 return wxPlatformInfo::GetOperatingSystemId(kernel);
904}
905
bdc72a22
VZ
906wxString wxGetOsDescription()
907{
8bb6b2c0 908 return wxGetCommandOutput(wxT("uname -s -r -m"));
bdc72a22
VZ
909}
910
e2478fde 911#endif // !__WXMAC__
bd3277fe 912
c1cb4153
VZ
913unsigned long wxGetProcessId()
914{
915 return (unsigned long)getpid();
916}
917
9d8aca48 918wxMemorySize wxGetFreeMemory()
bd3277fe
VZ
919{
920#if defined(__LINUX__)
921 // get it from /proc/meminfo
922 FILE *fp = fopen("/proc/meminfo", "r");
923 if ( fp )
924 {
925 long memFree = -1;
926
927 char buf[1024];
928 if ( fgets(buf, WXSIZEOF(buf), fp) && fgets(buf, WXSIZEOF(buf), fp) )
929 {
7c28d921
VZ
930 // /proc/meminfo changed its format in kernel 2.6
931 if ( wxPlatformInfo().CheckOSVersion(2, 6) )
932 {
933 unsigned long cached, buffers;
934 sscanf(buf, "MemFree: %ld", &memFree);
935
936 fgets(buf, WXSIZEOF(buf), fp);
937 sscanf(buf, "Buffers: %lu", &buffers);
938
939 fgets(buf, WXSIZEOF(buf), fp);
940 sscanf(buf, "Cached: %lu", &cached);
941
942 // add to "MemFree" also the "Buffers" and "Cached" values as
943 // free(1) does as otherwise the value never makes sense: for
944 // kernel 2.6 it's always almost 0
945 memFree += buffers + cached;
946
947 // values here are always expressed in kB and we want bytes
948 memFree *= 1024;
949 }
950 else // Linux 2.4 (or < 2.6, anyhow)
951 {
952 long memTotal, memUsed;
953 sscanf(buf, "Mem: %ld %ld %ld", &memTotal, &memUsed, &memFree);
954 }
bd3277fe
VZ
955 }
956
957 fclose(fp);
958
9d8aca48 959 return (wxMemorySize)memFree;
bd3277fe 960 }
9ad34f61
VZ
961#elif defined(__SGI__)
962 struct rminfo realmem;
963 if ( sysmp(MP_SAGET, MPSA_RMINFO, &realmem, sizeof realmem) == 0 )
964 return ((wxMemorySize)realmem.physmem * sysconf(_SC_PAGESIZE));
40f00746
VZ
965#elif defined(_SC_AVPHYS_PAGES)
966 return ((wxMemorySize)sysconf(_SC_AVPHYS_PAGES))*sysconf(_SC_PAGESIZE);
bd3277fe
VZ
967//#elif defined(__FREEBSD__) -- might use sysctl() to find it out, probably
968#endif
969
970 // can't find it out
971 return -1;
972}
973
7ba7c4e6 974bool wxGetDiskSpace(const wxString& path, wxDiskspaceSize_t *pTotal, wxDiskspaceSize_t *pFree)
eadd7bd2 975{
9952adac 976#if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
fbfb3fb3 977 // the case to "char *" is needed for AIX 4.3
85da04e9
VZ
978 wxStatfs_t fs;
979 if ( wxStatfs((char *)(const char*)path.fn_str(), &fs) != 0 )
eadd7bd2 980 {
401eb3de 981 wxLogSysError( wxT("Failed to get file system statistics") );
eadd7bd2 982
9d8aca48 983 return false;
eadd7bd2
VZ
984 }
985
125cb99b
VZ
986 // under Solaris we also have to use f_frsize field instead of f_bsize
987 // which is in general a multiple of f_frsize
988#ifdef HAVE_STATVFS
7ba7c4e6 989 wxDiskspaceSize_t blockSize = fs.f_frsize;
125cb99b 990#else // HAVE_STATFS
7ba7c4e6 991 wxDiskspaceSize_t blockSize = fs.f_bsize;
125cb99b 992#endif // HAVE_STATVFS/HAVE_STATFS
9952adac 993
eadd7bd2
VZ
994 if ( pTotal )
995 {
7ba7c4e6 996 *pTotal = wxDiskspaceSize_t(fs.f_blocks) * blockSize;
eadd7bd2
VZ
997 }
998
999 if ( pFree )
1000 {
7ba7c4e6 1001 *pFree = wxDiskspaceSize_t(fs.f_bavail) * blockSize;
eadd7bd2
VZ
1002 }
1003
9d8aca48 1004 return true;
125cb99b 1005#else // !HAVE_STATFS && !HAVE_STATVFS
9d8aca48 1006 return false;
125cb99b 1007#endif // HAVE_STATFS
eadd7bd2
VZ
1008}
1009
8fd0d89b
VZ
1010// ----------------------------------------------------------------------------
1011// env vars
1012// ----------------------------------------------------------------------------
1013
c0472c7c
VZ
1014#if USE_PUTENV
1015
1016WX_DECLARE_STRING_HASH_MAP(char *, wxEnvVars);
1017
1018static wxEnvVars gs_envVars;
1019
1020class wxSetEnvModule : public wxModule
1021{
1022public:
1023 virtual bool OnInit() { return true; }
1024 virtual void OnExit()
1025 {
1026 for ( wxEnvVars::const_iterator i = gs_envVars.begin();
1027 i != gs_envVars.end();
1028 ++i )
1029 {
1030 free(i->second);
1031 }
1032
1033 gs_envVars.clear();
1034 }
1035
1036 DECLARE_DYNAMIC_CLASS(wxSetEnvModule)
1037};
1038
1039IMPLEMENT_DYNAMIC_CLASS(wxSetEnvModule, wxModule)
1040
1041#endif // USE_PUTENV
1042
97b305b7 1043bool wxGetEnv(const wxString& var, wxString *value)
308978f6
VZ
1044{
1045 // wxGetenv is defined as getenv()
86501081 1046 char *p = wxGetenv(var);
308978f6 1047 if ( !p )
9d8aca48 1048 return false;
308978f6
VZ
1049
1050 if ( value )
1051 {
1052 *value = p;
1053 }
1054
9d8aca48 1055 return true;
308978f6
VZ
1056}
1057
90a77e64 1058static bool wxDoSetEnv(const wxString& variable, const char *value)
8fd0d89b
VZ
1059{
1060#if defined(HAVE_SETENV)
a1353ea4
VZ
1061 if ( !value )
1062 {
1063#ifdef HAVE_UNSETENV
65fd2fc2
VZ
1064 // don't test unsetenv() return value: it's void on some systems (at
1065 // least Darwin)
1066 unsetenv(variable.mb_str());
022a8d02 1067 return true;
a1353ea4
VZ
1068#else
1069 value = ""; // we can't pass NULL to setenv()
1070#endif
1071 }
1072
90a77e64 1073 return setenv(variable.mb_str(), value, 1 /* overwrite */) == 0;
8fd0d89b
VZ
1074#elif defined(HAVE_PUTENV)
1075 wxString s = variable;
1076 if ( value )
1077 s << _T('=') << value;
1078
1079 // transform to ANSI
67479dbd 1080 const wxWX2MBbuf p = s.mb_str();
8fd0d89b 1081
8fd0d89b
VZ
1082 char *buf = (char *)malloc(strlen(p) + 1);
1083 strcpy(buf, p);
1084
c0472c7c
VZ
1085 // store the string to free() it later
1086 wxEnvVars::iterator i = gs_envVars.find(variable);
1087 if ( i != gs_envVars.end() )
1088 {
1089 free(i->second);
1090 i->second = buf;
1091 }
1092 else // this variable hadn't been set before
1093 {
1094 gs_envVars[variable] = buf;
1095 }
1096
8fd0d89b
VZ
1097 return putenv(buf) == 0;
1098#else // no way to set an env var
67479dbd 1099 return false;
8fd0d89b
VZ
1100#endif
1101}
1102
90a77e64
VS
1103bool wxSetEnv(const wxString& variable, const wxString& value)
1104{
1105 return wxDoSetEnv(variable, value.mb_str());
1106}
1107
1108bool wxUnsetEnv(const wxString& variable)
1109{
1110 return wxDoSetEnv(variable, NULL);
1111}
1112
a37a5a73
VZ
1113// ----------------------------------------------------------------------------
1114// signal handling
1115// ----------------------------------------------------------------------------
1116
1117#if wxUSE_ON_FATAL_EXCEPTION
1118
1119#include <signal.h>
1120
90350682 1121extern "C" void wxFatalSignalHandler(wxTYPE_SA_HANDLER)
a37a5a73
VZ
1122{
1123 if ( wxTheApp )
1124 {
1125 // give the user a chance to do something special about this
1126 wxTheApp->OnFatalException();
1127 }
1128
1129 abort();
1130}
1131
1132bool wxHandleFatalExceptions(bool doit)
1133{
1134 // old sig handlers
9d8aca48 1135 static bool s_savedHandlers = false;
a37a5a73
VZ
1136 static struct sigaction s_handlerFPE,
1137 s_handlerILL,
1138 s_handlerBUS,
1139 s_handlerSEGV;
1140
9d8aca48 1141 bool ok = true;
a37a5a73
VZ
1142 if ( doit && !s_savedHandlers )
1143 {
1144 // install the signal handler
1145 struct sigaction act;
1146
1147 // some systems extend it with non std fields, so zero everything
1148 memset(&act, 0, sizeof(act));
1149
1150 act.sa_handler = wxFatalSignalHandler;
1151 sigemptyset(&act.sa_mask);
1152 act.sa_flags = 0;
1153
1154 ok &= sigaction(SIGFPE, &act, &s_handlerFPE) == 0;
1155 ok &= sigaction(SIGILL, &act, &s_handlerILL) == 0;
1156 ok &= sigaction(SIGBUS, &act, &s_handlerBUS) == 0;
1157 ok &= sigaction(SIGSEGV, &act, &s_handlerSEGV) == 0;
1158 if ( !ok )
1159 {
1160 wxLogDebug(_T("Failed to install our signal handler."));
1161 }
1162
9d8aca48 1163 s_savedHandlers = true;
a37a5a73
VZ
1164 }
1165 else if ( s_savedHandlers )
1166 {
1167 // uninstall the signal handler
1168 ok &= sigaction(SIGFPE, &s_handlerFPE, NULL) == 0;
1169 ok &= sigaction(SIGILL, &s_handlerILL, NULL) == 0;
1170 ok &= sigaction(SIGBUS, &s_handlerBUS, NULL) == 0;
1171 ok &= sigaction(SIGSEGV, &s_handlerSEGV, NULL) == 0;
1172 if ( !ok )
1173 {
1174 wxLogDebug(_T("Failed to uninstall our signal handler."));
1175 }
1176
9d8aca48 1177 s_savedHandlers = false;
a37a5a73
VZ
1178 }
1179 //else: nothing to do
1180
1181 return ok;
1182}
1183
1184#endif // wxUSE_ON_FATAL_EXCEPTION
1185
e2478fde
VZ
1186// ----------------------------------------------------------------------------
1187// wxExecute support
1188// ----------------------------------------------------------------------------
1189
1d043598 1190int wxAppTraits::AddProcessCallback(wxEndProcessData *data, int fd)
e2478fde 1191{
1d043598
VZ
1192 // define a custom handler processing only the closure of the descriptor
1193 struct wxEndProcessFDIOHandler : public wxFDIOHandler
e2478fde 1194 {
1d043598
VZ
1195 wxEndProcessFDIOHandler(wxEndProcessData *data, int fd)
1196 : m_data(data), m_fd(fd)
b827d647
VZ
1197 {
1198 }
e2478fde 1199
1d043598 1200 virtual void OnReadWaiting()
e2478fde 1201 {
1d043598
VZ
1202 wxFDIODispatcher::Get()->UnregisterFD(m_fd);
1203 close(m_fd);
05df0f1b 1204
1d043598 1205 wxHandleProcessTermination(m_data);
e2478fde 1206
1d043598 1207 delete this;
bc855d09 1208 }
e2478fde 1209
b827d647
VZ
1210 virtual void OnWriteWaiting() { wxFAIL_MSG("unreachable"); }
1211 virtual void OnExceptionWaiting() { wxFAIL_MSG("unreachable"); }
1212
1d043598
VZ
1213 wxEndProcessData * const m_data;
1214 const int m_fd;
1215 };
e2478fde 1216
1d043598
VZ
1217 wxFDIODispatcher::Get()->RegisterFD
1218 (
1219 fd,
1220 new wxEndProcessFDIOHandler(data, fd),
b827d647 1221 wxFDIO_INPUT
1d043598
VZ
1222 );
1223 return fd; // unused, but return something unique for the tag
e2478fde
VZ
1224}
1225
9d3845e8
VZ
1226bool wxAppTraits::CheckForRedirectedIO(wxExecuteData& execData)
1227{
1228#if HAS_PIPE_INPUT_STREAM
1229 bool hasIO = false;
1230
4d425dee 1231 if ( execData.bufOut && execData.bufOut->Update() )
9d3845e8 1232 hasIO = true;
9d3845e8 1233
4d425dee 1234 if ( execData.bufErr && execData.bufErr->Update() )
9d3845e8 1235 hasIO = true;
9d3845e8
VZ
1236
1237 return hasIO;
1238#else // !HAS_PIPE_INPUT_STREAM
1239 return false;
1240#endif // HAS_PIPE_INPUT_STREAM/!HAS_PIPE_INPUT_STREAM
1241}
1242
dbd1c638
VZ
1243// helper classes/functions used by WaitForChild()
1244namespace
1245{
1246
1247// convenient base class for IO handlers which are registered for read
1248// notifications only and which also stores the FD we're reading from
1249//
1250// the derived classes still have to implement OnReadWaiting()
33343395 1251class wxReadFDIOHandler : public wxFDIOHandler
46c7e1a1 1252{
33343395
VZ
1253public:
1254 wxReadFDIOHandler(wxFDIODispatcher& disp, int fd) : m_fd(fd)
46c7e1a1 1255 {
33343395
VZ
1256 if ( fd )
1257 disp.RegisterFD(fd, this, wxFDIO_INPUT);
1258 }
46c7e1a1 1259
33343395
VZ
1260 virtual void OnWriteWaiting() { wxFAIL_MSG("unreachable"); }
1261 virtual void OnExceptionWaiting() { wxFAIL_MSG("unreachable"); }
46c7e1a1 1262
dbd1c638 1263protected:
33343395
VZ
1264 const int m_fd;
1265
c0c133e1 1266 wxDECLARE_NO_COPY_CLASS(wxReadFDIOHandler);
33343395
VZ
1267};
1268
dbd1c638
VZ
1269// class for monitoring our end of the process detection pipe, simply sets a
1270// flag when input on the pipe (which must be due to EOF) is detected
33343395
VZ
1271class wxEndHandler : public wxReadFDIOHandler
1272{
1273public:
1274 wxEndHandler(wxFDIODispatcher& disp, int fd)
1275 : wxReadFDIOHandler(disp, fd)
1276 {
1277 m_terminated = false;
1278 }
1279
1280 bool Terminated() const { return m_terminated; }
46c7e1a1 1281
33343395 1282 virtual void OnReadWaiting() { m_terminated = true; }
46c7e1a1 1283
33343395
VZ
1284private:
1285 bool m_terminated;
1286
c0c133e1 1287 wxDECLARE_NO_COPY_CLASS(wxEndHandler);
33343395
VZ
1288};
1289
82db3c3d 1290#if HAS_PIPE_INPUT_STREAM
33343395 1291
dbd1c638
VZ
1292// class for monitoring our ends of child stdout/err, should be constructed
1293// with the FD and stream from wxExecuteData and will do nothing if they're
1294// invalid
1295//
1296// unlike wxEndHandler this class registers itself with the provided dispatcher
33343395
VZ
1297class wxRedirectedIOHandler : public wxReadFDIOHandler
1298{
1299public:
1300 wxRedirectedIOHandler(wxFDIODispatcher& disp,
1301 int fd,
1302 wxStreamTempInputBuffer *buf)
1303 : wxReadFDIOHandler(disp, fd),
1304 m_buf(buf)
1305 {
46c7e1a1 1306 }
33343395
VZ
1307
1308 virtual void OnReadWaiting()
1d043598 1309 {
33343395
VZ
1310 m_buf->Update();
1311 }
1312
1313private:
1314 wxStreamTempInputBuffer * const m_buf;
1315
c0c133e1 1316 wxDECLARE_NO_COPY_CLASS(wxRedirectedIOHandler);
33343395
VZ
1317};
1318
82db3c3d 1319#endif // HAS_PIPE_INPUT_STREAM
33343395 1320
b827d647 1321// helper function which calls waitpid() and analyzes the result
b827d647
VZ
1322int DoWaitForChild(int pid, int flags = 0)
1323{
1324 wxASSERT_MSG( pid > 0, "invalid PID" );
1325
1326 int status, rc;
1327
1328 // loop while we're getting EINTR
1329 for ( ;; )
1330 {
1331 rc = waitpid(pid, &status, flags);
1332
1333 if ( rc != -1 || errno != EINTR )
1334 break;
1335 }
1336
1337 if ( rc == 0 )
1338 {
1339 // This can only happen if the child application closes our dummy pipe
1340 // that is used to monitor its lifetime; in that case, our best bet is
1341 // to pretend the process did terminate, because otherwise wxExecute()
1342 // would hang indefinitely (OnReadWaiting() won't be called again, the
1343 // descriptor is closed now).
1344 wxLogDebug("Child process (PID %d) still alive but pipe closed so "
1345 "generating a close notification", pid);
1346 }
1347 else if ( rc == -1 )
1348 {
1349 wxLogLastError(wxString::Format("waitpid(%d)", pid));
1350 }
1351 else // child did terminate
1352 {
1353 wxASSERT_MSG( rc == pid, "unexpected waitpid() return value" );
1354
1355 if ( WIFEXITED(status) )
1356 return WEXITSTATUS(status);
1357 else if ( WIFSIGNALED(status) )
1358 return -WTERMSIG(status);
1359 else
1360 {
1361 wxLogError("Child process (PID %d) exited for unknown reason, "
1362 "status = %d", pid, status);
1363 }
1364 }
1365
1366 return -1;
1367}
1368
1369} // anonymous namespace
1370
33343395
VZ
1371int wxAppTraits::WaitForChild(wxExecuteData& execData)
1372{
1373 if ( !(execData.flags & wxEXEC_SYNC) )
1374 {
e528a71b
VZ
1375 // asynchronous execution: just launch the process and return,
1376 // endProcData will be destroyed when it terminates (currently we leak
1377 // it if the process doesn't terminate before we do and this should be
1378 // fixed but it's not a real leak so it's not really very high
1379 // priority)
1d043598 1380 wxEndProcessData *endProcData = new wxEndProcessData;
e528a71b
VZ
1381 endProcData->process = execData.process;
1382 endProcData->pid = execData.pid;
1d043598
VZ
1383 endProcData->tag = AddProcessCallback
1384 (
1385 endProcData,
33343395 1386 execData.GetEndProcReadFD()
1d043598 1387 );
e528a71b 1388 endProcData->async = true;
46c7e1a1 1389
1d043598 1390 return execData.pid;
33343395 1391 }
e528a71b 1392 //else: synchronous execution case
33343395 1393
82db3c3d 1394#if HAS_PIPE_INPUT_STREAM
33343395
VZ
1395 wxProcess * const process = execData.process;
1396 if ( process && process->IsRedirected() )
1397 {
1398 // we can't simply block waiting for the child to terminate as we would
1399 // dead lock if it writes more than the pipe buffer size (typically
1400 // 4KB) bytes of output -- it would then block waiting for us to read
1401 // the data while we'd block waiting for it to terminate
1402 //
1403 // so multiplex here waiting for any input from the child or closure of
1404 // the pipe used to indicate its termination
1405 wxSelectDispatcher disp;
1406
1407 wxEndHandler endHandler(disp, execData.GetEndProcReadFD());
1408
1409 wxRedirectedIOHandler outHandler(disp, execData.fdOut, execData.bufOut),
1410 errHandler(disp, execData.fdErr, execData.bufErr);
1411
1412 while ( !endHandler.Terminated() )
1413 {
1414 disp.Dispatch();
1415 }
1416 }
1417 //else: no IO redirection, just block waiting for the child to exit
82db3c3d 1418#endif // HAS_PIPE_INPUT_STREAM
33343395 1419
b827d647 1420 return DoWaitForChild(execData.pid);
46c7e1a1 1421}
46c7e1a1 1422
b827d647 1423void wxHandleProcessTermination(wxEndProcessData *data)
e2478fde 1424{
b827d647
VZ
1425 data->exitcode = DoWaitForChild(data->pid, WNOHANG);
1426
e2478fde 1427 // notify user about termination if required
b827d647 1428 if ( data->process )
e2478fde 1429 {
b827d647 1430 data->process->OnTerminate(data->pid, data->exitcode);
e2478fde
VZ
1431 }
1432
e528a71b
VZ
1433 if ( data->async )
1434 {
1435 // in case of asynchronous execution we don't need this data any more
1436 // after the child terminates
1437 delete data;
1438 }
1439 else // sync execution
1440 {
1441 // let wxExecute() know that the process has terminated
1442 data->pid = 0;
1443 }
e2478fde
VZ
1444}
1445