1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "chardev/char.h"
27#include "io/channel-socket.h"
28#include "qapi/error.h"
29#include "qemu/module.h"
30#include "qemu/option.h"
31
32#include "chardev/char-io.h"
33
34
35
36
37typedef struct {
38 Chardev parent;
39 QIOChannel *ioc;
40 uint8_t buf[CHR_READ_BUF_LEN];
41 int bufcnt;
42 int bufptr;
43 int max_size;
44} UdpChardev;
45
46#define UDP_CHARDEV(obj) OBJECT_CHECK(UdpChardev, (obj), TYPE_CHARDEV_UDP)
47
48
49static int udp_chr_write(Chardev *chr, const uint8_t *buf, int len)
50{
51 UdpChardev *s = UDP_CHARDEV(chr);
52
53 return qio_channel_write(
54 s->ioc, (const char *)buf, len, NULL);
55}
56
57static void udp_chr_flush_buffer(UdpChardev *s)
58{
59 Chardev *chr = CHARDEV(s);
60
61 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
62 int n = MIN(s->max_size, s->bufcnt - s->bufptr);
63 qemu_chr_be_write(chr, &s->buf[s->bufptr], n);
64 s->bufptr += n;
65 s->max_size = qemu_chr_be_can_write(chr);
66 }
67}
68
69static int udp_chr_read_poll(void *opaque)
70{
71 Chardev *chr = CHARDEV(opaque);
72 UdpChardev *s = UDP_CHARDEV(opaque);
73
74 s->max_size = qemu_chr_be_can_write(chr);
75
76
77
78
79 udp_chr_flush_buffer(s);
80
81 return s->max_size;
82}
83
84static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
85{
86 Chardev *chr = CHARDEV(opaque);
87 UdpChardev *s = UDP_CHARDEV(opaque);
88 ssize_t ret;
89
90 if (s->max_size == 0) {
91 return TRUE;
92 }
93 ret = qio_channel_read(
94 s->ioc, (char *)s->buf, sizeof(s->buf), NULL);
95 if (ret <= 0) {
96 remove_fd_in_watch(chr);
97 return FALSE;
98 }
99 s->bufcnt = ret;
100 s->bufptr = 0;
101 udp_chr_flush_buffer(s);
102
103 return TRUE;
104}
105
106static void udp_chr_update_read_handler(Chardev *chr)
107{
108 UdpChardev *s = UDP_CHARDEV(chr);
109
110 remove_fd_in_watch(chr);
111 if (s->ioc) {
112 chr->gsource = io_add_watch_poll(chr, s->ioc,
113 udp_chr_read_poll,
114 udp_chr_read, chr,
115 chr->gcontext);
116 }
117}
118
119static void char_udp_finalize(Object *obj)
120{
121 Chardev *chr = CHARDEV(obj);
122 UdpChardev *s = UDP_CHARDEV(obj);
123
124 remove_fd_in_watch(chr);
125 if (s->ioc) {
126 object_unref(OBJECT(s->ioc));
127 }
128 qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
129}
130
131static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
132 Error **errp)
133{
134 const char *host = qemu_opt_get(opts, "host");
135 const char *port = qemu_opt_get(opts, "port");
136 const char *localaddr = qemu_opt_get(opts, "localaddr");
137 const char *localport = qemu_opt_get(opts, "localport");
138 bool has_local = false;
139 SocketAddressLegacy *addr;
140 ChardevUdp *udp;
141
142 backend->type = CHARDEV_BACKEND_KIND_UDP;
143 if (host == NULL || strlen(host) == 0) {
144 host = "localhost";
145 }
146 if (port == NULL || strlen(port) == 0) {
147 error_setg(errp, "chardev: udp: remote port not specified");
148 return;
149 }
150 if (localport == NULL || strlen(localport) == 0) {
151 localport = "0";
152 } else {
153 has_local = true;
154 }
155 if (localaddr == NULL || strlen(localaddr) == 0) {
156 localaddr = "";
157 } else {
158 has_local = true;
159 }
160
161 udp = backend->u.udp.data = g_new0(ChardevUdp, 1);
162 qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp));
163
164 addr = g_new0(SocketAddressLegacy, 1);
165 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
166 addr->u.inet.data = g_new(InetSocketAddress, 1);
167 *addr->u.inet.data = (InetSocketAddress) {
168 .host = g_strdup(host),
169 .port = g_strdup(port),
170 .has_ipv4 = qemu_opt_get(opts, "ipv4"),
171 .ipv4 = qemu_opt_get_bool(opts, "ipv4", 0),
172 .has_ipv6 = qemu_opt_get(opts, "ipv6"),
173 .ipv6 = qemu_opt_get_bool(opts, "ipv6", 0),
174 };
175 udp->remote = addr;
176
177 if (has_local) {
178 udp->has_local = true;
179 addr = g_new0(SocketAddressLegacy, 1);
180 addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
181 addr->u.inet.data = g_new(InetSocketAddress, 1);
182 *addr->u.inet.data = (InetSocketAddress) {
183 .host = g_strdup(localaddr),
184 .port = g_strdup(localport),
185 };
186 udp->local = addr;
187 }
188}
189
190static void qmp_chardev_open_udp(Chardev *chr,
191 ChardevBackend *backend,
192 bool *be_opened,
193 Error **errp)
194{
195 ChardevUdp *udp = backend->u.udp.data;
196 SocketAddress *local_addr = socket_address_flatten(udp->local);
197 SocketAddress *remote_addr = socket_address_flatten(udp->remote);
198 QIOChannelSocket *sioc = qio_channel_socket_new();
199 char *name;
200 UdpChardev *s = UDP_CHARDEV(chr);
201 int ret;
202
203 ret = qio_channel_socket_dgram_sync(sioc, local_addr, remote_addr, errp);
204 qapi_free_SocketAddress(local_addr);
205 qapi_free_SocketAddress(remote_addr);
206 if (ret < 0) {
207 object_unref(OBJECT(sioc));
208 return;
209 }
210
211 name = g_strdup_printf("chardev-udp-%s", chr->label);
212 qio_channel_set_name(QIO_CHANNEL(sioc), name);
213 g_free(name);
214
215 s->ioc = QIO_CHANNEL(sioc);
216
217 *be_opened = false;
218}
219
220static void char_udp_class_init(ObjectClass *oc, void *data)
221{
222 ChardevClass *cc = CHARDEV_CLASS(oc);
223
224 cc->parse = qemu_chr_parse_udp;
225 cc->open = qmp_chardev_open_udp;
226 cc->chr_write = udp_chr_write;
227 cc->chr_update_read_handler = udp_chr_update_read_handler;
228}
229
230static const TypeInfo char_udp_type_info = {
231 .name = TYPE_CHARDEV_UDP,
232 .parent = TYPE_CHARDEV,
233 .instance_size = sizeof(UdpChardev),
234 .instance_finalize = char_udp_finalize,
235 .class_init = char_udp_class_init,
236};
237
238static void register_types(void)
239{
240 type_register_static(&char_udp_type_info);
241}
242
243type_init(register_types);
244
