1 | #include "qemu/osdep.h" |
2 | #include <termios.h> |
3 | #include "qapi/error.h" |
4 | #include "qemu/sockets.h" |
5 | #include "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, 1, &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 | } |
298 | |