]> git.saurik.com Git - wxWidgets.git/blobdiff - src/unix/utilsunx.cpp
Remove some out of date comments.
[wxWidgets.git] / src / unix / utilsunx.cpp
index d7036f000b5dcd08d0d94031cf7ee786bfb2dd25..ec550fcf244c9a990bec2e530683fd7418e9533a 100644 (file)
 #   include <sys/select.h>
 #endif
 
 #   include <sys/select.h>
 #endif
 
-#define HAS_PIPE_INPUT_STREAM (wxUSE_STREAMS && wxUSE_FILE)
+#define HAS_PIPE_STREAMS (wxUSE_STREAMS && wxUSE_FILE)
 
 
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS
 
 // define this to let wxexec.cpp know that we know what we're doing
 #define _WX_USED_BY_WXEXECUTE_
 #include "../common/execcmn.cpp"
 
 
 // define this to let wxexec.cpp know that we know what we're doing
 #define _WX_USED_BY_WXEXECUTE_
 #include "../common/execcmn.cpp"
 
-#endif // HAS_PIPE_INPUT_STREAM
+#endif // HAS_PIPE_STREAMS
 
 #if defined(__MWERKS__) && defined(__MACH__)
     #ifndef WXWIN_OS_DESCRIPTION
 
 #if defined(__MWERKS__) && defined(__MACH__)
     #ifndef WXWIN_OS_DESCRIPTION
@@ -255,7 +255,7 @@ int wxKill(long pid, wxSignal sig, wxKillError *rc, int flags)
 
             default:
                 // this goes against Unix98 docs so log it
 
             default:
                 // this goes against Unix98 docs so log it
-                wxLogDebug(_T("unexpected kill(2) return value %d"), err);
+                wxLogDebug(wxT("unexpected kill(2) return value %d"), err);
 
                 // something else...
                 *rc = wxKILL_ERROR;
 
                 // something else...
                 *rc = wxKILL_ERROR;
@@ -274,11 +274,11 @@ bool wxShutdown(int flags)
     switch ( flags )
     {
         case wxSHUTDOWN_POWEROFF:
     switch ( flags )
     {
         case wxSHUTDOWN_POWEROFF:
-            level = _T('0');
+            level = wxT('0');
             break;
 
         case wxSHUTDOWN_REBOOT:
             break;
 
         case wxSHUTDOWN_REBOOT:
-            level = _T('6');
+            level = wxT('6');
             break;
 
         case wxSHUTDOWN_LOGOFF:
             break;
 
         case wxSHUTDOWN_LOGOFF:
@@ -286,7 +286,7 @@ bool wxShutdown(int flags)
             return false;
 
         default:
             return false;
 
         default:
-            wxFAIL_MSG( _T("unknown wxShutdown() flag") );
+            wxFAIL_MSG( wxT("unknown wxShutdown() flag") );
             return false;
     }
 
             return false;
     }
 
@@ -297,7 +297,7 @@ bool wxShutdown(int flags)
 // wxStream classes to support IO redirection in wxExecute
 // ----------------------------------------------------------------------------
 
 // wxStream classes to support IO redirection in wxExecute
 // ----------------------------------------------------------------------------
 
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS
 
 bool wxPipeInputStream::CanRead() const
 {
 
 bool wxPipeInputStream::CanRead() const
 {
@@ -326,7 +326,7 @@ bool wxPipeInputStream::CanRead() const
             return false;
 
         default:
             return false;
 
         default:
-            wxFAIL_MSG(_T("unexpected select() return value"));
+            wxFAIL_MSG(wxT("unexpected select() return value"));
             // still fall through
 
         case 1:
             // still fall through
 
         case 1:
@@ -337,7 +337,46 @@ bool wxPipeInputStream::CanRead() const
     }
 }
 
     }
 }
 
