1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "qemu/osdep.h"
22#include "io/dns-resolver.h"
23#include "qapi/clone-visitor.h"
24#include "qapi/qapi-visit-sockets.h"
25#include "qemu/sockets.h"
26#include "qapi/error.h"
27#include "qemu/cutils.h"
28
29#ifndef AI_NUMERICSERV
30# define AI_NUMERICSERV 0
31#endif
32
33static QIODNSResolver *instance;
34static GOnce instance_init = G_ONCE_INIT;
35
36static gpointer qio_dns_resolve_init_instance(gpointer unused G_GNUC_UNUSED)
37{
38 instance = QIO_DNS_RESOLVER(object_new(TYPE_QIO_DNS_RESOLVER));
39 return NULL;
40}
41
42QIODNSResolver *qio_dns_resolver_get_instance(void)
43{
44 g_once(&instance_init, qio_dns_resolve_init_instance, NULL);
45 return instance;
46}
47
48static int qio_dns_resolver_lookup_sync_inet(QIODNSResolver *resolver,
49 SocketAddress *addr,
50 size_t *naddrs,
51 SocketAddress ***addrs,
52 Error **errp)
53{
54 struct addrinfo ai, *res, *e;
55 InetSocketAddress *iaddr = &addr->u.inet;
56 char port[33];
57 char uaddr[INET6_ADDRSTRLEN + 1];
58 char uport[33];
59 int rc;
60 Error *err = NULL;
61 size_t i;
62
63 *naddrs = 0;
64 *addrs = NULL;
65
66 memset(&ai, 0, sizeof(ai));
67 ai.ai_flags = AI_PASSIVE;
68 if (iaddr->has_numeric && iaddr->numeric) {
69 ai.ai_flags |= AI_NUMERICHOST | AI_NUMERICSERV;
70 }
71 ai.ai_family = inet_ai_family_from_address(iaddr, &err);
72 ai.ai_socktype = SOCK_STREAM;
73
74 if (err) {
75 error_propagate(errp, err);
76 return -1;
77 }
78
79 if (iaddr->host == NULL) {
80 error_setg(errp, "host not specified");
81 return -1;
82 }
83 if (iaddr->port != NULL) {
84 pstrcpy(port, sizeof(port), iaddr->port);
85 } else {
86 port[0] = '\0';
87 }
88
89 rc = getaddrinfo(strlen(iaddr->host) ? iaddr->host : NULL,
90 strlen(port) ? port : NULL, &ai, &res);
91 if (rc != 0) {
92 error_setg(errp, "address resolution failed for %s:%s: %s",
93 iaddr->host, port, gai_strerror(rc));
94 return -1;
95 }
96
97 for (e = res; e != NULL; e = e->ai_next) {
98 (*naddrs)++;
99 }
100
101 *addrs = g_new0(SocketAddress *, *naddrs);
102
103
104 for (i = 0, e = res; e != NULL; i++, e = e->ai_next) {
105 SocketAddress *newaddr = g_new0(SocketAddress, 1);
106
107 newaddr->type = SOCKET_ADDRESS_TYPE_INET;
108
109 getnameinfo((struct sockaddr *)e->ai_addr, e->ai_addrlen,
110 uaddr, INET6_ADDRSTRLEN, uport, 32,
111 NI_NUMERICHOST | NI_NUMERICSERV);
112
113 newaddr->u.inet = (InetSocketAddress){
114 .host = g_strdup(uaddr),
115 .port = g_strdup(uport),
116 .has_numeric = true,
117 .numeric = true,
118 .has_to = iaddr->has_to,
119 .to = iaddr->to,
120 .has_ipv4 = iaddr->has_ipv4,
121 .ipv4 = iaddr->ipv4,
122 .has_ipv6 = iaddr->has_ipv6,
123 .ipv6 = iaddr->ipv6,
124 };
125
126 (*addrs)[i] = newaddr;
127 }
128 freeaddrinfo(res);
129 return 0;
130}
131
132
133static int qio_dns_resolver_lookup_sync_nop(QIODNSResolver *resolver,
134 SocketAddress *addr,
135 size_t *naddrs,
136 SocketAddress ***addrs,
137 Error **errp)
138{
139 *naddrs = 1;
140 *addrs = g_new0(SocketAddress *, 1);
141 (*addrs)[0] = QAPI_CLONE(SocketAddress, addr);
142
143 return 0;
144}
145
146
147int qio_dns_resolver_lookup_sync(QIODNSResolver *resolver,
148 SocketAddress *addr,
149 size_t *naddrs,
150 SocketAddress ***addrs,
151 Error **errp)
152{
153 switch (addr->type) {
154 case SOCKET_ADDRESS_TYPE_INET:
155 return qio_dns_resolver_lookup_sync_inet(resolver,
156 addr,
157 naddrs,
158 addrs,
159 errp);
160
161 case SOCKET_ADDRESS_TYPE_UNIX:
162 case SOCKET_ADDRESS_TYPE_VSOCK:
163 case SOCKET_ADDRESS_TYPE_FD:
164 return qio_dns_resolver_lookup_sync_nop(resolver,
165 addr,
166 naddrs,
167 addrs,
168 errp);
169
170 default:
171 abort();
172 }
173}
174
175
176struct QIODNSResolverLookupData {
177 SocketAddress *addr;
178 SocketAddress **addrs;
179 size_t naddrs;
180};
181
182
183static void qio_dns_resolver_lookup_data_free(gpointer opaque)
184{
185 struct QIODNSResolverLookupData *data = opaque;
186 size_t i;
187
188 qapi_free_SocketAddress(data->addr);
189 for (i = 0; i < data->naddrs; i++) {
190 qapi_free_SocketAddress(data->addrs[i]);
191 }
192
193 g_free(data->addrs);
194 g_free(data);
195}
196
197
198static void qio_dns_resolver_lookup_worker(QIOTask *task,
199 gpointer opaque)
200{
201 QIODNSResolver *resolver = QIO_DNS_RESOLVER(qio_task_get_source(task));
202 struct QIODNSResolverLookupData *data = opaque;
203 Error *err = NULL;
204
205 qio_dns_resolver_lookup_sync(resolver,
206 data->addr,
207 &data->naddrs,
208 &data->addrs,
209 &err);
210 if (err) {
211 qio_task_set_error(task, err);
212 } else {
213 qio_task_set_result_pointer(task, opaque, NULL);
214 }
215
216 object_unref(OBJECT(resolver));
217}
218
219
220void qio_dns_resolver_lookup_async(QIODNSResolver *resolver,
221 SocketAddress *addr,
222 QIOTaskFunc func,
223 gpointer opaque,
224 GDestroyNotify notify)
225{
226 QIOTask *task;
227 struct QIODNSResolverLookupData *data =
228 g_new0(struct QIODNSResolverLookupData, 1);
229
230 data->addr = QAPI_CLONE(SocketAddress, addr);
231
232 task = qio_task_new(OBJECT(resolver), func, opaque, notify);
233
234 qio_task_run_in_thread(task,
235 qio_dns_resolver_lookup_worker,
236 data,
237 qio_dns_resolver_lookup_data_free,
238 NULL);
239}
240
241
242void qio_dns_resolver_lookup_result(QIODNSResolver *resolver,
243 QIOTask *task,
244 size_t *naddrs,
245 SocketAddress ***addrs)
246{
247 struct QIODNSResolverLookupData *data =
248 qio_task_get_result_pointer(task);
249 size_t i;
250
251 *naddrs = 0;
252 *addrs = NULL;
253 if (!data) {
254 return;
255 }
256
257 *naddrs = data->naddrs;
258 *addrs = g_new0(SocketAddress *, data->naddrs);
259 for (i = 0; i < data->naddrs; i++) {
260 (*addrs)[i] = QAPI_CLONE(SocketAddress, data->addrs[i]);
261 }
262}
263
264
265static const TypeInfo qio_dns_resolver_info = {
266 .parent = TYPE_OBJECT,
267 .name = TYPE_QIO_DNS_RESOLVER,
268 .instance_size = sizeof(QIODNSResolver),
269 .class_size = sizeof(QIODNSResolverClass),
270};
271
272
273static void qio_dns_resolver_register_types(void)
274{
275 type_register_static(&qio_dns_resolver_info);
276}
277
278
279type_init(qio_dns_resolver_register_types);
280
