nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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, see <http://www.gnu.org/licenses/>.
19 */
20  
21 #include "config.h"
22 #include <glib.h>
23 #include "glibintl.h"
24  
25 #include "gsrvtarget.h"
26  
27 #include <stdlib.h>
28 #include <string.h>
29  
30  
31 /**
32 * SECTION:gsrvtarget
33 * @short_description: DNS SRV record target
34 * @include: gio/gio.h
35 *
36 * SRV (service) records are used by some network protocols to provide
37 * service-specific aliasing and load-balancing. For example, XMPP
38 * (Jabber) uses SRV records to locate the XMPP server for a domain;
39 * rather than connecting directly to "example.com" or assuming a
40 * specific server hostname like "xmpp.example.com", an XMPP client
41 * would look up the "xmpp-client" SRV record for "example.com", and
42 * then connect to whatever host was pointed to by that record.
43 *
44 * You can use g_resolver_lookup_service() or
45 * g_resolver_lookup_service_async() to find the #GSrvTargets
46 * for a given service. However, if you are simply planning to connect
47 * to the remote service, you can use #GNetworkService's
48 * #GSocketConnectable interface and not need to worry about
49 * #GSrvTarget at all.
50 */
51  
52 struct _GSrvTarget {
53 gchar *hostname;
54 guint16 port;
55  
56 guint16 priority;
57 guint16 weight;
58 };
59  
60 /**
61 * GSrvTarget:
62 *
63 * A single target host/port that a network service is running on.
64 */
65  
66 G_DEFINE_BOXED_TYPE (GSrvTarget, g_srv_target,
67 g_srv_target_copy, g_srv_target_free)
68  
69 /**
70 * g_srv_target_new:
71 * @hostname: the host that the service is running on
72 * @port: the port that the service is running on
73 * @priority: the target's priority
74 * @weight: the target's weight
75 *
76 * Creates a new #GSrvTarget with the given parameters.
77 *
78 * You should not need to use this; normally #GSrvTargets are
79 * created by #GResolver.
80 *
81 * Returns: a new #GSrvTarget.
82 *
83 * Since: 2.22
84 */
85 GSrvTarget *
86 g_srv_target_new (const gchar *hostname,
87 guint16 port,
88 guint16 priority,
89 guint16 weight)
90 {
91 GSrvTarget *target = g_slice_new0 (GSrvTarget);
92  
93 target->hostname = g_strdup (hostname);
94 target->port = port;
95 target->priority = priority;
96 target->weight = weight;
97  
98 return target;
99 }
100  
101 /**
102 * g_srv_target_copy:
103 * @target: a #GSrvTarget
104 *
105 * Copies @target
106 *
107 * Returns: a copy of @target
108 *
109 * Since: 2.22
110 */
111 GSrvTarget *
112 g_srv_target_copy (GSrvTarget *target)
113 {
114 return g_srv_target_new (target->hostname, target->port,
115 target->priority, target->weight);
116 }
117  
118 /**
119 * g_srv_target_free:
120 * @target: a #GSrvTarget
121 *
122 * Frees @target
123 *
124 * Since: 2.22
125 */
126 void
127 g_srv_target_free (GSrvTarget *target)
128 {
129 g_free (target->hostname);
130 g_slice_free (GSrvTarget, target);
131 }
132  
133 /**
134 * g_srv_target_get_hostname:
135 * @target: a #GSrvTarget
136 *
137 * Gets @target's hostname (in ASCII form; if you are going to present
138 * this to the user, you should use g_hostname_is_ascii_encoded() to
139 * check if it contains encoded Unicode segments, and use
140 * g_hostname_to_unicode() to convert it if it does.)
141 *
142 * Returns: @target's hostname
143 *
144 * Since: 2.22
145 */
146 const gchar *
147 g_srv_target_get_hostname (GSrvTarget *target)
148 {
149 return target->hostname;
150 }
151  
152 /**
153 * g_srv_target_get_port:
154 * @target: a #GSrvTarget
155 *
156 * Gets @target's port
157 *
158 * Returns: @target's port
159 *
160 * Since: 2.22
161 */
162 guint16
163 g_srv_target_get_port (GSrvTarget *target)
164 {
165 return target->port;
166 }
167  
168 /**
169 * g_srv_target_get_priority:
170 * @target: a #GSrvTarget
171 *
172 * Gets @target's priority. You should not need to look at this;
173 * #GResolver already sorts the targets according to the algorithm in
174 * RFC 2782.
175 *
176 * Returns: @target's priority
177 *
178 * Since: 2.22
179 */
180 guint16
181 g_srv_target_get_priority (GSrvTarget *target)
182 {
183 return target->priority;
184 }
185  
186 /**
187 * g_srv_target_get_weight:
188 * @target: a #GSrvTarget
189 *
190 * Gets @target's weight. You should not need to look at this;
191 * #GResolver already sorts the targets according to the algorithm in
192 * RFC 2782.
193 *
194 * Returns: @target's weight
195 *
196 * Since: 2.22
197 */
198 guint16
199 g_srv_target_get_weight (GSrvTarget *target)
200 {
201 return target->weight;
202 }
203  
204 static gint
205 compare_target (gconstpointer a, gconstpointer b)
206 {
207 GSrvTarget *ta = (GSrvTarget *)a;
208 GSrvTarget *tb = (GSrvTarget *)b;
209  
210 if (ta->priority == tb->priority)
211 {
212 /* Arrange targets of the same priority "in any order, except
213 * that all those with weight 0 are placed at the beginning of
214 * the list"
215 */
216 return ta->weight - tb->weight;
217 }
218 else
219 return ta->priority - tb->priority;
220 }
221  
222 /**
223 * g_srv_target_list_sort: (skip)
224 * @targets: a #GList of #GSrvTarget
225 *
226 * Sorts @targets in place according to the algorithm in RFC 2782.
227 *
228 * Returns: (transfer full): the head of the sorted list.
229 *
230 * Since: 2.22
231 */
232 GList *
233 g_srv_target_list_sort (GList *targets)
234 {
235 gint sum, num, val, priority, weight;
236 GList *t, *out, *tail;
237 GSrvTarget *target;
238  
239 if (!targets)
240 return NULL;
241  
242 if (!targets->next)
243 {
244 target = targets->data;
245 if (!strcmp (target->hostname, "."))
246 {
247 /* 'A Target of "." means that the service is decidedly not
248 * available at this domain.'
249 */
250 g_srv_target_free (target);
251 g_list_free (targets);
252 return NULL;
253 }
254 }
255  
256 /* Sort input list by priority, and put the 0-weight targets first
257 * in each priority group. Initialize output list to %NULL.
258 */
259 targets = g_list_sort (targets, compare_target);
260 out = tail = NULL;
261  
262 /* For each group of targets with the same priority, remove them
263 * from @targets and append them to @out in a valid order.
264 */
265 while (targets)
266 {
267 priority = ((GSrvTarget *)targets->data)->priority;
268  
269 /* Count the number of targets at this priority level, and
270 * compute the sum of their weights.
271 */
272 sum = num = 0;
273 for (t = targets; t; t = t->next)
274 {
275 target = (GSrvTarget *)t->data;
276 if (target->priority != priority)
277 break;
278 sum += target->weight;
279 num++;
280 }
281  
282 /* While there are still targets at this priority level... */
283 while (num)
284 {
285 /* Randomly select from the targets at this priority level,
286 * giving precedence to the ones with higher weight,
287 * according to the rules from RFC 2782.
288 */
289 val = g_random_int_range (0, sum + 1);
290 for (t = targets; ; t = t->next)
291 {
292 weight = ((GSrvTarget *)t->data)->weight;
293 if (weight >= val)
294 break;
295 val -= weight;
296 }
297  
298 targets = g_list_remove_link (targets, t);
299  
300 if (!out)
301 out = t;
302 else
303 tail->next = t;
304 tail = t;
305  
306 sum -= weight;
307 num--;
308 }
309 }
310  
311 return out;
312 }