-#endif // HAS_PIPE_INPUT_STREAM
+size_t wxPipeOutputStream::OnSysWrite(const void *buffer, size_t size)
+{
+    // We need to suppress error logging here, because on writing to a pipe
+    // which is full, wxFile::Write reports a system error. However, this is
+    // not an extraordinary situation, and it should not be reported to the
+    // user (but if really needed, the program can recognize it by checking
+    // whether LastRead() == 0.) Other errors will be reported below.
+    size_t ret;
+    {
+        wxLogNull logNo;
+        ret = m_file->Write(buffer, size);
+    }
+
+    switch ( m_file->GetLastError() )
+    {
+       // pipe is full
+#ifdef EAGAIN
+       case EAGAIN:
+#endif
+#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
+       case EWOULDBLOCK:
+#endif
+           // do not treat it as an error
+           m_file->ClearLastError();
+           // fall through
+
+       // no error
+       case 0:
+           break;
+
+       // some real error
+       default:
+           wxLogSysError(_("Can't write to child process's stdin"));
+           m_lasterror = wxSTREAM_WRITE_ERROR;
+    }
+
+    return ret;
+}
+
+#endif // HAS_PIPE_STREAMS
 
 // ----------------------------------------------------------------------------
 // wxShell
 
 // ----------------------------------------------------------------------------
 // wxShell
@@ -349,12 +388,12 @@ static wxString wxMakeShellCommand(const wxString& command)
     if ( !command )
     {
         // just an interactive shell
     if ( !command )
     {
         // just an interactive shell
-        cmd = _T("xterm");
+        cmd = wxT("xterm");
     }
     else
     {
         // execute command in a shell
     }
     else
     {
         // execute command in a shell
-        cmd << _T("/bin/sh -c '") << command << _T('\'');
+        cmd << wxT("/bin/sh -c '") << command << wxT('\'');
     }
 
     return cmd;
     }
 
     return cmd;
@@ -367,7 +406,7 @@ bool wxShell(const wxString& command)
 
 bool wxShell(const wxString& command, wxArrayString& output)
 {
 
 bool wxShell(const wxString& command, wxArrayString& output)
 {
-    wxCHECK_MSG( !command.empty(), false, _T("can't exec shell non interactively") );
+    wxCHECK_MSG( !command.empty(), false, wxT("can't exec shell non interactively") );
 
     return wxExecute(wxMakeShellCommand(command), output);
 }
 
     return wxExecute(wxMakeShellCommand(command), output);
 }
@@ -394,7 +433,7 @@ public:
     ArgsArray(wchar_t **wargv)
     {
         int argc = 0;
     ArgsArray(wchar_t **wargv)
     {
         int argc = 0;
-        while ( *wargv++ )
+        while ( wargv[argc] )
             argc++;
 
         Init(argc);
             argc++;
 
         Init(argc);
@@ -429,7 +468,7 @@ private:
     int m_argc;
     char **m_argv;
 
     int m_argc;
     char **m_argv;
 
-    DECLARE_NO_COPY_CLASS(ArgsArray)
+    wxDECLARE_NO_COPY_CLASS(ArgsArray);
 };
 
 } // anonymous namespace
 };
 
 } // anonymous namespace
@@ -442,27 +481,30 @@ private:
 bool wxMacLaunch(char **argv);
 #endif
 
 bool wxMacLaunch(char **argv);
 #endif
 
-long wxExecute(const wxString& command, int flags, wxProcess *process)
+long wxExecute(const wxString& command, int flags, wxProcess *process,
+        const wxExecuteEnv *env)
 {
     ArgsArray argv(wxCmdLineParser::ConvertStringToArgs(command,
                                                         wxCMD_LINE_SPLIT_UNIX));
 
 {
     ArgsArray argv(wxCmdLineParser::ConvertStringToArgs(command,
                                                         wxCMD_LINE_SPLIT_UNIX));
 
-    return wxExecute(argv, flags, process);
+    return wxExecute(argv, flags, process, env);
 }
 
 #if wxUSE_UNICODE
 
 }
 
 #if wxUSE_UNICODE
 
-long wxExecute(wchar_t **wargv, int flags, wxProcess *process)
+long wxExecute(wchar_t **wargv, int flags, wxProcess *process,
+        const wxExecuteEnv *env)
 {
     ArgsArray argv(wargv);
 
 {
     ArgsArray argv(wargv);
 
-    return wxExecute(argv, flags, process);
+    return wxExecute(argv, flags, process, env);
 }
 
 #endif // wxUSE_UNICODE
 
 // wxExecute: the real worker function
 }
 
 #endif // wxUSE_UNICODE
 
 // wxExecute: the real worker function
