xref: /openbmc/qemu/qga/channel-posix.c (revision 782ee711) 
1 #include "qemu/osdep.h"
2 #include "qemu/cutils.h"
3 #include <termios.h>
4 #include "qapi/error.h"
5 #include "qemu/sockets.h"
6 #include "channel.h"
7 #include "cutils.h"
8 
9 #ifdef CONFIG_SOLARIS
10 #include <stropts.h>
11 #endif
12 
13 #define GA_CHANNEL_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
14 
15 struct GAChannel {
16     GIOChannel *listen_channel;
17     GIOChannel *client_channel;
18     GAChannelMethod method;
19     GAChannelCallback event_cb;
20     gpointer user_data;
21 };
22 
23 static int ga_channel_client_add(GAChannel *c, int fd);
24 
25 static gboolean ga_channel_listen_accept(GIOChannel *channel,
26                                          GIOCondition condition, gpointer data)
27 {
28     GAChannel *c = data;
29     int ret, client_fd;
30     bool accepted = false;
31 
32     g_assert(channel != NULL);
33 
34     client_fd = qemu_accept(g_io_channel_unix_get_fd(channel), NULL, NULL);
35     if (client_fd == -1) {
36         g_warning("error converting fd to gsocket: %s", strerror(errno));
37         goto out;
38     }
39     qemu_socket_set_nonblock(client_fd);
40     ret = ga_channel_client_add(c, client_fd);
41     if (ret) {
42         g_warning("error setting up connection");
43         close(client_fd);
44         goto out;
45     }
46     accepted = true;
47 
48 out:
49     /* only accept 1 connection at a time */
50     return !accepted;
51 }
52 
53 /* start polling for readable events on listen fd, new==true
54  * indicates we should use the existing s->listen_channel
55  */
56 static void ga_channel_listen_add(GAChannel *c, int listen_fd, bool create)
57 {
58     if (create) {
59         c->listen_channel = g_io_channel_unix_new(listen_fd);
60     }
61     g_io_add_watch(c->listen_channel, G_IO_IN, ga_channel_listen_accept, c);
62 }
63 
64 static void ga_channel_listen_close(GAChannel *c)
65 {
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->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,
124                                 GAChannelMethod method, int fd, Error **errp)
125 {
126     int ret;
127     c->method = method;
128 
129     switch (c->method) {
130     case GA_CHANNEL_VIRTIO_SERIAL: {
131         assert(fd < 0);
132         fd = qga_open_cloexec(
133             path,
134 #ifndef CONFIG_SOLARIS
135             O_ASYNC |
136 #endif
137             O_RDWR | O_NONBLOCK,
138             0
139         );
140         if (fd == -1) {
141             error_setg_errno(errp, errno, "error opening channel '%s'", path);
142             return false;
143         }
144 #ifdef CONFIG_SOLARIS
145         ret = ioctl(fd, I_SETSIG, S_OUTPUT | S_INPUT | S_HIPRI);
146         if (ret == -1) {
147             error_setg_errno(errp, errno, "error setting event mask for channel");
148             close(fd);
149             return false;
150         }
151 #endif
152 #ifdef __FreeBSD__
153         /*
154          * In the default state channel sends echo of every command to a
155          * client. The client program doesn't expect this and raises an
156          * error. Suppress echo by resetting ECHO terminal flag.
157          */
158         struct termios tio;
159         if (tcgetattr(fd, &tio) < 0) {
160             error_setg_errno(errp, errno, "error getting channel termios attrs");
161             close(fd);
162             return false;
163         }
164         tio.c_lflag &= ~ECHO;
165         if (tcsetattr(fd, TCSAFLUSH, &tio) < 0) {
166             error_setg_errno(errp, errno, "error setting channel termios attrs");
167             close(fd);
168             return false;
169         }
170 #endif /* __FreeBSD__ */
171         ret = ga_channel_client_add(c, fd);
172         if (ret) {
173             error_setg(errp, "error adding channel to main loop");
174             close(fd);
175             return false;
176         }
177         break;
178     }
179     case GA_CHANNEL_ISA_SERIAL: {
180         struct termios tio;
181 
182         assert(fd < 0);
183         fd = qga_open_cloexec(path, O_RDWR | O_NOCTTY | O_NONBLOCK, 0);
184         if (fd == -1) {
185             error_setg_errno(errp, errno, "error opening channel '%s'", path);
186             return false;
187         }
188         tcgetattr(fd, &tio);
189         /* set up serial port for non-canonical, dumb byte streaming */
190         tio.c_iflag &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
191                          INLCR | IGNCR | ICRNL | IXON | IXOFF | IXANY |
192                          IMAXBEL);
193         tio.c_oflag = 0;
194         tio.c_lflag = 0;
195         tio.c_cflag |= GA_CHANNEL_BAUDRATE_DEFAULT;
196         /* 1 available byte min or reads will block (we'll set non-blocking
197          * elsewhere, else we have to deal with read()=0 instead)
198          */
199         tio.c_cc[VMIN] = 1;
200         tio.c_cc[VTIME] = 0;
201         /* flush everything waiting for read/xmit, it's garbage at this point */
202         tcflush(fd, TCIFLUSH);
203         tcsetattr(fd, TCSANOW, &tio);
204         ret = ga_channel_client_add(c, fd);
205         if (ret) {
206             error_setg(errp, "error adding channel to main loop");
207             close(fd);
208             return false;
209         }
210         break;
211     }
212     case GA_CHANNEL_UNIX_LISTEN: {
213         if (fd < 0) {
214             fd = unix_listen(path, errp);
215             if (fd < 0) {
216                 return false;
217             }
218         }
219         ga_channel_listen_add(c, fd, true);
220         break;
221     }
222     case GA_CHANNEL_VSOCK_LISTEN: {
223         if (fd < 0) {
224             SocketAddress *addr;
225             char *addr_str;
226 
227             addr_str = g_strdup_printf("vsock:%s", path);
228             addr = socket_parse(addr_str, errp);
229             g_free(addr_str);
230             if (!addr) {
231                 return false;
232             }
233 
234             fd = socket_listen(addr, 1, errp);
235             qapi_free_SocketAddress(addr);
236             if (fd < 0) {
237                 return false;
238             }
239         }
240         ga_channel_listen_add(c, fd, true);
241         break;
242     }
243     default:
244         error_setg(errp, "error binding/listening to specified socket");
245         return false;
246     }
247 
248     return true;
249 }
250 
251 GIOStatus ga_channel_write_all(GAChannel *c, const gchar *buf, gsize size)
252 {
253     GError *err = NULL;
254     gsize written = 0;
255     GIOStatus status = G_IO_STATUS_NORMAL;
256 
257     while (size) {
258         g_debug("sending data, count: %d", (int)size);
259         status = g_io_channel_write_chars(c->client_channel, buf, size,
260                                           &written, &err);
261         if (status == G_IO_STATUS_NORMAL) {
262             size -= written;
263             buf += written;
264         } else if (status != G_IO_STATUS_AGAIN) {
265             g_warning("error writing to channel: %s", err->message);
266             return status;
267         }
268     }
269 
270     do {
271         status = g_io_channel_flush(c->client_channel, &err);
272     } while (status == G_IO_STATUS_AGAIN);
273 
274     if (status != G_IO_STATUS_NORMAL) {
275         g_warning("error flushing channel: %s", err->message);
276     }
277 
278     return status;
279 }
280 
281 GIOStatus ga_channel_read(GAChannel *c, gchar *buf, gsize size, gsize *count)
282 {
283     return g_io_channel_read_chars(c->client_channel, buf, size, count, NULL);
284 }
285 
286 GAChannel *ga_channel_new(GAChannelMethod method, const gchar *path,
287                           int listen_fd, GAChannelCallback cb, gpointer opaque)
288 {
289     Error *err = NULL;
290     GAChannel *c = g_new0(GAChannel, 1);
291     c->event_cb = cb;
292     c->user_data = opaque;
293 
294     if (!ga_channel_open(c, path, method, listen_fd, &err)) {
295         g_critical("%s", error_get_pretty(err));
296         error_free(err);
297         ga_channel_free(c);
298         return NULL;
299     }
300 
301     return c;
302 }
303 
304 void ga_channel_free(GAChannel *c)
305 {
306     if (c->listen_channel) {
307         ga_channel_listen_close(c);
308     }
309     if (c->client_channel) {
310         ga_channel_client_close(c);
311     }
312     g_free(c);
313 }
314