1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "qemu/osdep.h"
25#include "chardev/char.h"
26#include "io/channel-socket.h"
27#include "qapi/error.h"
28
29#include "chardev/char-io.h"
30
31
32
33
34typedef 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;
42
43#define UDP_CHARDEV(obj) OBJECT_CHECK(UdpChardev, (obj), TYPE_CHARDEV_UDP)
44
45
46static int udp_chr_write(Chardev *chr, const uint8_t *buf, int len)
47{
48 UdpChardev *s = UDP_CHARDEV(chr);
49
50 return qio_channel_write(
51 s->ioc, (const char *)buf, len, NULL);
52}
53
54static void udp_chr_flush_buffer(UdpChardev *s)
55{
56 Chardev *chr = CHARDEV(s);
57
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);
63 }
64}
65
66static int udp_chr_read_poll(void *opaque)
67{
68 Chardev *chr = CHARDEV(opaque);
69 UdpChardev *s = UDP_CHARDEV(opaque);
70
71 s->max_size = qemu_chr_be_can_write(chr);
72
73
74
75
76 udp_chr_flush_buffer(s);
77
78 return s->max_size;
79}
80
81static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
82{
83 Chardev *chr = CHARDEV(opaque);
84 UdpChardev *s = UDP_CHARDEV(opaque);
85 ssize_t ret;
86
87 if (s->max_size == 0) {
88 return TRUE;
89 }
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;
95 }
96 s->bufcnt = ret;
97 s->bufptr = 0;
98 udp_chr_flush_buffer(s);
99
100 return TRUE;
101}
102
103static void udp_chr_update_read_handler(Chardev *chr,
104 GMainContext *context)
105{
106 UdpChardev *s = UDP_CHARDEV(chr);
107
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);
114 }
115}
116
117static void char_udp_finalize(Object *obj)
118{
119 Chardev *chr = CHARDEV(obj);
120 UdpChardev *s = UDP_CHARDEV(obj);
121
122 remove_fd_in_watch(chr);
123 if (s->ioc) {
124 object_unref(OBJECT(s->ioc));
125 }
126 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
127}
128
129static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
130 Error **errp)
131{
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;
139
140 backend->type = CHARDEV_BACKEND_KIND_UDP;
141 if (host == NULL || strlen(host) == 0) {
142 host = "localhost";
143 }
144 if (port == NULL || strlen(port) == 0) {
145 error_setg(errp, "chardev: udp: remote port not specified");
146 return;
147 }
148 if (localport == NULL || strlen(localport) == 0) {
149 localport = "0";
150 } else {
151 has_local = true;
152 }
153 if (localaddr == NULL || strlen(localaddr) == 0) {
154 localaddr = "";
155 } else {
156 has_local = true;
157 }
158
159 udp = backend->u.udp.data = g_new0(ChardevUdp, 1);
160 qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp));
161
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),
172 };
173 udp->remote = addr;
174
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),
183 };
184 udp->local = addr;
185 }
186}
187
188static void qmp_chardev_open_udp(Chardev *chr,
189 ChardevBackend *backend,
190 bool *be_opened,
191 Error **errp)
192{
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;
200
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;
207 }
208
209 name = g_strdup_printf("chardev-udp-%s", chr->label);
210 qio_channel_set_name(QIO_CHANNEL(sioc), name);
211 g_free(name);
212
213 s->ioc = QIO_CHANNEL(sioc);
214
215 *be_opened = false;
216}
217
218static void char_udp_class_init(ObjectClass *oc, void *data)
219{
220 ChardevClass *cc = CHARDEV_CLASS(oc);
221
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;
226}
227
228static 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,
234};
235
236static void register_types(void)
237{
238 type_register_static(&char_udp_type_info);
239}
240
241type_init(register_types);
242
