@voipsdk/react-native-voipcloud 1.0.0 → 1.0.2

package/ios/VoipCloud.xcframework/ios-arm64/Headers/pjnath/turn_sock.h

@@ -0,0 +1,673 @@
+/* 
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+#ifndef __PJNATH_TURN_SOCK_H__
+#define __PJNATH_TURN_SOCK_H__
+
+/**
+ * @file turn_sock.h
+ * @brief TURN relay using UDP client as transport protocol
+ */
+#include <pjnath/turn_session.h>
+#include <pj/sock_qos.h>
+#include <pj/ssl_sock.h>
+
+
+PJ_BEGIN_DECL
+
+
+/* **************************************************************************/
+/**
+@addtogroup PJNATH_TURN_SOCK
+@{
+
+This is a ready to use object for relaying application data via a TURN server,
+by managing all the operations in \ref turn_op_sec.
+
+\section turnsock_using_sec Using TURN transport
+
+This object provides a thin wrapper to the \ref PJNATH_TURN_SESSION, hence the
+API is very much the same (apart from the obvious difference in the names).
+Please see \ref PJNATH_TURN_SESSION for the documentation on how to use the
+session.
+
+\section turnsock_samples_sec Samples
+
+The \ref turn_client_sample is a sample application to use the
+\ref PJNATH_TURN_SOCK.
+
+Also see <b>\ref samples_page</b> for other samples.
+
+ */
+
+
+/** 
+ * Opaque declaration for TURN client.
+ */
+typedef struct pj_turn_sock pj_turn_sock;
+
+/**
+ * This structure contains callbacks that will be called by the TURN
+ * transport.
+ */
+typedef struct pj_turn_sock_cb
+{
+    /**
+     * Notification when incoming data has been received from the remote
+     * peer via the TURN server. The data reported in this callback will
+     * be the exact data as sent by the peer (e.g. the TURN encapsulation
+     * such as Data Indication or ChannelData will be removed before this
+     * function is called).
+     *
+     * @param turn_sock     The TURN client transport.
+     * @param data          The data as received from the peer.    
+     * @param data_len      Length of the data.
+     * @param peer_addr     The peer address.
+     * @param addr_len      The length of the peer address.
+     */
+    void (*on_rx_data)(pj_turn_sock *turn_sock,
+                       void *pkt,
+                       unsigned pkt_len,
+                       const pj_sockaddr_t *peer_addr,
+                       unsigned addr_len);
+
+    /**
+     * Notifification when asynchronous send operation has completed.
+     *
+     * @param turn_sock     The TURN transport.
+     * @param sent          If value is positive non-zero it indicates the
+     *                      number of data sent. When the value is negative,
+     *                      it contains the error code which can be retrieved
+     *                      by negating the value (i.e. status=-sent).
+     *
+     * @return              Application should normally return PJ_TRUE to let
+     *                      the TURN transport continue its operation. However
+     *                      it must return PJ_FALSE if it has destroyed the
+     *                      TURN transport in this callback.
+     */
+    pj_bool_t (*on_data_sent)(pj_turn_sock *sock,
+                              pj_ssize_t sent);
+
+    /**
+     * Notification when TURN session state has changed. Application should
+     * implement this callback to monitor the progress of the TURN session.
+     *
+     * @param turn_sock     The TURN client transport.
+     * @param old_state     Previous state.
+     * @param new_state     Current state.
+     */
+    void (*on_state)(pj_turn_sock *turn_sock, 
+                     pj_turn_state_t old_state,
+                     pj_turn_state_t new_state);
+
+    /**
+     * Notification when TURN client received a ConnectionAttempt Indication
+     * from the TURN server, which indicates that peer initiates a TCP
+     * connection to allocated slot in the TURN server. Application should
+     * implement this callback if it uses RFC 6062 (TURN TCP allocations),
+     * otherwise TURN client will automatically accept it.
+     *
+     * If application accepts the peer connection attempt (i.e: by returning
+     * PJ_SUCCESS or not implementing this callback), the TURN socket will
+     * initiate a new connection to the TURN server and send ConnectionBind
+     * request, and eventually will notify application via
+     * on_connection_status callback, if implemented.
+     *
+     * @param turn_sock     The TURN client transport.
+     * @param conn_id       The connection ID assigned by TURN server.
+     * @param peer_addr     Peer address that tried to connect to the
+     *                      TURN server.
+     * @param addr_len      Length of the peer address.
+     *
+     * @return              The callback must return PJ_SUCCESS to accept
+     *                      the connection attempt.
+     */
+    pj_status_t (*on_connection_attempt)(pj_turn_sock *turn_sock,
+                                         pj_uint32_t conn_id,
+                                         const pj_sockaddr_t *peer_addr,
+                                         unsigned addr_len);
+
+    /**
+     * Notification for initiated TCP data connection to peer (RFC 6062),
+     * for example after peer connection attempt is accepted.
+     *
+     * @param turn_sock     The TURN client transport.
+     * @param status        The status code.
+     * @param conn_id       The connection ID.
+     * @param peer_addr     Peer address.
+     * @param addr_len      Length of the peer address.
+     */
+    void (*on_connection_status)(pj_turn_sock *turn_sock,
+                                 pj_status_t status,
+                                 pj_uint32_t conn_id,
+                                 const pj_sockaddr_t *peer_addr,
+                                 unsigned addr_len);
+
+} pj_turn_sock_cb;
+
+
+/**
+ * The default enabled SSL proto to be used.
+ * Default is all protocol above TLSv1 (TLSv1 & TLS v1.1 & TLS v1.2).
+ */
+#ifndef PJ_TURN_TLS_DEFAULT_PROTO
+#   define PJ_TURN_TLS_DEFAULT_PROTO  (PJ_SSL_SOCK_PROTO_TLS1 | \
+                                       PJ_SSL_SOCK_PROTO_TLS1_1 | \
+                                       PJ_SSL_SOCK_PROTO_TLS1_2)
+#endif
+
+/**
+ * TLS transport settings.
+ */
+typedef struct pj_turn_sock_tls_cfg
+{
+    /**
+     * Certificate of Authority (CA) list file.
+     */
+    pj_str_t    ca_list_file;
+
+    /**
+     * Certificate of Authority (CA) list directory path.
+     */
+    pj_str_t    ca_list_path;
+
+    /**
+     * Public endpoint certificate file, which will be used as client-
+     * side  certificate for outgoing TLS connection.
+     */
+    pj_str_t    cert_file;
+
+    /**
+     * Optional private key of the endpoint certificate to be used.
+     */
+    pj_str_t    privkey_file;
+
+    /**
+     * Certificate of Authority (CA) buffer. If ca_list_file, ca_list_path,
+     * cert_file or privkey_file are set, this setting will be ignored.
+     */
+    pj_ssl_cert_buffer ca_buf;
+
+    /**
+     * Public endpoint certificate buffer, which will be used as client-
+     * side  certificate for outgoing TLS connection, and server-side
+     * certificate for incoming TLS connection. If ca_list_file, ca_list_path,
+     * cert_file or privkey_file are set, this setting will be ignored.
+     */
+    pj_ssl_cert_buffer cert_buf;
+
+    /**
+     * Optional private key buffer of the endpoint certificate to be used. 
+     * If ca_list_file, ca_list_path, cert_file or privkey_file are set, 
+     * this setting will be ignored.
+     */
+    pj_ssl_cert_buffer privkey_buf;
+
+    /**
+     * Password to open private key.
+     */
+    pj_str_t    password;
+
+    /**
+     * The ssl socket parameter.
+     * These fields are used by TURN TLS:
+     * - proto
+     * - ciphers_num
+     * - ciphers
+     * - curves_num
+     * - curves
+     * - sigalgs
+     * - entropy_type
+     * - entropy_path
+     * - timeout
+     * - sockopt_params
+     * - sockopt_ignore_error
+     * - enable_renegotiation
+     */
+    pj_ssl_sock_param ssock_param;
+
+} pj_turn_sock_tls_cfg;
+
+/**
+ * Initialize TLS setting with default values.
+ *
+ * @param tls_cfg   The TLS setting to be initialized.
+ */
+ PJ_DECL(void) pj_turn_sock_tls_cfg_default(pj_turn_sock_tls_cfg *tls_cfg);
+
+/**
+ * Duplicate TLS setting.
+ *
+ * @param pool      The pool to duplicate strings etc.
+ * @param dst       Destination structure.
+ * @param src       Source structure.
+ */
+ PJ_DECL(void) pj_turn_sock_tls_cfg_dup(pj_pool_t *pool,
+                                        pj_turn_sock_tls_cfg *dst,
+                                        const pj_turn_sock_tls_cfg *src);
+
+/**
+ * Wipe out certificates and keys in the TLS setting.
+ *
+ * @param tls_cfg   The TLS setting.
+ */
+PJ_DECL(void) pj_turn_sock_tls_cfg_wipe_keys(pj_turn_sock_tls_cfg *tls_cfg);
+
+
+/**
+ * This structure describes options that can be specified when creating
+ * the TURN socket. Application should call #pj_turn_sock_cfg_default()
+ * to initialize this structure with its default values before using it.
+ */
+typedef struct pj_turn_sock_cfg
+{
+    /**
+     * The group lock to be used by the STUN socket. If NULL, the STUN socket
+     * will create one internally.
+     *
+     * Default: NULL
+     */
+    pj_grp_lock_t *grp_lock;
+
+    /**
+     * Packet buffer size.
+     *
+     * Default value is PJ_TURN_MAX_PKT_LEN.
+     */
+    unsigned max_pkt_size;
+
+    /**
+     * QoS traffic type to be set on this transport. When application wants
+     * to apply QoS tagging to the transport, it's preferable to set this
+     * field rather than \a qos_param fields since this is more portable.
+     *
+     * Default value is PJ_QOS_TYPE_BEST_EFFORT.
+     */
+    pj_qos_type qos_type;
+
+    /**
+     * Set the low level QoS parameters to the transport. This is a lower
+     * level operation than setting the \a qos_type field and may not be
+     * supported on all platforms.
+     *
+     * By default all settings in this structure are not set.
+     */
+    pj_qos_params qos_params;
+
+    /**
+     * Specify if STUN socket should ignore any errors when setting the QoS
+     * traffic type/parameters.
+     *
+     * Default: PJ_TRUE
+     */
+    pj_bool_t qos_ignore_error;
+
+    /**
+     * Specify the interface where the socket should be bound to. If the
+     * address is zero, socket will be bound to INADDR_ANY. If the address
+     * is non-zero, socket will be bound to this address only. If the port is
+     * set to zero, the socket will bind at any port (chosen by the OS).
+     */
+    pj_sockaddr bound_addr;
+
+    /**
+     * Specify the port range for TURN socket binding, relative to the start
+     * port number specified in \a bound_addr. Note that this setting is only
+     * applicable when the start port number is non zero.
+     *
+     * Default value is zero.
+     */
+    pj_uint16_t port_range;
+
+    /**
+     * Specify target value for socket receive buffer size. It will be
+     * applied using setsockopt(). When it fails to set the specified size,
+     * it will try with lower value until the highest possible has been
+     * successfully set.
+     *
+     * Default: 0 (OS default)
+     */
+    unsigned so_rcvbuf_size;
+
+    /**
+     * Specify target value for socket send buffer size. It will be
+     * applied using setsockopt(). When it fails to set the specified size,
+     * it will try with lower value until the highest possible has been
+     * successfully set.
+     *
+     * Default: 0 (OS default)
+     */
+    unsigned so_sndbuf_size;
+
+    /**
+     * This specifies TLS settings for TLS transport. It is only be used
+     * when this TLS is used to connect to the TURN server.
+     */
+    pj_turn_sock_tls_cfg tls_cfg;
+
+} pj_turn_sock_cfg;
+
+
+/**
+ * Initialize pj_turn_sock_cfg structure with default values.
+ */
+PJ_DECL(void) pj_turn_sock_cfg_default(pj_turn_sock_cfg *cfg);
+
+
+/**
+ * Create a TURN transport instance with the specified address family and
+ * connection type. Once TURN transport instance is created, application
+ * must call pj_turn_sock_alloc() to allocate a relay address in the TURN
+ * server.
+ *
+ * @param cfg           The STUN configuration which contains among other
+ *                      things the ioqueue and timer heap instance for
+ *                      the operation of this transport.
+ * @param af            Address family of the client connection. Currently
+ *                      pj_AF_INET() and pj_AF_INET6() are supported.
+ * @param conn_type     Connection type to the TURN server. Both TCP and
+ *                      UDP are supported.
+ * @param cb            Callback to receive events from the TURN transport.
+ * @param setting       Optional settings to be specified to the transport.
+ *                      If this parameter is NULL, default values will be
+ *                      used.
+ * @param user_data     Arbitrary application data to be associated with
+ *                      this transport.
+ * @param p_turn_sock   Pointer to receive the created instance of the
+ *                      TURN transport.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_create(pj_stun_config *cfg,
+                                         int af,
+                                         pj_turn_tp_type conn_type,
+                                         const pj_turn_sock_cb *cb,
+                                         const pj_turn_sock_cfg *setting,
+                                         void *user_data,
+                                         pj_turn_sock **p_turn_sock);
+
+/**
+ * Destroy the TURN transport instance. This will gracefully close the
+ * connection between the client and the TURN server. Although this
+ * function will return immediately, the TURN socket deletion may continue
+ * in the background and the application may still get state changes
+ * notifications from this transport.
+ *
+ * @param turn_sock     The TURN transport instance.
+ */
+PJ_DECL(void) pj_turn_sock_destroy(pj_turn_sock *turn_sock);
+
+
+/**
+ * Associate a user data with this TURN transport. The user data may then
+ * be retrieved later with #pj_turn_sock_get_user_data().
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param user_data     Arbitrary data.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_set_user_data(pj_turn_sock *turn_sock,
+                                                void *user_data);
+
+/**
+ * Retrieve the previously assigned user data associated with this TURN
+ * transport.
+ *
+ * @param turn_sock     The TURN transport instance.
+ *
+ * @return              The user/application data.
+ */
+PJ_DECL(void*) pj_turn_sock_get_user_data(pj_turn_sock *turn_sock);
+
+
+/**
+ * Get the group lock for this TURN transport.
+ *
+ * @param turn_sock     The TURN transport instance.
+ *
+ * @return              The group lock.
+ */
+PJ_DECL(pj_grp_lock_t *) pj_turn_sock_get_grp_lock(pj_turn_sock *turn_sock);
+
+
+/**
+ * Get the TURN transport info. The transport info contains, among other
+ * things, the allocated relay address.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param info          Pointer to be filled with TURN transport info.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_get_info(pj_turn_sock *turn_sock,
+                                           pj_turn_session_info *info);
+
+/**
+ * Acquire the internal mutex of the TURN transport. Application may need
+ * to call this function to synchronize access to other objects alongside 
+ * the TURN transport, to avoid deadlock.
+ *
+ * @param turn_sock     The TURN transport instance.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_lock(pj_turn_sock *turn_sock);
+
+
+/**
+ * Release the internal mutex previously held with pj_turn_sock_lock().
+ *
+ * @param turn_sock     The TURN transport instance.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_unlock(pj_turn_sock *turn_sock);
+
+
+/**
+ * Set STUN message logging for this TURN session. 
+ * See #pj_stun_session_set_log().
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param flags         Bitmask combination of #pj_stun_sess_msg_log_flag
+ */
+PJ_DECL(void) pj_turn_sock_set_log(pj_turn_sock *turn_sock,
+                                   unsigned flags);
+
+/**
+ * Configure the SOFTWARE name to be sent in all STUN requests by the
+ * TURN session.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param sw        Software name string. If this argument is NULL or
+ *                  empty, the session will not include SOFTWARE attribute
+ *                  in STUN requests and responses.
+ *
+ * @return          PJ_SUCCESS on success, or the appropriate error code.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_set_software_name(pj_turn_sock *turn_sock,
+                                                    const pj_str_t *sw);
+
+
+/**
+ * Allocate a relay address/resource in the TURN server. This function
+ * will resolve the TURN server using DNS SRV (if desired) and send TURN
+ * \a Allocate request using the specified credential to allocate a relay
+ * address in the server. This function completes asynchronously, and
+ * application will be notified when the allocation process has been
+ * successful in the \a on_state() callback when the state is set to
+ * PJ_TURN_STATE_READY. If the allocation fails, the state will be set
+ * to PJ_TURN_STATE_DEALLOCATING or greater.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param domain        The domain, hostname, or IP address of the TURN
+ *                      server. When this parameter contains domain name,
+ *                      the \a resolver parameter must be set to activate
+ *                      DNS SRV resolution.
+ * @param default_port  The default TURN port number to use when DNS SRV
+ *                      resolution is not used. If DNS SRV resolution is
+ *                      used, the server port number will be set from the
+ *                      DNS SRV records.
+ * @param resolver      If this parameter is not NULL, then the \a domain
+ *                      parameter will be first resolved with DNS SRV and
+ *                      then fallback to using DNS A/AAAA resolution when
+ *                      DNS SRV resolution fails. If this parameter is
+ *                      NULL, the \a domain parameter will be resolved as
+ *                      hostname.
+ * @param cred          The STUN credential to be used for the TURN server.
+ * @param param         Optional TURN allocation parameter.
+ *
+ * @return              PJ_SUCCESS if the operation has been successfully
+ *                      queued, or the appropriate error code on failure.
+ *                      When this function returns PJ_SUCCESS, the final
+ *                      result of the allocation process will be notified
+ *                      to application in \a on_state() callback.
+ *                      
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_alloc(pj_turn_sock *turn_sock,
+                                        const pj_str_t *domain,
+                                        int default_port,
+                                        pj_dns_resolver *resolver,
+                                        const pj_stun_auth_cred *cred,
+                                        const pj_turn_alloc_param *param);
+
+/**
+ * Create or renew permission in the TURN server for the specified peer IP
+ * addresses. Application must install permission for a particular (peer)
+ * IP address before it sends any data to that IP address, or otherwise
+ * the TURN server will drop the data.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param addr_cnt      Number of IP addresses.
+ * @param addr          Array of peer IP addresses. Only the address family
+ *                      and IP address portion of the socket address matter.
+ * @param options       Specify 1 to let the TURN client session automatically
+ *                      renew the permission later when they are about to
+ *                      expire.
+ *
+ * @return              PJ_SUCCESS if the operation has been successfully
+ *                      issued, or the appropriate error code. Note that
+ *                      the operation itself will complete asynchronously.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_set_perm(pj_turn_sock *turn_sock,
+                                           unsigned addr_cnt,
+                                           const pj_sockaddr addr[],
+                                           unsigned options);
+
+/**
+ * Send a data to the specified peer address via the TURN relay. This 
+ * function will encapsulate the data as STUN Send Indication or TURN
+ * ChannelData packet and send the message to the TURN server. The TURN
+ * server then will send the data to the peer.
+ *
+ * The allocation (pj_turn_sock_alloc()) must have been successfully
+ * created before application can relay any data.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param pkt           The data/packet to be sent to peer.
+ * @param pkt_len       Length of the data.
+ * @param peer_addr     The remote peer address (the ultimate destination
+ *                      of the data, and not the TURN server address).
+ * @param addr_len      Length of the address.
+ *
+ * @return              PJ_SUCCESS if data has been sent immediately, or
+ *                      PJ_EPENDING if data cannot be sent immediately. In
+ *                      this case the \a on_data_sent() callback will be
+ *                      called when data is actually sent. Any other return
+ *                      value indicates error condition.
+ */ 
+PJ_DECL(pj_status_t) pj_turn_sock_sendto(pj_turn_sock *turn_sock,
+                                        const pj_uint8_t *pkt,
+                                        unsigned pkt_len,
+                                        const pj_sockaddr_t *peer_addr,
+                                        unsigned addr_len);
+
+/**
+ * Optionally establish channel binding for the specified a peer address.
+ * This function will assign a unique channel number for the peer address
+ * and request channel binding to the TURN server for this address. When
+ * a channel has been bound to a peer, the TURN transport and TURN server
+ * will exchange data using ChannelData encapsulation format, which has
+ * lower bandwidth overhead than Send Indication (the default format used
+ * when peer address is not bound to a channel).
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param peer          The remote peer address.
+ * @param addr_len      Length of the address.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_bind_channel(pj_turn_sock *turn_sock,
+                                               const pj_sockaddr_t *peer,
+                                               unsigned addr_len);
+/**
+ * Initiate connection to the specified peer using Connect request.
+ * Application must call this function when it uses RFC 6062 (TURN TCP
+ * allocations) to initiate a data connection to a peer. The connection status
+ * will be notified via on_connection_status callback.
+ *
+ * According to RFC 6062, the TURN transport instance must be created with
+ * connection type are set to PJ_TURN_TP_TCP, application must send TCP
+ * Allocate request (with pj_turn_session_alloc(), set TURN allocation
+ * parameter peer_conn_type to PJ_TURN_TP_TCP) before calling this function.
+ *
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param peer          The remote peer address.
+ * @param addr_len      Length of the address.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_connect(pj_turn_sock *turn_sock,
+                                          const pj_sockaddr_t *peer,
+                                          unsigned addr_len);
+/**
+ * Close previous TCP data connection for the specified peer.
+ * According to RFC 6062, when the client wishes to terminate its relayed
+ * connection to the peer, it closes the data connection to the server.
+ *
+ * @param turn_sock     The TURN transport instance.
+ * @param peer          The remote peer address.
+ * @param addr_len      Length of the address.
+ *
+ * @return              PJ_SUCCESS if the operation has been successful,
+ *                      or the appropriate error code on failure.
+ */
+PJ_DECL(pj_status_t) pj_turn_sock_disconnect(pj_turn_sock *turn_sock,
+                                           const pj_sockaddr_t *peer,
+                                           unsigned addr_len);
+
+
+/**
+ * @}
+ */
+
+
+PJ_END_DECL
+
+
+#endif  /* __PJNATH_TURN_SOCK_H__ */
+