X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/40f00746d2d77955a2e21d2c17c864be3218ef4c..850df2d78866c3edcf848103b5dbc7e7fa1ee5fa:/src/unix/utilsunx.cpp diff --git a/src/unix/utilsunx.cpp b/src/unix/utilsunx.cpp index 3688288505..7f275de250 100644 --- a/src/unix/utilsunx.cpp +++ b/src/unix/utilsunx.cpp @@ -20,11 +20,18 @@ #include "wx/utils.h" +#define USE_PUTENV (!defined(HAVE_SETENV) && defined(HAVE_PUTENV)) + #ifndef WX_PRECOMP #include "wx/string.h" #include "wx/intl.h" #include "wx/log.h" #include "wx/app.h" + #include "wx/wxcrtvararg.h" + #if USE_PUTENV + #include "wx/module.h" + #include "wx/hashmap.h" + #endif #endif #include "wx/apptrait.h" @@ -38,6 +45,7 @@ #include "wx/unix/private.h" #include +#include // waitpid() #ifdef HAVE_SYS_SELECT_H # include @@ -473,7 +481,7 @@ long wxExecute(wxChar **argv, int flags, wxProcess *process) while (argv[mb_argc]) { - wxWX2MBbuf mb_arg = wxConvertWX2MB(argv[mb_argc]); + wxWX2MBbuf mb_arg = wxSafeConvertWX2MB(argv[mb_argc]); mb_argv[mb_argc] = strdup(mb_arg); mb_argc++; } @@ -687,7 +695,7 @@ long wxExecute(wxChar **argv, int flags, wxProcess *process) const wxChar* wxGetHomeDir( wxString *home ) { - *home = wxGetUserHome( wxEmptyString ); + *home = wxGetUserHome(); wxString tmp; if ( home->empty() ) *home = wxT("/"); @@ -699,11 +707,7 @@ const wxChar* wxGetHomeDir( wxString *home ) return home->c_str(); } -#if wxUSE_UNICODE -const wxMB2WXbuf wxGetUserHome( const wxString &user ) -#else // just for binary compatibility -- there is no 'const' here -char *wxGetUserHome( const wxString &user ) -#endif +wxString wxGetUserHome( const wxString &user ) { struct passwd *who = (struct passwd *) NULL; @@ -713,20 +717,17 @@ char *wxGetUserHome( const wxString &user ) if ((ptr = wxGetenv(wxT("HOME"))) != NULL) { -#if wxUSE_UNICODE - wxWCharBuffer buffer( ptr ); - return buffer; -#else return ptr; -#endif } - if ((ptr = wxGetenv(wxT("USER"))) != NULL || (ptr = wxGetenv(wxT("LOGNAME"))) != NULL) + + if ((ptr = wxGetenv(wxT("USER"))) != NULL || + (ptr = wxGetenv(wxT("LOGNAME"))) != NULL) { - who = getpwnam(wxConvertWX2MB(ptr)); + who = getpwnam(wxSafeConvertWX2MB(ptr)); } - // We now make sure the the user exists! - if (who == NULL) + // make sure the user exists! + if ( !who ) { who = getpwuid(getuid()); } @@ -736,7 +737,7 @@ char *wxGetUserHome( const wxString &user ) who = getpwnam (user.mb_str()); } - return wxConvertMB2WX(who ? who->pw_dir : 0); + return wxSafeConvertMB2WX(who ? who->pw_dir : 0); } // ---------------------------------------------------------------------------- @@ -787,7 +788,7 @@ static bool wxGetHostNameInternal(wxChar *buf, int sz) bool ok = uname(&uts) != -1; if ( ok ) { - wxStrncpy(buf, wxConvertMB2WX(uts.nodename), sz - 1); + wxStrncpy(buf, wxSafeConvertMB2WX(uts.nodename), sz - 1); buf[sz] = wxT('\0'); } #elif defined(HAVE_GETHOSTNAME) @@ -795,7 +796,7 @@ static bool wxGetHostNameInternal(wxChar *buf, int sz) bool ok = gethostname(cbuf, sz) != -1; if ( ok ) { - wxStrncpy(buf, wxConvertMB2WX(cbuf), sz - 1); + wxStrncpy(buf, wxSafeConvertMB2WX(cbuf), sz - 1); buf[sz] = wxT('\0'); } #else // no uname, no gethostname @@ -839,7 +840,7 @@ bool wxGetFullHostName(wxChar *buf, int sz) { if ( !wxStrchr(buf, wxT('.')) ) { - struct hostent *host = gethostbyname(wxConvertWX2MB(buf)); + struct hostent *host = gethostbyname(wxSafeConvertWX2MB(buf)); if ( !host ) { wxLogSysError(_("Cannot get the official hostname")); @@ -849,7 +850,7 @@ bool wxGetFullHostName(wxChar *buf, int sz) else { // the canonical name - wxStrncpy(buf, wxConvertMB2WX(host->h_name), sz); + wxStrncpy(buf, wxSafeConvertMB2WX(host->h_name), sz); } } //else: it's already a FQDN (BSD behaves this way) @@ -865,7 +866,7 @@ bool wxGetUserId(wxChar *buf, int sz) *buf = wxT('\0'); if ((who = getpwuid(getuid ())) != NULL) { - wxStrncpy (buf, wxConvertMB2WX(who->pw_name), sz - 1); + wxStrncpy (buf, wxSafeConvertMB2WX(who->pw_name), sz - 1); return true; } @@ -874,38 +875,33 @@ bool wxGetUserId(wxChar *buf, int sz) bool wxGetUserName(wxChar *buf, int sz) { +#ifdef HAVE_PW_GECOS struct passwd *who; *buf = wxT('\0'); if ((who = getpwuid (getuid ())) != NULL) { - // pw_gecos field in struct passwd is not standard -#ifdef HAVE_PW_GECOS char *comma = strchr(who->pw_gecos, ','); if (comma) *comma = '\0'; // cut off non-name comment fields - wxStrncpy (buf, wxConvertMB2WX(who->pw_gecos), sz - 1); -#else // !HAVE_PW_GECOS - wxStrncpy (buf, wxConvertMB2WX(who->pw_name), sz - 1); -#endif // HAVE_PW_GECOS/!HAVE_PW_GECOS + wxStrncpy (buf, wxSafeConvertMB2WX(who->pw_gecos), sz - 1); return true; } return false; +#else // !HAVE_PW_GECOS + return wxGetUserId(buf, sz); +#endif // HAVE_PW_GECOS/!HAVE_PW_GECOS } bool wxIsPlatform64Bit() { - wxString machine = wxGetCommandOutput(wxT("uname -m")); - - // NOTE: these tests are not 100% reliable! - return machine.Contains(wxT("AMD64")) || - machine.Contains(wxT("IA64")) || - machine.Contains(wxT("x64")) || - machine.Contains(wxT("X64")) || - machine.Contains(wxT("alpha")) || - machine.Contains(wxT("hppa64")) || - machine.Contains(wxT("ppc64")); + const wxString machine = wxGetCommandOutput(wxT("uname -m")); + + // the test for "64" is obviously not 100% reliable but seems to work fine + // in practice + return machine.Contains(wxT("64")) || + machine.Contains(wxT("alpha")); } // these functions are in mac/utils.cpp for wxMac @@ -916,9 +912,10 @@ wxOperatingSystemId wxGetOsVersion(int *verMaj, int *verMin) // get OS version int major, minor; wxString release = wxGetCommandOutput(wxT("uname -r")); - if ( !release.empty() && wxSscanf(release, wxT("%d.%d"), &major, &minor) != 2 ) + if ( release.empty() || + wxSscanf(release.c_str(), wxT("%d.%d"), &major, &minor) != 2 ) { - // unrecognized uname string format + // failed to get version string or unrecognized format major = minor = -1; } @@ -1047,10 +1044,39 @@ bool wxGetDiskSpace(const wxString& path, wxDiskspaceSize_t *pTotal, wxDiskspace // env vars // ---------------------------------------------------------------------------- +#if USE_PUTENV + +WX_DECLARE_STRING_HASH_MAP(char *, wxEnvVars); + +static wxEnvVars gs_envVars; + +class wxSetEnvModule : public wxModule +{ +public: + virtual bool OnInit() { return true; } + virtual void OnExit() + { + for ( wxEnvVars::const_iterator i = gs_envVars.begin(); + i != gs_envVars.end(); + ++i ) + { + free(i->second); + } + + gs_envVars.clear(); + } + + DECLARE_DYNAMIC_CLASS(wxSetEnvModule) +}; + +IMPLEMENT_DYNAMIC_CLASS(wxSetEnvModule, wxModule) + +#endif // USE_PUTENV + bool wxGetEnv(const wxString& var, wxString *value) { // wxGetenv is defined as getenv() - wxChar *p = wxGetenv(var); + char *p = wxGetenv(var); if ( !p ) return false; @@ -1062,13 +1088,22 @@ bool wxGetEnv(const wxString& var, wxString *value) return true; } -bool wxSetEnv(const wxString& variable, const wxChar *value) +static bool wxDoSetEnv(const wxString& variable, const char *value) { #if defined(HAVE_SETENV) - return setenv(variable.mb_str(), - value ? (const char *)wxString(value).mb_str() - : NULL, - 1 /* overwrite */) == 0; + if ( !value ) + { +#ifdef HAVE_UNSETENV + // don't test unsetenv() return value: it's void on some systems (at + // least Darwin) + unsetenv(variable.mb_str()); + return true; +#else + value = ""; // we can't pass NULL to setenv() +#endif + } + + return setenv(variable.mb_str(), value, 1 /* overwrite */) == 0; #elif defined(HAVE_PUTENV) wxString s = variable; if ( value ) @@ -1077,16 +1112,37 @@ bool wxSetEnv(const wxString& variable, const wxChar *value) // transform to ANSI const wxWX2MBbuf p = s.mb_str(); - // the string will be free()d by libc char *buf = (char *)malloc(strlen(p) + 1); strcpy(buf, p); + // store the string to free() it later + wxEnvVars::iterator i = gs_envVars.find(variable); + if ( i != gs_envVars.end() ) + { + free(i->second); + i->second = buf; + } + else // this variable hadn't been set before + { + gs_envVars[variable] = buf; + } + return putenv(buf) == 0; #else // no way to set an env var return false; #endif } +bool wxSetEnv(const wxString& variable, const wxString& value) +{ + return wxDoSetEnv(variable, value.mb_str()); +} + +bool wxUnsetEnv(const wxString& variable) +{ + return wxDoSetEnv(variable, NULL); +} + // ---------------------------------------------------------------------------- // signal handling // ---------------------------------------------------------------------------- @@ -1164,13 +1220,27 @@ bool wxHandleFatalExceptions(bool doit) #if wxUSE_GUI +#ifdef __DARWIN__ + #include +#endif // ---------------------------------------------------------------------------- // wxExecute support // ---------------------------------------------------------------------------- -// Darwin doesn't use the same process end detection mechanisms so we don't -// need wxExecute-related helpers for it -#if !(defined(__DARWIN__) && defined(__WXMAC__)) +/* + NOTE: If this proves not to work well for wxMac then move back to the old + behavior. If, however, it proves to work just fine, nuke all of the code + for the old behavior. I strongly suggest backporting this to 2.8 as well. + However, beware that while you can nuke the old code here, you cannot + nuke the wxAddProcessCallbackForPid from the 2.8 branch (found in + utilsexc_cf since it's an exported symbol). + */ +// #define USE_OLD_DARWIN_END_PROCESS_DETECT (defined(__DARWIN__) && defined(__WXMAC__)) +#define USE_OLD_DARWIN_END_PROCESS_DETECT 0 + +// wxMac/wxCocoa don't use the same process end detection mechanisms so we don't +// need wxExecute-related helpers for them +#if !USE_OLD_DARWIN_END_PROCESS_DETECT bool wxGUIAppTraits::CreateEndProcessPipe(wxExecuteData& execData) { @@ -1238,55 +1308,122 @@ int wxGUIAppTraits::WaitForChild(wxExecuteData& execData) } -#if defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)) - endProcData->tag = wxAddProcessCallbackForPid(endProcData, execData.pid); + if ( !(flags & wxEXEC_NOEVENTS) ) + { +#if USE_OLD_DARWIN_END_PROCESS_DETECT + endProcData->tag = wxAddProcessCallbackForPid(endProcData, execData.pid); #else - endProcData->tag = wxAddProcessCallback - ( - endProcData, - execData.pipeEndProcDetect.Detach(wxPipe::Read) - ); - - execData.pipeEndProcDetect.Close(); -#endif // defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)) + endProcData->tag = wxAddProcessCallback + ( + endProcData, + execData.pipeEndProcDetect.Detach(wxPipe::Read) + ); + + execData.pipeEndProcDetect.Close(); +#endif // USE_OLD_DARWIN_END_PROCESS_DETECT + } if ( flags & wxEXEC_SYNC ) { wxBusyCursor bc; - wxWindowDisabler *wd = flags & wxEXEC_NODISABLE ? NULL - : new wxWindowDisabler; + int exitcode = 0; - // endProcData->pid will be set to 0 from GTK_EndProcessDetector when the - // process terminates - while ( endProcData->pid != 0 ) - { - bool idle = true; + wxWindowDisabler *wd = flags & (wxEXEC_NODISABLE | wxEXEC_NOEVENTS) + ? NULL + : new wxWindowDisabler; -#if HAS_PIPE_INPUT_STREAM - if ( execData.bufOut ) + if ( flags & wxEXEC_NOEVENTS ) + { + // just block waiting for the child to exit + int status = 0; + + int result = waitpid(execData.pid, &status, 0); +#ifdef __DARWIN__ + /* DE: waitpid manpage states that waitpid can fail with EINTR + if the call is interrupted by a caught signal. I suppose + that means that this ought to be a while loop. + + The odd thing is that it seems to fail EVERY time. It fails + with a quickly exiting process (e.g. echo), and fails with a + slowly exiting process (e.g. sleep 2) but clearly after + having waited for the child to exit. Maybe it's a bug in + my particular version. + + It works, however, from the CFSocket callback without this + trick but in that case it's used only after CFSocket calls + the callback and with the WNOHANG flag which would seem to + preclude it from being interrupted or at least make it much + less likely since it would not then be waiting. + + If Darwin's man page is to be believed then this is definitely + necessary. It's just weird that I've never seen it before + and apparently no one else has either or you'd think they'd + have reported it by now. Perhaps blocking the GUI while + waiting for a child process to exit is simply not that common. + */ + if(result == -1 && errno == EINTR) { - execData.bufOut->Update(); - idle = false; + result = waitpid(execData.pid, &status, 0); } - if ( execData.bufErr ) +#endif + + if ( result == -1 ) + { + wxLogLastError(_T("waitpid")); + exitcode = -1; + } + else { - execData.bufErr->Update(); - idle = false; + wxASSERT_MSG( result == execData.pid, + _T("unexpected waitpid() return value") ); + + if ( WIFEXITED(status) ) + { + exitcode = WEXITSTATUS(status); + } + else // abnormal termination? + { + wxASSERT_MSG( WIFSIGNALED(status), + _T("unexpected child wait status") ); + exitcode = -1; + } } + } + else // !wxEXEC_NOEVENTS + { + // endProcData->pid will be set to 0 from GTK_EndProcessDetector when the + // process terminates + while ( endProcData->pid != 0 ) + { + bool idle = true; + +#if HAS_PIPE_INPUT_STREAM + if ( execData.bufOut ) + { + execData.bufOut->Update(); + idle = false; + } + + if ( execData.bufErr ) + { + execData.bufErr->Update(); + idle = false; + } #endif // HAS_PIPE_INPUT_STREAM - // don't consume 100% of the CPU while we're sitting in this - // loop - if ( idle ) - wxMilliSleep(1); + // don't consume 100% of the CPU while we're sitting in this + // loop + if ( idle ) + wxMilliSleep(1); - // give GTK+ a chance to call GTK_EndProcessDetector here and - // also repaint the GUI - wxYield(); - } + // give GTK+ a chance to call GTK_EndProcessDetector here and + // also repaint the GUI + wxYield(); + } - int exitcode = endProcData->exitcode; + exitcode = endProcData->exitcode; + } delete wd; delete endProcData;