gio/gnetworkaddress.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 <stdlib.h>
  28 #include "gnetworkaddress.h"
  29 #include "gasyncresult.h"
  30 #include "ginetaddress.h"
  31 #include "ginetsocketaddress.h"
  32 #include "gnetworkingprivate.h"
  33 #include "gresolver.h"
  34 #include "gsimpleasyncresult.h"
  35 #include "gsocketaddressenumerator.h"
  36 #include "gioerror.h"
  37 #include "gsocketconnectable.h"
  38
  39 #include <string.h>
  40
  41
  42 /**
  43  * SECTION:gnetworkaddress
  44  * @short_description: A GSocketConnectable for resolving hostnames
  45  * @include: gio/gio.h
  46  *
  47  * #GNetworkAddress provides an easy way to resolve a hostname and
  48  * then attempt to connect to that host, handling the possibility of
  49  * multiple IP addresses and multiple address families.
  50  *
  51  * See #GSocketConnectable for and example of using the connectable
  52  * interface.
  53  */
  54
  55 /**
  56  * GNetworkAddress:
  57  *
  58  * A #GSocketConnectable for resolving a hostname and connecting to
  59  * that host.
  60  */
  61
  62 struct _GNetworkAddressPrivate {
  63   gchar *hostname;
  64   guint16 port;
  65   GList *sockaddrs;
  66   gchar *scheme;
  67 };
  68
  69 enum {
  70   PROP_0,
  71   PROP_HOSTNAME,
  72   PROP_PORT,
  73   PROP_SCHEME,
  74 };
  75
  76 static void g_network_address_set_property (GObject      *object,
  77                                             guint         prop_id,
  78                                             const GValue *value,
  79                                             GParamSpec   *pspec);
  80 static void g_network_address_get_property (GObject      *object,
  81                                             guint         prop_id,
  82                                             GValue       *value,
  83                                             GParamSpec   *pspec);
  84
  85 static void                      g_network_address_connectable_iface_init (GSocketConnectableIface *iface);
  86 static GSocketAddressEnumerator *g_network_address_connectable_enumerate  (GSocketConnectable      *connectable);
  87
  88 G_DEFINE_TYPE_WITH_CODE (GNetworkAddress, g_network_address, G_TYPE_OBJECT,
  89                          G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
  90                                                 g_network_address_connectable_iface_init))
  91
  92 static void
  93 g_network_address_finalize (GObject *object)
  94 {
  95   GNetworkAddress *addr = G_NETWORK_ADDRESS (object);
  96
  97   g_free (addr->priv->hostname);
  98   g_free (addr->priv->scheme);
  99
 100   if (addr->priv->sockaddrs)
 101     {
 102       GList *a;
 103
 104       for (a = addr->priv->sockaddrs; a; a = a->next)
 105         g_object_unref (a->data);
 106       g_list_free (addr->priv->sockaddrs);
 107     }
 108
 109   G_OBJECT_CLASS (g_network_address_parent_class)->finalize (object);
 110 }
 111
 112 static void
 113 g_network_address_class_init (GNetworkAddressClass *klass)
 114 {
 115   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 116
 117   g_type_class_add_private (klass, sizeof (GNetworkAddressPrivate));
 118
 119   gobject_class->set_property = g_network_address_set_property;
 120   gobject_class->get_property = g_network_address_get_property;
 121   gobject_class->finalize = g_network_address_finalize;
 122
 123   g_object_class_install_property (gobject_class, PROP_HOSTNAME,
 124                                    g_param_spec_string ("hostname",
 125                                                         P_("Hostname"),
 126                                                         P_("Hostname to resolve"),
 127                                                         NULL,
 128                                                         G_PARAM_READWRITE |
 129                                                         G_PARAM_CONSTRUCT_ONLY |
 130                                                         G_PARAM_STATIC_STRINGS));
 131   g_object_class_install_property (gobject_class, PROP_PORT,
 132                                    g_param_spec_uint ("port",
 133                                                       P_("Port"),
 134                                                       P_("Network port"),
 135                                                       0, 65535, 0,
 136                                                       G_PARAM_READWRITE |
 137                                                       G_PARAM_CONSTRUCT_ONLY |
 138                                                       G_PARAM_STATIC_STRINGS));
 139
 140   g_object_class_install_property (gobject_class, PROP_SCHEME,
 141                                    g_param_spec_string ("scheme",
 142                                                         P_("Scheme"),
 143                                                         P_("URI Scheme"),
 144                                                         NULL,
 145                                                         G_PARAM_READWRITE |
 146                                                         G_PARAM_CONSTRUCT_ONLY |
 147                                                         G_PARAM_STATIC_STRINGS));
 148 }
 149
 150 static void
 151 g_network_address_connectable_iface_init (GSocketConnectableIface *connectable_iface)
 152 {
 153   connectable_iface->enumerate  = g_network_address_connectable_enumerate;
 154 }
 155
 156 static void
 157 g_network_address_init (GNetworkAddress *addr)
 158 {
 159   addr->priv = G_TYPE_INSTANCE_GET_PRIVATE (addr, G_TYPE_NETWORK_ADDRESS,
 160                                             GNetworkAddressPrivate);
 161 }
 162
 163 static void
 164 g_network_address_set_property (GObject      *object,
 165                                 guint         prop_id,
 166                                 const GValue *value,
 167                                 GParamSpec   *pspec)
 168 {
 169   GNetworkAddress *addr = G_NETWORK_ADDRESS (object);
 170
 171   switch (prop_id)
 172     {
 173     case PROP_HOSTNAME:
 174       g_free (addr->priv->hostname);
 175       addr->priv->hostname = g_value_dup_string (value);
 176       break;
 177
 178     case PROP_PORT:
 179       addr->priv->port = g_value_get_uint (value);
 180       break;
 181
 182     case PROP_SCHEME:
 183       if (addr->priv->scheme)
 184         g_free (addr->priv->scheme);
 185       addr->priv->scheme = g_value_dup_string (value);
 186       break;
 187
 188     default:
 189       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 190       break;
 191     }
 192
 193 }
 194
 195 static void
 196 g_network_address_get_property (GObject    *object,
 197                                 guint       prop_id,
 198                                 GValue     *value,
 199                                 GParamSpec *pspec)
 200 {
 201   GNetworkAddress *addr = G_NETWORK_ADDRESS (object);
 202
 203   switch (prop_id)
 204     {
 205     case PROP_HOSTNAME:
 206       g_value_set_string (value, addr->priv->hostname);
 207       break;
 208
 209     case PROP_PORT:
 210       g_value_set_uint (value, addr->priv->port);
 211       break;
 212
 213     case PROP_SCHEME:
 214       g_value_set_string (value, addr->priv->scheme);
 215       break;
 216
 217     default:
 218       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 219       break;
 220     }
 221
 222 }
 223
 224 static void
 225 g_network_address_set_addresses (GNetworkAddress *addr,
 226                                  GList           *addresses)
 227 {
 228   GList *a;
 229   GSocketAddress *sockaddr;
 230
 231   g_return_if_fail (addresses != NULL && addr->priv->sockaddrs == NULL);
 232
 233   for (a = addresses; a; a = a->next)
 234     {
 235       sockaddr = g_inet_socket_address_new (a->data, addr->priv->port);
 236       addr->priv->sockaddrs = g_list_prepend (addr->priv->sockaddrs, sockaddr);
 237       g_object_unref (a->data);
 238     }
 239   g_list_free (addresses);
 240   addr->priv->sockaddrs = g_list_reverse (addr->priv->sockaddrs);
 241 }
 242
 243 /**
 244  * g_network_address_new:
 245  * @hostname: the hostname
 246  * @port: the port
 247  *
 248  * Creates a new #GSocketConnectable for connecting to the given
 249  * @hostname and @port.
 250  *
 251  * Return value: the new #GNetworkAddress
 252  *
 253  * Since: 2.22
 254  */
 255 GSocketConnectable *
 256 g_network_address_new (const gchar *hostname,
 257                        guint16      port)
 258 {
 259   return g_object_new (G_TYPE_NETWORK_ADDRESS,
 260                        "hostname", hostname,
 261                        "port", port,
 262                        NULL);
 263 }
 264
 265 /**
 266  * g_network_address_parse:
 267  * @host_and_port: the hostname and optionally a port
 268  * @default_port: the default port if not in @host_and_port
 269  * @error: a pointer to a #GError, or %NULL
 270  *
 271  * Creates a new #GSocketConnectable for connecting to the given
 272  * @hostname and @port. May fail and return %NULL in case
 273  * parsing @host_and_port fails.
 274  *
 275  * @host_and_port may be in any of a number of recognised formats: an IPv6
 276  * address, an IPv4 address, or a domain name (in which case a DNS
 277  * lookup is performed). Quoting with [] is supported for all address
 278  * types. A port override may be specified in the usual way with a
 279  * colon. Ports may be given as decimal numbers or symbolic names (in
 280  * which case an /etc/services lookup is performed).
 281  *
 282  * If no port is specified in @host_and_port then @default_port will be
 283  * used as the port number to connect to.
 284  *
 285  * In general, @host_and_port is expected to be provided by the user
 286  * (allowing them to give the hostname, and a port overide if necessary)
 287  * and @default_port is expected to be provided by the application.
 288  *
 289  * Return value: the new #GNetworkAddress, or %NULL on error
 290  *
 291  * Since: 2.22
 292  */
 293 GSocketConnectable *
 294 g_network_address_parse (const gchar  *host_and_port,
 295                          guint16       default_port,
 296                          GError      **error)
 297 {
 298   GSocketConnectable *connectable;
 299   const gchar *port;
 300   guint16 portnum;
 301   gchar *name;
 302
 303   g_return_val_if_fail (host_and_port != NULL, NULL);
 304
 305   port = NULL;
 306   if (host_and_port[0] == '[')
 307     /* escaped host part (to allow, eg. "[2001:db8::1]:888") */
 308     {
 309       const gchar *end;
 310
 311       end = strchr (host_and_port, ']');
 312       if (end == NULL)
 313         {
 314           g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 315                        _("Hostname '%s' contains '[' but not ']'"), host_and_port);
 316           return NULL;
 317         }
 318
 319       if (end[1] == '\0')
 320         port = NULL;
 321       else if (end[1] == ':')
 322         port = &end[2];
 323       else
 324         {
 325           g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 326                        "The ']' character (in hostname '%s') must come at the"
 327                        " end or be immediately followed by ':' and a port",
 328                        host_and_port);
 329           return NULL;
 330         }
 331
 332       name = g_strndup (host_and_port + 1, end - host_and_port - 1);
 333     }
 334
 335   else if ((port = strchr (host_and_port, ':')))
 336     /* string has a ':' in it */
 337     {
 338       /* skip ':' */
 339       port++;
 340
 341       if (strchr (port, ':'))
 342         /* more than one ':' in string */
 343         {
 344           /* this is actually an unescaped IPv6 address */
 345           name = g_strdup (host_and_port);
 346           port = NULL;
 347         }
 348       else
 349         name = g_strndup (host_and_port, port - host_and_port - 1);
 350     }
 351
 352   else
 353     /* plain hostname, no port */
 354     name = g_strdup (host_and_port);
 355
 356   if (port != NULL)
 357     {
 358       if (port[0] == '\0')
 359         {
 360           g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 361                        "If a ':' character is given, it must be followed by a "
 362                        "port (in hostname '%s').", host_and_port);
 363           g_free (name);
 364           return NULL;
 365         }
 366
 367       else if ('0' <= port[0] && port[0] <= '9')
 368         {
 369           char *end;
 370           long value;
 371
 372           value = strtol (port, &end, 10);
 373           if (*end != '\0' || value < 0 || value > G_MAXUINT16)
 374             {
 375               g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 376                            "Invalid numeric port '%s' specified in hostname '%s'",
 377                            port, host_and_port);
 378               g_free (name);
 379               return NULL;
 380             }
 381
 382           portnum = value;
 383         }
 384
 385       else
 386         {
 387           struct servent *entry;
 388
 389           entry = getservbyname (port, "tcp");
 390           if (entry == NULL)
 391             {
 392               g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 393                            "Unknown service '%s' specified in hostname '%s'",
 394                            port, host_and_port);
 395 #ifdef HAVE_ENDSERVENT
 396               endservent ();
 397 #endif
 398               g_free (name);
 399               return NULL;
 400             }
 401
 402           portnum = g_ntohs (entry->s_port);
 403
 404 #ifdef HAVE_ENDSERVENT
 405           endservent ();
 406 #endif
 407         }
 408     }
 409   else
 410     {
 411       /* No port in host_and_port */
 412       portnum = default_port;
 413     }
 414
 415   connectable = g_network_address_new (name, portnum);
 416   g_free (name);
 417
 418   return connectable;
 419 }
 420
 421 /* Allowed characters outside alphanumeric for unreserved. */
 422 #define G_URI_OTHER_UNRESERVED "-._~"
 423
 424 /* This or something equivalent will eventually go into glib/guri.h */
 425 gboolean
 426 _g_uri_parse_authority (const char  *uri,
 427                         char       **host,
 428                         guint16     *port,
 429                         char       **userinfo)
 430 {
 431   char *tmp_str;
 432   const char *start, *p;
 433   char c;
 434
 435   g_return_val_if_fail (uri != NULL, FALSE);
 436
 437   if (host)
 438     *host = NULL;
 439
 440   if (port)
 441     *port = 0;
 442
 443   if (userinfo)
 444     *userinfo = NULL;
 445
 446   /* From RFC 3986 Decodes:
 447    * URI          = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
 448    * hier-part    = "//" authority path-abempty
 449    * path-abempty = *( "/" segment )
 450    * authority    = [ userinfo "@" ] host [ ":" port ]
 451    */
 452
 453   /* Check we have a valid scheme */
 454   tmp_str = g_uri_parse_scheme (uri);
 455
 456   if (tmp_str == NULL)
 457     return FALSE;
 458
 459   g_free (tmp_str);
 460
 461   /* Decode hier-part:
 462    *  hier-part   = "//" authority path-abempty
 463    */
 464   p = uri;
 465   start = strstr (p, "//");
 466
 467   if (start == NULL)
 468     return FALSE;
 469
 470   start += 2;
 471   p = strchr (start, '@');
 472
 473   if (p != NULL)
 474     {
 475       /* Decode userinfo:
 476        * userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
 477        * unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
 478        * pct-encoded   = "%" HEXDIG HEXDIG
 479        */
 480       while (1)
 481         {
 482           c = *p++;
 483
 484           if (c == '@')
 485             break;
 486
 487           /* pct-encoded */
 488           if (c == '%')
 489             {
 490               if (!(g_ascii_isxdigit (p[0]) ||
 491                     g_ascii_isxdigit (p[1])))
 492                 return FALSE;
 493
 494               p++;
 495
 496               continue;
 497             }
 498
 499           /* unreserved /  sub-delims / : */
 500           if (!(g_ascii_isalnum(c) ||
 501                 strchr (G_URI_OTHER_UNRESERVED, c) ||
 502                 strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) ||
 503                 c == ':'))
 504             return FALSE;
 505         }
 506
 507       if (userinfo)
 508         *userinfo = g_strndup (start, p - start - 1);
 509
 510       start = p;
 511     }
 512   else
 513     {
 514       p = start;
 515     }
 516
 517
 518   /* decode host:
 519    * host          = IP-literal / IPv4address / reg-name
 520    * reg-name      = *( unreserved / pct-encoded / sub-delims )
 521    */
 522
 523   /* If IPv6 or IPvFuture */
 524   if (*p == '[')
 525     {
 526       while (1)
 527         {
 528           c = *p++;
 529
 530           if (c == ']')
 531             break;
 532
 533           /* unreserved /  sub-delims */
 534           if (!(g_ascii_isalnum(c) ||
 535                 strchr (G_URI_OTHER_UNRESERVED, c) ||
 536                 strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) ||
 537                 c == ':' ||
 538                 c == '.'))
 539             goto error;
 540         }
 541     }
 542   else
 543     {
 544       while (1)
 545         {
 546           c = *p++;
 547
 548           if (c == ':' ||
 549               c == '/' ||
 550               c == '?' ||
 551               c == '#' ||
 552               c == '\0')
 553             break;
 554
 555           /* pct-encoded */
 556           if (c == '%')
 557             {
 558               if (!(g_ascii_isxdigit (p[0]) ||
 559                     g_ascii_isxdigit (p[1])))
 560                 goto error;
 561
 562               p++;
 563
 564               continue;
 565             }
 566
 567           /* unreserved /  sub-delims */
 568           if (!(g_ascii_isalnum(c) ||
 569                 strchr (G_URI_OTHER_UNRESERVED, c) ||
 570                 strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c)))
 571             goto error;
 572         }
 573     }
 574
 575   if (host)
 576     *host = g_uri_unescape_segment (start, p - 1, NULL);
 577
 578   if (c == ':')
 579     {
 580       /* Decode pot:
 581        *  port          = *DIGIT
 582        */
 583       guint tmp = 0;
 584
 585       while (1)
 586         {
 587           c = *p++;
 588
 589           if (c == '/' ||
 590               c == '?' ||
 591               c == '#' ||
 592               c == '\0')
 593             break;
 594
 595           if (!g_ascii_isdigit (c))
 596             goto error;
 597
 598           tmp = (tmp * 10) + (c - '0');
 599
 600           if (tmp > 65535)
 601             goto error;
 602         }
 603       if (port)
 604         *port = (guint16) tmp;
 605     }
 606
 607   return TRUE;
 608
 609 error:
 610   if (host && *host)
 611     {
 612       g_free (*host);
 613       *host = NULL;
 614     }
 615
 616   if (userinfo && *userinfo)
 617     {
 618       g_free (*userinfo);
 619       *userinfo = NULL;
 620     }
 621
 622   return FALSE;
 623 }
 624
 625 /**
 626  * g_network_address_parse_uri:
 627  * @uri: the hostname and optionally a port
 628  * @default_port: The default port if none is found in the URI
 629  * @error: a pointer to a #GError, or %NULL
 630  *
 631  * Creates a new #GSocketConnectable for connecting to the given
 632  * @uri. May fail and return %NULL in case parsing @uri fails.
 633  *
 634  * Using this rather than g_network_address_new() or
 635  * g_network_address_parse_host() allows #GSocketClient to determine
 636  * when to use application-specific proxy protocols.
 637  *
 638  * Return value: the new #GNetworkAddress, or %NULL on error
 639  *
 640  * Since: 2.26
 641  */
 642 GSocketConnectable *
 643 g_network_address_parse_uri (const gchar  *uri,
 644                              guint16       default_port,
 645                              GError      **error)
 646 {
 647   GSocketConnectable *conn;
 648   gchar *scheme;
 649   gchar *hostname;
 650   guint16 port;
 651
 652   if (!_g_uri_parse_authority (uri, &hostname, &port, NULL))
 653     {
 654       g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 655                    "Invalid URI '%s'",
 656                    uri);
 657       return NULL;
 658     }
 659
 660   if (port == 0)
 661     port = default_port;
 662
 663   scheme = g_uri_parse_scheme (uri);
 664
 665   conn = g_object_new (G_TYPE_NETWORK_ADDRESS,
 666                        "hostname", hostname,
 667                        "port", port,
 668                        "scheme", scheme,
 669                        NULL);
 670
 671   g_free (scheme);
 672   g_free (hostname);
 673
 674   return conn;
 675 }
 676
 677 /**
 678  * g_network_address_get_hostname:
 679  * @addr: a #GNetworkAddress
 680  *
 681  * Gets @addr's hostname. This might be either UTF-8 or ASCII-encoded,
 682  * depending on what @addr was created with.
 683  *
 684  * Return value: @addr's hostname
 685  *
 686  * Since: 2.22
 687  */
 688 const gchar *
 689 g_network_address_get_hostname (GNetworkAddress *addr)
 690 {
 691   g_return_val_if_fail (G_IS_NETWORK_ADDRESS (addr), NULL);
 692
 693   return addr->priv->hostname;
 694 }
 695
 696 /**
 697  * g_network_address_get_port:
 698  * @addr: a #GNetworkAddress
 699  *
 700  * Gets @addr's port number
 701  *
 702  * Return value: @addr's port (which may be 0)
 703  *
 704  * Since: 2.22
 705  */
 706 guint16
 707 g_network_address_get_port (GNetworkAddress *addr)
 708 {
 709   g_return_val_if_fail (G_IS_NETWORK_ADDRESS (addr), 0);
 710
 711   return addr->priv->port;
 712 }
 713
 714 /**
 715  * g_network_address_get_scheme:
 716  * @addr: a #GNetworkAddress
 717  *
 718  * Gets @addr's scheme
 719  *
 720  * Return value: @addr's scheme (%NULL if not built from URI)
 721  *
 722  * Since: 2.26
 723  */
 724 const gchar *
 725 g_network_address_get_scheme (GNetworkAddress *addr)
 726 {
 727   g_return_val_if_fail (G_IS_NETWORK_ADDRESS (addr), NULL);
 728
 729   return addr->priv->scheme;
 730 }
 731
 732 #define G_TYPE_NETWORK_ADDRESS_ADDRESS_ENUMERATOR (_g_network_address_address_enumerator_get_type ())
 733 #define G_NETWORK_ADDRESS_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_NETWORK_ADDRESS_ADDRESS_ENUMERATOR, GNetworkAddressAddressEnumerator))
 734
 735 typedef struct {
 736   GSocketAddressEnumerator parent_instance;
 737
 738   GNetworkAddress *addr;
 739   GList *a;
 740 } GNetworkAddressAddressEnumerator;
 741
 742 typedef struct {
 743   GSocketAddressEnumeratorClass parent_class;
 744
 745 } GNetworkAddressAddressEnumeratorClass;
 746
 747 G_DEFINE_TYPE (GNetworkAddressAddressEnumerator, _g_network_address_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)
 748
 749 static void
 750 g_network_address_address_enumerator_finalize (GObject *object)
 751 {
 752   GNetworkAddressAddressEnumerator *addr_enum =
 753     G_NETWORK_ADDRESS_ADDRESS_ENUMERATOR (object);
 754
 755   g_object_unref (addr_enum->addr);
 756
 757   G_OBJECT_CLASS (_g_network_address_address_enumerator_parent_class)->finalize (object);
 758 }
 759
 760 static GSocketAddress *
 761 g_network_address_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
 762                                            GCancellable              *cancellable,
 763                                            GError                   **error)
 764 {
 765   GNetworkAddressAddressEnumerator *addr_enum =
 766     G_NETWORK_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
 767   GSocketAddress *sockaddr;
 768
 769   if (!addr_enum->addr->priv->sockaddrs)
 770     {
 771       GResolver *resolver = g_resolver_get_default ();
 772       GList *addresses;
 773
 774       addresses = g_resolver_lookup_by_name (resolver,
 775                                              addr_enum->addr->priv->hostname,
 776                                              cancellable, error);
 777       g_object_unref (resolver);
 778
 779       if (!addresses)
 780         return NULL;
 781
 782       g_network_address_set_addresses (addr_enum->addr, addresses);
 783       addr_enum->a = addr_enum->addr->priv->sockaddrs;
 784     }
 785
 786   if (!addr_enum->a)
 787     return NULL;
 788   else
 789     {
 790       sockaddr = addr_enum->a->data;
 791       addr_enum->a = addr_enum->a->next;
 792       return g_object_ref (sockaddr);
 793     }
 794 }
 795
 796 static void
 797 got_addresses (GObject      *source_object,
 798                GAsyncResult *result,
 799                gpointer      user_data)
 800 {
 801   GSimpleAsyncResult *simple = user_data;
 802   GNetworkAddressAddressEnumerator *addr_enum =
 803     g_simple_async_result_get_op_res_gpointer (simple);
 804   GResolver *resolver = G_RESOLVER (source_object);
 805   GList *addresses;
 806   GError *error = NULL;
 807
 808   addresses = g_resolver_lookup_by_name_finish (resolver, result, &error);
 809   if (!addr_enum->addr->priv->sockaddrs)
 810     {
 811       if (error)
 812         {
 813           g_simple_async_result_set_from_error (simple, error);
 814           g_error_free (error);
 815         }
 816       else
 817         {
 818           g_network_address_set_addresses (addr_enum->addr, addresses);
 819           addr_enum->a = addr_enum->addr->priv->sockaddrs;
 820         }
 821     }
 822   else if (error)
 823     g_error_free (error);
 824
 825   g_object_unref (resolver);
 826
 827   g_simple_async_result_complete (simple);
 828   g_object_unref (simple);
 829 }
 830
 831 static void
 832 g_network_address_address_enumerator_next_async (GSocketAddressEnumerator  *enumerator,
 833                                                  GCancellable              *cancellable,
 834                                                  GAsyncReadyCallback        callback,
 835                                                  gpointer                   user_data)
 836 {
 837   GNetworkAddressAddressEnumerator *addr_enum =
 838     G_NETWORK_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
 839   GSimpleAsyncResult *simple;
 840
 841   simple = g_simple_async_result_new (G_OBJECT (enumerator),
 842                                       callback, user_data,
 843                                       g_network_address_address_enumerator_next_async);
 844
 845   if (!addr_enum->addr->priv->sockaddrs)
 846     {
 847       GResolver *resolver = g_resolver_get_default ();
 848
 849       g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (addr_enum), g_object_unref);
 850       g_resolver_lookup_by_name_async (resolver,
 851                                        addr_enum->addr->priv->hostname,
 852                                        cancellable,
 853                                        got_addresses, simple);
 854     }
 855   else
 856     {
 857       g_simple_async_result_complete_in_idle (simple);
 858       g_object_unref (simple);
 859     }
 860 }
 861
 862 static GSocketAddress *
 863 g_network_address_address_enumerator_next_finish (GSocketAddressEnumerator  *enumerator,
 864                                                   GAsyncResult              *result,
 865                                                   GError                   **error)
 866 {
 867   GNetworkAddressAddressEnumerator *addr_enum =
 868     G_NETWORK_ADDRESS_ADDRESS_ENUMERATOR (enumerator);
 869   GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
 870   GSocketAddress *sockaddr;
 871
 872   if (g_simple_async_result_propagate_error (simple, error))
 873     return NULL;
 874   else if (!addr_enum->a)
 875     return NULL;
 876   else
 877     {
 878       sockaddr = addr_enum->a->data;
 879       addr_enum->a = addr_enum->a->next;
 880       return g_object_ref (sockaddr);
 881     }
 882 }
 883
 884 static void
 885 _g_network_address_address_enumerator_init (GNetworkAddressAddressEnumerator *enumerator)
 886 {
 887 }
 888
 889 static void
 890 _g_network_address_address_enumerator_class_init (GNetworkAddressAddressEnumeratorClass *addrenum_class)
 891 {
 892   GObjectClass *object_class = G_OBJECT_CLASS (addrenum_class);
 893   GSocketAddressEnumeratorClass *enumerator_class =
 894     G_SOCKET_ADDRESS_ENUMERATOR_CLASS (addrenum_class);
 895
 896   enumerator_class->next = g_network_address_address_enumerator_next;
 897   enumerator_class->next_async = g_network_address_address_enumerator_next_async;
 898   enumerator_class->next_finish = g_network_address_address_enumerator_next_finish;
 899   object_class->finalize = g_network_address_address_enumerator_finalize;
 900 }
 901
 902 static GSocketAddressEnumerator *
 903 g_network_address_connectable_enumerate (GSocketConnectable *connectable)
 904 {
 905   GNetworkAddressAddressEnumerator *addr_enum;
 906
 907   addr_enum = g_object_new (G_TYPE_NETWORK_ADDRESS_ADDRESS_ENUMERATOR, NULL);
 908   addr_enum->addr = g_object_ref (connectable);
 909
 910   return (GSocketAddressEnumerator *)addr_enum;
 911 }