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