scsi: esp: check buffer length before reading scsi command
[qemu.git] / 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 }