NiceAgentRecvFunc ()

void
(*NiceAgentRecvFunc) (NiceAgent *agent,
                      guint stream_id,
                      guint component_id,
                      guint len,
                      gchar *buf,
                      gpointer user_data);

Callback function when data is received on a component

nice_agent_new ()

NiceAgent *
nice_agent_new (GMainContext *ctx,
                NiceCompatibility compat);

Create a new NiceAgent. The returned object must be freed with g_object_unref()

nice_agent_new_reliable ()

NiceAgent *
nice_agent_new_reliable (GMainContext *ctx,
                         NiceCompatibility compat);

Create a new NiceAgent in reliable mode. If the connectivity is established through ICE-UDP, then a PseudoTcpSocket will be transparently used to ensure reliability of the messages. The returned object must be freed with g_object_unref()

See also: “reliable-transport-writable”

Since: 0.0.11

nice_agent_new_full ()

NiceAgent *
nice_agent_new_full (GMainContext *ctx,
                     NiceCompatibility compat,
                     NiceAgentOption flags);

Create a new NiceAgent with parameters that must be be defined at construction time. The returned object must be freed with g_object_unref()

See also: NiceNominationMode and NiceAgentOption

Since: 0.1.15

nice_agent_add_local_address ()

gboolean
nice_agent_add_local_address (NiceAgent *agent,
                              NiceAddress *addr);

Add a local address from which to derive local host candidates for candidate gathering.

Since 0.0.5, if this method is not called, libnice will automatically discover the local addresses available

See also: nice_agent_gather_candidates()

nice_agent_set_port_range ()

void
nice_agent_set_port_range (NiceAgent *agent,
                           guint stream_id,
                           guint component_id,
                           guint min_port,
                           guint max_port);

Sets a preferred port range for allocating host candidates.

If a local host candidate cannot be created on that port range, then the nice_agent_gather_candidates() call will fail.

This MUST be called before nice_agent_gather_candidates()

nice_agent_add_stream ()

guint
nice_agent_add_stream (NiceAgent *agent,
                       guint n_components);

Adds a data stream to agent containing n_components components. The returned stream ID is guaranteed to be positive on success.

nice_agent_remove_stream ()

void
nice_agent_remove_stream (NiceAgent *agent,
                          guint stream_id);

Remove and free a previously created data stream from agent . If any I/O streams have been created using nice_agent_get_io_stream(), they should be closed completely using g_io_stream_close() before this is called, or they will get broken pipe errors.

nice_agent_set_relay_info ()

gboolean
nice_agent_set_relay_info (NiceAgent *agent,
                           guint stream_id,
                           guint component_id,
                           const gchar *server_ip,
                           guint server_port,
                           const gchar *username,
                           const gchar *password,
                           NiceRelayType type);

Sets the settings for using a relay server during the candidate discovery. This may be called multiple times to add multiple relay servers to the discovery process; one TCP and one UDP, for example.

nice_agent_forget_relays ()

gboolean
nice_agent_forget_relays (NiceAgent *agent,
                          guint stream_id,
                          guint component_id);

Forget all the relay servers previously added using nice_agent_set_relay_info(). Currently connected streams will keep using the relay as long as they have not been restarted and haven't succesfully negotiated a different path.

Since: 0.1.6

nice_agent_gather_candidates ()

gboolean
nice_agent_gather_candidates (NiceAgent *agent,
                              guint stream_id);

Allocate and start listening on local candidate ports and start the remote candidate gathering process. Once done, “candidate-gathering-done” is called for the stream. As soon as this function is called, “new-candidate” signals may be emitted, even before this function returns.

nice_agent_get_local_candidates() will only return non-empty results after calling this function.

See also: nice_agent_add_local_address()

See also: nice_agent_set_port_range()

nice_agent_set_remote_credentials ()

gboolean
nice_agent_set_remote_credentials (NiceAgent *agent,
                                   guint stream_id,
                                   const gchar *ufrag,
                                   const gchar *pwd);

Sets the remote credentials for stream stream_id .

nice_agent_get_local_credentials ()

gboolean
nice_agent_get_local_credentials (NiceAgent *agent,
                                  guint stream_id,
                                  gchar **ufrag,
                                  gchar **pwd);

Gets the local credentials for stream stream_id . This may be called any time after creating a stream using nice_agent_add_stream().

An error will be returned if this is called for a non-existent stream, or if either of ufrag or pwd are NULL.

nice_agent_set_local_credentials ()

gboolean
nice_agent_set_local_credentials (NiceAgent *agent,
                                  guint stream_id,
                                  const gchar *ufrag,
                                  const gchar *pwd);

Sets the local credentials for stream stream_id .

Since 0.1.11

nice_agent_set_remote_candidates ()

int
nice_agent_set_remote_candidates (NiceAgent *agent,
                                  guint stream_id,
                                  guint component_id,
                                  const GSList *candidates);

