#include "wx/process.h"
#include "wx/thread.h"
-#include "wx/unix/execute.h"
+#include "wx/stream.h"
+
+#if wxUSE_GUI
+ #include "wx/unix/execute.h"
+#endif
#include <stdarg.h>
#include <dirent.h>
#include <fcntl.h> // for O_WRONLY and friends
#include <time.h> // nanosleep() and/or usleep()
#include <ctype.h> // isspace()
-
-// JACS: needed for FD_SETSIZE
-#include <sys/time.h>
+#include <sys/time.h> // needed for FD_SETSIZE
#ifdef HAVE_UNAME
#include <sys/utsname.h> // for uname()
void wxUsleep(unsigned long milliseconds)
{
-#ifdef HAVE_NANOSLEEP
+#if defined(HAVE_NANOSLEEP)
timespec tmReq;
- tmReq.tv_sec = milliseconds / 1000;
+ tmReq.tv_sec = (time_t)(milliseconds / 1000);
tmReq.tv_nsec = (milliseconds % 1000) * 1000 * 1000;
// we're not interested in remaining time nor in return value
(void)nanosleep(&tmReq, (timespec *)NULL);
-#elif defined( HAVE_USLEEP )
+#elif defined(HAVE_USLEEP)
// uncomment this if you feel brave or if you are sure that your version
// of Solaris has a safe usleep() function but please notice that usleep()
// is known to lead to crashes in MT programs in Solaris 2.[67] and is not
#endif // Sun
usleep(milliseconds * 1000); // usleep(3) wants microseconds
+#elif defined(HAVE_SLEEP)
+ // under BeOS sleep() takes seconds (what about other platforms, if any?)
+ sleep(milliseconds * 1000);
#else // !sleep function
#error "usleep() or nanosleep() function required for wxUsleep"
#endif // sleep function
int wxKill(long pid, wxSignal sig)
{
- return kill(pid, (int)sig);
+ return kill((pid_t)pid, (int)sig);
}
#define WXEXECUTE_NARGS 127
return lRc;
}
-bool wxShell(const wxString& command)
+// ----------------------------------------------------------------------------
+// wxShell
+// ----------------------------------------------------------------------------
+
+static wxString wxMakeShellCommand(const wxString& command)
{
wxString cmd;
- if ( !!command )
- cmd.Printf(wxT("xterm -e %s"), command.c_str());
+ if ( !command )
+ {
+ // just an interactive shell
+ cmd = _T("xterm");
+ }
else
- cmd = command;
+ {
+ // execute command in a shell
+ cmd << _T("/bin/sh -c '") << command << _T('\'');
+ }
+
+ return cmd;
+}
- return wxExecute(cmd) != 0;
+bool wxShell(const wxString& command)
+{
+ return wxExecute(wxMakeShellCommand(command), TRUE /* sync */) == 0;
}
+bool wxShell(const wxString& command, wxArrayString& output)
+{
+ wxCHECK_MSG( !!command, FALSE, _T("can't exec shell non interactively") );
+
+ return wxExecute(wxMakeShellCommand(command), output);
+}
+
+#if wxUSE_GUI
+
void wxHandleProcessTermination(wxEndProcessData *proc_data)
{
int pid = (proc_data->pid > 0) ? proc_data->pid : -(proc_data->pid);
}
}
-long wxExecute( wxChar **argv, bool sync, wxProcess *process )
+#endif // wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// wxStream classes to support IO redirection in wxExecute
+// ----------------------------------------------------------------------------
+
+class wxProcessFileInputStream : public wxInputStream
+{
+public:
+ wxProcessFileInputStream(int fd) { m_fd = fd; }
+ ~wxProcessFileInputStream() { close(m_fd); }
+
+ virtual bool Eof() const;
+
+protected:
+ size_t OnSysRead(void *buffer, size_t bufsize);
+
+protected:
+ int m_fd;
+};
+
+class wxProcessFileOutputStream : public wxOutputStream
+{
+public:
+ wxProcessFileOutputStream(int fd) { m_fd = fd; }
+ ~wxProcessFileOutputStream() { close(m_fd); }
+
+protected:
+ size_t OnSysWrite(const void *buffer, size_t bufsize);
+
+protected:
+ int m_fd;
+};
+
+bool wxProcessFileInputStream::Eof() const
+{
+ if ( m_lasterror == wxSTREAM_EOF )
+ return TRUE;
+
+ // check if there is any input available
+ struct timeval tv;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+
+ fd_set readfds;
+ FD_ZERO(&readfds);
+ FD_SET(m_fd, &readfds);
+ switch ( select(m_fd + 1, &readfds, NULL, NULL, &tv) )
+ {
+ case -1:
+ wxLogSysError(_("Impossible to get child process input"));
+ // fall through
+
+ case 0:
+ return TRUE;
+
+ default:
+ wxFAIL_MSG(_T("unexpected select() return value"));
+ // still fall through
+
+ case 1:
+ // input available: check if there is any
+ return wxInputStream::Eof();
+ }
+}
+
+size_t wxProcessFileInputStream::OnSysRead(void *buffer, size_t bufsize)
+{
+ int ret = read(m_fd, buffer, bufsize);
+ if ( ret == 0 )
+ {
+ m_lasterror = wxSTREAM_EOF;
+ }
+ else if ( ret == -1 )
+ {
+ m_lasterror = wxSTREAM_READ_ERROR;
+ ret = 0;
+ }
+ else
+ {
+ m_lasterror = wxSTREAM_NOERROR;
+ }
+
+ return ret;
+}
+
+size_t wxProcessFileOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
+{
+ int ret = write(m_fd, buffer, bufsize);
+ if ( ret == -1 )
+ {
+ m_lasterror = wxSTREAM_WRITE_ERROR;
+ ret = 0;
+ }
+ else
+ {
+ m_lasterror = wxSTREAM_NOERROR;
+ }
+
+ return ret;
+}
+
+long wxExecute(wxChar **argv,
+ bool sync,
+ wxProcess *process)
{
wxCHECK_MSG( *argv, 0, wxT("can't exec empty command") );
while (argv[mb_argc])
{
- wxWX2MBbuf mb_arg = wxConvertWX2MB(argv[mb_argc]);
- mb_argv[mb_argc] = strdup(mb_arg);
- mb_argc++;
+ wxWX2MBbuf mb_arg = wxConvertWX2MB(argv[mb_argc]);
+ mb_argv[mb_argc] = strdup(mb_arg);
+ mb_argc++;
}
mb_argv[mb_argc] = (char *) NULL;
#if wxUSE_GUI
// create pipes
int end_proc_detect[2];
- if (pipe(end_proc_detect) == -1)
+ if ( pipe(end_proc_detect) == -1 )
{
wxLogSysError( _("Pipe creation failed") );
+ wxLogError( _("Failed to execute '%s'\n"), *argv );
ARGS_CLEANUP;
}
#endif // wxUSE_GUI
+ int pipeIn[2];
+ int pipeOut[2];
+ pipeIn[0] = pipeIn[1] =
+ pipeOut[0] = pipeOut[1] = -1;
+
+ if ( process && process->IsRedirected() )
+ {
+ if ( pipe(pipeIn) == -1 || pipe(pipeOut) == -1 )
+ {
+#if wxUSE_GUI
+ // free previously allocated resources
+ close(end_proc_detect[0]);
+ close(end_proc_detect[1]);
+#endif // wxUSE_GUI
+
+ wxLogSysError( _("Pipe creation failed") );
+ wxLogError( _("Failed to execute '%s'\n"), *argv );
+
+ ARGS_CLEANUP;
+
+ return 0;
+ }
+ }
+
// fork the process
#ifdef HAVE_VFORK
pid_t pid = vfork();
#else
pid_t pid = fork();
#endif
- if (pid == -1)
+
+ if ( pid == -1 ) // error?
{
+#if wxUSE_GUI
+ close(end_proc_detect[0]);
+ close(end_proc_detect[1]);
+ close(pipeIn[0]);
+ close(pipeIn[1]);
+ close(pipeOut[0]);
+ close(pipeOut[1]);
+#endif // wxUSE_GUI
+
wxLogSysError( _("Fork failed") );
ARGS_CLEANUP;
return 0;
}
- else if (pid == 0)
+ else if ( pid == 0 ) // we're in child
{
#if wxUSE_GUI
- // we're in child
close(end_proc_detect[0]); // close reading side
#endif // wxUSE_GUI
- // These three lines close the open file descriptors to to avoid any
+ // These lines close the open file descriptors to to avoid any
// input/output which might block the process or irritate the user. If
- // one wants proper IO for the subprocess, the right thing to do is
- // to start an xterm executing it.
- if (sync == 0)
+ // one wants proper IO for the subprocess, the right thing to do is to
+ // start an xterm executing it.
+ if ( !sync )
{
- // leave stderr opened, it won't do any hurm
for ( int fd = 0; fd < FD_SETSIZE; fd++ )
{
+ if ( fd == pipeIn[0] || fd == pipeOut[1]
#if wxUSE_GUI
- if ( fd == end_proc_detect[1] )
- continue;
+ || fd == end_proc_detect[1]
#endif // wxUSE_GUI
+ )
+ {
+ // don't close this one, we still need it
+ continue;
+ }
+ // leave stderr opened too, it won't do any hurm
if ( fd != STDERR_FILENO )
close(fd);
}
}
-#if 0
- close(STDERR_FILENO);
+ // redirect stdio and stdout
+ // (TODO: what about stderr?)
+ if ( pipeIn[0] != -1 )
+ {
+ if ( dup2(pipeIn[0], STDIN_FILENO) == -1 ||
+ dup2(pipeOut[1], STDOUT_FILENO) == -1 )
+ {
+ wxLogSysError(_("Failed to redirect child process "
+ "input/output"));
+ }
- // some programs complain about stderr not being open, so redirect
- // them:
- open("/dev/null", O_RDONLY); // stdin
- open("/dev/null", O_WRONLY); // stdout
- open("/dev/null", O_WRONLY); // stderr
-#endif
+ close(pipeIn[0]);
+ close(pipeOut[1]);
+ }
execvp (*mb_argv, mb_argv);
// there is no return after successful exec()
- wxFprintf(stderr, _("Can't execute '%s'\n"), *argv);
-
_exit(-1);
}
- else
+ else // we're in parent
{
-#if wxUSE_GUI
- wxEndProcessData *data = new wxEndProcessData;
+ ARGS_CLEANUP;
+ // pipe initialization: construction of the wxStreams
+ if ( process && process->IsRedirected() )
+ {
+ // These two streams are relative to this process.
+ wxOutputStream *outStream = new wxProcessFileOutputStream(pipeIn[1]);
+ wxInputStream *inStream = new wxProcessFileInputStream(pipeOut[0]);
+ close(pipeIn[0]); // close reading side
+ close(pipeOut[1]); // close writing side
- ARGS_CLEANUP;
+ process->SetPipeStreams(inStream, outStream);
+ }
+
+#if wxUSE_GUI
+ wxEndProcessData *data = new wxEndProcessData;
if ( sync )
{
- wxASSERT_MSG( !process, wxT("wxProcess param ignored for sync exec") );
+ // we may have process for capturing the program output, but it's
+ // not used in wxEndProcessData in the case of sync execution
data->process = NULL;
// sync execution: indicate it by negating the pid
data->pid = -pid;
data->tag = wxAddProcessCallback(data, end_proc_detect[0]);
- // we're in parent
+
close(end_proc_detect[1]); // close writing side
+ wxBusyCursor bc;
+ wxWindowDisabler wd;
+
// it will be set to 0 from GTK_EndProcessDetector
while (data->pid != 0)
wxYield();
return exitcode;
}
- else
+ else // async execution
{
// async execution, nothing special to do - caller will be
// notified about the process termination if process != NULL, data
// will be deleted in GTK_EndProcessDetector
- data->process = process;
- data->pid = pid;
- data->tag = wxAddProcessCallback(data, end_proc_detect[0]);
- // we're in parent
+ data->process = process;
+ data->pid = pid;
+ data->tag = wxAddProcessCallback(data, end_proc_detect[0]);
+
close(end_proc_detect[1]); // close writing side
return pid;
return exitcode;
#endif // wxUSE_GUI
}
- return 0;
+
+ return 0;
#undef ARGS_CLEANUP
}
bool wxGetUserName(wxChar *buf, int sz)
{
struct passwd *who;
- char *comma;
*buf = wxT('\0');
- if ((who = getpwuid (getuid ())) != NULL) {
-#ifndef __VMS__
- comma = strchr(who->pw_gecos, ',');
+ if ((who = getpwuid (getuid ())) != NULL)
+ {
+ // pw_gecos field in struct passwd is not standard
+#if 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
+#else // !HAVE_PW_GECOS
wxStrncpy (buf, wxConvertMB2WX(who->pw_name), sz - 1);
-#endif
+#endif // HAVE_PW_GECOS/!HAVE_PW_GECOS
return TRUE;
}
projects / wxWidgets.git / blobdiff