TeaSpeak/libnice-prebuild
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added linux_x86 prebuild files

Browse Source
This commit is contained in:
WolverinDEV 2019-11-11 19:50:32 +00:00
parent f68fa49132
commit a743f4640b
21 changed files with 6036 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

307
linux_x86/include/nice/address.h Normal file
View File

@ -0,0 +1,307 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2006-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2006-2009 Nokia Corporation. All rights reserved.
* Contact: Kai Vehmanen
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Dafydd Harries, Collabora Ltd.
* Kai Vehmanen
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef __LIBNICE_ADDRESS_H__
#define __LIBNICE_ADDRESS_H__
/**
* SECTION:address
* @short_description: IP address convenience library
* @stability: Stable
*
* The #NiceAddress structure will allow you to easily set/get and modify an IPv4
* or IPv6 address in order to communicate with the #NiceAgent.
*/
#include <glib.h>
#ifdef G_OS_WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
G_BEGIN_DECLS
/**
* NiceAddress:
*
* The #NiceAddress structure that represents an IPv4 or IPv6 address.
*/
struct _NiceAddress
{
union
{
struct sockaddr addr;
struct sockaddr_in ip4;
struct sockaddr_in6 ip6;
} s;
};
/**
* NICE_ADDRESS_STRING_LEN:
*
* The maximum string length representation of an address.
* When using nice_address_to_string() make sure the string has a size of
* at least %NICE_ADDRESS_STRING_LEN
*/
#define NICE_ADDRESS_STRING_LEN INET6_ADDRSTRLEN
typedef struct _NiceAddress NiceAddress;
/**
* nice_address_init:
* @addr: The #NiceAddress to init
*
* Initialize a #NiceAddress into an undefined address
*/
void
nice_address_init (NiceAddress *addr);
/**
* nice_address_new:
*
* Create a new #NiceAddress with undefined address
* You must free it with nice_address_free()
*
* Returns: The new #NiceAddress
*/
NiceAddress *
nice_address_new (void);
/**
* nice_address_free:
* @addr: The #NiceAddress to free
*
* Frees a #NiceAddress created with nice_address_new() or nice_address_dup()
*/
void
nice_address_free (NiceAddress *addr);
/**
* nice_address_dup:
* @addr: The #NiceAddress to dup
*
* Creates a new #NiceAddress with the same address as @addr
*
* Returns: The new #NiceAddress
*/
NiceAddress *
nice_address_dup (const NiceAddress *addr);
/**
* nice_address_set_ipv4:
* @addr: The #NiceAddress to modify
* @addr_ipv4: The IPv4 address
*
* Set @addr to an IPv4 address using the data from @addr_ipv4
*
<note>
<para>
This function will reset the port to 0, so make sure you call it before
nice_address_set_port()
</para>
</note>
*/
void
nice_address_set_ipv4 (NiceAddress *addr, guint32 addr_ipv4);
/**
* nice_address_set_ipv6:
* @addr: The #NiceAddress to modify
* @addr_ipv6: The IPv6 address
*
* Set @addr to an IPv6 address using the data from @addr_ipv6
*
<note>
<para>
This function will reset the port to 0, so make sure you call it before
nice_address_set_port()
</para>
</note>
*/
void
nice_address_set_ipv6 (NiceAddress *addr, const guchar *addr_ipv6);
/**
* nice_address_set_port:
* @addr: The #NiceAddress to modify
* @port: The port to set
*
* Set the port of @addr to @port
*/
void
nice_address_set_port (NiceAddress *addr, guint port);
/**
* nice_address_get_port:
* @addr: The #NiceAddress to query
*
* Retreive the port of @addr
*
* Returns: The port of @addr
*/
guint
nice_address_get_port (const NiceAddress *addr);
/**
* nice_address_set_from_string:
* @addr: The #NiceAddress to modify
* @str: The string to set
*
* Sets an IPv4 or IPv6 address from the string @str
*
* Returns: %TRUE if success, %FALSE on error
*/
gboolean
nice_address_set_from_string (NiceAddress *addr, const gchar *str);
/**
* nice_address_set_from_sockaddr:
* @addr: The #NiceAddress to modify
* @sin: The sockaddr to set
*
* Sets an IPv4 or IPv6 address from the sockaddr structure @sin
*
*/
void
nice_address_set_from_sockaddr (NiceAddress *addr, const struct sockaddr *sin);
/**
* nice_address_copy_to_sockaddr:
* @addr: The #NiceAddress to query
* @sin: The sockaddr to fill
*
* Fills the sockaddr structure @sin with the address contained in @addr
*
*/
void
nice_address_copy_to_sockaddr (const NiceAddress *addr, struct sockaddr *sin);
/**
* nice_address_equal:
* @a: First #NiceAddress to compare
* @b: Second #NiceAddress to compare
*
* Compares two #NiceAddress structures to see if they contain the same address
* and the same port.
*
* Returns: %TRUE if @a and @b are the same address, %FALSE if they are different
*/
gboolean
nice_address_equal (const NiceAddress *a, const NiceAddress *b);
/**
* nice_address_equal_no_port:
* @a: First #NiceAddress to compare
* @b: Second #NiceAddress to compare
*
* Compares two #NiceAddress structures to see if they contain the same address,
* ignoring the port.
*
* Returns: %TRUE if @a and @b are the same address, %FALSE if they
* are different
*
* Since: 0.1.8
*/
gboolean
nice_address_equal_no_port (const NiceAddress *a, const NiceAddress *b);
/**
* nice_address_to_string:
* @addr: The #NiceAddress to query
* @dst: The string to fill
*
* Transforms the address @addr into a human readable string
*
*/
void
nice_address_to_string (const NiceAddress *addr, gchar *dst);
/**
* nice_address_is_private:
* @addr: The #NiceAddress to query
*
* Verifies if the address in @addr is a private address or not
*
* Returns: %TRUE if @addr is a private address, %FALSE otherwise
*/
gboolean
nice_address_is_private (const NiceAddress *addr);
/**
* nice_address_is_valid:
* @addr: The #NiceAddress to query
*
* Validate whether the #NiceAddress @addr is a valid IPv4 or IPv6 address
*
* Returns: %TRUE if @addr is valid, %FALSE otherwise
*/
G_GNUC_WARN_UNUSED_RESULT
gboolean
nice_address_is_valid (const NiceAddress *addr);
/**
* nice_address_ip_version:
* @addr: The #NiceAddress to query
*
* Returns the IP version of the address
*
* Returns: 4 for IPv4, 6 for IPv6 and 0 for undefined address
*/
G_GNUC_WARN_UNUSED_RESULT
int
nice_address_ip_version (const NiceAddress *addr);
G_END_DECLS
#endif /* __LIBNICE_ADDRESS_H__ */

1709
linux_x86/include/nice/agent.h Normal file
View File

File diff suppressed because it is too large Load Diff

269
linux_x86/include/nice/candidate.h Normal file
View File

@ -0,0 +1,269 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2006-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2006-2009 Nokia Corporation. All rights reserved.
* Contact: Kai Vehmanen
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Dafydd Harries, Collabora Ltd.
* Youness Alaoui, Collabora Ltd.
* Kai Vehmanen, Nokia
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef __LIBNICE_CANDIDATE_H__
#define __LIBNICE_CANDIDATE_H__
#include <glib.h>
#include <glib-object.h>
/**
* SECTION:candidate
* @short_description: ICE candidate representation
* @see_also: #NiceAddress
* @stability: Stable
*
* A representation of an ICE candidate. Make sure you read the ICE drafts[1] to
* understand correctly the concept of ICE candidates.
*
* [1] http://tools.ietf.org/wg/mmusic/draft-ietf-mmusic-ice/
*/
G_BEGIN_DECLS
/* Constants for determining candidate priorities */
#define NICE_CANDIDATE_TYPE_PREF_HOST 120
#define NICE_CANDIDATE_TYPE_PREF_PEER_REFLEXIVE 110
#define NICE_CANDIDATE_TYPE_PREF_NAT_ASSISTED 105
#define NICE_CANDIDATE_TYPE_PREF_SERVER_REFLEXIVE 100
#define NICE_CANDIDATE_TYPE_PREF_RELAYED_UDP 30
#define NICE_CANDIDATE_TYPE_PREF_RELAYED 20
/* Priority preference constants for MS-ICE compatibility */
#define NICE_CANDIDATE_TRANSPORT_MS_PREF_UDP 15
#define NICE_CANDIDATE_TRANSPORT_MS_PREF_TCP 6
#define NICE_CANDIDATE_DIRECTION_MS_PREF_PASSIVE 2
#define NICE_CANDIDATE_DIRECTION_MS_PREF_ACTIVE 5
/* Max foundation size '1*32ice-char' plus terminating NULL, ICE ID-19 */
/**
* NICE_CANDIDATE_MAX_FOUNDATION:
*
* The maximum size a candidate foundation can have.
*/
#define NICE_CANDIDATE_MAX_FOUNDATION (32+1)
/**
* NiceCandidateType:
* @NICE_CANDIDATE_TYPE_HOST: A host candidate
* @NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE: A server reflexive candidate
* @NICE_CANDIDATE_TYPE_PEER_REFLEXIVE: A peer reflexive candidate
* @NICE_CANDIDATE_TYPE_RELAYED: A relay candidate
*
* An enum represneting the type of a candidate
*/
typedef enum
{
NICE_CANDIDATE_TYPE_HOST,
NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE,
NICE_CANDIDATE_TYPE_PEER_REFLEXIVE,
NICE_CANDIDATE_TYPE_RELAYED,
} NiceCandidateType;
/**
* NiceCandidateTransport:
* @NICE_CANDIDATE_TRANSPORT_UDP: UDP transport
* @NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE: TCP Active transport
* @NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE: TCP Passive transport
* @NICE_CANDIDATE_TRANSPORT_TCP_SO: TCP Simultaneous-Open transport
*
* An enum representing the type of transport to use
*/
typedef enum
{
NICE_CANDIDATE_TRANSPORT_UDP,
NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE,
NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE,
NICE_CANDIDATE_TRANSPORT_TCP_SO,
} NiceCandidateTransport;
/**
* NiceRelayType:
* @NICE_RELAY_TYPE_TURN_UDP: A TURN relay using UDP
* @NICE_RELAY_TYPE_TURN_TCP: A TURN relay using TCP
* @NICE_RELAY_TYPE_TURN_TLS: A TURN relay using TLS over TCP
*
* An enum representing the type of relay to use
*/
typedef enum {
NICE_RELAY_TYPE_TURN_UDP,
NICE_RELAY_TYPE_TURN_TCP,
NICE_RELAY_TYPE_TURN_TLS
} NiceRelayType;
typedef struct _NiceCandidate NiceCandidate;
typedef struct _TurnServer TurnServer;
/**
* TurnServer:
* @ref_count: Reference count for the structure.
* @server: The #NiceAddress of the TURN server
* @username: The TURN username
* @password: The TURN password
* @decoded_username: The base64 decoded TURN username
* @decoded_password: The base64 decoded TURN password
* @decoded_username_len: The length of @decoded_username
* @decoded_password_len: The length of @decoded_password
* @type: The #NiceRelayType of the server
*
* A structure to store the TURN relay settings
*/
struct _TurnServer
{
gint ref_count;
NiceAddress server;
gchar *username;
gchar *password;
guint8 *decoded_username;
guint8 *decoded_password;
gsize decoded_username_len;
gsize decoded_password_len;
NiceRelayType type;
};
/**
* NiceCandidate:
* @type: The type of candidate
* @transport: The transport being used for the candidate
* @addr: The #NiceAddress of the candidate
* @base_addr: The #NiceAddress of the base address used by the candidate
* @priority: The priority of the candidate <emphasis> see note </emphasis>
* @stream_id: The ID of the stream to which belongs the candidate
* @component_id: The ID of the component to which belongs the candidate
* @foundation: The foundation of the candidate
* @username: The candidate-specific username to use (overrides the one set
* by nice_agent_set_local_credentials() or nice_agent_set_remote_credentials())
* @password: The candidate-specific password to use (overrides the one set
* by nice_agent_set_local_credentials() or nice_agent_set_remote_credentials())
* @turn: The #TurnServer settings if the candidate is
* of type %NICE_CANDIDATE_TYPE_RELAYED
* @sockptr: The underlying socket
*
* A structure to represent an ICE candidate
<note>
<para>
The @priority is an integer as specified in the ICE draft 19. If you are
using the MSN or the GOOGLE compatibility mode (which are based on ICE
draft 6, which uses a floating point qvalue as priority), then the @priority
value will represent the qvalue multiplied by 1000.
</para>
</note>
*/
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 nul-terminated username string */
gchar *password; /* pointer to a nul-terminated password string */
TurnServer *turn;
gpointer sockptr;
};
/**
* nice_candidate_new:
* @type: The #NiceCandidateType of the candidate to create
*
* Creates a new candidate. Must be freed with nice_candidate_free()
*
* Returns: A new #NiceCandidate
*/
NiceCandidate *
nice_candidate_new (NiceCandidateType type);
/**
* nice_candidate_free:
* @candidate: The candidate to free
*
* Frees a #NiceCandidate
*/
void
nice_candidate_free (NiceCandidate *candidate);
/**
* nice_candidate_copy:
* @candidate: The candidate to copy
*
* Makes a copy of a #NiceCandidate
*
* Returns: A new #NiceCandidate, a copy of @candidate
*/
NiceCandidate *
nice_candidate_copy (const NiceCandidate *candidate);
/**
* nice_candidate_equal_target:
* @candidate1: A candidate
* @candidate2: A candidate
*
* Verifies that the candidates point to the same place, meaning they have
* the same transport and the same address. It ignores all other aspects.
*
* Returns: %TRUE if the candidates point to the same place
*
* Since: 0.1.15
*/
gboolean
nice_candidate_equal_target (const NiceCandidate *candidate1,
const NiceCandidate *candidate2);
GType nice_candidate_get_type (void);
/**
* NICE_TYPE_CANDIDATE:
*
* A boxed type for a #NiceCandidate.
*/
#define NICE_TYPE_CANDIDATE nice_candidate_get_type ()
G_END_DECLS
#endif /* __LIBNICE_CANDIDATE_H__ */