Sets, adds or updates the remote candidates for a component of a stream.

nice_agent_get_remote_candidates ()

GSList *
nice_agent_get_remote_candidates (NiceAgent *agent,
                                  guint stream_id,
                                  guint component_id);

Get a list of the remote candidates set on a stream's component

nice_agent_get_local_candidates ()

GSList *
nice_agent_get_local_candidates (NiceAgent *agent,
                                 guint stream_id,
                                 guint component_id);

Retrieve from the agent the list of all local candidates for a stream's component

nice_agent_get_selected_pair ()

gboolean
nice_agent_get_selected_pair (NiceAgent *agent,
                              guint stream_id,
                              guint component_id,
                              NiceCandidate **local,
                              NiceCandidate **remote);

Retreive the selected candidate pair for media transmission for a given stream's component.

nice_agent_peer_candidate_gathering_done ()

gboolean
nice_agent_peer_candidate_gathering_done
                               (NiceAgent *agent,
                                guint stream_id);

Notifies the agent that the remote peer has concluded candidate gathering and thus no more remote candidates are expected to arrive for stream_id .

This will allow the stream components without a successful connectivity check to stop waiting for more candidates to come and finally transit into NICE_COMPONENT_STATE_FAILED.

Calling the function has an effect only when “trickle-ice” is TRUE.

Since: 0.1.16

nice_agent_send ()

gint
nice_agent_send (NiceAgent *agent,
                 guint stream_id,
                 guint component_id,
                 guint len,
                 const gchar *buf);

Sends a data payload over a stream's component.

nice_agent_send_messages_nonblocking ()

gint
nice_agent_send_messages_nonblocking (NiceAgent *agent,
                                      guint stream_id,
                                      guint component_id,
                                      const NiceOutputMessage *messages,
                                      guint n_messages,
                                      GCancellable *cancellable,
                                      GError **error);

Sends multiple messages on the socket identified by the given stream/component pair. Transmission is non-blocking, so a G_IO_ERROR_WOULD_BLOCK error may be returned if the send buffer is full.

As with nice_agent_send(), the given component must be in NICE_COMPONENT_STATE_READY or, as a special case, in any state if it was previously ready and was then restarted.

On success, the number of messages written to the socket will be returned, which may be less than n_messages if transmission would have blocked part-way through. Zero will be returned if n_messages is zero, or if transmission would have blocked on the first message.

In reliable mode, it is instead recommended to use nice_agent_send(). The return value can be less than n_messages or 0 even if it is still possible to send a partial message. In this case, "nice-agent-writable" will never be triggered, so the application would have to use nice_agent_sent() to fill the buffer or have to retry sending at a later point.

On failure, -1 will be returned and error will be set. If the NiceAgent is reliable and the socket is not yet connected, G_IO_ERROR_BROKEN_PIPE will be returned; if the write buffer is full, G_IO_ERROR_WOULD_BLOCK will be returned. In both cases, wait for the “reliable-transport-writable” signal before trying again. If the given stream_id or component_id are invalid or not yet connected, G_IO_ERROR_BROKEN_PIPE will be returned. G_IO_ERROR_FAILED will be returned for other errors.

Since: 0.1.5

nice_agent_recv ()

gssize
nice_agent_recv (NiceAgent *agent,
                 guint stream_id,
                 guint component_id,
                 guint8 *buf,
                 gsize buf_len,
                 GCancellable *cancellable,
                 GError **error);

A single-message version of nice_agent_recv_messages().

Since: 0.1.5

nice_agent_recv_messages ()

gint
nice_agent_recv_messages (NiceAgent *agent,
                          guint stream_id,
                          guint component_id,
                          NiceInputMessage *messages,
                          guint n_messages,
                          GCancellable *cancellable,
                          GError **error);

Block on receiving data from the given stream/component combination on agent , returning only once exactly n_messages messages have been received and written into messages , the stream is closed by the other end or by calling nice_agent_remove_stream(), or cancellable is cancelled.

Any STUN packets received will not be added to messages ; instead, they'll be passed for processing to NiceAgent itself. Since NiceAgent does not poll for messages on its own, it's therefore essential to keep calling this function for ICE connection establishment to work.

In the non-error case, in reliable mode, this will block until all buffers in all n_messages have been filled with received data (i.e. messages is treated as a large, flat array of buffers). In non-reliable mode, it will block until n_messages messages have been received, each of which does not have to fill all the buffers in its NiceInputMessage. In the non-reliable case, each NiceInputMessage must have enough buffers to contain an entire message (65536 bytes), or any excess data may be silently dropped.

For each received message, “length” will be set to the number of valid bytes stored in the message’s buffers. The bytes are stored sequentially in the buffers; there are no gaps apart from at the end of the buffer array (in non-reliable mode). If non-NULL on input, “from” will have the address of the sending peer stored in it. The base addresses, sizes, and number of buffers in each message will not be modified in any case.

