gnetworkservice.c 24.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

/* GIO - GLib Input, Output and Streaming Library
 *
 * Copyright (C) 2008 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "config.h"
#include <glib.h>
#include "glibintl.h"

#include "gnetworkservice.h"
28

29 30 31
#include "gcancellable.h"
#include "ginetaddress.h"
#include "ginetsocketaddress.h"
32 33
#include "gioerror.h"
#include "gnetworkaddress.h"
34
#include "gnetworkingprivate.h"
35 36 37 38 39 40 41 42 43 44 45 46
#include "gresolver.h"
#include "gsimpleasyncresult.h"
#include "gsocketaddressenumerator.h"
#include "gsocketconnectable.h"
#include "gsrvtarget.h"

#include <stdlib.h>
#include <string.h>


/**
 * SECTION:gnetworkservice
Matthias Clasen's avatar
Matthias Clasen committed
47
 * @short_description: A GSocketConnectable for resolving SRV records
48 49 50 51 52 53 54 55 56 57 58
 * @include: gio/gio.h
 *
 * Like #GNetworkAddress does with hostnames, #GNetworkService
 * provides an easy way to resolve a SRV record, and then attempt to
 * connect to one of the hosts that implements that service, handling
 * service priority/weighting, multiple IP addresses, and multiple
 * address families.
 *
 * See #GSrvTarget for more information about SRV records, and see
 * #GSocketConnectable for and example of using the connectable
 * interface.
59
 */
60 61 62 63 64 65

/**
 * GNetworkService:
 *
 * A #GSocketConnectable for resolving a SRV record and connecting to
 * that service.
66
 */
67 68 69

struct _GNetworkServicePrivate
{
70
  gchar *service, *protocol, *domain, *scheme;
71 72 73 74 75 76 77 78
  GList *targets;
};

enum {
  PROP_0,
  PROP_SERVICE,
  PROP_PROTOCOL,
  PROP_DOMAIN,
79
  PROP_SCHEME
80 81 82 83 84 85 86 87 88 89 90
};

static void g_network_service_set_property (GObject      *object,
                                            guint         prop_id,
                                            const GValue *value,
                                            GParamSpec   *pspec);
static void g_network_service_get_property (GObject      *object,
                                            guint         prop_id,
                                            GValue       *value,
                                            GParamSpec   *pspec);

91 92 93
static void                      g_network_service_connectable_iface_init       (GSocketConnectableIface *iface);
static GSocketAddressEnumerator *g_network_service_connectable_enumerate        (GSocketConnectable      *connectable);
static GSocketAddressEnumerator *g_network_service_connectable_proxy_enumerate  (GSocketConnectable      *connectable);
94 95 96 97 98 99 100 101 102 103 104 105 106

G_DEFINE_TYPE_WITH_CODE (GNetworkService, g_network_service, G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE (G_TYPE_SOCKET_CONNECTABLE,
                                                g_network_service_connectable_iface_init))

static void
g_network_service_finalize (GObject *object)
{
  GNetworkService *srv = G_NETWORK_SERVICE (object);

  g_free (srv->priv->service);
  g_free (srv->priv->protocol);
  g_free (srv->priv->domain);
107
  g_free (srv->priv->scheme);
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

  if (srv->priv->targets)
    g_resolver_free_targets (srv->priv->targets);

  G_OBJECT_CLASS (g_network_service_parent_class)->finalize (object);
}

