?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added Scottish Gaelic translation
[glib.git] / gio / gthreadedresolver.c
blob2ba42f1726fa53cde1587782b64cc359a685441e
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2
3 /* GIO - GLib Input, Output and Streaming Library
4 *
5 * Copyright (C) 2008 Red Hat, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "config.h"
22 #include <glib.h>
23 #include "glibintl.h"
24
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "gthreadedresolver.h"
29 #include "gnetworkingprivate.h"
30
31 #include "gcancellable.h"
32 #include "ginetaddress.h"
33 #include "ginetsocketaddress.h"
34 #include "gtask.h"
35 #include "gsocketaddress.h"
36 #include "gsrvtarget.h"
37
38
39 G_DEFINE_TYPE (GThreadedResolver, g_threaded_resolver, G_TYPE_RESOLVER)
40
41 static void
42 g_threaded_resolver_init (GThreadedResolver *gtr)
43 {
44 }
45
46 static GResolverError
47 g_resolver_error_from_addrinfo_error (gint err)
48 {
49 switch (err)
50 {
51 case EAI_FAIL:
52 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
53 case EAI_NODATA:
54 #endif
55 case EAI_NONAME:
56 return G_RESOLVER_ERROR_NOT_FOUND;
57
58 case EAI_AGAIN:
59 return G_RESOLVER_ERROR_TEMPORARY_FAILURE;
60
61 default:
62 return G_RESOLVER_ERROR_INTERNAL;
63 }
64 }
65
66 static struct addrinfo addrinfo_hints;
67
68 static void
69 do_lookup_by_name (GTask *task,
70 gpointer source_object,
71 gpointer task_data,
72 GCancellable *cancellable)
73 {
74 const char *hostname = task_data;
75 struct addrinfo *res = NULL;
76 GList *addresses;
77 gint retval;
78
79 retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res);
80
81 if (retval == 0)
82 {
83 struct addrinfo *ai;
84 GSocketAddress *sockaddr;
85 GInetAddress *addr;
86
87 addresses = NULL;
88 for (ai = res; ai; ai = ai->ai_next)
89 {
90 sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen);
91 if (!sockaddr)
92 continue;
93 if (!G_IS_INET_SOCKET_ADDRESS (sockaddr))
94 {
95 g_clear_object (&sockaddr);
96 continue;
97 }
98
99 addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr));
100 addresses = g_list_prepend (addresses, addr);
101 g_object_unref (sockaddr);
102 }
103
104 if (addresses != NULL)
105 {
106 addresses = g_list_reverse (addresses);
107 g_task_return_pointer (task, addresses,
108 (GDestroyNotify)g_resolver_free_addresses);
109 }
110 else
111 {
112 /* All addresses failed to be converted to GSocketAddresses. */
113 g_task_return_new_error (task,
114 G_RESOLVER_ERROR,
115 G_RESOLVER_ERROR_NOT_FOUND,
116 _("Error resolving '%s': %s"),
117 hostname,
118 _("No valid addresses were found"));
119 }
120 }
121 else
122 {
123 g_task_return_new_error (task,
124 G_RESOLVER_ERROR,
125 g_resolver_error_from_addrinfo_error (retval),
126 _("Error resolving '%s': %s"),
127 hostname, gai_strerror (retval));
128 }
129
130 if (res)
131 freeaddrinfo (res);
132 }
133
134 static GList *
135 lookup_by_name (GResolver *resolver,
136 const gchar *hostname,
137 GCancellable *cancellable,
138 GError **error)
139 {
140 GTask *task;
141 GList *addresses;
142
143 task = g_task_new (resolver, cancellable, NULL, NULL);
144 g_task_set_task_data (task, g_strdup (hostname), g_free);
145 g_task_set_return_on_cancel (task, TRUE);
146 g_task_run_in_thread_sync (task, do_lookup_by_name);
147 addresses = g_task_propagate_pointer (task, error);
148 g_object_unref (task);
149
150 return addresses;
151 }
152
153 static void
154 lookup_by_name_async (GResolver *resolver,
155 const gchar *hostname,
156 GCancellable *cancellable,
157 GAsyncReadyCallback callback,
158 gpointer user_data)
159 {
160 GTask *task;
161
162 task = g_task_new (resolver, cancellable, callback, user_data);
163 g_task_set_task_data (task, g_strdup (hostname), g_free);
164 g_task_set_return_on_cancel (task, TRUE);
165 g_task_run_in_thread (task, do_lookup_by_name);
166 g_object_unref (task);
167 }
168
169 static GList *
170 lookup_by_name_finish (GResolver *resolver,
171 GAsyncResult *result,
172 GError **error)
173 {
174 g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
175
176 return g_task_propagate_pointer (G_TASK (result), error);
177 }
178
179
180 static void
181 do_lookup_by_address (GTask *task,
182 gpointer source_object,
183 gpointer task_data,
184 GCancellable *cancellable)
185 {
186 GInetAddress *address = task_data;
187 struct sockaddr_storage sockaddr;
188 gsize sockaddr_size;
189 GSocketAddress *gsockaddr;
190 gchar name[NI_MAXHOST];
191 gint retval;
192
193 gsockaddr = g_inet_socket_address_new (address, 0);
194 g_socket_address_to_native (gsockaddr, (struct sockaddr *)&sockaddr,
195 sizeof (sockaddr), NULL);
196 sockaddr_size = g_socket_address_get_native_size (gsockaddr);
197 g_object_unref (gsockaddr);
198
199 retval = getnameinfo ((struct sockaddr *)&sockaddr, sockaddr_size,
200 name, sizeof (name), NULL, 0, NI_NAMEREQD);
201 if (retval == 0)
202 g_task_return_pointer (task, g_strdup (name), g_free);
203 else
204 {
205 gchar *phys;
206
207 phys = g_inet_address_to_string (address);
208 g_task_return_new_error (task,
209 G_RESOLVER_ERROR,
210 g_resolver_error_from_addrinfo_error (retval),
211 _("Error reverse-resolving '%s': %s"),
212 phys ? phys : "(unknown)",
213 gai_strerror (retval));
214 g_free (phys);
215 }
216 }
217
218 static gchar *
219 lookup_by_address (GResolver *resolver,
220 GInetAddress *address,
221 GCancellable *cancellable,
222 GError **error)
223 {
224 GTask *task;
225 gchar *name;
226
227 task = g_task_new (resolver, cancellable, NULL, NULL);
228 g_task_set_task_data (task, g_object_ref (address), g_object_unref);
229 g_task_set_return_on_cancel (task, TRUE);
230 g_task_run_in_thread_sync (task, do_lookup_by_address);
231 name = g_task_propagate_pointer (task, error);
232 g_object_unref (task);
233
234 return name;
235 }
236
237 static void
238 lookup_by_address_async (GResolver *resolver,
239 GInetAddress *address,
240 GCancellable *cancellable,
241 GAsyncReadyCallback callback,
242 gpointer user_data)
243 {
244 GTask *task;
245
246 task = g_task_new (resolver, cancellable, callback, user_data);
247 g_task_set_task_data (task, g_object_ref (address), g_object_unref);
248 g_task_set_return_on_cancel (task, TRUE);
249 g_task_run_in_thread (task, do_lookup_by_address);
250 g_object_unref (task);
251 }
252
253 static gchar *
254 lookup_by_address_finish (GResolver *resolver,
255 GAsyncResult *result,
256 GError **error)
257 {
258 g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
259
260 return g_task_propagate_pointer (G_TASK (result), error);
261 }
262
263
264 #if defined(G_OS_UNIX)
265
266 #if defined __BIONIC__ && !defined BIND_4_COMPAT
267 /* Copy from bionic/libc/private/arpa_nameser_compat.h
268 * and bionic/libc/private/arpa_nameser.h */
269 typedef struct {
270 unsigned id :16; /* query identification number */
271 #if BYTE_ORDER == BIG_ENDIAN
272 /* fields in third byte */
273 unsigned qr: 1; /* response flag */
274 unsigned opcode: 4; /* purpose of message */
275 unsigned aa: 1; /* authoritive answer */
276 unsigned tc: 1; /* truncated message */
277 unsigned rd: 1; /* recursion desired */
278 /* fields in fourth byte */
279 unsigned ra: 1; /* recursion available */
280 unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */
281 unsigned ad: 1; /* authentic data from named */
282 unsigned cd: 1; /* checking disabled by resolver */
283 unsigned rcode :4; /* response code */
284 #endif
285 #if BYTE_ORDER == LITTLE_ENDIAN || BYTE_ORDER == PDP_ENDIAN
286 /* fields in third byte */
287 unsigned rd :1; /* recursion desired */
288 unsigned tc :1; /* truncated message */
289 unsigned aa :1; /* authoritive answer */
290 unsigned opcode :4; /* purpose of message */
291 unsigned qr :1; /* response flag */
292 /* fields in fourth byte */
293 unsigned rcode :4; /* response code */
294 unsigned cd: 1; /* checking disabled by resolver */
295 unsigned ad: 1; /* authentic data from named */
296 unsigned unused :1; /* unused bits (MBZ as of 4.9.3a3) */
297 unsigned ra :1; /* recursion available */
298 #endif
299 /* remaining bytes */
300 unsigned qdcount :16; /* number of question entries */
301 unsigned ancount :16; /* number of answer entries */
302 unsigned nscount :16; /* number of authority entries */
303 unsigned arcount :16; /* number of resource entries */
304 } HEADER;
305
306 #define NS_INT32SZ 4 /* #/bytes of data in a uint32_t */
307 #define NS_INT16SZ 2 /* #/bytes of data in a uint16_t */
308
309 #define NS_GET16(s, cp) do { \
310 const u_char *t_cp = (const u_char *)(cp); \
311 (s) = ((uint16_t)t_cp[0] << 8) \
312 | ((uint16_t)t_cp[1]) \
313 ; \
314 (cp) += NS_INT16SZ; \
315 } while (/*CONSTCOND*/0)
316
317 #define NS_GET32(l, cp) do { \
318 const u_char *t_cp = (const u_char *)(cp); \
319 (l) = ((uint32_t)t_cp[0] << 24) \
320 | ((uint32_t)t_cp[1] << 16) \
321 | ((uint32_t)t_cp[2] << 8) \
322 | ((uint32_t)t_cp[3]) \
323 ; \
324 (cp) += NS_INT32SZ; \
325 } while (/*CONSTCOND*/0)
326
327 #define GETSHORT NS_GET16
328 #define GETLONG NS_GET32
329
330 #define C_IN 1
331
332 /* From bionic/libc/private/resolv_private.h */
333 int dn_expand(const u_char *, const u_char *, const u_char *, char *, int);
334 #define dn_skipname __dn_skipname
335 int dn_skipname(const u_char *, const u_char *);
336
337 /* From bionic/libc/private/arpa_nameser_compat.h */
338 #define T_MX ns_t_mx
339 #define T_TXT ns_t_txt
340 #define T_SOA ns_t_soa
341 #define T_NS ns_t_ns
342
343 /* From bionic/libc/private/arpa_nameser.h */
344 typedef enum __ns_type {
345 ns_t_invalid = 0, /* Cookie. */
346 ns_t_a = 1, /* Host address. */
347 ns_t_ns = 2, /* Authoritative server. */
348 ns_t_md = 3, /* Mail destination. */
349 ns_t_mf = 4, /* Mail forwarder. */
350 ns_t_cname = 5, /* Canonical name. */
351 ns_t_soa = 6, /* Start of authority zone. */
352 ns_t_mb = 7, /* Mailbox domain name. */
353 ns_t_mg = 8, /* Mail group member. */
354 ns_t_mr = 9, /* Mail rename name. */
355 ns_t_null = 10, /* Null resource record. */
356 ns_t_wks = 11, /* Well known service. */
357 ns_t_ptr = 12, /* Domain name pointer. */
358 ns_t_hinfo = 13, /* Host information. */
359 ns_t_minfo = 14, /* Mailbox information. */
360 ns_t_mx = 15, /* Mail routing information. */
361 ns_t_txt = 16, /* Text strings. */
362 ns_t_rp = 17, /* Responsible person. */
363 ns_t_afsdb = 18, /* AFS cell database. */
364 ns_t_x25 = 19, /* X_25 calling address. */
365 ns_t_isdn = 20, /* ISDN calling address. */
366 ns_t_rt = 21, /* Router. */
367 ns_t_nsap = 22, /* NSAP address. */
368 ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */
369 ns_t_sig = 24, /* Security signature. */
370 ns_t_key = 25, /* Security key. */
371 ns_t_px = 26, /* X.400 mail mapping. */
372 ns_t_gpos = 27, /* Geographical position (withdrawn). */
373 ns_t_aaaa = 28, /* Ip6 Address. */
374 ns_t_loc = 29, /* Location Information. */
375 ns_t_nxt = 30, /* Next domain (security). */
376 ns_t_eid = 31, /* Endpoint identifier. */
377 ns_t_nimloc = 32, /* Nimrod Locator. */
378 ns_t_srv = 33, /* Server Selection. */
379 ns_t_atma = 34, /* ATM Address */
380 ns_t_naptr = 35, /* Naming Authority PoinTeR */
381 ns_t_kx = 36, /* Key Exchange */
382 ns_t_cert = 37, /* Certification record */
383 ns_t_a6 = 38, /* IPv6 address (deprecates AAAA) */
384 ns_t_dname = 39, /* Non-terminal DNAME (for IPv6) */
385 ns_t_sink = 40, /* Kitchen sink (experimentatl) */
386 ns_t_opt = 41, /* EDNS0 option (meta-RR) */
387 ns_t_apl = 42, /* Address prefix list (RFC 3123) */
388 ns_t_tkey = 249, /* Transaction key */
389 ns_t_tsig = 250, /* Transaction signature. */
390 ns_t_ixfr = 251, /* Incremental zone transfer. */
391 ns_t_axfr = 252, /* Transfer zone of authority. */
392 ns_t_mailb = 253, /* Transfer mailbox records. */
393 ns_t_maila = 254, /* Transfer mail agent records. */
394 ns_t_any = 255, /* Wildcard match. */
395 ns_t_zxfr = 256, /* BIND-specific, nonstandard. */
396 ns_t_max = 65536
397 } ns_type;
398
399 #endif /* __BIONIC__ */
400
401 static GVariant *
402 parse_res_srv (guchar *answer,
403 guchar *end,
404 guchar **p)
405 {
406 gchar namebuf[1024];
407 guint16 priority, weight, port;
408
409 GETSHORT (priority, *p);
410 GETSHORT (weight, *p);
411 GETSHORT (port, *p);
412 *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));
413
414 return g_variant_new ("(qqqs)",
415 priority,
416 weight,
417 port,
418 namebuf);
419 }
420
421 static GVariant *
422 parse_res_soa (guchar *answer,
423 guchar *end,
424 guchar **p)
425 {
426 gchar mnamebuf[1024];
427 gchar rnamebuf[1024];
428 guint32 serial, refresh, retry, expire, ttl;
429
430 *p += dn_expand (answer, end, *p, mnamebuf, sizeof (mnamebuf));
431 *p += dn_expand (answer, end, *p, rnamebuf, sizeof (rnamebuf));
432
433 GETLONG (serial, *p);
434 GETLONG (refresh, *p);
435 GETLONG (retry, *p);
436 GETLONG (expire, *p);
437 GETLONG (ttl, *p);
438
439 return g_variant_new ("(ssuuuuu)",
440 mnamebuf,
441 rnamebuf,
442 serial,
443 refresh,
444 retry,
445 expire,
446 ttl);
447 }
448
449 static GVariant *
450 parse_res_ns (guchar *answer,
451 guchar *end,
452 guchar **p)
453 {
454 gchar namebuf[1024];
455
456 *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));
457
458 return g_variant_new ("(s)", namebuf);
459 }
460
461 static GVariant *
462 parse_res_mx (guchar *answer,
463 guchar *end,
464 guchar **p)
465 {
466 gchar namebuf[1024];
467 guint16 preference;
468
469 GETSHORT (preference, *p);
470
471 *p += dn_expand (answer, end, *p, namebuf, sizeof (namebuf));
472
473 return g_variant_new ("(qs)",
474 preference,
475 namebuf);
476 }
477
478 static GVariant *
479 parse_res_txt (guchar *answer,
480 guchar *end,
481 guchar **p)
482 {
483 GVariant *record;
484 GPtrArray *array;
485 guchar *at = *p;
486 gsize len;
487
488 array = g_ptr_array_new_with_free_func (g_free);
489 while (at < end)
490 {
491 len = *(at++);
492 if (len > at - end)
493 break;
494 g_ptr_array_add (array, g_strndup ((gchar *)at, len));
495 at += len;
496 }
497
498 *p = at;
499 record = g_variant_new ("(@as)",
500 g_variant_new_strv ((const gchar **)array->pdata, array->len));
501 g_ptr_array_free (array, TRUE);
502 return record;
503 }
504
505 static gint
506 g_resolver_record_type_to_rrtype (GResolverRecordType type)
507 {
508 switch (type)
509 {
510 case G_RESOLVER_RECORD_SRV:
511 return T_SRV;
512 case G_RESOLVER_RECORD_TXT:
513 return T_TXT;
514 case G_RESOLVER_RECORD_SOA:
515 return T_SOA;
516 case G_RESOLVER_RECORD_NS:
517 return T_NS;
518 case G_RESOLVER_RECORD_MX:
519 return T_MX;
520 }
521 g_return_val_if_reached (-1);
522 }
523
524 static GList *
525 g_resolver_records_from_res_query (const gchar *rrname,
526 gint rrtype,
527 guchar *answer,
528 gint len,
529 gint herr,
530 GError **error)
531 {
532 gint count;
533 gchar namebuf[1024];
534 guchar *end, *p;
535 guint16 type, qclass, rdlength;
536 guint32 ttl;
537 HEADER *header;
538 GList *records;
539 GVariant *record;
540
541 if (len <= 0)
542 {
543 if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA)
544 {
545 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
546 _("No DNS record of the requested type for '%s'"), rrname);
547 }
548 else if (herr == TRY_AGAIN)
549 {
550 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE,
551 _("Temporarily unable to resolve '%s'"), rrname);
552 }
553 else
554 {
555 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
556 _("Error resolving '%s'"), rrname);
557 }
558
559 return NULL;
560 }
561
562 records = NULL;
563
564 header = (HEADER *)answer;
565 p = answer + sizeof (HEADER);
566 end = answer + len;
567
568 /* Skip query */
569 count = ntohs (header->qdcount);
570 while (count-- && p < end)
571 {
572 p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
573 p += 4;
574
575 /* To silence gcc warnings */
576 namebuf[0] = namebuf[1];
577 }
578
579 /* Read answers */
580 count = ntohs (header->ancount);
581 while (count-- && p < end)
582 {
583 p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
584 GETSHORT (type, p);
585 GETSHORT (qclass, p);
586 GETLONG (ttl, p);
587 ttl = ttl; /* To avoid -Wunused-but-set-variable */
588 GETSHORT (rdlength, p);
589
590 if (type != rrtype || qclass != C_IN)
591 {
592 p += rdlength;
593 continue;
594 }
595
596 switch (rrtype)
597 {
598 case T_SRV:
599 record = parse_res_srv (answer, end, &p);
600 break;
601 case T_MX:
602 record = parse_res_mx (answer, end, &p);
603 break;
604 case T_SOA:
605 record = parse_res_soa (answer, end, &p);
606 break;
607 case T_NS:
608 record = parse_res_ns (answer, end, &p);
609 break;
610 case T_TXT:
611 record = parse_res_txt (answer, p + rdlength, &p);
612 break;
613 default:
614 g_warn_if_reached ();
615 record = NULL;
616 break;
617 }
618
619 if (record != NULL)
620 records = g_list_prepend (records, record);
621 }
622
623 if (records == NULL)
624 {
625 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
626 _("No DNS record of the requested type for '%s'"), rrname);
627
628 return NULL;
629 }
630 else
631 return records;
632 }
633
634 #elif defined(G_OS_WIN32)
635
636 static GVariant *
637 parse_dns_srv (DNS_RECORD *rec)
638 {
639 return g_variant_new ("(qqqs)",
640 (guint16)rec->Data.SRV.wPriority,
641 (guint16)rec->Data.SRV.wWeight,
642 (guint16)rec->Data.SRV.wPort,
643 rec->Data.SRV.pNameTarget);
644 }
645
646 static GVariant *
647 parse_dns_soa (DNS_RECORD *rec)
648 {
649 return g_variant_new ("(ssuuuuu)",
650 rec->Data.SOA.pNamePrimaryServer,
651 rec->Data.SOA.pNameAdministrator,
652 (guint32)rec->Data.SOA.dwSerialNo,
653 (guint32)rec->Data.SOA.dwRefresh,
654 (guint32)rec->Data.SOA.dwRetry,
655 (guint32)rec->Data.SOA.dwExpire,
656 (guint32)rec->Data.SOA.dwDefaultTtl);
657 }
658
659 static GVariant *
660 parse_dns_ns (DNS_RECORD *rec)
661 {
662 return g_variant_new ("(s)", rec->Data.NS.pNameHost);
663 }
664
665 static GVariant *
666 parse_dns_mx (DNS_RECORD *rec)
667 {
668 return g_variant_new ("(qs)",
669 (guint16)rec->Data.MX.wPreference,
670 rec->Data.MX.pNameExchange);
671 }
672
673 static GVariant *
674 parse_dns_txt (DNS_RECORD *rec)
675 {
676 GVariant *record;
677 GPtrArray *array;
678 DWORD i;
679
680 array = g_ptr_array_new ();
681 for (i = 0; i < rec->Data.TXT.dwStringCount; i++)
682 g_ptr_array_add (array, rec->Data.TXT.pStringArray[i]);
683 record = g_variant_new ("(@as)",
684 g_variant_new_strv ((const gchar **)array->pdata, array->len));
685 g_ptr_array_free (array, TRUE);
686 return record;
687 }
688
689 static WORD
690 g_resolver_record_type_to_dnstype (GResolverRecordType type)
691 {
692 switch (type)
693 {
694 case G_RESOLVER_RECORD_SRV:
695 return DNS_TYPE_SRV;
696 case G_RESOLVER_RECORD_TXT:
697 return DNS_TYPE_TEXT;
698 case G_RESOLVER_RECORD_SOA:
699 return DNS_TYPE_SOA;
700 case G_RESOLVER_RECORD_NS:
701 return DNS_TYPE_NS;
702 case G_RESOLVER_RECORD_MX:
703 return DNS_TYPE_MX;
704 }
705 g_return_val_if_reached (-1);
706 }
707
708 static GList *
709 g_resolver_records_from_DnsQuery (const gchar *rrname,
710 WORD dnstype,
711 DNS_STATUS status,
712 DNS_RECORD *results,
713 GError **error)
714 {
715 DNS_RECORD *rec;
716 gpointer record;
717 GList *records;
718
719 if (status != ERROR_SUCCESS)
720 {
721 if (status == DNS_ERROR_RCODE_NAME_ERROR)
722 {
723 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
724 _("No DNS record of the requested type for '%s'"), rrname);
725 }
726 else if (status == DNS_ERROR_RCODE_SERVER_FAILURE)
727 {
728 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_TEMPORARY_FAILURE,
729 _("Temporarily unable to resolve '%s'"), rrname);
730 }
731 else
732 {
733 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL,
734 _("Error resolving '%s'"), rrname);
735 }
736
737 return NULL;
738 }
739
740 records = NULL;
741 for (rec = results; rec; rec = rec->pNext)
742 {
743 if (rec->wType != dnstype)
744 continue;
745 switch (dnstype)
746 {
747 case DNS_TYPE_SRV:
748 record = parse_dns_srv (rec);
749 break;
750 case DNS_TYPE_SOA:
751 record = parse_dns_soa (rec);
752 break;
753 case DNS_TYPE_NS:
754 record = parse_dns_ns (rec);
755 break;
756 case DNS_TYPE_MX:
757 record = parse_dns_mx (rec);
758 break;
759 case DNS_TYPE_TEXT:
760 record = parse_dns_txt (rec);
761 break;
762 default:
763 g_warn_if_reached ();
764 record = NULL;
765 break;
766 }
767 if (record != NULL)
768 records = g_list_prepend (records, g_variant_ref_sink (record));
769 }
770
771 if (records == NULL)
772 {
773 g_set_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
774 _("No DNS record of the requested type for '%s'"), rrname);
775
776 return NULL;
777 }
778 else
779 return records;
780 }
781
782 #endif
783
784 typedef struct {
785 char *rrname;
786 GResolverRecordType record_type;
787 } LookupRecordsData;
788
789 static void
790 free_lookup_records_data (LookupRecordsData *lrd)
791 {
792 g_free (lrd->rrname);
793 g_slice_free (LookupRecordsData, lrd);
794 }
795
796 static void
797 free_records (GList *records)
798 {
799 g_list_free_full (records, (GDestroyNotify) g_variant_unref);
800 }
801
802 #if defined(G_OS_UNIX)
803 #ifdef __BIONIC__
804 #define C_IN 1
805 int res_query(const char *, int, int, u_char *, int);
806 #endif
807 #endif
808
809 static void
810 do_lookup_records (GTask *task,
811 gpointer source_object,
812 gpointer task_data,
813 GCancellable *cancellable)
814 {
815 LookupRecordsData *lrd = task_data;
816 GList *records;
817 GError *error = NULL;
818
819 #if defined(G_OS_UNIX)
820 gint len = 512;
821 gint herr;
822 GByteArray *answer;
823 gint rrtype;
824
825 rrtype = g_resolver_record_type_to_rrtype (lrd->record_type);
826 answer = g_byte_array_new ();
827 for (;;)
828 {
829 g_byte_array_set_size (answer, len * 2);
830 len = res_query (lrd->rrname, C_IN, rrtype, answer->data, answer->len);
831
832 /* If answer fit in the buffer then we're done */
833 if (len < 0 || len < (gint)answer->len)
834 break;
835
836 /*
837 * On overflow some res_query's return the length needed, others
838 * return the full length entered. This code works in either case.
839 */
840 }
841
842 herr = h_errno;
843 records = g_resolver_records_from_res_query (lrd->rrname, rrtype, answer->data, len, herr, &error);
844 g_byte_array_free (answer, TRUE);
845
846 #else
847
848 DNS_STATUS status;
849 DNS_RECORD *results = NULL;
850 WORD dnstype;
851
852 dnstype = g_resolver_record_type_to_dnstype (lrd->record_type);
853 status = DnsQuery_A (lrd->rrname, dnstype, DNS_QUERY_STANDARD, NULL, &results, NULL);
854 records = g_resolver_records_from_DnsQuery (lrd->rrname, dnstype, status, results, &error);
855 if (results != NULL)
856 DnsRecordListFree (results, DnsFreeRecordList);
857
858 #endif
859
860 if (records)
861 g_task_return_pointer (task, records, (GDestroyNotify) free_records);
862 else
863 g_task_return_error (task, error);
864 }
865
866 static GList *
867 lookup_records (GResolver *resolver,
868 const gchar *rrname,
869 GResolverRecordType record_type,
870 GCancellable *cancellable,
871 GError **error)
872 {
873 GTask *task;
874 GList *records;
875 LookupRecordsData *lrd;
876
877 task = g_task_new (resolver, cancellable, NULL, NULL);
878
879 lrd = g_slice_new (LookupRecordsData);
880 lrd->rrname = g_strdup (rrname);
881 lrd->record_type = record_type;
882 g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data);
883
884 g_task_set_return_on_cancel (task, TRUE);
885 g_task_run_in_thread_sync (task, do_lookup_records);
886 records = g_task_propagate_pointer (task, error);
887 g_object_unref (task);
888
889 return records;
890 }
891
892 static void
893 lookup_records_async (GResolver *resolver,
894 const char *rrname,
895 GResolverRecordType record_type,
896 GCancellable *cancellable,
897 GAsyncReadyCallback callback,
898 gpointer user_data)
899 {
900 GTask *task;
901 LookupRecordsData *lrd;
902
903 task = g_task_new (resolver, cancellable, callback, user_data);
904
905 lrd = g_slice_new (LookupRecordsData);
906 lrd->rrname = g_strdup (rrname);
907 lrd->record_type = record_type;
908 g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data);
909
910 g_task_set_return_on_cancel (task, TRUE);
911 g_task_run_in_thread (task, do_lookup_records);
912 g_object_unref (task);
913 }
914
915 static GList *
916 lookup_records_finish (GResolver *resolver,
917 GAsyncResult *result,
918 GError **error)
919 {
920 g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
921
922 return g_task_propagate_pointer (G_TASK (result), error);
923 }
924
925
926 static void
927 g_threaded_resolver_class_init (GThreadedResolverClass *threaded_class)
928 {
929 GResolverClass *resolver_class = G_RESOLVER_CLASS (threaded_class);
930
931 resolver_class->lookup_by_name = lookup_by_name;
932 resolver_class->lookup_by_name_async = lookup_by_name_async;
933 resolver_class->lookup_by_name_finish = lookup_by_name_finish;
934 resolver_class->lookup_by_address = lookup_by_address;
935 resolver_class->lookup_by_address_async = lookup_by_address_async;
936 resolver_class->lookup_by_address_finish = lookup_by_address_finish;
937 resolver_class->lookup_records = lookup_records;
938 resolver_class->lookup_records_async = lookup_records_async;
939 resolver_class->lookup_records_finish = lookup_records_finish;
940
941 /* Initialize addrinfo_hints */
942 #ifdef AI_ADDRCONFIG
943 addrinfo_hints.ai_flags |= AI_ADDRCONFIG;
944 #endif
945 /* These two don't actually matter, they just get copied into the
946 * returned addrinfo structures (and then we ignore them). But if
947 * we leave them unset, we'll get back duplicate answers.
948 */
949 addrinfo_hints.ai_socktype = SOCK_STREAM;
950 addrinfo_hints.ai_protocol = IPPROTO_TCP;
951 }
glib mirror