This must not be used in combination with nice_agent_attach_recv() on the same stream/component pair.

If the stream/component pair doesn’t exist, or if a suitable candidate socket hasn’t yet been selected for it, a G_IO_ERROR_BROKEN_PIPE error will be returned. A G_IO_ERROR_CANCELLED error will be returned if the operation was cancelled. G_IO_ERROR_FAILED will be returned for other errors.

Since: 0.1.5

nice_agent_recv_nonblocking ()

gssize
nice_agent_recv_nonblocking (NiceAgent *agent,
                             guint stream_id,
                             guint component_id,
                             guint8 *buf,
                             gsize buf_len,
                             GCancellable *cancellable,
                             GError **error);

A single-message version of nice_agent_recv_messages_nonblocking().

Since: 0.1.5

nice_agent_recv_messages_nonblocking ()

gint
nice_agent_recv_messages_nonblocking (NiceAgent *agent,
                                      guint stream_id,
                                      guint component_id,
                                      NiceInputMessage *messages,
                                      guint n_messages,
                                      GCancellable *cancellable,
                                      GError **error);

Try to receive data from the given stream/component combination on agent , without blocking. If receiving data would block, -1 is returned and G_IO_ERROR_WOULD_BLOCK is set in error . If any other error occurs, -1 is returned and error is set accordingly. Otherwise, 0 is returned if (and only if) n_messages is 0. In all other cases, the number of valid messages stored in messages is returned, and will be greater than 0.

This function behaves similarly to nice_agent_recv_messages(), except that it will not block on filling (in reliable mode) or receiving (in non-reliable mode) exactly n_messages messages. In reliable mode, it will receive bytes into messages until it would block; in non-reliable mode, it will receive messages until it would block.

Any STUN packets received will not be added to messages ; instead, they'll be passed for processing to NiceAgent itself. Since NiceAgent does not poll for messages on its own, it's therefore essential to keep calling this function for ICE connection establishment to work.

As this function is non-blocking, cancellable is included only for parity with nice_agent_recv_messages(). If cancellable is cancelled before this function is called, a G_IO_ERROR_CANCELLED error will be returned immediately.

This must not be used in combination with nice_agent_attach_recv() on the same stream/component pair.

Since: 0.1.5

nice_agent_attach_recv ()

gboolean
nice_agent_attach_recv (NiceAgent *agent,
                        guint stream_id,
                        guint component_id,
                        GMainContext *ctx,
                        NiceAgentRecvFunc func,
                        gpointer data);

Attaches the stream's component's sockets to the Glib Mainloop Context in order to be notified whenever data becomes available for a component, and to enable NiceAgent to receive STUN messages (during the establishment of ICE connectivity).

This must not be used in combination with nice_agent_recv_messages() (or NiceIOStream or NiceInputStream) on the same stream/component pair.

Calling nice_agent_attach_recv() with a NULL func will detach any existing callback and cause reception to be paused for the given stream/component pair. You must iterate the previously specified GMainContext sufficiently to ensure all pending I/O callbacks have been received before calling this function to unset func , otherwise data loss of received packets may occur.

[skip]

nice_agent_set_selected_pair ()

gboolean
nice_agent_set_selected_pair (NiceAgent *agent,
                              guint stream_id,
                              guint component_id,
                              const gchar *lfoundation,
                              const gchar *rfoundation);

Sets the selected candidate pair for media transmission for a given stream's component. Calling this function will disable all further ICE processing (connection check, state machine updates, etc). Note that keepalives will continue to be sent.

nice_agent_set_selected_remote_candidate ()

gboolean
nice_agent_set_selected_remote_candidate
                               (NiceAgent *agent,
                                guint stream_id,
                                guint component_id,
                                NiceCandidate *candidate);

Sets the selected remote candidate for media transmission for a given stream's component. This is used to force the selection of a specific remote candidate even when connectivity checks are failing (e.g. non-ICE compatible candidates). Calling this function will disable all further ICE processing (connection check, state machine updates, etc). Note that keepalives will continue to be sent.

nice_agent_set_stream_tos ()

void
nice_agent_set_stream_tos (NiceAgent *agent,
                           guint stream_id,
                           gint tos);

Sets the IP_TOS and/or IPV6_TCLASS field on the stream's sockets' options

Since: 0.0.9

nice_agent_set_software ()

void
nice_agent_set_software (NiceAgent *agent,
                         const gchar *software);

This function will set the value of the SOFTWARE attribute to be added to STUN requests, responses and error responses sent during connectivity checks.

The SOFTWARE attribute will only be added in the NICE_COMPATIBILITY_RFC5245 and NICE_COMPATIBILITY_WLM2009 compatibility modes.

Since: 0.0.10

nice_agent_restart ()