-long wxExecute(char **argv, int flags, wxProcess *process)
+long wxExecute(char **argv, int flags, wxProcess *process,
+        const wxExecuteEnv *env)
 {
     // for the sync execution, we return -1 to indicate failure, but for async
     // case we return 0 which is never a valid PID
 {
     // for the sync execution, we return -1 to indicate failure, but for async
     // case we return 0 which is never a valid PID
@@ -480,7 +522,7 @@ long wxExecute(char **argv, int flags, wxProcess *process)
     // don't know what yet, so for now just warn the user (this is the least we
     // can do) about it
     wxASSERT_MSG( wxThread::IsMain(),
     // don't know what yet, so for now just warn the user (this is the least we
     // can do) about it
     wxASSERT_MSG( wxThread::IsMain(),
-                    _T("wxExecute() can be called only from the main thread") );
+                    wxT("wxExecute() can be called only from the main thread") );
 #endif // wxUSE_THREADS
 
 #if defined(__WXCOCOA__) || ( defined(__WXOSX_MAC__) && wxOSX_USE_COCOA_OR_CARBON )
 #endif // wxUSE_THREADS
 
 #if defined(__WXCOCOA__) || ( defined(__WXOSX_MAC__) && wxOSX_USE_COCOA_OR_CARBON )
@@ -556,12 +598,6 @@ long wxExecute(char **argv, int flags, wxProcess *process)
         }
 #endif // !__VMS
 
         }
 #endif // !__VMS
 
-        // reading side can be safely closed but we should keep the write one
-        // opened, it will be only closed when the process terminates resulting
-        // in a read notification to the parent
-        execData.pipeEndProcDetect.Detach(wxPipe::Write);
-        execData.pipeEndProcDetect.Close();
-
         // redirect stdin, stdout and stderr
         if ( pipeIn.IsOk() )
         {
         // redirect stdin, stdout and stderr
         if ( pipeIn.IsOk() )
         {
@@ -577,6 +613,73 @@ long wxExecute(char **argv, int flags, wxProcess *process)
             pipeErr.Close();
         }
 
             pipeErr.Close();
         }
 
+        // Close all (presumably accidentally) inherited file descriptors to
+        // avoid descriptor leaks. This means that we don't allow inheriting
+        // them purposefully but this seems like a lesser evil in wx code.
+        // Ideally we'd provide some flag to indicate that none (or some?) of
+        // the descriptors do not need to be closed but for now this is better
+        // than never closing them at all as wx code never used FD_CLOEXEC.
+
+        // Note that while the reading side of the end process detection pipe
+        // can be safely closed, we should keep the write one opened, it will
+        // be only closed when the process terminates resulting in a read
+        // notification to the parent
+        const int fdEndProc = execData.pipeEndProcDetect.Detach(wxPipe::Write);
+        execData.pipeEndProcDetect.Close();
+
+        // TODO: Iterating up to FD_SETSIZE is both inefficient (because it may
+        //       be quite big) and incorrect (because in principle we could
+        //       have more opened descriptions than this number). Unfortunately
+        //       there is no good portable solution for closing all descriptors
+        //       above a certain threshold but non-portable solutions exist for
+        //       most platforms, see [http://stackoverflow.com/questions/899038/
+        //          getting-the-highest-allocated-file-descriptor]
+        for ( int fd = 0; fd < (int)FD_SETSIZE; ++fd )
+        {
+            if ( fd != STDIN_FILENO  &&
+                 fd != STDOUT_FILENO &&
+                 fd != STDERR_FILENO &&
+                 fd != fdEndProc )
+            {
+                close(fd);
+            }
+        }
+
+
+        // Process additional options if we have any
+        if ( env )
+        {
+            // Change working directory if it is specified
+            if ( !env->cwd.empty() )
+                wxSetWorkingDirectory(env->cwd);
+
+            // Change environment if needed.
+            //
+            // NB: We can't use execve() currently because we allow using
+            //     non full paths to wxExecute(), i.e. we want to search for
+            //     the program in PATH. However it just might be simpler/better
+            //     to do the search manually and use execve() envp parameter to
+            //     set up the environment of the child process explicitly
+            //     instead of doing what we do below.
+            if ( !env->env.empty() )
+            {
+                wxEnvVariableHashMap oldenv;
+                wxGetEnvMap(&oldenv);
+
+                // Remove unwanted variables
+                wxEnvVariableHashMap::const_iterator it;
+                for ( it = oldenv.begin(); it != oldenv.end(); ++it )
+                {
+                    if ( env->env.find(it->first) == env->env.end() )
+                        wxUnsetEnv(it->first);
+                }
+
+                // And add the new ones (possibly replacing the old values)
+                for ( it = env->env.begin(); it != env->env.end(); ++it )
+                    wxSetEnv(it->first, it->second);
+            }
+        }
+
         execvp(*argv, argv);
 
         fprintf(stderr, "execvp(");
         execvp(*argv, argv);
 
         fprintf(stderr, "execvp(");
