candidate.c 10.6 KB
Newer Older
1 2 3
/*
 * This file is part of the Nice GLib ICE library.
 *
4 5 6
 * (C) 2006-2009 Collabora Ltd.
 *  Contact: Youness Alaoui
 * (C) 2006-2009 Nokia Corporation. All rights reserved.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *  Contact: Kai Vehmanen
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the Nice GLib ICE library.
 *
 * The Initial Developers of the Original Code are Collabora Ltd and Nokia
 * Corporation. All Rights Reserved.
 *
 * Contributors:
 *   Dafydd Harries, Collabora Ltd.
26
 *   Youness Alaoui, Collabora Ltd.
27
 *   Kai Vehmanen, Nokia
28 29 30 31 32 33 34 35 36 37 38
 *
 * Alternatively, the contents of this file may be used under the terms of the
 * the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
 * case the provisions of LGPL are applicable instead of those above. If you
 * wish to allow use of your version of this file only under the terms of the
 * LGPL and not to allow others to use your version of this file under the
 * MPL, indicate your decision by deleting the provisions above and replace
 * them with the notice and other provisions required by the LGPL. If you do
 * not delete the provisions above, a recipient may use your version of this
 * file under either the MPL or the LGPL.
 */
39

40
/*
41 42 43 44 45 46
 * @file candidate.c
 * @brief ICE candidate functions
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
47 48
#else
#define NICEAPI_EXPORT
49 50
#endif

51 52
#include <string.h>

53
#include "agent.h"
54
#include "component.h"
55
#include "interfaces.h"
56

57 58 59
G_DEFINE_BOXED_TYPE (NiceCandidate, nice_candidate, nice_candidate_copy,
    nice_candidate_free);

60 61 62
/* (ICE 4.1.1 "Gathering Candidates") ""Every candidate is a transport
 * address. It also has a type and a base. Three types are defined and 
 * gathered by this specification - host candidates, server reflexive 
63
 * candidates, and relayed candidates."" (ID-19) */
64

65
NICEAPI_EXPORT NiceCandidate *
66
nice_candidate_new (NiceCandidateType type)
67
{
68
  NiceCandidate *candidate;
69

70
  candidate = g_slice_new0 (NiceCandidate);
71 72 73 74 75
  candidate->type = type;
  return candidate;
}


76
NICEAPI_EXPORT void
77
nice_candidate_free (NiceCandidate *candidate)
78
{
79 80
  /* better way of checking if socket is allocated? */

81 82 83 84 85 86
  if (candidate->username)
    g_free (candidate->username);

  if (candidate->password)
    g_free (candidate->password);

87 88 89
  if (candidate->turn)
    turn_server_unref (candidate->turn);

90
  g_slice_free (NiceCandidate, candidate);
91 92 93
}


94
guint32
95
nice_candidate_jingle_priority (NiceCandidate *candidate)
96 97 98
{
  switch (candidate->type)
    {
99 100 101 102
    case NICE_CANDIDATE_TYPE_HOST:             return 1000;
    case NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE: return 900;
    case NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:   return 900;
    case NICE_CANDIDATE_TYPE_RELAYED:          return 500;
103
    default:                                   return 0;
104 105 106
    }
}

107
guint32
108 109 110 111
nice_candidate_msn_priority (NiceCandidate *candidate)
{
  switch (candidate->type)
    {
112 113 114 115
    case NICE_CANDIDATE_TYPE_HOST:             return 830;
    case NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE: return 550;
    case NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:   return 550;
    case NICE_CANDIDATE_TYPE_RELAYED:          return 450;
116
    default:                                   return 0;
117 118 119
    }
}

120

121
/*
122
 * ICE 4.1.2.1. "Recommended Formula" (ID-19):
123 124
 * returns number between 1 and 0x7effffff 
 */
