gio/gnetworkservice.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  * SPDX-License-Identifier: LGPL-2.1-or-later
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General
  20  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "config.h"
  24 #include <glib.h>
  25 #include "glibintl.h"
  26
  27 #include "gnetworkservice.h"
  28
  29 #include "gcancellable.h"
  30 #include "ginetaddress.h"
  31 #include "ginetsocketaddress.h"
  32 #include "gioerror.h"
  33 #include "gnetworkaddress.h"
  34 #include "gnetworkingprivate.h"
  35 #include "gresolver.h"
  36 #include "gtask.h"
  37 #include "gsocketaddressenumerator.h"
  38 #include "gsocketconnectable.h"
  39 #include "gsrvtarget.h"
  40
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44
  45 /**
  46  * SECTION:gnetworkservice
  47  * @short_description: A GSocketConnectable for resolving SRV records
  48  * @include: gio/gio.h
  49  *
  50  * Like #GNetworkAddress does with hostnames, #GNetworkService
  51  * provides an easy way to resolve a SRV record, and then attempt to
  52  * connect to one of the hosts that implements that service, handling
  53  * service priority/weighting, multiple IP addresses, and multiple
  54  * address families.
  55  *
  56  * See #GSrvTarget for more information about SRV records, and see
  57  * #GSocketConnectable for an example of using the connectable
  58  * interface.
  59  */
  60
  61 /**
  62  * GNetworkService:
  63  *
  64  * A #GSocketConnectable for resolving a SRV record and connecting to
  65  * that service.
  66  */
  67
  68 struct _GNetworkServicePrivate
  69 {
  70   gchar *service, *protocol, *domain, *scheme;
  71   GList *targets;
  72 };
  73
  74 enum {
  75   PROP_0,
  76   PROP_SERVICE,
  77   PROP_PROTOCOL,
  78   PROP_DOMAIN,
  79   PROP_SCHEME
  80 };
  81
  82 static void g_network_service_set_property (GObject      *object,
  83                                             guint         prop_id,
  84                                             const GValue *value,
  85                                             GParamSpec   *pspec);
  86 static void g_network_service_get_property (GObject      *object,
  87                                             guint         prop_id,
  88                                             GValue       *value,
  89                                             GParamSpec   *pspec);
  90
  91 static void                      g_network_service_connectable_iface_init       (GSocketConnectableIface *iface);
  92 static GSocketAddressEnumerator *g_network_service_connectable_enumerate        (GSocketConnectable      *connectable);
  93 static GSocketAddressEnumerator *g_network_service_connectable_proxy_enumerate  (GSocketConnectable      *connectable);
  94 static gchar                    *g_network_service_connectable_to_string        (GSocketConnectable      *connectable);
  95
  96 G_DEFINE_TYPE_WITH_CODE (GNetworkService, g_network_service, G_TYPE_OBJECT,
  97                          G_ADD_PRIVATE (GNetworkService)
  98                          G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
  99                                                 g_network_service_connectable_iface_init))
 100
 101 static void
 102 g_network_service_finalize (GObject *object)
 103 {
 104   GNetworkService *srv = G_NETWORK_SERVICE (object);
 105
 106   g_free (srv->priv->service);
 107   g_free (srv->priv->protocol);
 108   g_free (srv->priv->domain);
 109   g_free (srv->priv->scheme);
 110
 111   if (srv->priv->targets)
 112     g_resolver_free_targets (srv->priv->targets);
 113
 114   G_OBJECT_CLASS (g_network_service_parent_class)->finalize (object);
 115 }
 116
 117 static void
 118 g_network_service_class_init (GNetworkServiceClass *klass)
 119 {
 120   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 121
 122   gobject_class->set_property = g_network_service_set_property;
 123   gobject_class->get_property = g_network_service_get_property;
 124   gobject_class->finalize = g_network_service_finalize;
 125
 126   g_object_class_install_property (gobject_class, PROP_SERVICE,
 127                                    g_param_spec_string ("service",
 128                                                         P_("Service"),
 129                                                         P_("Service name, eg \"ldap\""),
 130                                                         NULL,
 131                                                         G_PARAM_READWRITE |
 132                                                         G_PARAM_CONSTRUCT_ONLY |
 133                                                         G_PARAM_STATIC_STRINGS));
 134   g_object_class_install_property (gobject_class, PROP_PROTOCOL,
 135                                    g_param_spec_string ("protocol",
 136                                                         P_("Protocol"),
 137                                                         P_("Network protocol, eg \"tcp\""),
 138                                                         NULL,
 139                                                         G_PARAM_READWRITE |
 140                                                         G_PARAM_CONSTRUCT_ONLY |
 141                                                         G_PARAM_STATIC_STRINGS));
 142   g_object_class_install_property (gobject_class, PROP_DOMAIN,
 143                                    g_param_spec_string ("domain",
 144                                                         P_("Domain"),
 145                                                         P_("Network domain, eg, \"example.com\""),
 146                                                         NULL,
 147                                                         G_PARAM_READWRITE |
 148                                                         G_PARAM_CONSTRUCT_ONLY |
 149                                                         G_PARAM_STATIC_STRINGS));
 150   g_object_class_install_property (gobject_class, PROP_DOMAIN,
 151                                    g_param_spec_string ("scheme",
 152                                                         P_("Scheme"),
 153                                                         P_("Network scheme (default is to use service)"),
 154                                                         NULL,
 155                                                         G_PARAM_READWRITE |
 156                                                         G_PARAM_STATIC_STRINGS));
 157
 158 }
 159
 160 static void
 161 g_network_service_connectable_iface_init (GSocketConnectableIface *connectable_iface)
 162 {
 163   connectable_iface->enumerate = g_network_service_connectable_enumerate;
 164   connectable_iface->proxy_enumerate = g_network_service_connectable_proxy_enumerate;
 165   connectable_iface->to_string = g_network_service_connectable_to_string;
 166 }
 167
 168 static void
 169 g_network_service_init (GNetworkService *srv)
 170 {
 171   srv->priv = g_network_service_get_instance_private (srv);
 172 }
 173
 174 static void
 175 g_network_service_set_property (GObject      *object,
 176                                 guint         prop_id,
 177                                 const GValue *value,
 178                                 GParamSpec   *pspec)
 179 {
 180   GNetworkService *srv = G_NETWORK_SERVICE (object);
 181
 182   switch (prop_id)
 183     {
 184     case PROP_SERVICE:
 185       srv->priv->service = g_value_dup_string (value);
 186       break;
 187
 188     case PROP_PROTOCOL:
 189       srv->priv->protocol = g_value_dup_string (value);
 190       break;
 191
 192     case PROP_DOMAIN:
 193       srv->priv->domain = g_value_dup_string (value);
 194       break;
 195
 196     case PROP_SCHEME:
 197       g_network_service_set_scheme (srv, g_value_get_string (value));
 198       break;
 199
 200     default:
 201       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 202       break;
 203     }
 204 }
 205
 206 static void
 207 g_network_service_get_property (GObject    *object,
 208                                 guint       prop_id,
 209                                 GValue     *value,
 210                                 GParamSpec *pspec)
 211 {
 212   GNetworkService *srv = G_NETWORK_SERVICE (object);
 213
 214   switch (prop_id)
 215     {
 216     case PROP_SERVICE:
 217       g_value_set_string (value, g_network_service_get_service (srv));
 218       break;
 219
 220     case PROP_PROTOCOL:
 221       g_value_set_string (value, g_network_service_get_protocol (srv));
 222       break;
 223
 224     case PROP_DOMAIN:
 225       g_value_set_string (value, g_network_service_get_domain (srv));
 226       break;
 227
 228     case PROP_SCHEME:
 229       g_value_set_string (value, g_network_service_get_scheme (srv));
 230       break;
 231
 232     default:
 233       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 234       break;
 235     }
 236 }
 237
 238 /**
 239  * g_network_service_new:
 240  * @service: the service type to look up (eg, "ldap")
 241  * @protocol: the networking protocol to use for @service (eg, "tcp")
 242  * @domain: the DNS domain to look up the service in
 243  *
 244  * Creates a new #GNetworkService representing the given @service,
 245  * @protocol, and @domain. This will initially be unresolved; use the
 246  * #GSocketConnectable interface to resolve it.
 247  *
 248  * Returns: (transfer full) (type GNetworkService): a new #GNetworkService
 249  *
 250  * Since: 2.22
 251  */
 252 GSocketConnectable *
 253 g_network_service_new (const gchar *service,
 254                        const gchar *protocol,
 255                        const gchar *domain)
 256 {
 257   return g_object_new (G_TYPE_NETWORK_SERVICE,
 258                        "service", service,
 259                        "protocol", protocol,
 260                        "domain", domain,
 261                        NULL);
 262 }
 263
 264 /**
 265  * g_network_service_get_service:
 266  * @srv: a #GNetworkService
 267  *
 268  * Gets @srv's service name (eg, "ldap").
 269  *
 270  * Returns: @srv's service name
 271  *
 272  * Since: 2.22
 273  */
 274 const gchar *
 275 g_network_service_get_service (GNetworkService *srv)
 276 {
 277   g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);
 278
 279   return srv->priv->service;
 280 }
 281
 282 /**
 283  * g_network_service_get_protocol:
 284  * @srv: a #GNetworkService
 285  *
 286  * Gets @srv's protocol name (eg, "tcp").
 287  *
 288  * Returns: @srv's protocol name
 289  *
 290  * Since: 2.22
 291  */
 292 const gchar *
 293 g_network_service_get_protocol (GNetworkService *srv)
 294 {
 295   g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);
 296
 297   return srv->priv->protocol;
 298 }
 299
 300 /**
 301  * g_network_service_get_domain:
 302  * @srv: a #GNetworkService
 303  *
 304  * Gets the domain that @srv serves. This might be either UTF-8 or
 305  * ASCII-encoded, depending on what @srv was created with.
 306  *
 307  * Returns: @srv's domain name
 308  *
 309  * Since: 2.22
 310  */
 311 const gchar *
 312 g_network_service_get_domain (GNetworkService *srv)
 313 {
 314   g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);
 315
 316   return srv->priv->domain;
 317 }
 318
 319 /**
 320  * g_network_service_get_scheme:
 321  * @srv: a #GNetworkService
 322  *
 323  * Gets the URI scheme used to resolve proxies. By default, the service name
 324  * is used as scheme.
 325  *
 326  * Returns: @srv's scheme name
 327  *
 328  * Since: 2.26
 329  */
 330 const gchar *
 331 g_network_service_get_scheme (GNetworkService *srv)
 332 {
 333   g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);
 334
 335   if (srv->priv->scheme)
 336     return srv->priv->scheme;
 337   else
 338     return srv->priv->service;
 339 }
 340
 341 /**
 342  * g_network_service_set_scheme:
 343  * @srv: a #GNetworkService
 344  * @scheme: a URI scheme
 345  *
 346  * Set's the URI scheme used to resolve proxies. By default, the service name
 347  * is used as scheme.
 348  *
 349  * Since: 2.26
 350  */
 351 void
 352 g_network_service_set_scheme (GNetworkService *srv,
 353                               const gchar     *scheme)
 354 {
 355   g_return_if_fail (G_IS_NETWORK_SERVICE (srv));
 356
 357   g_free (srv->priv->scheme);
 358   srv->priv->scheme = g_strdup (scheme);
 359
 360   g_object_notify (G_OBJECT (srv), "scheme");
 361 }
 362
 363 static GList *
 364 g_network_service_fallback_targets (GNetworkService *srv)
 365 {
 366   GSrvTarget *target;
 367   gboolean has_port;
 368   guint16 port;
 369
 370   has_port = g_getservbyname_ntohs (srv->priv->service, "tcp", &port);
 371
 372 #ifdef HAVE_ENDSERVENT
 373   endservent ();
 374 #endif
 375
 376   if (!has_port)
 377     return NULL;
 378
 379   target = g_srv_target_new (srv->priv->domain, port, 0, 0);
 380   return g_list_append (NULL, target);
 381 }
 382
 383 #define G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR (_g_network_service_address_enumerator_get_type ())
 384 #define G_NETWORK_SERVICE_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR, GNetworkServiceAddressEnumerator))
 385
 386 typedef struct {
 387   GSocketAddressEnumerator parent_instance;
 388
 389   GResolver *resolver;
 390   GNetworkService *srv;
 391   GSocketAddressEnumerator *addr_enum;
 392   GList *t;
 393   gboolean use_proxy;
 394
 395   GError *error;
 396
 397 } GNetworkServiceAddressEnumerator;
 398
 399 typedef struct {
 400   GSocketAddressEnumeratorClass parent_class;
 401
 402 } GNetworkServiceAddressEnumeratorClass;
 403
 404 static GType _g_network_service_address_enumerator_get_type (void);
 405 G_DEFINE_TYPE (GNetworkServiceAddressEnumerator, _g_network_service_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)
 406
 407 static GSocketAddress *
 408 g_network_service_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
 409                                            GCancellable              *cancellable,
 410                                            GError                   **error)
 411 {
 412   GNetworkServiceAddressEnumerator *srv_enum =
 413     G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (enumerator);
 414   GSocketAddress *ret = NULL;
 415
 416   /* If we haven't yet resolved srv, do that */
 417   if (!srv_enum->srv->priv->targets)
 418     {
 419       GList *targets;
 420       GError *my_error = NULL;
 421
 422       targets = g_resolver_lookup_service (srv_enum->resolver,
 423                                            srv_enum->srv->priv->service,
 424                                            srv_enum->srv->priv->protocol,
 425                                            srv_enum->srv->priv->domain,
 426                                            cancellable, &my_error);
 427       if (!targets && g_error_matches (my_error, G_RESOLVER_ERROR,
 428                                        G_RESOLVER_ERROR_NOT_FOUND))
 429         {
 430           targets = g_network_service_fallback_targets (srv_enum->srv);
 431           if (targets)
 432             g_clear_error (&my_error);
 433         }
 434
 435       if (my_error)
 436         {
 437           g_propagate_error (error, my_error);
 438           return NULL;
 439         }
 440
 441       srv_enum->srv->priv->targets = targets;
 442       srv_enum->t = srv_enum->srv->priv->targets;
 443     }
 444
 445   /* Delegate to GNetworkAddress */
 446   do
 447     {
 448       if (srv_enum->addr_enum == NULL && srv_enum->t)
 449         {
 450           GError *my_error = NULL;
 451           gchar *uri;
 452           gchar *hostname;
 453           GSocketConnectable *addr;
 454           GSrvTarget *target = srv_enum->t->data;
 455
 456           srv_enum->t = g_list_next (srv_enum->t);
 457
 458           hostname = g_hostname_to_ascii (g_srv_target_get_hostname (target));
 459
 460           if (hostname == NULL)
 461             {
 462               if (srv_enum->error == NULL)
 463                 srv_enum->error =
 464                   g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
 465                                "Received invalid hostname '%s' from GSrvTarget",
 466                                g_srv_target_get_hostname (target));
 467               continue;
 468             }
 469
 470           uri = g_uri_join (G_URI_FLAGS_NONE,
 471                             g_network_service_get_scheme (srv_enum->srv),
 472                             NULL,
 473                             hostname,
 474                             g_srv_target_get_port (target),
 475                             "",
 476                             NULL,
 477                             NULL);
 478           g_free (hostname);
 479
 480           addr = g_network_address_parse_uri (uri,
 481                                               g_srv_target_get_port (target),
 482                                               &my_error);
 483           g_free (uri);
 484
 485           if (addr == NULL)
 486             {
 487               if (srv_enum->error == NULL)
 488                 srv_enum->error = my_error;
 489               else
 490                 g_error_free (my_error);
 491               continue;
 492             }
 493
 494           if (srv_enum->use_proxy)
 495             srv_enum->addr_enum = g_socket_connectable_proxy_enumerate (addr);
 496           else
 497             srv_enum->addr_enum = g_socket_connectable_enumerate (addr);
 498           g_object_unref (addr);
 499         }
 500
 501       if (srv_enum->addr_enum)
 502         {
 503           GError *my_error = NULL;
 504
 505           ret = g_socket_address_enumerator_next (srv_enum->addr_enum,
 506                                                   cancellable,
 507                                                   &my_error);
 508
 509           if (my_error)
 510             {
 511               if (srv_enum->error == NULL)
 512                 srv_enum->error = my_error;
 513               else
 514                 g_error_free (my_error);
 515             }
 516
 517           if (!ret)
 518             {
 519               g_object_unref (srv_enum->addr_enum);
 520               srv_enum->addr_enum = NULL;
 521             }
 522         }
 523     }
 524   while (srv_enum->addr_enum == NULL && srv_enum->t);
 525
 526   if (ret == NULL && srv_enum->error)
 527     {
 528       g_propagate_error (error, srv_enum->error);
 529       srv_enum->error = NULL;
 530     }
 531
 532   return ret;
 533 }
 534
 535 static void next_async_resolved_targets   (GObject      *source_object,
 536                                            GAsyncResult *result,
 537                                            gpointer      user_data);
 538 static void next_async_have_targets       (GTask        *srv_enum);
 539 static void next_async_have_address       (GObject      *source_object,
 540                                            GAsyncResult *result,
 541                                            gpointer      user_data);
 542
 543 static void
 544 g_network_service_address_enumerator_next_async (GSocketAddressEnumerator  *enumerator,
 545                                                  GCancellable              *cancellable,
 546                                                  GAsyncReadyCallback        callback,
 547                                                  gpointer                   user_data)
 548 {
 549   GNetworkServiceAddressEnumerator *srv_enum =
 550     G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (enumerator);
 551   GTask *task;
 552
 553   task = g_task_new (enumerator, cancellable, callback, user_data);
 554   g_task_set_source_tag (task, g_network_service_address_enumerator_next_async);
 555
 556   /* If we haven't yet resolved srv, do that */
 557   if (!srv_enum->srv->priv->targets)
 558     {
 559       g_resolver_lookup_service_async (srv_enum->resolver,
 560                                        srv_enum->srv->priv->service,
 561                                        srv_enum->srv->priv->protocol,
 562                                        srv_enum->srv->priv->domain,
 563                                        cancellable,
 564                                        next_async_resolved_targets,
 565                                        task);
 566     }
 567   else
 568     next_async_have_targets (task);
 569 }
 570
 571 static void
 572 next_async_resolved_targets (GObject      *source_object,
 573                              GAsyncResult *result,
 574                              gpointer      user_data)
 575 {
 576   GTask *task = user_data;
 577   GNetworkServiceAddressEnumerator *srv_enum = g_task_get_source_object (task);
 578   GError *error = NULL;
 579   GList *targets;
 580
 581   targets = g_resolver_lookup_service_finish (srv_enum->resolver,
 582                                               result, &error);
 583
 584   if (!targets && g_error_matches (error, G_RESOLVER_ERROR,
 585                                    G_RESOLVER_ERROR_NOT_FOUND))
 586     {
 587       targets = g_network_service_fallback_targets (srv_enum->srv);
 588       if (targets)
 589         g_clear_error (&error);
 590     }
 591
 592   if (error)
 593     {
 594       g_task_return_error (task, error);
 595       g_object_unref (task);
 596     }
 597   else
 598     {
 599       srv_enum->t = srv_enum->srv->priv->targets = targets;
 600       next_async_have_targets (task);
 601     }
 602 }
 603
 604 static void
 605 next_async_have_targets (GTask *task)
 606 {
 607   GNetworkServiceAddressEnumerator *srv_enum = g_task_get_source_object (task);
 608
 609   /* Delegate to GNetworkAddress */
 610   if (srv_enum->addr_enum == NULL && srv_enum->t)
 611     {
 612       GSocketConnectable *addr;
 613       GSrvTarget *target = srv_enum->t->data;
 614
 615       srv_enum->t = g_list_next (srv_enum->t);
 616       addr = g_network_address_new (g_srv_target_get_hostname (target),
 617                                     (guint16) g_srv_target_get_port (target));
 618
 619       if (srv_enum->use_proxy)
 620         srv_enum->addr_enum = g_socket_connectable_proxy_enumerate (addr);
 621       else
 622         srv_enum->addr_enum = g_socket_connectable_enumerate (addr);
 623
 624       g_object_unref (addr);
 625     }
 626
 627   if (srv_enum->addr_enum)
 628     {
 629       g_socket_address_enumerator_next_async (srv_enum->addr_enum,
 630                                               g_task_get_cancellable (task),
 631                                               next_async_have_address,
 632                                               task);
 633     }
 634   else
 635     {
 636       if (srv_enum->error)
 637         {
 638           g_task_return_error (task, srv_enum->error);
 639           srv_enum->error = NULL;
 640         }
 641       else
 642         g_task_return_pointer (task, NULL, NULL);
 643
 644       g_object_unref (task);
 645     }
 646 }
 647
 648 static void
 649 next_async_have_address (GObject      *source_object,
 650                          GAsyncResult *result,
 651                          gpointer      user_data)
 652 {
 653   GTask *task = user_data;
 654   GNetworkServiceAddressEnumerator *srv_enum = g_task_get_source_object (task);
 655   GSocketAddress *address;
 656   GError *error = NULL;
 657
 658   address = g_socket_address_enumerator_next_finish (srv_enum->addr_enum,
 659                                                      result,
 660                                                      &error);
 661
 662   if (error)
 663     {
 664       if (srv_enum->error == NULL)
 665         srv_enum->error = error;
 666       else
 667         g_error_free (error);
 668     }
 669
 670   if (!address)
 671     {
 672       g_object_unref (srv_enum->addr_enum);
 673       srv_enum->addr_enum = NULL;
 674
 675       next_async_have_targets (task);
 676     }
 677   else
 678     {
 679       g_task_return_pointer (task, address, g_object_unref);
 680       g_object_unref (task);
 681     }
 682 }
 683
 684 static GSocketAddress *
 685 g_network_service_address_enumerator_next_finish (GSocketAddressEnumerator  *enumerator,
 686                                                   GAsyncResult              *result,
 687                                                   GError                   **error)
 688 {
 689   return g_task_propagate_pointer (G_TASK (result), error);
 690 }
 691
 692 static void
 693 _g_network_service_address_enumerator_init (GNetworkServiceAddressEnumerator *enumerator)
 694 {
 695 }
 696
 697 static void
 698 g_network_service_address_enumerator_finalize (GObject *object)
 699 {
 700   GNetworkServiceAddressEnumerator *srv_enum =
 701     G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (object);
 702
 703   if (srv_enum->srv)
 704     g_object_unref (srv_enum->srv);
 705
 706   if (srv_enum->addr_enum)
 707     g_object_unref (srv_enum->addr_enum);
 708
 709   if (srv_enum->resolver)
 710     g_object_unref (srv_enum->resolver);
 711
 712   if (srv_enum->error)
 713     g_error_free (srv_enum->error);
 714
 715   G_OBJECT_CLASS (_g_network_service_address_enumerator_parent_class)->finalize (object);
 716 }
 717
 718 static void
 719 _g_network_service_address_enumerator_class_init (GNetworkServiceAddressEnumeratorClass *srvenum_class)
 720 {
 721   GObjectClass *object_class = G_OBJECT_CLASS (srvenum_class);
 722   GSocketAddressEnumeratorClass *enumerator_class =
 723     G_SOCKET_ADDRESS_ENUMERATOR_CLASS (srvenum_class);
 724
 725   enumerator_class->next        = g_network_service_address_enumerator_next;
 726   enumerator_class->next_async  = g_network_service_address_enumerator_next_async;
 727   enumerator_class->next_finish = g_network_service_address_enumerator_next_finish;
 728
 729   object_class->finalize = g_network_service_address_enumerator_finalize;
 730 }
 731
 732 static GSocketAddressEnumerator *
 733 g_network_service_connectable_enumerate (GSocketConnectable *connectable)
 734 {
 735   GNetworkServiceAddressEnumerator *srv_enum;
 736
 737   srv_enum = g_object_new (G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR, NULL);
 738   srv_enum->srv = g_object_ref (G_NETWORK_SERVICE (connectable));
 739   srv_enum->resolver = g_resolver_get_default ();
 740   srv_enum->use_proxy = FALSE;
 741
 742   return G_SOCKET_ADDRESS_ENUMERATOR (srv_enum);
 743 }
 744
 745 static GSocketAddressEnumerator *
 746 g_network_service_connectable_proxy_enumerate (GSocketConnectable *connectable)
 747 {
 748   GSocketAddressEnumerator *addr_enum;
 749   GNetworkServiceAddressEnumerator *srv_enum;
 750
 751   addr_enum = g_network_service_connectable_enumerate (connectable);
 752   srv_enum = G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (addr_enum);
 753   srv_enum->use_proxy = TRUE;
 754
 755   return addr_enum;
 756 }
 757
 758 static gchar *
 759 g_network_service_connectable_to_string (GSocketConnectable *connectable)
 760 {
 761   GNetworkService *service;
 762
 763   service = G_NETWORK_SERVICE (connectable);
 764
 765   return g_strdup_printf ("(%s, %s, %s, %s)", service->priv->service,
 766                           service->priv->protocol, service->priv->domain,
 767                           service->priv->scheme);
 768 }