gboolean
nice_agent_restart (NiceAgent *agent);

Restarts the session as defined in ICE draft 19. This function needs to be called both when initiating (ICE spec section 9.1.1.1. "ICE Restarts"), as well as when reacting (spec section 9.2.1.1. "Detecting ICE Restart") to a restart.

nice_agent_restart_stream ()

gboolean
nice_agent_restart_stream (NiceAgent *agent,
                           guint stream_id);

Restarts a single stream as defined in RFC 5245. This function needs to be called both when initiating (ICE spec section 9.1.1.1. "ICE Restarts"), as well as when reacting (spec section 9.2.1.1. "Detecting ICE Restart") to a restart.

Unlike nice_agent_restart(), this applies to a single stream. It also does not generate a new tie breaker.

Since: 0.1.6

nice_agent_set_stream_name ()

gboolean
nice_agent_set_stream_name (NiceAgent *agent,
                            guint stream_id,
                            const gchar *name);

This function will assign a media type to a stream. The only values that can be used to produce a valid SDP are: "audio", "video", "text", "application", "image" and "message".

This is only useful when parsing and generating an SDP of the candidates.

See also: nice_agent_generate_local_sdp()

See also: nice_agent_parse_remote_sdp()

See also: nice_agent_get_stream_name()

Since: 0.1.4

nice_agent_get_stream_name ()

const gchar *
nice_agent_get_stream_name (NiceAgent *agent,
                            guint stream_id);

This function will return the name assigned to a stream.

See also: nice_agent_set_stream_name()

Since: 0.1.4

nice_agent_get_default_local_candidate ()

NiceCandidate *
nice_agent_get_default_local_candidate
                               (NiceAgent *agent,
                                guint stream_id,
                                guint component_id);

This helper function will return the recommended default candidate to be used for non-ICE compatible clients. This will usually be the candidate with the lowest priority, since it will be the longest path but the one with the most chances of success.

nice_agent_generate_local_sdp ()

gchar *
nice_agent_generate_local_sdp (NiceAgent *agent);

Generate an SDP string containing the local candidates and credentials for all streams and components in the agent.

See also: nice_agent_set_stream_name()

See also: nice_agent_parse_remote_sdp()

See also: nice_agent_generate_local_stream_sdp()

See also: nice_agent_generate_local_candidate_sdp()

See also: nice_agent_get_default_local_candidate()

Since: 0.1.4

nice_agent_generate_local_stream_sdp ()

gchar *
nice_agent_generate_local_stream_sdp (NiceAgent *agent,
                                      guint stream_id,
                                      gboolean include_non_ice);

Generate an SDP string containing the local candidates and credentials for a stream.

See also: nice_agent_set_stream_name()

See also: nice_agent_parse_remote_stream_sdp()

See also: nice_agent_generate_local_sdp()

See also: nice_agent_generate_local_candidate_sdp()

See also: nice_agent_get_default_local_candidate()

Since: 0.1.4

nice_agent_generate_local_candidate_sdp ()

gchar *
nice_agent_generate_local_candidate_sdp
                               (NiceAgent *agent,
                                NiceCandidate *candidate);

Generate an SDP string representing a local candidate.

See also: nice_agent_parse_remote_candidate_sdp()

See also: nice_agent_generate_local_sdp()

See also: nice_agent_generate_local_stream_sdp()

Since: 0.1.4

nice_agent_parse_remote_sdp ()

int
nice_agent_parse_remote_sdp (NiceAgent *agent,
                             const gchar *sdp);

Parse an SDP string and extracts candidates and credentials from it and sets them on the agent.

See also: nice_agent_set_stream_name()

See also: nice_agent_generate_local_sdp()

See also: nice_agent_parse_remote_stream_sdp()

See also: nice_agent_parse_remote_candidate_sdp()

Since: 0.1.4

nice_agent_parse_remote_stream_sdp ()

GSList *
nice_agent_parse_remote_stream_sdp (NiceAgent *agent,
                                    guint stream_id,
                                    const gchar *sdp,
                                    gchar **ufrag,
                                    gchar **pwd);

Parse an SDP string representing a single stream and extracts candidates and credentials from it.

See also: nice_agent_generate_local_stream_sdp()

See also: nice_agent_parse_remote_sdp()

See also: nice_agent_parse_remote_candidate_sdp()

Since: 0.1.4

nice_agent_parse_remote_candidate_sdp ()

NiceCandidate *
nice_agent_parse_remote_candidate_sdp (NiceAgent *agent,
                                       guint stream_id,
                                       const gchar *sdp);

Parse an SDP string and extracts the candidate from it.

See also: nice_agent_generate_local_candidate_sdp()

See also: nice_agent_parse_remote_sdp()

See also: nice_agent_parse_remote_stream_sdp()

Since: 0.1.4

nice_agent_get_io_stream ()

