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 ipv6, 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, janus_network_address *public_addr);
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);
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_enable_nat_1_1(void);
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_ipv6_enabled(void);
void janus_set_max_nack_queue(uint mnq);
uint janus_get_max_nack_queue(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_rfc4588_enabled(gboolean enabled);
gboolean janus_is_rfc4588_enabled(void);
void janus_ice_set_event_stats_period(int period);
int janus_ice_get_event_stats_period(void);
gboolean janus_ice_is_ice_debugging_enabled(void);
void janus_ice_debugging_enable(void);
void janus_ice_debugging_disable(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_handle janus_handle;
typedef struct janus_handle_webrtc janus_handle_webrtc;
typedef struct janus_handle_webrtc_medium janus_handle_webrtc_medium;
typedef struct janus_trickle janus_trickle;

#define JANUS_HANDLE_WEBRTC_PROCESSING_OFFER    (1 << 0)
#define JANUS_HANDLE_WEBRTC_START                               (1 << 1)
#define JANUS_HANDLE_WEBRTC_READY                               (1 << 2)
#define JANUS_HANDLE_WEBRTC_STOP                                (1 << 3)
#define JANUS_HANDLE_WEBRTC_ALERT                               (1 << 4)
#define JANUS_HANDLE_WEBRTC_NEGOTIATED                  (1 << 5)
#define JANUS_HANDLE_WEBRTC_TRICKLE                             (1 << 7)
#define JANUS_HANDLE_WEBRTC_ALL_TRICKLES                (1 << 8)
#define JANUS_HANDLE_WEBRTC_TRICKLE_SYNCED              (1 << 9)
#define JANUS_HANDLE_WEBRTC_DATA_CHANNELS               (1 << 10)
#define JANUS_HANDLE_WEBRTC_CLEANING                    (1 << 11)
#define JANUS_HANDLE_WEBRTC_GOT_OFFER                   (1 << 14)
#define JANUS_HANDLE_WEBRTC_GOT_ANSWER                  (1 << 15)
#define JANUS_HANDLE_WEBRTC_HAS_AGENT                   (1 << 16)
#define JANUS_HANDLE_WEBRTC_ICE_RESTART                 (1 << 17)
#define JANUS_HANDLE_WEBRTC_RESEND_TRICKLES             (1 << 18)
#define JANUS_HANDLE_WEBRTC_RFC4588_RTX                 (1 << 19)
#define JANUS_HANDLE_WEBRTC_NEW_DATACHAN_SDP    (1 << 20)


typedef enum janus_media_type {
        JANUS_MEDIA_UNKNOWN = 0,
        JANUS_MEDIA_AUDIO,
        JANUS_MEDIA_VIDEO,
        JANUS_MEDIA_DATA
} janus_media_type;

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

typedef struct janus_media_stats {
        janus_media_stats_info info[3];
        guint sl_lost_count;
} janus_media_stats;

void janus_ice_notify_hangup(janus_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_handle {
        void *session;
        guint64 handle_id;
        char *opaque_id;
        gint64 created;
        void *app;
        janus_plugin_session *app_handle;
        janus_flags webrtc_flags;
        gint cdone;
        GMainContext *mainctx;
        GMainLoop *mainloop;
        GThread *thread;
        GSource *rtp_source, *rtcp_source, *stats_source, *twcc_source;
        NiceAgent *agent;
        gint64 agent_created;
        gboolean controlling;
        gchar *pc_mid;
        guint stream_id;
        janus_handle_webrtc *pc;
        gchar *rtp_profile;
        gchar *local_sdp;
        gchar *remote_sdp;
        const gchar *hangup_reason;
        GList *pending_trickles;
        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 closepc;
        volatile gint destroyed;
        janus_refcount ref;
};

struct janus_handle_webrtc {
        janus_handle *handle;
        guint stream_id;
        guint component_id;
        gint cdone:1;
        guint state;
        gint64 ice_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 framemarking_ext_id;
        gboolean do_transport_wide_cc;
        gint transport_wide_cc_ext_id;
        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;
        janus_dtls_role dtls_role;
        janus_media_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;
        gboolean noerrorlog;
        janus_mutex mutex;
        volatile gint destroyed;
        janus_refcount ref;
};

#define LAST_SEQS_MAX_LEN 160

struct janus_handle_webrtc_medium {
        janus_handle_webrtc *pc;
        janus_media_type type;
        int mindex;
        char *mid;
        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 legacy_rid;
        janus_rtp_switching_context rtp_ctx[3];
        GList *payload_types;
        GHashTable *rtx_payload_types;
        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];
        GHashTable *rtx_nacked[3];
        gint64 first_ntp_ts[3];
        guint32 first_rtp_ts[3];
        guint32 last_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_media_stats in_stats;
        janus_media_stats out_stats;
        gboolean noerrorlog;
        janus_mutex mutex;
        volatile gint destroyed;
        janus_refcount ref;
};
janus_handle_webrtc_medium *janus_handle_webrtc_medium_create(janus_handle *handle, janus_media_type type);

struct janus_trickle {
        janus_handle *handle;
        gint64 received;
        char *transaction;
        json_t *candidate;
};


janus_trickle *janus_trickle_new(const char *transaction, json_t *candidate);
gint janus_trickle_parse(janus_handle *handle, json_t *candidate, const char **error);
void janus_trickle_destroy(janus_trickle *trickle);



janus_handle *janus_handle_create(void *core_session, const char *opaque_id);
gint janus_handle_attach_plugin(void *core_session, janus_handle *handle, janus_plugin *plugin);
gint janus_handle_destroy(void *core_session, janus_handle *handle);
void janus_handle_webrtc_hangup(janus_handle *handle, const char *reason);
void janus_handle_webrtc_destroy(janus_handle_webrtc *pc);



void janus_ice_relay_rtp(janus_handle *handle, int mindex, gboolean video, char *buf, int len);
void janus_ice_relay_rtcp(janus_handle *handle, int mindex, gboolean video, char *buf, int len);
void janus_ice_relay_data(janus_handle *handle, char *label, char *buf, int len);
void janus_ice_incoming_data(janus_handle *handle, char *label, char *buffer, int length);
void janus_ice_relay_sctp(janus_handle *handle, char *buffer, int length);



int janus_handle_setup_local(janus_handle *handle, gboolean offer, gboolean trickle);
void janus_handle_candidates_to_sdp(janus_handle *handle, janus_sdp_mline *mline, guint stream_id, guint component_id);
void janus_handle_setup_remote_candidates(janus_handle *handle, guint stream_id, guint component_id);
void janus_handle_dtls_handshake_done(janus_handle *handle);
void janus_handle_ice_restart(janus_handle *handle);
void janus_handle_resend_trickles(janus_handle *handle);


void janus_ice_set_static_event_loops(int loops);
int janus_ice_get_static_event_loops(void);
void janus_ice_stop_static_event_loops(void);

#endif