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