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