@@ -601,10 +704,12 @@ long wxExecute(char **argv, int flags, wxProcess *process)
     {
         // save it for WaitForChild() use
         execData.pid = pid;
     {
         // save it for WaitForChild() use
         execData.pid = pid;
+        if (execData.process)
+            execData.process->SetPid(pid);  // and also in the wxProcess
 
         // prepare for IO redirection
 
 
         // prepare for IO redirection
 
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS
         // the input buffer bufOut is connected to stdout, this is why it is
         // called bufOut and not bufIn
         wxStreamTempInputBuffer bufOut,
         // the input buffer bufOut is connected to stdout, this is why it is
         // called bufOut and not bufIn
         wxStreamTempInputBuffer bufOut,
@@ -612,8 +717,24 @@ long wxExecute(char **argv, int flags, wxProcess *process)
 
         if ( process && process->IsRedirected() )
         {
 
         if ( process && process->IsRedirected() )
         {
+            // Avoid deadlocks which could result from trying to write to the
+            // child input pipe end while the child itself is writing to its
+            // output end and waiting for us to read from it.
+            if ( !pipeIn.MakeNonBlocking(wxPipe::Write) )
+            {
+                // This message is not terrible useful for the user but what
+                // else can we do? Also, should we fail here or take the risk
+                // to continue and deadlock? Currently we choose the latter but
+                // it might not be the best idea.
+                wxLogSysError(_("Failed to set up non-blocking pipe, "
+                                "the program might hang."));
+#if wxUSE_LOG
+                wxLog::FlushActive();
+#endif
+            }
+
             wxOutputStream *inStream =
             wxOutputStream *inStream =
-                new wxFileOutputStream(pipeIn.Detach(wxPipe::Write));
+                new wxPipeOutputStream(pipeIn.Detach(wxPipe::Write));
 
             const int fdOut = pipeOut.Detach(wxPipe::Read);
             wxPipeInputStream *outStream = new wxPipeInputStream(fdOut);
 
             const int fdOut = pipeOut.Detach(wxPipe::Read);
             wxPipeInputStream *outStream = new wxPipeInputStream(fdOut);
@@ -632,7 +753,7 @@ long wxExecute(char **argv, int flags, wxProcess *process)
             execData.fdOut = fdOut;
             execData.fdErr = fdErr;
         }
             execData.fdOut = fdOut;
             execData.fdErr = fdErr;
         }
-#endif // HAS_PIPE_INPUT_STREAM
+#endif // HAS_PIPE_STREAMS
 
         if ( pipeIn.IsOk() )
         {
 
         if ( pipeIn.IsOk() )
         {
@@ -720,7 +841,7 @@ static wxString wxGetCommandOutput(const wxString &cmd)
     FILE *f = popen(cmd.ToAscii(), "r");
     if ( !f )
     {
     FILE *f = popen(cmd.ToAscii(), "r");
     if ( !f )
     {
-        wxLogSysError(_T("Executing \"%s\" failed"), cmd.c_str());
+        wxLogSysError(wxT("Executing \"%s\" failed"), cmd.c_str());
         return wxEmptyString;
     }
 
         return wxEmptyString;
     }
 
@@ -736,7 +857,7 @@ static wxString wxGetCommandOutput(const wxString &cmd)
 
     pclose(f);
 
 
     pclose(f);
 
-    if ( !s.empty() && s.Last() == _T('\n') )
+    if ( !s.empty() && s.Last() == wxT('\n') )
         s.RemoveLast();
 
     return s;
         s.RemoveLast();
 
     return s;
@@ -871,6 +992,25 @@ bool wxIsPlatform64Bit()
                 machine.Contains(wxT("alpha"));
 }
 
                 machine.Contains(wxT("alpha"));
 }
 
+#ifdef __LINUX__
+wxLinuxDistributionInfo wxGetLinuxDistributionInfo()
+{
+    const wxString id = wxGetCommandOutput(wxT("lsb_release --id"));
+    const wxString desc = wxGetCommandOutput(wxT("lsb_release --description"));
+    const wxString rel = wxGetCommandOutput(wxT("lsb_release --release"));
+    const wxString codename = wxGetCommandOutput(wxT("lsb_release --codename"));
+
+    wxLinuxDistributionInfo ret;
+
+    id.StartsWith("Distributor ID:\t", &ret.Id);
+    desc.StartsWith("Description:\t", &ret.Description);
+    rel.StartsWith("Release:\t", &ret.Release);
+    codename.StartsWith("Codename:\t", &ret.CodeName);
+
+    return ret;
+}
+#endif
+
 // these functions are in src/osx/utilsexc_base.cpp for wxMac
 #ifndef __WXMAC__
 
 // these functions are in src/osx/utilsexc_base.cpp for wxMac
 #ifndef __WXMAC__
 
@@ -1074,7 +1214,7 @@ static bool wxDoSetEnv(const wxString& variable, const char *value)
 #elif defined(HAVE_PUTENV)
     wxString s = variable;
     if ( value )
 #elif defined(HAVE_PUTENV)
     wxString s = variable;
     if ( value )
-        s << _T('=') << value;
+        s << wxT('=') << value;
 
     // transform to ANSI
     const wxWX2MBbuf p = s.mb_str();
 
     // transform to ANSI
     const wxWX2MBbuf p = s.mb_str();
@@ -1157,7 +1297,7 @@ bool wxHandleFatalExceptions(bool doit)
         ok &= sigaction(SIGSEGV, &act, &s_handlerSEGV) == 0;
         if ( !ok )
         {
         ok &= sigaction(SIGSEGV, &act, &s_handlerSEGV) == 0;
         if ( !ok )
         {
-            wxLogDebug(_T("Failed to install our signal handler."));
+            wxLogDebug(wxT("Failed to install our signal handler."));
         }
 
         s_savedHandlers = true;
         }
 
         s_savedHandlers = true;
@@ -1171,7 +1311,7 @@ bool wxHandleFatalExceptions(bool doit)
         ok &= sigaction(SIGSEGV, &s_handlerSEGV, NULL) == 0;
         if ( !ok )
         {
         ok &= sigaction(SIGSEGV, &s_handlerSEGV, NULL) == 0;
         if ( !ok )
         {
-            wxLogDebug(_T("Failed to uninstall our signal handler."));
+            wxLogDebug(wxT("Failed to uninstall our signal handler."));
         }
 
         s_savedHandlers = false;
         }
 
         s_savedHandlers = false;
@@ -1225,7 +1365,7 @@ int wxAppTraits::AddProcessCallback(wxEndProcessData *data, int fd)
 
 bool wxAppTraits::CheckForRedirectedIO(wxExecuteData& execData)
 {
 
 bool wxAppTraits::CheckForRedirectedIO(wxExecuteData& execData)
 {
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS
     bool hasIO = false;
 
     if ( execData.bufOut && execData.bufOut->Update() )
     bool hasIO = false;
 
     if ( execData.bufOut && execData.bufOut->Update() )
@@ -1235,9 +1375,11 @@ bool wxAppTraits::CheckForRedirectedIO(wxExecuteData& execData)
         hasIO = true;
 
     return hasIO;
         hasIO = true;
 
     return hasIO;
-#else // !HAS_PIPE_INPUT_STREAM
+#else // !HAS_PIPE_STREAMS
+    wxUnusedVar(execData);
+
     return false;
     return false;
-#endif // HAS_PIPE_INPUT_STREAM/!HAS_PIPE_INPUT_STREAM
+#endif // HAS_PIPE_STREAMS/!HAS_PIPE_STREAMS
 }
 
 // helper classes/functions used by WaitForChild()
 }
 
 // helper classes/functions used by WaitForChild()
@@ -1263,7 +1405,7 @@ public:
 protected:
     const int m_fd;
 
 protected:
     const int m_fd;
 
-    DECLARE_NO_COPY_CLASS(wxReadFDIOHandler)
+    wxDECLARE_NO_COPY_CLASS(wxReadFDIOHandler);
 };
 
 // class for monitoring our end of the process detection pipe, simply sets a
 };
 
 // class for monitoring our end of the process detection pipe, simply sets a