static void
g_network_service_class_init (GNetworkServiceClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  g_type_class_add_private (klass, sizeof (GNetworkServicePrivate));

  gobject_class->set_property = g_network_service_set_property;
  gobject_class->get_property = g_network_service_get_property;
  gobject_class->finalize = g_network_service_finalize;

  g_object_class_install_property (gobject_class, PROP_SERVICE,
                                   g_param_spec_string ("service",
                                                        P_("Service"),
                                                        P_("Service name, eg \"ldap\""),
                                                        NULL,
131 132 133
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY |
                                                        G_PARAM_STATIC_STRINGS));
134 135 136 137 138
  g_object_class_install_property (gobject_class, PROP_PROTOCOL,
                                   g_param_spec_string ("protocol",
                                                        P_("Protocol"),
                                                        P_("Network protocol, eg \"tcp\""),
                                                        NULL,
139 140 141
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY |
                                                        G_PARAM_STATIC_STRINGS));
142 143
  g_object_class_install_property (gobject_class, PROP_DOMAIN,
                                   g_param_spec_string ("domain",
144
                                                        P_("Domain"),
145 146
                                                        P_("Network domain, eg, \"example.com\""),
                                                        NULL,
147 148 149
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY |
                                                        G_PARAM_STATIC_STRINGS));
150 151 152 153 154 155 156 157
  g_object_class_install_property (gobject_class, PROP_DOMAIN,
                                   g_param_spec_string ("scheme",
                                                        P_("Scheme"),
                                                        P_("Network scheme (default is to use service)"),
                                                        NULL,
                                                        G_PARAM_READWRITE |
                                                        G_PARAM_STATIC_STRINGS));

158 159 160 161 162 163
}

static void
g_network_service_connectable_iface_init (GSocketConnectableIface *connectable_iface)
{
  connectable_iface->enumerate = g_network_service_connectable_enumerate;
164
  connectable_iface->proxy_enumerate = g_network_service_connectable_proxy_enumerate;
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
}

static void
g_network_service_init (GNetworkService *srv)
{
  srv->priv = G_TYPE_INSTANCE_GET_PRIVATE (srv, G_TYPE_NETWORK_SERVICE,
                                           GNetworkServicePrivate);
}