105
linux_x86/include/nice/debug.h Normal file
View File

@ -0,0 +1,105 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2008 Nokia Corporation. All rights reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef __LIBNICE_DEBUG_H__
#define __LIBNICE_DEBUG_H__
/**
* SECTION:debug
* @short_description: Debug messages utility functions
* @stability: Unstable
*
* <para>Libnice can output a lot of information when debug messages are enabled.
* This can significantly help track down problems and/or understand what
* it's doing.</para>
*
* <para>You can enable/disable the debug messages by calling nice_debug_enable()
* or nice_debug_disable() and choosing whether you want only ICE debug messages
* or also stun debug messages.</para>
*
* <para>By default, the debug messages are disabled, unless the environment
* variable NICE_DEBUG is set, in which case, it must contain a comma separated
* list of flags specifying which debug to enable.</para>
* <para> The currently available flags are "nice", "stun", "pseudotcp",
* "pseudotcp-verbose" or "all" to enable all debug messages.</para>
* <para> If the 'pseudotcp' flag is enabled, then 'pseudotcp-verbose' gets
* automatically disabled. This is to allow the use of the 'all' flag without
* having verbose messages from pseudotcp. You can enable verbose debug messages
* from the pseudotcp layer by specifying 'pseudotcp-verbose' without the
* 'pseudotcp' flag.</para>
*
*
* <para>This API is unstable and is subject to change at any time...
* More flags are to come and a better API to enable/disable each flag
* should be added.</para>
*/
#include <glib.h>
G_BEGIN_DECLS
/**
* nice_debug_enable:
* @with_stun: Also enable STUN debugging messages
*
* Enables libnice debug output to the terminal. Note that the
* `G_MESSAGES_DEBUG` and `NICE_DEBUG` environment variables must be set to the
* set of logging domains to print, in order for any output to be printed. Set
* them to `all` to print all debugging messages, or any of the following
* domains:
* - `libnice-stun`
* - `libnice-tests`
* - `libnice-socket`
* - `libnice`
* - `libnice-pseudotcp`
* - `libnice-pseudotcp-verbose`
*/
void nice_debug_enable (gboolean with_stun);
/**
* nice_debug_disable:
* @with_stun: Also disable stun debugging messages
*
* Disables libnice debug output to the terminal
*/
void nice_debug_disable (gboolean with_stun);
G_END_DECLS
#endif /* __LIBNICE_DEBUG_H__ */

82
linux_x86/include/nice/interfaces.h Normal file
View File

@ -0,0 +1,82 @@
/*
* interfaces.h - Source for interface discovery code
*
* Farsight Helper functions
* Copyright (C) 2006 Youness Alaoui <kakaroto@kakaroto.homelinux.net>
* Copyright (C) 2008-2009 Collabora, Nokia
* Contact: Youness Alaoui
* Copyright (C) 2008-2009 Nokia Corporation. All rights reserved.
*
* 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
*/
#ifndef __LIBNICE_INTERFACES_H__
#define __LIBNICE_INTERFACES_H__
/**
* SECTION:interfaces
* @short_description: Utility functions to discover local network interfaces
* @include: interfaces.h
* @stability: Stable
*
* These utility functions allow the discovery of local network interfaces
* in a portable manner, they also allow finding the local ip addresses or
* the address allocated to a network interface.
*/
#include <glib.h>
G_BEGIN_DECLS
/**
* nice_interfaces_get_ip_for_interface:
* @interface_name: name of local interface
*
* Retrieves the IP address of an interface by its name. If this fails, %NULL
* is returned.
*
* Returns: (nullable) (transfer full): a newly-allocated string with the IP
* address
*/
gchar * nice_interfaces_get_ip_for_interface (gchar *interface_name);
/**
* nice_interfaces_get_local_ips:
* @include_loopback: Include any loopback devices
*
* Get a list of local ipv4 interface addresses
*
* Returns: (element-type utf8) (transfer full): a newly-allocated #GList of
* strings. The caller must free it.
*/
GList * nice_interfaces_get_local_ips (gboolean include_loopback);
/**
* nice_interfaces_get_local_interfaces:
*
* Get the list of local interfaces
*
* Returns: (element-type utf8) (transfer full): a newly-allocated #GList of
* strings. The caller must free it.
*/
GList * nice_interfaces_get_local_interfaces (void);
G_END_DECLS
#endif /* __LIBNICE_INTERFACES_H__ */

46
linux_x86/include/nice/nice.h Normal file
View File

@ -0,0 +1,46 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2006-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2006-2009 Nokia Corporation. All rights reserved.
* Contact: Kai Vehmanen
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Dafydd Harries, Collabora Ltd.
* Youness Alaoui, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef _NICE_H
#define _NICE_H
#include "agent.h"
#include "interfaces.h"
#endif /* _NICE_H */

599
linux_x86/include/nice/pseudotcp.h Normal file
View File

