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