ice.h

Go to the documentation of this file.

#ifndef JANUS_ICE_H
#define JANUS_ICE_H

#include <glib.h>
#include <agent.h>

#include "sdp.h"
#include "dtls.h"
#include "sctp.h"
#include "rtcp.h"
#include "text2pcap.h"
#include "utils.h"
#include "ip-utils.h"
#include "refcount.h"
#include "plugins/plugin.h"


void janus_ice_init(gboolean ice_lite, gboolean ice_tcp, gboolean full_trickle, gboolean ignore_mdns,
        gboolean ipv6, gboolean ipv6_linklocal, uint16_t rtp_min_port, uint16_t rtp_max_port);
void janus_ice_deinit(void);
int janus_ice_test_stun_server(janus_network_address *addr, uint16_t port, uint16_t local_port, janus_network_address *public_addr, uint16_t *public_port);
int janus_ice_set_stun_server(gchar *stun_server, uint16_t stun_port);
int janus_ice_set_turn_server(gchar *turn_server, uint16_t turn_port, gchar *turn_type, gchar *turn_user, gchar *turn_pwd);
int janus_ice_set_turn_rest_api(gchar *api_server, gchar *api_key, gchar *api_method, uint api_timeout);
char *janus_ice_get_stun_server(void);
uint16_t janus_ice_get_stun_port(void);
char *janus_ice_get_turn_server(void);
uint16_t janus_ice_get_turn_port(void);
char *janus_ice_get_turn_rest_api(void);
void janus_ice_allow_force_relay(void);
gboolean janus_ice_is_force_relay_allowed(void);
void janus_ice_enable_nat_1_1(gboolean keep_private_host);
void janus_ice_enforce_interface(const char *ip);
gboolean janus_ice_is_enforced(const char *ip);
void janus_ice_ignore_interface(const char *ip);
gboolean janus_ice_is_ignored(const char *ip);
gboolean janus_ice_is_ice_lite_enabled(void);
gboolean janus_ice_is_ice_tcp_enabled(void);
gboolean janus_ice_is_full_trickle_enabled(void);
gboolean janus_ice_is_mdns_enabled(void);
gboolean janus_ice_is_ipv6_enabled(void);
gboolean janus_ice_is_ipv6_linklocal_enabled(void);
#ifdef HAVE_ICE_NOMINATION

void janus_ice_set_nomination_mode(const char *nomination);
const char *janus_ice_get_nomination_mode(void);
#endif

void janus_ice_set_consent_freshness_enabled(gboolean enabled);
gboolean janus_ice_is_consent_freshness_enabled(void);
void janus_ice_set_keepalive_conncheck_enabled(gboolean enabled);
gboolean janus_ice_is_keepalive_conncheck_enabled(void);
void janus_ice_set_hangup_on_failed_enabled(gboolean enabled);
gboolean janus_ice_is_hangup_on_failed_enabled(void);
void janus_set_min_nack_queue(uint16_t mnq);
uint16_t janus_get_min_nack_queue(void);
void janus_set_nack_optimizations_enabled(gboolean optimize);
gboolean janus_is_nack_optimizations_enabled(void);
void janus_set_no_media_timer(uint timer);
uint janus_get_no_media_timer(void);
void janus_set_slowlink_threshold(uint packets);
uint janus_get_slowlink_threshold(void);
void janus_set_twcc_period(uint period);
uint janus_get_twcc_period(void);
void janus_set_dscp(int dscp);
int janus_get_dscp(void);
void janus_ice_set_event_stats_period(int period);
int janus_ice_get_event_stats_period(void);
int janus_ice_get_peerconnection_num(void);

void janus_ice_event_set_combine_media_stats(gboolean combine_media_stats_to_one_event);
gboolean janus_ice_event_get_combine_media_stats(void);

void janus_enable_opaqueid_in_api(void);
gboolean janus_is_opaqueid_in_api_enabled(void);


const gchar *janus_get_ice_state_name(gint state);


