/*

 * Farstream - Farstream libnice Stream Transmitter

 *

 * Copyright 2007 Collabora Ltd.

 *  @author: Olivier Crete <olivier.crete@collabora.co.uk>

 * Copyright 2007 Nokia Corp.

 *

 * fs-nice-stream-transmitter.c - A Farstream libnice stream transmitter

 *

 * 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA

 */

/**

 * SECTION:fs-nice-stream-transmitter

 * @short_description: A stream transmitter object for ICE using libnice

 * @see_also: #FsRawUdpStreamTransmitter

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "fs-nice-stream-transmitter.h"

#include "fs-nice-transmitter.h"

#include "fs-nice-agent.h"

#include <farstream/fs-conference.h>

#include <gst/gst.h>

#include <string.h>

#include <sys/types.h>

#define GST_CAT_DEFAULT fs_nice_transmitter_debug

/* Signals */

enum

{

  LAST_SIGNAL

};

/* props */

enum

{

  PROP_0,

  PROP_SENDING,

  PROP_PREFERRED_LOCAL_CANDIDATES,

  PROP_STUN_IP,

  PROP_STUN_PORT,

  PROP_CONTROLLING_MODE,

  PROP_STREAM_ID,

  PROP_COMPATIBILITY_MODE,

  PROP_ASSOCIATE_ON_SOURCE,

  PROP_RELAY_INFO,

  PROP_MIN_PORT,

  PROP_MAX_PORT,

  PROP_ICE_TCP,

  PROP_ICE_UDP,

  PROP_RELIABLE,

  PROP_DEBUG,

  PROP_SEND_COMPONENT_MUX

};

struct _FsNiceStreamTransmitterPrivate

{

  FsNiceTransmitter *transmitter;

  FsNiceAgent *agent;

  guint stream_id;

  guint min_port;

  guint max_port;

  gchar *stun_ip;

  guint stun_port;

  gboolean controlling_mode;

  gboolean ice_udp;

  gboolean ice_tcp;

  gboolean reliable;

  gboolean send_component_mux;

  guint compatibility_mode;

  GMutex mutex;

  GList *preferred_local_candidates;

  gulong state_changed_handler_id;

  gulong gathering_done_handler_id;

  gulong new_selected_pair_handler_id;

  gulong new_candidate_handler_id;

  gulong tos_changed_handler_id;

  GPtrArray *relay_info;

  volatile gint associate_on_source;

  gboolean *component_has_been_ready; /* only from NiceAgent main thread */

  /* Everything below is protected by the mutex */

  gboolean sending;

  gboolean forced_candidates;

  GList *remote_candidates;

  GList *local_candidates;

  /* These are fixed and must be identical in the latest draft */

  gchar *username;

  gchar *password;

  gboolean gathered;

  NiceGstStream *gststream;

};

#define FS_NICE_STREAM_TRANSMITTER_GET_PRIVATE(o)  \

  (G_TYPE_INSTANCE_GET_PRIVATE ((o), FS_TYPE_NICE_STREAM_TRANSMITTER, \

                                FsNiceStreamTransmitterPrivate))

#define FS_NICE_STREAM_TRANSMITTER_LOCK(o)   g_mutex_lock (&(o)->priv->mutex)

#define FS_NICE_STREAM_TRANSMITTER_UNLOCK(o) g_mutex_unlock (&(o)->priv->mutex)

static void fs_nice_stream_transmitter_class_init (FsNiceStreamTransmitterClass *klass);

static void fs_nice_stream_transmitter_init (FsNiceStreamTransmitter *self);

static void fs_nice_stream_transmitter_dispose (GObject *object);

static void fs_nice_stream_transmitter_finalize (GObject *object);

static void fs_nice_stream_transmitter_get_property (GObject *object,

                                                guint prop_id,

                                                GValue *value,

                                                GParamSpec *pspec);

static void fs_nice_stream_transmitter_set_property (GObject *object,

                                                guint prop_id,

                                                const GValue *value,

                                                GParamSpec *pspec);

static gboolean fs_nice_stream_transmitter_add_remote_candidates (

    FsStreamTransmitter *streamtransmitter, GList *candidates,

    GError **error);

static gboolean fs_nice_stream_transmitter_force_remote_candidates (

    FsStreamTransmitter *streamtransmitter,

    GList *remote_candidates,

    GError **error);