static void
g_network_service_set_property (GObject      *object,
                                guint         prop_id,
                                const GValue *value,
                                GParamSpec   *pspec)
{
  GNetworkService *srv = G_NETWORK_SERVICE (object);

182
  switch (prop_id)
183 184 185 186 187 188 189 190 191 192 193 194 195
    {
    case PROP_SERVICE:
      srv->priv->service = g_value_dup_string (value);
      break;

    case PROP_PROTOCOL:
      srv->priv->protocol = g_value_dup_string (value);
      break;

    case PROP_DOMAIN:
      srv->priv->domain = g_value_dup_string (value);
      break;

196 197 198 199
    case PROP_SCHEME:
      g_network_service_set_scheme (srv, g_value_get_string (value));
      break;

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
g_network_service_get_property (GObject    *object,
                                guint       prop_id,
                                GValue     *value,
                                GParamSpec *pspec)
{
  GNetworkService *srv = G_NETWORK_SERVICE (object);

  switch (prop_id)
215
    {
216 217 218 219 220 221 222 223 224 225 226 227
    case PROP_SERVICE:
      g_value_set_string (value, g_network_service_get_service (srv));
      break;

    case PROP_PROTOCOL:
      g_value_set_string (value, g_network_service_get_protocol (srv));
      break;

    case PROP_DOMAIN:
      g_value_set_string (value, g_network_service_get_domain (srv));
      break;

228 229 230 231
    case PROP_SCHEME:
      g_value_set_string (value, g_network_service_get_scheme (srv));
      break;

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

/**
 * g_network_service_new:
 * @service: the service type to look up (eg, "ldap")
 * @protocol: the networking protocol to use for @service (eg, "tcp")
 * @domain: the DNS domain to look up the service in
 *
 * Creates a new #GNetworkService representing the given @service,
 * @protocol, and @domain. This will initially be unresolved; use the
 * #GSocketConnectable interface to resolve it.
 *
248
 * Return value: (transfer full) (type GNetworkService): a new #GNetworkService
249 250
 *
 * Since: 2.22
251
 */
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
GSocketConnectable *
g_network_service_new (const gchar *service,
                       const gchar *protocol,
                       const gchar *domain)
{
  return g_object_new (G_TYPE_NETWORK_SERVICE,
                       "service", service,
                       "protocol", protocol,
                       "domain", domain,
                       NULL);
}

/**
 * g_network_service_get_service:
 * @srv: a #GNetworkService
 *
 * Gets @srv's service name (eg, "ldap").
 *
 * Return value: @srv's service name
 *
 * Since: 2.22
273
 */
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
const gchar *
g_network_service_get_service (GNetworkService *srv)
{
  g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);

  return srv->priv->service;
}

/**
 * g_network_service_get_protocol:
 * @srv: a #GNetworkService
 *
 * Gets @srv's protocol name (eg, "tcp").
 *
 * Return value: @srv's protocol name
 *
 * Since: 2.22
291
 */
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
const gchar *
g_network_service_get_protocol (GNetworkService *srv)
{
  g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);

  return srv->priv->protocol;
}

/**
 * g_network_service_get_domain:
 * @srv: a #GNetworkService
 *
 * Gets the domain that @srv serves. This might be either UTF-8 or
 * ASCII-encoded, depending on what @srv was created with.
 *
 * Return value: @srv's domain name
 *
 * Since: 2.22
310
 */
311 312 313 314 315 316 317 318
const gchar *
g_network_service_get_domain (GNetworkService *srv)
{
  g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);

  return srv->priv->domain;
}

319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
/**
 * g_network_service_get_scheme:
 * @srv: a #GNetworkService
 *
 * Get's the URI scheme used to resolve proxies. By default, the service name
 * is used as scheme.
 *
 * Return value: @srv's scheme name
 *
 * Since: 2.26
 */
const gchar *
g_network_service_get_scheme (GNetworkService *srv)
{
  g_return_val_if_fail (G_IS_NETWORK_SERVICE (srv), NULL);

  if (srv->priv->scheme)
    return srv->priv->scheme;
  else
    return srv->priv->service;
}

/**
 * g_network_service_set_scheme:
 * @srv: a #GNetworkService
344
 * @scheme: a URI scheme
345 346 347 348 349 350 351
 *
 * Set's the URI scheme used to resolve proxies. By default, the service name
 * is used as scheme.
 *
 * Since: 2.26
 */
void
352 353
g_network_service_set_scheme (GNetworkService *srv,
                              const gchar     *scheme)
354 355 356 357 358 359 360 361 362 363
{
  g_return_if_fail (G_IS_NETWORK_SERVICE (srv));

  if (srv->priv->scheme)
    g_free (srv->priv->scheme);
  srv->priv->scheme = g_strdup (scheme);

  g_object_notify (G_OBJECT (srv), "scheme");
}

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
static GList *
g_network_service_fallback_targets (GNetworkService *srv)
{
  GSrvTarget *target;
  struct servent *entry;
  guint16 port;

  entry = getservbyname (srv->priv->service, "tcp");
  port = entry ? g_ntohs (entry->s_port) : 0;
#ifdef HAVE_ENDSERVENT
  endservent ();
#endif

  if (entry == NULL)
      return NULL;

  target = g_srv_target_new (srv->priv->domain, port, 0, 0);
  return g_list_append (NULL, target);
}
383

384 385 386 387 388 389 390 391
#define G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR (_g_network_service_address_enumerator_get_type ())
#define G_NETWORK_SERVICE_ADDRESS_ENUMERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR, GNetworkServiceAddressEnumerator))

typedef struct {
  GSocketAddressEnumerator parent_instance;

  GResolver *resolver;
  GNetworkService *srv;
392 393 394
  GSocketAddressEnumerator *addr_enum;
  GList *t;
  gboolean use_proxy;
395 396 397 398 399 400 401 402 403 404 405 406 407

  GError *error;

  /* For async operation */
  GCancellable *cancellable;
  GSimpleAsyncResult *result;
} GNetworkServiceAddressEnumerator;

typedef struct {
  GSocketAddressEnumeratorClass parent_class;

} GNetworkServiceAddressEnumeratorClass;

Allison Karlitskaya's avatar
Allison Karlitskaya committed
408
static GType _g_network_service_address_enumerator_get_type (void);
409 410 411 412 413 414 415 416 417
G_DEFINE_TYPE (GNetworkServiceAddressEnumerator, _g_network_service_address_enumerator, G_TYPE_SOCKET_ADDRESS_ENUMERATOR)

static GSocketAddress *
g_network_service_address_enumerator_next (GSocketAddressEnumerator  *enumerator,
                                           GCancellable              *cancellable,
                                           GError                   **error)
{
  GNetworkServiceAddressEnumerator *srv_enum =
    G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (enumerator);
418
  GSocketAddress *ret = NULL;
419 420 421 422 423

  /* If we haven't yet resolved srv, do that */
  if (!srv_enum->srv->priv->targets)
    {
      GList *targets;
424
      GError *my_error = NULL;
425 426 427 428 429

      targets = g_resolver_lookup_service (srv_enum->resolver,
                                           srv_enum->srv->priv->service,
                                           srv_enum->srv->priv->protocol,
                                           srv_enum->srv->priv->domain,
430 431 432 433 434 435 436 437 438
                                           cancellable, &my_error);
      if (!targets && g_error_matches (my_error, G_RESOLVER_ERROR,
                                       G_RESOLVER_ERROR_NOT_FOUND))
        {
          targets = g_network_service_fallback_targets (srv_enum->srv);
          if (targets)
            g_clear_error (&my_error);
        }

439
      if (my_error)
440 441 442 443
        {
          g_propagate_error (error, my_error);
          return NULL;
        }
444

445
      srv_enum->srv->priv->targets = targets;
446 447 448
      srv_enum->t = srv_enum->srv->priv->targets;
    }

449
  /* Delegate to GNetworkAddress */
450 451
  do
    {
452
      if (srv_enum->addr_enum == NULL && srv_enum->t)
453
        {
454 455 456 457 458 459 460 461 462 463 464
          GError *error = NULL;
          gchar *uri;
          gchar *hostname;
          GSocketConnectable *addr;
          GSrvTarget *target = srv_enum->t->data;

          srv_enum->t = g_list_next (srv_enum->t);

          hostname = g_hostname_to_ascii (g_srv_target_get_hostname (target));

          if (hostname == NULL)
465
            {
466 467 468 469 470 471
              if (srv_enum->error == NULL)
                srv_enum->error =
                  g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
                               "Received invalid hostname '%s' from GSrvTarget",
                               g_srv_target_get_hostname (target));
              continue;
472 473
            }

474 475 476 477
          uri = _g_uri_from_authority (g_network_service_get_scheme (srv_enum->srv),
                                       hostname,
                                       g_srv_target_get_port (target),
                                       NULL);
478
          g_free (hostname);
479

480 481 482 483
          addr = g_network_address_parse_uri (uri,
                                              g_srv_target_get_port (target),
                                              &error);
          g_free (uri);
484

485
          if (addr == NULL)
486
            {
487 488 489
              if (srv_enum->error == NULL)
                srv_enum->error = error;
              continue;
490
            }
491 492 493

          if (srv_enum->use_proxy)
            srv_enum->addr_enum = g_socket_connectable_proxy_enumerate (addr);
494
          else
495 496 497 498 499 500 501 502 503 504 505 506 507
            srv_enum->addr_enum = g_socket_connectable_enumerate (addr);
          g_object_unref (addr);
        }

      if (srv_enum->addr_enum)
        {
          GError *error = NULL;

          ret = g_socket_address_enumerator_next (srv_enum->addr_enum,
                                                  cancellable,
                                                  &error);

          if (error)
508
            {
509 510 511 512
              if (srv_enum->error == NULL)
                srv_enum->error = error;
              else
                g_error_free (error);
513
            }
514

515 516
          if (!ret)
            {
517 518
              g_object_unref (srv_enum->addr_enum);
              srv_enum->addr_enum = NULL;
519 520 521
            }
        }
    }
522
  while (srv_enum->addr_enum == NULL && srv_enum->t);
523

524
  if (ret == NULL && srv_enum->error)
525
    {
526 527
      g_propagate_error (error, srv_enum->error);
      srv_enum->error = NULL;
528 529
    }

530
  return ret;
531 532 533 534 535 536
}