typedef struct janus_ice_handle janus_ice_handle;
typedef struct janus_ice_peerconnection janus_ice_peerconnection;
typedef struct janus_ice_peerconnection_medium janus_ice_peerconnection_medium;
typedef struct janus_ice_trickle janus_ice_trickle;

#define JANUS_ICE_HANDLE_WEBRTC_PROCESSING_OFFER        (1 << 0)
#define JANUS_ICE_HANDLE_WEBRTC_START                           (1 << 1)
#define JANUS_ICE_HANDLE_WEBRTC_READY                           (1 << 2)
#define JANUS_ICE_HANDLE_WEBRTC_STOP                            (1 << 3)
#define JANUS_ICE_HANDLE_WEBRTC_ALERT                           (1 << 4)
#define JANUS_ICE_HANDLE_WEBRTC_NEGOTIATED                      (1 << 5)
#define JANUS_ICE_HANDLE_WEBRTC_TRICKLE                         (1 << 7)
#define JANUS_ICE_HANDLE_WEBRTC_ALL_TRICKLES            (1 << 8)
#define JANUS_ICE_HANDLE_WEBRTC_TRICKLE_SYNCED          (1 << 9)
#define JANUS_ICE_HANDLE_WEBRTC_DATA_CHANNELS           (1 << 10)
#define JANUS_ICE_HANDLE_WEBRTC_CLEANING                        (1 << 11)
#define JANUS_ICE_HANDLE_WEBRTC_HAS_AUDIO                       (1 << 12)
#define JANUS_ICE_HANDLE_WEBRTC_HAS_VIDEO                       (1 << 13)
#define JANUS_ICE_HANDLE_WEBRTC_GOT_OFFER                       (1 << 14)
#define JANUS_ICE_HANDLE_WEBRTC_GOT_ANSWER                      (1 << 15)
#define JANUS_ICE_HANDLE_WEBRTC_HAS_AGENT                       (1 << 16)
#define JANUS_ICE_HANDLE_WEBRTC_ICE_RESTART                     (1 << 17)
#define JANUS_ICE_HANDLE_WEBRTC_RESEND_TRICKLES         (1 << 18)
#define JANUS_ICE_HANDLE_WEBRTC_RFC4588_RTX                     (1 << 19)
#define JANUS_ICE_HANDLE_WEBRTC_NEW_DATACHAN_SDP        (1 << 20)
#define JANUS_ICE_HANDLE_WEBRTC_E2EE                            (1 << 21)


typedef enum janus_media_type {
        JANUS_MEDIA_UNKNOWN = 0,
        JANUS_MEDIA_AUDIO,
        JANUS_MEDIA_VIDEO,
        JANUS_MEDIA_DATA
} janus_media_type;
const char *janus_media_type_str(janus_media_type type);

typedef struct janus_ice_stats_info {
        guint32 packets;
        guint64 bytes;
        guint32 bytes_lastsec, bytes_lastsec_temp;
        gint64 updated;
        gboolean notified_lastsec;
        guint32 nacks;
} janus_ice_stats_info;

typedef struct janus_ice_stats {
        janus_ice_stats_info info[3];
        guint sl_lost_count;
} janus_ice_stats;

void janus_ice_notify_hangup(janus_ice_handle *handle, const char *reason);


gboolean janus_plugin_session_is_alive(janus_plugin_session *plugin_session);


typedef struct janus_seq_info {
        gint64 ts;
        guint16 seq;
        guint16 state;
        struct janus_seq_info *next;
        struct janus_seq_info *prev;
} janus_seq_info;
void janus_seq_list_free(janus_seq_info **head);
enum {
        SEQ_MISSING,
        SEQ_NACKED,
        SEQ_GIVEUP,
        SEQ_RECVED
};