@@ -1284,10 +1426,10 @@ public:
 private:
     bool m_terminated;
 
 private:
     bool m_terminated;
 
-    DECLARE_NO_COPY_CLASS(wxEndHandler)
+    wxDECLARE_NO_COPY_CLASS(wxEndHandler);
 };
 
 };
 
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS
 
 // class for monitoring our ends of child stdout/err, should be constructed
 // with the FD and stream from wxExecuteData and will do nothing if they're
 
 // class for monitoring our ends of child stdout/err, should be constructed
 // with the FD and stream from wxExecuteData and will do nothing if they're
@@ -1313,10 +1455,10 @@ public:
 private:
     wxStreamTempInputBuffer * const m_buf;
 
 private:
     wxStreamTempInputBuffer * const m_buf;
 
-    DECLARE_NO_COPY_CLASS(wxRedirectedIOHandler)
+    wxDECLARE_NO_COPY_CLASS(wxRedirectedIOHandler);
 };
 
 };
 
-#endif // HAS_PIPE_INPUT_STREAM
+#endif // HAS_PIPE_STREAMS
 
 // helper function which calls waitpid() and analyzes the result
 int DoWaitForChild(int pid, int flags = 0)
 
 // helper function which calls waitpid() and analyzes the result
 int DoWaitForChild(int pid, int flags = 0)
