aboutsummaryrefslogtreecommitdiffstats
path: root/camel/camel-stream-process.c
diff options
context:
space:
mode:
authorDavid Woodhouse <dwmw2@infradead.org>2003-09-04 06:41:40 +0800
committerDavid Woodhouse <dwmw2@src.gnome.org>2003-09-04 06:41:40 +0800
commit1e1baedfa5183785dbc37e79a360a83d1f7e38d5 (patch)
tree5f80601ffed63529adb3c8ce3ba9e558b22e4e52 /camel/camel-stream-process.c
parent1d5176dbe5bb48f45e8cb9339b66d35e5df65554 (diff)
downloadgsoc2013-evolution-1e1baedfa5183785dbc37e79a360a83d1f7e38d5.tar.gz
gsoc2013-evolution-1e1baedfa5183785dbc37e79a360a83d1f7e38d5.tar.zst
gsoc2013-evolution-1e1baedfa5183785dbc37e79a360a83d1f7e38d5.zip
New stream implementation for running commands. Compile the above
2003-09-03 David Woodhouse <dwmw2@infradead.org> * camel-stream-process.[ch]: New stream implementation for running commands. * Makefile.am: Compile the above svn path=/trunk/; revision=22454
Diffstat (limited to 'camel/camel-stream-process.c')
-rw-r--r--camel/camel-stream-process.c268
1 files changed, 268 insertions, 0 deletions
diff --git a/camel/camel-stream-process.c b/camel/camel-stream-process.c
new file mode 100644
index 0000000000..2038d29efc
--- /dev/null
+++ b/camel/camel-stream-process.c
@@ -0,0 +1,268 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; fill-column: 160 -*- */
+/* camel-stream-process.c : stream over piped process */
+
+/*
+ * Copyright (C) 2003 Ximian Inc.
+ *
+ * Authors: David Woodhouse <dwmw2@infradead.org>,
+ * Jeffrey Stedfast <fejj@ximian.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "camel-stream-process.h"
+#include "camel-file-utils.h"
+
+extern int camel_verbose_debug;
+
+static CamelObjectClass *parent_class = NULL;
+
+/* Returns the class for a CamelStream */
+#define CS_CLASS(so) CAMEL_STREAM_PROCESS_CLASS(CAMEL_OBJECT_GET_CLASS(so))
+
+/* dummy implementations, for a PROCESS stream */
+static ssize_t stream_read (CamelStream *stream, char *buffer, size_t n);
+static ssize_t stream_write (CamelStream *stream, const char *buffer, size_t n);
+static int stream_close (CamelStream *stream);
+static int stream_flush (CamelStream *stream);
+
+static void
+camel_stream_process_finalise (CamelObject *object)
+{
+ /* Ensure we clean up after ourselves -- kill
+ the child process and reap it. */
+ stream_close(CAMEL_STREAM (object));
+}
+
+static void
+camel_stream_process_class_init (CamelStreamProcessClass *camel_stream_process_class)
+{
+ CamelStreamClass *camel_stream_class = (CamelStreamClass *)camel_stream_process_class;
+
+ parent_class = camel_type_get_global_classfuncs( CAMEL_OBJECT_TYPE );
+
+ /* virtual method definition */
+ camel_stream_class->read = stream_read;
+ camel_stream_class->write = stream_write;
+ camel_stream_class->close = stream_close;
+ camel_stream_class->flush = stream_flush;
+}
+
+static void
+camel_stream_process_init (gpointer object, gpointer klass)
+{
+ CamelStreamProcess *stream = CAMEL_STREAM_PROCESS (object);
+
+ stream->sockfd = -1;
+ stream->childpid = 0;
+}
+
+
+CamelType
+camel_stream_process_get_type (void)
+{
+ static CamelType camel_stream_process_type = CAMEL_INVALID_TYPE;
+
+ if (camel_stream_process_type == CAMEL_INVALID_TYPE) {
+ camel_stream_process_type =
+ camel_type_register( camel_stream_get_type(),
+ "CamelStreamProcess",
+ sizeof( CamelStreamProcess ),
+ sizeof( CamelStreamProcessClass ),
+ (CamelObjectClassInitFunc) camel_stream_process_class_init,
+ NULL,
+ (CamelObjectInitFunc) camel_stream_process_init,
+ (CamelObjectFinalizeFunc) camel_stream_process_finalise);
+ }
+
+ return camel_stream_process_type;
+}
+
+/**
+ * camel_stream_process_new:
+ *
+ * Returns a PROCESS stream.
+ *
+ * Return value: the stream
+ **/
+CamelStream *
+camel_stream_process_new(void)
+{
+ return (CamelStream *)camel_object_new(camel_stream_process_get_type ());
+}
+
+
+static ssize_t
+stream_read (CamelStream *stream, char *buffer, size_t n)
+{
+ CamelStreamProcess *stream_process = CAMEL_STREAM_PROCESS (stream);
+
+ return camel_read(stream_process->sockfd, buffer, n);
+}
+
+static ssize_t
+stream_write (CamelStream *stream, const char *buffer, size_t n)
+{
+ CamelStreamProcess *stream_process = CAMEL_STREAM_PROCESS (stream);
+
+ return camel_write(stream_process->sockfd, buffer, n);
+}
+
+static int
+stream_flush (CamelStream *stream)
+{
+ return 0;
+}
+
+static int
+stream_close (CamelStream *object)
+{
+ CamelStreamProcess *stream = CAMEL_STREAM_PROCESS (object);
+ if (camel_verbose_debug)
+ fprintf(stderr, "Process stream close. sockfd %d, childpid %d\n",
+ stream->sockfd, stream->childpid);
+
+ if (stream->sockfd != -1) {
+ close(stream->sockfd);
+ stream->sockfd = -1;
+ }
+ if (stream->childpid) {
+ int ret, i;
+ for (i=0; i<4; i++) {
+ ret = waitpid(stream->childpid, NULL, WNOHANG);
+ if (camel_verbose_debug)
+ fprintf(stderr, "waitpid() for pid %d returned %d (errno %d)\n",
+ stream->childpid, ret, ret==-1?errno:0);
+ if (ret == stream->childpid || errno == ECHILD)
+ break;
+ switch(i) {
+ case 0:
+ if (camel_verbose_debug)
+ fprintf(stderr, "Sending SIGTERM to pid %d\n",
+ stream->childpid);
+ kill(stream->childpid, SIGTERM);
+ break;
+ case 2:
+ if (camel_verbose_debug)
+ fprintf(stderr, "Sending SIGKILL to pid %d\n",
+ stream->childpid);
+ kill(stream->childpid, SIGKILL);
+ break;
+ case 1:
+ case 3:
+ sleep(1);
+ break;
+ }
+ }
+ stream->childpid = 0;
+ }
+ return 0;
+}
+
+static void do_exec_command(int fd, const char *command, char **env)
+{
+ int i, maxopen;
+
+ /* Not a lot we can do if there's an error other than bail. */
+ if (dup2(fd, 0) == -1)
+ exit(1);
+ if (dup2(fd, 1) == -1)
+ exit(1);
+
+ /* What to do with stderr? Possibly put it through a separate pipe
+ and bring up a dialog box with its output if anything does get
+ spewed to it? It'd help the user understand what was going wrong
+ with their command, but it's hard to do cleanly. For now we just
+ leave it as it is. Perhaps we should close it and reopen /dev/null? */
+
+ maxopen = sysconf(_SC_OPEN_MAX);
+ for (i=3; i < maxopen; i++)
+ close(i);
+
+ setsid();
+#ifdef TIOCNOTTY
+ /* Detach from the controlling tty if we have one. Otherwise,
+ SSH might do something stupid like trying to use it instead
+ of running $SSH_ASKPASS. Doh. */
+ fd = open("/dev/tty", O_RDONLY);
+ if (fd != -1) {
+ ioctl(fd, TIOCNOTTY, NULL);
+ close(fd);
+ }
+#endif /* TIOCNOTTY */
+
+ /* Set up child's environment. We _add_ to it, don't use execle,
+ because otherwise we'd destroy stuff like SSH_AUTH_SOCK etc. */
+ for (; env && *env; env++) {
+ char *eq = strchr(*env, '=');
+ if (!eq) {
+ unsetenv(*env);
+ continue;
+ }
+ *eq = 0;
+ eq++;
+ setenv(*env, eq, 1);
+ }
+
+ execl("/bin/sh", "/bin/sh", "-c", command, NULL);
+
+ if (camel_verbose_debug)
+ fprintf(stderr, "exec failed %d\n", errno);
+ exit(1);
+}
+
+int
+camel_stream_process_connect(CamelStreamProcess *stream, const char *command, const char **env)
+{
+ int sockfds[2];
+
+ if (stream->sockfd != -1 || stream->childpid) {
+ stream_close(CAMEL_STREAM (stream));
+ }
+
+ if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfds))
+ return -1;
+
+ stream->childpid = fork();
+ if (!stream->childpid) {
+ do_exec_command(sockfds[1], command, (char **)env);
+ } else if (stream->childpid == -1) {
+ close(sockfds[0]);
+ close(sockfds[1]);
+ stream->sockfd = -1;
+ return -1;
+ }
+
+ close(sockfds[1]);
+ stream->sockfd = sockfds[0];
+
+ return 0;
+}