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