memory: Rename queue to mrqueue (memory region queue)
[qemu.git] / chardev / char-udp.c
blob4ee11d3ebf15219d2627dd0fda21ea362f7dec5b
1 /*
2 * QEMU System Emulator
4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include "qemu/osdep.h"
25 #include "chardev/char.h"
26 #include "io/channel-socket.h"
27 #include "qapi/error.h"
29 #include "chardev/char-io.h"
31 /***********************************************************/
32 /* UDP Net console */
34 typedef struct {
35 Chardev parent;
36 QIOChannel *ioc;
37 uint8_t buf[CHR_READ_BUF_LEN];
38 int bufcnt;
39 int bufptr;
40 int max_size;
41 } UdpChardev;
43 #define UDP_CHARDEV(obj) OBJECT_CHECK(UdpChardev, (obj), TYPE_CHARDEV_UDP)
45 /* Called with chr_write_lock held. */
46 static int udp_chr_write(Chardev *chr, const uint8_t *buf, int len)
48 UdpChardev *s = UDP_CHARDEV(chr);
50 return qio_channel_write(
51 s->ioc, (const char *)buf, len, NULL);
54 static void udp_chr_flush_buffer(UdpChardev *s)
56 Chardev *chr = CHARDEV(s);
58 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
59 int n = MIN(s->max_size, s->bufcnt - s->bufptr);
60 qemu_chr_be_write(chr, &s->buf[s->bufptr], n);
61 s->bufptr += n;
62 s->max_size = qemu_chr_be_can_write(chr);
66 static int udp_chr_read_poll(void *opaque)
68 Chardev *chr = CHARDEV(opaque);
69 UdpChardev *s = UDP_CHARDEV(opaque);
71 s->max_size = qemu_chr_be_can_write(chr);
73 /* If there were any stray characters in the queue process them
74 * first
76 udp_chr_flush_buffer(s);
78 return s->max_size;
81 static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
83 Chardev *chr = CHARDEV(opaque);
84 UdpChardev *s = UDP_CHARDEV(opaque);
85 ssize_t ret;
87 if (s->max_size == 0) {
88 return TRUE;
90 ret = qio_channel_read(
91 s->ioc, (char *)s->buf, sizeof(s->buf), NULL);
92 if (ret <= 0) {
93 remove_fd_in_watch(chr);
94 return FALSE;
96 s->bufcnt = ret;
97 s->bufptr = 0;
98 udp_chr_flush_buffer(s);
100 return TRUE;
103 static void udp_chr_update_read_handler(Chardev *chr,
104 GMainContext *context)
106 UdpChardev *s = UDP_CHARDEV(chr);
108 remove_fd_in_watch(chr);
109 if (s->ioc) {
110 chr->gsource = io_add_watch_poll(chr, s->ioc,
111 udp_chr_read_poll,
112 udp_chr_read, chr,
113 context);
117 static void char_udp_finalize(Object *obj)
119 Chardev *chr = CHARDEV(obj);
120 UdpChardev *s = UDP_CHARDEV(obj);
122 remove_fd_in_watch(chr);
123 if (s->ioc) {
124 object_unref(OBJECT(s->ioc));
126 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
129 static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
130 Error **errp)
132 const char *host = qemu_opt_get(opts, "host");
133 const char *port = qemu_opt_get(opts, "port");
134 const char *localaddr = qemu_opt_get(opts, "localaddr");
135 const char *localport = qemu_opt_get(opts, "localport");
136 bool has_local = false;
137 SocketAddressLegacy *addr;
138 ChardevUdp *udp;
140 backend->type = CHARDEV_BACKEND_KIND_UDP;
141 if (host == NULL || strlen(host) == 0) {
142 host = "localhost";
144 if (port == NULL || strlen(port) == 0) {
145 error_setg(errp, "chardev: udp: remote port not specified");
146 return;
148 if (localport == NULL || strlen(localport) == 0) {
149 localport = "0";
150 } else {
151 has_local = true;
153 if (localaddr == NULL || strlen(localaddr) == 0) {
154 localaddr = "";
155 } else {
156 has_local = true;
159 udp = backend->u.udp.data = g_new0(ChardevUdp, 1);
160 qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp));
162 addr = g_new0(SocketAddressLegacy, 1);
163 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
164 addr->u.inet.data = g_new(InetSocketAddress, 1);
165 *addr->u.inet.data = (InetSocketAddress) {
166 .host = g_strdup(host),
167 .port = g_strdup(port),
168 .has_ipv4 = qemu_opt_get(opts, "ipv4"),
169 .ipv4 = qemu_opt_get_bool(opts, "ipv4", 0),
170 .has_ipv6 = qemu_opt_get(opts, "ipv6"),
171 .ipv6 = qemu_opt_get_bool(opts, "ipv6", 0),
173 udp->remote = addr;
175 if (has_local) {
176 udp->has_local = true;
177 addr = g_new0(SocketAddressLegacy, 1);
178 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
179 addr->u.inet.data = g_new(InetSocketAddress, 1);
180 *addr->u.inet.data = (InetSocketAddress) {
181 .host = g_strdup(localaddr),
182 .port = g_strdup(localport),
184 udp->local = addr;
188 static void qmp_chardev_open_udp(Chardev *chr,
189 ChardevBackend *backend,
190 bool *be_opened,
191 Error **errp)
193 ChardevUdp *udp = backend->u.udp.data;
194 SocketAddress *local_addr = socket_address_flatten(udp->local);
195 SocketAddress *remote_addr = socket_address_flatten(udp->remote);
196 QIOChannelSocket *sioc = qio_channel_socket_new();
197 char *name;
198 UdpChardev *s = UDP_CHARDEV(chr);
199 int ret;
201 ret = qio_channel_socket_dgram_sync(sioc, local_addr, remote_addr, errp);
202 qapi_free_SocketAddress(local_addr);
203 qapi_free_SocketAddress(remote_addr);
204 if (ret < 0) {
205 object_unref(OBJECT(sioc));
206 return;
209 name = g_strdup_printf("chardev-udp-%s", chr->label);
210 qio_channel_set_name(QIO_CHANNEL(sioc), name);
211 g_free(name);
213 s->ioc = QIO_CHANNEL(sioc);
214 /* be isn't opened until we get a connection */
215 *be_opened = false;
218 static void char_udp_class_init(ObjectClass *oc, void *data)
220 ChardevClass *cc = CHARDEV_CLASS(oc);
222 cc->parse = qemu_chr_parse_udp;
223 cc->open = qmp_chardev_open_udp;
224 cc->chr_write = udp_chr_write;
225 cc->chr_update_read_handler = udp_chr_update_read_handler;
228 static const TypeInfo char_udp_type_info = {
229 .name = TYPE_CHARDEV_UDP,
230 .parent = TYPE_CHARDEV,
231 .instance_size = sizeof(UdpChardev),
232 .instance_finalize = char_udp_finalize,
233 .class_init = char_udp_class_init,
236 static void register_types(void)
238 type_register_static(&char_udp_type_info);
241 type_init(register_types);