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