Import Upstream version 2.72.4

gio/gsrvtarget.c

@@ -0,0 +1,312 @@
+/* -*- 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.1 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include <glib.h>
+#include "glibintl.h"
+
+#include "gsrvtarget.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+
+/**
+ * SECTION:gsrvtarget
+ * @short_description: DNS SRV record target
+ * @include: gio/gio.h
+ *
+ * SRV (service) records are used by some network protocols to provide
+ * service-specific aliasing and load-balancing. For example, XMPP
+ * (Jabber) uses SRV records to locate the XMPP server for a domain;
+ * rather than connecting directly to "example.com" or assuming a
+ * specific server hostname like "xmpp.example.com", an XMPP client
+ * would look up the "xmpp-client" SRV record for "example.com", and
+ * then connect to whatever host was pointed to by that record.
+ *
+ * You can use g_resolver_lookup_service() or
+ * g_resolver_lookup_service_async() to find the #GSrvTargets
+ * for a given service. However, if you are simply planning to connect
+ * to the remote service, you can use #GNetworkService's
+ * #GSocketConnectable interface and not need to worry about
+ * #GSrvTarget at all.
+ */
+
+struct _GSrvTarget {
+  gchar   *hostname;
+  guint16  port;
+
+  guint16  priority;
+  guint16  weight;
+};
+
+/**
+ * GSrvTarget:
+ *
+ * A single target host/port that a network service is running on.
+ */
+
+G_DEFINE_BOXED_TYPE (GSrvTarget, g_srv_target,
+                     g_srv_target_copy, g_srv_target_free)
+
+/**
+ * g_srv_target_new:
+ * @hostname: the host that the service is running on
+ * @port: the port that the service is running on
+ * @priority: the target's priority
+ * @weight: the target's weight
+ *
+ * Creates a new #GSrvTarget with the given parameters.
+ *
+ * You should not need to use this; normally #GSrvTargets are
+ * created by #GResolver.
+ *
+ * Returns: a new #GSrvTarget.
+ *
+ * Since: 2.22
+ */
+GSrvTarget *
+g_srv_target_new (const gchar *hostname,
+                  guint16      port,
+                  guint16      priority,
+                  guint16      weight)
+{
+  GSrvTarget *target = g_slice_new0 (GSrvTarget);
+
+  target->hostname = g_strdup (hostname);
+  target->port = port;
+  target->priority = priority;
+  target->weight = weight;
+
+  return target;
+}
+
+/**
+ * g_srv_target_copy:
+ * @target: a #GSrvTarget
+ *
+ * Copies @target
+ *
+ * Returns: a copy of @target
+ *
+ * Since: 2.22
+ */
+GSrvTarget *
+g_srv_target_copy (GSrvTarget *target)
+{
+  return g_srv_target_new (target->hostname, target->port,
+                           target->priority, target->weight);
+}
+
+/**
+ * g_srv_target_free:
+ * @target: a #GSrvTarget
+ *
+ * Frees @target
+ *
+ * Since: 2.22
+ */
+void
+g_srv_target_free (GSrvTarget *target)
+{
+  g_free (target->hostname);
+  g_slice_free (GSrvTarget, target);
+}
+
+/**
+ * g_srv_target_get_hostname:
+ * @target: a #GSrvTarget
+ *
+ * Gets @target's hostname (in ASCII form; if you are going to present
+ * this to the user, you should use g_hostname_is_ascii_encoded() to
+ * check if it contains encoded Unicode segments, and use
+ * g_hostname_to_unicode() to convert it if it does.)
+ *
+ * Returns: @target's hostname
+ *
+ * Since: 2.22
+ */
+const gchar *
+g_srv_target_get_hostname (GSrvTarget *target)
+{
+  return target->hostname;
+}
+
+/**
+ * g_srv_target_get_port:
+ * @target: a #GSrvTarget
+ *
+ * Gets @target's port
+ *
+ * Returns: @target's port
+ *
+ * Since: 2.22
+ */
+guint16
+g_srv_target_get_port (GSrvTarget *target)
+{
+  return target->port;
+}
+
+/**
+ * g_srv_target_get_priority:
+ * @target: a #GSrvTarget
+ *
+ * Gets @target's priority. You should not need to look at this;
+ * #GResolver already sorts the targets according to the algorithm in
+ * RFC 2782.
+ *
+ * Returns: @target's priority
+ *
+ * Since: 2.22
+ */
+guint16
+g_srv_target_get_priority (GSrvTarget *target)
+{
+  return target->priority;
+}
+
+/**
+ * g_srv_target_get_weight:
+ * @target: a #GSrvTarget
+ *
+ * Gets @target's weight. You should not need to look at this;
+ * #GResolver already sorts the targets according to the algorithm in
+ * RFC 2782.
+ *
+ * Returns: @target's weight
+ *
+ * Since: 2.22
+ */
+guint16
+g_srv_target_get_weight (GSrvTarget *target)
+{
+  return target->weight;
+}
+
+static gint
+compare_target (gconstpointer a, gconstpointer b)
+{
+  GSrvTarget *ta = (GSrvTarget *)a;
+  GSrvTarget *tb = (GSrvTarget *)b;
+
+  if (ta->priority == tb->priority)
+    {
+      /* Arrange targets of the same priority "in any order, except
+       * that all those with weight 0 are placed at the beginning of
+       * the list"
+       */
+      return ta->weight - tb->weight;
+    }
+  else
+    return ta->priority - tb->priority;
+}
+
+/**
+ * g_srv_target_list_sort: (skip)
+ * @targets: a #GList of #GSrvTarget
+ *
+ * Sorts @targets in place according to the algorithm in RFC 2782.
+ *
+ * Returns: (transfer full): the head of the sorted list.
+ *
+ * Since: 2.22
+ */
+GList *
+g_srv_target_list_sort (GList *targets)
+{
+  gint sum, num, val, priority, weight;
+  GList *t, *out, *tail;
+  GSrvTarget *target;
+
+  if (!targets)
+    return NULL;
+
+  if (!targets->next)
+    {
+      target = targets->data;
+      if (!strcmp (target->hostname, "."))
+        {
+          /* 'A Target of "." means that the service is decidedly not
+           * available at this domain.'
+           */
+          g_srv_target_free (target);
+          g_list_free (targets);
+          return NULL;
+        }
+    }
+
+  /* Sort input list by priority, and put the 0-weight targets first
+   * in each priority group. Initialize output list to %NULL.
+   */
+  targets = g_list_sort (targets, compare_target);
+  out = tail = NULL;
+
+  /* For each group of targets with the same priority, remove them
+   * from @targets and append them to @out in a valid order.
+   */
+  while (targets)
+    {
+      priority = ((GSrvTarget *)targets->data)->priority;
+
+      /* Count the number of targets at this priority level, and
+       * compute the sum of their weights.
+       */
+      sum = num = 0;
+      for (t = targets; t; t = t->next)
+        {
+          target = (GSrvTarget *)t->data;
+          if (target->priority != priority)
+            break;
+          sum += target->weight;
+          num++;
+        }
+
+      /* While there are still targets at this priority level... */
+      while (num)
+        {
+          /* Randomly select from the targets at this priority level,
+           * giving precedence to the ones with higher weight,
+           * according to the rules from RFC 2782.
+           */
+          val = g_random_int_range (0, sum + 1);
+          for (t = targets; ; t = t->next)
+            {
+              weight = ((GSrvTarget *)t->data)->weight;
+              if (weight >= val)
+                break;
+              val -= weight;
+            }
+
+          targets = g_list_remove_link (targets, t);
+
+          if (!out)
+            out = t;
+          else
+            tail->next = t;
+          tail = t;
+
+          sum -= weight;
+          num--;
+        }
+    }
+
+  return out;
+}