qga/channel-posix.c

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