[qemu.git] / qga / channel-posix.c

#include "qemu/osdep.h"
#include <termios.h>
#include "qapi/error.h"
#include "qemu/sockets.h"
#include "channel.h"

#ifdef CONFIG_SOLARIS
#include <stropts.h>
#endif

#define GA_CHANNEL_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */

struct GAChannel {
    GIOChannel *listen_channel;
    GIOChannel *client_channel;
    GAChannelMethod method;
    GAChannelCallback event_cb;
    gpointer user_data;
};

static int ga_channel_client_add(GAChannel *c, int fd);

static gboolean ga_channel_listen_accept(GIOChannel *channel,
                                         GIOCondition condition, gpointer data)
{
    GAChannel *c = data;
    int ret, client_fd;
    bool accepted = false;

    g_assert(channel != NULL);

    client_fd = qemu_accept(g_io_channel_unix_get_fd(channel), NULL, NULL);
    if (client_fd == -1) {
        g_warning("error converting fd to gsocket: %s", strerror(errno));
        goto out;
    }
    qemu_set_nonblock(client_fd);
    ret = ga_channel_client_add(c, client_fd);
    if (ret) {
        g_warning("error setting up connection");
        close(client_fd);
        goto out;
    }
    accepted = true;

out:
    /* only accept 1 connection at a time */
    return !accepted;
}

/* start polling for readable events on listen fd, new==true
 * indicates we should use the existing s->listen_channel
 */
static void ga_channel_listen_add(GAChannel *c, int listen_fd, bool create)
{
    if (create) {
        c->listen_channel = g_io_channel_unix_new(listen_fd);
    }
    g_io_add_watch(c->listen_channel, G_IO_IN, ga_channel_listen_accept, c);
}

static void ga_channel_listen_close(GAChannel *c)
{
    g_assert(c->listen_channel);
    g_io_channel_shutdown(c->listen_channel, true, NULL);
    g_io_channel_unref(c->listen_channel);
    c->listen_channel = NULL;
}

/* cleanup state for closed connection/session, start accepting new
 * connections if we're in listening mode
 */
static void ga_channel_client_close(GAChannel *c)
{
    g_assert(c->client_channel);
    g_io_channel_shutdown(c->client_channel, true, NULL);
    g_io_channel_unref(c->client_channel);
    c->client_channel = NULL;
    if (c->listen_channel) {
        ga_channel_listen_add(c, 0, false);
    }
}

static gboolean ga_channel_client_event(GIOChannel *channel,
                                        GIOCondition condition, gpointer data)
{
    GAChannel *c = data;
    gboolean client_cont;

    g_assert(c);
    if (c->event_cb) {
        client_cont = c->event_cb(condition, c->user_data);
        if (!client_cont) {
            ga_channel_client_close(c);
            return false;
        }
    }
    return true;
}

static int ga_channel_client_add(GAChannel *c, int fd)
{
    GIOChannel *client_channel;
    GError *err = NULL;

    g_assert(c && !c->client_channel);
    client_channel = g_io_channel_unix_new(fd);
    g_assert(client_channel);
    g_io_channel_set_encoding(client_channel, NULL, &err);
    if (err != NULL) {
        g_warning("error setting channel encoding to binary");
        g_error_free(err);
        return -1;
    }
    g_io_add_watch(client_channel, G_IO_IN | G_IO_HUP,
                   ga_channel_client_event, c);
    c->client_channel = client_channel;
    return 0;
}

