qga/channel-posix.c

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