struct janus_ice_handle {
        void *session;
        guint64 handle_id;
        char *opaque_id;
        char *token;
        gint64 created;
        void *app;
        janus_plugin_session *app_handle;
        janus_flags webrtc_flags;
        gint cdone;
        GMainContext *mainctx;
        GMainLoop *mainloop;
        void *static_event_loop;
        GThread *thread;
        GSource *rtp_source, *rtcp_source, *stats_source, *twcc_source;
        NiceAgent *agent;
        gint64 agent_created;
        gint64 agent_started;
        gboolean controlling;
        gchar *pc_mid;
        guint stream_id;
        janus_ice_peerconnection *pc;
        gchar *rtp_profile;
        gchar *local_sdp;
        gchar *remote_sdp;
        const gchar *hangup_reason;
        GList *pending_trickles;
        GAsyncQueue *queued_candidates;
        GAsyncQueue *queued_packets;
        guint srtp_errors_count;
        gint last_srtp_error, last_srtp_summary;
        gint last_event_stats;
        volatile gint dump_packets;
        janus_text2pcap *text2pcap;
        janus_mutex mutex;
        volatile gint has_pc;
        volatile gint closepc;
        volatile gint destroyed;
        janus_refcount ref;
};

struct janus_ice_peerconnection {
        janus_ice_handle *handle;
        guint stream_id;
        guint component_id;
        gboolean cdone;
        guint state;
        gint64 gathered;
        gint64 connected;
        GSList *candidates;
        GSList *local_candidates;
        GSList *remote_candidates;
        gchar *selected_pair;
        gboolean process_started;
        GSource *icestate_source;
        gint64 icefailed_detected;
        GSource *dtlsrt_source;
        janus_dtls_srtp *dtls;
        gint mid_ext_id;
        gint rid_ext_id, ridrtx_ext_id;
        gint audiolevel_ext_id;
        gint videoorientation_ext_id;
        gint playoutdelay_ext_id;
        gint dependencydesc_ext_id;
        gint abs_send_time_ext_id;
        gint abs_capture_time_ext_id;
        gint videolayers_ext_id;
        gboolean do_transport_wide_cc;
        gint transport_wide_cc_ext_id;
        guint16 transport_wide_cc_out_seq_num;
        guint32 transport_wide_cc_last_seq_num;
        guint32 transport_wide_cc_last_feedback_seq_num;
        guint16 transport_wide_cc_cycles;
        guint transport_wide_cc_feedback_count;
        GSList *transport_wide_received_seq_nums;
        uint32_t remb_bitrate;
        janus_dtls_role dtls_role;
        janus_ice_stats dtls_in_stats, dtls_out_stats;
        gchar *remote_hashing;
        gchar *remote_fingerprint;
        gchar *ruser;
        gchar *rpass;
        GHashTable *media;
        GHashTable *media_byssrc;
        GHashTable *media_bymid;
        GHashTable *media_bytype;
        GHashTable *payload_types;
        GHashTable *clock_rates;
        GHashTable *rtx_payload_types;
        GHashTable *rtx_payload_types_rev;
        GQueue *nacks_queue;
        gboolean noerrorlog;
        volatile gint too_large;
        janus_mutex mutex;
        volatile gint destroyed;
        janus_refcount ref;
};

#define LAST_SEQS_MAX_LEN 160