static void next_async_resolved_targets   (GObject                          *source_object,
                                           GAsyncResult                     *result,
                                           gpointer                          user_data);
static void next_async_have_targets       (GNetworkServiceAddressEnumerator *srv_enum);
537
static void next_async_have_address       (GObject                          *source_object,
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
                                           GAsyncResult                     *result,
                                           gpointer                          user_data);

static void
g_network_service_address_enumerator_next_async (GSocketAddressEnumerator  *enumerator,
                                                 GCancellable              *cancellable,
                                                 GAsyncReadyCallback        callback,
                                                 gpointer                   user_data)
{
  GNetworkServiceAddressEnumerator *srv_enum =
    G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (enumerator);

  g_return_if_fail (srv_enum->result == NULL);

  srv_enum->result = g_simple_async_result_new (G_OBJECT (enumerator),
                                                callback, user_data,
                                                g_network_service_address_enumerator_next_async);
555 556 557

  if (cancellable)
    srv_enum->cancellable = g_object_ref (cancellable);
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580

  /* If we haven't yet resolved srv, do that */
  if (!srv_enum->srv->priv->targets)
    {
      g_resolver_lookup_service_async (srv_enum->resolver,
                                       srv_enum->srv->priv->service,
                                       srv_enum->srv->priv->protocol,
                                       srv_enum->srv->priv->domain,
                                       cancellable,
                                       next_async_resolved_targets,
                                       srv_enum);
    }
  else
    next_async_have_targets (srv_enum);
}

