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"
24 #include "wx/string.h"
30 #include "wx/apptrait.h"
32 #include "wx/process.h"
33 #include "wx/thread.h"
35 #include "wx/wfstream.h"
37 #include "wx/unix/execute.h"
38 #include "wx/unix/private.h"
42 #ifdef HAVE_SYS_SELECT_H
43 # include <sys/select.h>
46 #define HAS_PIPE_INPUT_STREAM (wxUSE_STREAMS && wxUSE_FILE)
48 #if HAS_PIPE_INPUT_STREAM
50 // define this to let wxexec.cpp know that we know what we're doing
51 #define _WX_USED_BY_WXEXECUTE_
52 #include "../common/execcmn.cpp"
54 #endif // HAS_PIPE_INPUT_STREAM
58 #if defined(__MWERKS__) && defined(__MACH__)
59 #ifndef WXWIN_OS_DESCRIPTION
60 #define WXWIN_OS_DESCRIPTION "MacOS X"
62 #ifndef HAVE_NANOSLEEP
63 #define HAVE_NANOSLEEP
69 // our configure test believes we can use sigaction() if the function is
70 // available but Metrowekrs with MSL run-time does have the function but
71 // doesn't have sigaction struct so finally we can't use it...
73 #undef wxUSE_ON_FATAL_EXCEPTION
74 #define wxUSE_ON_FATAL_EXCEPTION 0
78 // not only the statfs syscall is called differently depending on platform, but
79 // one of its incarnations, statvfs(), takes different arguments under
80 // different platforms and even different versions of the same system (Solaris
81 // 7 and 8): if you want to test for this, don't forget that the problems only
82 // appear if the large files support is enabled
85 #include <sys/param.h>
86 #include <sys/mount.h>
89 #endif // __BSD__/!__BSD__
91 #define wxStatfs statfs
93 #ifndef HAVE_STATFS_DECL
94 // some systems lack statfs() prototype in the system headers (AIX 4)
95 extern "C" int statfs(const char *path
, struct statfs
*buf
);
100 #include <sys/statvfs.h>
102 #define wxStatfs statvfs
103 #endif // HAVE_STATVFS
105 #if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
106 // WX_STATFS_T is detected by configure
107 #define wxStatfs_t WX_STATFS_T
110 // SGI signal.h defines signal handler arguments differently depending on
111 // whether _LANGUAGE_C_PLUS_PLUS is set or not - do set it
112 #if defined(__SGI__) && !defined(_LANGUAGE_C_PLUS_PLUS)
113 #define _LANGUAGE_C_PLUS_PLUS 1
119 #include <sys/stat.h>
120 #include <sys/types.h>
121 #include <sys/wait.h>
126 #include <fcntl.h> // for O_WRONLY and friends
127 #include <time.h> // nanosleep() and/or usleep()
128 #include <ctype.h> // isspace()
129 #include <sys/time.h> // needed for FD_SETSIZE
132 #include <sys/utsname.h> // for uname()
135 // Used by wxGetFreeMemory().
137 #include <sys/sysmp.h>
138 #include <sys/sysinfo.h> // for SAGET and MINFO structures
141 // ----------------------------------------------------------------------------
142 // conditional compilation
143 // ----------------------------------------------------------------------------
145 // many versions of Unices have this function, but it is not defined in system
146 // headers - please add your system here if it is the case for your OS.
147 // SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
148 #if !defined(HAVE_USLEEP) && \
149 ((defined(__SUN__) && !defined(__SunOs_5_6) && \
150 !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
151 defined(__osf__) || defined(__EMX__))
155 /* I copied this from the XFree86 diffs. AV. */
156 #define INCL_DOSPROCESS
158 inline void usleep(unsigned long delay
)
160 DosSleep(delay
? (delay
/1000l) : 1l);
163 int usleep(unsigned int usec
);
164 #endif // __EMX__/Unix
167 #define HAVE_USLEEP 1
168 #endif // Unices without usleep()
170 // ============================================================================
172 // ============================================================================
174 // ----------------------------------------------------------------------------
176 // ----------------------------------------------------------------------------
178 void wxSleep(int nSecs
)
183 void wxMicroSleep(unsigned long microseconds
)
185 #if defined(HAVE_NANOSLEEP)
187 tmReq
.tv_sec
= (time_t)(microseconds
/ 1000000);
188 tmReq
.tv_nsec
= (microseconds
% 1000000) * 1000;
190 // we're not interested in remaining time nor in return value
191 (void)nanosleep(&tmReq
, (timespec
*)NULL
);
192 #elif defined(HAVE_USLEEP)
193 // uncomment this if you feel brave or if you are sure that your version
194 // of Solaris has a safe usleep() function but please notice that usleep()
195 // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
196 // documented as MT-Safe
197 #if defined(__SUN__) && wxUSE_THREADS
198 #error "usleep() cannot be used in MT programs under Solaris."
201 usleep(microseconds
);
202 #elif defined(HAVE_SLEEP)
203 // under BeOS sleep() takes seconds (what about other platforms, if any?)
204 sleep(microseconds
* 1000000);
205 #else // !sleep function
206 #error "usleep() or nanosleep() function required for wxMicroSleep"
207 #endif // sleep function
210 void wxMilliSleep(unsigned long milliseconds
)
212 wxMicroSleep(milliseconds
*1000);
215 // ----------------------------------------------------------------------------
216 // process management
217 // ----------------------------------------------------------------------------
219 int wxKill(long pid
, wxSignal sig
, wxKillError
*rc
, int flags
)
221 int err
= kill((pid_t
) (flags
& wxKILL_CHILDREN
) ? -pid
: pid
, (int)sig
);
224 switch ( err
? errno
: 0 )
231 *rc
= wxKILL_BAD_SIGNAL
;
235 *rc
= wxKILL_ACCESS_DENIED
;
239 *rc
= wxKILL_NO_PROCESS
;
243 // this goes against Unix98 docs so log it
244 wxLogDebug(_T("unexpected kill(2) return value %d"), err
);
254 #define WXEXECUTE_NARGS 127
256 #if defined(__DARWIN__)
257 long wxMacExecute(wxChar
**argv
,
262 long wxExecute( const wxString
& command
, int flags
, wxProcess
*process
)
264 wxCHECK_MSG( !command
.empty(), 0, wxT("can't exec empty command") );
266 wxLogTrace(wxT("exec"), wxT("Executing \"%s\""), command
.c_str());
269 // fork() doesn't mix well with POSIX threads: on many systems the program
270 // deadlocks or crashes for some reason. Probably our code is buggy and
271 // doesn't do something which must be done to allow this to work, but I
272 // don't know what yet, so for now just warn the user (this is the least we
274 wxASSERT_MSG( wxThread::IsMain(),
275 _T("wxExecute() can be called only from the main thread") );
276 #endif // wxUSE_THREADS
279 wxChar
*argv
[WXEXECUTE_NARGS
];
281 const wxChar
*cptr
= command
.c_str();
282 wxChar quotechar
= wxT('\0'); // is arg quoted?
283 bool escaped
= false;
285 // split the command line in arguments
288 argument
= wxEmptyString
;
289 quotechar
= wxT('\0');
291 // eat leading whitespace:
292 while ( wxIsspace(*cptr
) )
295 if ( *cptr
== wxT('\'') || *cptr
== wxT('"') )
300 if ( *cptr
== wxT('\\') && ! escaped
)
307 // all other characters:
311 // have we reached the end of the argument?
312 if ( (*cptr
== quotechar
&& ! escaped
)
313 || (quotechar
== wxT('\0') && wxIsspace(*cptr
))
314 || *cptr
== wxT('\0') )
316 wxASSERT_MSG( argc
< WXEXECUTE_NARGS
,
317 wxT("too many arguments in wxExecute") );
319 argv
[argc
] = new wxChar
[argument
.length() + 1];
320 wxStrcpy(argv
[argc
], argument
.c_str());
323 // if not at end of buffer, swallow last character:
327 break; // done with this one, start over
334 #if defined(__DARWIN__)
335 // wxMacExecute only executes app bundles.
336 // It returns an error code if the target is not an app bundle, thus falling
337 // through to the regular wxExecute for non app bundles.
338 lRc
= wxMacExecute(argv
, flags
, process
);
339 if( lRc
!= ((flags
& wxEXEC_SYNC
) ? -1 : 0))
343 // do execute the command
344 lRc
= wxExecute(argv
, flags
, process
);
349 delete [] argv
[argc
++];
354 // ----------------------------------------------------------------------------
356 // ----------------------------------------------------------------------------
358 static wxString
wxMakeShellCommand(const wxString
& command
)
363 // just an interactive shell
368 // execute command in a shell
369 cmd
<< _T("/bin/sh -c '") << command
<< _T('\'');
375 bool wxShell(const wxString
& command
)
377 return wxExecute(wxMakeShellCommand(command
), wxEXEC_SYNC
) == 0;
380 bool wxShell(const wxString
& command
, wxArrayString
& output
)
382 wxCHECK_MSG( !command
.empty(), false, _T("can't exec shell non interactively") );
384 return wxExecute(wxMakeShellCommand(command
), output
);
387 // Shutdown or reboot the PC
388 bool wxShutdown(wxShutdownFlags wFlags
)
393 case wxSHUTDOWN_POWEROFF
:
397 case wxSHUTDOWN_REBOOT
:
402 wxFAIL_MSG( _T("unknown wxShutdown() flag") );
406 return system(wxString::Format(_T("init %c"), level
).mb_str()) == 0;
409 // ----------------------------------------------------------------------------
410 // wxStream classes to support IO redirection in wxExecute
411 // ----------------------------------------------------------------------------
413 #if HAS_PIPE_INPUT_STREAM
415 bool wxPipeInputStream::CanRead() const
417 if ( m_lasterror
== wxSTREAM_EOF
)
420 // check if there is any input available
425 const int fd
= m_file
->fd();
430 wxFD_SET(fd
, &readfds
);
432 switch ( select(fd
+ 1, &readfds
, NULL
, NULL
, &tv
) )
435 wxLogSysError(_("Impossible to get child process input"));
442 wxFAIL_MSG(_T("unexpected select() return value"));
443 // still fall through
446 // input available -- or maybe not, as select() returns 1 when a
447 // read() will complete without delay, but it could still not read
453 #endif // HAS_PIPE_INPUT_STREAM
455 // ----------------------------------------------------------------------------
456 // wxExecute: the real worker function
457 // ----------------------------------------------------------------------------
459 long wxExecute(wxChar
**argv
, int flags
, wxProcess
*process
)
461 // for the sync execution, we return -1 to indicate failure, but for async
462 // case we return 0 which is never a valid PID
464 // we define this as a macro, not a variable, to avoid compiler warnings
465 // about "ERROR_RETURN_CODE value may be clobbered by fork()"
466 #define ERROR_RETURN_CODE ((flags & wxEXEC_SYNC) ? -1 : 0)
468 wxCHECK_MSG( *argv
, ERROR_RETURN_CODE
, wxT("can't exec empty command") );
472 char *mb_argv
[WXEXECUTE_NARGS
];
474 while (argv
[mb_argc
])
476 wxWX2MBbuf mb_arg
= wxSafeConvertWX2MB(argv
[mb_argc
]);
477 mb_argv
[mb_argc
] = strdup(mb_arg
);
480 mb_argv
[mb_argc
] = (char *) NULL
;
482 // this macro will free memory we used above
483 #define ARGS_CLEANUP \
484 for ( mb_argc = 0; mb_argv[mb_argc]; mb_argc++ ) \
485 free(mb_argv[mb_argc])
487 // no need for cleanup
490 wxChar
**mb_argv
= argv
;
491 #endif // Unicode/ANSI
493 // we want this function to work even if there is no wxApp so ensure that
494 // we have a valid traits pointer
495 wxConsoleAppTraits traitsConsole
;
496 wxAppTraits
*traits
= wxTheApp
? wxTheApp
->GetTraits() : NULL
;
498 traits
= &traitsConsole
;
500 // this struct contains all information which we pass to and from
501 // wxAppTraits methods
502 wxExecuteData execData
;
503 execData
.flags
= flags
;
504 execData
.process
= process
;
507 if ( !traits
->CreateEndProcessPipe(execData
) )
509 wxLogError( _("Failed to execute '%s'\n"), *argv
);
513 return ERROR_RETURN_CODE
;
516 // pipes for inter process communication
517 wxPipe pipeIn
, // stdin
521 if ( process
&& process
->IsRedirected() )
523 if ( !pipeIn
.Create() || !pipeOut
.Create() || !pipeErr
.Create() )
525 wxLogError( _("Failed to execute '%s'\n"), *argv
);
529 return ERROR_RETURN_CODE
;
535 // NB: do *not* use vfork() here, it completely breaks this code for some
536 // reason under Solaris (and maybe others, although not under Linux)
537 // But on OpenVMS we do not have fork so we have to use vfork and
538 // cross our fingers that it works.
544 if ( pid
== -1 ) // error?
546 wxLogSysError( _("Fork failed") );
550 return ERROR_RETURN_CODE
;
552 else if ( pid
== 0 ) // we're in child
554 // These lines close the open file descriptors to to avoid any
555 // input/output which might block the process or irritate the user. If
556 // one wants proper IO for the subprocess, the right thing to do is to
557 // start an xterm executing it.
558 if ( !(flags
& wxEXEC_SYNC
) )
560 // FD_SETSIZE is unsigned under BSD, signed under other platforms
561 // so we need a cast to avoid warnings on all platforms
562 for ( int fd
= 0; fd
< (int)FD_SETSIZE
; fd
++ )
564 if ( fd
== pipeIn
[wxPipe::Read
]
565 || fd
== pipeOut
[wxPipe::Write
]
566 || fd
== pipeErr
[wxPipe::Write
]
567 || traits
->IsWriteFDOfEndProcessPipe(execData
, fd
) )
569 // don't close this one, we still need it
573 // leave stderr opened too, it won't do any harm
574 if ( fd
!= STDERR_FILENO
)
579 #if !defined(__VMS) && !defined(__EMX__)
580 if ( flags
& wxEXEC_MAKE_GROUP_LEADER
)
582 // Set process group to child process' pid. Then killing -pid
583 // of the parent will kill the process and all of its children.
588 // reading side can be safely closed but we should keep the write one
590 traits
->DetachWriteFDOfEndProcessPipe(execData
);
592 // redirect stdin, stdout and stderr
595 if ( dup2(pipeIn
[wxPipe::Read
], STDIN_FILENO
) == -1 ||
596 dup2(pipeOut
[wxPipe::Write
], STDOUT_FILENO
) == -1 ||
597 dup2(pipeErr
[wxPipe::Write
], STDERR_FILENO
) == -1 )
599 wxLogSysError(_("Failed to redirect child process input/output"));
607 execvp (*mb_argv
, mb_argv
);
609 fprintf(stderr
, "execvp(");
610 // CS changed ppc to ppc_ as ppc is not available under mac os CW Mach-O
611 for ( char **ppc_
= mb_argv
; *ppc_
; ppc_
++ )
612 fprintf(stderr
, "%s%s", ppc_
== mb_argv
? "" : ", ", *ppc_
);
613 fprintf(stderr
, ") failed with error %d!\n", errno
);
615 // there is no return after successful exec()
618 // some compilers complain about missing return - of course, they
619 // should know that exit() doesn't return but what else can we do if
622 // and, sure enough, other compilers complain about unreachable code
623 // after exit() call, so we can just always have return here...
624 #if defined(__VMS) || defined(__INTEL_COMPILER)
628 else // we're in parent
632 // save it for WaitForChild() use
635 // prepare for IO redirection
637 #if HAS_PIPE_INPUT_STREAM
638 // the input buffer bufOut is connected to stdout, this is why it is
639 // called bufOut and not bufIn
640 wxStreamTempInputBuffer bufOut
,
642 #endif // HAS_PIPE_INPUT_STREAM
644 if ( process
&& process
->IsRedirected() )
646 #if HAS_PIPE_INPUT_STREAM
647 wxOutputStream
*inStream
=
648 new wxFileOutputStream(pipeIn
.Detach(wxPipe::Write
));
650 wxPipeInputStream
*outStream
=
651 new wxPipeInputStream(pipeOut
.Detach(wxPipe::Read
));
653 wxPipeInputStream
*errStream
=
654 new wxPipeInputStream(pipeErr
.Detach(wxPipe::Read
));
656 process
->SetPipeStreams(outStream
, inStream
, errStream
);
658 bufOut
.Init(outStream
);
659 bufErr
.Init(errStream
);
661 execData
.bufOut
= &bufOut
;
662 execData
.bufErr
= &bufErr
;
663 #endif // HAS_PIPE_INPUT_STREAM
673 return traits
->WaitForChild(execData
);
676 #if !defined(__VMS) && !defined(__INTEL_COMPILER)
677 return ERROR_RETURN_CODE
;
681 #undef ERROR_RETURN_CODE
684 // ----------------------------------------------------------------------------
685 // file and directory functions
686 // ----------------------------------------------------------------------------
688 const wxChar
* wxGetHomeDir( wxString
*home
)
690 *home
= wxGetUserHome( wxEmptyString
);
696 if ( tmp
.Last() != wxT(']'))
697 if ( tmp
.Last() != wxT('/')) *home
<< wxT('/');
699 return home
->c_str();
703 const wxMB2WXbuf
wxGetUserHome( const wxString
&user
)
704 #else // just for binary compatibility -- there is no 'const' here
705 char *wxGetUserHome( const wxString
&user
)
708 struct passwd
*who
= (struct passwd
*) NULL
;
714 if ((ptr
= wxGetenv(wxT("HOME"))) != NULL
)
717 wxWCharBuffer
buffer( ptr
);
723 if ((ptr
= wxGetenv(wxT("USER"))) != NULL
|| (ptr
= wxGetenv(wxT("LOGNAME"))) != NULL
)
725 who
= getpwnam(wxSafeConvertWX2MB(ptr
));
728 // We now make sure the the user exists!
731 who
= getpwuid(getuid());
736 who
= getpwnam (user
.mb_str());
739 return wxSafeConvertMB2WX(who
? who
->pw_dir
: 0);
742 // ----------------------------------------------------------------------------
743 // network and user id routines
744 // ----------------------------------------------------------------------------
746 // private utility function which returns output of the given command, removing
747 // the trailing newline
748 static wxString
wxGetCommandOutput(const wxString
&cmd
)
750 FILE *f
= popen(cmd
.ToAscii(), "r");
753 wxLogSysError(_T("Executing \"%s\" failed"), cmd
.c_str());
754 return wxEmptyString
;
761 if ( !fgets(buf
, sizeof(buf
), f
) )
764 s
+= wxString::FromAscii(buf
);
769 if ( !s
.empty() && s
.Last() == _T('\n') )
775 // retrieve either the hostname or FQDN depending on platform (caller must
776 // check whether it's one or the other, this is why this function is for
778 static bool wxGetHostNameInternal(wxChar
*buf
, int sz
)
780 wxCHECK_MSG( buf
, false, wxT("NULL pointer in wxGetHostNameInternal") );
784 // we're using uname() which is POSIX instead of less standard sysinfo()
785 #if defined(HAVE_UNAME)
787 bool ok
= uname(&uts
) != -1;
790 wxStrncpy(buf
, wxSafeConvertMB2WX(uts
.nodename
), sz
- 1);
793 #elif defined(HAVE_GETHOSTNAME)
795 bool ok
= gethostname(cbuf
, sz
) != -1;
798 wxStrncpy(buf
, wxSafeConvertMB2WX(cbuf
), sz
- 1);
801 #else // no uname, no gethostname
802 wxFAIL_MSG(wxT("don't know host name for this machine"));
805 #endif // uname/gethostname
809 wxLogSysError(_("Cannot get the hostname"));
815 bool wxGetHostName(wxChar
*buf
, int sz
)
817 bool ok
= wxGetHostNameInternal(buf
, sz
);
821 // BSD systems return the FQDN, we only want the hostname, so extract
822 // it (we consider that dots are domain separators)
823 wxChar
*dot
= wxStrchr(buf
, wxT('.'));
834 bool wxGetFullHostName(wxChar
*buf
, int sz
)
836 bool ok
= wxGetHostNameInternal(buf
, sz
);
840 if ( !wxStrchr(buf
, wxT('.')) )
842 struct hostent
*host
= gethostbyname(wxSafeConvertWX2MB(buf
));
845 wxLogSysError(_("Cannot get the official hostname"));
851 // the canonical name
852 wxStrncpy(buf
, wxSafeConvertMB2WX(host
->h_name
), sz
);
855 //else: it's already a FQDN (BSD behaves this way)
861 bool wxGetUserId(wxChar
*buf
, int sz
)
866 if ((who
= getpwuid(getuid ())) != NULL
)
868 wxStrncpy (buf
, wxSafeConvertMB2WX(who
->pw_name
), sz
- 1);
875 bool wxGetUserName(wxChar
*buf
, int sz
)
881 if ((who
= getpwuid (getuid ())) != NULL
)
883 char *comma
= strchr(who
->pw_gecos
, ',');
885 *comma
= '\0'; // cut off non-name comment fields
886 wxStrncpy (buf
, wxSafeConvertMB2WX(who
->pw_gecos
), sz
- 1);
891 #else // !HAVE_PW_GECOS
892 return wxGetUserId(buf
, sz
);
893 #endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
896 bool wxIsPlatform64Bit()
898 wxString machine
= wxGetCommandOutput(wxT("uname -m"));
900 // NOTE: these tests are not 100% reliable!
901 return machine
.Contains(wxT("AMD64")) ||
902 machine
.Contains(wxT("IA64")) ||
903 machine
.Contains(wxT("x64")) ||
904 machine
.Contains(wxT("X64")) ||
905 machine
.Contains(wxT("alpha")) ||
906 machine
.Contains(wxT("hppa64")) ||
907 machine
.Contains(wxT("ppc64"));
910 // these functions are in mac/utils.cpp for wxMac
913 wxOperatingSystemId
wxGetOsVersion(int *verMaj
, int *verMin
)
917 wxString release
= wxGetCommandOutput(wxT("uname -r"));
918 if ( release
.empty() || wxSscanf(release
, wxT("%d.%d"), &major
, &minor
) != 2 )
920 // failed to get version string or unrecognized format
930 // try to understand which OS are we running
931 wxString kernel
= wxGetCommandOutput(wxT("uname -s"));
932 if ( kernel
.empty() )
933 kernel
= wxGetCommandOutput(wxT("uname -o"));
935 if ( kernel
.empty() )
938 return wxPlatformInfo::GetOperatingSystemId(kernel
);
941 wxString
wxGetOsDescription()
943 return wxGetCommandOutput(wxT("uname -s -r -m"));
948 unsigned long wxGetProcessId()
950 return (unsigned long)getpid();
953 wxMemorySize
wxGetFreeMemory()
955 #if defined(__LINUX__)
956 // get it from /proc/meminfo
957 FILE *fp
= fopen("/proc/meminfo", "r");
963 if ( fgets(buf
, WXSIZEOF(buf
), fp
) && fgets(buf
, WXSIZEOF(buf
), fp
) )
965 // /proc/meminfo changed its format in kernel 2.6
966 if ( wxPlatformInfo().CheckOSVersion(2, 6) )
968 unsigned long cached
, buffers
;
969 sscanf(buf
, "MemFree: %ld", &memFree
);
971 fgets(buf
, WXSIZEOF(buf
), fp
);
972 sscanf(buf
, "Buffers: %lu", &buffers
);
974 fgets(buf
, WXSIZEOF(buf
), fp
);
975 sscanf(buf
, "Cached: %lu", &cached
);
977 // add to "MemFree" also the "Buffers" and "Cached" values as
978 // free(1) does as otherwise the value never makes sense: for
979 // kernel 2.6 it's always almost 0
980 memFree
+= buffers
+ cached
;
982 // values here are always expressed in kB and we want bytes
985 else // Linux 2.4 (or < 2.6, anyhow)
987 long memTotal
, memUsed
;
988 sscanf(buf
, "Mem: %ld %ld %ld", &memTotal
, &memUsed
, &memFree
);
994 return (wxMemorySize
)memFree
;
996 #elif defined(__SGI__)
997 struct rminfo realmem
;
998 if ( sysmp(MP_SAGET
, MPSA_RMINFO
, &realmem
, sizeof realmem
) == 0 )
999 return ((wxMemorySize
)realmem
.physmem
* sysconf(_SC_PAGESIZE
));
1000 #elif defined(_SC_AVPHYS_PAGES)
1001 return ((wxMemorySize
)sysconf(_SC_AVPHYS_PAGES
))*sysconf(_SC_PAGESIZE
);
1002 //#elif defined(__FREEBSD__) -- might use sysctl() to find it out, probably
1005 // can't find it out
1009 bool wxGetDiskSpace(const wxString
& path
, wxDiskspaceSize_t
*pTotal
, wxDiskspaceSize_t
*pFree
)
1011 #if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
1012 // the case to "char *" is needed for AIX 4.3
1014 if ( wxStatfs((char *)(const char*)path
.fn_str(), &fs
) != 0 )
1016 wxLogSysError( wxT("Failed to get file system statistics") );
1021 // under Solaris we also have to use f_frsize field instead of f_bsize
1022 // which is in general a multiple of f_frsize
1024 wxDiskspaceSize_t blockSize
= fs
.f_frsize
;
1025 #else // HAVE_STATFS
1026 wxDiskspaceSize_t blockSize
= fs
.f_bsize
;
1027 #endif // HAVE_STATVFS/HAVE_STATFS
1031 *pTotal
= wxDiskspaceSize_t(fs
.f_blocks
) * blockSize
;
1036 *pFree
= wxDiskspaceSize_t(fs
.f_bavail
) * blockSize
;
1040 #else // !HAVE_STATFS && !HAVE_STATVFS
1042 #endif // HAVE_STATFS
1045 // ----------------------------------------------------------------------------
1047 // ----------------------------------------------------------------------------
1049 bool wxGetEnv(const wxString
& var
, wxString
*value
)
1051 // wxGetenv is defined as getenv()
1052 wxChar
*p
= wxGetenv(var
);
1064 bool wxSetEnv(const wxString
& variable
, const wxChar
*value
)
1066 #if defined(HAVE_SETENV)
1067 return setenv(variable
.mb_str(),
1068 value
? (const char *)wxString(value
).mb_str()
1070 1 /* overwrite */) == 0;
1071 #elif defined(HAVE_PUTENV)
1072 wxString s
= variable
;
1074 s
<< _T('=') << value
;
1076 // transform to ANSI
1077 const wxWX2MBbuf p
= s
.mb_str();
1079 // the string will be free()d by libc
1080 char *buf
= (char *)malloc(strlen(p
) + 1);
1083 return putenv(buf
) == 0;
1084 #else // no way to set an env var
1089 // ----------------------------------------------------------------------------
1091 // ----------------------------------------------------------------------------
1093 #if wxUSE_ON_FATAL_EXCEPTION
1097 extern "C" void wxFatalSignalHandler(wxTYPE_SA_HANDLER
)
1101 // give the user a chance to do something special about this
1102 wxTheApp
->OnFatalException();
1108 bool wxHandleFatalExceptions(bool doit
)
1111 static bool s_savedHandlers
= false;
1112 static struct sigaction s_handlerFPE
,
1118 if ( doit
&& !s_savedHandlers
)
1120 // install the signal handler
1121 struct sigaction act
;
1123 // some systems extend it with non std fields, so zero everything
1124 memset(&act
, 0, sizeof(act
));
1126 act
.sa_handler
= wxFatalSignalHandler
;
1127 sigemptyset(&act
.sa_mask
);
1130 ok
&= sigaction(SIGFPE
, &act
, &s_handlerFPE
) == 0;
1131 ok
&= sigaction(SIGILL
, &act
, &s_handlerILL
) == 0;
1132 ok
&= sigaction(SIGBUS
, &act
, &s_handlerBUS
) == 0;
1133 ok
&= sigaction(SIGSEGV
, &act
, &s_handlerSEGV
) == 0;
1136 wxLogDebug(_T("Failed to install our signal handler."));
1139 s_savedHandlers
= true;
1141 else if ( s_savedHandlers
)
1143 // uninstall the signal handler
1144 ok
&= sigaction(SIGFPE
, &s_handlerFPE
, NULL
) == 0;
1145 ok
&= sigaction(SIGILL
, &s_handlerILL
, NULL
) == 0;
1146 ok
&= sigaction(SIGBUS
, &s_handlerBUS
, NULL
) == 0;
1147 ok
&= sigaction(SIGSEGV
, &s_handlerSEGV
, NULL
) == 0;
1150 wxLogDebug(_T("Failed to uninstall our signal handler."));
1153 s_savedHandlers
= false;
1155 //else: nothing to do
1160 #endif // wxUSE_ON_FATAL_EXCEPTION
1162 #endif // wxUSE_BASE
1166 // ----------------------------------------------------------------------------
1167 // wxExecute support
1168 // ----------------------------------------------------------------------------
1170 // Darwin doesn't use the same process end detection mechanisms so we don't
1171 // need wxExecute-related helpers for it
1172 #if !(defined(__DARWIN__) && defined(__WXMAC__))
1174 bool wxGUIAppTraits::CreateEndProcessPipe(wxExecuteData
& execData
)
1176 return execData
.pipeEndProcDetect
.Create();
1179 bool wxGUIAppTraits::IsWriteFDOfEndProcessPipe(wxExecuteData
& execData
, int fd
)
1181 return fd
== (execData
.pipeEndProcDetect
)[wxPipe::Write
];
1184 void wxGUIAppTraits::DetachWriteFDOfEndProcessPipe(wxExecuteData
& execData
)
1186 execData
.pipeEndProcDetect
.Detach(wxPipe::Write
);
1187 execData
.pipeEndProcDetect
.Close();
1192 bool wxGUIAppTraits::CreateEndProcessPipe(wxExecuteData
& WXUNUSED(execData
))
1198 wxGUIAppTraits::IsWriteFDOfEndProcessPipe(wxExecuteData
& WXUNUSED(execData
),
1205 wxGUIAppTraits::DetachWriteFDOfEndProcessPipe(wxExecuteData
& WXUNUSED(execData
))
1207 // nothing to do here, we don't use the pipe
1210 #endif // !Darwin/Darwin
1212 int wxGUIAppTraits::WaitForChild(wxExecuteData
& execData
)
1214 wxEndProcessData
*endProcData
= new wxEndProcessData
;
1216 const int flags
= execData
.flags
;
1218 // wxAddProcessCallback is now (with DARWIN) allowed to call the
1219 // callback function directly if the process terminates before
1220 // the callback can be added to the run loop. Set up the endProcData.
1221 if ( flags
& wxEXEC_SYNC
)
1223 // we may have process for capturing the program output, but it's
1224 // not used in wxEndProcessData in the case of sync execution
1225 endProcData
->process
= NULL
;
1227 // sync execution: indicate it by negating the pid
1228 endProcData
->pid
= -execData
.pid
;
1232 // async execution, nothing special to do -- caller will be
1233 // notified about the process termination if process != NULL, endProcData
1234 // will be deleted in GTK_EndProcessDetector
1235 endProcData
->process
= execData
.process
;
1236 endProcData
->pid
= execData
.pid
;
1240 #if defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__))
1241 endProcData
->tag
= wxAddProcessCallbackForPid(endProcData
, execData
.pid
);
1243 endProcData
->tag
= wxAddProcessCallback
1246 execData
.pipeEndProcDetect
.Detach(wxPipe::Read
)
1249 execData
.pipeEndProcDetect
.Close();
1250 #endif // defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__))
1252 if ( flags
& wxEXEC_SYNC
)
1255 wxWindowDisabler
*wd
= flags
& wxEXEC_NODISABLE
? NULL
1256 : new wxWindowDisabler
;
1258 // endProcData->pid will be set to 0 from GTK_EndProcessDetector when the
1259 // process terminates
1260 while ( endProcData
->pid
!= 0 )
1264 #if HAS_PIPE_INPUT_STREAM
1265 if ( execData
.bufOut
)
1267 execData
.bufOut
->Update();
1271 if ( execData
.bufErr
)
1273 execData
.bufErr
->Update();
1276 #endif // HAS_PIPE_INPUT_STREAM
1278 // don't consume 100% of the CPU while we're sitting in this
1283 // give GTK+ a chance to call GTK_EndProcessDetector here and
1284 // also repaint the GUI
1288 int exitcode
= endProcData
->exitcode
;
1295 else // async execution
1297 return execData
.pid
;
1304 void wxHandleProcessTermination(wxEndProcessData
*proc_data
)
1306 // notify user about termination if required
1307 if ( proc_data
->process
)
1309 proc_data
->process
->OnTerminate(proc_data
->pid
, proc_data
->exitcode
);
1313 if ( proc_data
->pid
> 0 )
1319 // let wxExecute() know that the process has terminated
1324 #endif // wxUSE_BASE