struct janus_ice_peerconnection_medium {
        janus_ice_peerconnection *pc;
        janus_media_type type;
        int mindex;
        char *mid;
        char *msid, *mstid, *remote_msid, *remote_mstid;
        guint32 ssrc;
        guint32 ssrc_rtx;
        guint32 ssrc_peer[3], ssrc_peer_new[3], ssrc_peer_orig[3], ssrc_peer_temp;
        guint32 ssrc_peer_rtx[3], ssrc_peer_rtx_new[3], ssrc_peer_rtx_orig[3];
        char *rid[3];
        gboolean disabled_rid[3];
        gboolean rids_hml;
        gboolean legacy_rid;
        janus_rtp_switching_context rtp_ctx[3];
        GList *payload_types;
        int opusred_pt;
        GHashTable *rtx_payload_types;
        GHashTable *clock_rates;
        gint payload_type, rtx_payload_type;
        char *codec;
        gboolean (* video_is_keyframe)(const char* buffer, int len);
        gboolean send, recv;
        janus_rtcp_context *rtcp_ctx[3];
        uint16_t nack_queue_ms;
        GHashTable *rtx_nacked[3];
        GHashTable *pending_nacked_cleanup;
        gint64 first_ntp_ts[3];
        guint32 first_rtp_ts[3];
        gint64 last_ntp_ts;
        guint32 last_rtp_ts;
        gboolean do_nacks;
        GQueue *retransmit_buffer;
        GHashTable *retransmit_seqs;
        guint16 rtx_seq_number;
        gint64 retransmit_log_ts;
        guint retransmit_recent_cnt;
        gint64 nack_sent_log_ts;
        guint nack_sent_recent_cnt;
        janus_seq_info *last_seqs[3];
        janus_ice_stats in_stats;
        janus_ice_stats out_stats;
        gboolean noerrorlog;
        janus_mutex mutex;
        volatile gint destroyed;
        janus_refcount ref;
};
janus_ice_peerconnection_medium *janus_ice_peerconnection_medium_create(janus_ice_handle *handle, janus_media_type type);

struct janus_ice_trickle {
        janus_ice_handle *handle;
        gint64 received;
        char *transaction;
        json_t *candidate;
};


janus_ice_trickle *janus_ice_trickle_new(const char *transaction, json_t *candidate);
gint janus_ice_trickle_parse(janus_ice_handle *handle, json_t *candidate, const char **error);
void janus_ice_trickle_destroy(janus_ice_trickle *trickle);



janus_ice_handle *janus_ice_handle_create(void *core_session, const char *opaque_id, const char *token);
gint janus_ice_handle_attach_plugin(void *core_session, janus_ice_handle *handle, janus_plugin *plugin, int loop_index);
gint janus_ice_handle_destroy(void *core_session, janus_ice_handle *handle);
void janus_ice_webrtc_hangup(janus_ice_handle *handle, const char *reason);
void janus_ice_peerconnection_destroy(janus_ice_peerconnection *pc);



void janus_ice_relay_rtp(janus_ice_handle *handle, janus_plugin_rtp *packet);
void janus_ice_relay_rtcp(janus_ice_handle *handle, janus_plugin_rtcp *packet);
void janus_ice_relay_data(janus_ice_handle *handle, janus_plugin_data *packet);
void janus_ice_send_pli(janus_ice_handle *handle);
void janus_ice_send_pli_stream(janus_ice_handle *handle, int mindex);
void janus_ice_send_remb(janus_ice_handle *handle, uint32_t bitrate);
void janus_ice_incoming_data(janus_ice_handle *handle, char *label, char *protocol, gboolean textdata, char *buffer, int length);
void janus_ice_relay_sctp(janus_ice_handle *handle, char *buffer, int length);
void janus_ice_notify_data_ready(janus_ice_handle *handle);
void janus_ice_notify_media_stopped(janus_ice_handle *handle);



int janus_ice_setup_local(janus_ice_handle *handle, gboolean offer, gboolean trickle, janus_dtls_role dtls_role);
void janus_ice_candidates_to_sdp(janus_ice_handle *handle, janus_sdp_mline *mline, guint stream_id, guint component_id);
void janus_ice_add_remote_candidate(janus_ice_handle *handle, NiceCandidate *c);
void janus_ice_setup_remote_candidates(janus_ice_handle *handle, guint stream_id, guint component_id);
void janus_ice_dtls_handshake_done(janus_ice_handle *handle);
void janus_ice_restart(janus_ice_handle *handle);
void janus_ice_resend_trickles(janus_ice_handle *handle);


void janus_ice_set_static_event_loops(int loops, gboolean allow_api);
int janus_ice_get_static_event_loops(void);
gboolean janus_ice_is_loop_indication_allowed(void);
json_t *janus_ice_static_event_loops_info(void);
void janus_ice_stop_static_event_loops(void);

#endif