static void
next_async_resolved_targets (GObject      *source_object,
                             GAsyncResult *result,
                             gpointer      user_data)
{
  GNetworkServiceAddressEnumerator *srv_enum = user_data;
  GError *error = NULL;
581
  GList *targets;
582

583 584 585 586 587 588 589 590 591 592
  targets = g_resolver_lookup_service_finish (srv_enum->resolver,
                                              result, &error);

  if (!targets && g_error_matches (error, G_RESOLVER_ERROR,
                                   G_RESOLVER_ERROR_NOT_FOUND))
    {
      targets = g_network_service_fallback_targets (srv_enum->srv);
      if (targets)
        g_clear_error (&error);
    }
593 594

  if (error)
595
    {
596
      GSimpleAsyncResult *simple = srv_enum->result;
597

598
      srv_enum->result = NULL;
599
      g_simple_async_result_take_error (simple, error);
600 601 602 603 604
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
    }
  else
    {
605
      srv_enum->t = srv_enum->srv->priv->targets = targets;
606
      next_async_have_targets (srv_enum);
607 608 609 610 611 612
    }
}

static void
next_async_have_targets (GNetworkServiceAddressEnumerator *srv_enum)
{
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
  /* Delegate to GNetworkAddress */
  if (srv_enum->addr_enum == NULL && srv_enum->t)
    {
      GSocketConnectable *addr;
      GSrvTarget *target = srv_enum->t->data;

      srv_enum->t = g_list_next (srv_enum->t);
      addr = g_network_address_new (g_srv_target_get_hostname (target),
                                    (guint16) g_srv_target_get_port (target));

      if (srv_enum->use_proxy)
        srv_enum->addr_enum = g_socket_connectable_proxy_enumerate (addr);
      else
        srv_enum->addr_enum = g_socket_connectable_enumerate (addr);

      g_object_unref (addr);
    }
630

631
  if (srv_enum->addr_enum)
632
    {
633 634 635 636 637 638 639 640 641 642
      g_socket_address_enumerator_next_async (srv_enum->addr_enum,
                                              srv_enum->cancellable,
                                              next_async_have_address,
                                              srv_enum);
    }
  else
    {
      GSimpleAsyncResult *simple = srv_enum->result;
      srv_enum->result = NULL;

643 644
      if (srv_enum->error)
        {
645
          g_simple_async_result_take_error (simple, srv_enum->error);
646 647 648
          srv_enum->error = NULL;
        }

649 650
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
651 652 653 654
    }
}

static void
655 656 657
next_async_have_address (GObject      *source_object,
                         GAsyncResult *result,
                         gpointer      user_data)
