<STRUCT>
<NAME>NiceInputMessage</NAME>
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;
</STRUCT>
<STRUCT>
<NAME>NiceOutputMessage</NAME>
typedef struct {
  GOutputVector *buffers;
  gint n_buffers;
} NiceOutputMessage;
</STRUCT>
<MACRO>
<NAME>NICE_TYPE_AGENT</NAME>
#define NICE_TYPE_AGENT nice_agent_get_type()
</MACRO>
<MACRO>
<NAME>NICE_AGENT</NAME>
#define NICE_AGENT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
  NICE_TYPE_AGENT, NiceAgent))
</MACRO>
<MACRO>
<NAME>NICE_AGENT_CLASS</NAME>
#define NICE_AGENT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), \
  NICE_TYPE_AGENT, NiceAgentClass))
</MACRO>
<MACRO>
<NAME>NICE_IS_AGENT</NAME>
#define NICE_IS_AGENT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
  NICE_TYPE_AGENT))
</MACRO>
<MACRO>
<NAME>NICE_IS_AGENT_CLASS</NAME>
#define NICE_IS_AGENT_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
  NICE_TYPE_AGENT))
</MACRO>
<MACRO>
<NAME>NICE_AGENT_GET_CLASS</NAME>
#define NICE_AGENT_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
  NICE_TYPE_AGENT, NiceAgentClass))
</MACRO>
<STRUCT>
<NAME>NiceAgentClass</NAME>
struct _NiceAgentClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>nice_agent_get_type</NAME>
<RETURNS>GType  </RETURNS>
void 
</FUNCTION>
<MACRO>
<NAME>NICE_AGENT_MAX_REMOTE_CANDIDATES</NAME>
#define NICE_AGENT_MAX_REMOTE_CANDIDATES    25
</MACRO>
<ENUM>
<NAME>NiceComponentState</NAME>
typedef enum
{
  NICE_COMPONENT_STATE_DISCONNECTED,
  NICE_COMPONENT_STATE_GATHERING,
  NICE_COMPONENT_STATE_CONNECTING,
  NICE_COMPONENT_STATE_CONNECTED,
  NICE_COMPONENT_STATE_READY,
  NICE_COMPONENT_STATE_FAILED,
  NICE_COMPONENT_STATE_LAST
} NiceComponentState;
</ENUM>
<ENUM>
<NAME>NiceComponentType</NAME>
typedef enum
{
  NICE_COMPONENT_TYPE_RTP = 1,
  NICE_COMPONENT_TYPE_RTCP = 2
} NiceComponentType;
</ENUM>
<ENUM>
<NAME>NiceCompatibility</NAME>
typedef enum
{
  NICE_COMPATIBILITY_RFC5245 = 0,
  NICE_COMPATIBILITY_DRAFT19 = NICE_COMPATIBILITY_RFC5245,
  NICE_COMPATIBILITY_GOOGLE,
  NICE_COMPATIBILITY_MSN,
  NICE_COMPATIBILITY_WLM2009,
  NICE_COMPATIBILITY_OC2007,
  NICE_COMPATIBILITY_OC2007R2,
  NICE_COMPATIBILITY_LAST = NICE_COMPATIBILITY_OC2007R2,
} NiceCompatibility;
</ENUM>
<ENUM>
<NAME>NiceProxyType</NAME>
typedef enum
{
  NICE_PROXY_TYPE_NONE = 0,
  NICE_PROXY_TYPE_SOCKS5,
  NICE_PROXY_TYPE_HTTP,
  NICE_PROXY_TYPE_LAST = NICE_PROXY_TYPE_HTTP,
} NiceProxyType;
</ENUM>
<USER_FUNCTION>
<NAME>NiceAgentRecvFunc</NAME>
<RETURNS>void </RETURNS>

  NiceAgent *agent, guint stream_id, guint component_id, guint len,
  gchar *buf, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>nice_agent_new</NAME>
<RETURNS>NiceAgent  *</RETURNS>
GMainContext *ctx, NiceCompatibility compat 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_new_reliable</NAME>
<RETURNS>NiceAgent  *</RETURNS>
GMainContext *ctx, NiceCompatibility compat 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_add_local_address</NAME>
<RETURNS>gboolean </RETURNS>
NiceAgent *agent, NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_add_stream</NAME>
<RETURNS>guint </RETURNS>
 NiceAgent *agent, guint n_components 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_remove_stream</NAME>
<RETURNS>void </RETURNS>
 NiceAgent *agent, guint stream_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_port_range</NAME>
<RETURNS>void </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, guint min_port, guint max_port 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_relay_info</NAME>
<RETURNS>gboolean  </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, const gchar *server_ip, guint server_port, const gchar *username, const gchar *password, NiceRelayType type 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_gather_candidates</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_remote_credentials</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, const gchar *ufrag, const gchar *pwd 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_local_credentials</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, gchar **ufrag, gchar **pwd 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_remote_candidates</NAME>
<RETURNS>int </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, const GSList *candidates 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_send</NAME>
<RETURNS>gint </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, guint len, const gchar *buf 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_send_messages_nonblocking</NAME>
<RETURNS>gint </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, const NiceOutputMessage *messages, guint n_messages, GCancellable *cancellable, GError **error 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_local_candidates</NAME>
<RETURNS>GSList  *</RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_remote_candidates</NAME>
<RETURNS>GSList  *</RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_restart</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_restart_stream</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_attach_recv</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, GMainContext *ctx, NiceAgentRecvFunc func, gpointer data 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_recv</NAME>
<RETURNS>gssize </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, guint8 *buf, gsize buf_len, GCancellable *cancellable, GError **error 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_recv_messages</NAME>
<RETURNS>gint </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, NiceInputMessage *messages, guint n_messages, GCancellable *cancellable, GError **error 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_recv_nonblocking</NAME>
<RETURNS>gssize </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, guint8 *buf, gsize buf_len, GCancellable *cancellable, GError **error 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_recv_messages_nonblocking</NAME>
<RETURNS>gint </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, NiceInputMessage *messages, guint n_messages, GCancellable *cancellable, GError **error 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_selected_pair</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, const gchar *lfoundation, const gchar *rfoundation 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_selected_pair</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, NiceCandidate **local, NiceCandidate **remote 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_selected_socket</NAME>
<RETURNS>GSocket  *</RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_selected_remote_candidate</NAME>
<RETURNS>gboolean </RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id, NiceCandidate *candidate 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_stream_tos</NAME>
<RETURNS>void  </RETURNS>
 NiceAgent *agent, guint stream_id, gint tos 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_software</NAME>
<RETURNS>void  </RETURNS>
 NiceAgent *agent, const gchar *software 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_set_stream_name</NAME>