GIOStream *
nice_agent_get_io_stream (NiceAgent *agent,
                          guint stream_id,
                          guint component_id);

Gets a GIOStream wrapper around the given stream and component in agent . The I/O stream will be valid for as long as stream_id is valid. The GInputStream and GOutputStream implement GPollableInputStream and GPollableOutputStream.

This function may only be called on reliable NiceAgents. It is a programming error to try and create an I/O stream wrapper for an unreliable stream.

Since: 0.1.5

nice_agent_get_selected_socket ()

GSocket *
nice_agent_get_selected_socket (NiceAgent *agent,
                                guint stream_id,
                                guint component_id);

Retreive the local socket associated with the selected candidate pair for media transmission for a given stream's component.

This is useful for adding ICE support to legacy applications that already have a protocol that maintains a connection. If the socket is duplicated before unrefing the agent, the application can take over and continue to use it. New applications are encouraged to use the built in libnice stream handling instead and let libnice handle the connection maintenance.

Users of this method are encouraged to not use a TURN relay or any kind of proxy, as in this case, the socket will not be available to the application because the packets are encapsulated.

Since: 0.1.5

nice_agent_get_sockets ()

GPtrArray *
nice_agent_get_sockets (NiceAgent *agent,
                        guint stream_id,
                        guint component_id);

Each component can have multiple sockets, this is an API to retrieve them all to be able to set properties. Most of the sockets for a component are created when calling nice_agent_gather_candidates(), so this API should be called right after to able to set properties on the sockets before they are used.

These sockets can be a mix of UDP & TCP sockets depending on the compatibility mode and options that have been set.

Since: 0.1.17

nice_agent_get_component_state ()

NiceComponentState
nice_agent_get_component_state (NiceAgent *agent,
                                guint stream_id,
                                guint component_id);

Retrieves the current state of a component.

Since: 0.1.8

nice_agent_close_async ()

void
nice_agent_close_async (NiceAgent *agent,
                        GAsyncReadyCallback callback,
                        gpointer callback_data);

Asynchronously closes resources the agent has allocated on remote servers.

The agent will call the callback in the current GMainContext in which this function is called. The GAsyncResult in the callback can be ignored as this operation never fails.

Calling this function before freeing the agent makes sure the allocated relay ports aren't left behind on TURN server but properly removed.

Since: 0.1.16

nice_component_state_to_string ()

const gchar *
nice_component_state_to_string (NiceComponentState state);

Returns a string representation of the state, generally to use in debug messages.

Since: 0.1.6

NiceAgent

typedef struct _NiceAgent NiceAgent;

The NiceAgent is the main GObject of the libnice library and represents the ICE agent.

enum NiceComponentState

An enum representing the state of a component.

See also: “component-state-changed”

enum NiceComponentType

Convenience enum representing the type of a component for use as the component_id for RTP/RTCP usages.

   nice_agent_send (agent, stream_id, NICE_COMPONENT_TYPE_RTP, len, buf);
   

enum NiceProxyType

An enum to specify which proxy type to use for relaying. Note that the proxies will only be used with TCP TURN relaying.

See also: “proxy-type”

Since: 0.0.4

enum NiceNominationMode

An enum to specity the kind of nomination mode to use by the agent, as described in RFC 5245. Two modes exists, regular and aggressive. They differ by the way the controlling agent chooses to put the USE-CANDIDATE attribute in its STUN messages. The aggressive mode is supposed to nominate a pair faster, than the regular mode, potentially causing the nominated pair to change until the connection check completes.

Since: 0.1.15

enum NiceCompatibility

An enum to specify which compatible specifications the NiceAgent should use. Use with nice_agent_new()

NiceInputMessage

typedef struct {
  GInputVector *buffers;
  gint n_buffers;  /* may be -1 to indicate @buffers is NULL-terminated */
  NiceAddress *from;  /* return location for address of message sender */
  gsize length;  /* sum of the lengths of @buffers */
} NiceInputMessage;

Represents a single message received off the network. For reliable connections, this is essentially just an array of buffers (specifically, from can be ignored). for non-reliable connections, it represents a single packet as received from the OS.

n_buffers may be -1 to indicate that buffers is terminated by a GInputVector with a NULL buffer pointer.

By providing arrays of NiceInputMessages to functions like nice_agent_recv_messages(), multiple messages may be received with a single call, which is more efficient than making multiple calls in a loop. In this manner, nice_agent_recv_messages() is analogous to recvmmsg(); and NiceInputMessage to struct mmsghdr.

Since: 0.1.5

NiceOutputMessage

typedef struct {
  GOutputVector *buffers;
  gint n_buffers;
} NiceOutputMessage;

Represents a single message to transmit on the network. For reliable connections, this is essentially just an array of buffer. for non-reliable connections, it represents a single packet to send to the OS.