658 659
{
  GNetworkServiceAddressEnumerator *srv_enum = user_data;
660
  GSocketAddress *address;
661
  GError *error = NULL;
662 663 664 665
  
  address = g_socket_address_enumerator_next_finish (srv_enum->addr_enum,
                                                     result,
                                                     &error);
666

667
  if (error)
668
    {
669 670
      if (srv_enum->error == NULL)
        srv_enum->error = error;
671
      else
672
        g_error_free (error);
673
    }
674

675 676
  if (!address)
    {
677 678 679 680
      g_object_unref (srv_enum->addr_enum);
      srv_enum->addr_enum = NULL;

      next_async_have_targets (srv_enum);
681
    }
682 683 684
  else
    {
      GSimpleAsyncResult *simple = srv_enum->result;
685

686
      srv_enum->result = NULL;
687

688 689 690
      if (address)
        g_simple_async_result_set_op_res_gpointer (simple,
                                                   address, g_object_unref);
691

692 693
      g_simple_async_result_complete (simple);
      g_object_unref (simple);
694 695 696 697 698 699 700 701 702 703 704
    }
}

static GSocketAddress *
g_network_service_address_enumerator_next_finish (GSocketAddressEnumerator  *enumerator,
                                                  GAsyncResult              *result,
                                                  GError                   **error)
{
  GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
  GSocketAddress *sockaddr;

705 706 707
  if (g_simple_async_result_propagate_error (simple, error))
    return NULL;

708 709 710 711 712 713 714 715 716 717
  sockaddr = g_simple_async_result_get_op_res_gpointer (simple);
  return sockaddr ? g_object_ref (sockaddr) : NULL;
}

static void
_g_network_service_address_enumerator_init (GNetworkServiceAddressEnumerator *enumerator)
{
}

static void
718
g_network_service_address_enumerator_finalize (GObject *object)
719
{
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
  GNetworkServiceAddressEnumerator *srv_enum =
    G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (object);

  if (srv_enum->srv)
    g_object_unref (srv_enum->srv);

  if (srv_enum->addr_enum)
    g_object_unref (srv_enum->addr_enum);

  if (srv_enum->resolver)
    g_object_unref (srv_enum->resolver);

  if (srv_enum->result)
    g_object_unref (srv_enum->result);

  if (srv_enum->cancellable)
    g_object_unref (srv_enum->cancellable);

  if (srv_enum->error)
    g_error_free (srv_enum->error);

  G_OBJECT_CLASS (_g_network_service_address_enumerator_parent_class)->finalize (object);
}

static void
_g_network_service_address_enumerator_class_init (GNetworkServiceAddressEnumeratorClass *srvenum_class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (srvenum_class);
748
  GSocketAddressEnumeratorClass *enumerator_class =
749
    G_SOCKET_ADDRESS_ENUMERATOR_CLASS (srvenum_class);
750

751 752
  enumerator_class->next        = g_network_service_address_enumerator_next;
  enumerator_class->next_async  = g_network_service_address_enumerator_next_async;
753
  enumerator_class->next_finish = g_network_service_address_enumerator_next_finish;
754

755 756 757 758 759 760 761 762 763 764 765
  object_class->finalize = g_network_service_address_enumerator_finalize;
}

static GSocketAddressEnumerator *
g_network_service_connectable_enumerate (GSocketConnectable *connectable)
{
  GNetworkServiceAddressEnumerator *srv_enum;

  srv_enum = g_object_new (G_TYPE_NETWORK_SERVICE_ADDRESS_ENUMERATOR, NULL);
  srv_enum->srv = g_object_ref (connectable);
  srv_enum->resolver = g_resolver_get_default ();
766 767 768 769 770 771 772 773 774 775 776 777 778 779
  srv_enum->use_proxy = FALSE;

  return G_SOCKET_ADDRESS_ENUMERATOR (srv_enum);
}

static GSocketAddressEnumerator *
g_network_service_connectable_proxy_enumerate (GSocketConnectable *connectable)
{
  GSocketAddressEnumerator *addr_enum;
  GNetworkServiceAddressEnumerator *srv_enum;

  addr_enum = g_network_service_connectable_enumerate (connectable);
  srv_enum = G_NETWORK_SERVICE_ADDRESS_ENUMERATOR (addr_enum);
  srv_enum->use_proxy = TRUE;
780

781
  return addr_enum;
782
}