<RETURNS>gboolean  </RETURNS>
 NiceAgent *agent, guint stream_id, const gchar *name 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_stream_name</NAME>
<RETURNS>const gchar  *</RETURNS>
 NiceAgent *agent, guint stream_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_default_local_candidate</NAME>
<RETURNS>NiceCandidate  *</RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_generate_local_sdp</NAME>
<RETURNS>gchar  *</RETURNS>
 NiceAgent *agent 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_generate_local_stream_sdp</NAME>
<RETURNS>gchar  *</RETURNS>
 NiceAgent *agent, guint stream_id, gboolean include_non_ice 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_generate_local_candidate_sdp</NAME>
<RETURNS>gchar  *</RETURNS>
 NiceAgent *agent, NiceCandidate *candidate 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_parse_remote_sdp</NAME>
<RETURNS>int </RETURNS>
 NiceAgent *agent, const gchar *sdp 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_parse_remote_stream_sdp</NAME>
<RETURNS>GSList  *</RETURNS>
 NiceAgent *agent, guint stream_id, const gchar *sdp, gchar **ufrag, gchar **pwd 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_parse_remote_candidate_sdp</NAME>
<RETURNS>NiceCandidate  *</RETURNS>
 NiceAgent *agent, guint stream_id, const gchar *sdp 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_io_stream</NAME>
<RETURNS>GIOStream  *</RETURNS>
 NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_component_state_to_string</NAME>
<RETURNS>const gchar  *</RETURNS>
NiceComponentState state 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_forget_relays</NAME>
<RETURNS>gboolean </RETURNS>
NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<FUNCTION>
<NAME>nice_agent_get_component_state</NAME>
<RETURNS>NiceComponentState </RETURNS>
NiceAgent *agent, guint stream_id, guint component_id 
</FUNCTION>
<STRUCT>
<NAME>NiceAgent</NAME>
</STRUCT>
<FUNCTION>
<NAME>pseudo_tcp_socket_get_type</NAME>
<RETURNS>GType  </RETURNS>
void 
</FUNCTION>
<MACRO>
<NAME>PSEUDO_TCP_SOCKET_TYPE</NAME>
#define PSEUDO_TCP_SOCKET_TYPE \
  (pseudo_tcp_socket_get_type ())
</MACRO>
<MACRO>
<NAME>PSEUDO_TCP_SOCKET</NAME>
#define PSEUDO_TCP_SOCKET(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST((obj), PSEUDO_TCP_SOCKET_TYPE, \
                              PseudoTcpSocket))
</MACRO>
<MACRO>
<NAME>PSEUDO_TCP_SOCKET_CLASS</NAME>
#define PSEUDO_TCP_SOCKET_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST((klass), PSEUDO_TCP_SOCKET_TYPE, \
                           PseudoTcpSocketClass))
</MACRO>
<MACRO>
<NAME>IS_PSEUDO_TCP_SOCKET</NAME>
#define IS_PSEUDO_TCP_SOCKET(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE((obj), PSEUDO_TCP_SOCKET_TYPE))
</MACRO>
<MACRO>
<NAME>IS_PSEUDO_TCP_SOCKET_CLASS</NAME>
#define IS_PSEUDO_TCP_SOCKET_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE((klass), PSEUDO_TCP_SOCKET_TYPE))
</MACRO>
<MACRO>
<NAME>PSEUDOTCP_SOCKET_GET_CLASS</NAME>
#define PSEUDOTCP_SOCKET_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), PSEUDO_TCP_SOCKET_TYPE, \
                              PseudoTcpSocketClass))