@@ -1352,15 +1494,21 @@ int DoWaitForChild(int pid, int flags = 0)
     {
         wxASSERT_MSG( rc == pid, "unexpected waitpid() return value" );
 
     {
         wxASSERT_MSG( rc == pid, "unexpected waitpid() return value" );
 
+        // notice that the caller expects the exit code to be signed, e.g. -1
+        // instead of 255 so don't assign WEXITSTATUS() to an int
+        signed char exitcode;
         if ( WIFEXITED(status) )
         if ( WIFEXITED(status) )
-            return WEXITSTATUS(status);
+            exitcode = WEXITSTATUS(status);
         else if ( WIFSIGNALED(status) )
         else if ( WIFSIGNALED(status) )
-            return -WTERMSIG(status);
+            exitcode = -WTERMSIG(status);
         else
         {
             wxLogError("Child process (PID %d) exited for unknown reason, "
                        "status = %d", pid, status);
         else
         {
             wxLogError("Child process (PID %d) exited for unknown reason, "
                        "status = %d", pid, status);
+            exitcode = -1;
         }
         }
+
+        return exitcode;
     }
 
     return -1;
     }
 
     return -1;
@@ -1391,7 +1539,7 @@ int wxAppTraits::WaitForChild(wxExecuteData& execData)
     }
     //else: synchronous execution case
 
     }
     //else: synchronous execution case
 
-#if HAS_PIPE_INPUT_STREAM
+#if HAS_PIPE_STREAMS && wxUSE_SOCKETS
     wxProcess * const process = execData.process;
     if ( process && process->IsRedirected() )
     {
     wxProcess * const process = execData.process;
     if ( process && process->IsRedirected() )
     {
@@ -1415,7 +1563,7 @@ int wxAppTraits::WaitForChild(wxExecuteData& execData)
         }
     }
     //else: no IO redirection, just block waiting for the child to exit
         }
     }
     //else: no IO redirection, just block waiting for the child to exit
-#endif // HAS_PIPE_INPUT_STREAM
+#endif // HAS_PIPE_STREAMS
 
     return DoWaitForChild(execData.pid);
 }
 
     return DoWaitForChild(execData.pid);
 }