static gboolean ga_channel_open(GAChannel *c, const gchar *path,
                                GAChannelMethod method, int fd)
{
    int ret;
    c->method = method;

    switch (c->method) {
    case GA_CHANNEL_VIRTIO_SERIAL: {
        assert(fd < 0);
        fd = qemu_open(path, O_RDWR | O_NONBLOCK
#ifndef CONFIG_SOLARIS
                           | O_ASYNC
#endif
                           );
        if (fd == -1) {
            g_critical("error opening channel: %s", strerror(errno));
            return false;
        }
#ifdef CONFIG_SOLARIS
        ret = ioctl(fd, I_SETSIG, S_OUTPUT | S_INPUT | S_HIPRI);
        if (ret == -1) {
            g_critical("error setting event mask for channel: %s",
                       strerror(errno));
            close(fd);
            return false;
        }
#endif
        ret = ga_channel_client_add(c, fd);
        if (ret) {
            g_critical("error adding channel to main loop");
            close(fd);
            return false;
        }
        break;
    }
    case GA_CHANNEL_ISA_SERIAL: {
        struct termios tio;

        assert(fd < 0);
        fd = qemu_open(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
        if (fd == -1) {
            g_critical("error opening channel: %s", strerror(errno));
            return false;
        }
        tcgetattr(fd, &tio);
        /* set up serial port for non-canonical, dumb byte streaming */
        tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
                         INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
                         IMAXBEL);
        tio.c_oflag = 0;
        tio.c_lflag = 0;
        tio.c_cflag |= GA_CHANNEL_BAUDRATE_DEFAULT;
        /* 1 available byte min or reads will block (we'll set non-blocking
         * elsewhere, else we have to deal with read()=0 instead)
         */
        tio.c_cc[VMIN] = 1;
        tio.c_cc[VTIME] = 0;
        /* flush everything waiting for read/xmit, it's garbage at this point */
        tcflush(fd, TCIFLUSH);
        tcsetattr(fd, TCSANOW, &tio);
        ret = ga_channel_client_add(c, fd);
        if (ret) {
            g_critical("error adding channel to main loop");
            close(fd);
            return false;
        }
        break;
    }
    case GA_CHANNEL_UNIX_LISTEN: {
        if (fd < 0) {
            Error *local_err = NULL;

            fd = unix_listen(path, &local_err);
            if (local_err != NULL) {
                g_critical("%s", error_get_pretty(local_err));
                error_free(local_err);
                return false;
            }
        }
        ga_channel_listen_add(c, fd, true);
        break;
    }
    case GA_CHANNEL_VSOCK_LISTEN: {
        if (fd < 0) {
            Error *local_err = NULL;
            SocketAddress *addr;
            char *addr_str;

            addr_str = g_strdup_printf("vsock:%s", path);
            addr = socket_parse(addr_str, &local_err);
            g_free(addr_str);
            if (local_err != NULL) {
                g_critical("%s", error_get_pretty(local_err));
                error_free(local_err);
                return false;
            }

            fd = socket_listen(addr, &local_err);
            qapi_free_SocketAddress(addr);
            if (local_err != NULL) {
                g_critical("%s", error_get_pretty(local_err));
                error_free(local_err);
                return false;
            }
        }
        ga_channel_listen_add(c, fd, true);
        break;
    }
    default:
        g_critical("error binding/listening to specified socket");
        return false;
    }

    return true;
}

GIOStatus ga_channel_write_all(GAChannel *c, const gchar *buf, gsize size)
{
    GError *err = NULL;
    gsize written = 0;
    GIOStatus status = G_IO_STATUS_NORMAL;

    while (size) {
        g_debug("sending data, count: %d", (int)size);
        status = g_io_channel_write_chars(c->client_channel, buf, size,
                                          &written, &err);
        if (status == G_IO_STATUS_NORMAL) {
            size -= written;
            buf += written;
        } else if (status != G_IO_STATUS_AGAIN) {
            g_warning("error writing to channel: %s", err->message);
            return status;
        }
    }

    do {
        status = g_io_channel_flush(c->client_channel, &err);
    } while (status == G_IO_STATUS_AGAIN);

    if (status != G_IO_STATUS_NORMAL) {
        g_warning("error flushing channel: %s", err->message);
    }

    return status;
}

GIOStatus ga_channel_read(GAChannel *c, gchar *buf, gsize size, gsize *count)
{
    return g_io_channel_read_chars(c->client_channel, buf, size, count, NULL);
}

GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
                          int listen_fd, GAChannelCallback cb, gpointer opaque)
{
    GAChannel *c = g_new0(GAChannel, 1);
    c->event_cb = cb;
    c->user_data = opaque;

    if (!ga_channel_open(c, path, method, listen_fd)) {
        g_critical("error opening channel");
        ga_channel_free(c);
        return NULL;
    }

    return c;
}

void ga_channel_free(GAChannel *c)
{
    if (c->listen_channel) {
        ga_channel_listen_close(c);
    }
    if (c->client_channel) {
        ga_channel_client_close(c);
    }
    g_free(c);
}
Commit	Line	Data
4459bf38	1	#include "qemu/osdep.h"
125b310e	2	#include <termios.h>
da34e65c	3	#include "qapi/error.h"
1de7afc9	4	#include "qemu/sockets.h"
dc03272d	5	#include "channel.h"
125b310e	6
e61ab1da AF	7	#ifdef CONFIG_SOLARIS
	8	#include <stropts.h>
	9	#endif
	10
125b310e MR	11	#define GA_CHANNEL_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
	12
	13	struct GAChannel {
	14	GIOChannel *listen_channel;
	15	GIOChannel *client_channel;
	16	GAChannelMethod method;
	17	GAChannelCallback event_cb;
	18	gpointer user_data;
	19	};
	20
	21	static int ga_channel_client_add(GAChannel *c, int fd);
	22
	23	static gboolean ga_channel_listen_accept(GIOChannel *channel,
	24	GIOCondition condition, gpointer data)
	25	{
	26	GAChannel *c = data;
	27	int ret, client_fd;
	28	bool accepted = false;
125b310e MR	29
	30	g_assert(channel != NULL);
	31
b8093d38	32	client_fd = qemu_accept(g_io_channel_unix_get_fd(channel), NULL, NULL);
125b310e MR	33	if (client_fd == -1) {
	34	g_warning("error converting fd to gsocket: %s", strerror(errno));
	35	goto out;
	36	}
16b38080	37	qemu_set_nonblock(client_fd);
125b310e MR	38	ret = ga_channel_client_add(c, client_fd);
	39	if (ret) {
	40	g_warning("error setting up connection");
32c16620	41	close(client_fd);
125b310e MR	42	goto out;
	43	}
	44	accepted = true;
	45
	46	out:
	47	/* only accept 1 connection at a time */
	48	return !accepted;
	49	}
	50
	51	/* start polling for readable events on listen fd, new==true
	52	* indicates we should use the existing s->listen_channel
	53	*/
	54	static void ga_channel_listen_add(GAChannel *c, int listen_fd, bool create)
	55	{
	56	if (create) {
	57	c->listen_channel = g_io_channel_unix_new(listen_fd);
	58	}
	59	g_io_add_watch(c->listen_channel, G_IO_IN, ga_channel_listen_accept, c);
	60	}
	61
	62	static void ga_channel_listen_close(GAChannel *c)
	63	{
125b310e MR	64	g_assert(c->listen_channel);
	65	g_io_channel_shutdown(c->listen_channel, true, NULL);
	66	g_io_channel_unref(c->listen_channel);
	67	c->listen_channel = NULL;
	68	}
	69
	70	/* cleanup state for closed connection/session, start accepting new
	71	* connections if we're in listening mode
	72	*/
	73	static void ga_channel_client_close(GAChannel *c)
	74	{
	75	g_assert(c->client_channel);
	76	g_io_channel_shutdown(c->client_channel, true, NULL);
	77	g_io_channel_unref(c->client_channel);
	78	c->client_channel = NULL;
f06b2031	79	if (c->listen_channel) {
125b310e MR	80	ga_channel_listen_add(c, 0, false);
	81	}
	82	}
	83
	84	static gboolean ga_channel_client_event(GIOChannel *channel,
	85	GIOCondition condition, gpointer data)
	86	{
	87	GAChannel *c = data;
	88	gboolean client_cont;
	89
	90	g_assert(c);
	91	if (c->event_cb) {
	92	client_cont = c->event_cb(condition, c->user_data);
	93	if (!client_cont) {
	94	ga_channel_client_close(c);
	95	return false;
	96	}
	97	}
	98	return true;
	99	}
	100
	101	static int ga_channel_client_add(GAChannel *c, int fd)
	102	{
	103	GIOChannel *client_channel;
	104	GError *err = NULL;
	105
	106	g_assert(c && !c->client_channel);
	107	client_channel = g_io_channel_unix_new(fd);
	108	g_assert(client_channel);
	109	g_io_channel_set_encoding(client_channel, NULL, &err);
	110	if (err != NULL) {
	111	g_warning("error setting channel encoding to binary");
	112	g_error_free(err);
	113	return -1;
	114	}
	115	g_io_add_watch(client_channel, G_IO_IN \| G_IO_HUP,
	116	ga_channel_client_event, c);
	117	c->client_channel = client_channel;
	118	return 0;
	119	}
	120