n_buffers may be -1 to indicate that buffers is terminated by a GOutputVector with a NULL buffer pointer.

By providing arrays of NiceOutputMessages to functions like nice_agent_send_messages_nonblocking(), multiple messages may be transmitted with a single call, which is more efficient than making multiple calls in a loop. In this manner, nice_agent_send_messages_nonblocking() is analogous to sendmmsg(); and NiceOutputMessage to struct mmsghdr.

Since: 0.1.5

NICE_AGENT_MAX_REMOTE_CANDIDATES

#define NICE_AGENT_MAX_REMOTE_CANDIDATES    25

A hard limit for the number of remote candidates. This limit is enforced to protect against malevolent remote clients.

enum NiceAgentOption

These are options that can be passed to nice_agent_new_full(). They set various properties on the agent. Not including them sets the property to the other value.

Since: 0.1.15

The “bytestream-tcp” property

  “bytestream-tcp”           gboolean

This property defines whether receive/send over a TCP or pseudo-TCP, in reliable mode, are considered as packetized or as bytestream. In unreliable mode, every send/recv is considered as packetized, and this property is ignored and cannot be set.

In reliable mode, this property will always return TRUE in the NICE_COMPATIBILITY_GOOGLE compatibility mode.

If the property is TRUE, the stream is considered in bytestream mode and data can be read with any receive size. If the property is FALSE, then the stream is considred packetized and each receive will return one packet of the same size as what was sent from the peer. If in packetized mode, then doing a receive with a size smaller than the packet, will cause the remaining bytes in the packet to be dropped, breaking the reliability of the stream.

This property is currently read-only, and will become read/write once bytestream mode will be supported.

Owner: NiceAgent

Flags: Read

Default value: FALSE

Since: 0.1.8

The “compatibility” property

  “compatibility”            guint

The Nice agent can work in various compatibility modes depending on what the application/peer needs.

See also: NiceCompatibility

Owner: NiceAgent

Flags: Read / Write / Construct Only

Allowed values: <= 5

Default value: 0

The “controlling-mode” property

  “controlling-mode”         gboolean

Whether the agent has the controlling role. This property should be modified before gathering candidates, any modification occuring later will be hold until ICE is restarted.

Owner: NiceAgent

Flags: Read / Write

Default value: FALSE

The “force-relay” property

  “force-relay”              gboolean

Force all traffic to go through a relay for added privacy, this allows hiding the local IP address. When this is enabled, so local candidates are available before relay servers have been set with nice_agent_set_relay_info().

Owner: NiceAgent

Flags: Read / Write

Default value: FALSE

Since: 0.1.14

The “full-mode” property

  “full-mode”                gboolean

Whether agent runs in ICE full mode.

Owner: NiceAgent

Flags: Read / Write / Construct Only

Default value: TRUE

The “ice-tcp” property

  “ice-tcp”                  gboolean

Whether the agent should use ICE-TCP when gathering candidates. If the option is disabled, no TCP candidates will be generated. If the agent is in reliable mode, then pseudotcp will need to be used over UDP candidates.

This option should be set before gathering candidates and should not be modified afterwards.

The “ice-tcp” property can be set at the same time as the “ice-udp” property, but both cannot be unset at the same time. If “ice-udp” is set to FALSE, then this property cannot be set to FALSE as well.

Owner: NiceAgent

Flags: Read / Write

Default value: TRUE

Since: 0.1.8

The “ice-trickle” property

  “ice-trickle”              gboolean

Whether to perform Trickle ICE as per draft-ietf-ice-trickle-ice-21. When TRUE, the agent will postpone changing a component state to NICE_COMPONENT_STATE_FAILED until nice_agent_peer_candidate_gathering_done() has been called with the ID of the component's stream.

Owner: NiceAgent

Flags: Read / Write

Default value: FALSE

Since: 0.1.16

The “ice-udp” property

  “ice-udp”                  gboolean

Whether the agent should use ICE-UDP when gathering candidates. If the option is disabled, no UDP candidates will be generated. If the agent is in reliable mode, then pseudotcp will not be used since pseudotcp works on top of UDP candidates.

This option should be set before gathering candidates and should not be modified afterwards.

The “ice-udp” property can be set at the same time as the “ice-tcp” property, but both cannot be unset at the same time. If “ice-tcp” is set to FALSE, then this property cannot be set to FALSE as well.

Owner: NiceAgent

Flags: Read / Write

Default value: TRUE

Since: 0.1.8

The “idle-timeout” property

  “idle-timeout”             guint

A final timeout in msec, launched when the agent becomes idle, before stopping its activity.

This timer will delay the decision to set a component as failed. This delay is added to reduce the chance to see the agent receiving new stun activity just after the conncheck list has been declared failed (some valid pairs, no nominated pair, and no in-progress pairs), reactiviting conncheck activity, and causing a (valid) state transitions like that: connecting -> failed -> connecting -> connected -> ready. Such transitions are not buggy per-se, but may break the test-suite, that counts precisely the number of time each state has been set, and doesnt expect these transcient failed states.

