qga/channel-posix.c

   1 #include "qemu/osdep.h"
   2 #include <termios.h>
   3 #include "qapi/error.h"
   4 #include "qemu/sockets.h"
   5 #include "qga/channel.h"
   6
   7 #ifdef CONFIG_SOLARIS
   8 #include <stropts.h>
   9 #endif
  10
  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;
  29
  30     g_assert(channel != NULL);
  31
  32     client_fd = qemu_accept(g_io_channel_unix_get_fd(channel), NULL, NULL);
  33     if (client_fd == -1) {
  34         g_warning("error converting fd to gsocket: %s", strerror(errno));
  35         goto out;
  36     }
  37     qemu_set_nonblock(client_fd);
  38     ret = ga_channel_client_add(c, client_fd);
  39     if (ret) {
  40         g_warning("error setting up connection");
  41         close(client_fd);
  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 {
  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;
  79     if (c->listen_channel) {
  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
 121 static gboolean ga_channel_open(GAChannel *c, const gchar *path,
 122                                 GAChannelMethod method, int fd)
 123 {
 124     int ret;
 125     c->method = method;
 126
 127     switch (c->method) {
 128     case GA_CHANNEL_VIRTIO_SERIAL: {
 129         assert(fd < 0);
 130         fd = qemu_open(path, O_RDWR | O_NONBLOCK
 131 #ifndef CONFIG_SOLARIS
 132                            | O_ASYNC
 133 #endif
 134                            );
 135         if (fd == -1) {
 136             g_critical("error opening channel: %s", strerror(errno));
 137             return false;
 138         }
 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));
 144             close(fd);
 145             return false;
 146         }
 147 #endif
 148         ret = ga_channel_client_add(c, fd);
 149         if (ret) {
 150             g_critical("error adding channel to main loop");
 151             close(fd);
 152             return false;
 153         }
 154         break;
 155     }
 156     case GA_CHANNEL_ISA_SERIAL: {
 157         struct termios tio;
 158
 159         assert(fd < 0);
 160         fd = qemu_open(path, O_RDWR | O_NOCTTY | O_NONBLOCK);
 161         if (fd == -1) {
 162             g_critical("error opening channel: %s", strerror(errno));
 163             return false;
 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) {
 183             g_critical("error adding channel to main loop");
 184             close(fd);
 185             return false;
 186         }
 187         break;
 188     }
 189     case GA_CHANNEL_UNIX_LISTEN: {
 190         if (fd < 0) {
 191             Error *local_err = NULL;
 192
 193             fd = unix_listen(path, &local_err);
 194             if (local_err != NULL) {
 195                 g_critical("%s", error_get_pretty(local_err));
 196                 error_free(local_err);
 197                 return false;
 198             }
 199         }
 200         ga_channel_listen_add(c, fd, true);
 201         break;
 202     }
 203     case GA_CHANNEL_VSOCK_LISTEN: {
 204         if (fd < 0) {
 205             Error *local_err = NULL;
 206             SocketAddress *addr;
 207             char *addr_str;
 208
 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             }
 225         }
 226         ga_channel_listen_add(c, fd, true);
 227         break;
 228     }
 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) {
 244         g_debug("sending data, count: %d", (int)size);
 245         status = g_io_channel_write_chars(c->client_channel, buf, size,
 246                                           &written, &err);
 247         if (status == G_IO_STATUS_NORMAL) {
 248             size -= written;
 249             buf += written;
 250         } else if (status != G_IO_STATUS_AGAIN) {
 251             g_warning("error writing to channel: %s", err->message);
 252             return status;
 253         }
 254     }
 255
 256     do {
 257         status = g_io_channel_flush(c->client_channel, &err);
 258     } while (status == G_IO_STATUS_AGAIN);
 259
 260     if (status != G_IO_STATUS_NORMAL) {
 261         g_warning("error flushing channel: %s", err->message);
 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,
 273                           int listen_fd, GAChannelCallback cb, gpointer opaque)
 274 {
 275     GAChannel *c = g_new0(GAChannel, 1);
 276     c->event_cb = cb;
 277     c->user_data = opaque;
 278
 279     if (!ga_channel_open(c, path, method, listen_fd)) {
 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 {
 290     if (c->listen_channel) {
 291         ga_channel_listen_close(c);
 292     }
 293     if (c->client_channel) {
 294         ga_channel_client_close(c);
 295     }
 296     g_free(c);
 297 }