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 default #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
 249       simple = g_simple_async_result_new (G_OBJECT (resolver),
 250                                           callback, user_data,
 251                                           g_resolver_lookup_by_name_async);
 252
 253       g_simple_async_result_set_op_res_gpointer (simple, addr, g_object_unref);
 254       g_simple_async_result_complete_in_idle (simple);
 255       g_object_unref (simple);
 256       return;
 257     }
 258
 259   if (g_hostname_is_non_ascii (hostname))
 260     hostname = ascii_hostname = g_hostname_to_ascii (hostname);
 261
 262   G_RESOLVER_GET_CLASS (resolver)->
 263     lookup_by_name_async (resolver, hostname, cancellable, callback, user_data);
 264
 265   g_free (ascii_hostname);
 266 }
 267
 268 /**
 269  * g_resolver_lookup_by_name_finish:
 270  * @resolver: a #GResolver
 271  * @result: the result passed to your #GAsyncReadyCallback
 272  * @error: return location for a #GError, or %NULL
 273  *
 274  * Retrieves the result of a call to
 275  * g_resolver_lookup_by_name_async().
 276  *
 277  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 278  * a value from #GResolverError. If the operation was cancelled,
 279  * @error will be set to %G_IO_ERROR_CANCELLED.
 280  *
 281  * Return value: a #GList of #GInetAddress, or %NULL on error. See
 282  * g_resolver_lookup_by_name() for more details.
 283  *
 284  * Since: 2.22
 285  */
 286 GList *
 287 g_resolver_lookup_by_name_finish (GResolver     *resolver,
 288                                   GAsyncResult  *result,
 289                                   GError       **error)
 290 {
 291   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 292
 293   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 294     {
 295       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 296
 297       if (g_simple_async_result_propagate_error (simple, error))
 298         return NULL;
 299
 300       /* Handle the stringified-IP-addr case */
 301       if (g_simple_async_result_get_source_tag (simple) == g_resolver_lookup_by_name_async)
 302         {
 303           GInetAddress *addr;
 304
 305           addr = g_simple_async_result_get_op_res_gpointer (simple);
 306           return g_list_append (NULL, g_object_ref (addr));
 307         }
 308     }
 309
 310   return G_RESOLVER_GET_CLASS (resolver)->
 311     lookup_by_name_finish (resolver, result, error);
 312 }
 313
 314 /**
 315  * g_resolver_free_addresses:
 316  * @addresses: a #GList of #GInetAddress
 317  *
 318  * Frees @addresses (which should be the return value from
 319  * g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()).
 320  * (This is a convenience method; you can also simply free the results
 321  * by hand.)
 322  *
 323  * Since: 2.22
 324  */
 325 void
 326 g_resolver_free_addresses (GList *addresses)
 327 {
 328   GList *a;
 329
 330   for (a = addresses; a; a = a->next)
 331     g_object_unref (a->data);
 332   g_list_free (addresses);
 333 }
 334
 335 /**
 336  * g_resolver_lookup_by_address:
 337  * @resolver: a #GResolver
 338  * @address: the address to reverse-resolve
 339  * @cancellable: a #GCancellable, or %NULL
 340  * @error: return location for a #GError, or %NULL
 341  *
 342  * Synchronously reverse-resolves @address to determine its
 343  * associated hostname.
 344  *
 345  * If the DNS resolution fails, @error (if non-%NULL) will be set to
 346  * a value from #GResolverError.
 347  *
 348  * If @cancellable is non-%NULL, it can be used to cancel the
 349  * operation, in which case @error (if non-%NULL) will be set to
 350  * %G_IO_ERROR_CANCELLED.
 351  *
 352  * Return value: a hostname (either ASCII-only, or in ASCII-encoded
 353  *     form), or %NULL on error.
 354  *
 355  * Since: 2.22
 356  */
 357 gchar *
 358 g_resolver_lookup_by_address (GResolver     *resolver,
 359                               GInetAddress  *address,
 360                               GCancellable  *cancellable,
 361                               GError       **error)
 362 {
 363   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 364   g_return_val_if_fail (G_IS_INET_ADDRESS (address), NULL);
 365
 366   return G_RESOLVER_GET_CLASS (resolver)->
 367     lookup_by_address (resolver, address, cancellable, error);
 368 }
 369
 370 /**
 371  * g_resolver_lookup_by_address_async:
 372  * @resolver: a #GResolver
 373  * @address: the address to reverse-resolve
 374  * @cancellable: a #GCancellable, or %NULL
 375  * @callback: callback to call after resolution completes
 376  * @user_data: data for @callback
 377  *
 378  * Begins asynchronously reverse-resolving @address to determine its
 379  * associated hostname, and eventually calls @callback, which must
 380  * call g_resolver_lookup_by_address_finish() to get the final result.
 381  *
 382  * Since: 2.22
 383  */
 384 void
 385 g_resolver_lookup_by_address_async (GResolver           *resolver,
 386                                     GInetAddress        *address,
 387                                     GCancellable        *cancellable,
 388                                     GAsyncReadyCallback  callback,
 389                                     gpointer             user_data)
 390 {
 391   g_return_if_fail (G_IS_RESOLVER (resolver));
 392   g_return_if_fail (G_IS_INET_ADDRESS (address));
 393
 394   G_RESOLVER_GET_CLASS (resolver)->
 395     lookup_by_address_async (resolver, address, cancellable, callback, user_data);
 396 }
 397
 398 /**
 399  * g_resolver_lookup_by_address_finish:
 400  * @resolver: a #GResolver
 401  * @result: the result passed to your #GAsyncReadyCallback
 402  * @error: return location for a #GError, or %NULL
 403  *
 404  * Retrieves the result of a previous call to
 405  * g_resolver_lookup_by_address_async().
 406  *
 407  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 408  * a value from #GResolverError. If the operation was cancelled,
 409  * @error will be set to %G_IO_ERROR_CANCELLED.
 410  *
 411  * Return value: a hostname (either ASCII-only, or in ASCII-encoded
 412  * form), or %NULL on error.
 413  *
 414  * Since: 2.22
 415  */
 416 gchar *
 417 g_resolver_lookup_by_address_finish (GResolver     *resolver,
 418                                      GAsyncResult  *result,
 419                                      GError       **error)
 420 {
 421   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 422
 423   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 424     {
 425       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 426
 427       if (g_simple_async_result_propagate_error (simple, error))
 428         return NULL;
 429     }
 430
 431   return G_RESOLVER_GET_CLASS (resolver)->
 432     lookup_by_address_finish (resolver, result, error);
 433 }
 434
 435 static gchar *
 436 g_resolver_get_service_rrname (const char *service,
 437                                const char *protocol,
 438                                const char *domain)
 439 {
 440   gchar *rrname, *ascii_domain = NULL;
 441
 442   if (g_hostname_is_non_ascii (domain))
 443     domain = ascii_domain = g_hostname_to_ascii (domain);
 444
 445   rrname = g_strdup_printf ("_%s._%s.%s", service, protocol, domain);
 446
 447   g_free (ascii_domain);
 448   return rrname;
 449 }
 450
 451 /**
 452  * g_resolver_lookup_service:
 453  * @resolver: a #GResolver
 454  * @service: the service type to look up (eg, "ldap")
 455  * @protocol: the networking protocol to use for @service (eg, "tcp")
 456  * @domain: the DNS domain to look up the service in
 457  * @cancellable: a #GCancellable, or %NULL
 458  * @error: return location for a #GError, or %NULL
 459  *
 460  * Synchronously performs a DNS SRV lookup for the given @service and
 461  * @protocol in the given @domain and returns an array of #GSrvTarget.
 462  * @domain may be an ASCII-only or UTF-8 hostname. Note also that the
 463  * @service and @protocol arguments <emphasis>do not</emphasis>
 464  * include the leading underscore that appears in the actual DNS
 465  * entry.
 466  *
 467  * On success, g_resolver_lookup_service() will return a #GList of
 468  * #GSrvTarget, sorted in order of preference. (That is, you should
 469  * attempt to connect to the first target first, then the second if
 470  * the first fails, etc.)
 471  *
 472  * If the DNS resolution fails, @error (if non-%NULL) will be set to
 473  * a value from #GResolverError.
 474  *
 475  * If @cancellable is non-%NULL, it can be used to cancel the
 476  * operation, in which case @error (if non-%NULL) will be set to
 477  * %G_IO_ERROR_CANCELLED.
 478  *
 479  * If you are planning to connect to the service, it is usually easier
 480  * to create a #GNetworkService and use its #GSocketConnectable
 481  * interface.
 482  *
 483  * Return value: a #GList of #GSrvTarget, or %NULL on error. You must
 484  * free each of the targets and the list when you are done with it.
 485  * (You can use g_resolver_free_targets() to do this.)
 486  *
 487  * Since: 2.22
 488  */
 489 GList *
 490 g_resolver_lookup_service (GResolver     *resolver,
 491                            const gchar   *service,
 492                            const gchar   *protocol,
 493                            const gchar   *domain,
 494                            GCancellable  *cancellable,
 495                            GError       **error)
 496 {
 497   GList *targets;
 498   gchar *rrname;
 499
 500   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 501   g_return_val_if_fail (service != NULL, NULL);
 502   g_return_val_if_fail (protocol != NULL, NULL);
 503   g_return_val_if_fail (domain != NULL, NULL);
 504
 505   rrname = g_resolver_get_service_rrname (service, protocol, domain);
 506
 507   targets = G_RESOLVER_GET_CLASS (resolver)->
 508     lookup_service (resolver, rrname, cancellable, error);
 509
 510   g_free (rrname);
 511   return targets;
 512 }
 513
 514 /**
 515  * g_resolver_lookup_service_async:
 516  * @resolver: a #GResolver
 517  * @service: the service type to look up (eg, "ldap")
 518  * @protocol: the networking protocol to use for @service (eg, "tcp")
 519  * @domain: the DNS domain to look up the service in
 520  * @cancellable: a #GCancellable, or %NULL
 521  * @callback: callback to call after resolution completes
 522  * @user_data: data for @callback
 523  *
 524  * Begins asynchronously performing a DNS SRV lookup for the given
 525  * @service and @protocol in the given @domain, and eventually calls
 526  * @callback, which must call g_resolver_lookup_service_finish() to
 527  * get the final result. See g_resolver_lookup_service() for more
 528  * details.
 529  *
 530  * Since: 2.22
 531  */
 532 void
 533 g_resolver_lookup_service_async (GResolver           *resolver,
 534                                  const gchar         *service,
 535                                  const gchar         *protocol,
 536                                  const gchar         *domain,
 537                                  GCancellable        *cancellable,
 538                                  GAsyncReadyCallback  callback,
 539                                  gpointer             user_data)
 540 {
 541   gchar *rrname;
 542
 543   g_return_if_fail (G_IS_RESOLVER (resolver));
 544   g_return_if_fail (service != NULL);
 545   g_return_if_fail (protocol != NULL);
 546   g_return_if_fail (domain != NULL);
 547
 548   rrname = g_resolver_get_service_rrname (service, protocol, domain);
 549
 550   G_RESOLVER_GET_CLASS (resolver)->
 551     lookup_service_async (resolver, rrname, cancellable, callback, user_data);
 552
 553   g_free (rrname);
 554 }
 555
 556 /**
 557  * g_resolver_lookup_service_finish:
 558  * @resolver: a #GResolver
 559  * @result: the result passed to your #GAsyncReadyCallback
 560  * @error: return location for a #GError, or %NULL
 561  *
 562  * Retrieves the result of a previous call to
 563  * g_resolver_lookup_service_async().
 564  *
 565  * If the DNS resolution failed, @error (if non-%NULL) will be set to
 566  * a value from #GResolverError. If the operation was cancelled,
 567  * @error will be set to %G_IO_ERROR_CANCELLED.
 568  *
 569  * Return value: a #GList of #GSrvTarget, or %NULL on error. See
 570  * g_resolver_lookup_service() for more details.
 571  *
 572  * Since: 2.22
 573  */
 574 GList *
 575 g_resolver_lookup_service_finish (GResolver     *resolver,
 576                                   GAsyncResult  *result,
 577                                   GError       **error)
 578 {
 579   g_return_val_if_fail (G_IS_RESOLVER (resolver), NULL);
 580
 581   if (G_IS_SIMPLE_ASYNC_RESULT (result))
 582     {
 583       GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 584
 585       if (g_simple_async_result_propagate_error (simple, error))
 586         return NULL;
 587     }
 588
 589   return G_RESOLVER_GET_CLASS (resolver)->
 590     lookup_service_finish (resolver, result, error);
 591 }
 592
 593 /**
 594  * g_resolver_free_targets:
 595  * @targets: a #GList of #GSrvTarget
 596  *
 597  * Frees @targets (which should be the return value from
 598  * g_resolver_lookup_service() or g_resolver_lookup_service_finish()).
 599  * (This is a convenience method; you can also simply free the
 600  * results by hand.)
 601  *
 602  * Since: 2.22
 603  */
 604 void
 605 g_resolver_free_targets (GList *targets)
 606 {
 607   GList *t;
 608
 609   for (t = targets; t; t = t->next)
 610     g_srv_target_free (t->data);
 611   g_list_free (targets);
 612 }
 613
 614 /**
 615  * g_resolver_error_quark:
 616  *
 617  * Gets the #GResolver Error Quark.
 618  *
 619  * Return value: a #GQuark.
 620  *
 621  * Since: 2.22
 622  */
 623 GQuark
 624 g_resolver_error_quark (void)
 625 {
 626   return g_quark_from_static_string ("g-resolver-error-quark");
 627 }
 628
 629
 630 static GResolverError
 631 g_resolver_error_from_addrinfo_error (gint err)
 632 {
 633   switch (err)
 634     {
 635     case EAI_FAIL:
 636 #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
 637     case EAI_NODATA:
 638 #endif
 639     case EAI_NONAME:
 640       return G_RESOLVER_ERROR_NOT_FOUND;
 641
 642     case EAI_AGAIN:
 643       return G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 644
 645     default:
 646       return G_RESOLVER_ERROR_INTERNAL;
 647     }
 648 }
 649
 650 struct addrinfo _g_resolver_addrinfo_hints;
 651
 652 /* Private method to process a getaddrinfo() response. */
 653 GList *
 654 _g_resolver_addresses_from_addrinfo (const char       *hostname,
 655                                      struct addrinfo  *res,
 656                                      gint              gai_retval,
 657                                      GError          **error)
 658 {
 659   struct addrinfo *ai;
 660   GSocketAddress *sockaddr;
 661   GInetAddress *addr;
 662   GList *addrs;
 663
 664   if (gai_retval != 0)
 665     {
 666       g_set_error (error, G_RESOLVER_ERROR,
 667                    g_resolver_error_from_addrinfo_error (gai_retval),
 668                    _("Error resolving '%s': %s"),
 669                    hostname, gai_strerror (gai_retval));
 670       return NULL;
 671     }
 672
 673   g_return_val_if_fail (res != NULL, NULL);
 674
 675   addrs = NULL;
 676   for (ai = res; ai; ai = ai->ai_next)
 677     {
 678       sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen);
 679       if (!sockaddr || !G_IS_INET_SOCKET_ADDRESS (sockaddr))
 680         continue;
 681
 682       addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr));
 683       addrs = g_list_prepend (addrs, addr);
 684       g_object_unref (sockaddr);
 685     }
 686
 687   return g_list_reverse (addrs);
 688 }
 689
 690 /* Private method to set up a getnameinfo() request */
 691 void
 692 _g_resolver_address_to_sockaddr (GInetAddress            *address,
 693                                  struct sockaddr_storage *sa,
 694                                  gsize                   *sa_len)
 695 {
 696   GSocketAddress *sockaddr;
 697
 698   sockaddr = g_inet_socket_address_new (address, 0);
 699   g_socket_address_to_native (sockaddr, (struct sockaddr *)sa, sizeof (*sa), NULL);
 700   *sa_len = g_socket_address_get_native_size (sockaddr);
 701   g_object_unref (sockaddr);
 702 }
 703
 704 /* Private method to process a getnameinfo() response. */
 705 char *
 706 _g_resolver_name_from_nameinfo (GInetAddress  *address,
 707                                 const gchar   *name,
 708                                 gint           gni_retval,
 709                                 GError       **error)
 710 {
 711   if (gni_retval != 0)
 712     {
 713       gchar *phys;
 714
 715       phys = g_inet_address_to_string (address);
 716       g_set_error (error, G_RESOLVER_ERROR,
 717                    g_resolver_error_from_addrinfo_error (gni_retval),
 718                    _("Error reverse-resolving '%s': %s"),
 719                    phys ? phys : "(unknown)", gai_strerror (gni_retval));
 720       g_free (phys);
 721       return NULL;
 722     }
 723
 724   return g_strdup (name);
 725 }
 726
 727 #if defined(G_OS_UNIX)
 728 /* Private method to process a res_query response into GSrvTargets */
 729 GList *
 730 _g_resolver_targets_from_res_query (const gchar      *rrname,
 731                                     guchar           *answer,
 732                                     gint              len,
 733                                     gint              herr,
 734                                     GError          **error)
 735 {
 736   gint count;
 737   gchar namebuf[1024];
 738   guchar *end, *p;
 739   guint16 type, qclass, rdlength, priority, weight, port;
 740   guint32 ttl;
 741   HEADER *header;
 742   GSrvTarget *target;
 743   GList *targets;
 744
 745   if (len <= 0)
 746     {
 747       GResolverError errnum;
 748       const gchar *format;
 749
 750       if (len == 0 || herr == HOST_NOT_FOUND || herr == NO_DATA)
 751         {
 752           errnum = G_RESOLVER_ERROR_NOT_FOUND;
 753           format = _("No service record for '%s'");
 754         }
 755       else if (herr == TRY_AGAIN)
 756         {
 757           errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 758           format = _("Temporarily unable to resolve '%s'");
 759         }
 760       else
 761         {
 762           errnum = G_RESOLVER_ERROR_INTERNAL;
 763           format = _("Error resolving '%s'");
 764         }
 765
 766       g_set_error (error, G_RESOLVER_ERROR, errnum, format, rrname);
 767       return NULL;
 768     }
 769
 770   targets = NULL;
 771
 772   header = (HEADER *)answer;
 773   p = answer + sizeof (HEADER);
 774   end = answer + len;
 775
 776   /* Skip query */
 777   count = ntohs (header->qdcount);
 778   while (count-- && p < end)
 779     {
 780       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 781       p += 4;
 782     }
 783
 784   /* Read answers */
 785   count = ntohs (header->ancount);
 786   while (count-- && p < end)
 787     {
 788       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 789       GETSHORT (type, p);
 790       GETSHORT (qclass, p);
 791       GETLONG  (ttl, p);
 792       GETSHORT (rdlength, p);
 793
 794       if (type != T_SRV || qclass != C_IN)
 795         {
 796           p += rdlength;
 797           continue;
 798         }
 799
 800       GETSHORT (priority, p);
 801       GETSHORT (weight, p);
 802       GETSHORT (port, p);
 803       p += dn_expand (answer, end, p, namebuf, sizeof (namebuf));
 804
 805       target = g_srv_target_new (namebuf, port, priority, weight);
 806       targets = g_list_prepend (targets, target);
 807     }
 808
 809   return g_srv_target_list_sort (targets);
 810 }
 811 #elif defined(G_OS_WIN32)
 812 /* Private method to process a DnsQuery response into GSrvTargets */
 813 GList *
 814 _g_resolver_targets_from_DnsQuery (const gchar  *rrname,
 815                                    DNS_STATUS    status,
 816                                    DNS_RECORD   *results,
 817                                    GError      **error)
 818 {
 819   DNS_RECORD *rec;
 820   GSrvTarget *target;
 821   GList *targets;
 822
 823   if (status != ERROR_SUCCESS)
 824     {
 825       GResolverError errnum;
 826       const gchar *format;
 827
 828       if (status == DNS_ERROR_RCODE_NAME_ERROR)
 829         {
 830           errnum = G_RESOLVER_ERROR_NOT_FOUND;
 831           format = _("No service record for '%s'");
 832         }
 833       else if (status == DNS_ERROR_RCODE_SERVER_FAILURE)
 834         {
 835           errnum = G_RESOLVER_ERROR_TEMPORARY_FAILURE;
 836           format = _("Temporarily unable to resolve '%s'");
 837         }
 838       else
 839         {
 840           errnum = G_RESOLVER_ERROR_INTERNAL;
 841           format = _("Error resolving '%s'");
 842         }
 843
 844       g_set_error (error, G_RESOLVER_ERROR, errnum, format, rrname);
 845       return NULL;
 846     }
 847
 848   targets = NULL;
 849   for (rec = results; rec; rec = rec->pNext)
 850     {
 851       if (rec->wType != DNS_TYPE_SRV)
 852         continue;
 853
 854       target = g_srv_target_new (rec->Data.SRV.pNameTarget,
 855                                  rec->Data.SRV.wPort,
 856                                  rec->Data.SRV.wPriority,
 857                                  rec->Data.SRV.wWeight);
 858       targets = g_list_prepend (targets, target);
 859     }
 860
 861   return g_srv_target_list_sort (targets);
 862 }
 863
 864 #endif
 865
 866 #define __G_RESOLVER_C__
 867 #include "gioaliasdef.c"