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