This timer is also useful when the agent is in controlled mode and the other controlling peer takes some time to elect its nominated pair (this may be the case for SfB peers).

This timer is *NOT* part if the RFC5245, as this situation is not covered in sect 8.1.2 "Updating States", but deals with a real use-case, where a controlled agent can not wait forever for the other peer to make a nomination decision.

Also note that the value of this timeout will not delay the emission of 'connected' and 'ready' agent signals, and will not slow down the behaviour of the agent when the peer agent works in a timely manner.

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: [50,60000]

Default value: 5000

Since: 0.1.17

The “keepalive-conncheck” property

  “keepalive-conncheck”      gboolean

Use binding requests as keepalives instead of binding indications. This means that the keepalives may time out which will change the component state to NICE_COMPONENT_STATE_FAILED.

Enabing this is a slight violation of RFC 5245 section 10 which recommends using Binding Indications for keepalives.

This is always enabled if the compatibility mode is NICE_COMPATIBILITY_GOOGLE.

Owner: NiceAgent

Flags: Read / Write

Default value: FALSE

Since: 0.1.8

The “main-context” property

  “main-context”             gpointer

A GLib main context is needed for all timeouts used by libnice. This is a property being set by the nice_agent_new() call.

Owner: NiceAgent

Flags: Read / Write / Construct Only

The “max-connectivity-checks” property

  “max-connectivity-checks”  guint

Upper limit for the total number of connectivity checks performed.

Owner: NiceAgent

Flags: Read / Write

Default value: 0

The “nomination-mode” property

  “nomination-mode”          NiceNominationMode

The nomination mode used in the ICE specification for describing the selection of valid pairs to be used upstream.

See also: NiceNominationMode

Owner: NiceAgent

Flags: Read / Write / Construct Only

Default value: NICE_NOMINATION_MODE_AGGRESSIVE

Since: 0.1.15

The “proxy-ip” property

  “proxy-ip”                 char *

The proxy server IP used to bypass a proxy firewall

Owner: NiceAgent

Flags: Read / Write

Default value: NULL

Since: 0.0.4

The “proxy-password” property

  “proxy-password”           char *

The password used to authenticate with the proxy

Owner: NiceAgent

Flags: Read / Write

Default value: NULL

Since: 0.0.4

The “proxy-port” property

  “proxy-port”               guint

The proxy server port used to bypass a proxy firewall

Owner: NiceAgent

Flags: Read / Write

Allowed values: [1,65536]

Default value: 1

Since: 0.0.4

The “proxy-type” property

  “proxy-type”               guint

The type of proxy set in the proxy-ip property

Owner: NiceAgent

Flags: Read / Write

Allowed values: <= 2

Default value: 0

Since: 0.0.4

The “proxy-username” property

  “proxy-username”           char *

The username used to authenticate with the proxy

Owner: NiceAgent

Flags: Read / Write

Default value: NULL

Since: 0.0.4

The “reliable” property

  “reliable”                 gboolean

Whether the agent is providing a reliable transport of messages (through ICE-TCP or PseudoTCP over ICE-UDP)

Owner: NiceAgent

Flags: Read / Write / Construct Only

Default value: FALSE

Since: 0.0.11

The “stun-initial-timeout” property

  “stun-initial-timeout”     guint

The initial timeout (msecs) of the STUN binding requests used in the gathering stage, to find our local candidates. This property is described as 'RTO' in the RFC 5389 and RFC 5245. This timeout is doubled for each retransmission, until “stun-max-retransmissions” have been done, with an exception for the last restransmission, where the timeout is divided by two instead (RFC 5389 indicates that a customisable multiplier 'Rm' to 'RTO' should be used).

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: [20,9999]

Default value: 500

Since: 0.1.15

The “stun-max-retransmissions” property

  “stun-max-retransmissions” guint

The maximum number of retransmissions of the STUN binding requests used in the gathering stage, to find our local candidates, and used in the connection check stage, to test the validity of each constructed pair. This property is described as 'Rc' in the RFC 5389, with a default value of 7. The timeout of each STUN request is doubled for each retransmission, so the choice of this value has a direct impact on the time needed to move from the CONNECTED state to the READY state, and on the time needed to complete the GATHERING state.

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: [1,99]

Default value: 3

Since: 0.1.15

The “stun-pacing-timer” property

  “stun-pacing-timer”        guint

Timer 'Ta' (msecs) used in the IETF ICE specification for pacing candidate gathering and sending of connectivity checks.

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: >= 1

Default value: 20

The “stun-reliable-timeout” property

  “stun-reliable-timeout”    guint

The initial timeout of the STUN binding requests used for a reliable timer.

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: [20,99999]

