1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/utilsunx.cpp
3 // Purpose: generic Unix implementation of many wx functions
4 // Author: Vadim Zeitlin
6 // Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // ============================================================================
12 // ============================================================================
14 // ----------------------------------------------------------------------------
16 // ----------------------------------------------------------------------------
18 // for compilers that support precompilation, includes "wx.h".
19 #include "wx/wxprec.h"
23 #define USE_PUTENV (!defined(HAVE_SETENV) && defined(HAVE_PUTENV))
26 #include "wx/string.h"
30 #include "wx/wxcrtvararg.h"
32 #include "wx/module.h"
33 #include "wx/hashmap.h"
37 #include "wx/apptrait.h"
39 #include "wx/process.h"
40 #include "wx/thread.h"
42 #include "wx/wfstream.h"
44 #include "wx/private/selectdispatcher.h"
45 #include "wx/private/fdiodispatcher.h"
46 #include "wx/unix/execute.h"
47 #include "wx/unix/private.h"
49 #ifdef wxHAS_GENERIC_PROCESS_CALLBACK
50 #include "wx/private/fdiodispatcher.h"
54 #include <sys/wait.h> // waitpid()
56 #ifdef HAVE_SYS_SELECT_H
57 # include <sys/select.h>
60 #define HAS_PIPE_INPUT_STREAM (wxUSE_STREAMS && wxUSE_FILE)
62 #if HAS_PIPE_INPUT_STREAM
64 // define this to let wxexec.cpp know that we know what we're doing
65 #define _WX_USED_BY_WXEXECUTE_
66 #include "../common/execcmn.cpp"
68 #endif // HAS_PIPE_INPUT_STREAM
70 #if defined(__MWERKS__) && defined(__MACH__)
71 #ifndef WXWIN_OS_DESCRIPTION
72 #define WXWIN_OS_DESCRIPTION "MacOS X"
74 #ifndef HAVE_NANOSLEEP
75 #define HAVE_NANOSLEEP
81 // our configure test believes we can use sigaction() if the function is
82 // available but Metrowekrs with MSL run-time does have the function but
83 // doesn't have sigaction struct so finally we can't use it...
85 #undef wxUSE_ON_FATAL_EXCEPTION
86 #define wxUSE_ON_FATAL_EXCEPTION 0
90 // not only the statfs syscall is called differently depending on platform, but
91 // one of its incarnations, statvfs(), takes different arguments under
92 // different platforms and even different versions of the same system (Solaris
93 // 7 and 8): if you want to test for this, don't forget that the problems only
94 // appear if the large files support is enabled
97 #include <sys/param.h>
98 #include <sys/mount.h>
101 #endif // __BSD__/!__BSD__
103 #define wxStatfs statfs
105 #ifndef HAVE_STATFS_DECL
106 // some systems lack statfs() prototype in the system headers (AIX 4)
107 extern "C" int statfs(const char *path
, struct statfs
*buf
);
109 #endif // HAVE_STATFS
112 #include <sys/statvfs.h>
114 #define wxStatfs statvfs
115 #endif // HAVE_STATVFS
117 #if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
118 // WX_STATFS_T is detected by configure
119 #define wxStatfs_t WX_STATFS_T
122 // SGI signal.h defines signal handler arguments differently depending on
123 // whether _LANGUAGE_C_PLUS_PLUS is set or not - do set it
124 #if defined(__SGI__) && !defined(_LANGUAGE_C_PLUS_PLUS)
125 #define _LANGUAGE_C_PLUS_PLUS 1
131 #include <sys/stat.h>
132 #include <sys/types.h>
133 #include <sys/wait.h>
138 #include <fcntl.h> // for O_WRONLY and friends
139 #include <time.h> // nanosleep() and/or usleep()
140 #include <ctype.h> // isspace()
141 #include <sys/time.h> // needed for FD_SETSIZE
144 #include <sys/utsname.h> // for uname()
147 // Used by wxGetFreeMemory().
149 #include <sys/sysmp.h>
150 #include <sys/sysinfo.h> // for SAGET and MINFO structures
153 // ----------------------------------------------------------------------------
154 // conditional compilation
155 // ----------------------------------------------------------------------------
157 // many versions of Unices have this function, but it is not defined in system
158 // headers - please add your system here if it is the case for your OS.
159 // SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
160 #if !defined(HAVE_USLEEP) && \
161 ((defined(__SUN__) && !defined(__SunOs_5_6) && \
162 !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
163 defined(__osf__) || defined(__EMX__))
167 /* I copied this from the XFree86 diffs. AV. */
168 #define INCL_DOSPROCESS
170 inline void usleep(unsigned long delay
)
172 DosSleep(delay ?
(delay
/1000l) : 1l);
175 int usleep(unsigned int usec
);
176 #endif // __EMX__/Unix
179 #define HAVE_USLEEP 1
180 #endif // Unices without usleep()
182 // ============================================================================
184 // ============================================================================
186 // ----------------------------------------------------------------------------
188 // ----------------------------------------------------------------------------
190 void wxSleep(int nSecs
)
195 void wxMicroSleep(unsigned long microseconds
)
197 #if defined(HAVE_NANOSLEEP)
199 tmReq
.tv_sec
= (time_t)(microseconds
/ 1000000);
200 tmReq
.tv_nsec
= (microseconds
% 1000000) * 1000;
202 // we're not interested in remaining time nor in return value
203 (void)nanosleep(&tmReq
, (timespec
*)NULL
);
204 #elif defined(HAVE_USLEEP)
205 // uncomment this if you feel brave or if you are sure that your version
206 // of Solaris has a safe usleep() function but please notice that usleep()
207 // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
208 // documented as MT-Safe
209 #if defined(__SUN__) && wxUSE_THREADS
210 #error "usleep() cannot be used in MT programs under Solaris."
213 usleep(microseconds
);
214 #elif defined(HAVE_SLEEP)
215 // under BeOS sleep() takes seconds (what about other platforms, if any?)
216 sleep(microseconds
* 1000000);
217 #else // !sleep function
218 #error "usleep() or nanosleep() function required for wxMicroSleep"
219 #endif // sleep function
222 void wxMilliSleep(unsigned long milliseconds
)
224 wxMicroSleep(milliseconds
*1000);
227 // ----------------------------------------------------------------------------
228 // process management
229 // ----------------------------------------------------------------------------
231 int wxKill(long pid
, wxSignal sig
, wxKillError
*rc
, int flags
)
233 int err
= kill((pid_t
) (flags
& wxKILL_CHILDREN
) ?
-pid
: pid
, (int)sig
);
236 switch ( err ? errno
: 0 )
243 *rc
= wxKILL_BAD_SIGNAL
;
247 *rc
= wxKILL_ACCESS_DENIED
;
251 *rc
= wxKILL_NO_PROCESS
;
255 // this goes against Unix98 docs so log it
256 wxLogDebug(_T("unexpected kill(2) return value %d"), err
);
266 #define WXEXECUTE_NARGS 127
268 #if defined(__DARWIN__)
269 long wxMacExecute(wxChar
**argv
,
274 long wxExecute( const wxString
& command
, int flags
, wxProcess
*process
)
276 wxCHECK_MSG( !command
.empty(), 0, wxT("can't exec empty command") );
278 wxLogTrace(wxT("exec"), wxT("Executing \"%s\""), command
.c_str());
281 // fork() doesn't mix well with POSIX threads: on many systems the program
282 // deadlocks or crashes for some reason. Probably our code is buggy and
283 // doesn't do something which must be done to allow this to work, but I
284 // don't know what yet, so for now just warn the user (this is the least we
286 wxASSERT_MSG( wxThread
::IsMain(),
287 _T("wxExecute() can be called only from the main thread") );
288 #endif // wxUSE_THREADS
291 wxChar
*argv
[WXEXECUTE_NARGS
];
293 const wxChar
*cptr
= command
.c_str();
294 wxChar quotechar
= wxT('\0'); // is arg quoted?
295 bool escaped
= false;
297 // split the command line in arguments
300 argument
= wxEmptyString
;
301 quotechar
= wxT('\0');
303 // eat leading whitespace:
304 while ( wxIsspace(*cptr
) )
307 if ( *cptr
== wxT('\'') || *cptr
== wxT('"') )
312 if ( *cptr
== wxT('\\') && ! escaped
)
319 // all other characters:
323 // have we reached the end of the argument?
324 if ( (*cptr
== quotechar
&& ! escaped
)
325 || (quotechar
== wxT('\0') && wxIsspace(*cptr
))
326 || *cptr
== wxT('\0') )
328 wxASSERT_MSG( argc
< WXEXECUTE_NARGS
,
329 wxT("too many arguments in wxExecute") );
331 argv
[argc
] = new wxChar
[argument
.length() + 1];
332 wxStrcpy(argv
[argc
], argument
.c_str());
335 // if not at end of buffer, swallow last character:
339 break; // done with this one, start over
346 #if defined(__DARWIN__)
347 // wxMacExecute only executes app bundles.
348 // It returns an error code if the target is not an app bundle, thus falling
349 // through to the regular wxExecute for non app bundles.
350 lRc
= wxMacExecute(argv
, flags
, process
);
351 if( lRc
!= ((flags
& wxEXEC_SYNC
) ?
-1 : 0))
355 // do execute the command
356 lRc
= wxExecute(argv
, flags
, process
);
361 delete [] argv
[argc
++];
366 // ----------------------------------------------------------------------------
368 // ----------------------------------------------------------------------------
370 static wxString
wxMakeShellCommand(const wxString
& command
)
375 // just an interactive shell
380 // execute command in a shell
381 cmd
<< _T("/bin/sh -c '") << command
<< _T('\'');
387 bool wxShell(const wxString
& command
)
389 return wxExecute(wxMakeShellCommand(command
), wxEXEC_SYNC
) == 0;
392 bool wxShell(const wxString
& command
, wxArrayString
& output
)
394 wxCHECK_MSG( !command
.empty(), false, _T("can't exec shell non interactively") );
396 return wxExecute(wxMakeShellCommand(command
), output
);
399 // Shutdown or reboot the PC
400 bool wxShutdown(wxShutdownFlags wFlags
)
405 case wxSHUTDOWN_POWEROFF
:
409 case wxSHUTDOWN_REBOOT
:
414 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
418 return system(wxString
::Format(_T("init %c"), level
).mb_str()) == 0;
421 // ----------------------------------------------------------------------------
422 // wxStream classes to support IO redirection in wxExecute
423 // ----------------------------------------------------------------------------
425 #if HAS_PIPE_INPUT_STREAM
427 bool wxPipeInputStream
::CanRead() const
429 if ( m_lasterror
== wxSTREAM_EOF
)
432 // check if there is any input available
437 const int fd
= m_file
->fd();
442 wxFD_SET(fd
, &readfds
);
444 switch ( select(fd
+ 1, &readfds
, NULL
, NULL
, &tv
) )
447 wxLogSysError(_("Impossible to get child process input"));
454 wxFAIL_MSG(_T("unexpected select() return value"));
455 // still fall through
458 // input available -- or maybe not, as select() returns 1 when a
459 // read() will complete without delay, but it could still not read
465 #endif // HAS_PIPE_INPUT_STREAM
467 // ----------------------------------------------------------------------------
468 // wxExecute: the real worker function
469 // ----------------------------------------------------------------------------
471 long wxExecute(wxChar
**argv
, int flags
, wxProcess
*process
)
473 // for the sync execution, we return -1 to indicate failure, but for async
474 // case we return 0 which is never a valid PID
476 // we define this as a macro, not a variable, to avoid compiler warnings
477 // about "ERROR_RETURN_CODE value may be clobbered by fork()"
478 #define ERROR_RETURN_CODE ((flags & wxEXEC_SYNC) ? -1 : 0)
480 wxCHECK_MSG( *argv
, ERROR_RETURN_CODE
, wxT("can't exec empty command") );
484 char *mb_argv
[WXEXECUTE_NARGS
];
486 while (argv
[mb_argc
])
488 wxWX2MBbuf mb_arg
= wxSafeConvertWX2MB(argv
[mb_argc
]);
489 mb_argv
[mb_argc
] = strdup(mb_arg
);
492 mb_argv
[mb_argc
] = (char *) NULL
;
494 // this macro will free memory we used above
495 #define ARGS_CLEANUP \
496 for ( mb_argc = 0; mb_argv[mb_argc]; mb_argc++ ) \
497 free(mb_argv[mb_argc])
499 // no need for cleanup
502 wxChar
**mb_argv
= argv
;
503 #endif // Unicode/ANSI
505 // we want this function to work even if there is no wxApp so ensure that
506 // we have a valid traits pointer
507 wxConsoleAppTraits traitsConsole
;
508 wxAppTraits
*traits
= wxTheApp ? wxTheApp
->GetTraits() : NULL
;
510 traits
= &traitsConsole
;
512 // this struct contains all information which we pass to and from
513 // wxAppTraits methods
514 wxExecuteData execData
;
515 execData
.flags
= flags
;
516 execData
.process
= process
;
519 if ( !execData
.pipeEndProcDetect
.Create() )
521 wxLogError( _("Failed to execute '%s'\n"), *argv
);
525 return ERROR_RETURN_CODE
;
528 // pipes for inter process communication
529 wxPipe pipeIn
, // stdin
533 if ( process
&& process
->IsRedirected() )
535 if ( !pipeIn
.Create() || !pipeOut
.Create() || !pipeErr
.Create() )
537 wxLogError( _("Failed to execute '%s'\n"), *argv
);
541 return ERROR_RETURN_CODE
;
547 // NB: do *not* use vfork() here, it completely breaks this code for some
548 // reason under Solaris (and maybe others, although not under Linux)
549 // But on OpenVMS we do not have fork so we have to use vfork and
550 // cross our fingers that it works.
556 if ( pid
== -1 ) // error?
558 wxLogSysError( _("Fork failed") );
562 return ERROR_RETURN_CODE
;
564 else if ( pid
== 0 ) // we're in child
566 // These lines close the open file descriptors to to avoid any
567 // input/output which might block the process or irritate the user. If
568 // one wants proper IO for the subprocess, the right thing to do is to
569 // start an xterm executing it.
570 if ( !(flags
& wxEXEC_SYNC
) )
572 // FD_SETSIZE is unsigned under BSD, signed under other platforms
573 // so we need a cast to avoid warnings on all platforms
574 for ( int fd
= 0; fd
< (int)FD_SETSIZE
; fd
++ )
576 if ( fd
== pipeIn
[wxPipe
::Read
]
577 || fd
== pipeOut
[wxPipe
::Write
]
578 || fd
== pipeErr
[wxPipe
::Write
]
579 || fd
== (execData
.pipeEndProcDetect
)[wxPipe
::Write
] )
581 // don't close this one, we still need it
585 // leave stderr opened too, it won't do any harm
586 if ( fd
!= STDERR_FILENO
)
591 #if !defined(__VMS) && !defined(__EMX__)
592 if ( flags
& wxEXEC_MAKE_GROUP_LEADER
)
594 // Set process group to child process' pid. Then killing -pid
595 // of the parent will kill the process and all of its children.
600 // reading side can be safely closed but we should keep the write one
601 // opened, it will be only closed when the process terminates resulting
602 // in a read notification to the parent
603 execData
.pipeEndProcDetect
.Detach(wxPipe
::Write
);
604 execData
.pipeEndProcDetect
.Close();
606 // redirect stdin, stdout and stderr
609 if ( dup2(pipeIn
[wxPipe
::Read
], STDIN_FILENO
) == -1 ||
610 dup2(pipeOut
[wxPipe
::Write
], STDOUT_FILENO
) == -1 ||
611 dup2(pipeErr
[wxPipe
::Write
], STDERR_FILENO
) == -1 )
613 wxLogSysError(_("Failed to redirect child process input/output"));
621 execvp (*mb_argv
, mb_argv
);
623 fprintf(stderr
, "execvp(");
624 // CS changed ppc to ppc_ as ppc is not available under mac os CW Mach-O
625 for ( char **ppc_
= mb_argv
; *ppc_
; ppc_
++ )
626 fprintf(stderr
, "%s%s", ppc_
== mb_argv ?
"" : ", ", *ppc_
);
627 fprintf(stderr
, ") failed with error %d!\n", errno
);
629 // there is no return after successful exec()
632 // some compilers complain about missing return - of course, they
633 // should know that exit() doesn't return but what else can we do if
636 // and, sure enough, other compilers complain about unreachable code
637 // after exit() call, so we can just always have return here...
638 #if defined(__VMS) || defined(__INTEL_COMPILER)
642 else // we're in parent
646 // save it for WaitForChild() use
649 // prepare for IO redirection
651 #if HAS_PIPE_INPUT_STREAM
652 // the input buffer bufOut is connected to stdout, this is why it is
653 // called bufOut and not bufIn
654 wxStreamTempInputBuffer bufOut
,
657 if ( process
&& process
->IsRedirected() )
659 wxOutputStream
*inStream
=
660 new wxFileOutputStream(pipeIn
.Detach(wxPipe
::Write
));
662 const int fdOut
= pipeOut
.Detach(wxPipe
::Read
);
663 wxPipeInputStream
*outStream
= new wxPipeInputStream(fdOut
);
665 const int fdErr
= pipeErr
.Detach(wxPipe
::Read
);
666 wxPipeInputStream
*errStream
= new wxPipeInputStream(fdErr
);
668 process
->SetPipeStreams(outStream
, inStream
, errStream
);
670 bufOut
.Init(outStream
);
671 bufErr
.Init(errStream
);
673 execData
.bufOut
= &bufOut
;
674 execData
.bufErr
= &bufErr
;
676 execData
.fdOut
= fdOut
;
677 execData
.fdErr
= fdErr
;
679 #endif // HAS_PIPE_INPUT_STREAM
688 return traits
->WaitForChild(execData
);
691 #if !defined(__VMS) && !defined(__INTEL_COMPILER)
692 return ERROR_RETURN_CODE
;
696 #undef ERROR_RETURN_CODE
699 // ----------------------------------------------------------------------------
700 // file and directory functions
701 // ----------------------------------------------------------------------------
703 const wxChar
* wxGetHomeDir( wxString
*home
)
705 *home
= wxGetUserHome();
711 if ( tmp
.Last() != wxT(']'))
712 if ( tmp
.Last() != wxT('/')) *home
<< wxT('/');
714 return home
->c_str();
717 wxString
wxGetUserHome( const wxString
&user
)
719 struct passwd
*who
= (struct passwd
*) NULL
;
725 if ((ptr
= wxGetenv(wxT("HOME"))) != NULL
)
730 if ((ptr
= wxGetenv(wxT("USER"))) != NULL
||
731 (ptr
= wxGetenv(wxT("LOGNAME"))) != NULL
)
733 who
= getpwnam(wxSafeConvertWX2MB(ptr
));
736 // make sure the user exists!
739 who
= getpwuid(getuid());
744 who
= getpwnam (user
.mb_str());
747 return wxSafeConvertMB2WX(who ? who
->pw_dir
: 0);
750 // ----------------------------------------------------------------------------
751 // network and user id routines
752 // ----------------------------------------------------------------------------
754 // private utility function which returns output of the given command, removing
755 // the trailing newline
756 static wxString
wxGetCommandOutput(const wxString
&cmd
)
758 FILE *f
= popen(cmd
.ToAscii(), "r");
761 wxLogSysError(_T("Executing \"%s\" failed"), cmd
.c_str());
762 return wxEmptyString
;
769 if ( !fgets(buf
, sizeof(buf
), f
) )
772 s
+= wxString
::FromAscii(buf
);
777 if ( !s
.empty() && s
.Last() == _T('\n') )
783 // retrieve either the hostname or FQDN depending on platform (caller must
784 // check whether it's one or the other, this is why this function is for
786 static bool wxGetHostNameInternal(wxChar
*buf
, int sz
)
788 wxCHECK_MSG( buf
, false, wxT("NULL pointer in wxGetHostNameInternal") );
792 // we're using uname() which is POSIX instead of less standard sysinfo()
793 #if defined(HAVE_UNAME)
795 bool ok
= uname(&uts
) != -1;
798 wxStrncpy(buf
, wxSafeConvertMB2WX(uts
.nodename
), sz
- 1);
801 #elif defined(HAVE_GETHOSTNAME)
803 bool ok
= gethostname(cbuf
, sz
) != -1;
806 wxStrncpy(buf
, wxSafeConvertMB2WX(cbuf
), sz
- 1);
809 #else // no uname, no gethostname
810 wxFAIL_MSG(wxT("don't know host name for this machine"));
813 #endif // uname/gethostname
817 wxLogSysError(_("Cannot get the hostname"));
823 bool wxGetHostName(wxChar
*buf
, int sz
)
825 bool ok
= wxGetHostNameInternal(buf
, sz
);
829 // BSD systems return the FQDN, we only want the hostname, so extract
830 // it (we consider that dots are domain separators)
831 wxChar
*dot
= wxStrchr(buf
, wxT('.'));
842 bool wxGetFullHostName(wxChar
*buf
, int sz
)
844 bool ok
= wxGetHostNameInternal(buf
, sz
);
848 if ( !wxStrchr(buf
, wxT('.')) )
850 struct hostent
*host
= gethostbyname(wxSafeConvertWX2MB(buf
));
853 wxLogSysError(_("Cannot get the official hostname"));
859 // the canonical name
860 wxStrncpy(buf
, wxSafeConvertMB2WX(host
->h_name
), sz
);
863 //else: it's already a FQDN (BSD behaves this way)
869 bool wxGetUserId(wxChar
*buf
, int sz
)
874 if ((who
= getpwuid(getuid ())) != NULL
)
876 wxStrncpy (buf
, wxSafeConvertMB2WX(who
->pw_name
), sz
- 1);
883 bool wxGetUserName(wxChar
*buf
, int sz
)
889 if ((who
= getpwuid (getuid ())) != NULL
)
891 char *comma
= strchr(who
->pw_gecos
, ',');
893 *comma
= '\0'; // cut off non-name comment fields
894 wxStrncpy (buf
, wxSafeConvertMB2WX(who
->pw_gecos
), sz
- 1);
899 #else // !HAVE_PW_GECOS
900 return wxGetUserId(buf
, sz
);
901 #endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
904 bool wxIsPlatform64Bit()
906 const wxString machine
= wxGetCommandOutput(wxT("uname -m"));
908 // the test for "64" is obviously not 100% reliable but seems to work fine
910 return machine
.Contains(wxT("64")) ||
911 machine
.Contains(wxT("alpha"));
914 // these functions are in mac/utils.cpp for wxMac
917 wxOperatingSystemId
wxGetOsVersion(int *verMaj
, int *verMin
)
921 wxString release
= wxGetCommandOutput(wxT("uname -r"));
922 if ( release
.empty() ||
923 wxSscanf(release
.c_str(), wxT("%d.%d"), &major
, &minor
) != 2 )
925 // failed to get version string or unrecognized format
935 // try to understand which OS are we running
936 wxString kernel
= wxGetCommandOutput(wxT("uname -s"));
937 if ( kernel
.empty() )
938 kernel
= wxGetCommandOutput(wxT("uname -o"));
940 if ( kernel
.empty() )
943 return wxPlatformInfo
::GetOperatingSystemId(kernel
);
946 wxString
wxGetOsDescription()
948 return wxGetCommandOutput(wxT("uname -s -r -m"));
953 unsigned long wxGetProcessId()
955 return (unsigned long)getpid();
958 wxMemorySize
wxGetFreeMemory()
960 #if defined(__LINUX__)
961 // get it from /proc/meminfo
962 FILE *fp
= fopen("/proc/meminfo", "r");
968 if ( fgets(buf
, WXSIZEOF(buf
), fp
) && fgets(buf
, WXSIZEOF(buf
), fp
) )
970 // /proc/meminfo changed its format in kernel 2.6
971 if ( wxPlatformInfo().CheckOSVersion(2, 6) )
973 unsigned long cached
, buffers
;
974 sscanf(buf
, "MemFree: %ld", &memFree
);
976 fgets(buf
, WXSIZEOF(buf
), fp
);
977 sscanf(buf
, "Buffers: %lu", &buffers
);
979 fgets(buf
, WXSIZEOF(buf
), fp
);
980 sscanf(buf
, "Cached: %lu", &cached
);
982 // add to "MemFree" also the "Buffers" and "Cached" values as
983 // free(1) does as otherwise the value never makes sense: for
984 // kernel 2.6 it's always almost 0
985 memFree
+= buffers
+ cached
;
987 // values here are always expressed in kB and we want bytes
990 else // Linux 2.4 (or < 2.6, anyhow)
992 long memTotal
, memUsed
;
993 sscanf(buf
, "Mem: %ld %ld %ld", &memTotal
, &memUsed
, &memFree
);
999 return (wxMemorySize
)memFree
;
1001 #elif defined(__SGI__)
1002 struct rminfo realmem
;
1003 if ( sysmp(MP_SAGET
, MPSA_RMINFO
, &realmem
, sizeof realmem
) == 0 )
1004 return ((wxMemorySize
)realmem
.physmem
* sysconf(_SC_PAGESIZE
));
1005 #elif defined(_SC_AVPHYS_PAGES)
1006 return ((wxMemorySize
)sysconf(_SC_AVPHYS_PAGES
))*sysconf(_SC_PAGESIZE
);
1007 //#elif defined(__FREEBSD__) -- might use sysctl() to find it out, probably
1010 // can't find it out
1014 bool wxGetDiskSpace(const wxString
& path
, wxDiskspaceSize_t
*pTotal
, wxDiskspaceSize_t
*pFree
)
1016 #if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
1017 // the case to "char *" is needed for AIX 4.3
1019 if ( wxStatfs((char *)(const char*)path
.fn_str(), &fs
) != 0 )
1021 wxLogSysError( wxT("Failed to get file system statistics") );
1026 // under Solaris we also have to use f_frsize field instead of f_bsize
1027 // which is in general a multiple of f_frsize
1029 wxDiskspaceSize_t blockSize
= fs
.f_frsize
;
1030 #else // HAVE_STATFS
1031 wxDiskspaceSize_t blockSize
= fs
.f_bsize
;
1032 #endif // HAVE_STATVFS/HAVE_STATFS
1036 *pTotal
= wxDiskspaceSize_t(fs
.f_blocks
) * blockSize
;
1041 *pFree
= wxDiskspaceSize_t(fs
.f_bavail
) * blockSize
;
1045 #else // !HAVE_STATFS && !HAVE_STATVFS
1047 #endif // HAVE_STATFS
1050 // ----------------------------------------------------------------------------
1052 // ----------------------------------------------------------------------------
1056 WX_DECLARE_STRING_HASH_MAP(char *, wxEnvVars
);
1058 static wxEnvVars gs_envVars
;
1060 class wxSetEnvModule
: public wxModule
1063 virtual bool OnInit() { return true; }
1064 virtual void OnExit()
1066 for ( wxEnvVars
::const_iterator i
= gs_envVars
.begin();
1067 i
!= gs_envVars
.end();
1076 DECLARE_DYNAMIC_CLASS(wxSetEnvModule
)
1079 IMPLEMENT_DYNAMIC_CLASS(wxSetEnvModule
, wxModule
)
1081 #endif // USE_PUTENV
1083 bool wxGetEnv(const wxString
& var
, wxString
*value
)
1085 // wxGetenv is defined as getenv()
1086 char *p
= wxGetenv(var
);
1098 static bool wxDoSetEnv(const wxString
& variable
, const char *value
)
1100 #if defined(HAVE_SETENV)
1103 #ifdef HAVE_UNSETENV
1104 // don't test unsetenv() return value: it's void on some systems (at
1106 unsetenv(variable
.mb_str());
1109 value
= ""; // we can't pass NULL to setenv()
1113 return setenv(variable
.mb_str(), value
, 1 /* overwrite */) == 0;
1114 #elif defined(HAVE_PUTENV)
1115 wxString s
= variable
;
1117 s
<< _T('=') << value
;
1119 // transform to ANSI
1120 const wxWX2MBbuf p
= s
.mb_str();
1122 char *buf
= (char *)malloc(strlen(p
) + 1);
1125 // store the string to free() it later
1126 wxEnvVars
::iterator i
= gs_envVars
.find(variable
);
1127 if ( i
!= gs_envVars
.end() )
1132 else // this variable hadn't been set before
1134 gs_envVars
[variable
] = buf
;
1137 return putenv(buf
) == 0;
1138 #else // no way to set an env var
1143 bool wxSetEnv(const wxString
& variable
, const wxString
& value
)
1145 return wxDoSetEnv(variable
, value
.mb_str());
1148 bool wxUnsetEnv(const wxString
& variable
)
1150 return wxDoSetEnv(variable
, NULL
);
1153 // ----------------------------------------------------------------------------
1155 // ----------------------------------------------------------------------------
1157 #if wxUSE_ON_FATAL_EXCEPTION
1161 extern "C" void wxFatalSignalHandler(wxTYPE_SA_HANDLER
)
1165 // give the user a chance to do something special about this
1166 wxTheApp
->OnFatalException();
1172 bool wxHandleFatalExceptions(bool doit
)
1175 static bool s_savedHandlers
= false;
1176 static struct sigaction s_handlerFPE
,
1182 if ( doit
&& !s_savedHandlers
)
1184 // install the signal handler
1185 struct sigaction act
;
1187 // some systems extend it with non std fields, so zero everything
1188 memset(&act
, 0, sizeof(act
));
1190 act
.sa_handler
= wxFatalSignalHandler
;
1191 sigemptyset(&act
.sa_mask
);
1194 ok
&= sigaction(SIGFPE
, &act
, &s_handlerFPE
) == 0;
1195 ok
&= sigaction(SIGILL
, &act
, &s_handlerILL
) == 0;
1196 ok
&= sigaction(SIGBUS
, &act
, &s_handlerBUS
) == 0;
1197 ok
&= sigaction(SIGSEGV
, &act
, &s_handlerSEGV
) == 0;
1200 wxLogDebug(_T("Failed to install our signal handler."));
1203 s_savedHandlers
= true;
1205 else if ( s_savedHandlers
)
1207 // uninstall the signal handler
1208 ok
&= sigaction(SIGFPE
, &s_handlerFPE
, NULL
) == 0;
1209 ok
&= sigaction(SIGILL
, &s_handlerILL
, NULL
) == 0;
1210 ok
&= sigaction(SIGBUS
, &s_handlerBUS
, NULL
) == 0;
1211 ok
&= sigaction(SIGSEGV
, &s_handlerSEGV
, NULL
) == 0;
1214 wxLogDebug(_T("Failed to uninstall our signal handler."));
1217 s_savedHandlers
= false;
1219 //else: nothing to do
1224 #endif // wxUSE_ON_FATAL_EXCEPTION
1226 // ----------------------------------------------------------------------------
1227 // wxExecute support
1228 // ----------------------------------------------------------------------------
1230 int wxAppTraits
::AddProcessCallback(wxEndProcessData
*data
, int fd
)
1232 // define a custom handler processing only the closure of the descriptor
1233 struct wxEndProcessFDIOHandler
: public wxFDIOHandler
1235 wxEndProcessFDIOHandler(wxEndProcessData
*data
, int fd
)
1236 : m_data(data
), m_fd(fd
)
1239 virtual void OnReadWaiting()
1240 { wxFAIL_MSG("this isn't supposed to happen"); }
1241 virtual void OnWriteWaiting()
1242 { wxFAIL_MSG("this isn't supposed to happen"); }
1244 virtual void OnExceptionWaiting()
1246 const int pid
= m_data
->pid
> 0 ? m_data
->pid
: -(m_data
->pid
);
1249 // has the process really terminated?
1250 int rc
= waitpid(pid
, &status
, WNOHANG
);
1253 // This can only happen if the child application closes our
1254 // dummy pipe that is used to monitor its lifetime; in that
1255 // case, our best bet is to pretend the process did terminate,
1256 // because otherwise wxExecute() would hang indefinitely
1257 // (OnExceptionWaiting() won't be called again, the descriptor
1259 wxLogDebug("Child process (PID %d) still alive, "
1260 "even though pipe was closed.", pid
);
1262 else if ( rc
== -1 )
1264 // As above, if waitpid() fails, the best we can do is to log the
1265 // error and pretend the child terminated:
1266 wxLogSysError(_("Failed to check child process' status"));
1269 // set exit code to -1 if something bad happened
1270 m_data
->exitcode
= rc
> 0 && WIFEXITED(status
) ?
WEXITSTATUS(status
)
1274 "Child process (PID %d) terminated with exit code %d",
1275 pid
, m_data
->exitcode
);
1277 // child exited, end waiting
1278 wxFDIODispatcher
::Get()->UnregisterFD(m_fd
);
1281 wxHandleProcessTermination(m_data
);
1286 wxEndProcessData
* const m_data
;
1290 wxFDIODispatcher
::Get()->RegisterFD
1293 new wxEndProcessFDIOHandler(data
, fd
),
1296 return fd
; // unused, but return something unique for the tag
1299 bool wxAppTraits
::CheckForRedirectedIO(wxExecuteData
& execData
)
1301 #if HAS_PIPE_INPUT_STREAM
1304 if ( execData
.bufOut
&& execData
.bufOut
->Update() )
1307 if ( execData
.bufErr
&& execData
.bufErr
->Update() )
1311 #else // !HAS_PIPE_INPUT_STREAM
1313 #endif // HAS_PIPE_INPUT_STREAM/!HAS_PIPE_INPUT_STREAM
1316 class wxReadFDIOHandler
: public wxFDIOHandler
1319 wxReadFDIOHandler(wxFDIODispatcher
& disp
, int fd
) : m_fd(fd
)
1322 disp
.RegisterFD(fd
, this, wxFDIO_INPUT
);
1325 int GetFD() const { return m_fd
; }
1327 virtual void OnWriteWaiting() { wxFAIL_MSG("unreachable"); }
1328 virtual void OnExceptionWaiting() { wxFAIL_MSG("unreachable"); }
1333 DECLARE_NO_COPY_CLASS(wxReadFDIOHandler
)
1336 class wxEndHandler
: public wxReadFDIOHandler
1339 wxEndHandler(wxFDIODispatcher
& disp
, int fd
)
1340 : wxReadFDIOHandler(disp
, fd
)
1342 m_terminated
= false;
1345 bool Terminated() const { return m_terminated
; }
1347 virtual void OnReadWaiting() { m_terminated
= true; }
1352 DECLARE_NO_COPY_CLASS(wxEndHandler
)
1357 class wxRedirectedIOHandler
: public wxReadFDIOHandler
1360 wxRedirectedIOHandler(wxFDIODispatcher
& disp
,
1362 wxStreamTempInputBuffer
*buf
)
1363 : wxReadFDIOHandler(disp
, fd
),
1368 virtual void OnReadWaiting()
1374 wxStreamTempInputBuffer
* const m_buf
;
1376 DECLARE_NO_COPY_CLASS(wxRedirectedIOHandler
)
1379 #endif // wxUSE_STREAMS
1381 int wxAppTraits
::WaitForChild(wxExecuteData
& execData
)
1383 if ( !(execData
.flags
& wxEXEC_SYNC
) )
1385 // asynchronous execution: just launch the process and return
1386 wxEndProcessData
*endProcData
= new wxEndProcessData
;
1387 endProcData
->process
= execData
.process
;
1388 endProcData
->pid
= execData
.pid
;
1389 endProcData
->tag
= AddProcessCallback
1392 execData
.GetEndProcReadFD()
1395 return execData
.pid
;
1399 wxProcess
* const process
= execData
.process
;
1400 if ( process
&& process
->IsRedirected() )
1402 // we can't simply block waiting for the child to terminate as we would
1403 // dead lock if it writes more than the pipe buffer size (typically
1404 // 4KB) bytes of output -- it would then block waiting for us to read
1405 // the data while we'd block waiting for it to terminate
1407 // so multiplex here waiting for any input from the child or closure of
1408 // the pipe used to indicate its termination
1409 wxSelectDispatcher disp
;
1411 wxEndHandler
endHandler(disp
, execData
.GetEndProcReadFD());
1413 wxRedirectedIOHandler
outHandler(disp
, execData
.fdOut
, execData
.bufOut
),
1414 errHandler(disp
, execData
.fdErr
, execData
.bufErr
);
1416 while ( !endHandler
.Terminated() )
1421 //else: no IO redirection, just block waiting for the child to exit
1422 #endif // wxUSE_STREAMS
1426 int result
= waitpid(execData
.pid
, &status
, 0);
1428 /* DE: waitpid manpage states that waitpid can fail with EINTR
1429 if the call is interrupted by a caught signal. I suppose
1430 that means that this ought to be a while loop.
1432 The odd thing is that it seems to fail EVERY time. It fails
1433 with a quickly exiting process (e.g. echo), and fails with a
1434 slowly exiting process (e.g. sleep 2) but clearly after
1435 having waited for the child to exit. Maybe it's a bug in
1436 my particular version.
1438 It works, however, from the CFSocket callback without this
1439 trick but in that case it's used only after CFSocket calls
1440 the callback and with the WNOHANG flag which would seem to
1441 preclude it from being interrupted or at least make it much
1442 less likely since it would not then be waiting.
1444 If Darwin's man page is to be believed then this is definitely
1445 necessary. It's just weird that I've never seen it before
1446 and apparently no one else has either or you'd think they'd
1447 have reported it by now. Perhaps blocking the GUI while
1448 waiting for a child process to exit is simply not that common.
1450 if ( result
== -1 && errno
== EINTR
)
1452 result
= waitpid(execData
.pid
, &status
, 0);
1454 #endif // __DARWIN__
1458 wxLogLastError("waitpid");
1460 else // child terminated
1462 wxASSERT_MSG( result
== execData
.pid
,
1463 "unexpected waitpid() return value" );
1465 if ( WIFEXITED(status
) )
1467 return WEXITSTATUS(status
);
1469 else // abnormal termination?
1471 wxASSERT_MSG( WIFSIGNALED(status
),
1472 "unexpected child wait status" );
1476 wxLogSysError(_("Waiting for subprocess termination failed"));
1481 void wxHandleProcessTermination(wxEndProcessData
*proc_data
)
1483 // notify user about termination if required
1484 if ( proc_data
->process
)
1486 proc_data
->process
->OnTerminate(proc_data
->pid
, proc_data
->exitcode
);
1490 if ( proc_data
->pid
> 0 )
1495 else // sync execution
1497 // let wxExecute() know that the process has terminated