static gboolean fs_nice_stream_transmitter_gather_local_candidates (

    FsStreamTransmitter *streamtransmitter,

    GError **error);

static void fs_nice_stream_transmitter_stop (

    FsStreamTransmitter *streamtransmitter);

static void agent_state_changed (NiceAgent *agent,

    guint stream_id,

    guint component_id,

    guint state,

    gpointer user_data);

static void agent_gathering_done (NiceAgent *agent, guint stream_id,

    gpointer user_data);

static void agent_new_selected_pair (NiceAgent *agent,

    guint stream_id,

    guint component_id,

    const gchar *lfoundation,

    const gchar *rfoundation,

    gpointer user_data);

static void agent_new_candidate (NiceAgent *agent,

    guint stream_id,

    guint component_id,

    const gchar *foundation,

    gpointer user_data);

static GstPadProbeReturn known_buffer_have_buffer_handler (GstPad *pad,

    GstPadProbeInfo *info,

    gpointer user_data);

static GObjectClass *parent_class = NULL;

// static guint signals[LAST_SIGNAL] = { 0 };

static GType type = 0;

GType

fs_nice_stream_transmitter_get_type (void)

{

  return type;

}

GType

fs_nice_stream_transmitter_register_type (FsPlugin *module G_GNUC_UNUSED)

{

  static const GTypeInfo info = {

    sizeof (FsNiceStreamTransmitterClass),

    NULL,

    NULL,

    (GClassInitFunc) fs_nice_stream_transmitter_class_init,

    NULL,

    NULL,

    sizeof (FsNiceStreamTransmitter),

    0,

    (GInstanceInitFunc) fs_nice_stream_transmitter_init

  };

  type = g_type_register_static (FS_TYPE_STREAM_TRANSMITTER,

      "FsNiceStreamTransmitter", &info, 0);

  return type;

}

static void

