Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-6.0-pull-request' into...
[qemu/ar7.git] / chardev / char-udp.c
blob16b5dbce5824327f649fd2a7a9890a93d3bf7402
1 /*
2  * QEMU System Emulator
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  *
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:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
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.
23  */
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"
32 #include "chardev/char-io.h"
33 #include "qom/object.h"
35 /***********************************************************/
36 /* UDP Net console */
38 struct UdpChardev {
39     Chardev parent;
40     QIOChannel *ioc;
41     uint8_t buf[CHR_READ_BUF_LEN];
42     int bufcnt;
43     int bufptr;
44     int max_size;
46 typedef struct UdpChardev UdpChardev;
48 DECLARE_INSTANCE_CHECKER(UdpChardev, UDP_CHARDEV,
49                          TYPE_CHARDEV_UDP)
51 /* Called with chr_write_lock held.  */
52 static int udp_chr_write(Chardev *chr, const uint8_t *buf, int len)
54     UdpChardev *s = UDP_CHARDEV(chr);
56     return qio_channel_write(
57         s->ioc, (const char *)buf, len, NULL);
60 static void udp_chr_flush_buffer(UdpChardev *s)
62     Chardev *chr = CHARDEV(s);
64     while (s->max_size > 0 && s->bufptr < s->bufcnt) {
65         int n = MIN(s->max_size, s->bufcnt - s->bufptr);
66         qemu_chr_be_write(chr, &s->buf[s->bufptr], n);
67         s->bufptr += n;
68         s->max_size = qemu_chr_be_can_write(chr);
69     }
72 static int udp_chr_read_poll(void *opaque)
74     Chardev *chr = CHARDEV(opaque);
75     UdpChardev *s = UDP_CHARDEV(opaque);
77     s->max_size = qemu_chr_be_can_write(chr);
79     /* If there were any stray characters in the queue process them
80      * first
81      */
82     udp_chr_flush_buffer(s);
84     return s->max_size;
87 static gboolean udp_chr_read(QIOChannel *chan, GIOCondition cond, void *opaque)
89     Chardev *chr = CHARDEV(opaque);
90     UdpChardev *s = UDP_CHARDEV(opaque);
91     ssize_t ret;
93     if (s->max_size == 0) {
94         return TRUE;
95     }
96     ret = qio_channel_read(
97         s->ioc, (char *)s->buf, sizeof(s->buf), NULL);
98     if (ret <= 0) {
99         remove_fd_in_watch(chr);
100         return FALSE;
101     }
102     s->bufcnt = ret;
103     s->bufptr = 0;
104     udp_chr_flush_buffer(s);
106     return TRUE;
109 static void udp_chr_update_read_handler(Chardev *chr)
111     UdpChardev *s = UDP_CHARDEV(chr);
113     remove_fd_in_watch(chr);
114     if (s->ioc) {
115         chr->gsource = io_add_watch_poll(chr, s->ioc,
116                                            udp_chr_read_poll,
117                                            udp_chr_read, chr,
118                                            chr->gcontext);
119     }
122 static void char_udp_finalize(Object *obj)
124     Chardev *chr = CHARDEV(obj);
125     UdpChardev *s = UDP_CHARDEV(obj);
127     remove_fd_in_watch(chr);
128     if (s->ioc) {
129         object_unref(OBJECT(s->ioc));
130     }
131     qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
134 static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
135                                Error **errp)
137     const char *host = qemu_opt_get(opts, "host");
138     const char *port = qemu_opt_get(opts, "port");
139     const char *localaddr = qemu_opt_get(opts, "localaddr");
140     const char *localport = qemu_opt_get(opts, "localport");
141     bool has_local = false;
142     SocketAddressLegacy *addr;
143     ChardevUdp *udp;
145     backend->type = CHARDEV_BACKEND_KIND_UDP;
146     if (host == NULL || strlen(host) == 0) {
147         host = "localhost";
148     }
149     if (port == NULL || strlen(port) == 0) {
150         error_setg(errp, "chardev: udp: remote port not specified");
151         return;
152     }
153     if (localport == NULL || strlen(localport) == 0) {
154         localport = "0";
155     } else {
156         has_local = true;
157     }
158     if (localaddr == NULL || strlen(localaddr) == 0) {
159         localaddr = "";
160     } else {
161         has_local = true;
162     }
164     udp = backend->u.udp.data = g_new0(ChardevUdp, 1);
165     qemu_chr_parse_common(opts, qapi_ChardevUdp_base(udp));
167     addr = g_new0(SocketAddressLegacy, 1);
168     addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
169     addr->u.inet.data = g_new(InetSocketAddress, 1);
170     *addr->u.inet.data = (InetSocketAddress) {
171         .host = g_strdup(host),
172         .port = g_strdup(port),
173         .has_ipv4 = qemu_opt_get(opts, "ipv4"),
174         .ipv4 = qemu_opt_get_bool(opts, "ipv4", 0),
175         .has_ipv6 = qemu_opt_get(opts, "ipv6"),
176         .ipv6 = qemu_opt_get_bool(opts, "ipv6", 0),
177     };
178     udp->remote = addr;
180     if (has_local) {
181         udp->has_local = true;
182         addr = g_new0(SocketAddressLegacy, 1);
183         addr->type = SOCKET_ADDRESS_LEGACY_KIND_INET;
184         addr->u.inet.data = g_new(InetSocketAddress, 1);
185         *addr->u.inet.data = (InetSocketAddress) {
186             .host = g_strdup(localaddr),
187             .port = g_strdup(localport),
188         };
189         udp->local = addr;
190     }
193 static void qmp_chardev_open_udp(Chardev *chr,
194                                  ChardevBackend *backend,
195                                  bool *be_opened,
196                                  Error **errp)
198     ChardevUdp *udp = backend->u.udp.data;
199     SocketAddress *local_addr = socket_address_flatten(udp->local);
200     SocketAddress *remote_addr = socket_address_flatten(udp->remote);
201     QIOChannelSocket *sioc = qio_channel_socket_new();
202     char *name;
203     UdpChardev *s = UDP_CHARDEV(chr);
204     int ret;
206     ret = qio_channel_socket_dgram_sync(sioc, local_addr, remote_addr, errp);
207     qapi_free_SocketAddress(local_addr);
208     qapi_free_SocketAddress(remote_addr);
209     if (ret < 0) {
210         object_unref(OBJECT(sioc));
211         return;
212     }
214     name = g_strdup_printf("chardev-udp-%s", chr->label);
215     qio_channel_set_name(QIO_CHANNEL(sioc), name);
216     g_free(name);
218     s->ioc = QIO_CHANNEL(sioc);
219     /* be isn't opened until we get a connection */
220     *be_opened = false;
223 static void char_udp_class_init(ObjectClass *oc, void *data)
225     ChardevClass *cc = CHARDEV_CLASS(oc);
227     cc->parse = qemu_chr_parse_udp;
228     cc->open = qmp_chardev_open_udp;
229     cc->chr_write = udp_chr_write;
230     cc->chr_update_read_handler = udp_chr_update_read_handler;
233 static const TypeInfo char_udp_type_info = {
234     .name = TYPE_CHARDEV_UDP,
235     .parent = TYPE_CHARDEV,
236     .instance_size = sizeof(UdpChardev),
237     .instance_finalize = char_udp_finalize,
238     .class_init = char_udp_class_init,
241 static void register_types(void)
243     type_register_static(&char_udp_type_info);
246 type_init(register_types);