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     struct sockaddr_un addr;
  30     socklen_t addrlen = sizeof(addr);
  31
  32     g_assert(channel != NULL);
  33
  34     client_fd = qemu_accept(g_io_channel_unix_get_fd(channel),
  35                             (struct sockaddr *)&addr, &addrlen);
  36     if (client_fd == -1) {
  37         g_warning("error converting fd to gsocket: %s", strerror(errno));
  38         goto out;
  39     }
  40     qemu_set_nonblock(client_fd);
  41     ret = ga_channel_client_add(c, client_fd);
  42     if (ret) {
  43         g_warning("error setting up connection");
  44         close(client_fd);
  45         goto out;
  46     }
  47     accepted = true;
  48
  49 out:
  50     /* only accept 1 connection at a time */
  51     return !accepted;
  52 }
  53
  54 /* start polling for readable events on listen fd, new==true
  55  * indicates we should use the existing s->listen_channel
  56  */
  57 static void ga_channel_listen_add(GAChannel *c, int listen_fd, bool create)
  58 {
  59     if (create) {
  60         c->listen_channel = g_io_channel_unix_new(listen_fd);
  61     }
  62     g_io_add_watch(c->listen_channel, G_IO_IN, ga_channel_listen_accept, c);
  63 }
  64
  65 static void ga_channel_listen_close(GAChannel *c)
  66 {
  67     g_assert(c->method == GA_CHANNEL_UNIX_LISTEN);
  68     g_assert(c->listen_channel);
  69     g_io_channel_shutdown(c->listen_channel, true, NULL);
  70     g_io_channel_unref(c->listen_channel);
  71     c->listen_channel = NULL;
  72 }
  73
  74 /* cleanup state for closed connection/session, start accepting new
  75  * connections if we're in listening mode
  76  */
  77 static void ga_channel_client_close(GAChannel *c)
  78 {
  79     g_assert(c->client_channel);
  80     g_io_channel_shutdown(c->client_channel, true, NULL);
  81     g_io_channel_unref(c->client_channel);
  82     c->client_channel = NULL;
  83     if (c->method == GA_CHANNEL_UNIX_LISTEN && c->listen_channel) {
  84         ga_channel_listen_add(c, 0, false);
  85     }
  86 }
  87
  88 static gboolean ga_channel_client_event(GIOChannel *channel,
  89                                         GIOCondition condition, gpointer data)
  90 {
  91     GAChannel *c = data;
  92     gboolean client_cont;
  93
  94     g_assert(c);
  95     if (c->event_cb) {
  96         client_cont = c->event_cb(condition, c->user_data);
  97         if (!client_cont) {
  98             ga_channel_client_close(c);
  99             return false;
 100         }
 101     }
 102     return true;
 103 }
 104
 105 static int ga_channel_client_add(GAChannel *c, int fd)
 106 {
 107     GIOChannel *client_channel;
 108     GError *err = NULL;
 109
 110     g_assert(c && !c->client_channel);
 111     client_channel = g_io_channel_unix_new(fd);
 112     g_assert(client_channel);
 113     g_io_channel_set_encoding(client_channel, NULL, &err);
 114     if (err != NULL) {
 115         g_warning("error setting channel encoding to binary");
 116         g_error_free(err);
 117         return -1;
 118     }
 119     g_io_add_watch(client_channel, G_IO_IN | G_IO_HUP,
 120                    ga_channel_client_event, c);
 121     c->client_channel = client_channel;
 122     return 0;
 123 }
 124
 125 static gboolean ga_channel_open(GAChannel *c, const gchar *path, GAChannelMethod method)
 126 {
 127     int ret;
 128     c->method = method;
 129
 130     switch (c->method) {
 131     case GA_CHANNEL_VIRTIO_SERIAL: {
 132         int fd = qemu_open(path, O_RDWR | O_NONBLOCK
 133 #ifndef CONFIG_SOLARIS
 134                            | O_ASYNC
 135 #endif
 136                            );
 137         if (fd == -1) {
 138             g_critical("error opening channel: %s", strerror(errno));
 139             return false;
 140         }
 141 #ifdef CONFIG_SOLARIS
 142         ret = ioctl(fd, I_SETSIG, S_OUTPUT | S_INPUT | S_HIPRI);
 143         if (ret == -1) {
 144             g_critical("error setting event mask for channel: %s",
 145                        strerror(errno));
 146             close(fd);
 147             return false;
 148         }
 149 #endif
 150         ret = ga_channel_client_add(c, fd);
 151         if (ret) {
 152             g_critical("error adding channel to main loop");
 153             close(fd);
 154             return false;
 155         }
 156         break;
 157     }
 158     case GA_CHANNEL_ISA_SERIAL: {
 159         struct termios tio;
 160         int 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         Error *local_err = NULL;
 191         int fd = unix_listen(path, NULL, strlen(path), &local_err);
 192         if (local_err != NULL) {
 193             g_critical("%s", error_get_pretty(local_err));
 194             error_free(local_err);
 195             return false;
 196         }
 197         ga_channel_listen_add(c, fd, true);
 198         break;
 199     }
 200     default:
 201         g_critical("error binding/listening to specified socket");
 202         return false;
 203     }
 204
 205     return true;
 206 }
 207
 208 GIOStatus ga_channel_write_all(GAChannel *c, const gchar *buf, gsize size)
 209 {
 210     GError *err = NULL;
 211     gsize written = 0;
 212     GIOStatus status = G_IO_STATUS_NORMAL;
 213
 214     while (size) {
 215         g_debug("sending data, count: %d", (int)size);
 216         status = g_io_channel_write_chars(c->client_channel, buf, size,
 217                                           &written, &err);
 218         if (status == G_IO_STATUS_NORMAL) {
 219             size -= written;
 220             buf += written;
 221         } else if (status != G_IO_STATUS_AGAIN) {
 222             g_warning("error writing to channel: %s", err->message);
 223             return status;
 224         }
 225     }
 226
 227     do {
 228         status = g_io_channel_flush(c->client_channel, &err);
 229     } while (status == G_IO_STATUS_AGAIN);
 230
 231     if (status != G_IO_STATUS_NORMAL) {
 232         g_warning("error flushing channel: %s", err->message);
 233     }
 234
 235     return status;
 236 }
 237
 238 GIOStatus ga_channel_read(GAChannel *c, gchar *buf, gsize size, gsize *count)
 239 {
 240     return g_io_channel_read_chars(c->client_channel, buf, size, count, NULL);
 241 }
 242
 243 GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
 244                           GAChannelCallback cb, gpointer opaque)
 245 {
 246     GAChannel *c = g_new0(GAChannel, 1);
 247     c->event_cb = cb;
 248     c->user_data = opaque;
 249
 250     if (!ga_channel_open(c, path, method)) {
 251         g_critical("error opening channel");
 252         ga_channel_free(c);
 253         return NULL;
 254     }
 255
 256     return c;
 257 }
 258
 259 void ga_channel_free(GAChannel *c)
 260 {
 261     if (c->method == GA_CHANNEL_UNIX_LISTEN
 262         && c->listen_channel) {
 263         ga_channel_listen_close(c);
 264     }
 265     if (c->client_channel) {
 266         ga_channel_client_close(c);
 267     }
 268     g_free(c);
 269 }