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