src/unix/utilsunx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #include "wx/defs.h"
  19 #include "wx/string.h"
  20
  21 #include "wx/intl.h"
  22 #include "wx/log.h"
  23 #include "wx/app.h"
  24
  25 #include "wx/utils.h"
  26 #include "wx/process.h"
  27 #include "wx/thread.h"
  28
  29 #include "wx/stream.h"
  30
  31 #if wxUSE_GUI
  32     #include "wx/unix/execute.h"
  33 #endif
  34
  35 // SGI signal.h defines signal handler arguments differently depending on
  36 // whether _LANGUAGE_C_PLUS_PLUS is set or not - do set it
  37 #if defined(__SGI__) && !defined(_LANGUAGE_C_PLUS_PLUS)
  38     #define _LANGUAGE_C_PLUS_PLUS 1
  39 #endif // SGI hack
  40
  41 #include <stdarg.h>
  42 #include <dirent.h>
  43 #include <string.h>
  44 #include <sys/stat.h>
  45 #include <sys/types.h>
  46 #include <unistd.h>
  47 #include <sys/wait.h>
  48 #include <pwd.h>
  49 #include <errno.h>
  50 #include <netdb.h>
  51 #include <signal.h>
  52 #include <fcntl.h>          // for O_WRONLY and friends
  53 #include <time.h>           // nanosleep() and/or usleep()
  54 #include <ctype.h>          // isspace()
  55 #include <sys/time.h>       // needed for FD_SETSIZE
  56
  57 #ifdef HAVE_UNAME
  58     #include <sys/utsname.h> // for uname()
  59 #endif // HAVE_UNAME
  60
  61 // ----------------------------------------------------------------------------
  62 // conditional compilation
  63 // ----------------------------------------------------------------------------
  64
  65 // many versions of Unices have this function, but it is not defined in system
  66 // headers - please add your system here if it is the case for your OS.
  67 // SunOS < 5.6 (i.e. Solaris < 2.6) and DG-UX are like this.
  68 #if !defined(HAVE_USLEEP) && \
  69     (defined(__SUN__) && !defined(__SunOs_5_6) && \
  70                          !defined(__SunOs_5_7) && !defined(__SUNPRO_CC)) || \
  71      defined(__osf__) || defined(__EMX__)
  72     extern "C"
  73     {
  74         #ifdef __SUN__
  75             int usleep(unsigned int usec);
  76         #else // !Sun
  77             #ifdef __EMX__
  78                 /* I copied this from the XFree86 diffs. AV. */
  79                 #define INCL_DOSPROCESS
  80                 #include <os2.h>
  81                 inline void usleep(unsigned long delay)
  82                 {
  83                     DosSleep(delay ? (delay/1000l) : 1l);
  84                 }
  85             #else // !Sun && !EMX
  86                 void usleep(unsigned long usec);
  87             #endif
  88         #endif // Sun/EMX/Something else
  89     };
  90
  91     #define HAVE_USLEEP 1
  92 #endif // Unices without usleep()
  93
  94 // ============================================================================
  95 // implementation
  96 // ============================================================================
  97
  98 // ----------------------------------------------------------------------------
  99 // sleeping
 100 // ----------------------------------------------------------------------------
 101
 102 void wxSleep(int nSecs)
 103 {
 104     sleep(nSecs);
 105 }
 106
 107 void wxUsleep(unsigned long milliseconds)
 108 {
 109 #if defined(HAVE_NANOSLEEP)
 110     timespec tmReq;
 111     tmReq.tv_sec = (time_t)(milliseconds / 1000);
 112     tmReq.tv_nsec = (milliseconds % 1000) * 1000 * 1000;
 113
 114     // we're not interested in remaining time nor in return value
 115     (void)nanosleep(&tmReq, (timespec *)NULL);
 116 #elif defined(HAVE_USLEEP)
 117     // uncomment this if you feel brave or if you are sure that your version
 118     // of Solaris has a safe usleep() function but please notice that usleep()
 119     // is known to lead to crashes in MT programs in Solaris 2.[67] and is not
 120     // documented as MT-Safe
 121     #if defined(__SUN__) && wxUSE_THREADS
 122         #error "usleep() cannot be used in MT programs under Solaris."
 123     #endif // Sun
 124
 125     usleep(milliseconds * 1000); // usleep(3) wants microseconds
 126 #elif defined(HAVE_SLEEP)
 127     // under BeOS sleep() takes seconds (what about other platforms, if any?)
 128     sleep(milliseconds * 1000);
 129 #else // !sleep function
 130     #error "usleep() or nanosleep() function required for wxUsleep"
 131 #endif // sleep function
 132 }
 133
 134 // ----------------------------------------------------------------------------
 135 // process management
 136 // ----------------------------------------------------------------------------
 137
 138 int wxKill(long pid, wxSignal sig, wxKillError *rc)
 139 {
 140     int err = kill((pid_t)pid, (int)sig);
 141     if ( rc )
 142     {
 143         switch ( err )
 144         {
 145             case 0:
 146                 *rc = wxKILL_OK;
 147                 break;
 148
 149             case EINVAL:
 150                 *rc = wxKILL_BAD_SIGNAL;
 151                 break;
 152
 153             case EPERM:
 154                 *rc = wxKILL_ACCESS_DENIED;
 155                 break;
 156
 157             case ESRCH:
 158                 *rc = wxKILL_NO_PROCESS;
 159                 break;
 160
 161             default:
 162                 // this goes against Unix98 docs so log it
 163                 wxLogDebug(_T("unexpected kill(2) return value %d"), err);
 164
 165                 // something else...
 166                 *rc = wxKILL_ERROR;
 167         }
 168     }
 169
 170     return err;
 171 }
 172
 173 #define WXEXECUTE_NARGS   127
 174
 175 long wxExecute( const wxString& command, bool sync, wxProcess *process )
 176 {
 177     wxCHECK_MSG( !command.IsEmpty(), 0, wxT("can't exec empty command") );
 178
 179     int argc = 0;
 180     wxChar *argv[WXEXECUTE_NARGS];
 181     wxString argument;
 182     const wxChar *cptr = command.c_str();
 183     wxChar quotechar = wxT('\0'); // is arg quoted?
 184     bool escaped = FALSE;
 185
 186     // split the command line in arguments
 187     do
 188     {
 189         argument=wxT("");
 190         quotechar = wxT('\0');
 191
 192         // eat leading whitespace:
 193         while ( wxIsspace(*cptr) )
 194             cptr++;
 195
 196         if ( *cptr == wxT('\'') || *cptr == wxT('"') )
 197             quotechar = *cptr++;
 198
 199         do
 200         {
 201             if ( *cptr == wxT('\\') && ! escaped )
 202             {
 203                 escaped = TRUE;
 204                 cptr++;
 205                 continue;
 206             }
 207
 208             // all other characters:
 209             argument += *cptr++;
 210             escaped = FALSE;
 211
 212             // have we reached the end of the argument?
 213             if ( (*cptr == quotechar && ! escaped)
 214                  || (quotechar == wxT('\0') && wxIsspace(*cptr))
 215                  || *cptr == wxT('\0') )
 216             {
 217                 wxASSERT_MSG( argc < WXEXECUTE_NARGS,
 218                               wxT("too many arguments in wxExecute") );
 219
 220                 argv[argc] = new wxChar[argument.length() + 1];
 221                 wxStrcpy(argv[argc], argument.c_str());
 222                 argc++;
 223
 224                 // if not at end of buffer, swallow last character:
 225                 if(*cptr)
 226                     cptr++;
 227
 228                 break; // done with this one, start over
 229             }
 230         } while(*cptr);
 231     } while(*cptr);
 232     argv[argc] = NULL;
 233
 234     // do execute the command
 235     long lRc = wxExecute(argv, sync, process);
 236
 237     // clean up
 238     argc = 0;
 239     while( argv[argc] )
 240         delete [] argv[argc++];
 241
 242     return lRc;
 243 }
 244
 245 // ----------------------------------------------------------------------------
 246 // wxShell
 247 // ----------------------------------------------------------------------------
 248
 249 static wxString wxMakeShellCommand(const wxString& command)
 250 {
 251     wxString cmd;
 252     if ( !command )
 253     {
 254         // just an interactive shell
 255         cmd = _T("xterm");
 256     }
 257     else
 258     {
 259         // execute command in a shell
 260         cmd << _T("/bin/sh -c '") << command << _T('\'');
 261     }
 262
 263     return cmd;
 264 }
 265
 266 bool wxShell(const wxString& command)
 267 {
 268     return wxExecute(wxMakeShellCommand(command), TRUE /* sync */) == 0;
 269 }
 270
 271 bool wxShell(const wxString& command, wxArrayString& output)
 272 {
 273     wxCHECK_MSG( !!command, FALSE, _T("can't exec shell non interactively") );
 274
 275     return wxExecute(wxMakeShellCommand(command), output);
 276 }
 277
 278 #if wxUSE_GUI
 279
 280 void wxHandleProcessTermination(wxEndProcessData *proc_data)
 281 {
 282     int pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
 283
 284     // waitpid is POSIX so should be available everywhere, however on older
 285     // systems wait() might be used instead in a loop (until the right pid
 286     // terminates)
 287     int status = 0;
 288     int rc;
 289
 290     // wait for child termination and if waitpid() was interrupted, try again
 291     do
 292     {
 293        rc = waitpid(pid, &status, 0);
 294     }
 295     while ( rc == -1 && errno == EINTR );
 296
 297
 298     if( rc == -1 || ! (WIFEXITED(status) || WIFSIGNALED(status)) )
 299     {
 300        wxLogSysError(_("Waiting for subprocess termination failed"));
 301        /* AFAIK, this can only happen if something went wrong within
 302           wxGTK, i.e. due to a race condition or some serious bug.
 303           After having fixed the order of statements in
 304           GTK_EndProcessDetector(). (KB)
 305        */
 306     }
 307     else
 308     {
 309         // notify user about termination if required
 310         if (proc_data->process)
 311         {
 312             proc_data->process->OnTerminate(proc_data->pid,
 313                                             WEXITSTATUS(status));
 314         }
 315         // clean up
 316         if ( proc_data->pid > 0 )
 317         {
 318            delete proc_data;
 319         }
 320         else
 321         {
 322            // wxExecute() will know about it
 323            proc_data->exitcode = status;
 324
 325            proc_data->pid = 0;
 326         }
 327     }
 328 }
 329
 330 #endif // wxUSE_GUI
 331
 332 // ----------------------------------------------------------------------------
 333 // wxStream classes to support IO redirection in wxExecute
 334 // ----------------------------------------------------------------------------
 335
 336 class wxProcessFileInputStream : public wxInputStream
 337 {
 338 public:
 339     wxProcessFileInputStream(int fd) { m_fd = fd; }
 340     ~wxProcessFileInputStream() { close(m_fd); }
 341
 342     virtual bool Eof() const;
 343
 344 protected:
 345     size_t OnSysRead(void *buffer, size_t bufsize);
 346
 347 protected:
 348     int m_fd;
 349 };
 350
 351 class wxProcessFileOutputStream : public wxOutputStream
 352 {
 353 public:
 354     wxProcessFileOutputStream(int fd) { m_fd = fd; }
 355     ~wxProcessFileOutputStream() { close(m_fd); }
 356
 357 protected:
 358     size_t OnSysWrite(const void *buffer, size_t bufsize);
 359
 360 protected:
 361     int m_fd;
 362 };
 363
 364 bool wxProcessFileInputStream::Eof() const
 365 {
 366     if ( m_lasterror == wxSTREAM_EOF )
 367         return TRUE;
 368
 369     // check if there is any input available
 370     struct timeval tv;
 371     tv.tv_sec = 0;
 372     tv.tv_usec = 0;
 373
 374     fd_set readfds;
 375     FD_ZERO(&readfds);
 376     FD_SET(m_fd, &readfds);
 377     switch ( select(m_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 TRUE;
 385
 386         default:
 387             wxFAIL_MSG(_T("unexpected select() return value"));
 388             // still fall through
 389
 390         case 1:
 391             // input available: check if there is any
 392             return wxInputStream::Eof();
 393     }
 394 }
 395
 396 size_t wxProcessFileInputStream::OnSysRead(void *buffer, size_t bufsize)
 397 {
 398     int ret = read(m_fd, buffer, bufsize);
 399     if ( ret == 0 )
 400     {
 401         m_lasterror = wxSTREAM_EOF;
 402     }
 403     else if ( ret == -1 )
 404     {
 405         m_lasterror = wxSTREAM_READ_ERROR;
 406         ret = 0;
 407     }
 408     else
 409     {
 410         m_lasterror = wxSTREAM_NOERROR;
 411     }
 412
 413     return ret;
 414 }
 415
 416 size_t wxProcessFileOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
 417 {
 418     int ret = write(m_fd, buffer, bufsize);
 419     if ( ret == -1 )
 420     {
 421         m_lasterror = wxSTREAM_WRITE_ERROR;
 422         ret = 0;
 423     }
 424     else
 425     {
 426         m_lasterror = wxSTREAM_NOERROR;
 427     }
 428
 429     return ret;
 430 }
 431
 432 long wxExecute(wxChar **argv,
 433                bool sync,
 434                wxProcess *process)
 435 {
 436     // for the sync execution, we return -1 to indicate failure, but for async
 437     // case we return 0 which is never a valid PID
 438     //
 439     // we define this as a macro, not a variable, to avoid compiler warnings
 440     // about "ERROR_RETURN_CODE value may be clobbered by fork()"
 441     #define ERROR_RETURN_CODE ((sync) ? -1 : 0)
 442
 443     wxCHECK_MSG( *argv, ERROR_RETURN_CODE, wxT("can't exec empty command") );
 444
 445 #if wxUSE_UNICODE
 446     int mb_argc = 0;
 447     char *mb_argv[WXEXECUTE_NARGS];
 448
 449     while (argv[mb_argc])
 450     {
 451         wxWX2MBbuf mb_arg = wxConvertWX2MB(argv[mb_argc]);
 452         mb_argv[mb_argc] = strdup(mb_arg);
 453         mb_argc++;
 454     }
 455     mb_argv[mb_argc] = (char *) NULL;
 456
 457     // this macro will free memory we used above
 458     #define ARGS_CLEANUP                                 \
 459         for ( mb_argc = 0; mb_argv[mb_argc]; mb_argc++ ) \
 460             free(mb_argv[mb_argc])
 461 #else // ANSI
 462     // no need for cleanup
 463     #define ARGS_CLEANUP
 464
 465     wxChar **mb_argv = argv;
 466 #endif // Unicode/ANSI
 467
 468 #if wxUSE_GUI
 469     // create pipes
 470     int end_proc_detect[2];
 471     if ( pipe(end_proc_detect) == -1 )
 472     {
 473         wxLogSysError( _("Pipe creation failed") );
 474         wxLogError( _("Failed to execute '%s'\n"), *argv );
 475
 476         ARGS_CLEANUP;
 477
 478         return ERROR_RETURN_CODE;
 479     }
 480 #endif // wxUSE_GUI
 481
 482     // pipes for inter process communication
 483     int pipeIn[2],      // stdin
 484         pipeOut[2],     // stdout
 485         pipeErr[2];     // stderr
 486
 487     pipeIn[0] = pipeIn[1] =
 488     pipeOut[0] = pipeOut[1] =
 489     pipeErr[0] = pipeErr[1] = -1;
 490
 491     if ( process && process->IsRedirected() )
 492     {
 493         if ( pipe(pipeIn) == -1 || pipe(pipeOut) == -1 || pipe(pipeErr) == -1 )
 494         {
 495 #if wxUSE_GUI
 496             // free previously allocated resources
 497             close(end_proc_detect[0]);
 498             close(end_proc_detect[1]);
 499 #endif // wxUSE_GUI
 500
 501             wxLogSysError( _("Pipe creation failed") );
 502             wxLogError( _("Failed to execute '%s'\n"), *argv );
 503
 504             ARGS_CLEANUP;
 505
 506             return ERROR_RETURN_CODE;
 507         }
 508     }
 509
 510     // fork the process
 511 #ifdef HAVE_VFORK
 512     pid_t pid = vfork();
 513 #else
 514     pid_t pid = fork();
 515 #endif
 516
 517     if ( pid == -1 )     // error?
 518     {
 519 #if wxUSE_GUI
 520         close(end_proc_detect[0]);
 521         close(end_proc_detect[1]);
 522         close(pipeIn[0]);
 523         close(pipeIn[1]);
 524         close(pipeOut[0]);
 525         close(pipeOut[1]);
 526         close(pipeErr[0]);
 527         close(pipeErr[1]);
 528 #endif // wxUSE_GUI
 529
 530         wxLogSysError( _("Fork failed") );
 531
 532         ARGS_CLEANUP;
 533
 534         return ERROR_RETURN_CODE;
 535     }
 536     else if ( pid == 0 )  // we're in child
 537     {
 538 #if wxUSE_GUI
 539         close(end_proc_detect[0]); // close reading side
 540 #endif // wxUSE_GUI
 541
 542         // These lines close the open file descriptors to to avoid any
 543         // input/output which might block the process or irritate the user. If
 544         // one wants proper IO for the subprocess, the right thing to do is to
 545         // start an xterm executing it.
 546         if ( !sync )
 547         {
 548             for ( int fd = 0; fd < FD_SETSIZE; fd++ )
 549             {
 550                 if ( fd == pipeIn[0] || fd == pipeOut[1] || fd == pipeErr[1]
 551 #if wxUSE_GUI
 552                      || fd == end_proc_detect[1]
 553 #endif // wxUSE_GUI
 554                    )
 555                 {
 556                     // don't close this one, we still need it
 557                     continue;
 558                 }
 559
 560                 // leave stderr opened too, it won't do any hurm
 561                 if ( fd != STDERR_FILENO )
 562                     close(fd);
 563             }
 564         }
 565
 566         // redirect stdio, stdout and stderr
 567         if ( pipeIn[0] != -1 )
 568         {
 569             if ( dup2(pipeIn[0], STDIN_FILENO) == -1 ||
 570                  dup2(pipeOut[1], STDOUT_FILENO) == -1 ||
 571                  dup2(pipeErr[1], STDERR_FILENO) == -1 )
 572             {
 573                 wxLogSysError(_("Failed to redirect child process input/output"));
 574             }
 575
 576             close(pipeIn[0]);
 577             close(pipeOut[1]);
 578             close(pipeErr[1]);
 579         }
 580
 581         execvp (*mb_argv, mb_argv);
 582
 583         // there is no return after successful exec()
 584         _exit(-1);
 585     }
 586     else // we're in parent
 587     {
 588         ARGS_CLEANUP;
 589
 590         // pipe initialization: construction of the wxStreams
 591         if ( process && process->IsRedirected() )
 592         {
 593             // These two streams are relative to this process.
 594             wxOutputStream *outStream = new wxProcessFileOutputStream(pipeIn[1]);
 595             wxInputStream *inStream = new wxProcessFileInputStream(pipeOut[0]);
 596             wxInputStream *errStream = new wxProcessFileInputStream(pipeErr[0]);
 597
 598             close(pipeIn[0]); // close reading side
 599             close(pipeOut[1]); // close writing side
 600             close(pipeErr[1]); // close writing side
 601
 602             process->SetPipeStreams(inStream, outStream, errStream);
 603         }
 604
 605 #if wxUSE_GUI
 606         wxEndProcessData *data = new wxEndProcessData;
 607
 608         if ( sync )
 609         {
 610             // we may have process for capturing the program output, but it's
 611             // not used in wxEndProcessData in the case of sync execution
 612             data->process = NULL;
 613
 614             // sync execution: indicate it by negating the pid
 615             data->pid = -pid;
 616             data->tag = wxAddProcessCallback(data, end_proc_detect[0]);
 617
 618             close(end_proc_detect[1]); // close writing side
 619
 620             wxBusyCursor bc;
 621             wxWindowDisabler wd;
 622
 623             // it will be set to 0 from GTK_EndProcessDetector
 624             while (data->pid != 0)
 625                 wxYield();
 626
 627             int exitcode = data->exitcode;
 628
 629             delete data;
 630
 631             return exitcode;
 632         }
 633         else // async execution
 634         {
 635             // async execution, nothing special to do - caller will be
 636             // notified about the process termination if process != NULL, data
 637             // will be deleted in GTK_EndProcessDetector
 638             data->process  = process;
 639             data->pid      = pid;
 640             data->tag      = wxAddProcessCallback(data, end_proc_detect[0]);
 641
 642             close(end_proc_detect[1]); // close writing side
 643
 644             return pid;
 645         }
 646 #else // !wxUSE_GUI
 647         wxASSERT_MSG( sync, wxT("async execution not supported yet") );
 648
 649         int exitcode = 0;
 650         if ( waitpid(pid, &exitcode, 0) == -1 || !WIFEXITED(exitcode) )
 651         {
 652             wxLogSysError(_("Waiting for subprocess termination failed"));
 653         }
 654
 655         return exitcode;
 656 #endif // wxUSE_GUI
 657     }
 658 #ifdef __VMS
 659    // VMS does not recognise exit as a return and complains about
 660    // a missing return
 661    // I think VMS is wrong in this
 662    //     JJ
 663    return 0;
 664 #endif
 665 }
 666
 667 #undef ERROR_RETURN_CODE
 668 #undef ARGS_CLEANUP
 669
 670 // ----------------------------------------------------------------------------
 671 // file and directory functions
 672 // ----------------------------------------------------------------------------
 673
 674 const wxChar* wxGetHomeDir( wxString *home  )
 675 {
 676     *home = wxGetUserHome( wxString() );
 677    wxString tmp;
 678     if ( home->IsEmpty() )
 679         *home = wxT("/");
 680 #ifdef __VMS
 681    tmp = *home;
 682    if ( tmp.Last() != wxT(']'))
 683      if ( tmp.Last() != wxT('/')) *home << wxT('/');
 684 #endif
 685     return home->c_str();
 686 }
 687
 688 #if wxUSE_UNICODE
 689 const wxMB2WXbuf wxGetUserHome( const wxString &user )
 690 #else // just for binary compatibility -- there is no 'const' here
 691 char *wxGetUserHome( const wxString &user )
 692 #endif
 693 {
 694     struct passwd *who = (struct passwd *) NULL;
 695
 696     if ( !user )
 697     {
 698         wxChar *ptr;
 699
 700         if ((ptr = wxGetenv(wxT("HOME"))) != NULL)
 701         {
 702             return ptr;
 703         }
 704         if ((ptr = wxGetenv(wxT("USER"))) != NULL || (ptr = wxGetenv(wxT("LOGNAME"))) != NULL)
 705         {
 706             who = getpwnam(wxConvertWX2MB(ptr));
 707         }
 708
 709         // We now make sure the the user exists!
 710         if (who == NULL)
 711         {
 712             who = getpwuid(getuid());
 713         }
 714     }
 715     else
 716     {
 717       who = getpwnam (user.mb_str());
 718     }
 719
 720     return wxConvertMB2WX(who ? who->pw_dir : 0);
 721 }
 722
 723 // ----------------------------------------------------------------------------
 724 // network and user id routines
 725 // ----------------------------------------------------------------------------
 726
 727 // retrieve either the hostname or FQDN depending on platform (caller must
 728 // check whether it's one or the other, this is why this function is for
 729 // private use only)
 730 static bool wxGetHostNameInternal(wxChar *buf, int sz)
 731 {
 732     wxCHECK_MSG( buf, FALSE, wxT("NULL pointer in wxGetHostNameInternal") );
 733
 734     *buf = wxT('\0');
 735
 736     // we're using uname() which is POSIX instead of less standard sysinfo()
 737 #if defined(HAVE_UNAME)
 738     struct utsname uts;
 739     bool ok = uname(&uts) != -1;
 740     if ( ok )
 741     {
 742         wxStrncpy(buf, wxConvertMB2WX(uts.nodename), sz - 1);
 743         buf[sz] = wxT('\0');
 744     }
 745 #elif defined(HAVE_GETHOSTNAME)
 746     bool ok = gethostname(buf, sz) != -1;
 747 #else // no uname, no gethostname
 748     wxFAIL_MSG(wxT("don't know host name for this machine"));
 749
 750     bool ok = FALSE;
 751 #endif // uname/gethostname
 752
 753     if ( !ok )
 754     {
 755         wxLogSysError(_("Cannot get the hostname"));
 756     }
 757
 758     return ok;
 759 }
 760
 761 bool wxGetHostName(wxChar *buf, int sz)
 762 {
 763     bool ok = wxGetHostNameInternal(buf, sz);
 764
 765     if ( ok )
 766     {
 767         // BSD systems return the FQDN, we only want the hostname, so extract
 768         // it (we consider that dots are domain separators)
 769         wxChar *dot = wxStrchr(buf, wxT('.'));
 770         if ( dot )
 771         {
 772             // nuke it
 773             *dot = wxT('\0');
 774         }
 775     }
 776
 777     return ok;
 778 }
 779
 780 bool wxGetFullHostName(wxChar *buf, int sz)
 781 {
 782     bool ok = wxGetHostNameInternal(buf, sz);
 783
 784     if ( ok )
 785     {
 786         if ( !wxStrchr(buf, wxT('.')) )
 787         {
 788             struct hostent *host = gethostbyname(wxConvertWX2MB(buf));
 789             if ( !host )
 790             {
 791                 wxLogSysError(_("Cannot get the official hostname"));
 792
 793                 ok = FALSE;
 794             }
 795             else
 796             {
 797                 // the canonical name
 798                 wxStrncpy(buf, wxConvertMB2WX(host->h_name), sz);
 799             }
 800         }
 801         //else: it's already a FQDN (BSD behaves this way)
 802     }
 803
 804     return ok;
 805 }
 806
 807 bool wxGetUserId(wxChar *buf, int sz)
 808 {
 809     struct passwd *who;
 810
 811     *buf = wxT('\0');
 812     if ((who = getpwuid(getuid ())) != NULL)
 813     {
 814         wxStrncpy (buf, wxConvertMB2WX(who->pw_name), sz - 1);
 815         return TRUE;
 816     }
 817
 818     return FALSE;
 819 }
 820
 821 bool wxGetUserName(wxChar *buf, int sz)
 822 {
 823     struct passwd *who;
 824
 825     *buf = wxT('\0');
 826     if ((who = getpwuid (getuid ())) != NULL)
 827     {
 828         // pw_gecos field in struct passwd is not standard
 829 #ifdef HAVE_PW_GECOS
 830        char *comma = strchr(who->pw_gecos, ',');
 831        if (comma)
 832            *comma = '\0'; // cut off non-name comment fields
 833        wxStrncpy (buf, wxConvertMB2WX(who->pw_gecos), sz - 1);
 834 #else // !HAVE_PW_GECOS
 835        wxStrncpy (buf, wxConvertMB2WX(who->pw_name), sz - 1);
 836 #endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
 837        return TRUE;
 838     }
 839
 840     return FALSE;
 841 }
 842
 843 wxString wxGetOsDescription()
 844 {
 845 #ifndef WXWIN_OS_DESCRIPTION
 846     #error WXWIN_OS_DESCRIPTION should be defined in config.h by configure
 847 #else
 848     return WXWIN_OS_DESCRIPTION;
 849 #endif
 850 }
 851
 852 // this function returns the GUI toolkit version in GUI programs, but OS
 853 // version in non-GUI ones
 854 #if !wxUSE_GUI
 855
 856 int wxGetOsVersion(int *majorVsn, int *minorVsn)
 857 {
 858     int major, minor;
 859     char name[256];
 860
 861     if ( sscanf(WXWIN_OS_DESCRIPTION, "%s %d.%d", name, &major, &minor) != 3 )
 862     {
 863         // unreckognized uname string format
 864         major = minor = -1;
 865     }
 866
 867     if ( majorVsn )
 868         *majorVsn = major;
 869     if ( minorVsn )
 870         *minorVsn = minor;
 871
 872     return wxUNIX;
 873 }
 874
 875 #endif // !wxUSE_GUI
 876
 877 long wxGetFreeMemory()
 878 {
 879 #if defined(__LINUX__)
 880     // get it from /proc/meminfo
 881     FILE *fp = fopen("/proc/meminfo", "r");
 882     if ( fp )
 883     {
 884         long memFree = -1;
 885
 886         char buf[1024];
 887         if ( fgets(buf, WXSIZEOF(buf), fp) && fgets(buf, WXSIZEOF(buf), fp) )
 888         {
 889             long memTotal, memUsed;
 890             sscanf(buf, "Mem: %ld %ld %ld", &memTotal, &memUsed, &memFree);
 891         }
 892
 893         fclose(fp);
 894
 895         return memFree;
 896     }
 897 #elif defined(__SUN__) && defined(_SC_AVPHYS_PAGES)
 898     return sysconf(_SC_AVPHYS_PAGES)*sysconf(_SC_PAGESIZE);
 899 //#elif defined(__FREEBSD__) -- might use sysctl() to find it out, probably
 900 #endif
 901
 902     // can't find it out
 903     return -1;
 904 }
 905
 906 // ----------------------------------------------------------------------------
 907 // env vars
 908 // ----------------------------------------------------------------------------
 909
 910 bool wxGetEnv(const wxString& var, wxString *value)
 911 {
 912     // wxGetenv is defined as getenv()
 913     wxChar *p = wxGetenv(var);
 914     if ( !p )
 915         return FALSE;
 916
 917     if ( value )
 918     {
 919         *value = p;
 920     }
 921
 922     return TRUE;
 923 }
 924
 925 bool wxSetEnv(const wxString& variable, const wxChar *value)
 926 {
 927 #if defined(HAVE_SETENV)
 928     return setenv(variable.mb_str(), value ? wxString(value).mb_str().data()
 929                                            : NULL, 1 /* overwrite */) == 0;
 930 #elif defined(HAVE_PUTENV)
 931     wxString s = variable;
 932     if ( value )
 933         s << _T('=') << value;
 934
 935     // transform to ANSI
 936     const char *p = s.mb_str();
 937
 938     // the string will be free()d by libc
 939     char *buf = (char *)malloc(strlen(p) + 1);
 940     strcpy(buf, p);
 941
 942     return putenv(buf) == 0;
 943 #else // no way to set an env var
 944     return FALSE;
 945 #endif
 946 }
 947
 948 // ----------------------------------------------------------------------------
 949 // signal handling
 950 // ----------------------------------------------------------------------------
 951
 952 #if wxUSE_ON_FATAL_EXCEPTION
 953
 954 #include <signal.h>
 955
 956 static void wxFatalSignalHandler(wxTYPE_SA_HANDLER)
 957 {
 958     if ( wxTheApp )
 959     {
 960         // give the user a chance to do something special about this
 961         wxTheApp->OnFatalException();
 962     }
 963
 964     abort();
 965 }
 966
 967 bool wxHandleFatalExceptions(bool doit)
 968 {
 969     // old sig handlers
 970     static bool s_savedHandlers = FALSE;
 971     static struct sigaction s_handlerFPE,
 972                             s_handlerILL,
 973                             s_handlerBUS,
 974                             s_handlerSEGV;
 975
 976     bool ok = TRUE;
 977     if ( doit && !s_savedHandlers )
 978     {
 979         // install the signal handler
 980         struct sigaction act;
 981
 982         // some systems extend it with non std fields, so zero everything
 983         memset(&act, 0, sizeof(act));
 984
 985         act.sa_handler = wxFatalSignalHandler;
 986         sigemptyset(&act.sa_mask);
 987         act.sa_flags = 0;
 988
 989         ok &= sigaction(SIGFPE, &act, &s_handlerFPE) == 0;
 990         ok &= sigaction(SIGILL, &act, &s_handlerILL) == 0;
 991         ok &= sigaction(SIGBUS, &act, &s_handlerBUS) == 0;
 992         ok &= sigaction(SIGSEGV, &act, &s_handlerSEGV) == 0;
 993         if ( !ok )
 994         {
 995             wxLogDebug(_T("Failed to install our signal handler."));
 996         }
 997
 998         s_savedHandlers = TRUE;
 999     }
1000     else if ( s_savedHandlers )
1001     {
1002         // uninstall the signal handler
1003         ok &= sigaction(SIGFPE, &s_handlerFPE, NULL) == 0;
1004         ok &= sigaction(SIGILL, &s_handlerILL, NULL) == 0;
1005         ok &= sigaction(SIGBUS, &s_handlerBUS, NULL) == 0;
1006         ok &= sigaction(SIGSEGV, &s_handlerSEGV, NULL) == 0;
1007         if ( !ok )
1008         {
1009             wxLogDebug(_T("Failed to uninstall our signal handler."));
1010         }
1011
1012         s_savedHandlers = FALSE;
1013     }
1014     //else: nothing to do
1015
1016     return ok;
1017 }
1018
1019 #endif // wxUSE_ON_FATAL_EXCEPTION
1020
1021 // ----------------------------------------------------------------------------
1022 // error and debug output routines (deprecated, use wxLog)
1023 // ----------------------------------------------------------------------------
1024
1025 void wxDebugMsg( const char *format, ... )
1026 {
1027   va_list ap;
1028   va_start( ap, format );
1029   vfprintf( stderr, format, ap );
1030   fflush( stderr );
1031   va_end(ap);
1032 }
1033
1034 void wxError( const wxString &msg, const wxString &title )
1035 {
1036   wxFprintf( stderr, _("Error ") );
1037   if (!title.IsNull()) wxFprintf( stderr, wxT("%s "), WXSTRINGCAST(title) );
1038   if (!msg.IsNull()) wxFprintf( stderr, wxT(": %s"), WXSTRINGCAST(msg) );
1039   wxFprintf( stderr, wxT(".\n") );
1040 }
1041
1042 void wxFatalError( const wxString &msg, const wxString &title )
1043 {
1044   wxFprintf( stderr, _("Error ") );
1045   if (!title.IsNull()) wxFprintf( stderr, wxT("%s "), WXSTRINGCAST(title) );
1046   if (!msg.IsNull()) wxFprintf( stderr, wxT(": %s"), WXSTRINGCAST(msg) );
1047   wxFprintf( stderr, wxT(".\n") );
1048   exit(3); // the same exit code as for abort()
1049 }
1050