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