Default value: 2000

Since: 0.1.15

The “stun-server” property

  “stun-server”              char *

The IP address (not the hostname) of the STUN server to use.

Owner: NiceAgent

Flags: Read / Write

Default value: NULL

The “stun-server-port” property

  “stun-server-port”         guint

Port of the STUN server used to gather server-reflexive candidates.

Owner: NiceAgent

Flags: Read / Write

Allowed values: [1,65536]

Default value: 1

The “support-renomination” property

  “support-renomination”     gboolean

Support RENOMINATION STUN attribute proposed here: https://tools.ietf.org/html/draft-thatcher-ice-renomination-00 As soon as RENOMINATION attribute is received from remote candidate's address, corresponding candidates pair gets selected. This is specific to Google Chrome/libWebRTC.

Owner: NiceAgent

Flags: Read / Write

Default value: FALSE

The “upnp” property

  “upnp”                     gboolean

Whether the agent should use UPnP to open a port in the router and get the external IP

Owner: NiceAgent

Flags: Read / Write / Construct

Default value: TRUE

Since: 0.0.7

The “upnp-timeout” property

  “upnp-timeout”             guint

The maximum amount of time (in milliseconds) to wait for UPnP discovery to finish before signaling the “candidate-gathering-done” signal

Owner: NiceAgent

Flags: Read / Write / Construct

Allowed values: [100,60000]

Default value: 200

Since: 0.0.7

The “candidate-gathering-done” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               gpointer   user_data)

This signal is fired whenever a stream has finished gathering its candidates after a call to nice_agent_gather_candidates()

Flags: Run Last

The “component-state-changed” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               guint      component_id,
               guint      state,
               gpointer   user_data)

This signal is fired whenever a component’s state changes. There are many valid state transitions.

Flags: Run Last

The “initial-binding-request-received” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               gpointer   user_data)

This signal is fired when we received our first binding request from the peer.

Flags: Run Last

The “new-candidate” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               guint      component_id,
               char      *foundation,
               gpointer   user_data)

This signal is fired when the agent discovers a new local candidate. When this signal is emitted, a matching “new-candidate-full” is also emitted with the candidate.

See also: “candidate-gathering-done”, “new-candidate-full”

Flags: Run Last

The “new-candidate-full” signal

void
user_function (NiceAgent     *agent,
               NiceCandidate *candidate,
               gpointer       user_data)

This signal is fired when the agent discovers a new local candidate. When this signal is emitted, a matching “new-candidate” is also emitted with the candidate's foundation.

See also: “candidate-gathering-done”, “new-candidate”

Flags: Run Last

Since: 0.1.8

The “new-remote-candidate” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               guint      component_id,
               char      *foundation,
               gpointer   user_data)

This signal is fired when the agent discovers a new remote candidate. This can happen with peer reflexive candidates. When this signal is emitted, a matching “new-remote-candidate-full” is also emitted with the candidate.

See also: “new-remote-candidate-full”

Flags: Run Last

The “new-remote-candidate-full” signal

void
user_function (NiceAgent     *agent,
               NiceCandidate *candidate,
               gpointer       user_data)

This signal is fired when the agent discovers a new remote candidate. This can happen with peer reflexive candidates. When this signal is emitted, a matching “new-remote-candidate” is also emitted with the candidate's foundation.

See also: “new-remote-candidate”

Flags: Run Last

Since: 0.1.8

The “new-selected-pair” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               guint      component_id,
               char      *lfoundation,
               char      *rfoundation,
               gpointer   user_data)

This signal is fired once a candidate pair is selected for data transfer for a stream's component This is emitted along with “new-selected-pair-full” which has the whole candidate, the Foundation of a Candidate is not a unique identifier.

See also: “new-selected-pair-full”

Flags: Run Last

The “new-selected-pair-full” signal

void
user_function (NiceAgent     *agent,
               guint          stream_id,
               guint          component_id,
               NiceCandidate *lcandidate,
               NiceCandidate *rcandidate,
               gpointer       user_data)

This signal is fired once a candidate pair is selected for data transfer for a stream's component. This is emitted along with “new-selected-pair”.

See also: “new-selected-pair”

Flags: Run Last

Since: 0.1.8

The “reliable-transport-writable” signal

void
user_function (NiceAgent *agent,
               guint      stream_id,
               guint      component_id,
               gpointer   user_data)

This signal is fired on the reliable NiceAgent when the underlying reliable transport becomes writable. This signal is only emitted when the nice_agent_send() function returns less bytes than requested to send (or -1) and once when the connection is established.

Flags: Run Last

Since: 0.0.11

The “streams-removed” signal

void
user_function (NiceAgent           *agent,
               _NiceAgentStreamIds *stream_ids,
               gpointer             user_data)

This signal is fired whenever one or more streams are removed from the agent .

Flags: Run Last

Since: 0.1.5