26de2296 SH	121	static gboolean ga_channel_open(GAChannel c, const gchar path,
26de2296 SH	122	GAChannelMethod method, int fd)
125b310e MR	123	{
	124	int ret;
	125	c->method = method;
	126
	127	switch (c->method) {
	128	case GA_CHANNEL_VIRTIO_SERIAL: {
26de2296 SH	129	assert(fd < 0);
26de2296 SH	130	fd = qemu_open(path, O_RDWR \| O_NONBLOCK
e61ab1da AF	131	#ifndef CONFIG_SOLARIS
	132	\| O_ASYNC
	133	#endif
	134	);
125b310e MR	135	if (fd == -1) {
125b310e MR	136	g_critical("error opening channel: %s", strerror(errno));
7868181f	137	return false;
125b310e	138	}
e61ab1da AF	139	#ifdef CONFIG_SOLARIS
	140	ret = ioctl(fd, I_SETSIG, S_OUTPUT \| S_INPUT \| S_HIPRI);
	141	if (ret == -1) {
	142	g_critical("error setting event mask for channel: %s",
	143	strerror(errno));
7868181f MA	144	close(fd);
7868181f MA	145	return false;
e61ab1da AF	146	}
e61ab1da AF	147	#endif
125b310e MR	148	ret = ga_channel_client_add(c, fd);
	149	if (ret) {
	150	g_critical("error adding channel to main loop");
d4f4a3ef	151	close(fd);
125b310e MR	152	return false;
	153	}
	154	break;
	155	}
	156	case GA_CHANNEL_ISA_SERIAL: {
	157	struct termios tio;
26de2296 SH	158
	159	assert(fd < 0);
	160	fd = qemu_open(path, O_RDWR \| O_NOCTTY \| O_NONBLOCK);
125b310e MR	161	if (fd == -1) {
125b310e MR	162	g_critical("error opening channel: %s", strerror(errno));
7868181f	163	return false;
125b310e MR	164	}
	165	tcgetattr(fd, &tio);
	166	/* set up serial port for non-canonical, dumb byte streaming */
	167	tio.c_iflag &= ~(IGNBRK \| BRKINT \| IGNPAR \| PARMRK \| INPCK \| ISTRIP \|
	168	INLCR \| IGNCR \| ICRNL \| IXON \| IXOFF \| IXANY \|
	169	IMAXBEL);
	170	tio.c_oflag = 0;
	171	tio.c_lflag = 0;
	172	tio.c_cflag \|= GA_CHANNEL_BAUDRATE_DEFAULT;
	173	/* 1 available byte min or reads will block (we'll set non-blocking
	174	* elsewhere, else we have to deal with read()=0 instead)
	175	*/
	176	tio.c_cc[VMIN] = 1;
	177	tio.c_cc[VTIME] = 0;
	178	/* flush everything waiting for read/xmit, it's garbage at this point */
	179	tcflush(fd, TCIFLUSH);
	180	tcsetattr(fd, TCSANOW, &tio);
	181	ret = ga_channel_client_add(c, fd);
	182	if (ret) {
7868181f MA	183	g_critical("error adding channel to main loop");
	184	close(fd);
	185	return false;
125b310e MR	186	}
	187	break;
	188	}
	189	case GA_CHANNEL_UNIX_LISTEN: {
26de2296 SH	190	if (fd < 0) {
	191	Error *local_err = NULL;
	192
62473511	193	fd = unix_listen(path, &local_err);
26de2296 SH	194	if (local_err != NULL) {
	195	g_critical("%s", error_get_pretty(local_err));
	196	error_free(local_err);
	197	return false;
	198	}
125b310e MR	199	}
	200	ga_channel_listen_add(c, fd, true);
	201	break;
	202	}
586ef5de	203	case GA_CHANNEL_VSOCK_LISTEN: {
26de2296 SH	204	if (fd < 0) {
	205	Error *local_err = NULL;
	206	SocketAddress *addr;
	207	char *addr_str;
586ef5de	208
26de2296 SH	209	addr_str = g_strdup_printf("vsock:%s", path);
	210	addr = socket_parse(addr_str, &local_err);
	211	g_free(addr_str);
	212	if (local_err != NULL) {
	213	g_critical("%s", error_get_pretty(local_err));
	214	error_free(local_err);
	215	return false;
	216	}
	217
	218	fd = socket_listen(addr, &local_err);
	219	qapi_free_SocketAddress(addr);
	220	if (local_err != NULL) {
	221	g_critical("%s", error_get_pretty(local_err));
	222	error_free(local_err);
	223	return false;
	224	}
586ef5de SH	225	}
	226	ga_channel_listen_add(c, fd, true);
	227	break;
	228	}
125b310e MR	229	default:
	230	g_critical("error binding/listening to specified socket");
	231	return false;
	232	}
	233
	234	return true;
	235	}
	236
	237	GIOStatus ga_channel_write_all(GAChannel c, const gchar buf, gsize size)
	238	{
	239	GError *err = NULL;
	240	gsize written = 0;
	241	GIOStatus status = G_IO_STATUS_NORMAL;
	242
	243	while (size) {
f74df9bf	244	g_debug("sending data, count: %d", (int)size);
125b310e MR	245	status = g_io_channel_write_chars(c->client_channel, buf, size,
125b310e MR	246	&written, &err);
f74df9bf YP	247	if (status == G_IO_STATUS_NORMAL) {
	248	size -= written;
	249	buf += written;
	250	} else if (status != G_IO_STATUS_AGAIN) {
125b310e	251	g_warning("error writing to channel: %s", err->message);
f74df9bf	252	return status;
125b310e	253	}
125b310e MR	254	}
125b310e MR	255
f74df9bf	256	do {
125b310e	257	status = g_io_channel_flush(c->client_channel, &err);
f74df9bf YP	258	} while (status == G_IO_STATUS_AGAIN);
	259
	260	if (status != G_IO_STATUS_NORMAL) {
	261	g_warning("error flushing channel: %s", err->message);
125b310e MR	262	}
	263
	264	return status;
	265	}
	266
	267	GIOStatus ga_channel_read(GAChannel c, gchar buf, gsize size, gsize *count)
	268	{
	269	return g_io_channel_read_chars(c->client_channel, buf, size, count, NULL);
	270	}
	271
	272	GAChannel ga_channel_new(GAChannelMethod method, const gchar path,
26de2296	273	int listen_fd, GAChannelCallback cb, gpointer opaque)
125b310e	274	{
f3a06403	275	GAChannel *c = g_new0(GAChannel, 1);
125b310e MR	276	c->event_cb = cb;
	277	c->user_data = opaque;
	278
26de2296	279	if (!ga_channel_open(c, path, method, listen_fd)) {
125b310e MR	280	g_critical("error opening channel");
	281	ga_channel_free(c);
	282	return NULL;
	283	}
	284
	285	return c;
	286	}
	287
	288	void ga_channel_free(GAChannel *c)
	289	{
f06b2031	290	if (c->listen_channel) {
125b310e MR	291	ga_channel_listen_close(c);
	292	}
	293	if (c->client_channel) {
	294	ga_channel_client_close(c);
	295	}
	296	g_free(c);
	297	}