</MACRO>
<STRUCT>
<NAME>PseudoTcpSocketClass</NAME>
struct _PseudoTcpSocketClass {
    GObjectClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>PseudoTcpSocket</NAME>
struct _PseudoTcpSocket {
    GObject parent;
    PseudoTcpSocketPrivate *priv;
};
</STRUCT>
<ENUM>
<NAME>PseudoTcpDebugLevel</NAME>
typedef enum {
  PSEUDO_TCP_DEBUG_NONE = 0,
  PSEUDO_TCP_DEBUG_NORMAL,
  PSEUDO_TCP_DEBUG_VERBOSE,
} PseudoTcpDebugLevel;
</ENUM>
<ENUM>
<NAME>PseudoTcpState</NAME>
typedef enum {
  TCP_LISTEN,
  TCP_SYN_SENT,
  TCP_SYN_RECEIVED,
  TCP_ESTABLISHED,
  TCP_CLOSED,
  TCP_FIN_WAIT_1,
  TCP_FIN_WAIT_2,
  TCP_CLOSING,
  TCP_TIME_WAIT,
  TCP_CLOSE_WAIT,
  TCP_LAST_ACK,
} PseudoTcpState;
</ENUM>
<ENUM>
<NAME>PseudoTcpWriteResult</NAME>
typedef enum {
  WR_SUCCESS,
  WR_TOO_LARGE,
  WR_FAIL
} PseudoTcpWriteResult;
</ENUM>
<ENUM>
<NAME>PseudoTcpShutdown</NAME>
typedef enum {
  PSEUDO_TCP_SHUTDOWN_RD,
  PSEUDO_TCP_SHUTDOWN_WR,
  PSEUDO_TCP_SHUTDOWN_RDWR,
} PseudoTcpShutdown;
</ENUM>
<STRUCT>
<NAME>PseudoTcpCallbacks</NAME>
typedef struct {
  gpointer user_data;
  void  (*PseudoTcpOpened) (PseudoTcpSocket *tcp, gpointer data);
  void  (*PseudoTcpReadable) (PseudoTcpSocket *tcp, gpointer data);
  void  (*PseudoTcpWritable) (PseudoTcpSocket *tcp, gpointer data);
  void  (*PseudoTcpClosed) (PseudoTcpSocket *tcp, guint32 error, gpointer data);
  PseudoTcpWriteResult (*WritePacket) (PseudoTcpSocket *tcp,
      const gchar * buffer, guint32 len, gpointer data);
} PseudoTcpCallbacks;
</STRUCT>
<FUNCTION>
<NAME>pseudo_tcp_socket_new</NAME>
<RETURNS>PseudoTcpSocket  *</RETURNS>
guint32 conversation, PseudoTcpCallbacks *callbacks 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_connect</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_recv</NAME>
<RETURNS>gint   </RETURNS>
PseudoTcpSocket *self, char * buffer, size_t len 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_send</NAME>
<RETURNS>gint  </RETURNS>
PseudoTcpSocket *self, const char * buffer, guint32 len 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_close</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpSocket *self, gboolean force 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_shutdown</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpSocket *self, PseudoTcpShutdown how 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_get_error</NAME>
<RETURNS>int  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_get_next_clock</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self, guint64 *timeout 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_notify_clock</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_notify_mtu</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpSocket *self, guint16 mtu 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_notify_packet</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self, const gchar * buffer, guint32 len 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_notify_message</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self, NiceInputMessage *message 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_set_debug_level</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpDebugLevel level 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_get_available_bytes</NAME>
<RETURNS>gint  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_can_send</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_get_available_send_space</NAME>
<RETURNS>gsize  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_set_time</NAME>
<RETURNS>void  </RETURNS>
PseudoTcpSocket *self, guint32 current_time 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_is_closed</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<FUNCTION>
<NAME>pseudo_tcp_socket_is_closed_remotely</NAME>
<RETURNS>gboolean  </RETURNS>
PseudoTcpSocket *self 
</FUNCTION>
<STRUCT>
<NAME>PseudoTcpSocketPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>NiceAddress</NAME>
struct _NiceAddress
{
  union
  {
    struct sockaddr     addr;
    struct sockaddr_in  ip4;
    struct sockaddr_in6 ip6;
  } s;
};
</STRUCT>
<MACRO>
<NAME>NICE_ADDRESS_STRING_LEN</NAME>
#define NICE_ADDRESS_STRING_LEN INET6_ADDRSTRLEN
</MACRO>
<FUNCTION>
<NAME>nice_address_init</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_new</NAME>
<RETURNS>NiceAddress  *</RETURNS>
void 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_free</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_dup</NAME>
<RETURNS>NiceAddress  *</RETURNS>
const NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_set_ipv4</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr, guint32 addr_ipv4 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_set_ipv6</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr, const guchar *addr_ipv6 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_set_port</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr, guint port 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_get_port</NAME>
<RETURNS>guint </RETURNS>
const NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_set_from_string</NAME>
<RETURNS>gboolean </RETURNS>
NiceAddress *addr, const gchar *str 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_set_from_sockaddr</NAME>
<RETURNS>void </RETURNS>
NiceAddress *addr, const struct sockaddr *sin 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_copy_to_sockaddr</NAME>
<RETURNS>void </RETURNS>
const NiceAddress *addr, struct sockaddr *sin 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_equal</NAME>
<RETURNS>gboolean </RETURNS>
const NiceAddress *a, const NiceAddress *b 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_equal_no_port</NAME>
<RETURNS>gboolean </RETURNS>
const NiceAddress *a, const NiceAddress *b 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_to_string</NAME>
<RETURNS>void </RETURNS>
const NiceAddress *addr, gchar *dst 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_is_private</NAME>
<RETURNS>gboolean </RETURNS>
const NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_is_valid</NAME>
<RETURNS>gboolean </RETURNS>
const NiceAddress *addr 
</FUNCTION>
<FUNCTION>
<NAME>nice_address_ip_version</NAME>
<RETURNS>int </RETURNS>
const NiceAddress *addr 
</FUNCTION>
<STRUCT>
<NAME>NiceAddress</NAME>
</STRUCT>
<FUNCTION>
<NAME>nice_debug_enable</NAME>
<RETURNS>void  </RETURNS>
gboolean with_stun 
</FUNCTION>
<FUNCTION>
<NAME>nice_debug_disable</NAME>
<RETURNS>void  </RETURNS>
gboolean with_stun 
</FUNCTION>
<FUNCTION>
<NAME>nice_interfaces_get_ip_for_interface</NAME>
<RETURNS>gchar  * </RETURNS>
gchar *interface_name 
</FUNCTION>
<FUNCTION>
<NAME>nice_interfaces_get_local_ips</NAME>
<RETURNS>GList  * </RETURNS>
gboolean include_loopback 
</FUNCTION>
<FUNCTION>
<NAME>nice_interfaces_get_local_interfaces</NAME>
<RETURNS>GList  * </RETURNS>
void 
</FUNCTION>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_HOST</NAME>
#define NICE_CANDIDATE_TYPE_PREF_HOST                 120
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_PEER_REFLEXIVE</NAME>
#define NICE_CANDIDATE_TYPE_PREF_PEER_REFLEXIVE       110
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED</NAME>
#define NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED         105
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_SERVER_REFLEXIVE</NAME>
#define NICE_CANDIDATE_TYPE_PREF_SERVER_REFLEXIVE     100
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_UDP_TUNNELED</NAME>
#define NICE_CANDIDATE_TYPE_PREF_UDP_TUNNELED          75
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TYPE_PREF_RELAYED</NAME>
#define NICE_CANDIDATE_TYPE_PREF_RELAYED               10
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TRANSPORT_MS_PREF_UDP</NAME>
#define NICE_CANDIDATE_TRANSPORT_MS_PREF_UDP           15
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_TRANSPORT_MS_PREF_TCP</NAME>
#define NICE_CANDIDATE_TRANSPORT_MS_PREF_TCP            6
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_DIRECTION_MS_PREF_PASSIVE</NAME>
#define NICE_CANDIDATE_DIRECTION_MS_PREF_PASSIVE        2
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_DIRECTION_MS_PREF_ACTIVE</NAME>
#define NICE_CANDIDATE_DIRECTION_MS_PREF_ACTIVE         5
</MACRO>
<MACRO>
<NAME>NICE_CANDIDATE_MAX_FOUNDATION</NAME>
#define NICE_CANDIDATE_MAX_FOUNDATION                (32+1)
</MACRO>
<ENUM>
<NAME>NiceCandidateType</NAME>
typedef enum
{
  NICE_CANDIDATE_TYPE_HOST,
  NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE,
  NICE_CANDIDATE_TYPE_PEER_REFLEXIVE,
  NICE_CANDIDATE_TYPE_RELAYED,
} NiceCandidateType;
</ENUM>
<ENUM>
<NAME>NiceCandidateTransport</NAME>
typedef enum
{
  NICE_CANDIDATE_TRANSPORT_UDP,
  NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE,
  NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE,
  NICE_CANDIDATE_TRANSPORT_TCP_SO,
} NiceCandidateTransport;
</ENUM>
<ENUM>
<NAME>NiceRelayType</NAME>
typedef enum {
  NICE_RELAY_TYPE_TURN_UDP,
  NICE_RELAY_TYPE_TURN_TCP,
  NICE_RELAY_TYPE_TURN_TLS
} NiceRelayType;
</ENUM>
<STRUCT>
<NAME>TurnServer</NAME>
struct _TurnServer
{
  gint ref_count;