125
guint32
126
nice_candidate_ice_priority_full (
127 128 129 130
  // must be ∈ (0, 126) (max 2^7 - 2)
  guint type_preference,
  // must be ∈ (0, 65535) (max 2^16 - 1)
  guint local_preference,
131
  // must be ∈ (0, 255) (max 2 ^ 8 - 1)
132 133 134 135 136 137 138 139
  guint component_id)
{
  return (
      0x1000000 * type_preference +
      0x100 * local_preference +
      (0x100 - component_id));
}

140
static guint32
141
nice_candidate_ice_local_preference_full (guint direction_preference,
142 143 144 145 146 147
    guint other_preference)
{
  return (0x2000 * direction_preference +
      other_preference);
}

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
static guint8
nice_candidate_ip_local_preference (const NiceCandidate *candidate)
{
  guint8 preference = 0;
  gchar ip_string[INET6_ADDRSTRLEN];
  GList/*<owned gchar*>*/ *ips = NULL;
  GList/*<unowned gchar*>*/ *iter;

  /* Ensure otherwise identical host candidates with only different IP addresses
   * (multihomed host) get assigned different priorities. Position of the IP in
   * the list obtained from nice_interfaces_get_local_ips() serves here as the
   * distinguishing value of other_preference. Reflexive and relayed candidates
   * are likewise differentiated by their base address.
   *
   * This is required by RFC 5245 Section 4.1.2.1:
   *   https://tools.ietf.org/html/rfc5245#section-4.1.2.1
   */
  if (candidate->type == NICE_CANDIDATE_TYPE_HOST) {
    nice_address_to_string (&candidate->addr, ip_string);
  } else {
    nice_address_to_string (&candidate->base_addr, ip_string);
  }

  ips = nice_interfaces_get_local_ips (TRUE);

  for (iter = ips; iter; iter = g_list_next (iter)) {
    if (g_strcmp0 (ip_string, iter->data) == 0) {
      break;
    }
    ++preference;
  }

  g_list_free_full (ips, g_free);

  return preference;
}

185
static guint16
186
nice_candidate_ice_local_preference (const NiceCandidate *candidate)
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
{
  guint direction_preference;

  switch (candidate->transport)
    {
      case NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE:
        if (candidate->type == NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE ||
            candidate->type == NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED)
          direction_preference = 4;
        else
          direction_preference = 6;
        break;
      case NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE:
        if (candidate->type == NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE ||
            candidate->type == NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED)
          direction_preference = 2;
        else
          direction_preference = 4;
        break;
      case NICE_CANDIDATE_TRANSPORT_TCP_SO:
        if (candidate->type == NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE ||
            candidate->type == NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED)
          direction_preference = 6;
        else
          direction_preference = 2;
        break;
      case NICE_CANDIDATE_TRANSPORT_UDP:
      default:
        return 1;
        break;
    }

219 220
  return nice_candidate_ice_local_preference_full (direction_preference,
      nice_candidate_ip_local_preference (candidate));
221
}
222

223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
static guint32
nice_candidate_ms_ice_local_preference_full (guint transport_preference,
    guint direction_preference, guint other_preference)
{
  return 0x1000 * transport_preference +
      0x200 * direction_preference +
      0x1 * other_preference;
}

static guint32
nice_candidate_ms_ice_local_preference (const NiceCandidate *candidate)
{
  guint8 transport_preference = 0;
  guint8 direction_preference = 0;

  switch (candidate->transport)
    {
    case NICE_CANDIDATE_TRANSPORT_TCP_SO:
    case NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE:
      transport_preference = NICE_CANDIDATE_TRANSPORT_MS_PREF_TCP;
      direction_preference = NICE_CANDIDATE_DIRECTION_MS_PREF_ACTIVE;
      break;
    case NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE:
      transport_preference = NICE_CANDIDATE_TRANSPORT_MS_PREF_TCP;
      direction_preference = NICE_CANDIDATE_DIRECTION_MS_PREF_PASSIVE;
      break;
    case NICE_CANDIDATE_TRANSPORT_UDP:
    default:
      transport_preference = NICE_CANDIDATE_TRANSPORT_MS_PREF_UDP;
      break;
    }

  return nice_candidate_ms_ice_local_preference_full(transport_preference,
256
      direction_preference, nice_candidate_ip_local_preference (candidate));
257 258 259 260
}