fs_nice_stream_transmitter_class_init (FsNiceStreamTransmitterClass *klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  FsStreamTransmitterClass *streamtransmitterclass =

    FS_STREAM_TRANSMITTER_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->set_property = fs_nice_stream_transmitter_set_property;

  gobject_class->get_property = fs_nice_stream_transmitter_get_property;

  gobject_class->dispose = fs_nice_stream_transmitter_dispose;

  gobject_class->finalize = fs_nice_stream_transmitter_finalize;

  streamtransmitterclass->add_remote_candidates =

    fs_nice_stream_transmitter_add_remote_candidates;

  streamtransmitterclass->force_remote_candidates =

    fs_nice_stream_transmitter_force_remote_candidates;

  streamtransmitterclass->gather_local_candidates =

    fs_nice_stream_transmitter_gather_local_candidates;

  streamtransmitterclass->stop =

    fs_nice_stream_transmitter_stop;

  g_type_class_add_private (klass, sizeof (FsNiceStreamTransmitterPrivate));

  g_object_class_override_property (gobject_class, PROP_SENDING, "sending");

  g_object_class_override_property (gobject_class,

      PROP_PREFERRED_LOCAL_CANDIDATES, "preferred-local-candidates");

  g_object_class_override_property (gobject_class, PROP_ASSOCIATE_ON_SOURCE,

      "associate-on-source");

  g_object_class_install_property (gobject_class, PROP_STUN_IP,

      g_param_spec_string (

          "stun-ip",

          "STUN server",

          "The STUN server used to obtain server-reflexive candidates",

          NULL,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_STUN_PORT,

      g_param_spec_uint (

          "stun-port",

          "STUN server port",

          "The STUN server used to obtain server-reflexive candidates",

          0, 65536,

          3478,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_CONTROLLING_MODE,

      g_param_spec_boolean (

          "controlling-mode",

          "ICE controlling mode",

          "Whether the agent is in controlling mode",

          TRUE,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_ICE_UDP,

      g_param_spec_boolean (

          "ice-udp",

          "ICE UDP",

          "Whether the agent gathers UDP candidates",

          TRUE,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_ICE_TCP,

      g_param_spec_boolean (

          "ice-tcp",

          "ICE TCP",

          "Whether the agent gathers TCP candidates",

          TRUE,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_RELIABLE,

      g_param_spec_boolean (

          "reliable",

          "reliable mode",

          "Whether the agent is reliable",

          FALSE,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_STREAM_ID,

      g_param_spec_uint (

          "stream-id",

          "The id of the stream",

          "The id of the stream according to libnice",

          0, G_MAXINT,

          0,

          G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_COMPATIBILITY_MODE,

      g_param_spec_uint (

          "compatibility-mode",

          "The compability-mode",

          "The id of the stream according to libnice",

          NICE_COMPATIBILITY_DRAFT19, NICE_COMPATIBILITY_LAST,

          NICE_COMPATIBILITY_DRAFT19,

          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  /**

   * FsNiceStreamTransmitter:relay-info:

   *

   * This is a #GPtrArray containing one or more #GstStructure.

   *

   * The fields in the structure are:

   *  <informaltable>

   *   Required

   *   

   *     (gchar*)

   *     ip

   *     The IP address of the TURN server

   *   

   *   

   *     (guint)

   *     port

   *     The port of the TURN server

   *   

   *   

   *     (gchar*)

   *     username

   *   

   *   

   *     (gchar*)

   *     password

   *   

   *   Optional

   *   

   *    (gchar *)

   *    relay-type

   *    The type of TURN server, can use "udp", "tcp" or "tls".

   *        Defaults to "udp" if not specified.

   *   

   *   

   *    (guint)

   *    component

   *    The component this TURN server and creditials will be used for.

   *    If no component is specified, it will be used for all components where

   *    no per-component details were specified.

   *    This is useful if you want to specify different short term creditial

   *    username/password combinations for Google and MSN compatibility modes.

   *    

   *   

   *  </informaltable>

   *

   * Example:

   * |[

   GPtrArray *relay_info = g_ptr_array_new_full (1, (GDestroyNotify) gst_structure_free);

   g_ptr_array_add (relay_info,

      gst_structure_new ("aa",

          "ip", G_TYPE_STRING, "127.0.0.1",

          "port", G_TYPE_UINT, 7654,

          "username", G_TYPE_STRING, "blah",

          "password", G_TYPE_STRING, "blah2",

          "relay-type", G_TYPE_STRING, "udp",

          NULL));

   |]

   *

   */

  g_object_class_install_property (gobject_class, PROP_RELAY_INFO,

      g_param_spec_boxed (

          "relay-info",

          "Information for the TURN server",

          "ip/port/username/password/relay-type/component of the TURN servers"

          " in a GPtrArray of GstStructures",

          G_TYPE_PTR_ARRAY,

          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_DEBUG,

      g_param_spec_boolean (

          "debug",

          "Enable debug messages",

          "Whether the agent should enable libnice and stun debug messages",

          FALSE,

          G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_MIN_PORT,

      g_param_spec_uint (

          "min-port",

          "Minimal listen port",

          "Minimal port number for allocating host candidates."

          " 0 means use any port",

          0, 65535,

          0,

          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_MAX_PORT,

      g_param_spec_uint (

          "max-port",

          "Maximal listen port",

          "Maximal port number for allocating host candidates."

          " It should apply that min-port < max-port; otherwise, any port is"

          " used, just as when the value is 0",

          0, 65535,

          0,

          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, PROP_SEND_COMPONENT_MUX,

      g_param_spec_boolean (

          "send-component-mux",

          "Send component mux",

          "Whether to mux all components on the same component as component 1",

          FALSE,

          G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));

}

static void

fs_nice_stream_transmitter_init (FsNiceStreamTransmitter *self)

{

  /* member init */

  self->priv = FS_NICE_STREAM_TRANSMITTER_GET_PRIVATE (self);

  self->priv->sending = TRUE;

  g_mutex_init (&self->priv->mutex);

  self->priv->controlling_mode = TRUE;

  self->priv->ice_udp = TRUE;

  self->priv->ice_tcp = TRUE;

  self->priv->reliable = TRUE;

}

static void

fs_nice_stream_transmitter_dispose (GObject *object)

{

  FsNiceStreamTransmitter *self = FS_NICE_STREAM_TRANSMITTER (object);

  fs_nice_stream_transmitter_stop (FS_STREAM_TRANSMITTER_CAST (object));

  FS_NICE_STREAM_TRANSMITTER_LOCK (self);

  if (self->priv->state_changed_handler_id)

    g_signal_handler_disconnect (self->priv->agent->agent,

        self->priv->state_changed_handler_id);

  self->priv->state_changed_handler_id = 0;

  if (self->priv->gathering_done_handler_id)

    g_signal_handler_disconnect (self->priv->agent->agent,

        self->priv->gathering_done_handler_id);

  self->priv->gathering_done_handler_id = 0;

  if (self->priv->new_selected_pair_handler_id)

    g_signal_handler_disconnect (self->priv->agent->agent,

        self->priv->new_selected_pair_handler_id);

  self->priv->new_selected_pair_handler_id = 0;

  if (self->priv->new_candidate_handler_id)

    g_signal_handler_disconnect (self->priv->agent->agent,

        self->priv->new_candidate_handler_id);

  self->priv->new_candidate_handler_id = 0;

  if (self->priv->tos_changed_handler_id)

    g_signal_handler_disconnect (self->priv->transmitter,

        self->priv->tos_changed_handler_id);

  self->priv->tos_changed_handler_id = 0;

  if (self->priv->agent)

  {

    g_object_unref (self->priv->agent);

    self->priv->agent = NULL;

  }

  FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

  if (self->priv->transmitter)

  {

    g_object_unref (self->priv->transmitter);

    self->priv->transmitter = NULL;

  }

  parent_class->dispose (object);

}

static void

fs_nice_stream_transmitter_stop (FsStreamTransmitter *streamtransmitter)

{

  FsNiceStreamTransmitter *self =

    FS_NICE_STREAM_TRANSMITTER (streamtransmitter);

  NiceGstStream *gststream;

  guint stream_id;

  FS_NICE_STREAM_TRANSMITTER_LOCK (self);

  gststream = self->priv->gststream;

  self->priv->gststream = NULL;

  stream_id = self->priv->stream_id;

  /* We can't unset the stream id because it gets messy fast, just leave it as

   * is, all calls should fail anyway

   */

  FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

  if (gststream)

    fs_nice_transmitter_free_gst_stream (self->priv->transmitter, gststream);

  if (stream_id)

    nice_agent_remove_stream (self->priv->agent->agent, stream_id);

}

static void

fs_nice_stream_transmitter_finalize (GObject *object)

{

  FsNiceStreamTransmitter *self = FS_NICE_STREAM_TRANSMITTER (object);

  fs_candidate_list_destroy (self->priv->preferred_local_candidates);

  fs_candidate_list_destroy (self->priv->remote_candidates);

  fs_candidate_list_destroy (self->priv->local_candidates);

  if (self->priv->relay_info)

    g_ptr_array_unref (self->priv->relay_info);

  g_free (self->priv->stun_ip);

  g_mutex_clear (&self->priv->mutex);

  g_free (self->priv->username);

  g_free (self->priv->password);

  g_free (self->priv->component_has_been_ready);

  parent_class->finalize (object);

}

static void

fs_nice_stream_transmitter_get_property (GObject *object,

                                           guint prop_id,

                                           GValue *value,

                                           GParamSpec *pspec)

{

  FsNiceStreamTransmitter *self = FS_NICE_STREAM_TRANSMITTER (object);

  switch (prop_id)

  {

    case PROP_SENDING:

      FS_NICE_STREAM_TRANSMITTER_LOCK (self);

      g_value_set_boolean (value, self->priv->sending);

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      break;

    case PROP_PREFERRED_LOCAL_CANDIDATES:

      g_value_set_boxed (value, self->priv->preferred_local_candidates);

      break;

    case PROP_STUN_IP:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_string (value, self->priv->stun_ip);

      break;

    case PROP_STUN_PORT:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_uint (value, self->priv->stun_port);

      break;

    case PROP_CONTROLLING_MODE:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_boolean (value, self->priv->controlling_mode);

      break;

    case PROP_ICE_UDP:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_boolean (value, self->priv->ice_udp);

      break;

    case PROP_ICE_TCP:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_boolean (value, self->priv->ice_tcp);

      break;

    case PROP_RELIABLE:

      if (self->priv->agent)

        g_object_get_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      else

        g_value_set_boolean (value, self->priv->reliable);

      break;

    case PROP_STREAM_ID:

      FS_NICE_STREAM_TRANSMITTER_LOCK (self);

      g_value_set_uint (value, self->priv->stream_id);

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      break;

    case PROP_COMPATIBILITY_MODE:

      g_value_set_uint (value, self->priv->compatibility_mode);

      break;

    case PROP_ASSOCIATE_ON_SOURCE:

      g_value_set_boolean (value,

          g_atomic_int_get (&self->priv->associate_on_source));

      break;

    case PROP_SEND_COMPONENT_MUX:

      g_value_set_boolean (value, self->priv->send_component_mux);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

fs_nice_stream_transmitter_set_property (GObject *object,

                                           guint prop_id,

                                           const GValue *value,

                                           GParamSpec *pspec)

{

  FsNiceStreamTransmitter *self = FS_NICE_STREAM_TRANSMITTER (object);

  switch (prop_id)

  {

    case PROP_SENDING:

      FS_NICE_STREAM_TRANSMITTER_LOCK (self);

      self->priv->sending = g_value_get_boolean (value);

      if (self->priv->gststream)

        fs_nice_transmitter_set_sending (self->priv->transmitter,

            self->priv->gststream, g_value_get_boolean (value));

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      break;

    case PROP_PREFERRED_LOCAL_CANDIDATES:

      self->priv->preferred_local_candidates = g_value_dup_boxed (value);

      break;

    case PROP_STUN_IP:

      self->priv->stun_ip = g_value_dup_string (value);

      break;

    case PROP_STUN_PORT:

      self->priv->stun_port = g_value_get_uint (value);

      break;

    case PROP_CONTROLLING_MODE:

      self->priv->controlling_mode = g_value_get_boolean (value);

      if (self->priv->transmitter && self->priv->agent)

        g_object_set_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      break;

    case PROP_ICE_UDP:

      self->priv->ice_udp = g_value_get_boolean (value);

      if (self->priv->transmitter && self->priv->agent)

        g_object_set_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      break;

    case PROP_ICE_TCP:

      self->priv->ice_tcp = g_value_get_boolean (value);

      if (self->priv->transmitter && self->priv->agent)

        g_object_set_property (G_OBJECT (self->priv->agent->agent),

            g_param_spec_get_name (pspec), value);

      break;

    case PROP_RELIABLE:

      self->priv->reliable = g_value_get_boolean (value);

      break;

    case PROP_COMPATIBILITY_MODE:

      self->priv->compatibility_mode = g_value_get_uint (value);

      break;

    case PROP_ASSOCIATE_ON_SOURCE:

      g_atomic_int_set (&self->priv->associate_on_source,

          g_value_get_boolean (value));

      break;

    case PROP_RELAY_INFO:

      self->priv->relay_info = g_value_dup_boxed (value);

      break;

    case PROP_MIN_PORT:

      self->priv->min_port = g_value_get_uint (value);

      break;

    case PROP_MAX_PORT:

      self->priv->max_port = g_value_get_uint (value);

      break;

    case PROP_DEBUG:

      if (g_value_get_boolean (value)) {

        nice_debug_enable (TRUE);

      } else {

        nice_debug_disable (TRUE);

      }

      break;

    case PROP_SEND_COMPONENT_MUX:

      self->priv->send_component_mux = g_value_get_boolean (value);

      if (self->priv->gststream != NULL)

        fs_nice_transmitter_set_send_component_mux (self->priv->transmitter,

            self->priv->gststream, self->priv->send_component_mux);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static NiceCandidateType

fs_candidate_type_to_nice_candidate_type (FsCandidateType type)

{

  switch (type)

  {

    case FS_CANDIDATE_TYPE_HOST:

      return NICE_CANDIDATE_TYPE_HOST;

    case FS_CANDIDATE_TYPE_SRFLX:

      return NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE;

    case FS_CANDIDATE_TYPE_PRFLX:

      return NICE_CANDIDATE_TYPE_PEER_REFLEXIVE;

    case FS_CANDIDATE_TYPE_RELAY:

      return NICE_CANDIDATE_TYPE_RELAYED;

    default:

      GST_WARNING ("Invalid candidate type %d, defaulting to type host", type);

      return NICE_CANDIDATE_TYPE_HOST;

  }

}

static NiceCandidateTransport

fs_network_protocol_to_nice_candidate_protocol (FsNetworkProtocol proto)

{

  switch (proto)

  {

    case FS_NETWORK_PROTOCOL_UDP:

      return NICE_CANDIDATE_TRANSPORT_UDP;

    case FS_NETWORK_PROTOCOL_TCP_ACTIVE:

      return NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE;

    case FS_NETWORK_PROTOCOL_TCP_PASSIVE:

      return NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE;

    case FS_NETWORK_PROTOCOL_TCP_SO:

      return NICE_CANDIDATE_TRANSPORT_TCP_SO;

    default:

      GST_WARNING ("Invalid Fs network protocol type %u", proto);

      return NICE_CANDIDATE_TRANSPORT_UDP;

  }

}

static NiceCandidate *

fs_candidate_to_nice_candidate (FsNiceStreamTransmitter *self,

    FsCandidate *candidate)

{

  NiceCandidate *nc = nice_candidate_new (

      fs_candidate_type_to_nice_candidate_type (candidate->type));

  nc->transport =

    fs_network_protocol_to_nice_candidate_protocol (candidate->proto);

  nc->priority = candidate->priority;

  nc->stream_id = self->priv->stream_id;

  nc->component_id = candidate->component_id;

  if (candidate->foundation != NULL)

    strncpy (nc->foundation, candidate->foundation,

       NICE_CANDIDATE_MAX_FOUNDATION - 1);

  nc->username = g_strdup(candidate->username);

  nc->password = g_strdup(candidate->password);

  if (candidate->ip == NULL)

    goto error;

  if (!nice_address_set_from_string (&nc->addr, candidate->ip))

    goto error;

  nice_address_set_port (&nc->addr, candidate->port);

  if (candidate->base_ip && candidate->base_port)

  {

    if (!nice_address_set_from_string (&nc->base_addr, candidate->base_ip))

      goto error;

    nice_address_set_port (&nc->base_addr, candidate->base_port);

  }

  return nc;

 error:

  nice_candidate_free (nc);

  return NULL;

}

static gboolean

fs_nice_stream_transmitter_add_remote_candidates (

    FsStreamTransmitter *streamtransmitter,

    GList *candidates,

    GError **error)

{

  FsNiceStreamTransmitter *self =

    FS_NICE_STREAM_TRANSMITTER (streamtransmitter);

  GList  *item;

  GSList *nice_candidates = NULL;

  gint c;

  const gchar *username;

  const gchar *password;

  if (!candidates)

  {

    GST_DEBUG ("NULL candidates passed, lets do an ICE restart");

    FS_NICE_STREAM_TRANSMITTER_LOCK (self);

    if (self->priv->remote_candidates)

      fs_candidate_list_destroy (self->priv->remote_candidates);

    self->priv->remote_candidates = NULL;

    self->priv->forced_candidates = FALSE;

    g_free (self->priv->username);

    g_free (self->priv->password);

    self->priv->username = NULL;

    self->priv->password = NULL;

    FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

    nice_agent_restart (self->priv->agent->agent);

    return TRUE;

  }

  FS_NICE_STREAM_TRANSMITTER_LOCK (self);

  username = self->priv->username;

  password = self->priv->password;

  /* Validate candidates */

  for (item = candidates;

       item;

       item = g_list_next (item))

  {

    FsCandidate *candidate = item->data;

    if (!candidate->ip)

    {

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,

          "Candidate MUST have an IP address");

      return FALSE;

    }

    if (candidate->component_id == 0 ||

        candidate->component_id > self->priv->transmitter->components)

    {

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,

          "Candidate MUST have a component id between 1 and %d, %d is invalid",

          self->priv->transmitter->components, candidate->component_id);

      return FALSE;

    }

    if (candidate->type == FS_CANDIDATE_TYPE_MULTICAST)

    {

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,

          "libnice transmitter does not accept multicast candidates");

      return FALSE;

    }

    if (!candidate->username)

    {

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,

          "Invalid remote candidates passed, does not have a username");

      return FALSE;

    }

    if (self->priv->compatibility_mode != NICE_COMPATIBILITY_GOOGLE &&

        !candidate->password)

    {

      FS_NICE_STREAM_TRANSMITTER_UNLOCK (self);

      g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,

          "Invalid remote candidates passed, does not have a password");

      return FALSE;

    }

    if (self->priv->compatibility_mode != NICE_COMPATIBILITY_GOOGLE &&

        self->priv->compatibility_mode != NICE_COMPATIBILITY_MSN &&

        self->priv->compatibility_mode != NICE_COMPATIBILITY_OC2007)

    {