  NiceAddress server;
  gchar *username;
  gchar *password;
  NiceRelayType type;
};
</STRUCT>
<STRUCT>
<NAME>NiceCandidate</NAME>
struct _NiceCandidate
{
  NiceCandidateType type;
  NiceCandidateTransport transport;
  NiceAddress addr;
  NiceAddress base_addr;
  guint32 priority;
  guint stream_id;
  guint component_id;
  gchar foundation[NICE_CANDIDATE_MAX_FOUNDATION];
  gchar *username;        /* pointer to a NULL-terminated username string */
  gchar *password;        /* pointer to a NULL-terminated password string */
  TurnServer *turn;
  gpointer sockptr;
};
</STRUCT>
<FUNCTION>
<NAME>nice_candidate_new</NAME>
<RETURNS>NiceCandidate  *</RETURNS>
NiceCandidateType type 
</FUNCTION>
<FUNCTION>
<NAME>nice_candidate_free</NAME>
<RETURNS>void </RETURNS>
NiceCandidate *candidate 
</FUNCTION>
<FUNCTION>
<NAME>nice_candidate_copy</NAME>
<RETURNS>NiceCandidate  *</RETURNS>
const NiceCandidate *candidate 
</FUNCTION>
<FUNCTION>
<NAME>nice_candidate_get_type</NAME>
<RETURNS>GType  </RETURNS>
void 
</FUNCTION>
<MACRO>
<NAME>NICE_TYPE_CANDIDATE</NAME>
#define NICE_TYPE_CANDIDATE nice_candidate_get_type ()
</MACRO>
<ENUM>
<NAME>StunClass</NAME>
typedef enum
{
  STUN_REQUEST=0,
  STUN_INDICATION=1,
  STUN_RESPONSE=2,
  STUN_ERROR=3
} StunClass;
</ENUM>
<ENUM>
<NAME>StunMethod</NAME>
typedef enum
{
  STUN_BINDING=0x001,    /* RFC5389 */
  STUN_SHARED_SECRET=0x002,  /* old RFC3489 */
  STUN_ALLOCATE=0x003,    /* TURN-12 */
  STUN_SET_ACTIVE_DST=0x004,  /* TURN-04 */
  STUN_REFRESH=0x004,  /* TURN-12 */
  STUN_SEND=0x004,  /* TURN-00 */
  STUN_CONNECT=0x005,    /* TURN-04 */
  STUN_OLD_SET_ACTIVE_DST=0x006,  /* TURN-00 */
  STUN_IND_SEND=0x006,    /* TURN-12 */
  STUN_IND_DATA=0x007,    /* TURN-12 */
  STUN_IND_CONNECT_STATUS=0x008,  /* TURN-04 */
  STUN_CREATEPERMISSION= 0x008, /* TURN-12 */
  STUN_CHANNELBIND= 0x009 /* TURN-12 */
} StunMethod;
</ENUM>
<ENUM>
<NAME>StunAttribute</NAME>
typedef enum
{
  /* Mandatory attributes */
  /* 0x0000 */        /* reserved */
  STUN_ATTRIBUTE_MAPPED_ADDRESS=0x0001,    /* RFC5389 */
  STUN_ATTRIBUTE_RESPONSE_ADDRESS=0x0002,  /* old RFC3489 */
  STUN_ATTRIBUTE_CHANGE_REQUEST=0x0003,    /* old RFC3489 */
  STUN_ATTRIBUTE_SOURCE_ADDRESS=0x0004,    /* old RFC3489 */
  STUN_ATTRIBUTE_CHANGED_ADDRESS=0x0005,  /* old RFC3489 */
  STUN_ATTRIBUTE_USERNAME=0x0006,      /* RFC5389 */
  STUN_ATTRIBUTE_PASSWORD=0x0007,    /* old RFC3489 */
  STUN_ATTRIBUTE_MESSAGE_INTEGRITY=0x0008,    /* RFC5389 */
  STUN_ATTRIBUTE_ERROR_CODE=0x0009,      /* RFC5389 */
  STUN_ATTRIBUTE_UNKNOWN_ATTRIBUTES=0x000A,    /* RFC5389 */
  STUN_ATTRIBUTE_REFLECTED_FROM=0x000B,    /* old RFC3489 */
  STUN_ATTRIBUTE_CHANNEL_NUMBER=0x000C,        /* TURN-12 */
  STUN_ATTRIBUTE_LIFETIME=0x000D,      /* TURN-12 */
  /* MS_ALTERNATE_SERVER is only used by Microsoft's dialect, probably should
   * not to be placed in STUN_ALL_KNOWN_ATTRIBUTES */
  STUN_ATTRIBUTE_MS_ALTERNATE_SERVER=0x000E, /* MS-TURN */
  STUN_ATTRIBUTE_MAGIC_COOKIE=0x000F,        /* midcom-TURN 08 */
  STUN_ATTRIBUTE_BANDWIDTH=0x0010,      /* TURN-04 */
  STUN_ATTRIBUTE_DESTINATION_ADDRESS=0x0011,        /* midcom-TURN 08 */
  STUN_ATTRIBUTE_REMOTE_ADDRESS=0x0012,    /* TURN-04 */
  STUN_ATTRIBUTE_PEER_ADDRESS=0x0012,    /* TURN-09 */
  STUN_ATTRIBUTE_XOR_PEER_ADDRESS=0x0012,    /* TURN-12 */
  STUN_ATTRIBUTE_DATA=0x0013,      /* TURN-12 */
  STUN_ATTRIBUTE_REALM=0x0014,      /* RFC5389 */
  STUN_ATTRIBUTE_NONCE=0x0015,      /* RFC5389 */
  STUN_ATTRIBUTE_RELAY_ADDRESS=0x0016,    /* TURN-04 */
  STUN_ATTRIBUTE_RELAYED_ADDRESS=0x0016,    /* TURN-09 */
  STUN_ATTRIBUTE_XOR_RELAYED_ADDRESS=0x0016,    /* TURN-12 */
  STUN_ATTRIBUTE_REQUESTED_ADDRESS_TYPE=0x0017,  /* TURN-IPv6-05 */
  STUN_ATTRIBUTE_REQUESTED_PORT_PROPS=0x0018,  /* TURN-04 */
  STUN_ATTRIBUTE_REQUESTED_PROPS=0x0018,  /* TURN-09 */
  STUN_ATTRIBUTE_EVEN_PORT=0x0018,  /* TURN-12 */
  STUN_ATTRIBUTE_REQUESTED_TRANSPORT=0x0019,  /* TURN-12 */
  STUN_ATTRIBUTE_DONT_FRAGMENT=0x001A,  /* TURN-12 */
  /* 0x001B */        /* reserved */
  /* 0x001C */        /* reserved */
  /* 0x001D */        /* reserved */
  /* 0x001E */        /* reserved */
  /* 0x001F */        /* reserved */
  STUN_ATTRIBUTE_XOR_MAPPED_ADDRESS=0x0020,    /* RFC5389 */
  STUN_ATTRIBUTE_TIMER_VAL=0x0021,      /* TURN-04 */
  STUN_ATTRIBUTE_REQUESTED_IP=0x0022,    /* TURN-04 */
  STUN_ATTRIBUTE_RESERVATION_TOKEN=0x0022,    /* TURN-09 */
  STUN_ATTRIBUTE_CONNECT_STAT=0x0023,    /* TURN-04 */
  STUN_ATTRIBUTE_PRIORITY=0x0024,      /* ICE-19 */
  STUN_ATTRIBUTE_USE_CANDIDATE=0x0025,    /* ICE-19 */
  /* 0x0026 */        /* reserved */
  /* 0x0027 */        /* reserved */
  /* 0x0028 */        /* reserved */
  /* 0x0029 */        /* reserved */
  /* 0x002A-0x7fff */      /* reserved */

  /* Optional attributes */
  /* 0x8000-0x8021 */      /* reserved */
  STUN_ATTRIBUTE_OPTIONS=0x8001, /* libjingle */
  STUN_ATTRIBUTE_MS_VERSION=0x8008,    /* MS-TURN */
  STUN_ATTRIBUTE_MS_XOR_MAPPED_ADDRESS=0x8020,    /* MS-TURN */
  STUN_ATTRIBUTE_SOFTWARE=0x8022,      /* RFC5389 */
  STUN_ATTRIBUTE_ALTERNATE_SERVER=0x8023,    /* RFC5389 */
  /* 0x8024 */        /* reserved */
  /* 0x8025 */        /* reserved */
  /* 0x8026 */        /* reserved */
  /* 0x8027 */        /* reserved */
  STUN_ATTRIBUTE_FINGERPRINT=0x8028,    /* RFC5389 */
  STUN_ATTRIBUTE_ICE_CONTROLLED=0x8029,    /* ICE-19 */
  STUN_ATTRIBUTE_ICE_CONTROLLING=0x802A,    /* ICE-19 */
  /* 0x802B-0x804F */      /* reserved */
  STUN_ATTRIBUTE_MS_SEQUENCE_NUMBER=0x8050,     /* MS-TURN */
  /* 0x8051-0x8053 */      /* reserved */
  STUN_ATTRIBUTE_CANDIDATE_IDENTIFIER=0x8054    /* MS-ICE2 */
  /* 0x8055-0xFFFF */      /* reserved */
} StunAttribute;
</ENUM>
<TYPEDEF>
<NAME>StunTransactionId</NAME>
typedef uint8_t StunTransactionId[STUN_MESSAGE_TRANS_ID_LEN];
</TYPEDEF>
<ENUM>
<NAME>StunError</NAME>
typedef enum
{
  STUN_ERROR_TRY_ALTERNATE=300,      /* RFC5389 */
  STUN_ERROR_BAD_REQUEST=400,      /* RFC5389 */
  STUN_ERROR_UNAUTHORIZED=401,      /* RFC5389 */
  STUN_ERROR_UNKNOWN_ATTRIBUTE=420,    /* RFC5389 */
  STUN_ERROR_ALLOCATION_MISMATCH=437,   /* TURN-12 */
  STUN_ERROR_STALE_NONCE=438,      /* RFC5389 */
  STUN_ERROR_ACT_DST_ALREADY=439,    /* TURN-04 */
  STUN_ERROR_UNSUPPORTED_FAMILY=440,      /* TURN-IPv6-05 */
  STUN_ERROR_WRONG_CREDENTIALS=441,    /* TURN-12 */
  STUN_ERROR_UNSUPPORTED_TRANSPORT=442,    /* TURN-12 */
  STUN_ERROR_INVALID_IP=443,      /* TURN-04 */
  STUN_ERROR_INVALID_PORT=444,      /* TURN-04 */
  STUN_ERROR_OP_TCP_ONLY=445,      /* TURN-04 */
  STUN_ERROR_CONN_ALREADY=446,      /* TURN-04 */
  STUN_ERROR_ALLOCATION_QUOTA_REACHED=486,    /* TURN-12 */
  STUN_ERROR_ROLE_CONFLICT=487,      /* ICE-19 */
  STUN_ERROR_SERVER_ERROR=500,      /* RFC5389 */
  STUN_ERROR_SERVER_CAPACITY=507,    /* TURN-04 */
  STUN_ERROR_INSUFFICIENT_CAPACITY=508,    /* TURN-12 */
  STUN_ERROR_MAX=699
} StunError;
</ENUM>
<ENUM>
<NAME>StunMessageReturn</NAME>
typedef enum
{
  STUN_MESSAGE_RETURN_SUCCESS,
  STUN_MESSAGE_RETURN_NOT_FOUND,
  STUN_MESSAGE_RETURN_INVALID,
  STUN_MESSAGE_RETURN_NOT_ENOUGH_SPACE,
  STUN_MESSAGE_RETURN_UNSUPPORTED_ADDRESS
} StunMessageReturn;
</ENUM>
<MACRO>
<NAME>STUN_MAX_MESSAGE_SIZE</NAME>
#define STUN_MAX_MESSAGE_SIZE 65552
</MACRO>
<STRUCT>
<NAME>StunMessage</NAME>
struct _StunMessage {
  StunAgent *agent;
  uint8_t *buffer;
  size_t buffer_len;
  uint8_t *key;
  size_t key_len;
  uint8_t long_term_key[16];
  bool long_term_valid;
};
</STRUCT>
<FUNCTION>
<NAME>stun_message_init</NAME>
<RETURNS>bool  </RETURNS>
StunMessage *msg, StunClass c, StunMethod m, const StunTransactionId id 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_length</NAME>
<RETURNS>uint16_t  </RETURNS>
const StunMessage *msg 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find</NAME>
<RETURNS>const void  * </RETURNS>
const StunMessage * msg, StunAttribute type, uint16_t *palen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_flag</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find32</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, uint32_t *pval 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find64</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, uint64_t *pval 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_string</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, char *buf, size_t buflen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_addr</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, struct sockaddr_storage *addr, socklen_t *addrlen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_xor_addr</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, struct sockaddr_storage *addr, socklen_t *addrlen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_xor_addr_full</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, StunAttribute type, struct sockaddr_storage *addr, socklen_t *addrlen, uint32_t magic_cookie 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_find_error</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
const StunMessage *msg, int *code 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append</NAME>
<RETURNS>void  *</RETURNS>
StunMessage *msg, StunAttribute type, size_t length 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_bytes</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage *msg, StunAttribute type, const void *data, size_t len 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_flag</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage *msg, StunAttribute type 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append32</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage *msg, StunAttribute type, uint32_t value 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append64</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage *msg, StunAttribute type, uint64_t value 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_string</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage *msg, StunAttribute type, const char *str 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_addr</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage * msg, StunAttribute type, const struct sockaddr *addr, socklen_t addrlen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_xor_addr</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage * msg, StunAttribute type, const struct sockaddr_storage *addr, socklen_t addrlen 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_xor_addr_full</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage * msg, StunAttribute type, const struct sockaddr_storage *addr, socklen_t addrlen, uint32_t magic_cookie 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_append_error</NAME>
<RETURNS>StunMessageReturn  </RETURNS>
StunMessage * msg, StunError code 
</FUNCTION>
<MACRO>
<NAME>STUN_MESSAGE_BUFFER_INCOMPLETE</NAME>
#define STUN_MESSAGE_BUFFER_INCOMPLETE 0
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_BUFFER_INVALID</NAME>
#define STUN_MESSAGE_BUFFER_INVALID -1
</MACRO>
<FUNCTION>
<NAME>stun_message_validate_buffer_length</NAME>
<RETURNS>int  </RETURNS>
const uint8_t *msg, size_t length, bool has_padding 
</FUNCTION>
<STRUCT>
<NAME>StunInputVector</NAME>
typedef struct {
  const uint8_t *buffer;
  size_t size;
} StunInputVector;
</STRUCT>
<FUNCTION>
<NAME>stun_message_validate_buffer_length_fast</NAME>
<RETURNS>ssize_t  </RETURNS>
StunInputVector *buffers, int n_buffers, size_t total_length, bool has_padding 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_id</NAME>
<RETURNS>void  </RETURNS>
const StunMessage *msg, StunTransactionId id 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_get_class</NAME>
<RETURNS>StunClass  </RETURNS>
const StunMessage *msg 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_get_method</NAME>
<RETURNS>StunMethod  </RETURNS>
const StunMessage *msg 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_has_attribute</NAME>
<RETURNS>bool  </RETURNS>
const StunMessage *msg, StunAttribute type 
</FUNCTION>
<FUNCTION>
<NAME>stun_message_has_cookie</NAME>
<RETURNS>bool  </RETURNS>
const StunMessage *msg 
</FUNCTION>
<FUNCTION>
<NAME>stun_optional</NAME>
<RETURNS>bool  </RETURNS>
uint16_t t 
</FUNCTION>
<FUNCTION>
<NAME>stun_strerror</NAME>
<RETURNS>const char  *</RETURNS>
StunError code 
</FUNCTION>
<TYPEDEF>
<NAME>StunAgent</NAME>
typedef struct stun_agent_t StunAgent;
</TYPEDEF>
<ENUM>
<NAME>StunCompatibility</NAME>
typedef enum {
  STUN_COMPATIBILITY_RFC3489,
  STUN_COMPATIBILITY_RFC5389,
  STUN_COMPATIBILITY_WLM2009,
  STUN_COMPATIBILITY_OC2007,
  STUN_COMPATIBILITY_LAST = STUN_COMPATIBILITY_OC2007
} StunCompatibility;
</ENUM>
<ENUM>
<NAME>StunValidationStatus</NAME>
typedef enum {
  STUN_VALIDATION_SUCCESS,
  STUN_VALIDATION_NOT_STUN,
  STUN_VALIDATION_INCOMPLETE_STUN,
  STUN_VALIDATION_BAD_REQUEST,
  STUN_VALIDATION_UNAUTHORIZED_BAD_REQUEST,
  STUN_VALIDATION_UNAUTHORIZED,
  STUN_VALIDATION_UNMATCHED_RESPONSE,
  STUN_VALIDATION_UNKNOWN_REQUEST_ATTRIBUTE,
  STUN_VALIDATION_UNKNOWN_ATTRIBUTE,
} StunValidationStatus;
</ENUM>
<ENUM>
<NAME>StunAgentUsageFlags</NAME>
typedef enum {
  STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS    = (1 << 0),
  STUN_AGENT_USAGE_LONG_TERM_CREDENTIALS     = (1 << 1),
  STUN_AGENT_USAGE_USE_FINGERPRINT           = (1 << 2),
  STUN_AGENT_USAGE_ADD_SOFTWARE              = (1 << 3),
  STUN_AGENT_USAGE_IGNORE_CREDENTIALS        = (1 << 4),
  STUN_AGENT_USAGE_NO_INDICATION_AUTH        = (1 << 5),
  STUN_AGENT_USAGE_FORCE_VALIDATER           = (1 << 6),
  STUN_AGENT_USAGE_NO_ALIGNED_ATTRIBUTES     = (1 << 7),
} StunAgentUsageFlags;
</ENUM>
<STRUCT>
<NAME>StunAgentSavedIds</NAME>
typedef struct {
  StunTransactionId id;
  StunMethod method;
  uint8_t *key;
  size_t key_len;
  uint8_t long_term_key[16];
  bool long_term_valid;
  bool valid;
} StunAgentSavedIds;
</STRUCT>
<STRUCT>
<NAME>stun_agent_t</NAME>
struct stun_agent_t {
  StunCompatibility compatibility;
  StunAgentSavedIds sent_ids[STUN_AGENT_MAX_SAVED_IDS];
  uint16_t *known_attributes;
  StunAgentUsageFlags usage_flags;
  const char *software_attribute;
};
</STRUCT>
<STRUCT>
<NAME>StunDefaultValidaterData</NAME>
typedef struct {
  uint8_t *username;
  size_t username_len;
  uint8_t *password;
  size_t password_len;
} StunDefaultValidaterData;
</STRUCT>
<USER_FUNCTION>
<NAME>StunMessageIntegrityValidate</NAME>
<RETURNS>bool </RETURNS>
StunAgent *agent,
    StunMessage *message, uint8_t *username, uint16_t username_len,
    uint8_t **password, size_t *password_len, void *user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>stun_agent_default_validater</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunMessage *message, uint8_t *username, uint16_t username_len, uint8_t **password, size_t *password_len, void *user_data 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_init</NAME>
<RETURNS>void  </RETURNS>
StunAgent *agent, const uint16_t *known_attributes, StunCompatibility compatibility, StunAgentUsageFlags usage_flags 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_validate</NAME>
<RETURNS>StunValidationStatus  </RETURNS>
StunAgent *agent, StunMessage *msg, const uint8_t *buffer, size_t buffer_len, StunMessageIntegrityValidate validater, void * validater_data 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_init_request</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, StunMethod m 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_init_indication</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, StunMethod m 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_init_response</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, const StunMessage *request 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_init_error</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, const StunMessage *request, StunError err 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_build_unknown_attributes_error</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, const StunMessage *request 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_finish_message</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, const uint8_t *key, size_t key_len 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_forget_transaction</NAME>
<RETURNS>bool  </RETURNS>
StunAgent *agent, StunTransactionId id 
</FUNCTION>
<FUNCTION>
<NAME>stun_agent_set_software</NAME>
<RETURNS>void  </RETURNS>
StunAgent *agent, const char *software 
</FUNCTION>
<FUNCTION>
<NAME>stun_debug_enable</NAME>
<RETURNS>void  </RETURNS>
void 
</FUNCTION>
<FUNCTION>
<NAME>stun_debug_disable</NAME>
<RETURNS>void  </RETURNS>
void 
</FUNCTION>
<USER_FUNCTION>
<NAME>StunDebugHandler</NAME>
<RETURNS>void </RETURNS>
const char *format, va_list ap
</USER_FUNCTION>
<FUNCTION>
<NAME>stun_set_debug_handler</NAME>
<RETURNS>void  </RETURNS>
StunDebugHandler handler 
</FUNCTION>
<FUNCTION>
<NAME>stun_debug</NAME>
<RETURNS>void  </RETURNS>
const char *fmt, ... 
</FUNCTION>
<FUNCTION>
<NAME>stun_debug_bytes</NAME>
<RETURNS>void  </RETURNS>
const char *prefix, const void *data, size_t len 
</FUNCTION>
<MACRO>
<NAME>STUN_MESSAGE_TYPE_POS</NAME>
#define STUN_MESSAGE_TYPE_POS 0
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_TYPE_LEN</NAME>
#define STUN_MESSAGE_TYPE_LEN 2
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_LENGTH_POS</NAME>
#define STUN_MESSAGE_LENGTH_POS \
  (STUN_MESSAGE_TYPE_POS + STUN_MESSAGE_TYPE_LEN)
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_LENGTH_LEN</NAME>
#define STUN_MESSAGE_LENGTH_LEN 2
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_TRANS_ID_POS</NAME>
#define STUN_MESSAGE_TRANS_ID_POS \
  (STUN_MESSAGE_LENGTH_POS + STUN_MESSAGE_LENGTH_LEN)
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_TRANS_ID_LEN</NAME>
#define STUN_MESSAGE_TRANS_ID_LEN 16
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_ATTRIBUTES_POS</NAME>
#define STUN_MESSAGE_ATTRIBUTES_POS \
  (STUN_MESSAGE_TRANS_ID_POS + STUN_MESSAGE_TRANS_ID_LEN)
</MACRO>
<MACRO>
<NAME>STUN_MESSAGE_HEADER_LENGTH</NAME>
#define STUN_MESSAGE_HEADER_LENGTH STUN_MESSAGE_ATTRIBUTES_POS
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_TYPE_POS</NAME>
#define STUN_ATTRIBUTE_TYPE_POS 0
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_TYPE_LEN</NAME>
#define STUN_ATTRIBUTE_TYPE_LEN 2
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_LENGTH_POS</NAME>
#define STUN_ATTRIBUTE_LENGTH_POS \
  (STUN_ATTRIBUTE_TYPE_POS + STUN_ATTRIBUTE_TYPE_LEN)
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_LENGTH_LEN</NAME>
#define STUN_ATTRIBUTE_LENGTH_LEN 2
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_VALUE_POS</NAME>
#define STUN_ATTRIBUTE_VALUE_POS \
  (STUN_ATTRIBUTE_LENGTH_POS + STUN_ATTRIBUTE_LENGTH_LEN)
</MACRO>
<MACRO>
<NAME>STUN_ATTRIBUTE_HEADER_LENGTH</NAME>
#define STUN_ATTRIBUTE_HEADER_LENGTH STUN_ATTRIBUTE_VALUE_POS
</MACRO>
<MACRO>
<NAME>STUN_MAX_MESSAGE_SIZE_IPV4</NAME>
#define STUN_MAX_MESSAGE_SIZE_IPV4 576
</MACRO>
<MACRO>
<NAME>STUN_MAX_MESSAGE_SIZE_IPV6</NAME>
#define STUN_MAX_MESSAGE_SIZE_IPV6 1280
</MACRO>
<MACRO>
<NAME>STUN_ID_LEN</NAME>
#define STUN_ID_LEN 16
</MACRO>
<MACRO>
<NAME>STUN_AGENT_MAX_SAVED_IDS</NAME>
#define STUN_AGENT_MAX_SAVED_IDS 200
</MACRO>
<MACRO>
<NAME>STUN_AGENT_MAX_UNKNOWN_ATTRIBUTES</NAME>
#define STUN_AGENT_MAX_UNKNOWN_ATTRIBUTES 256
</MACRO>
<MACRO>
<NAME>STUN_MAGIC_COOKIE</NAME>
#define STUN_MAGIC_COOKIE 0x2112A442
</MACRO>
<MACRO>
<NAME>TURN_MAGIC_COOKIE</NAME>
#define TURN_MAGIC_COOKIE 0x72c64bc6
</MACRO>
<ENUM>
<NAME>StunUsageTurnRequestPorts</NAME>
typedef enum {
  STUN_USAGE_TURN_REQUEST_PORT_NORMAL = 0,
  STUN_USAGE_TURN_REQUEST_PORT_EVEN = 1,
  STUN_USAGE_TURN_REQUEST_PORT_EVEN_AND_RESERVE = 2
} StunUsageTurnRequestPorts;
</ENUM>
<ENUM>
<NAME>StunUsageTurnCompatibility</NAME>
typedef enum {
  STUN_USAGE_TURN_COMPATIBILITY_DRAFT9,
  STUN_USAGE_TURN_COMPATIBILITY_GOOGLE,
  STUN_USAGE_TURN_COMPATIBILITY_MSN,
  STUN_USAGE_TURN_COMPATIBILITY_OC2007,
  STUN_USAGE_TURN_COMPATIBILITY_RFC5766,
} StunUsageTurnCompatibility;
</ENUM>
<ENUM>
<NAME>StunUsageTurnReturn</NAME>
typedef enum {
  STUN_USAGE_TURN_RETURN_RELAY_SUCCESS,
  STUN_USAGE_TURN_RETURN_MAPPED_SUCCESS,
  STUN_USAGE_TURN_RETURN_ERROR,
  STUN_USAGE_TURN_RETURN_INVALID,
  STUN_USAGE_TURN_RETURN_ALTERNATE_SERVER,
} StunUsageTurnReturn;
</ENUM>
<FUNCTION>
<NAME>stun_usage_turn_create</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, StunMessage *previous_response, StunUsageTurnRequestPorts request_ports, int32_t bandwidth, int32_t lifetime, uint8_t *username, size_t username_len, uint8_t *password, size_t password_len, StunUsageTurnCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_turn_create_refresh</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, StunMessage *previous_response, int32_t lifetime, uint8_t *username, size_t username_len, uint8_t *password, size_t password_len, StunUsageTurnCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_turn_create_permission</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, uint8_t *username, size_t username_len, uint8_t *password, size_t password_len, uint8_t *realm, size_t realm_len, uint8_t *nonce, size_t nonce_len, struct sockaddr_storage *peer, StunUsageTurnCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_turn_process</NAME>
<RETURNS>StunUsageTurnReturn  </RETURNS>
StunMessage *msg, struct sockaddr_storage *relay_addr, socklen_t *relay_addrlen, struct sockaddr_storage *addr, socklen_t *addrlen, struct sockaddr_storage *alternate_server, socklen_t *alternate_server_len, uint32_t *bandwidth, uint32_t *lifetime, StunUsageTurnCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_turn_refresh_process</NAME>
<RETURNS>StunUsageTurnReturn  </RETURNS>
StunMessage *msg, uint32_t *lifetime, StunUsageTurnCompatibility compatibility 
</FUNCTION>
<ENUM>
<NAME>StunUsageBindReturn</NAME>
typedef enum {
  STUN_USAGE_BIND_RETURN_SUCCESS,
  STUN_USAGE_BIND_RETURN_ERROR,
  STUN_USAGE_BIND_RETURN_INVALID,
  STUN_USAGE_BIND_RETURN_ALTERNATE_SERVER,
  STUN_USAGE_BIND_RETURN_TIMEOUT,
} StunUsageBindReturn;
</ENUM>
<FUNCTION>
<NAME>stun_usage_bind_create</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_bind_process</NAME>
<RETURNS>StunUsageBindReturn  </RETURNS>
StunMessage *msg, struct sockaddr *addr, socklen_t *addrlen, struct sockaddr *alternate_server, socklen_t *alternate_server_len 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_bind_keepalive</NAME>
<RETURNS>size_t  </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buf, size_t len 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_bind_run</NAME>
<RETURNS>StunUsageBindReturn  </RETURNS>
const struct sockaddr *srv, socklen_t srvlen, struct sockaddr_storage *addr, socklen_t *addrlen 
</FUNCTION>
<TYPEDEF>
<NAME>StunTimer</NAME>
typedef struct stun_timer_s StunTimer;
</TYPEDEF>
<STRUCT>
<NAME>stun_timer_s</NAME>
struct stun_timer_s {
  struct timeval deadline;
  unsigned delay;
  unsigned retransmissions;
  unsigned max_retransmissions;
};
</STRUCT>
<MACRO>
<NAME>STUN_TIMER_DEFAULT_TIMEOUT</NAME>
#define STUN_TIMER_DEFAULT_TIMEOUT 600
</MACRO>
<MACRO>
<NAME>STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS</NAME>
#define STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS 3
</MACRO>
<MACRO>
<NAME>STUN_TIMER_DEFAULT_RELIABLE_TIMEOUT</NAME>
#define STUN_TIMER_DEFAULT_RELIABLE_TIMEOUT 7900
</MACRO>
<ENUM>
<NAME>StunUsageTimerReturn</NAME>
typedef enum {
  STUN_USAGE_TIMER_RETURN_SUCCESS,
  STUN_USAGE_TIMER_RETURN_RETRANSMIT,
  STUN_USAGE_TIMER_RETURN_TIMEOUT
} StunUsageTimerReturn;
</ENUM>
<FUNCTION>
<NAME>stun_timer_start</NAME>
<RETURNS>void  </RETURNS>
StunTimer *timer, unsigned int initial_timeout, unsigned int max_retransmissions 
</FUNCTION>
<FUNCTION>
<NAME>stun_timer_start_reliable</NAME>
<RETURNS>void  </RETURNS>
StunTimer *timer, unsigned int initial_timeout 
</FUNCTION>
<FUNCTION>
<NAME>stun_timer_refresh</NAME>
<RETURNS>StunUsageTimerReturn  </RETURNS>
StunTimer *timer 
</FUNCTION>
<FUNCTION>
<NAME>stun_timer_remainder</NAME>
<RETURNS>unsigned  </RETURNS>
const StunTimer *timer 
</FUNCTION>
<ENUM>
<NAME>StunUsageIceCompatibility</NAME>
typedef enum {
  STUN_USAGE_ICE_COMPATIBILITY_RFC5245,
  STUN_USAGE_ICE_COMPATIBILITY_GOOGLE,
  STUN_USAGE_ICE_COMPATIBILITY_MSN,
  STUN_USAGE_ICE_COMPATIBILITY_WLM2009,
  STUN_USAGE_ICE_COMPATIBILITY_DRAFT19 = STUN_USAGE_ICE_COMPATIBILITY_RFC5245,
} StunUsageIceCompatibility;
</ENUM>
<ENUM>
<NAME>StunUsageIceReturn</NAME>
typedef enum {
  STUN_USAGE_ICE_RETURN_SUCCESS,
  STUN_USAGE_ICE_RETURN_ERROR,
  STUN_USAGE_ICE_RETURN_INVALID,
  STUN_USAGE_ICE_RETURN_ROLE_CONFLICT,
  STUN_USAGE_ICE_RETURN_INVALID_REQUEST,
  STUN_USAGE_ICE_RETURN_INVALID_METHOD,
  STUN_USAGE_ICE_RETURN_MEMORY_ERROR,
  STUN_USAGE_ICE_RETURN_INVALID_ADDRESS,
  STUN_USAGE_ICE_RETURN_NO_MAPPED_ADDRESS,
} StunUsageIceReturn;
</ENUM>
<FUNCTION>
<NAME>stun_usage_ice_conncheck_create</NAME>
<RETURNS>size_t </RETURNS>
StunAgent *agent, StunMessage *msg, uint8_t *buffer, size_t buffer_len, const uint8_t *username, const size_t username_len, const uint8_t *password, const size_t password_len, bool cand_use, bool controlling, uint32_t priority, uint64_t tie, const char *candidate_identifier, StunUsageIceCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_ice_conncheck_process</NAME>
<RETURNS>StunUsageIceReturn  </RETURNS>
StunMessage *msg, struct sockaddr_storage *addr, socklen_t *addrlen, StunUsageIceCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_ice_conncheck_create_reply</NAME>
<RETURNS>StunUsageIceReturn </RETURNS>
StunAgent *agent, StunMessage *req, StunMessage *msg, uint8_t *buf, size_t *plen, const struct sockaddr_storage *src, socklen_t srclen, bool *control, uint64_t tie, StunUsageIceCompatibility compatibility 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_ice_conncheck_priority</NAME>
<RETURNS>uint32_t  </RETURNS>
const StunMessage *msg 
</FUNCTION>
<FUNCTION>
<NAME>stun_usage_ice_conncheck_use_candidate</NAME>
<RETURNS>bool  </RETURNS>
const StunMessage *msg 
</FUNCTION>