static guint8
nice_candidate_ice_type_preference (const NiceCandidate *candidate,
261
    gboolean reliable, gboolean nat_assisted)
262
{
263
  guint8 type_preference;
264 265 266

  switch (candidate->type)
    {
267
    case NICE_CANDIDATE_TYPE_HOST:
268 269
      type_preference = NICE_CANDIDATE_TYPE_PREF_HOST;
      break;
270
    case NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:
271 272
      type_preference = NICE_CANDIDATE_TYPE_PREF_PEER_REFLEXIVE;
      break;
273
    case NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE:
274 275 276 277 278
      if (nat_assisted)
        type_preference = NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED;
      else
        type_preference = NICE_CANDIDATE_TYPE_PREF_SERVER_REFLEXIVE;
      break;
279
    case NICE_CANDIDATE_TYPE_RELAYED:
280 281 282 283
      if (candidate->turn->type == NICE_RELAY_TYPE_TURN_UDP)
        type_preference = NICE_CANDIDATE_TYPE_PREF_RELAYED_UDP;
      else
        type_preference = NICE_CANDIDATE_TYPE_PREF_RELAYED;
284
      break;
285
    default:
286 287
      type_preference = 0;
      break;
288 289
    }

290 291 292
  if ((reliable && candidate->transport == NICE_CANDIDATE_TRANSPORT_UDP) ||
      (!reliable && candidate->transport != NICE_CANDIDATE_TRANSPORT_UDP)) {
    type_preference = type_preference / 2;
293
  }
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

  return type_preference;
}

guint32
nice_candidate_ice_priority (const NiceCandidate *candidate,
    gboolean reliable, gboolean nat_assisted)
{
  guint8 type_preference;
  guint16 local_preference;

  type_preference = nice_candidate_ice_type_preference (candidate, reliable,
      nat_assisted);
  local_preference = nice_candidate_ice_local_preference (candidate);

  return nice_candidate_ice_priority_full (type_preference, local_preference,
      candidate->component_id);
}

guint32
nice_candidate_ms_ice_priority (const NiceCandidate *candidate,
    gboolean reliable, gboolean nat_assisted)
{
  guint8 type_preference;
  guint16 local_preference;

  type_preference = nice_candidate_ice_type_preference (candidate, reliable,
      nat_assisted);
  local_preference = nice_candidate_ms_ice_local_preference (candidate);
323 324 325

  return nice_candidate_ice_priority_full (type_preference, local_preference,
      candidate->component_id);
326 327
}

328
/*
329
 * Calculates the pair priority as specified in ICE
330
 * sect 5.7.2. "Computing Pair Priority and Ordering Pairs" (ID-19).
331
 */
332
guint64
333 334 335 336
nice_candidate_pair_priority (guint32 o_prio, guint32 a_prio)
{
  guint32 max = o_prio > a_prio ? o_prio : a_prio;
  guint32 min = o_prio < a_prio ? o_prio : a_prio;
337 338 339
  /* These two constants are here explictly to make some version of GCC happy */
  const guint64 one = 1;
  const guint64 thirtytwo = 32;
340

341
  return (one << thirtytwo) * min + 2 * max + (o_prio > a_prio ? 1 : 0);
342
}
343

344
/*
345 346 347 348 349
 * Copies a candidate
 */
NICEAPI_EXPORT NiceCandidate *
nice_candidate_copy (const NiceCandidate *candidate)
{
350
  NiceCandidate *copy;
351

352 353 354
  g_return_val_if_fail (candidate != NULL, NULL);

  copy = nice_candidate_new (candidate->type);
355 356
  memcpy (copy, candidate, sizeof(NiceCandidate));

357
  copy->turn = NULL;
358 359 360 361 362
  copy->username = g_strdup (copy->username);
  copy->password = g_strdup (copy->password);

  return copy;
}