nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
medit/moo/mooterm/mootermvt-unix.c

531 lines
14 KiB
C
Raw Blame History

/*
* mooterm/mootermvt-unix.c
*
* Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* See COPYING file that comes with this distribution.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "mooterm/mootermvt.h"
#include "mooterm/pty.h"
#include "mooutils/moomarshals.h"
#include "mooutils/moocompat.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#ifdef HAVE_POLL_H
#include <poll.h>
#elif HAVE_SYS_POLL_H
#include <sys/poll.h>
#endif
#define READ_CHILD_OUT_PRIORITY G_PRIORITY_HIGH_IDLE
#define TERM_EMULATION "xterm"
#define READ_BUFSIZE 2048
#define POLL_TIME 5
#define POLL_NUM 1
#define MOO_TERM_VT_UNIX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MOO_TYPE_TERM_VT_UNIX, MooTermVtUnix))
#define MOO_TERM_VT_UNIX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_TERM_VT_UNIX, MooTermVtUnixClass))
#define MOO_IS_TERM_VT_UNIX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MOO_TYPE_TERM_VT_UNIX))
#define MOO_IS_TERM_VT_UNIX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_TERM_VT_UNIX))
#define MOO_TERM_VT_UNIX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_TERM_VT_UNIX, MooTermVtUnixClass))
typedef struct _MooTermVtUnix MooTermVtUnix;
typedef struct _MooTermVtUnixClass MooTermVtUnixClass;
struct _MooTermVtUnix {
MooTermVt parent;
gboolean child_alive;
GPid child_pid;
int master;
int width;
int height;
gboolean non_block;
GIOChannel *io;
guint io_watch_id;
};
struct _MooTermVtUnixClass {
MooTermVtClass parent_class;
};
static void moo_term_vt_unix_finalize (GObject *object);
static void set_size (MooTermVt *vt,
gulong width,
gulong height);
static gboolean fork_command (MooTermVt *vt,
const char *cmd,
const char *working_dir,
char **envp);
static void feed_child (MooTermVt *vt,
const char *string,
gssize len);
static void kill_child (MooTermVt *vt);
static gboolean read_child_out (GIOChannel *source,
GIOCondition condition,
MooTermVtUnix *vt);
static void feed_parent (MooTermVtUnix *vt,
const char *string,
gssize len);
/* MOO_TYPE_TERM_VT_UNIX */
G_DEFINE_TYPE (MooTermVtUnix, moo_term_vt_unix, MOO_TYPE_TERM_VT)
static void moo_term_vt_unix_class_init (MooTermVtUnixClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
MooTermVtClass *vt_class = MOO_TERM_VT_CLASS (klass);
gobject_class->finalize = moo_term_vt_unix_finalize;
vt_class->set_size = set_size;
vt_class->fork_command = fork_command;
vt_class->feed_child = feed_child;
vt_class->kill_child = kill_child;
}
static void moo_term_vt_unix_init (MooTermVtUnix *vt)
{
vt->child_alive = FALSE;
vt->child_pid = (GPid)-1;
vt->master = -1;
vt->width = 80;
vt->height = 24;
vt->non_block = FALSE;
vt->io = NULL;
vt->io_watch_id = 0;
}
static void moo_term_vt_unix_finalize (GObject *object)
{
MooTermVtUnix *vt = MOO_TERM_VT_UNIX (object);
kill_child (MOO_TERM_VT (vt));
G_OBJECT_CLASS (moo_term_vt_unix_parent_class)->finalize (object);
}
static void set_size (MooTermVt *vt,
gulong width,
gulong height)
{
MooTermVtUnix *vtu;
g_return_if_fail (MOO_IS_TERM_VT_UNIX (vt));
vtu = MOO_TERM_VT_UNIX (vt);
if (vtu->child_alive)
_vte_pty_set_size (vtu->master, width, height);
vtu->width = width;
vtu->height = height;
}
static gboolean fork_command (MooTermVt *vt_gen,
const char *cmd,
const char *working_dir,
char **envp)
{
MooTermVtUnix *vt;
int argv_len;
char **argv = NULL;
int env_len = 0;
char **new_env;
GError *err = NULL;
int status, flags;
int i;
GSource *src;
g_return_val_if_fail (cmd != NULL, FALSE);
g_return_val_if_fail (MOO_IS_TERM_VT_UNIX (vt_gen), FALSE);
vt = MOO_TERM_VT_UNIX (vt_gen);
g_return_val_if_fail (!vt->child_alive, FALSE);
if (!g_shell_parse_argv (cmd, &argv_len, &argv, &err))
{
g_critical ("%s: could not parse command line", G_STRLOC);
if (err != NULL)
{
g_critical ("%s: %s", G_STRLOC, err->message);
g_error_free (err);
}
if (argv != NULL)
g_strfreev (argv);
return FALSE;
}
if (envp)
{
char **e;
for (e = envp; *e != NULL; ++e)
++env_len;
}
new_env = g_new (char*, env_len + 2);
for (i = 0; i < env_len; ++i)
new_env[i] = g_strdup (envp[i]);
new_env[env_len] = g_strdup ("TERM=" TERM_EMULATION);
new_env[env_len + 1] = NULL;
vt->master = _vte_pty_open (&vt->child_pid, new_env,
argv[0],
argv,
working_dir,
vt->width, vt->height,
FALSE, FALSE, FALSE);
g_strfreev (new_env);
if (vt->master == -1)
{
g_critical ("%s: could not fork child", G_STRLOC);
return FALSE;
}
else
{
g_message ("%s: forked child pid %d", G_STRLOC, vt->child_pid);
}
if (waitpid (-1, &status, WNOHANG) == -1)
g_critical ("%s: error in waitpid", G_STRLOC);
if ((flags = fcntl (vt->master, F_GETFL)) < 0)
g_critical ("%s: F_GETFL on master", G_STRLOC);
else if (-1 == fcntl (vt->master, F_SETFL, O_NONBLOCK | flags))
g_critical ("%s: F_SETFL on master", G_STRLOC);
else
vt->non_block = TRUE;
vt->io = g_io_channel_unix_new (vt->master);
g_return_val_if_fail (vt->io != NULL, FALSE);
g_io_channel_set_encoding (vt->io, NULL, NULL);
g_io_channel_set_buffered (vt->io, FALSE);
vt->io_watch_id = g_io_add_watch (vt->io,
G_IO_IN | G_IO_PRI | G_IO_HUP,
(GIOFunc) read_child_out,
vt);
src = g_main_context_find_source_by_id (NULL, vt->io_watch_id);
if (src)
g_source_set_priority (src, READ_CHILD_OUT_PRIORITY);
else
g_warning ("%s: could not find io_watch_id source", G_STRLOC);
vt->child_alive = TRUE;
return TRUE;
}
static void kill_child (MooTermVt *vt_gen)
{
MooTermVtUnix *vt = MOO_TERM_VT_UNIX (vt_gen);
if (vt->io_watch_id)
{
g_source_remove (vt->io_watch_id);
vt->io_watch_id = 0;
}
if (vt->io)
{
feed_child (MOO_TERM_VT (vt), "\4", 1);
g_io_channel_shutdown (vt->io, TRUE, NULL);
g_io_channel_unref (vt->io);
vt->io = NULL;
}
if (vt->master != -1)
{
_vte_pty_close (vt->master);
vt->master = -1;
}
vt->non_block = FALSE;
vt->child_pid = (GPid)-1;
if (vt->child_alive)
{
vt->child_alive = FALSE;
g_signal_emit_by_name (vt, "child-died");
}
}
static gboolean read_child_out (G_GNUC_UNUSED GIOChannel *source,
GIOCondition condition,
MooTermVtUnix *vt)
{
gboolean error_occured = FALSE;
int error_no = 0;
char buf[READ_BUFSIZE];
int current = 0;
guint again = POLL_NUM;
if (condition & G_IO_HUP)
{
g_message ("%s: G_IO_HUP", G_STRLOC);
error_no = errno;
goto error;
}
else if (condition & G_IO_ERR)
{
g_message ("%s: G_IO_ERR", G_STRLOC);
error_no = errno;
goto error;
}
g_assert (condition & (G_IO_IN | G_IO_PRI));
if (vt->non_block)
{
int r = read (vt->master, buf, READ_BUFSIZE);
switch (r)
{
case -1:
error_occured = TRUE;
error_no = errno;
goto error;
case 0:
break;
default:
feed_parent (vt, buf, r);
break;
}
return TRUE;
}
while (again && !error_occured && current < READ_BUFSIZE)
{
struct pollfd fd = {vt->master, POLLIN | POLLPRI, 0};
int res = poll (&fd, 1, POLL_TIME);
switch (res)
{
case 0:
--again;
break;
case 1:
if (fd.revents & (POLLNVAL | POLLERR | POLLHUP))
{
again = 0;
if (errno != EAGAIN && errno != EINTR)
{
error_occured = TRUE;
error_no = errno;
}
}
else if (fd.revents & (POLLIN | POLLPRI))
{
int r = read (vt->master, buf + current, 1);
switch (r)
{
case -1:
error_occured = TRUE;
error_no = errno;
break;
case 0:
--again;
break;
case 1:
++current;
break;
default:
g_assert_not_reached();
}
}
break;
case -1:
again = 0;
if (errno != EAGAIN && errno != EINTR)
{
error_occured = TRUE;
error_no = errno;
}
break;
default:
g_assert_not_reached();
}
}
if (current > 0)
feed_parent (vt, buf, current);
if (error_occured)
goto error;
return TRUE;
error:
if (error_occured)
g_message ("error in %s", G_STRLOC);
if (error_no)
g_message ("%s: %s", G_STRLOC, g_strerror (error_no));
if (vt->io)
{
_vte_pty_close (vt->master);
vt->master = -1;
g_io_channel_shutdown (vt->io, TRUE, NULL);
g_io_channel_unref (vt->io);
vt->io = NULL;
vt->io_watch_id = 0;
}
kill_child (MOO_TERM_VT (vt));
return FALSE;
}
static void feed_parent (MooTermVtUnix *vt,
const char *string,
gssize len)
{
moo_term_buffer_feed (moo_term_vt_get_buffer (MOO_TERM_VT (vt)),
string, len);
}
#define CHUNK_SIZE 1024
static void feed_child (MooTermVt *vt_gen,
const char *string,
gssize len)
{
guint total_written = 0;
GError *err = NULL;
guint eagain_count = 0;
MooTermVtUnix *vt = MOO_TERM_VT_UNIX (vt_gen);
g_return_if_fail (vt->io != NULL);
if (len < 0)
len = strlen (string);
while (total_written < (guint)len)
{
gsize written = 0;
GIOStatus status;
status = g_io_channel_write_chars (vt->io, string + total_written,
MIN (len - total_written, CHUNK_SIZE),
&written, &err);
if (err)
{
g_critical ("%s: %s", G_STRLOC, err->message);
g_error_free (err);
break;
}
if (status != G_IO_STATUS_NORMAL)
{
gboolean stop = FALSE;
switch (status)
{
case G_IO_STATUS_ERROR:
g_critical ("%s: g_io_channel_write_chars returned G_IO_STATUS_ERROR", G_STRLOC);
stop = TRUE;
break;
case G_IO_STATUS_EOF:
g_critical ("%s: g_io_channel_write_chars returned G_IO_STATUS_EOF", G_STRLOC);
stop = TRUE;
break;
case G_IO_STATUS_AGAIN:
++eagain_count;
if (eagain_count > 2)
{
g_critical ("%s: g_io_channel_write_chars returned G_IO_STATUS_AGAIN 2 times", G_STRLOC);
stop = TRUE;
}
else
{
g_usleep (10000);
}
break;
default:
g_assert_not_reached ();
}
if (stop)
break;
}
else if (written <= 0)
{
g_critical ("%s: error in g_io_channel_write_chars", G_STRLOC);
break;
}
total_written += written;
}
}
Reference in New Issue View Git Blame Copy Permalink