gio/gresolver.c

   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, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "config.h"
  24 #include <glib.h>
  25 #include "glibintl.h"
  26
  27 #include "gresolver.h"
  28 #include "gnetworkingprivate.h"
  29 #include "gasyncresult.h"
  30 #include "ginetaddress.h"
  31 #include "ginetsocketaddress.h"
  32 #include "gsimpleasyncresult.h"
  33 #include "gsrvtarget.h"
  34
  35 #ifdef G_OS_UNIX
  36 #include "gunixresolver.h"
  37 #endif
  38 #ifdef G_OS_WIN32
  39 #include "gwin32resolver.h"
  40 #endif
  41
  42 #include <stdlib.h>
  43
  44 #include "gioalias.h"
  45
  46 /**
  47  * SECTION:gresolver
  48  * @short_description: Asynchronous and cancellable DNS resolver
  49  * @include: gio/gio.h
  50  *
  51  * #GResolver provides cancellable synchronous and asynchronous DNS
  52  * resolution, for hostnames (g_resolver_lookup_by_address(),
  53  * g_resolver_lookup_by_name() and their async variants) and SRV
  54  * (service) records (g_resolver_lookup_service()).
  55  *
  56  * #GNetworkAddress and #GNetworkService provide wrappers around
  57  * #GResolver functionality that also implement #GSocketConnectable,
  58  * making it easy to connect to a remote host/service.
  59  */
  60
  61 /**
  62  * GResolver:
  63  *
  64  * The object that handles DNS resolution. Use g_resolver_get_default()
  65  * to get the default resolver.
  66  */
  67 G_DEFINE_TYPE (GResolver, g_resolver, G_TYPE_OBJECT)
  68
  69 static void
  70 g_resolver_class_init (GResolverClass *resolver_class)
  71 {
  72   volatile GType type;
  73
  74   /* Make sure _g_networking_init() has been called */
  75   type = g_inet_address_get_type ();
  76
  77   /* Initialize _g_resolver_addrinfo_hints */
  78 #ifdef AI_ADDRCONFIG
  79   _g_resolver_addrinfo_hints.ai_flags |= AI_ADDRCONFIG;
  80 #endif
  81   /* These two don't actually matter, they just get copied into the
  82    * returned addrinfo structures (and then we ignore them). But if
  83    * we leave them unset, we'll get back duplicate answers.
  84    */
  85   _g_resolver_addrinfo_hints.ai_socktype = SOCK_STREAM;
  86   _g_resolver_addrinfo_hints.ai_protocol = IPPROTO_TCP;
  87 }
  88
  89 static void
  90 g_resolver_init (GResolver *resolver)
  91 {
  92 }
  93
  94 static GResolver *default_resolver;
  95
  96 /**
  97  * g_resolver_get_default:
  98  *
  99  * Gets the default #GResolver. You should unref it when you are done
 100  * with it. #GResolver may use its reference count as a hint about how
 101  * many threads/processes, etc it should allocate for concurrent DNS
 102  * resolutions.
 103  *
 104  * Return value: the #GResolver.
 105  *
 106  * Since: 2.22
 107  **/
 108 GResolver *
 109 g_resolver_get_default (void)
 110 {
 111   if (!default_resolver)
 112     {
 113       if (g_thread_supported ())
 114         default_resolver = g_object_new (G_TYPE_THREADED_RESOLVER, NULL);
 115       else
 116         {
 117 #if defined(G_OS_UNIX)
 118           default_resolver = g_object_new (G_TYPE_UNIX_RESOLVER, NULL);
 119 #elif defined(G_OS_WIN32)
 120           default_resolver = g_object_new (G_TYPE_WIN32_RESOLVER, NULL);
 121 #endif
 122         }
 123     }
 124
 125   return g_object_ref (default_resolver);
 126 }
 127
 128 /**
 129  * g_resolver_set_default:
 130  * @resolver: the new default #GResolver
 131  *
 132  * Sets @resolver to be the application's default resolver (reffing
 133  * @resolver, and unreffing the previous default resolver, if any).
 134  * Future calls to g_resolver_get_default() will return this resolver.
 135  *
 136  * This can be used if an application wants to perform any sort of DNS
 137  * caching or "pinning"; it can implement its own #GResolver that
 138  * calls the original default resolver for DNS operations, and
 139  * implements its own cache policies on top of that, and then set
 140  * itself as the default resolver for all later code to use.
 141  *
 142  * Since: 2.22
 143  */
 144 void
 145 g_resolver_set_default (GResolver *resolver)
 146 {
 147   if (default_resolver)
 148     g_object_unref (default_resolver);
 149   default_resolver = g_object_ref (resolver);
 150 }
 151
 152
 153 /**
 154  * g_resolver_lookup_by_name:
 155  * @resolver: a #GResolver
 156  * @hostname: the hostname to look up
 157  * @cancellable: a #GCancellable, or %NULL
 158  * @error: return location for a #GError, or %NULL
 159  *
 160  * Synchronously resolves @hostname to determine its associated IP
 161  * address(es). @hostname may be an ASCII-only or UTF-8 hostname, or
 162  * the textual form of an IP address (in which case this just becomes
 163  * a wrapper around g_inet_address_new_from_string()).
 164  *
 165  * On success, g_resolver_lookup_by_name() will return a #GList of
 166  * #GInetAddress, sorted in order of preference. (That is, you should
 167  * attempt to connect to the first address first, then the second if
 168  * the first fails, etc.)
 169  *
 170  * If the DNS resolution fails, @error (if non-%NULL) will be set to a
 171  * value from #GResolverError.
 172  *
 173  * If @cancellable is non-%NULL, it can be used to cancel the
 174  * operation, in which case @error (if non-%NULL) will be set to
 175  * %G_IO_ERROR_CANCELLED.
 176  *
 177  * If you are planning to connect to a socket on the resolved IP
 178  * address, it may be easier to create a #GNetworkAddress and use its
 179  * #GSocketConnectable interface.
 180  *
 181  * Return value: a #GList of #GInetAddress, or %NULL on error. You
 182  * must unref each of the addresses and free the list when you are
 183  * done with it. (You can use g_resolver_free_addresses() to do this.)
 184  *
 185  * Since: 2.22
 186  */
 187 GList *
 188 g_resolver_lookup_by_name (GResolver     *resolver,
 189                            const gchar   *hostname,
 190                            GCancellable  *cancellable,
 191                            GError       **error)
 192 {
 193   GInetAddress *addr;
 194   GList *addrs;
 195   gchar *ascii_hostname = NULL;
 196
 197   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 198   g_return_val_if_fail (hostname != NULL, NULL);
 199
 200   /* Check if @hostname is just an IP address */
 201   addr = g_inet_address_new_from_string (hostname);
 202   if (addr)
 203     return g_list_append (NULL, addr);
 204
 205   if (g_hostname_is_non_ascii (hostname))
 206     hostname = ascii_hostname = g_hostname_to_ascii (hostname);
 207
 208   addrs = G_RESOLVER_GET_CLASS (resolver)->
 209     lookup_by_name (resolver, hostname, cancellable, error);
 210
 211   g_free (ascii_hostname);
 212   return addrs;
 213 }
 214
 215 /**
 216  * g_resolver_lookup_by_name_async:
 217  * @resolver: a #GResolver
 218  * @hostname: the hostname to look up the address of
 219  * @cancellable: a #GCancellable, or %NULL
 220  * @callback: callback to call after resolution completes
 221  * @user_data: data for @callback
 222  *
 223  * Begins asynchronously resolving @hostname to determine its
 224  * associated IP address(es), and eventually calls @callback, which
 225  * must call g_resolver_lookup_by_name_finish() to get the result.
 226  * See g_resolver_lookup_by_name() for more details.
 227  *
 228  * Since: 2.22
 229  */
 230 void
 231 g_resolver_lookup_by_name_async (GResolver           *resolver,
 232                                  const gchar         *hostname,
 233                                  GCancellable        *cancellable,
 234                                  GAsyncReadyCallback  callback,
 235                                  gpointer             user_data)
 236 {
 237   GInetAddress *addr;
 238   gchar *ascii_hostname = NULL;
 239
 240   g_return_if_fail (G_IS_RESOLVER (resolver));
 241   g_return_if_fail (hostname != NULL);
 242
 243   /* Check if @hostname is just an IP address */
 244   addr = g_inet_address_new_from_string (hostname);
 245   if (addr)
 246     {
 247       GSimpleAsyncResult *simple;
 248       GList *addrs;
 249
 250       simple = g_simple_async_result_new (G_OBJECT (resolver),
 251                                           callback, user_data,
 252                                           g_resolver_lookup_by_name_async);
 253
 254       addrs = g_list_append (NULL, addr);
 255       g_simple_async_result_set_op_res_gpointer (simple, addrs, (GDestroyNotify)g_resolver_free_addresses);
 256       g_simple_async_result_complete_in_idle (simple);
 257       g_object_unref (simple);
 258       return;
 259     }
 260
 261   if (g_hostname_is_non_ascii (hostname))
 262     hostname = ascii_hostname = g_hostname_to_ascii (hostname);
 263
 264   G_RESOLVER_GET_CLASS (resolver)->
 265     lookup_by_name_async (resolver, hostname, cancellable, callback, user_data);
 266
 267   g_free (ascii_hostname);
 268 }
 269
 270 /**
 271  * g_resolver_lookup_by_name_finish:
 272  * @resolver: a #GResolver
 273  * @result: the result passed to your #GAsyncReadyCallback
 274  * @error: return location for a #GError, or %NULL
 275  *
 276  * Retrieves the result of a call to
 277  * g_resolver_lookup_by_name_async().
 278  *
 279  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 280  * a value from #GResolverError. If the operation was cancelled,
 281  * @error will be set to %G_IO_ERROR_CANCELLED.
 282  *
 283  * Return value: a #GList of #GInetAddress, or %NULL on error. See
 284  * g_resolver_lookup_by_name() for more details.
 285  *
 286  * Since: 2.22
 287  */
 288 GList *
 289 g_resolver_lookup_by_name_finish (GResolver     *resolver,
 290                                   GAsyncResult  *result,
 291                                   GError       **error)
 292 {
 293   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 294
 295   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 296     {
 297       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 298
 299       if (g_simple_async_result_propagate_error (simple, error))
 300         return NULL;
 301
 302       /* Handle the stringified-IP-addr case */
 303       if (g_simple_async_result_get_source_tag (simple) == g_resolver_lookup_by_name_async)
 304         {
 305           GList *addrs;
 306
 307           addrs = g_simple_async_result_get_op_res_gpointer (simple);
 308           g_simple_async_result_set_op_res_gpointer (simple, NULL, NULL);
 309           return addrs;
 310         }
 311     }
 312
 313   return G_RESOLVER_GET_CLASS (resolver)->
 314     lookup_by_name_finish (resolver, result, error);
 315 }
 316
 317 /**
 318  * g_resolver_free_addresses:
 319  * @addresses: a #GList of #GInetAddress
 320  *
 321  * Frees @addresses (which should be the return value from
 322  * g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()).
 323  * (This is a convenience method; you can also simply free the results
 324  * by hand.)
 325  *
 326  * Since: 2.22
 327  */
 328 void
 329 g_resolver_free_addresses (GList *addresses)
 330 {
 331   GList *a;
 332
 333   for (a = addresses; a; a = a->next)
 334     g_object_unref (a->data);
 335   g_list_free (addresses);
 336 }
 337
 338 /**
 339  * g_resolver_lookup_by_address:
 340  * @resolver: a #GResolver
 341  * @address: the address to reverse-resolve
 342  * @cancellable: a #GCancellable, or %NULL
 343  * @error: return location for a #GError, or %NULL
 344  *
 345  * Synchronously reverse-resolves @address to determine its
 346  * associated hostname.
 347  *
 348  * If the DNS resolution fails, @error (if non-%NULL) will be set to
 349  * a value from #GResolverError.
 350  *
 351  * If @cancellable is non-%NULL, it can be used to cancel the
 352  * operation, in which case @error (if non-%NULL) will be set to
 353  * %G_IO_ERROR_CANCELLED.
 354  *
 355  * Return value: a hostname (either ASCII-only, or in ASCII-encoded
 356  * form), or %NULL on error.
 357  *
 358  * Since: 2.22
 359  */
 360 gchar *
 361 g_resolver_lookup_by_address (GResolver     *resolver,
 362                               GInetAddress  *address,
 363                               GCancellable  *cancellable,
 364                               GError       **error)
 365 {
 366   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 367   g_return_val_if_fail (G_IS_INET_ADDRESS (address), NULL);
 368
 369   return G_RESOLVER_GET_CLASS (resolver)->
 370     lookup_by_address (resolver, address, cancellable, error);
 371 }
 372
 373 /**
 374  * g_resolver_lookup_by_address_async:
 375  * @resolver: a #GResolver
 376  * @address: the address to reverse-resolve
 377  * @cancellable: a #GCancellable, or %NULL
 378  * @callback: callback to call after resolution completes
 379  * @user_data: data for @callback
 380  *
 381  * Begins asynchronously reverse-resolving @address to determine its
 382  * associated hostname, and eventually calls @callback, which must
 383  * call g_resolver_lookup_by_address_finish() to get the final result.
 384  *
 385  * Since: 2.22
 386  */
 387 void
 388 g_resolver_lookup_by_address_async (GResolver           *resolver,
 389                                     GInetAddress        *address,
 390                                     GCancellable        *cancellable,
 391                                     GAsyncReadyCallback  callback,
 392                                     gpointer             user_data)
 393 {
 394   g_return_if_fail (G_IS_RESOLVER (resolver));
 395   g_return_if_fail (G_IS_INET_ADDRESS (address));
 396
 397   G_RESOLVER_GET_CLASS (resolver)->
 398     lookup_by_address_async (resolver, address, cancellable, callback, user_data);
 399 }
 400
 401 /**
 402  * g_resolver_lookup_by_address_finish:
 403  * @resolver: a #GResolver
 404  * @result: the result passed to your #GAsyncReadyCallback
 405  * @error: return location for a #GError, or %NULL
 406  *
 407  * Retrieves the result of a previous call to
 408  * g_resolver_lookup_by_address_async().
 409  *
 410  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 411  * a value from #GResolverError. If the operation was cancelled,
 412  * @error will be set to %G_IO_ERROR_CANCELLED.
 413  *
 414  * Return value: a hostname (either ASCII-only, or in ASCII-encoded
 415  * form), or %NULL on error.
 416  *
 417  * Since: 2.22
 418  */
 419 gchar *
 420 g_resolver_lookup_by_address_finish (GResolver     *resolver,
 421                                      GAsyncResult  *result,
 422                                      GError       **error)
 423 {
 424   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 425
 426   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 427     {
 428       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 429
 430       if (g_simple_async_result_propagate_error (simple, error))
 431         return NULL;
 432     }
 433
 434   return G_RESOLVER_GET_CLASS (resolver)->
 435     lookup_by_address_finish (resolver, result, error);
 436 }
 437
 438 static gchar *
 439 g_resolver_get_service_rrname (const char *service,
 440                                const char *protocol,
 441                                const char *domain)
 442 {
 443   gchar *rrname, *ascii_domain = NULL;
 444
 445   if (g_hostname_is_non_ascii (domain))
 446     domain = ascii_domain = g_hostname_to_ascii (domain);
 447
 448   rrname = g_strdup_printf ("_%s._%s.%s", service, protocol, domain);
 449
 450   g_free (ascii_domain);
 451   return rrname;
 452 }
 453
 454 /**
 455  * g_resolver_lookup_service:
 456  * @resolver: a #GResolver
 457  * @service: the service type to look up (eg, "ldap")
 458  * @protocol: the networking protocol to use for @service (eg, "tcp")
 459  * @domain: the DNS domain to look up the service in
 460  * @cancellable: a #GCancellable, or %NULL
 461  * @error: return location for a #GError, or %NULL
 462  *
 463  * Synchronously performs a DNS SRV lookup for the given @service and
 464  * @protocol in the given @domain and returns an array of #GSrvTarget.
 465  * @domain may be an ASCII-only or UTF-8 hostname. Note also that the
 466  * @service and @protocol arguments <emphasis>do not</emphasis>
 467  * include the leading underscore that appears in the actual DNS
 468  * entry.
 469  *
 470  * On success, g_resolver_lookup_service() will return a #GList of
 471  * #GSrvTarget, sorted in order of preference. (That is, you should
 472  * attempt to connect to the first target first, then the second if
 473  * the first fails, etc.)
 474  *
 475  * If the DNS resolution fails, @error (if non-%NULL) will be set to
 476  * a value from #GResolverError.
 477  *
 478  * If @cancellable is non-%NULL, it can be used to cancel the
 479  * operation, in which case @error (if non-%NULL) will be set to
 480  * %G_IO_ERROR_CANCELLED.
 481  *
 482  * If you are planning to connect to the service, it is usually easier
 483  * to create a #GNetworkService and use its #GSocketConnectable
 484  * interface.
 485  *
 486  * Return value: a #GList of #GSrvTarget, or %NULL on error. You must
 487  * free each of the targets and the list when you are done with it.
 488  * (You can use g_resolver_free_targets() to do this.)
 489  *
 490  * Since: 2.22
 491  */
 492 GList *
 493 g_resolver_lookup_service (GResolver     *resolver,
 494                            const gchar   *service,
 495                            const gchar   *protocol,
 496                            const gchar   *domain,
 497                            GCancellable  *cancellable,
 498                            GError       **error)
 499 {
 500   GList *targets;
 501   gchar *rrname;
 502
 503   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 504   g_return_val_if_fail (service != NULL, NULL);
 505   g_return_val_if_fail (protocol != NULL, NULL);
 506   g_return_val_if_fail (domain != NULL, NULL);
 507
 508   rrname = g_resolver_get_service_rrname (service, protocol, domain);
 509
 510   targets = G_RESOLVER_GET_CLASS (resolver)->
 511     lookup_service (resolver, rrname, cancellable, error);
 512
 513   g_free (rrname);
 514   return targets;
 515 }
 516
 517 /**
 518  * g_resolver_lookup_service_async:
 519  * @resolver: a #GResolver
 520  * @service: the service type to look up (eg, "ldap")
 521  * @protocol: the networking protocol to use for @service (eg, "tcp")
 522  * @domain: the DNS domain to look up the service in
 523  * @cancellable: a #GCancellable, or %NULL
 524  * @callback: callback to call after resolution completes
 525  * @user_data: data for @callback
 526  *
 527  * Begins asynchronously performing a DNS SRV lookup for the given
 528  * @service and @protocol in the given @domain, and eventually calls
 529  * @callback, which must call g_resolver_lookup_service_finish() to
 530  * get the final result. See g_resolver_lookup_service() for more
 531  * details.
 532  *
 533  * Since: 2.22
 534  */
 535 void
 536 g_resolver_lookup_service_async (GResolver           *resolver,
 537                                  const gchar         *service,
 538                                  const gchar         *protocol,
 539                                  const gchar         *domain,
 540                                  GCancellable        *cancellable,
 541                                  GAsyncReadyCallback  callback,
 542                                  gpointer             user_data)
 543 {
 544   gchar *rrname;
 545
 546   g_return_if_fail (G_IS_RESOLVER (resolver));
 547   g_return_if_fail (service != NULL);
 548   g_return_if_fail (protocol != NULL);
 549   g_return_if_fail (domain != NULL);
 550
 551   rrname = g_resolver_get_service_rrname (service, protocol, domain);
 552
 553   G_RESOLVER_GET_CLASS (resolver)->
 554     lookup_service_async (resolver, rrname, cancellable, callback, user_data);
 555
 556   g_free (rrname);
 557 }
 558
 559 /**
 560  * g_resolver_lookup_service_finish:
 561  * @resolver: a #GResolver
 562  * @result: the result passed to your #GAsyncReadyCallback
 563  * @error: return location for a #GError, or %NULL
 564  *
 565  * Retrieves the result of a previous call to
 566  * g_resolver_lookup_service_async().
 567  *
 568  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 569  * a value from #GResolverError. If the operation was cancelled,
 570  * @error will be set to %G_IO_ERROR_CANCELLED.
 571  *
 572  * Return value: a #GList of #GSrvTarget, or %NULL on error. See
 573  * g_resolver_lookup_service() for more details.
 574  *
 575  * Since: 2.22
 576  */
 577 GList *
 578 g_resolver_lookup_service_finish (GResolver     *resolver,
 579                                   GAsyncResult  *result,
 580                                   GError       **error)
 581 {
 582   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 583
 584   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 585     {
 586       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 587
 588       if (g_simple_async_result_propagate_error (simple, error))
 589         return NULL;
 590     }
 591
 592   return G_RESOLVER_GET_CLASS (resolver)->
 593     lookup_service_finish (resolver, result, error);
 594 }
 595
 596 /**
 597  * g_resolver_free_targets:
 598  * @targets: a #GList of #GSrvTarget
 599  *
 600  * Frees @targets (which should be the return value from
 601  * g_resolver_lookup_service() or g_resolver_lookup_service_finish()).
 602  * (This is a convenience method; you can also simply free the
 603  * results by hand.)
 604  *
 605  * Since: 2.22
 606  */
 607 void
 608 g_resolver_free_targets (GList *targets)
 609 {
 610   GList *t;
 611
 612   for (t = targets; t; t = t->next)
 613     g_srv_target_free (t->data);
 614   g_list_free (targets);
 615 }
 616
 617 /**
 618  * g_resolver_error_quark:
 619  *
 620  * Gets the #GResolver Error Quark.
 621  *
 622  * Return value: a #GQuark.
 623  *
 624  * Since: 2.22
 625  */
 626 GQuark
 627 g_resolver_error_quark (void)
 628 {
 629   return g_quark_from_static_string ("g-resolver-error-quark");
 630 }
 631
 632
 633 static GResolverError
 634 g_resolver_error_from_addrinfo_error (gint err)
 635 {
 636   switch (err)
 637     {
 638     case EAI_FAIL:
 639     case EAI_NODATA:
 640     case EAI_NONAME:
 641       return G_RESOLVER_ERROR_NOT_FOUND;
 642
 643     case EAI_AGAIN:
 644       return G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 645
 646     default:
 647       return G_RESOLVER_ERROR_INTERNAL;
 648     }
 649 }
 650
 651 struct addrinfo _g_resolver_addrinfo_hints;
 652
 653 /* Private method to process a getaddrinfo() response. */
 654 GList *
 655 _g_resolver_addresses_from_addrinfo (const char       *hostname,
 656                                      struct addrinfo  *res,
 657                                      gint              gai_retval,
 658                                      GError          **error)
 659 {
 660   struct addrinfo *ai;
 661   GSocketAddress *sockaddr;
 662   GInetAddress *addr;
 663   GList *addrs;
 664
 665   if (gai_retval != 0)
 666     {
 667       g_set_error (error, G_RESOLVER_ERROR,
 668                    g_resolver_error_from_addrinfo_error (gai_retval),
 669                    _("Error resolving '%s': %s"),
 670                    hostname, gai_strerror (gai_retval));
 671       return NULL;
 672     }
 673
 674   g_return_val_if_fail (res != NULL, NULL);
 675
 676   addrs = NULL;
 677   for (ai = res; ai; ai = ai->ai_next)
 678     {
 679       sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen);
 680       if (!sockaddr || !G_IS_INET_SOCKET_ADDRESS (sockaddr))
 681         continue;
 682
 683       addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr));
 684       addrs = g_list_prepend (addrs, addr);
 685       g_object_unref (sockaddr);
 686     }
 687
 688   return g_list_reverse (addrs);
 689 }
 690
 691 /* Private method to set up a getnameinfo() request */
 692 void
 693 _g_resolver_address_to_sockaddr (GInetAddress            *address,
 694                                  struct sockaddr_storage *sa,
 695                                  gsize                   *sa_len)
 696 {
 697   GSocketAddress *sockaddr;
 698
 699   sockaddr = g_inet_socket_address_new (address, 0);
 700   g_socket_address_to_native (sockaddr, (struct sockaddr *)sa, sizeof (*sa));
 701   *sa_len = g_socket_address_get_native_size (sockaddr);
 702   g_object_unref (sockaddr);
 703 }
 704
 705 /* Private method to process a getnameinfo() response. */
 706 char *
 707 _g_resolver_name_from_nameinfo (GInetAddress  *address,
 708                                 const gchar   *name,
 709                                 gint           gni_retval,
 710                                 GError       **error)
 711 {
 712   if (gni_retval != 0)
 713     {
 714       gchar *phys;
 715
 716       phys = g_inet_address_to_string (address);
 717       g_set_error (error, G_RESOLVER_ERROR,
 718                    g_resolver_error_from_addrinfo_error (gni_retval),
 719                    _("Error reverse-resolving '%s': %s"),
 720                    phys ? phys : "(unknown)", gai_strerror (gni_retval));
 721       g_free (phys);
 722       return NULL;
 723     }
 724
 725   return g_strdup (name);
 726 }
 727
 728 #if defined(G_OS_UNIX)
 729 /* Private method to process a res_query response into GSrvTargets */
 730 GList *
 731 _g_resolver_targets_from_res_query (const gchar      *rrname,
 732                                     guchar           *answer,
 733                                     gint              len,
 734                                     gint              herr,
 735                                     GError          **error)
 736 {
 737   gint count;
 738   gchar namebuf[1024];
 739   guchar *end, *p;
 740   guint16 type, qclass, rdlength, priority, weight, port;
 741   guint32 ttl;
 742   HEADER *header;
 743   GSrvTarget *target;
 744   GList *targets;
 745
 746   if (len <= 0)
 747     {
 748       GResolverError errnum;
 749       const gchar *format;
 750
 751       if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA)
 752         {
 753           errnum = G_RESOLVER_ERROR_NOT_FOUND;
 754           format = _("No service record for '%s'");
 755         }
 756       else if (herr == TRY_AGAIN)
 757         {
 758           errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 759           format = _("Temporarily unable to resolve '%s'");
 760         }
 761       else
 762         {
 763           errnum = G_RESOLVER_ERROR_INTERNAL;
 764           format = _("Error resolving '%s'");
 765         }
 766
 767       g_set_error (error, G_RESOLVER_ERROR, errnum, format, rrname);
 768       return NULL;
 769     }
 770
 771   targets = NULL;
 772
 773   header = (HEADER *)answer;
 774   p = answer + sizeof (HEADER);
 775   end = answer + len;
 776
 777   /* Skip query */
 778   count = ntohs (header->qdcount);
 779   while (count-- && p < end)
 780     {
 781       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 782       p += 4;
 783     }
 784
 785   /* Read answers */
 786   count = ntohs (header->ancount);
 787   while (count-- && p < end)
 788     {
 789       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 790       GETSHORT (type, p);
 791       GETSHORT (qclass, p);
 792       GETLONG  (ttl, p);
 793       GETSHORT (rdlength, p);
 794
 795       if (type != T_SRV || qclass != C_IN)
 796         {
 797           p += rdlength;
 798           continue;
 799         }
 800
 801       GETSHORT (priority, p);
 802       GETSHORT (weight, p);
 803       GETSHORT (port, p);
 804       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 805
 806       target = g_srv_target_new (namebuf, port, priority, weight);
 807       targets = g_list_prepend (targets, target);
 808     }
 809
 810   return g_srv_target_list_sort (targets);
 811 }
 812 #elif defined(G_OS_WIN32)
 813 /* Private method to process a DnsQuery response into GSrvTargets */
 814 GList *
 815 _g_resolver_targets_from_DnsQuery (const gchar  *rrname,
 816                                    DNS_STATUS    status,
 817                                    DNS_RECORD   *results,
 818                                    GError      **error)
 819 {
 820   DNS_RECORD *rec;
 821   GSrvTarget *target;
 822   GList *targets;
 823
 824   if (status != ERROR_SUCCESS)
 825     {
 826       GResolverError errnum;
 827       const gchar *format;
 828
 829       if (status == DNS_ERROR_RCODE_NAME_ERROR)
 830         {
 831           errnum = G_RESOLVER_ERROR_NOT_FOUND;
 832           format = _("No service record for '%s'");
 833         }
 834       else if (status == DNS_ERROR_RCODE_SERVER_FAILURE)
 835         {
 836           errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 837           format = _("Temporarily unable to resolve '%s'");
 838         }
 839       else
 840         {
 841           errnum = G_RESOLVER_ERROR_INTERNAL;
 842           format = _("Error resolving '%s'");
 843         }
 844
 845       g_set_error (error, G_RESOLVER_ERROR, errnum, format, rrname);
 846       return NULL;
 847     }
 848
 849   targets = NULL;
 850   for (rec = results; rec; rec = rec->pNext)
 851     {
 852       if (rec->wType != DNS_TYPE_SRV)
 853         continue;
 854
 855       target = g_srv_target_new (rec->Data.SRV.pNameTarget,
 856                                  rec->Data.SRV.wPort,
 857                                  rec->Data.SRV.wPriority,
 858                                  rec->Data.SRV.wWeight);
 859       targets = g_list_prepend (targets, target);
 860     }
 861
 862   return g_srv_target_list_sort (targets);
 863 }
 864
 865 #endif
 866
 867 #define __G_RESOLVER_C__
 868 #include "gioaliasdef.c"