Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtmail/libDtMail/Common/Process.C

@@ -0,0 +1,275 @@
+/*
+ *+SNOTICE
+ *
+ *
+ *	$TOG: Process.C /main/6 1998/04/06 13:26:21 mgreess $
+ *
+ *	RESTRICTED CONFIDENTIAL INFORMATION:
+ *	
+ *	The information in this document is subject to special
+ *	restrictions in a confidential disclosure agreement bertween
+ *	HP, IBM, Sun, USL, SCO and Univel.  Do not distribute this
+ *	document outside HP, IBM, Sun, USL, SCO, or Univel wihtout
+ *	Sun's specific written approval.  This documment and all copies
+ *	and derivative works thereof must be returned or destroyed at
+ *	Sun's request.
+ *
+ *	Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
+ *
+ *+ENOTICE
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <poll.h>
+
+/*
+** file included for INFTIM
+*/ 
+#if defined(SunOS) || defined(USL) || defined(__uxp__)
+#include <stropts.h>
+#elif defined(HPUX)
+#include <sys/poll.h>
+#elif defined(_AIX) || defined(linux)
+#define INFTIM (-1)             /* Infinite timeout */
+#endif
+
+#include <sys/wait.h>
+
+#include "Process.hh"
+#include <DtMail/Threads.hh>
+#include <DtMail/IO.hh>
+
+static const int DEFAULT_SIZE = 64 << 10;
+
+void
+SetNoBlock(int fd)
+{
+    int flags;
+    do {
+	flags = fcntl(fd, F_GETFL);
+    } while(flags < 0 && errno == EINTR);
+
+    if (flags < 0) {
+	return;
+    }
+
+    flags |= O_NONBLOCK;
+
+    int status;
+    do {
+	status = fcntl(fd, F_SETFL, flags);
+    } while (status < 0 && errno == EINTR);
+
+    return;
+}
+
+int
+RunProg(const char * program,
+	char *const * argv,
+	const char * stdin_data,
+	const unsigned long stdin_size,
+	char ** stdout_data,
+	unsigned long & stdout_size,
+	char ** stderr_data,
+	unsigned long & stderr_size)
+{
+    // See if we are supposed to do I/O with the child.
+    //
+    int stdin_fd[2];
+    int stdout_fd[2];
+    int stderr_fd[2];
+
+    size_t stdout_bufsize = 0;
+    unsigned long stderr_bufsize = 0;
+
+    if (stdin_data) {
+	pipe(stdin_fd);
+	SetNoBlock(stdin_fd[1]);
+    }
+
+    if (stdout_data) {
+	pipe(stdout_fd);
+	SetNoBlock(stdout_fd[0]);
+    }
+
+    if (stderr_data) {
+	pipe(stderr_fd);
+	SetNoBlock(stderr_fd[0]);
+    }
+
+    // We will fork and set up the file descriptors in the
+    // child.
+    //
+
+#if defined(POSIX_THREADS)
+    pid_t child = fork1();
+#else
+    pid_t child = fork();
+#endif
+
+    if (child < 0) {
+	return(child);
+    }
+
+    if (child == 0) { // The real child process.
+	if (stdin_data) {
+	    SafeDup2(stdin_fd[0], STDIN_FILENO);
+	    close(stdin_fd[0]);
+	    close(stdin_fd[1]);
+	}
+
+	if (stdout_data) {
+	    SafeDup2(stdout_fd[1], STDOUT_FILENO);
+	    close(stdout_fd[0]);
+	    close(stdout_fd[1]);
+	}
+
+	if (stderr_data) {
+	    SafeDup2(stderr_fd[1], STDERR_FILENO);
+	    close(stderr_fd[0]);
+	    close(stderr_fd[1]);
+	}
+
+	SafeExecvp(program, argv);
+	return(child);
+    }
+    else { // This is still us.
+
+	int stdin_written = 0;
+
+	int nfds = 1;
+	pollfd fds[3];
+	memset(fds, 0, sizeof(fds));
+
+	fds[0].fd = stdin_fd[1];
+	fds[0].events = POLLOUT;
+	close(stdin_fd[0]);
+
+	if (stdout_data) {
+	    fds[1].fd = stdout_fd[0];
+	    fds[1].events = POLLIN;
+	    nfds = 2;
+	    *stdout_data = (char *)malloc(DEFAULT_SIZE);
+	    stdout_bufsize = DEFAULT_SIZE;
+	    stdout_size = 0;
+	    close(stdout_fd[1]);
+	} else {
+	    fds[1].fd = -1;
+	}
+
+	if (stderr_data) {
+	    fds[2].fd = stderr_fd[0];
+	    fds[2].events = POLLIN;
+	    nfds = 3;
+	    *stderr_data = (char *)malloc(DEFAULT_SIZE);
+	    stderr_bufsize = DEFAULT_SIZE;
+	    stderr_size = 0;
+	    close(stderr_fd[1]);
+	} else {
+	    fds[2].fd = -1;
+	}
+
+	// set up the initial events we way we care about.  Note that
+	// fds[1] and fds[2] may not be used -- nfds may be less than 3
+
+
+	while (1) {
+	    int result;
+	    int i;
+
+	    // check to make sure there is really some work to do
+	    // walk through the fds structure.  If we get to the end
+	    // without finding anything to do, i will be == nfds
+	    for (i = 0; i < nfds; i++) {
+		if (fds[i].fd >= 0) break;
+	    }
+	    if (i == nfds) {
+		// there was no work to do
+		break;
+	    }
+
+
+	    // we probably don't want to wait forever, so we can try
+	    // and reap the child here, just in case it exits...
+	    result = poll(fds, nfds, INFTIM);
+
+	    if (result < 0) {
+		// poll error -- what do we do?
+		if (errno == EINTR) continue;
+
+		// not much else to do -- poll really shouldn't fail...
+		break;
+	    }
+
+	    if ((fds[0].revents & POLLOUT) &&
+		stdin_data && stdin_written < stdin_size) {
+		int status = SafeWrite(stdin_fd[1], stdin_data + stdin_written,
+				       (size_t) stdin_size - stdin_written);
+		if (status > 0) {
+		    stdin_written += status;
+		}
+
+		if (stdin_written >= stdin_size) {
+		    // we're done with the input
+		    close(stdin_fd[1]);
+		    fds[0].fd = -1;
+		    fds[0].events = 0;
+		}
+	    }
+
+	    // We will now try to read 4K from each requested file
+	    // descriptor.
+	    //
+	    if (stdout_data && (fds[1].revents & POLLIN)) {
+		int status = SafeRead(stdout_fd[0], *stdout_data + stdout_size,
+				      4096);
+
+		if (status < 0 && errno != EAGAIN) {
+		    break;
+		}
+
+		if (status > 0) {
+		    stdout_size += status;
+		    if ((stdout_size + 4096) > stdout_bufsize) {
+			stdout_bufsize += DEFAULT_SIZE;
+			*stdout_data = (char *)realloc(*stdout_data, stdout_bufsize);
+		    }
+		}
+	    }
+
+	    if (stderr_data && (fds[2].revents & POLLIN)) {
+		int status = SafeRead(stderr_fd[0], *stderr_data + stderr_size,
+				      4096);
+
+		if (status < 0 && errno != EAGAIN) {
+		    break;
+		}
+
+		if (status > 0) {
+		    stderr_size += status;
+		}
+
+		if ((stderr_size + 4096) > stderr_bufsize) {
+		    stderr_bufsize += DEFAULT_SIZE;
+		    *stderr_data =
+		      (char*) realloc(*stderr_data, (size_t) stderr_bufsize);
+		}
+	    }
+
+	    if ((fds[0].revents & POLLHUP) ||
+		(fds[1].revents & POLLHUP) ||
+		(fds[2].revents & POLLHUP)) {
+		break;
+	    }
+	}
+
+	int child_stat;
+	SafeWaitpid(child, &child_stat, 0);
+	return(child_stat);
+    }
+    return(child);
+}