@ -0,0 +1,599 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2010, 2014 Collabora Ltd.
* Contact: Philip Withnall
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Philip Withnall, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef __LIBNICE_PSEUDOTCP_H__
#define __LIBNICE_PSEUDOTCP_H__
/**
* SECTION:pseudotcp
* @short_description: Pseudo TCP implementation
* @include: pseudotcp.h
* @stability: Stable
*
* The #PseudoTcpSocket is an object implementing a Pseudo Tcp Socket for use
* over UDP.
* The socket will implement a subset of the TCP stack to allow for a reliable
* transport over non-reliable sockets (such as UDP).
*
* See the file tests/test-pseudotcp.c in the source package for an example
* of how to use the object.
*
* Since: 0.0.11
*/
#include <glib-object.h>
#ifndef __GTK_DOC_IGNORE__
#ifdef G_OS_WIN32
# include <winsock2.h>
#ifndef ECONNABORTED
# define ECONNABORTED WSAECONNABORTED
#endif
#ifndef ENOTCONN
# define ENOTCONN WSAENOTCONN
#endif
#ifndef EWOULDBLOCK
# define EWOULDBLOCK WSAEWOULDBLOCK
#endif
#ifndef ECONNRESET
# define ECONNRESET WSAECONNRESET
#endif
#ifndef EMSGSIZE
# define EMSGSIZE WSAEMSGSIZE
#endif
#ifndef ETIMEDOUT
# define ETIMEDOUT WSAETIMEDOUT
#endif
#endif
#endif
#include "agent.h"
G_BEGIN_DECLS
/**
* PseudoTcpSocket:
*
* The #PseudoTcpSocket is the GObject implementing the Pseudo TCP Socket
*
* Since: 0.0.11
*/
typedef struct _PseudoTcpSocket PseudoTcpSocket;
typedef struct _PseudoTcpSocketClass PseudoTcpSocketClass;
GType pseudo_tcp_socket_get_type (void);
/* TYPE MACROS */
#define PSEUDO_TCP_SOCKET_TYPE \
(pseudo_tcp_socket_get_type ())
#define PSEUDO_TCP_SOCKET(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), PSEUDO_TCP_SOCKET_TYPE, \
PseudoTcpSocket))
#define PSEUDO_TCP_SOCKET_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), PSEUDO_TCP_SOCKET_TYPE, \
PseudoTcpSocketClass))
#define IS_PSEUDO_TCP_SOCKET(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj), PSEUDO_TCP_SOCKET_TYPE))
#define IS_PSEUDO_TCP_SOCKET_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass), PSEUDO_TCP_SOCKET_TYPE))
#define PSEUDOTCP_SOCKET_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), PSEUDO_TCP_SOCKET_TYPE, \
PseudoTcpSocketClass))
/**
* PseudoTcpDebugLevel:
* @PSEUDO_TCP_DEBUG_NONE: Disable debug messages
* @PSEUDO_TCP_DEBUG_NORMAL: Enable basic debug messages
* @PSEUDO_TCP_DEBUG_VERBOSE: Enable verbose debug messages
*
* Valid values of debug levels to be set.
*
* Since: 0.0.11
*/
typedef enum {
PSEUDO_TCP_DEBUG_NONE = 0,
PSEUDO_TCP_DEBUG_NORMAL,
PSEUDO_TCP_DEBUG_VERBOSE,
} PseudoTcpDebugLevel;
/**
* PseudoTcpState:
* @PSEUDO_TCP_LISTEN: The socket's initial state. The socket isn't connected and is
* listening for an incoming connection
* @PSEUDO_TCP_SYN_SENT: The socket has sent a connection request (SYN) packet and is
* waiting for an answer
* @PSEUDO_TCP_SYN_RECEIVED: The socket has received a connection request (SYN) packet.
* @PSEUDO_TCP_ESTABLISHED: The socket is connected
* @PSEUDO_TCP_CLOSED: The socket has been closed
* @PSEUDO_TCP_FIN_WAIT_1: The socket has been closed locally but not remotely
* (Since: 0.1.8)
* @PSEUDO_TCP_FIN_WAIT_2: The socket has been closed locally but not remotely
* (Since: 0.1.8)
* @PSEUDO_TCP_CLOSING: The socket has been closed locally and remotely
* (Since: 0.1.8)
* @PSEUDO_TCP_TIME_WAIT: The socket has been closed locally and remotely
* (Since: 0.1.8)
* @PSEUDO_TCP_CLOSE_WAIT: The socket has been closed remotely but not locally
* (Since: 0.1.8)
* @PSEUDO_TCP_LAST_ACK: The socket has been closed locally and remotely
* (Since: 0.1.8)
*
* An enum representing the state of the #PseudoTcpSocket. These states
* correspond to the TCP states in RFC 793.
* <para> See also: #PseudoTcpSocket:state </para>
*
* Since: 0.0.11
*/
typedef enum {
PSEUDO_TCP_LISTEN,
PSEUDO_TCP_SYN_SENT,
PSEUDO_TCP_SYN_RECEIVED,
PSEUDO_TCP_ESTABLISHED,
PSEUDO_TCP_CLOSED,
PSEUDO_TCP_FIN_WAIT_1,
PSEUDO_TCP_FIN_WAIT_2,
PSEUDO_TCP_CLOSING,
PSEUDO_TCP_TIME_WAIT,
PSEUDO_TCP_CLOSE_WAIT,
PSEUDO_TCP_LAST_ACK,
} PseudoTcpState;
/**
* PseudoTcpWriteResult:
* @WR_SUCCESS: The write operation was successful
* @WR_TOO_LARGE: The socket type requires that message be sent atomically
* and the size of the message to be sent made this impossible.
* @WR_FAIL: There was an error sending the message
*
* An enum representing the result value of the write operation requested by
* the #PseudoTcpSocket.
* <para> See also: %PseudoTcpCallbacks:WritePacket </para>
*
* Since: 0.0.11
*/
typedef enum {
WR_SUCCESS,
WR_TOO_LARGE,
WR_FAIL
} PseudoTcpWriteResult;
/**
* PseudoTcpShutdown:
* @PSEUDO_TCP_SHUTDOWN_RD: Shut down the local reader only
* @PSEUDO_TCP_SHUTDOWN_WR: Shut down the local writer only
* @PSEUDO_TCP_SHUTDOWN_RDWR: Shut down both reading and writing
*
* Options for which parts of a connection to shut down when calling
* pseudo_tcp_socket_shutdown(). These correspond to the values passed to POSIX
* shutdown().
*
* Since: 0.1.8
*/
typedef enum {
PSEUDO_TCP_SHUTDOWN_RD,
PSEUDO_TCP_SHUTDOWN_WR,
PSEUDO_TCP_SHUTDOWN_RDWR,
} PseudoTcpShutdown;
/**
* PseudoTcpCallbacks:
* @user_data: A user defined pointer to be passed to the callbacks
* @PseudoTcpOpened: The #PseudoTcpSocket is now connected
* @PseudoTcpReadable: The socket is readable
* @PseudoTcpWritable: The socket is writable
* @PseudoTcpClosed: The socket was closed (both sides)
* @WritePacket: This callback is called when the socket needs to send data.
*
* A structure containing callbacks functions that will be called by the
* #PseudoTcpSocket when some events happen.
* <para> See also: #PseudoTcpWriteResult </para>
*
* Since: 0.0.11
*/
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;
/**
* pseudo_tcp_socket_new:
* @conversation: The conversation id for the socket.
* @callbacks: A pointer to the #PseudoTcpCallbacks structure for getting
* notified of the #PseudoTcpSocket events.
*
* Creates a new #PseudoTcpSocket for the specified conversation
*
<note>
<para>
The @callbacks must be non-NULL, in order to get notified of packets the
socket needs to send.
</para>
<para>
If the @callbacks structure was dynamicly allocated, it can be freed
after the call @pseudo_tcp_socket_new
</para>
</note>
*
* Returns: The new #PseudoTcpSocket object, %NULL on error
*
* Since: 0.0.11
*/
PseudoTcpSocket *pseudo_tcp_socket_new (guint32 conversation,
PseudoTcpCallbacks *callbacks);
/**
* pseudo_tcp_socket_connect:
* @self: The #PseudoTcpSocket object.
*
* Connects the #PseudoTcpSocket to the peer with the same conversation id.
* The connection will only be successful after the
* %PseudoTcpCallbacks:PseudoTcpOpened callback is called
*
* Returns: %TRUE on success, %FALSE on failure (not in %TCP_LISTEN state)
* <para> See also: pseudo_tcp_socket_get_error() </para>
*
* Since: 0.0.11
*/
gboolean pseudo_tcp_socket_connect(PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_recv:
* @self: The #PseudoTcpSocket object.
* @buffer: The buffer to fill with received data
* @len: The length of @buffer
*
* Receive data from the socket.
*
<note>
<para>
Only call this on the %PseudoTcpCallbacks:PseudoTcpReadable callback.
</para>
<para>
This function should be called in a loop. If this function does not
return -1 with EWOULDBLOCK as the error, the
%PseudoTcpCallbacks:PseudoTcpReadable callback will not be called again.
</para>
</note>
*
* Returns: The number of bytes received or -1 in case of error
* <para> See also: pseudo_tcp_socket_get_error() </para>
*
* Since: 0.0.11
*/
gint pseudo_tcp_socket_recv(PseudoTcpSocket *self, char * buffer, size_t len);
/**
* pseudo_tcp_socket_send:
* @self: The #PseudoTcpSocket object.
* @buffer: The buffer with data to send
* @len: The length of @buffer
*
* Send data on the socket.
*
<note>
<para>
If this function return -1 with EWOULDBLOCK as the error, or if the return
value is lower than @len, then the %PseudoTcpCallbacks:PseudoTcpWritable
callback will be called when the socket will become writable.
</para>
</note>
*
* Returns: The number of bytes sent or -1 in case of error
* <para> See also: pseudo_tcp_socket_get_error() </para>
*
* Since: 0.0.11
*/
gint pseudo_tcp_socket_send(PseudoTcpSocket *self, const char * buffer,
guint32 len);
/**
* pseudo_tcp_socket_close:
* @self: The #PseudoTcpSocket object.
* @force: %TRUE to close the socket forcefully, %FALSE to close it gracefully
*
* Close the socket for sending. If @force is set to %FALSE, the socket will
* finish sending pending data before closing. If it is set to %TRUE, the socket
* will discard pending data and close the connection immediately (sending a TCP
* RST segment).
*
* The socket will be closed in both directions – sending and receiving – and
* any pending received data must be read before calling this function, by
* calling pseudo_tcp_socket_recv() until it blocks. If any pending data is in
* the receive buffer when pseudo_tcp_socket_close() is called, a TCP RST
* segment will be sent to the peer to notify it of the data loss.
*
<note>
<para>
The %PseudoTcpCallbacks:PseudoTcpClosed callback will not be called once
the socket gets closed. It is only used for aborted connection.
Instead, the socket gets closed when the pseudo_tcp_socket_get_next_clock()
function returns FALSE.
</para>
</note>
*
* <para> See also: pseudo_tcp_socket_get_next_clock() </para>
*
* Since: 0.0.11
*/
void pseudo_tcp_socket_close(PseudoTcpSocket *self, gboolean force);
/**
* pseudo_tcp_socket_shutdown:
* @self: The #PseudoTcpSocket object.
* @how: The directions of the connection to shut down.
*
* Shut down sending, receiving, or both on the socket, depending on the value
* of @how. The behaviour of pseudo_tcp_socket_send() and
* pseudo_tcp_socket_recv() will immediately change after this function returns
* (depending on the value of @how), though the socket may continue to process
* network traffic in the background even if sending or receiving data is
* forbidden.
*
* This is equivalent to the POSIX shutdown() function. Setting @how to
* %PSEUDO_TCP_SHUTDOWN_RDWR is equivalent to calling pseudo_tcp_socket_close().
*
* Since: 0.1.8
*/
void pseudo_tcp_socket_shutdown (PseudoTcpSocket *self, PseudoTcpShutdown how);
/**
* pseudo_tcp_socket_get_error:
* @self: The #PseudoTcpSocket object.
*
* Return the last encountered error.
*
<note>
<para>
The return value can be :
<para>
EINVAL (for pseudo_tcp_socket_connect()).
</para>
<para>
EWOULDBLOCK or ENOTCONN (for pseudo_tcp_socket_recv() and
pseudo_tcp_socket_send()).
</para>
</para>
</note>
*
* Returns: The error code
* <para> See also: pseudo_tcp_socket_connect() </para>
* <para> See also: pseudo_tcp_socket_recv() </para>
* <para> See also: pseudo_tcp_socket_send() </para>
*
* Since: 0.0.11
*/
int pseudo_tcp_socket_get_error(PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_get_next_clock:
* @self: The #PseudoTcpSocket object.
* @timeout: A pointer to be filled with the new timeout.
*
* Call this to determine the timeout needed before the next time call
* to pseudo_tcp_socket_notify_clock() should be made.
*
* Returns: %TRUE if @timeout was filled, %FALSE if the socket is closed and
* ready to be destroyed.
*
* <para> See also: pseudo_tcp_socket_notify_clock() </para>
*
* Since: 0.0.11
*/
gboolean pseudo_tcp_socket_get_next_clock(PseudoTcpSocket *self,
guint64 *timeout);
/**
* pseudo_tcp_socket_notify_clock:
* @self: The #PseudoTcpSocket object.
*
* Start the processing of receiving data, pending data or syn/acks.
* Call this based on timeout value returned by
* pseudo_tcp_socket_get_next_clock().
* It's ok to call this too frequently.
*
* <para> See also: pseudo_tcp_socket_get_next_clock() </para>
*
* Since: 0.0.11
*/
void pseudo_tcp_socket_notify_clock(PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_notify_mtu:
* @self: The #PseudoTcpSocket object.
* @mtu: The new MTU of the socket
*
* Set the MTU of the socket
*
* Since: 0.0.11
*/
void pseudo_tcp_socket_notify_mtu(PseudoTcpSocket *self, guint16 mtu);
/**
* pseudo_tcp_socket_notify_packet:
* @self: The #PseudoTcpSocket object.
* @buffer: The buffer containing the received data
* @len: The length of @buffer
*
* Notify the #PseudoTcpSocket when a new packet arrives
*
* Returns: %TRUE if the packet was processed successfully, %FALSE otherwise
*
* Since: 0.0.11
*/
gboolean pseudo_tcp_socket_notify_packet(PseudoTcpSocket *self,
const gchar * buffer, guint32 len);
/**
* pseudo_tcp_socket_notify_message:
* @self: The #PseudoTcpSocket object.
* @message: A #NiceInputMessage containing the received data.
*
* Notify the #PseudoTcpSocket that a new message has arrived, and enqueue the
* data in its buffers to the #PseudoTcpSocket’s receive buffer.
*
* Returns: %TRUE if the packet was processed successfully, %FALSE otherwise
*
* Since: 0.1.5
*/
gboolean pseudo_tcp_socket_notify_message (PseudoTcpSocket *self,
NiceInputMessage *message);
/**
* pseudo_tcp_set_debug_level:
* @level: The level of debug to set
*
* Sets the debug level to enable/disable normal/verbose debug messages.
*
* Since: 0.0.11
*/
void pseudo_tcp_set_debug_level (PseudoTcpDebugLevel level);
/**
* pseudo_tcp_socket_get_available_bytes:
* @self: The #PseudoTcpSocket object.
*
* Gets the number of bytes of data in the buffer that can be read without
* receiving more packets from the network.
*
* Returns: The number of bytes or -1 if the connection is not established
*
* Since: 0.1.5
*/
gint pseudo_tcp_socket_get_available_bytes (PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_can_send:
* @self: The #PseudoTcpSocket object.
*
* Returns if there is space in the send buffer to send any data.
*
* Returns: %TRUE if data can be sent, %FALSE otherwise
*
* Since: 0.1.5
*/
gboolean pseudo_tcp_socket_can_send (PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_get_available_send_space:
* @self: The #PseudoTcpSocket object.
*
* Gets the number of bytes of space available in the transmission buffer.
*
* Returns: The number of bytes, or 0 if the connection is not established.
*
* Since: 0.1.5
*/
gsize pseudo_tcp_socket_get_available_send_space (PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_set_time:
* @self: The #PseudoTcpSocket object.
* @current_time: Current monotonic time, in milliseconds; or zero to use the
* system monotonic clock.
*
* Sets the current monotonic time to be used by the TCP socket when calculating
* timeouts and expiry times. If this function is not called, or is called with
* @current_time as zero, g_get_monotonic_time() will be used. Otherwise, the
* specified @current_time will be used until it is updated by calling this
* function again.
*
* This function is intended for testing only, and should not be used in
* production code.
*
* Since: 0.1.8
*/
void pseudo_tcp_socket_set_time (PseudoTcpSocket *self, guint32 current_time);
/**
* pseudo_tcp_socket_is_closed:
* @self: The #PseudoTcpSocket object.
*
* Gets whether the socket is closed, with the shutdown handshake completed,
* and both peers no longer able to read or write data to the connection.
*
* Returns: %TRUE if the socket is closed in both directions, %FALSE otherwise
* Since: 0.1.8
*/
gboolean pseudo_tcp_socket_is_closed (PseudoTcpSocket *self);
/**
* pseudo_tcp_socket_is_closed_remotely:
* @self: The #PseudoTcpSocket object.
*
* Gets whether the socket has been closed on the remote peer’s side of the
* connection (i.e. whether pseudo_tcp_socket_close() has been called there).
* This is guaranteed to return %TRUE if pseudo_tcp_socket_is_closed() returns
* %TRUE. It will not return %TRUE after pseudo_tcp_socket_close() is called
* until a FIN segment is received from the remote peer.
*
* Returns: %TRUE if the remote peer has closed its side of the connection,
* %FALSE otherwise
* Since: 0.1.8
*/
gboolean pseudo_tcp_socket_is_closed_remotely (PseudoTcpSocket *self);
G_END_DECLS
#endif /* __LIBNICE_PSEUDOTCP_H__ */

203
linux_x86/include/stun/constants.h Normal file
View File

@ -0,0 +1,203 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2008 Nokia Corporation. All rights reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef _STUN_CONSTANTS_H
#define _STUN_CONSTANTS_H
/**
* SECTION:stunconstants
* @short_description: STUN constants
* @include: stun/constants.h
* @stability: Stable
*
* Various constants defining parts of the STUN and TURN protocols and
* on-the-wire packet formats.
*/
/**
* STUN_ATTRIBUTE_LENGTH_LEN:
*
* Length of the length field of a STUN attribute (in bytes).
*/
/**
* STUN_ATTRIBUTE_LENGTH_POS:
*
* Offset of the length field of a STUN attribute (in bytes).
*/
/**
* STUN_ATTRIBUTE_TYPE_LEN:
*
* Length of the type field of a STUN attribute (in bytes).
*/
/**
* STUN_ATTRIBUTE_TYPE_POS:
*
* Offset of the type field of a STUN attribute (in bytes).
*/
/**
* STUN_ATTRIBUTE_VALUE_POS:
*
* Offset of the value field of a STUN attribute (in bytes).
*/
/**
* STUN_ID_LEN:
*
* Length of the ID field of a STUN message (in bytes).
*/
/**
* STUN_MAGIC_COOKIE:
*
* Magic cookie value used to identify STUN messages.
*/
/**
* TURN_MAGIC_COOKIE:
*
* Magic cookie value used to identify TURN messages.
*/
/**
* STUN_MAX_MESSAGE_SIZE_IPV4:
*
* Maximum size of a STUN message sent over IPv4 (in bytes).
*/
/**
* STUN_MAX_MESSAGE_SIZE_IPV6:
*
* Maximum size of a STUN message sent over IPv6 (in bytes).
*/
/**
* STUN_MESSAGE_ATTRIBUTES_POS:
*
* Offset of the attributes of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_HEADER_LENGTH:
*
* Total length of a STUN message header (in bytes).
*/
/**
* STUN_MESSAGE_LENGTH_LEN:
*
* Length of the length field of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_LENGTH_POS:
*
* Offset of the length field of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_TRANS_ID_LEN:
*
* Length of the transaction ID field of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_TRANS_ID_POS:
*
* Offset of the transaction ID field of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_TYPE_LEN:
*
* Length of the type field of a STUN message (in bytes).
*/
/**
* STUN_MESSAGE_TYPE_POS:
*
* Offset of the type field of a STUN message (in bytes).
*/
#define STUN_MESSAGE_TYPE_POS 0
#define STUN_MESSAGE_TYPE_LEN 2
#define STUN_MESSAGE_LENGTH_POS \
(STUN_MESSAGE_TYPE_POS + STUN_MESSAGE_TYPE_LEN)
#define STUN_MESSAGE_LENGTH_LEN 2
#define STUN_MESSAGE_TRANS_ID_POS \
(STUN_MESSAGE_LENGTH_POS + STUN_MESSAGE_LENGTH_LEN)
#define STUN_MESSAGE_TRANS_ID_LEN 16
#define STUN_MESSAGE_ATTRIBUTES_POS \
(STUN_MESSAGE_TRANS_ID_POS + STUN_MESSAGE_TRANS_ID_LEN)
#define STUN_MESSAGE_HEADER_LENGTH STUN_MESSAGE_ATTRIBUTES_POS
#define STUN_ATTRIBUTE_TYPE_POS 0
#define STUN_ATTRIBUTE_TYPE_LEN 2
#define STUN_ATTRIBUTE_LENGTH_POS \
(STUN_ATTRIBUTE_TYPE_POS + STUN_ATTRIBUTE_TYPE_LEN)
#define STUN_ATTRIBUTE_LENGTH_LEN 2
#define STUN_ATTRIBUTE_VALUE_POS \
(STUN_ATTRIBUTE_LENGTH_POS + STUN_ATTRIBUTE_LENGTH_LEN)
/**
* STUN_ATTRIBUTE_HEADER_LENGTH:
*
* Length of a single STUN attribute header (in bytes).
*/
#define STUN_ATTRIBUTE_HEADER_LENGTH STUN_ATTRIBUTE_VALUE_POS
#define STUN_MAX_MESSAGE_SIZE_IPV4 576
#define STUN_MAX_MESSAGE_SIZE_IPV6 1280
/* #define STUN_MAX_MESSAGE_SIZE STUN_MAX_MESSAGE_SIZE_IPV4 */
#define STUN_ID_LEN 16
/**
* STUN_AGENT_MAX_SAVED_IDS:
*
* Maximum number of simultaneously ongoing STUN transactions.
*/
#define STUN_AGENT_MAX_SAVED_IDS 200
/**
* STUN_AGENT_MAX_UNKNOWN_ATTRIBUTES:
*
* Maximum number of unknown attribute which can be handled in a single STUN
* message.
*/
#define STUN_AGENT_MAX_UNKNOWN_ATTRIBUTES 256
#define STUN_MAGIC_COOKIE 0x2112A442
#define TURN_MAGIC_COOKIE 0x72c64bc6
#ifndef TRUE
#define TRUE (1 == 1)
#endif
#ifndef FALSE
#define FALSE (0 == 1)
#endif
#endif /* _STUN_CONSTANTS_H */

102
linux_x86/include/stun/debug.h Normal file
View File

@ -0,0 +1,102 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2007 Nokia Corporation. All rights reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef STUN_DEBUG_H
#define STUN_DEBUG_H
#include <stddef.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* stun_debug_enable:
*
* Enable debug messages to stderr
*/
void stun_debug_enable (void);
/**
* stun_debug_disable:
*
* Disable debug messages to stderr
*/
void stun_debug_disable (void);
/**
* StunDebugHandler:
* @format: printf()-style debug message format string
* @ap: Parameters to substitute into message placeholders
*
* Callback for a debug message from the STUN code.
*/
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4))
typedef void (*StunDebugHandler) (const char *format, va_list ap)
__attribute__((__format__ (__printf__, 1, 0)));
#else
typedef void (*StunDebugHandler) (const char *format, va_list ap);
#endif
/**
* stun_set_debug_handler:
* @handler: (nullable): Handler for STUN debug messages, or %NULL to use the
* default
*
* Set a callback function to be invoked for each debug message from the STUN
* code. The callback will only be invoked if STUN debugging is enabled using
* stun_debug_enable().
*
* The default callback prints the formatted debug message to stderr.
*/
void stun_set_debug_handler (StunDebugHandler handler);
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4))
void stun_debug (const char *fmt, ...)
__attribute__((__format__ (__printf__, 1, 2)));
#else
void stun_debug (const char *fmt, ...);
#endif
void stun_debug_bytes (const char *prefix, const void *data, size_t len);
# ifdef __cplusplus
}
# endif
#endif /* STUN_DEBUG_H */

521
linux_x86/include/stun/stunagent.h Normal file
View File

@ -0,0 +1,521 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2008-2009 Nokia Corporation. All rights reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef _STUN_AGENT_H
#define _STUN_AGENT_H
/**
* SECTION:stunagent
* @short_description: STUN agent for building and validating STUN messages
* @include: stun/stunagent.h
* @see_also: #StunMessage
* @stability: Stable
*
* The STUN Agent allows you to create and validate STUN messages easily.
* It's main purpose is to make sure the building and validation methods used
* are compatible with the RFC you create it with. It also tracks the transaction
* ids of the requests you send, so you can validate if a STUN response you
* received should be processed by that agent or not.
*
*/
#ifdef _WIN32
#include "win32_common.h"
#else
#include <stdint.h>
#endif
#include <stdbool.h>
#include <sys/types.h>
/**
* StunAgent:
*
* An opaque structure representing the STUN agent.
*/
typedef struct stun_agent_t StunAgent;
#include "stunmessage.h"
#include "debug.h"
/**
* StunCompatibility:
* @STUN_COMPATIBILITY_RFC3489: Use the STUN specifications compatible with
* RFC 3489
* @STUN_COMPATIBILITY_RFC5389: Use the STUN specifications compatible with
* RFC 5389
* @STUN_COMPATIBILITY_MSICE2: Use the STUN specifications compatible with
* [MS-ICE2] (a mix between RFC3489 and RFC5389)
* @STUN_COMPATIBILITY_OC2007: Use the STUN specifications compatible with
* Microsoft Office Communicator 2007 (basically RFC3489 with swapped
* REALM and NONCE attribute hex IDs, attributes are not aligned)
* @STUN_COMPATIBILITY_WLM2009: An alias for @STUN_COMPATIBILITY_MSICE2
* @STUN_COMPATIBILITY_LAST: Dummy last compatibility mode
*
* Enum that specifies the STUN compatibility mode of the #StunAgent
*
* <warning>@STUN_COMPATIBILITY_WLM2009 is deprecated and should not be used
* in newly-written code. It is kept for compatibility reasons and represents
* the same compatibility as @STUN_COMPATIBILITY_MSICE2.</warning>
*/
typedef enum {
STUN_COMPATIBILITY_RFC3489,
STUN_COMPATIBILITY_RFC5389,
STUN_COMPATIBILITY_MSICE2,
STUN_COMPATIBILITY_OC2007,
STUN_COMPATIBILITY_WLM2009 = STUN_COMPATIBILITY_MSICE2,
STUN_COMPATIBILITY_LAST = STUN_COMPATIBILITY_OC2007
} StunCompatibility;
/**
* StunValidationStatus:
* @STUN_VALIDATION_SUCCESS: The message is validated
* @STUN_VALIDATION_NOT_STUN: This is not a valid STUN message
* @STUN_VALIDATION_INCOMPLETE_STUN: The message seems to be valid but incomplete
* @STUN_VALIDATION_BAD_REQUEST: The message does not have the cookie or the
* fingerprint while the agent needs it with its usage
* @STUN_VALIDATION_UNAUTHORIZED_BAD_REQUEST: The message is valid but
* unauthorized with no username and message-integrity attributes.
* A BAD_REQUEST error must be generated
* @STUN_VALIDATION_UNAUTHORIZED: The message is valid but unauthorized as
* the username/password do not match.
* An UNAUTHORIZED error must be generated
* @STUN_VALIDATION_UNMATCHED_RESPONSE: The message is valid but this is a
* response/error that doesn't match a previously sent request
* @STUN_VALIDATION_UNKNOWN_REQUEST_ATTRIBUTE: The message is valid but
* contains one or more unknown comprehension attributes.
* stun_agent_build_unknown_attributes_error() should be called
* @STUN_VALIDATION_UNKNOWN_ATTRIBUTE: The message is valid but contains one
* or more unknown comprehension attributes. This is a response, or error,
* or indication message and no error response should be sent
*
* This enum is used as the return value of stun_agent_validate() and represents
* the status result of the validation of a STUN message.
*/
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;
/**
* StunAgentUsageFlags:
* @STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS: The agent should be using the short
* term credentials mechanism for authenticating STUN messages
* @STUN_AGENT_USAGE_LONG_TERM_CREDENTIALS: The agent should be using the long
* term credentials mechanism for authenticating STUN messages
* @STUN_AGENT_USAGE_USE_FINGERPRINT: The agent should add the FINGERPRINT
* attribute to the STUN messages it creates.
* @STUN_AGENT_USAGE_ADD_SOFTWARE: The agent should add the SOFTWARE attribute
* to the STUN messages it creates. Calling nice_agent_set_software() will have
* the same effect as enabling this Usage. STUN Indications do not have the
* SOFTWARE attributes added to them though. The SOFTWARE attribute is only
* added for the RFC5389 and MSICE2 compatibility modes.
* @STUN_AGENT_USAGE_IGNORE_CREDENTIALS: The agent should ignore any credentials
* in the STUN messages it receives (the MESSAGE-INTEGRITY attribute
* will never be validated by stun_agent_validate())
* @STUN_AGENT_USAGE_NO_INDICATION_AUTH: The agent should ignore credentials
* in the STUN messages it receives if the #StunClass of the message is
* #STUN_INDICATION (some implementation require #STUN_INDICATION messages to
* be authenticated, while others never add a MESSAGE-INTEGRITY attribute to a
* #STUN_INDICATION message)
* @STUN_AGENT_USAGE_FORCE_VALIDATER: The agent should always try to validate
* the password of a STUN message, even if it already knows what the password
* should be (a response to a previously created request). This means that the
* #StunMessageIntegrityValidate callback will always be called when there is
* a MESSAGE-INTEGRITY attribute.
* @STUN_AGENT_USAGE_NO_ALIGNED_ATTRIBUTES: The agent should not assume STUN
* attributes are aligned on 32-bit boundaries when parsing messages and also
* do not add padding when creating messages.
*
* This enum defines a bitflag usages for a #StunAgent and they will define how
* the agent should behave, independently of the compatibility mode it uses.
* <para> See also: stun_agent_init() </para>
* <para> See also: stun_agent_validate() </para>
*/
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;
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 stun_agent_t {
StunCompatibility compatibility;
StunAgentSavedIds sent_ids[STUN_AGENT_MAX_SAVED_IDS];
uint16_t *known_attributes;
StunAgentUsageFlags usage_flags;
const char *software_attribute;
bool ms_ice2_send_legacy_connchecks;
};
/**
* StunDefaultValidaterData:
* @username: The username
* @username_len: The length of the @username
* @password: The password
* @password_len: The length of the @password
*
* This structure is used as an element of the user_data to the
* stun_agent_default_validater() function for authenticating a STUN
* message during validationg.
* <para> See also: stun_agent_default_validater() </para>
*/
typedef struct {
uint8_t *username;
size_t username_len;
uint8_t *password;
size_t password_len;
} StunDefaultValidaterData;
/**
* StunMessageIntegrityValidate:
* @agent: The #StunAgent
* @message: The #StunMessage being validated
* @username: The username found in the @message
* @username_len: The length of @username
* @password: The password associated with that username. This argument is a
* pointer to a byte array that must be set by the validater function.
* @password_len: The length of @password which must also be set by the
* validater function.
* @user_data: Data to give the function
*
* This is the prototype for the @validater argument of the stun_agent_validate()
* function.
* <para> See also: stun_agent_validate() </para>
* Returns: %TRUE if the authentication was successful,
* %FALSE if the authentication failed
*/
typedef bool (*StunMessageIntegrityValidate) (StunAgent *agent,
StunMessage *message, uint8_t *username, uint16_t username_len,
uint8_t **password, size_t *password_len, void *user_data);
/**
* stun_agent_default_validater:
* @agent: The #StunAgent
* @message: The #StunMessage being validated
* @username: The username found in the @message
* @username_len: The length of @username
* @password: The password associated with that username. This argument is a
* pointer to a byte array that must be set by the validater function.
* @password_len: The length of @password which must also be set by the
* validater function.
* @user_data: This must be an array of #StunDefaultValidaterData structures.
* The last element in the array must have a username set to NULL
*
* This is a helper function to be used with stun_agent_validate(). If no
* complicated processing of the username needs to be done, this function can
* be used with stun_agent_validate() to quickly and easily match the username
* of a STUN message with its password. Its @user_data argument must be an array
* of #StunDefaultValidaterData which will allow us to map a username to a
* password
* <para> See also: stun_agent_validate() </para>
* Returns: %TRUE if the authentication was successful,
* %FALSE if the authentication failed
*/
bool stun_agent_default_validater (StunAgent *agent,
StunMessage *message, uint8_t *username, uint16_t username_len,
uint8_t **password, size_t *password_len, void *user_data);
/**
* stun_agent_init:
* @agent: The #StunAgent to initialize
* @known_attributes: An array of #uint16_t specifying which attributes should
* be known by the agent. Any STUN message received that contains a mandatory
* attribute that is not in this array will yield a
* #STUN_VALIDATION_UNKNOWN_REQUEST_ATTRIBUTE or a
* #STUN_VALIDATION_UNKNOWN_ATTRIBUTE error when calling stun_agent_validate()
* @compatibility: The #StunCompatibility to use for this agent. This will affect
* how the agent builds and validates the STUN messages
* @usage_flags: A bitflag using #StunAgentUsageFlags values to define which
* STUN usages the agent should use.
*
* This function must be called to initialize an agent before it is being used.
*
<note>
<para>
The @known_attributes data must exist in memory as long as the @agent is used
</para>
<para>
If the #STUN_AGENT_USAGE_SHORT_TERM_CREDENTIALS and
#STUN_AGENT_USAGE_LONG_TERM_CREDENTIALS usage flags are not set, then the
agent will default in using the short term credentials mechanism
</para>
<para>
The #STUN_AGENT_USAGE_USE_FINGERPRINT and #STUN_AGENT_USAGE_ADD_SOFTWARE
usage flags are only valid if the #STUN_COMPATIBILITY_RFC5389 or
#STUN_COMPATIBILITY_MSICE2 @compatibility is used
</para>
</note>
*/
void stun_agent_init (StunAgent *agent, const uint16_t *known_attributes,
StunCompatibility compatibility, StunAgentUsageFlags usage_flags);
/**
* stun_agent_validate:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The data buffer of the STUN message
* @buffer_len: The length of @buffer
* @validater: A #StunMessageIntegrityValidate function callback that will
* be called if the agent needs to validate a MESSAGE-INTEGRITY attribute. It
* will only be called if the agent finds a message that needs authentication
* and a USERNAME is present in the STUN message, but no password is known.
* The validater will not be called if the #STUN_AGENT_USAGE_IGNORE_CREDENTIALS
* usage flag is set on the agent, and it will always be called if the
* #STUN_AGENT_USAGE_FORCE_VALIDATER usage flag is set on the agent.
* @validater_data: A user data to give to the @validater callback when it gets
* called.
*
* This function is used to validate an inbound STUN message and transform its
* data buffer into a #StunMessage. It will take care of various validation
* algorithms to make sure that the STUN message is valid and correctly
* authenticated.
* <para> See also: stun_agent_default_validater() </para>
* Returns: A #StunValidationStatus
<note>
<para>
if the return value is different from #STUN_VALIDATION_NOT_STUN or
#STUN_VALIDATION_INCOMPLETE_STUN, then the @msg argument will contain a valid
STUN message that can be used.
This means that you can use the @msg variable as the @request argument to
functions like stun_agent_init_error() or
stun_agent_build_unknown_attributes_error().
If the return value is #STUN_VALIDATION_BAD_REQUEST,
#STUN_VALIDATION_UNAUTHORIZED or #STUN_VALIDATION_UNAUTHORIZED_BAD_REQUEST
then the @key in the #StunMessage will not be set, so that error responses
will not have a MESSAGE-INTEGRITY attribute.
</para>
</note>
*/
StunValidationStatus stun_agent_validate (StunAgent *agent, StunMessage *msg,
const uint8_t *buffer, size_t buffer_len,
StunMessageIntegrityValidate validater, void * validater_data);
/**
* stun_agent_init_request:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The buffer to use in the #StunMessage
* @buffer_len: The length of the buffer
* @m: The #StunMethod of the request
*
* Creates a new STUN message of class #STUN_REQUEST and with the method @m
* Returns: %TRUE if the message was initialized correctly, %FALSE otherwise
*/
bool stun_agent_init_request (StunAgent *agent, StunMessage *msg,
uint8_t *buffer, size_t buffer_len, StunMethod m);
/**
* stun_agent_init_indication:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The buffer to use in the #StunMessage
* @buffer_len: The length of the buffer
* @m: The #StunMethod of the indication
*
* Creates a new STUN message of class #STUN_INDICATION and with the method @m
* Returns: %TRUE if the message was initialized correctly, %FALSE otherwise
*/
bool stun_agent_init_indication (StunAgent *agent, StunMessage *msg,
uint8_t *buffer, size_t buffer_len, StunMethod m);
/**
* stun_agent_init_response:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The buffer to use in the #StunMessage
* @buffer_len: The length of the buffer
* @request: The #StunMessage of class #STUN_REQUEST that this response is for
*
* Creates a new STUN message of class #STUN_RESPONSE and with the same method
* and transaction ID as the message @request. This will also copy the pointer
* to the key that was used to authenticate the request, so you won't need to
* specify the key with stun_agent_finish_message()
* Returns: %TRUE if the message was initialized correctly, %FALSE otherwise
*/
bool stun_agent_init_response (StunAgent *agent, StunMessage *msg,
uint8_t *buffer, size_t buffer_len, const StunMessage *request);
/**
* stun_agent_init_error:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The buffer to use in the #StunMessage
* @buffer_len: The length of the buffer
* @request: The #StunMessage of class #STUN_REQUEST that this error response
* is for
* @err: The #StunError to put in the ERROR-CODE attribute of the error response
*
* Creates a new STUN message of class #STUN_ERROR and with the same method
* and transaction ID as the message @request. This will also copy the pointer
* to the key that was used to authenticate the request (if authenticated),
* so you won't need to specify the key with stun_agent_finish_message().
* It will then add the ERROR-CODE attribute with code @err and the associated
* string.
* Returns: %TRUE if the message was initialized correctly, %FALSE otherwise
*/
bool stun_agent_init_error (StunAgent *agent, StunMessage *msg,
uint8_t *buffer, size_t buffer_len, const StunMessage *request,
StunError err);
/**
* stun_agent_build_unknown_attributes_error:
* @agent: The #StunAgent
* @msg: The #StunMessage to build
* @buffer: The buffer to use in the #StunMessage
* @buffer_len: The length of the buffer
* @request: The #StunMessage of class #STUN_REQUEST that this response is for
*
* Creates a new STUN message of class #STUN_ERROR and with the same method
* and transaction ID as the message @request. It will then add the ERROR-CODE
* attribute with code #STUN_ERROR_UNKNOWN_ATTRIBUTE and add all the unknown
* mandatory attributes from the @request STUN message in the
* #STUN_ATTRIBUTE_UNKNOWN_ATTRIBUTES attribute, it will then finish the message
* by calling stun_agent_finish_message()
* Returns: The size of the message built
*/
size_t stun_agent_build_unknown_attributes_error (StunAgent *agent,
StunMessage *msg, uint8_t *buffer, size_t buffer_len,
const StunMessage *request);
/**
* stun_agent_finish_message:
* @agent: The #StunAgent
* @msg: The #StunMessage to finish
* @key: The key to use for the MESSAGE-INTEGRITY attribute
* @key_len: The length of the @key
*
* This function will 'finish' a message and make it ready to be sent. It will
* add the MESSAGE-INTEGRITY and FINGERPRINT attributes if necessary. If the
* STUN message has a #STUN_REQUEST class, it will save the transaction id of
* the message in the agent for future matching of the response.
* <para>See also: stun_agent_forget_transaction()</para>
* Returns: The final size of the message built or 0 if an error occured
* <note>
<para>
The return value must always be checked. a value of 0 means the either
the buffer's size is too small to contain the finishing attributes
(MESSAGE-INTEGRITY, FINGERPRINT), or that there is no more free slots
for saving the sent id in the agent's state.
</para>
<para>
Everytime stun_agent_finish_message() is called for a #STUN_REQUEST
message, you must make sure to call stun_agent_forget_transaction() in
case the response times out and is never received. This is to avoid
filling up the #StunAgent's sent ids state preventing any further
use of the stun_agent_finish_message()
</para>
</note>
*/
size_t stun_agent_finish_message (StunAgent *agent, StunMessage *msg,
const uint8_t *key, size_t key_len);
/**
* stun_agent_forget_transaction:
* @agent: The #StunAgent
* @id: The #StunTransactionId of the transaction to forget
*
* This function is used to make the #StunAgent forget about a previously
* created transaction.
* <para>
* This function should be called when a STUN request was previously
* created with stun_agent_finish_message() and for which no response was ever
* received (timed out). The #StunAgent keeps a list of the sent transactions
* in order to validate the responses received. If the response is never received
* this will allow the #StunAgent to forget about the timed out transaction and
* free its slot for future transactions.
* </para>
* Since: 0.0.6
* Returns: %TRUE if the transaction was found, %FALSE otherwise
*/
bool stun_agent_forget_transaction (StunAgent *agent, StunTransactionId id);
/**
* stun_agent_set_software:
* @agent: The #StunAgent
* @software: The value of the SOFTWARE attribute to add.
*
* This function will set the value of the SOFTWARE attribute to be added to
* STUN requests, responses and error responses.
* <para>
* Calling this function will automatically enable the addition of the SOFTWARE
* attribute for RFC5389 and MSICE2 compatibility modes.
*
* </para>
* <note>
<para>
The @software argument must be in UTF-8 encoding and only the first
128 characters will be sent.
</para>
<para>
The value of the @software argument must stay valid throughout the life of
the StunAgent's life. Do not free its content.
</para>
</note>
*
* Since: 0.0.10
*
*/
void stun_agent_set_software (StunAgent *agent, const char *software);
#endif /* _STUN_AGENT_H */

1017
linux_x86/include/stun/stunmessage.h Normal file
View File

File diff suppressed because it is too large Load Diff

165
linux_x86/include/stun/usages/bind.h Normal file
View File

@ -0,0 +1,165 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2007-2009 Nokia Corporation. All rights reserved.
* Contact: Rémi Denis-Courmont
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Rémi Denis-Courmont, Nokia
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef STUN_BIND_H
# define STUN_BIND_H 1
/**
* SECTION:bind
* @short_description: STUN Binding Usage
* @include: stun/usages/bind.h
* @stability: Stable
*
* The STUN Binding usage allows for easily creating and parsing STUN Binding
* requests and responses. It offers both an asynchronous and a synchronous API
* that uses the STUN timer usage.
*/
#ifdef _WIN32
# include "../win32_common.h"
#else
# include <stdbool.h>
# include <stdint.h>
#endif
# include "stun/stunagent.h"
# ifdef __cplusplus
extern "C" {
# endif
/**
* StunUsageBindReturn:
* @STUN_USAGE_BIND_RETURN_SUCCESS: The binding usage succeeded
* @STUN_USAGE_BIND_RETURN_ERROR: There was an unknown error in the bind usage
* @STUN_USAGE_BIND_RETURN_INVALID: The message is invalid and should be ignored
* @STUN_USAGE_BIND_RETURN_ALTERNATE_SERVER: The binding request has an
* ALTERNATE-SERVER attribute
* @STUN_USAGE_BIND_RETURN_TIMEOUT: The binding was unsuccessful because it has
* timed out.
*
* Return value of stun_usage_bind_process() and stun_usage_bind_run() which
* allows you to see what status the function call returned.
*/
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;
/**
* stun_usage_bind_create:
* @agent: The #StunAgent to use to create the binding request
* @msg: The #StunMessage to build
* @buffer: The buffer to use for creating the #StunMessage
* @buffer_len: The size of the @buffer
*
* Create a new STUN binding request to use with a STUN server.
* Returns: The length of the built message.
*/
size_t stun_usage_bind_create (StunAgent *agent, StunMessage *msg,
uint8_t *buffer, size_t buffer_len);
/**
* stun_usage_bind_process:
* @msg: The #StunMessage to process
* @addr: A pointer to a #sockaddr structure to fill with the mapped address
* that the STUN server gives us
* @addrlen: The length of @add. rMust be set to the size of the @addr socket
* address and will be set to the actual length of the socket address.
* @alternate_server: A pointer to a #sockaddr structure to fill with the
* address of an alternate server to which we should send our new STUN
* binding request, in case the currently used STUN server is requesting the use
* of an alternate server. This argument will only be filled if the return value
* of the function is #STUN_USAGE_BIND_RETURN_ALTERNATE_SERVER
* @alternate_server_len: The length of @alternate_server. Must be set to
* the size of the @alternate_server socket address and will be set to the
* actual length of the socket address.
*
* Process a STUN binding response and extracts the mapped address from the STUN
* message. Also checks for the ALTERNATE-SERVER attribute.
* Returns: A #StunUsageBindReturn value.
* Note that #STUN_USAGE_BIND_RETURN_TIMEOUT cannot be returned by this function
*/
StunUsageBindReturn stun_usage_bind_process (StunMessage *msg,
struct sockaddr *addr, socklen_t *addrlen,
struct sockaddr *alternate_server, socklen_t *alternate_server_len);
/**
* stun_usage_bind_keepalive:
* @agent: The #StunAgent to use to build the message
* @msg: The #StunMessage to build
* @buf: The buffer to use for creating the #StunMessage
* @len: The size of the @buf
*
* Creates a STUN binding indication that can be used for a keepalive.
* Since this is an indication message, no STUN response will be generated
* and it can only be used as a keepalive message.
* Returns: The length of the message to send
*/
size_t stun_usage_bind_keepalive (StunAgent *agent, StunMessage *msg,
uint8_t *buf, size_t len);
/**
* stun_usage_bind_run:
* @srv: A pointer to the #sockaddr structure representing the STUN server's
* address
* @srvlen: The length of @srv
* @addr: A pointer to a #sockaddr structure to fill with the mapped address
* that the STUN server gives us
* @addrlen: The length of @addr
*
* This is a convenience function that will do a synchronous Binding request to
* a server and wait for its answer. It will create the socket transports and
* use the #StunTimer usage to send the request and handle the response.
* Returns: A #StunUsageBindReturn.
* Possible return values are #STUN_USAGE_BIND_RETURN_SUCCESS,
* #STUN_USAGE_BIND_RETURN_ERROR and #STUN_USAGE_BIND_RETURN_TIMEOUT
*/
StunUsageBindReturn stun_usage_bind_run (const struct sockaddr *srv,
socklen_t srvlen, struct sockaddr_storage *addr, socklen_t *addrlen);
# ifdef __cplusplus
}
# endif
#endif

240
linux_x86/include/stun/usages/ice.h Normal file
View File

@ -0,0 +1,240 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2007-2009 Nokia Corporation. All rights reserved.
* Contact: Rémi Denis-Courmont
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Rémi Denis-Courmont, Nokia
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef STUN_CONNCHECK_H
# define STUN_CONNCHECK_H 1
/**
* SECTION:ice
* @short_description: STUN ICE Usage
* @include: stun/usages/ice.h
* @stability: Stable
*
* The STUN ICE usage allows for easily creating and parsing STUN Binding
* requests and responses used for ICE connectivity checks. The API allows you
* to create a connectivity check message, parse a response or create a reply
* to an incoming connectivity check request.
*/
# include "stun/stunagent.h"
# ifdef __cplusplus
extern "C" {
# endif
/**
* StunUsageIceCompatibility:
* @STUN_USAGE_ICE_COMPATIBILITY_RFC5245: The ICE compatibility with RFC 5245
* @STUN_USAGE_ICE_COMPATIBILITY_GOOGLE: The ICE compatibility with Google's
* implementation of ICE
* @STUN_USAGE_ICE_COMPATIBILITY_MSN: The ICE compatibility with MSN's
* implementation of ICE
* @STUN_USAGE_ICE_COMPATIBILITY_MSICE2: The ICE compatibility with [MS-ICE2]
* specification
* @STUN_USAGE_ICE_COMPATIBILITY_DRAFT19: The ICE compatibility with draft 19
* @STUN_USAGE_ICE_COMPATIBILITY_WLM2009: An alias
* for @STUN_USAGE_ICE_COMPATIBILITY_MSICE2
*
* This enum defines which compatibility modes this ICE usage can use
*
* <warning>@STUN_USAGE_ICE_COMPATIBILITY_DRAFT19 and
* @STUN_USAGE_ICE_COMPATIBILITY_WLM2009 are deprecated and should not be used
* in newly-written code. They are kept for compatibility reasons and represent
* the same compatibilities as @STUN_USAGE_ICE_COMPATIBILITY_RFC5245 and
* @STUN_USAGE_ICE_COMPATIBILITY_MSICE2 respectively.</warning>
*/
typedef enum {
STUN_USAGE_ICE_COMPATIBILITY_RFC5245,
STUN_USAGE_ICE_COMPATIBILITY_GOOGLE,
STUN_USAGE_ICE_COMPATIBILITY_MSN,
STUN_USAGE_ICE_COMPATIBILITY_MSICE2,
STUN_USAGE_ICE_COMPATIBILITY_DRAFT19 = STUN_USAGE_ICE_COMPATIBILITY_RFC5245,
STUN_USAGE_ICE_COMPATIBILITY_WLM2009 = STUN_USAGE_ICE_COMPATIBILITY_MSICE2,
} StunUsageIceCompatibility;
/**
* StunUsageIceReturn:
* @STUN_USAGE_ICE_RETURN_SUCCESS: The function succeeded
* @STUN_USAGE_ICE_RETURN_ERROR: There was an unspecified error
* @STUN_USAGE_ICE_RETURN_INVALID: The message is invalid for processing
* @STUN_USAGE_ICE_RETURN_ROLE_CONFLICT: A role conflict was detected
* @STUN_USAGE_ICE_RETURN_INVALID_REQUEST: The message is an not a request
* @STUN_USAGE_ICE_RETURN_INVALID_METHOD: The method of the request is invalid
* @STUN_USAGE_ICE_RETURN_MEMORY_ERROR: The buffer size is too small to hold
* the STUN reply
* @STUN_USAGE_ICE_RETURN_INVALID_ADDRESS: The mapped address argument has
* an invalid address family
* @STUN_USAGE_ICE_RETURN_NO_MAPPED_ADDRESS: The response is valid but no
* MAPPED-ADDRESS or XOR-MAPPED-ADDRESS attribute was found
*
* Return value of stun_usage_ice_conncheck_process() and
* stun_usage_ice_conncheck_create_reply() which allows you to see what
* status the function call returned.
*/
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;
/**
* stun_usage_ice_conncheck_create:
* @agent: The #StunAgent to use to build the request
* @msg: The #StunMessage to build
* @buffer: The buffer to use for creating the #StunMessage
* @buffer_len: The size of the @buffer
* @username: The username to use in the request
* @username_len: The length of @username
* @password: The key to use for building the MESSAGE-INTEGRITY
* @password_len: The length of @password
* @cand_use: Set to %TRUE to append the USE-CANDIDATE flag to the request
* @controlling: Set to %TRUE if you are the controlling agent or set to
* %FALSE if you are the controlled agent.
* @priority: The value of the PRIORITY attribute
* @tie: The value of the tie-breaker to put in the ICE-CONTROLLED or
* ICE-CONTROLLING attribute
* @candidate_identifier: The foundation value to put in the
* CANDIDATE-IDENTIFIER attribute
* @compatibility: The compatibility mode to use for building the conncheck
* request
*
* Builds an ICE connectivity check STUN message.
* If the compatibility is not #STUN_USAGE_ICE_COMPATIBILITY_RFC5245, the
* @cand_use, @controlling, @priority and @tie arguments are not used.
* If the compatibility is not #STUN_USAGE_ICE_COMPATIBILITY_MSICE2, the
* @candidate_identifier argument is not used.
* Returns: The length of the message built.
*/
size_t
stun_usage_ice_conncheck_create (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);
/**
* stun_usage_ice_conncheck_process:
* @msg: The #StunMessage to process
* @addr: A pointer to a #sockaddr structure to fill with the mapped address
* that the STUN connectivity check response contains
* @addrlen: The length of @addr
* @compatibility: The compatibility mode to use for processing the conncheck
* response
*
* Process an ICE connectivity check STUN message and retrieve the
* mapped address from the message
* <para> See also stun_usage_ice_conncheck_priority() and
* stun_usage_ice_conncheck_use_candidate() </para>
* Returns: A #StunUsageIceReturn value
*/
StunUsageIceReturn stun_usage_ice_conncheck_process (StunMessage *msg,
struct sockaddr_storage *addr, socklen_t *addrlen,
StunUsageIceCompatibility compatibility);
/**
* stun_usage_ice_conncheck_create_reply:
* @agent: The #StunAgent to use to build the response
* @req: The original STUN request to reply to
* @msg: The #StunMessage to build
* @buf: The buffer to use for creating the #StunMessage
* @plen: A pointer containing the size of the @buffer on input.
* Will contain the length of the message built on output.
* @src: A pointer to a #sockaddr structure containing the source address from
* which the request was received. Will be used as the mapped address in the
* response
* @srclen: The length of @addr
* @control: Set to %TRUE if you are the controlling agent or set to
* %FALSE if you are the controlled agent.
* @tie: The value of the tie-breaker to put in the ICE-CONTROLLED or
* ICE-CONTROLLING attribute
* @compatibility: The compatibility mode to use for building the conncheck
* response
*
* Tries to parse a STUN connectivity check request and builds a
* response accordingly.
<note>
<para>
In case of error, the @msg is filled with the appropriate error response
to be sent and the value of @plen is set to the size of that message.
If @plen has a size of 0, then no error response should be sent.
</para>
</note>
* Returns: A #StunUsageIceReturn value
*/
StunUsageIceReturn
stun_usage_ice_conncheck_create_reply (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);
/**
* stun_usage_ice_conncheck_priority:
* @msg: The #StunMessage to parse
*
* Extracts the priority from a STUN message.
* Returns: host byte order priority, or 0 if not specified.
*/
uint32_t stun_usage_ice_conncheck_priority (const StunMessage *msg);
/**
* stun_usage_ice_conncheck_use_candidate:
* @msg: The #StunMessage to parse
*
* Extracts the USE-CANDIDATE attribute flag from a STUN message.
* Returns: %TRUE if the flag is set, %FALSE if not.
*/
bool stun_usage_ice_conncheck_use_candidate (const StunMessage *msg);
# ifdef __cplusplus
}
# endif
#endif

240
linux_x86/include/stun/usages/timer.h Normal file
View File

@ -0,0 +1,240 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2007-2009 Nokia Corporation. All rights reserved.
* Contact: Rémi Denis-Courmont
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Rémi Denis-Courmont, Nokia
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef STUN_TIMER_H
# define STUN_TIMER_H 1
/**
* SECTION:timer
* @short_description: STUN timer Usage
* @include: stun/usages/timer.h
* @stability: Stable
*
* The STUN timer usage is a set of helpful utility functions that allows you
* to easily track when a STUN message should be retransmitted or considered
* as timed out.
*
*
<example>
<title>Simple example on how to use the timer usage</title>
<programlisting>
StunTimer timer;
unsigned remainder;
StunUsageTimerReturn ret;
// Build the message, etc..
...
// Send the message and start the timer
send(socket, request, sizeof(request));
stun_timer_start(&timer, STUN_TIMER_DEFAULT_TIMEOUT,
STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS);
// Loop until we get the response
for (;;) {
remainder = stun_timer_remainder(&timer);
// Poll the socket until data is received or the timer expires
if (poll (&pollfd, 1, delay) <= 0) {
// Time out and no response was received
ret = stun_timer_refresh (&timer);
if (ret == STUN_USAGE_TIMER_RETURN_TIMEOUT) {
// Transaction timed out
break;
} else if (ret == STUN_USAGE_TIMER_RETURN_RETRANSMIT) {
// A retransmission is necessary
send(socket, request, sizeof(request));
continue;
} else if (ret == STUN_USAGE_TIMER_RETURN_SUCCESS) {
// The refresh succeeded and nothing has to be done, continue polling
continue;
}
} else {
// We received a response, read it
recv(socket, response, sizeof(response));
break;
}
}
// Check if the transaction timed out or not
if (ret == STUN_USAGE_TIMER_RETURN_TIMEOUT) {
// do whatever needs to be done in that case
} else {
// Parse the response
}
</programlisting>
</example>
*/
#ifdef _WIN32
#include <winsock2.h>
#else
# include <sys/types.h>
# include <sys/time.h>
# include <time.h>
#endif
/**
* StunTimer:
*
* An opaque structure representing a STUN transaction retransmission timer
*/
typedef struct stun_timer_s StunTimer;
struct stun_timer_s {
struct timeval deadline;
unsigned delay;
unsigned retransmissions;
unsigned max_retransmissions;
};
/**
* STUN_TIMER_DEFAULT_TIMEOUT:
*
* The default intial timeout to use for the timer
* RFC recommendds 500, but it's ridiculous, 50ms is known to work in most
* cases as it is also what is used by SIP style VoIP when sending A-Law and
* mu-Law audio, so 200ms should be hyper safe. With an initial timeout
* of 200ms, a default of 7 transmissions, the last timeout will be
* 16 * 200ms, and we expect to receive a response from the stun server
* before (1 + 2 + 4 + 8 + 16 + 32 + 16) * 200ms = 15200 ms after the initial
* stun request has been sent.
*/
#define STUN_TIMER_DEFAULT_TIMEOUT 200
/**
* STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS:
*
* The default maximum retransmissions allowed before a timer decides to timeout
*/
#define STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS 7
/**
* STUN_TIMER_DEFAULT_RELIABLE_TIMEOUT:
*
* The default intial timeout to use for a reliable timer
*/
#define STUN_TIMER_DEFAULT_RELIABLE_TIMEOUT 7900
/**
* StunUsageTimerReturn:
* @STUN_USAGE_TIMER_RETURN_SUCCESS: The timer was refreshed successfully
* and there is nothing to be done
* @STUN_USAGE_TIMER_RETURN_RETRANSMIT: The timer expired and the message
* should be retransmitted now.
* @STUN_USAGE_TIMER_RETURN_TIMEOUT: The timer expired as well as all the
* retransmissions, the transaction timed out
*
* Return value of stun_usage_timer_refresh() which provides you with status
* information on the timer.
*/
typedef enum {
STUN_USAGE_TIMER_RETURN_SUCCESS,
STUN_USAGE_TIMER_RETURN_RETRANSMIT,
STUN_USAGE_TIMER_RETURN_TIMEOUT
} StunUsageTimerReturn;
# ifdef __cplusplus
extern "C" {
# endif
/**
* stun_timer_start:
* @timer: The #StunTimer to start
* @initial_timeout: The initial timeout to use before the first retransmission
* @max_retransmissions: The maximum number of transmissions before the
* #StunTimer times out
*
* Starts a STUN transaction retransmission timer.
* This should be called as soon as you send the message for the first time on
* a UDP socket.
* The timeout before the next retransmission is set to @initial_timeout, then
* each time a packet is retransmited, that timeout will be doubled, until the
* @max_retransmissions retransmissions limit is reached.
* <para>
* To determine the total timeout value, one can use the following equation :
<programlisting>
total_timeout = initial_timeout * (2^(max_retransmissions + 1) - 1);
</programlisting>
* </para>
*
* See also: #STUN_TIMER_DEFAULT_TIMEOUT
*
* See also: #STUN_TIMER_DEFAULT_MAX_RETRANSMISSIONS
*/
void stun_timer_start (StunTimer *timer, unsigned int initial_timeout,
unsigned int max_retransmissions);
/**
* stun_timer_start_reliable:
* @timer: The #StunTimer to start
* @initial_timeout: The initial timeout to use before the first retransmission
*
* Starts a STUN transaction retransmission timer for a reliable transport.
* This should be called as soon as you send the message for the first time on
* a TCP socket
*/
void stun_timer_start_reliable (StunTimer *timer, unsigned int initial_timeout);
/**
* stun_timer_refresh:
* @timer: The #StunTimer to refresh
*
* Updates a STUN transaction retransmission timer.
* Returns: A #StunUsageTimerReturn telling you what to do next
*/
StunUsageTimerReturn stun_timer_refresh (StunTimer *timer);
/**
* stun_timer_remainder:
* @timer: The #StunTimer to query
*
* Query the timer on the time left before the next refresh should be done
* Returns: The time remaining for the timer to expire in milliseconds
*/
unsigned stun_timer_remainder (const StunTimer *timer);
# ifdef __cplusplus
}
# endif
#endif /* !STUN_TIMER_H */

301
linux_x86/include/stun/usages/turn.h Normal file
View File

@ -0,0 +1,301 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2007-2009 Nokia Corporation. All rights reserved.
* Contact: Rémi Denis-Courmont
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Rémi Denis-Courmont, Nokia
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
#ifndef STUN_TURN_H
# define STUN_TURN_H 1
/**
* SECTION:turn
* @short_description: TURN Allocation Usage
* @include: stun/usages/turn.h
* @stability: Stable
*
* The STUN TURN usage allows for easily creating and parsing STUN Allocate
* requests and responses used for TURN. The API allows you to create a new
* allocation or refresh an existing one as well as to parse a response to
* an allocate or refresh request.
*/
#ifdef _WIN32
# include "../win32_common.h"
#else
# include <stdbool.h>
# include <stdint.h>
#endif
#ifdef _WIN32
#include <winsock2.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#endif
# include "stun/stunagent.h"
# ifdef __cplusplus
extern "C" {
# endif
/**
* StunUsageTurnRequestPorts:
* @STUN_USAGE_TURN_REQUEST_PORT_NORMAL: Request a normal port
* @STUN_USAGE_TURN_REQUEST_PORT_EVEN: Request an even port
* @STUN_USAGE_TURN_REQUEST_PORT_EVEN_AND_RESERVE: Request an even port and
* reserve the next higher port
*
* This enum is used to specify which port configuration you want when creating
* a new Allocation
*/
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;
/**
* StunUsageTurnCompatibility:
* @STUN_USAGE_TURN_COMPATIBILITY_DRAFT9: Use the specification compatible with
* TURN Draft 09
* @STUN_USAGE_TURN_COMPATIBILITY_GOOGLE: Use the specification compatible with
* Google Talk's relay server
* @STUN_USAGE_TURN_COMPATIBILITY_MSN: Use the specification compatible with
* MSN TURN servers
* @STUN_USAGE_TURN_COMPATIBILITY_OC2007: Use the specification compatible with
* Microsoft Office Communicator 2007
* @STUN_USAGE_TURN_COMPATIBILITY_RFC5766: Use the specification compatible with
* RFC 5766 (the final, canonical TURN standard)
*
* Specifies which TURN specification compatibility to use
*/
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;
/**
* StunUsageTurnReturn:
* @STUN_USAGE_TURN_RETURN_RELAY_SUCCESS: The response was successful and a relay
* address is provided
* @STUN_USAGE_TURN_RETURN_MAPPED_SUCCESS: The response was successful and a
* relay address as well as a mapped address are provided
* @STUN_USAGE_TURN_RETURN_ERROR: The response resulted in an error
* @STUN_USAGE_TURN_RETURN_INVALID: The response is not a valid response
* @STUN_USAGE_TURN_RETURN_ALTERNATE_SERVER: The server requests the message
* to be sent to an alternate server
*
* Return value of stun_usage_turn_process() and
* stun_usage_turn_refresh_process() which allows you to see what status the
* function call returned.
*/
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;
/**
* stun_usage_turn_create:
* @agent: The #StunAgent to use to build the request
* @msg: The #StunMessage to build
* @buffer: The buffer to use for creating the #StunMessage
* @buffer_len: The size of the @buffer
* @previous_response: If this is the first request you are sending, set this
* argument to NULL, if it's a subsequent request you are building, then set this
* argument to the response you have received. This argument is used for building
* long term credentials (using the REALM and NONCE attributes) as well as for
* getting the RESERVATION-TOKEN attribute when you previously requested an
* allocation which reserved two ports
* @request_ports: Specify how you want to request the allocated port(s).
* This is only used if the compatibility is set to
* #STUN_USAGE_TURN_COMPATIBILITY_DRAFT9
* <para>See #StunUsageTurnRequestPorts </para>
* @bandwidth: The bandwidth to request from the server for the allocation. If
* this value is negative, then no BANDWIDTH attribute is added to the request.
* This is only used if the compatibility is set to
* #STUN_USAGE_TURN_COMPATIBILITY_DRAFT9
* @lifetime: The lifetime of the allocation to request from the server. If
* this value is negative, then no LIFETIME attribute is added to the request.
* This is only used if the compatibility is set to
* #STUN_USAGE_TURN_COMPATIBILITY_DRAFT9
* @username: The username to use in the request
* @username_len: The length of @username
* @password: The key to use for building the MESSAGE-INTEGRITY
* @password_len: The length of @password
* @compatibility: The compatibility mode to use for building the Allocation
* request
*
* Create a new TURN Allocation request
* Returns: The length of the message to send
*/
size_t stun_usage_turn_create (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);
/**
* stun_usage_turn_create_refresh:
* @agent: The #StunAgent to use to build the request
* @msg: The #StunMessage to build
* @buffer: The buffer to use for creating the #StunMessage
* @buffer_len: The size of the @buffer
* @previous_response: If this is the first request you are sending, set this
* argument to NULL, if it's a subsequent request you are building, then set this
* argument to the response you have received. This argument is used for building
* long term credentials (using the REALM and NONCE attributes)
* @lifetime: The lifetime of the allocation to request from the server. If
* this value is negative, then no LIFETIME attribute is added to the request.
* This is only used if the compatibility is set to
* #STUN_USAGE_TURN_COMPATIBILITY_DRAFT9
* @username: The username to use in the request
* @username_len: The length of @username
* @password: The key to use for building the MESSAGE-INTEGRITY
* @password_len: The length of @password
* @compatibility: The compatibility mode to use for building the Allocation
* request
*
* Create a new TURN Refresh request
* Returns: The length of the message to send
*/
size_t stun_usage_turn_create_refresh (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);
/**
* stun_usage_turn_create_permission:
* @agent: The #StunAgent to use to build the request
* @msg: The #StunMessage to build
* @buffer: The buffer to use for creating the #StunMessage
* @buffer_len: The size of the @buffer
* @username: The username to use in the request
* @username_len: The length of @username
* @password: The key to use for building the MESSAGE-INTEGRITY
* @password_len: The length of @password
* @realm: The realm identifier to use in the request
* @realm_len: The length of @realm
* @nonce: Unique and securely random nonce to use in the request
* @nonce_len: The length of @nonce
* @peer: Server-reflexive host address to request permission for
* @compatibility: The compatibility mode to use for building the
* CreatePermission request
*
* Create a new TURN CreatePermission request
*
* Returns: The length of the message to send
*/
size_t stun_usage_turn_create_permission (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);
/**
* stun_usage_turn_process:
* @msg: The message containing the response
* @relay_addr: A pointer to a #sockaddr structure to fill with the relay address
* that the TURN server allocated for us
* @relay_addrlen: The length of @relay_addr
* @addr: A pointer to a #sockaddr structure to fill with the mapped address
* that the STUN response contains.
* This argument will only be filled if the return value
* of the function is #STUN_USAGE_TURN_RETURN_MAPPED_SUCCESS
* @addrlen: The length of @addr
* @alternate_server: A pointer to a #sockaddr structure to fill with the
* address of an alternate server to which we should send our new STUN
* Allocate request, in case the currently used TURN server is requesting the use
* of an alternate server. This argument will only be filled if the return value
* of the function is #STUN_USAGE_TURN_RETURN_ALTERNATE_SERVER
* In the case of @STUN_USAGE_TURN_COMPATIBILITY_OC2007 compatibility, the
* @alternate_server could be filled at any time, and should only be considered
* if the request was sent to a different server than the address returned
* in the @alternate_server field
* @alternate_server_len: The length of @alternate_server
* @bandwidth: A pointer to fill with the bandwidth the TURN server allocated us
* @lifetime: A pointer to fill with the lifetime of the allocation
* @compatibility: The compatibility mode to use for processing the Allocation
* response
*
* Process a TURN Allocate response and extract the necessary information from
* the message
* Returns: A #StunUsageTurnReturn value
*/
StunUsageTurnReturn stun_usage_turn_process (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);
/**
* stun_usage_turn_refresh_process:
* @msg: The message containing the response
* @lifetime: A pointer to fill with the lifetime of the allocation
* @compatibility: The compatibility mode to use for processing the Refresh
* response
*
* Process a TURN Refresh response and extract the necessary information from
* the message
* Returns: A #StunUsageTurnReturn value. A #STUN_USAGE_TURN_RETURN_RELAY_SUCCESS
* means the Refresh was successful, but no relay address is given (kept the same
* as for the original allocation)
*/
StunUsageTurnReturn stun_usage_turn_refresh_process (StunMessage *msg,
uint32_t *lifetime, StunUsageTurnCompatibility compatibility);
# ifdef __cplusplus
}
# endif
#endif

74
linux_x86/include/stun/win32_common.h Normal file
View File

@ -0,0 +1,74 @@
/*
* This file is part of the Nice GLib ICE library.
*
* (C) 2008-2009 Collabora Ltd.
* Contact: Youness Alaoui
* (C) 2008-2009 Nokia Corporation. All rights reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Nice GLib ICE library.
*
* The Initial Developers of the Original Code are Collabora Ltd and Nokia
* Corporation. All Rights Reserved.
*
* Contributors:
* Youness Alaoui, Collabora Ltd.
* Danny Smith
*
* Alternatively, the contents of this file may be used under the terms of the
* the GNU Lesser General Public License Version 2.1 (the "LGPL"), in which
* case the provisions of LGPL are applicable instead of those above. If you
* wish to allow use of your version of this file only under the terms of the
* LGPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replace
* them with the notice and other provisions required by the LGPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the LGPL.
*/
/* ISO C9x 7.18 Integer types <stdint.h>
* Based on ISO/IEC SC22/WG14 9899 Committee draft (SC22 N2794)
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* Contributor: Danny Smith <danny_r_smith_2001@yahoo.co.nz>
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAIMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Date: 2000-12-02
*/
#ifndef _WIN32_COMMON_H
#define _WIN32_COMMON_H
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
/* On MSVC, ssize_t is SSIZE_T */
#ifdef _MSC_VER
#include <BaseTsd.h>
#define ssize_t SSIZE_T
#endif
/* Windows v10.0.16232 SDK defines MSG_ERRQUEUE, but doesn't support it with
* recvmsg, and also uses a different msghdr struct */
#undef MSG_ERRQUEUE
#endif /* _WIN32_COMMON_H */

41
linux_x86/lib/libnice.la Executable file
View File

@ -0,0 +1,41 @@
# libnice.la - a libtool library file
# Generated by libtool (GNU libtool) 2.4.2 Debian-2.4.2-1.7ubuntu1
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='libnice.so.10'
# Names of this library.
library_names='libnice.so.10.9.0 libnice.so.10 libnice.so'
# The name of the static archive.
old_library=''
# Linker flags that can not go in dependency_libs.
inherited_linker_flags=''
# Libraries that this one depends upon.
dependency_libs=' -L/root/libnice/../boringssl/crypto/ -L/root/libnice/../boringssl/ssl/ -lrt -lz -lpthread -ldl -lresolv -lcrypto -lssl'
# Names of additional weak libraries provided by this library
weak_library_names=''
# Version information for libnice.
current=19
age=9
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='/root/libnice/packages/lib'

1
linux_x86/lib/libnice.so Symbolic link
View File

@ -0,0 +1 @@
libnice.so.10.9.0

1
linux_x86/lib/libnice.so.10 Symbolic link
View File

@ -0,0 +1 @@
libnice.so.10.9.0

BIN
linux_x86/lib/libnice.so.10.9.0 Executable file
View File

Binary file not shown.

13
linux_x86/lib/pkgconfig/nice.pc Normal file
View File

@ -0,0 +1,13 @@
prefix=/root/libnice/packages
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
upnp_enabled=
Name: libnice
Description: ICE library
Version: 0.1.16.1
Requires: glib-2.0 >= 2.54 gio-2.0 >= 2.54 gobject-2.0 >= 2.54
Requires.private: gthread-2.0 libcrypto
Libs: -L${libdir} -lnice
Cflags: -I${includedir}/nice -I${includedir}