PeerStreamer-ng

/*! \file   janus_sip.c

 * \author Lorenzo Miniero <lorenzo@meetecho.com>

 * \copyright GNU General Public License v3

 * \brief  Janus SIP plugin

 * \details  This is a simple SIP plugin for Janus, allowing WebRTC peers

 * to register at a SIP server (e.g., Asterisk) and call SIP user agents

 * through the gateway. Specifically, when attaching to the plugin peers

 * are requested to provide their SIP server credentials, i.e., the address

 * of the SIP server and their username/secret. This results in the plugin

 * registering at the SIP server and acting as a SIP client on behalf of

 * the web peer. Most of the SIP states and lifetime are masked by the plugin,

 * and only the relevant events (e.g., INVITEs and BYEs) and functionality

 * (call, hangup) are made available to the web peer: peers can call

 * extensions at the SIP server or wait for incoming INVITEs, and during

 * a call they can send DTMF tones. Calls can do plain RTP or SDES-SRTP.

 *

 * The concept behind this plugin is to allow different web pages associated

 * to the same peer, and hence the same SIP user, to attach to the plugin

 * at the same time and yet just do a SIP REGISTER once. The same should

 * apply for calls: while an incoming call would be notified to all the

 * web UIs associated to the peer, only one would be able to pick up and

 * answer, in pretty much the same way as SIP forking works but without the

 * need to fork in the same place. This specific functionality, though, has

 * not been implemented as of yet.

 *

 * \section sipapi SIP Plugin API

 *

 * All requests you can send in the SIP Plugin API are asynchronous,

 * which means all responses (successes and errors) will be delivered

 * as events with the same transaction.

 *

 * The supported requests are \c register , \c unregister , \c call ,

 * \c accept, \c info , \c message , \c dtmf_info , \c recording ,

 * \c hold , \c unhold and \c hangup . \c register can be used,

 * as the name suggests, to register a username at a SIP registrar to

 * call and be called, while \c unregister unregisters it; \c call is used

 * to send an INVITE to a different SIP URI through the plugin, while

 * \c accept is used to accept the call in case one is invited instead

 * of inviting; \c hold and \c unhold can be used respectively to put a

 * call on-hold and to resume it; \c info allows you to send a generic

 * SIP INFO request, while \c dtmf_info is focused on using INFO for DTMF

 * instead; \c message is the method you use to send a SIP message

 * to the other peer; \c recording is used, instead, to record the

 * conversation to one or more .mjr files (depending on the direction you

 * want to record); finally, \c hangup can be used to terminate the

 * communication at any time, either to hangup (BYE) an ongoing call or

 * to cancel/decline (CANCEL/BYE) a call that hasn't started yet.

 *

 * Actual API docs: TBD.

 *

 * \ingroup plugins

 * \ref plugins

 */

#include "plugin.h"

#include <arpa/inet.h>

#include <net/if.h>

#include <jansson.h>

#include <sofia-sip/msg_header.h>

#include <sofia-sip/nua.h>

#include <sofia-sip/sdp.h>

#include <sofia-sip/sip_status.h>

#include <sofia-sip/url.h>

#include <sofia-sip/tport_tag.h>

#include <sofia-sip/su_log.h>

#include "../debug.h"

#include "../apierror.h"

#include "../config.h"

#include "../mutex.h"

#include "../record.h"

#include "../rtp.h"

#include "../rtcp.h"

#include "../sdp-utils.h"

#include "../utils.h"

#include "../ip-utils.h"

/* Plugin information */

#define JANUS_SIP_VERSION                        6

#define JANUS_SIP_VERSION_STRING        "0.0.6"

#define JANUS_SIP_DESCRIPTION                "This is a simple SIP plugin for Janus, allowing WebRTC peers to register at a SIP server and call SIP user agents through the gateway."

#define JANUS_SIP_NAME                                "JANUS SIP plugin"

#define JANUS_SIP_AUTHOR                        "Meetecho s.r.l."

#define JANUS_SIP_PACKAGE                        "janus.plugin.sip"

/* Plugin methods */

janus_plugin *create(void);

int janus_sip_init(janus_callbacks *callback, const char *config_path);

void janus_sip_destroy(void);

int janus_sip_get_api_compatibility(void);

int janus_sip_get_version(void);

const char *janus_sip_get_version_string(void);

const char *janus_sip_get_description(void);

const char *janus_sip_get_name(void);

const char *janus_sip_get_author(void);

const char *janus_sip_get_package(void);

void janus_sip_create_session(janus_plugin_session *handle, int *error);

struct janus_plugin_result *janus_sip_handle_message(janus_plugin_session *handle, char *transaction, json_t *message, json_t *jsep);

void janus_sip_setup_media(janus_plugin_session *handle);

void janus_sip_incoming_rtp(janus_plugin_session *handle, int video, char *buf, int len);

void janus_sip_incoming_rtcp(janus_plugin_session *handle, int video, char *buf, int len);

void janus_sip_hangup_media(janus_plugin_session *handle);

void janus_sip_destroy_session(janus_plugin_session *handle, int *error);

json_t *janus_sip_query_session(janus_plugin_session *handle);

/* Plugin setup */

static janus_plugin janus_sip_plugin =

        JANUS_PLUGIN_INIT (

                .init = janus_sip_init,

                .destroy = janus_sip_destroy,

                .get_api_compatibility = janus_sip_get_api_compatibility,

                .get_version = janus_sip_get_version,

                .get_version_string = janus_sip_get_version_string,

                .get_description = janus_sip_get_description,

                .get_name = janus_sip_get_name,

                .get_author = janus_sip_get_author,

                .get_package = janus_sip_get_package,

                .create_session = janus_sip_create_session,

                .handle_message = janus_sip_handle_message,

                .setup_media = janus_sip_setup_media,

                .incoming_rtp = janus_sip_incoming_rtp,

                .incoming_rtcp = janus_sip_incoming_rtcp,

                .hangup_media = janus_sip_hangup_media,

                .destroy_session = janus_sip_destroy_session,

                .query_session = janus_sip_query_session,

        );

/* Plugin creator */

janus_plugin *create(void) {

        JANUS_LOG(LOG_VERB, "%s created!\n", JANUS_SIP_NAME);

        return &janus_sip_plugin;

}

/* Parameter validation */

static struct janus_json_parameter request_parameters[] = {

        {"request", JSON_STRING, JANUS_JSON_PARAM_REQUIRED}

};

static struct janus_json_parameter register_parameters[] = {

        {"type", JSON_STRING, 0},

        {"send_register", JANUS_JSON_BOOL, 0},

        {"sips", JANUS_JSON_BOOL, 0},

        {"username", JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"secret", JSON_STRING, 0},

        {"ha1_secret", JSON_STRING, 0},

        {"authuser", JSON_STRING, 0},

        {"headers", JSON_OBJECT, 0},

        {"refresh", JANUS_JSON_BOOL, 0}

};

static struct janus_json_parameter proxy_parameters[] = {

        {"proxy", JSON_STRING, 0},

        {"outbound_proxy", JSON_STRING, 0}

};

static struct janus_json_parameter call_parameters[] = {

        {"uri", JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"autoack", JANUS_JSON_BOOL, 0},

        {"headers", JSON_OBJECT, 0},

        {"srtp", JSON_STRING, 0}

};

static struct janus_json_parameter accept_parameters[] = {

        {"srtp", JSON_STRING, 0}

};

static struct janus_json_parameter recording_parameters[] = {

        {"action", JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"audio", JANUS_JSON_BOOL, 0},

        {"video", JANUS_JSON_BOOL, 0},

        {"peer_audio", JANUS_JSON_BOOL, 0},

        {"peer_video", JANUS_JSON_BOOL, 0},

        {"filename", JSON_STRING, 0}

};

static struct janus_json_parameter dtmf_info_parameters[] = {

        {"digit", JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"duration", JSON_INTEGER, JANUS_JSON_PARAM_POSITIVE}

};

static struct janus_json_parameter info_parameters[] = {

        {"type", JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"content", JSON_STRING, JANUS_JSON_PARAM_REQUIRED}

};

static struct janus_json_parameter sipmessage_parameters[] = {

        {"content", JSON_STRING, JANUS_JSON_PARAM_REQUIRED}

};

/* Useful stuff */

static volatile gint initialized = 0, stopping = 0;

static gboolean notify_events = TRUE;

static janus_callbacks *gateway = NULL;

static char *local_ip = NULL;

static int keepalive_interval = 120;

static gboolean behind_nat = FALSE;

static char *user_agent;

#define JANUS_DEFAULT_REGISTER_TTL        3600

static int register_ttl = JANUS_DEFAULT_REGISTER_TTL;

static GThread *handler_thread;

static GThread *watchdog;

static void *janus_sip_handler(void *data);

typedef struct janus_sip_message {

        janus_plugin_session *handle;

        char *transaction;

        json_t *message;

        json_t *jsep;

} janus_sip_message;

static GAsyncQueue *messages = NULL;

static janus_sip_message exit_message;

static void janus_sip_message_free(janus_sip_message *msg) {

        if(!msg || msg == &exit_message)

                return;

        msg->handle = NULL;

        g_free(msg->transaction);

        msg->transaction = NULL;

        if(msg->message)

                json_decref(msg->message);

        msg->message = NULL;

        if(msg->jsep)

                json_decref(msg->jsep);

        msg->jsep = NULL;

        g_free(msg);

}

typedef enum {

        janus_sip_registration_status_disabled = -2,

        janus_sip_registration_status_failed = -1,

        janus_sip_registration_status_unregistered = 0,

        janus_sip_registration_status_registering,

        janus_sip_registration_status_registered,

        janus_sip_registration_status_unregistering,

} janus_sip_registration_status;

static const char *janus_sip_registration_status_string(janus_sip_registration_status status) {

        switch(status) {

                case janus_sip_registration_status_disabled:

                        return "disabled";

                case janus_sip_registration_status_failed:

                        return "failed";

                case janus_sip_registration_status_unregistered:

                        return "unregistered";

                case janus_sip_registration_status_registering:

                        return "registering";

                case janus_sip_registration_status_registered:

                        return "registered";

                case janus_sip_registration_status_unregistering:

                        return "unregistering";

                default:

                        return "unknown";

        }

}

typedef enum {

        janus_sip_call_status_idle = 0,

        janus_sip_call_status_inviting,

        janus_sip_call_status_invited,

        janus_sip_call_status_incall,

        janus_sip_call_status_closing,

} janus_sip_call_status;

static const char *janus_sip_call_status_string(janus_sip_call_status status) {

        switch(status) {

                case janus_sip_call_status_idle:

                        return "idle";

                case janus_sip_call_status_inviting:

                        return "inviting";

                case janus_sip_call_status_invited:

                        return "invited";

                case janus_sip_call_status_incall:

                        return "incall";

                case janus_sip_call_status_closing:

                        return "closing";

                default:

                        return "unknown";

        }

}

/* Sofia stuff */

typedef struct ssip_s ssip_t;

typedef struct ssip_oper_s ssip_oper_t;

typedef enum {

        janus_sip_secret_type_plaintext = 1,

        janus_sip_secret_type_hashed = 2,

        janus_sip_secret_type_unknown

} janus_sip_secret_type;

typedef struct janus_sip_account {

        char *identity;

        char *user_agent;                /* Used to override the general UA string */

        gboolean sips;

        char *username;

        char *display_name;                /* Used for outgoing calls in the From header */

        char *authuser;                        /**< username to use for authentication */

        char *secret;

        janus_sip_secret_type secret_type;

        int sip_port;

        char *proxy;

        char *outbound_proxy;

        janus_sip_registration_status registration_status;

} janus_sip_account;

typedef struct janus_sip_media {

        char *remote_ip;

        gboolean earlymedia;

        gboolean ready;

        gboolean autoack;

        gboolean require_srtp, has_srtp_local, has_srtp_remote;

        gboolean on_hold;

        gboolean has_audio;

        int audio_rtp_fd, audio_rtcp_fd;

        int local_audio_rtp_port, remote_audio_rtp_port;

        int local_audio_rtcp_port, remote_audio_rtcp_port;

        guint32 audio_ssrc, audio_ssrc_peer;

        int audio_pt;

        const char *audio_pt_name;

        srtp_t audio_srtp_in, audio_srtp_out;

        srtp_policy_t audio_remote_policy, audio_local_policy;

        int audio_srtp_suite_in, audio_srtp_suite_out;

        gboolean audio_send;

        janus_sdp_mdirection pre_hold_audio_dir;

        gboolean has_video;

        int video_rtp_fd, video_rtcp_fd;

        int local_video_rtp_port, remote_video_rtp_port;

        int local_video_rtcp_port, remote_video_rtcp_port;

        guint32 video_ssrc, video_ssrc_peer;

        int video_pt;

        const char *video_pt_name;

        srtp_t video_srtp_in, video_srtp_out;

        srtp_policy_t video_remote_policy, video_local_policy;

        int video_srtp_suite_in, video_srtp_suite_out;

        gboolean video_send;

        janus_sdp_mdirection pre_hold_video_dir;

        janus_rtp_switching_context context;

        int pipefd[2];

        gboolean updated;

} janus_sip_media;

typedef struct janus_sip_session {

        janus_plugin_session *handle;

        ssip_t *stack;

        janus_sip_account account;

        janus_sip_call_status status;

        janus_sip_media media;

        char *transaction;

        char *callee;

        char *callid;

        janus_sdp *sdp;                                /* The SDP this user sent */

        janus_recorder *arc;                /* The Janus recorder instance for this user's audio, if enabled */

        janus_recorder *arc_peer;        /* The Janus recorder instance for the peer's audio, if enabled */

        janus_recorder *vrc;                /* The Janus recorder instance for this user's video, if enabled */

        janus_recorder *vrc_peer;        /* The Janus recorder instance for the peer's video, if enabled */

        janus_mutex rec_mutex;                /* Mutex to protect the recorders from race conditions */

        volatile gint hangingup;

        gint64 destroyed;        /* Time at which this session was marked as destroyed */

        janus_mutex mutex;

} janus_sip_session;

static GHashTable *sessions;

static GList *old_sessions;

static GHashTable *identities;

static GHashTable *callids;

static janus_mutex sessions_mutex;

#undef SU_ROOT_MAGIC_T

#define SU_ROOT_MAGIC_T        ssip_t

#undef NUA_MAGIC_T

#define NUA_MAGIC_T                ssip_t

#undef NUA_HMAGIC_T

#define NUA_HMAGIC_T        ssip_oper_t

struct ssip_s {

        su_home_t s_home[1];

        su_root_t *s_root;

        nua_t *s_nua;

        nua_handle_t *s_nh_r, *s_nh_i;

        janus_sip_session *session;

};

/* SRTP stuff (in case we need SDES) */

static int janus_sip_srtp_set_local(janus_sip_session *session, gboolean video, char **crypto) {

        if(session == NULL)

                return -1;

        /* Generate key/salt */

        uint8_t *key = g_malloc0(SRTP_MASTER_LENGTH);

        srtp_crypto_get_random(key, SRTP_MASTER_LENGTH);

        /* Set SRTP policies */

        srtp_policy_t *policy = video ? &session->media.video_local_policy : &session->media.audio_local_policy;

        srtp_crypto_policy_set_rtp_default(&(policy->rtp));

        srtp_crypto_policy_set_rtcp_default(&(policy->rtcp));

        policy->ssrc.type = ssrc_any_inbound;

        policy->key = key;

        policy->next = NULL;

        /* Create SRTP context */

        srtp_err_status_t res = srtp_create(video ? &session->media.video_srtp_out : &session->media.audio_srtp_out, policy);

        if(res != srtp_err_status_ok) {

                /* Something went wrong... */

                JANUS_LOG(LOG_ERR, "Oops, error creating outbound SRTP session: %d (%s)\n", res, janus_srtp_error_str(res));

                g_free(key);

                policy->key = NULL;

                return -2;

        }

        /* Base64 encode the salt */

        *crypto = g_base64_encode(key, SRTP_MASTER_LENGTH);

        if((video && session->media.video_srtp_out) || (!video && session->media.audio_srtp_out)) {

                JANUS_LOG(LOG_VERB, "%s outbound SRTP session created\n", video ? "Video" : "Audio");

        }

        return 0;

}

static int janus_sip_srtp_set_remote(janus_sip_session *session, gboolean video, const char *crypto, int suite) {

        if(session == NULL || crypto == NULL)

                return -1;

        /* Base64 decode the crypto string and set it as the remote SRTP context */

        gsize len = 0;

        guchar *decoded = g_base64_decode(crypto, &len);

        if(len < SRTP_MASTER_LENGTH) {

                /* FIXME Can this happen? */

                g_free(decoded);

                return -2;

        }

        /* Set SRTP policies */

        srtp_policy_t *policy = video ? &session->media.video_remote_policy : &session->media.audio_remote_policy;

        srtp_crypto_policy_set_rtp_default(&(policy->rtp));

        srtp_crypto_policy_set_rtcp_default(&(policy->rtcp));

        if(suite == 32) {

                srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&(policy->rtp));

                srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&(policy->rtcp));

        } else if(suite == 80) {

                srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&(policy->rtp));

                srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&(policy->rtcp));

        }

        policy->ssrc.type = ssrc_any_inbound;

        policy->key = decoded;

        policy->next = NULL;

        /* Create SRTP context */

        srtp_err_status_t res = srtp_create(video ? &session->media.video_srtp_in : &session->media.audio_srtp_in, policy);

        if(res != srtp_err_status_ok) {

                /* Something went wrong... */

                JANUS_LOG(LOG_ERR, "Oops, error creating inbound SRTP session: %d (%s)\n", res, janus_srtp_error_str(res));

                g_free(decoded);

                policy->key = NULL;

                return -2;

        }

        if((video && session->media.video_srtp_in) || (!video && session->media.audio_srtp_in)) {

                JANUS_LOG(LOG_VERB, "%s inbound SRTP session created\n", video ? "Video" : "Audio");

        }

        return 0;

}

static void janus_sip_srtp_cleanup(janus_sip_session *session) {

        if(session == NULL)

                return;

        session->media.autoack = TRUE;

        session->media.require_srtp = FALSE;

        session->media.has_srtp_local = FALSE;

        session->media.has_srtp_remote = FALSE;

        /* Audio */

        if(session->media.audio_srtp_out)

                srtp_dealloc(session->media.audio_srtp_out);

        session->media.audio_srtp_out = NULL;

        g_free(session->media.audio_local_policy.key);

        session->media.audio_local_policy.key = NULL;

        session->media.audio_srtp_suite_out = 0;

        if(session->media.audio_srtp_in)

                srtp_dealloc(session->media.audio_srtp_in);

        session->media.audio_srtp_in = NULL;

        g_free(session->media.audio_remote_policy.key);

        session->media.audio_remote_policy.key = NULL;

        session->media.audio_srtp_suite_in = 0;

        /* Video */

        if(session->media.video_srtp_out)

                srtp_dealloc(session->media.video_srtp_out);

        session->media.video_srtp_out = NULL;

        g_free(session->media.video_local_policy.key);

        session->media.video_local_policy.key = NULL;

        session->media.video_srtp_suite_out = 0;

        if(session->media.video_srtp_in)

                srtp_dealloc(session->media.video_srtp_in);

        session->media.video_srtp_in = NULL;

        g_free(session->media.video_remote_policy.key);

        session->media.video_remote_policy.key = NULL;

        session->media.video_srtp_suite_in = 0;

}

/* Sofia Event thread */

gpointer janus_sip_sofia_thread(gpointer user_data);

/* Sofia callbacks */

void janus_sip_sofia_callback(nua_event_t event, int status, char const *phrase, nua_t *nua, nua_magic_t *magic, nua_handle_t *nh, nua_hmagic_t *hmagic, sip_t const *sip, tagi_t tags[]);

/* SDP parsing and manipulation */

void janus_sip_sdp_process(janus_sip_session *session, janus_sdp *sdp, gboolean answer, gboolean update, gboolean *changed);

char *janus_sip_sdp_manipulate(janus_sip_session *session, janus_sdp *sdp, gboolean answer);

/* Media */

static int janus_sip_allocate_local_ports(janus_sip_session *session);

static void *janus_sip_relay_thread(void *data);

/* URI parsing utilies */

#define JANUS_SIP_URI_MAXLEN        1024

typedef struct {

        char data[JANUS_SIP_URI_MAXLEN];

        url_t url[1];

} janus_sip_uri_t;

/* Parses a SIP URI (SIPS is not supported), returns 0 on success, -1 otherwise */

static int janus_sip_parse_uri(janus_sip_uri_t *sip_uri, const char *data) {

        g_strlcpy(sip_uri->data, data, JANUS_SIP_URI_MAXLEN);

        if (url_d(sip_uri->url, sip_uri->data) < 0 || sip_uri->url->url_type != url_sip)

                return -1;

        return 0;

}

/* Similar to the above function, but it also accepts SIPS URIs */

static int janus_sip_parse_proxy_uri(janus_sip_uri_t *sip_uri, const char *data) {

        g_strlcpy(sip_uri->data, data, JANUS_SIP_URI_MAXLEN);

        if (url_d(sip_uri->url, sip_uri->data) < 0 || (sip_uri->url->url_type != url_sip && sip_uri->url->url_type != url_sips))

                return -1;

        return 0;

}

/* Error codes */

#define JANUS_SIP_ERROR_UNKNOWN_ERROR                499

#define JANUS_SIP_ERROR_NO_MESSAGE                        440

#define JANUS_SIP_ERROR_INVALID_JSON                441

#define JANUS_SIP_ERROR_INVALID_REQUEST                442

#define JANUS_SIP_ERROR_MISSING_ELEMENT                443

#define JANUS_SIP_ERROR_INVALID_ELEMENT                444

#define JANUS_SIP_ERROR_ALREADY_REGISTERED        445

#define JANUS_SIP_ERROR_INVALID_ADDRESS                446

#define JANUS_SIP_ERROR_WRONG_STATE                        447

#define JANUS_SIP_ERROR_MISSING_SDP                        448

#define JANUS_SIP_ERROR_LIBSOFIA_ERROR                449

#define JANUS_SIP_ERROR_IO_ERROR                        450

#define JANUS_SIP_ERROR_RECORDING_ERROR                451

#define JANUS_SIP_ERROR_TOO_STRICT                        452

/* SIP watchdog/garbage collector (sort of) */

static void *janus_sip_watchdog(void *data) {

        JANUS_LOG(LOG_INFO, "SIP watchdog started\n");

        gint64 now = 0;

        while(g_atomic_int_get(&initialized) && !g_atomic_int_get(&stopping)) {

                janus_mutex_lock(&sessions_mutex);

                /* Iterate on all the sessions */

                now = janus_get_monotonic_time();

                if(old_sessions != NULL) {

                        GList *sl = old_sessions;

                        JANUS_LOG(LOG_HUGE, "Checking %d old SIP sessions...\n", g_list_length(old_sessions));

                        while(sl) {

                                janus_sip_session *session = (janus_sip_session *)sl->data;

                                if(!session) {

                                        sl = sl->next;

                                        continue;

                                }

                                if (now-session->destroyed >= 5*G_USEC_PER_SEC) {

                                        /* We're lazy and actually get rid of the stuff only after a few seconds */

                                        JANUS_LOG(LOG_VERB, "Freeing old SIP session\n");

                                        GList *rm = sl->next;

                                        old_sessions = g_list_delete_link(old_sessions, sl);

                                        sl = rm;

                                        if (session->account.identity) {

                                            g_hash_table_remove(identities, session->account.identity);

                                            g_free(session->account.identity);

                                            session->account.identity = NULL;

                                        }

                                        session->account.sips = TRUE;

                                        if (session->account.proxy) {

                                            g_free(session->account.proxy);

                                            session->account.proxy = NULL;

                                        }

                                        if (session->account.outbound_proxy) {

                                            g_free(session->account.outbound_proxy);

                                            session->account.outbound_proxy = NULL;

                                        }

                                        if (session->account.secret) {

                                            g_free(session->account.secret);

                                            session->account.secret = NULL;

                                        }

                                        if (session->account.username) {

                                            g_free(session->account.username);

                                            session->account.username = NULL;

                                        }

                                        if (session->account.display_name) {

                                            g_free(session->account.display_name);

                                            session->account.display_name = NULL;

                                        }

                                        if (session->account.user_agent) {

                                            g_free(session->account.user_agent);

                                            session->account.user_agent = NULL;

                                        }

                                        if (session->account.authuser) {

                                            g_free(session->account.authuser);

                                            session->account.authuser = NULL;

                                        }

                                        if (session->callee) {

                                            g_free(session->callee);

                                            session->callee = NULL;

                                        }

                                        if (session->callid) {

                                            g_hash_table_remove(callids, session->callid);

                                            g_free(session->callid);

                                            session->callid = NULL;

                                        }

                                        if (session->sdp) {

                                            janus_sdp_free(session->sdp);

                                            session->sdp = NULL;

                                        }

                                        if (session->transaction) {

                                            g_free(session->transaction);

                                            session->transaction = NULL;

                                        }

                                        if (session->media.remote_ip) {

                                            g_free(session->media.remote_ip);

                                            session->media.remote_ip = NULL;

                                        }

                                        janus_sip_srtp_cleanup(session);

                                        session->handle = NULL;

                                        g_free(session);

                                        session = NULL;

                                        continue;

                                }

                                sl = sl->next;

                        }

                }

                janus_mutex_unlock(&sessions_mutex);

                g_usleep(500000);

        }

        JANUS_LOG(LOG_INFO, "SIP watchdog stopped\n");

        return NULL;

}

/* Random string helper (for call-ids) */

static char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

static void janus_sip_random_string(int length, char *buffer) {

        if(length > 0 && buffer) {

                int l = (int)(sizeof(charset)-1);

                int i=0;

                for(i=0; i<length; i++) {

                        int key = rand() % l;

                        buffer[i] = charset[key];

                }

                buffer[length-1] = '\0';

        }

}

/* Sofia SIP logger function: when the Event Handlers mechanism is enabled,

 * we use this to intercept SIP messages sent by the stack (received

 * messages are more easily recoverable in janus_sip_sofia_callback) */

char sofia_log[2048];

char call_id[255];

gboolean skip = FALSE, started = FALSE, append = FALSE;

static void janus_sip_sofia_logger(void *stream, char const *fmt, va_list ap) {

        if(!fmt)

                return;

        char line[255];

        g_vsnprintf(line, sizeof(line), fmt, ap);

        if(skip) {

                /* This is a message we're not interested in: just check when it ends */

                if(line[3] == '-') {

                        skip = FALSE;

                        append = FALSE;

                }

                return;

        }

        if(append) {

                /* We're copying a message in our buffer: check if this is the end */

                if(line[3] == '-') {

                        if(!started) {

                                /* Ok, start appending from now on */

                                started = TRUE;

                                sofia_log[0] = '\0';

                                call_id[0] = '\0';

                        } else {

                                /* Message ended, handle it */

                                skip = FALSE;

                                append = FALSE;

                                /* Look for the session this message belongs to */

                                janus_sip_session *session = NULL;

                                if(strlen(call_id))

                                        session = g_hash_table_lookup(callids, call_id);

                                if(!session) {

                                        /* Couldn't find any SIP session with that Call-ID, check the request */

                                        if(strstr(sofia_log, "REGISTER") == sofia_log || strstr(sofia_log, "SIP/2.0 ") == sofia_log) {

                                                /* FIXME This is a REGISTER or a response code:

                                                 * check the To header and get the identity from there */

                                                char *from = strstr(sofia_log, "To: ");

                                                if(from) {

                                                        from = from+4;

                                                        char *start = strstr(from, "<");

                                                        if(start) {

                                                                start++;

                                                                char *end = strstr(from, ">");

                                                                if(end) {

                                                                        *end = '\0';

                                                                        g_snprintf(call_id, sizeof(call_id), "%s", start);

                                                                        *end = '>';

                                                                        session = g_hash_table_lookup(identities, call_id);

                                                                }

                                                        }

                                                }

                                        }

                                }

                                if(session) {

                                        /* Notify event handlers about the content of the whole outgoing SIP message */

                                        json_t *info = json_object();

                                        json_object_set_new(info, "event", json_string("sip-out"));

                                        json_object_set_new(info, "sip", json_string(sofia_log));

                                        gateway->notify_event(&janus_sip_plugin, session->handle, info);

                                } else {

                                        JANUS_LOG(LOG_WARN, "Couldn't find a session associated to this message, dropping it...\n%s", sofia_log);

                                }

                                /* Done, reset the buffers */

                                sofia_log[0] = '\0';

                                call_id[0] = '\0';

                        }

                        return;

                }

                if(strlen(line) == 1) {

                        /* Append a carriage and return */

                        g_strlcat(sofia_log, "\r\n", sizeof(sofia_log));

                } else {

                        /* If this is an OPTIONS, we don't care: drop it */

                        char *header = &line[3];

                        if(strstr(header, "OPTIONS") == header) {

                                skip = TRUE;

                                return;

                        }

                        /* Is this a Call-ID header? Keep note of it */

                        if(strstr(header, "Call-ID") == header) {

                                g_snprintf(call_id, sizeof(call_id), "%s", header+9);

                        }

                        /* Append the line to our buffer, skipping the indent */

                        g_strlcat(sofia_log, &line[3], sizeof(sofia_log));

                }

                return;

        }

        /* Still waiting to decide if this is a message we need */

        if(line[0] == 's' && line[1] == 'e' && line[2] == 'n' && line[3] == 'd' && line[4] == ' ') {

                /* An outgoing message is going to be logged, prepare for that */

                skip = FALSE;

                started = FALSE;

                append = TRUE;

                int length = atoi(&line[5]);

                JANUS_LOG(LOG_HUGE, "Intercepting message (%d bytes)\n", length);

                if(strstr(line, "-----"))

                        started = TRUE;

        }

}

/* Plugin implementation */

int janus_sip_init(janus_callbacks *callback, const char *config_path) {

        if(g_atomic_int_get(&stopping)) {

                /* Still stopping from before */

                return -1;

        }

        if(callback == NULL || config_path == NULL) {

                /* Invalid arguments */

                return -1;

        }

        /* Read configuration */

        char filename[255];

        g_snprintf(filename, 255, "%s/%s.cfg", config_path, JANUS_SIP_PACKAGE);

        JANUS_LOG(LOG_VERB, "Configuration file: %s\n", filename);

        janus_config *config = janus_config_parse(filename);

        if(config != NULL) {

                janus_config_print(config);

                janus_config_item *item = janus_config_get_item_drilldown(config, "general", "local_ip");

                if(item && item->value) {

                        /* Verify that the address is valid */

                        struct ifaddrs *ifas = NULL;

                        janus_network_address iface;

                        janus_network_address_string_buffer ibuf;

                        if(getifaddrs(&ifas) || ifas == NULL) {

                                JANUS_LOG(LOG_ERR, "Unable to acquire list of network devices/interfaces; some configurations may not work as expected...\n");

                        } else {

                                if(janus_network_lookup_interface(ifas, item->value, &iface) != 0) {

                                        JANUS_LOG(LOG_WARN, "Error setting local IP address to %s, falling back to detecting IP address...\n", item->value);

                                } else {

                                        if(janus_network_address_to_string_buffer(&iface, &ibuf) != 0 || janus_network_address_string_buffer_is_null(&ibuf)) {

                                                JANUS_LOG(LOG_WARN, "Error getting local IP address from %s, falling back to detecting IP address...\n", item->value);

                                        } else {

                                                local_ip = g_strdup(janus_network_address_string_from_buffer(&ibuf));

                                        }

                                }

                        }

                }

                item = janus_config_get_item_drilldown(config, "general", "keepalive_interval");

                if(item && item->value)

                        keepalive_interval = atoi(item->value);

                JANUS_LOG(LOG_VERB, "SIP keep-alive interval set to %d seconds\n", keepalive_interval);

                item = janus_config_get_item_drilldown(config, "general", "register_ttl");

                if(item && item->value)

                        register_ttl = atoi(item->value);

                JANUS_LOG(LOG_VERB, "SIP registration TTL set to %d seconds\n", register_ttl);

                item = janus_config_get_item_drilldown(config, "general", "behind_nat");

                if(item && item->value)

                        behind_nat = janus_is_true(item->value);

                item = janus_config_get_item_drilldown(config, "general", "user_agent");

                if(item && item->value)

                        user_agent = g_strdup(item->value);

                else

                        user_agent = g_strdup("Janus WebRTC Gateway SIP Plugin "JANUS_SIP_VERSION_STRING);

                JANUS_LOG(LOG_VERB, "SIP User-Agent set to %s\n", user_agent);

                item = janus_config_get_item_drilldown(config, "general", "events");

                if(item != NULL && item->value != NULL)

                        notify_events = janus_is_true(item->value);

                if(!notify_events && callback->events_is_enabled()) {

                        JANUS_LOG(LOG_WARN, "Notification of events to handlers disabled for %s\n", JANUS_SIP_NAME);

                }

                janus_config_destroy(config);

        }

        config = NULL;

        if(local_ip == NULL) {

                local_ip = janus_network_detect_local_ip_as_string(janus_network_query_options_any_ip);

                if(local_ip == NULL) {

                        JANUS_LOG(LOG_WARN, "Couldn't find any address! using 127.0.0.1 as the local IP... (which is NOT going to work out of your machine)\n");

                        local_ip = g_strdup("127.0.0.1");

                }

        }

        JANUS_LOG(LOG_VERB, "Local IP set to %s\n", local_ip);

#ifdef HAVE_SRTP_2

        /* Init randomizer (for randum numbers in SRTP) */

        RAND_poll();

#endif

        /* Setup sofia */

        su_init();

        if(callback->events_is_enabled()) {

                /* Enable the transport logging, as we want to have access to the SIP messages */

                setenv("TPORT_LOG", "1", 1);

                su_log_redirect(NULL, janus_sip_sofia_logger, NULL);

        }

        sessions = g_hash_table_new(NULL, NULL);

        callids = g_hash_table_new(g_str_hash, g_str_equal);

        identities = g_hash_table_new(g_str_hash, g_str_equal);

        janus_mutex_init(&sessions_mutex);

        messages = g_async_queue_new_full((GDestroyNotify) janus_sip_message_free);

        /* This is the callback we'll need to invoke to contact the gateway */

        gateway = callback;

        g_atomic_int_set(&initialized, 1);

        GError *error = NULL;

        /* Start the sessions watchdog */

        watchdog = g_thread_try_new("sip watchdog", &janus_sip_watchdog, NULL, &error);

        if(error != NULL) {

                g_atomic_int_set(&initialized, 0);

                JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the SIP watchdog thread...\n", error->code, error->message ? error->message : "??");

                return -1;

        }

        /* Launch the thread that will handle incoming messages */

        handler_thread = g_thread_try_new("sip handler", janus_sip_handler, NULL, &error);

        if(error != NULL) {

                g_atomic_int_set(&initialized, 0);

                JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the SIP handler thread...\n", error->code, error->message ? error->message : "??");

                return -1;

        }

        JANUS_LOG(LOG_INFO, "%s initialized!\n", JANUS_SIP_NAME);

        return 0;

}

void janus_sip_destroy(void) {

        if(!g_atomic_int_get(&initialized))

                return;

        g_atomic_int_set(&stopping, 1);

        g_async_queue_push(messages, &exit_message);

        if(handler_thread != NULL) {

                g_thread_join(handler_thread);

                handler_thread = NULL;

        }

        if(watchdog != NULL) {

                g_thread_join(watchdog);

                watchdog = NULL;

        }

        /* FIXME We should destroy the sessions cleanly */

        janus_mutex_lock(&sessions_mutex);

        g_hash_table_destroy(sessions);

        g_hash_table_destroy(callids);

        g_hash_table_destroy(identities);

        sessions = NULL;

        callids = NULL;

        identities = NULL;

        janus_mutex_unlock(&sessions_mutex);

        g_async_queue_unref(messages);

        messages = NULL;

        g_atomic_int_set(&initialized, 0);

        g_atomic_int_set(&stopping, 0);

        /* Deinitialize sofia */

        su_deinit();

        g_free(local_ip);

        JANUS_LOG(LOG_INFO, "%s destroyed!\n", JANUS_SIP_NAME);

}

int janus_sip_get_api_compatibility(void) {

        /* Important! This is what your plugin MUST always return: don't lie here or bad things will happen */

        return JANUS_PLUGIN_API_VERSION;

}

int janus_sip_get_version(void) {

        return JANUS_SIP_VERSION;

}

const char *janus_sip_get_version_string(void) {

        return JANUS_SIP_VERSION_STRING;

}

const char *janus_sip_get_description(void) {

        return JANUS_SIP_DESCRIPTION;

}

const char *janus_sip_get_name(void) {

        return JANUS_SIP_NAME;

}

const char *janus_sip_get_author(void) {

        return JANUS_SIP_AUTHOR;

}

const char *janus_sip_get_package(void) {

        return JANUS_SIP_PACKAGE;

}

void janus_sip_create_session(janus_plugin_session *handle, int *error) {

        if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized)) {

                *error = -1;

                return;

        }

        janus_sip_session *session = g_malloc0(sizeof(janus_sip_session));

        session->handle = handle;

        session->account.identity = NULL;

        session->account.sips = TRUE;

        session->account.username = NULL;

        session->account.display_name = NULL;

        session->account.user_agent = NULL;

        session->account.authuser = NULL;

        session->account.secret = NULL;

        session->account.secret_type = janus_sip_secret_type_unknown;

        session->account.sip_port = 0;

        session->account.proxy = NULL;

        session->account.outbound_proxy = NULL;

        session->account.registration_status = janus_sip_registration_status_unregistered;

        session->status = janus_sip_call_status_idle;

        session->stack = NULL;

        session->transaction = NULL;

        session->callee = NULL;

        session->callid = NULL;

        session->sdp = NULL;

        session->media.remote_ip = NULL;

        session->media.earlymedia = FALSE;

        session->media.ready = FALSE;

        session->media.autoack = TRUE;

        session->media.require_srtp = FALSE;

        session->media.has_srtp_local = FALSE;

        session->media.has_srtp_remote = FALSE;

        session->media.on_hold = FALSE;

        session->media.has_audio = FALSE;

        session->media.audio_rtp_fd = -1;

        session->media.audio_rtcp_fd= -1;

        session->media.local_audio_rtp_port = 0;

        session->media.remote_audio_rtp_port = 0;

        session->media.local_audio_rtcp_port = 0;

        session->media.remote_audio_rtcp_port = 0;

        session->media.audio_ssrc = 0;

        session->media.audio_ssrc_peer = 0;

        session->media.audio_pt = -1;

        session->media.audio_pt_name = NULL;

        session->media.audio_srtp_suite_in = 0;

        session->media.audio_srtp_suite_out = 0;

        session->media.audio_send = TRUE;

        session->media.pre_hold_audio_dir = JANUS_SDP_DEFAULT;

        session->media.has_video = FALSE;

        session->media.video_rtp_fd = -1;

        session->media.video_rtcp_fd= -1;

        session->media.local_video_rtp_port = 0;

        session->media.remote_video_rtp_port = 0;

        session->media.local_video_rtcp_port = 0;

        session->media.remote_video_rtcp_port = 0;

        session->media.video_ssrc = 0;

        session->media.video_ssrc_peer = 0;

        session->media.video_pt = -1;

        session->media.video_pt_name = NULL;

        session->media.video_srtp_suite_in = 0;

        session->media.video_srtp_suite_out = 0;

        session->media.video_send = TRUE;

        session->media.pre_hold_video_dir = JANUS_SDP_DEFAULT;

        /* Initialize the RTP context */

        janus_rtp_switching_context_reset(&session->media.context);

        session->media.pipefd[0] = -1;

        session->media.pipefd[1] = -1;

        session->media.updated = FALSE;

        janus_mutex_init(&session->rec_mutex);

        session->destroyed = 0;

        g_atomic_int_set(&session->hangingup, 0);

        janus_mutex_init(&session->mutex);

        handle->plugin_handle = session;

        janus_mutex_lock(&sessions_mutex);

        g_hash_table_insert(sessions, handle, session);

        janus_mutex_unlock(&sessions_mutex);

        return;

}

void janus_sip_destroy_session(janus_plugin_session *handle, int *error) {

        if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized)) {

                *error = -1;

                return;

        }

        janus_sip_session *session = (janus_sip_session *)handle->plugin_handle;

        if(!session) {

                JANUS_LOG(LOG_ERR, "No SIP session associated with this handle...\n");

                *error = -2;

                return;

        }

        janus_mutex_lock(&sessions_mutex);

        if(!session->destroyed) {

                g_hash_table_remove(sessions, handle);

                janus_sip_hangup_media(handle);

                session->destroyed = janus_get_monotonic_time();

                JANUS_LOG(LOG_VERB, "Destroying SIP session (%s)...\n", session->account.username ? session->account.username : "unregistered user");

                if(session->stack != NULL) {

                        /* Shutdown the NUA: this will remove the session later on */

                        nua_shutdown(session->stack->s_nua);

                } else {

                        /* No stack, maybe never registered: cleaning up and removing the session is done in a lazy way */

                        old_sessions = g_list_append(old_sessions, session);

                }

        }

        janus_mutex_unlock(&sessions_mutex);

        return;

}

json_t *janus_sip_query_session(janus_plugin_session *handle) {

        if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized)) {

                return NULL;

        }

        janus_sip_session *session = (janus_sip_session *)handle->plugin_handle;

        if(!session) {

                JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");

                return NULL;

        }

        /* Provide some generic info, e.g., if we're in a call and with whom */

        json_t *info = json_object();

        json_object_set_new(info, "username", session->account.username ? json_string(session->account.username) : NULL);

        json_object_set_new(info, "display_name", session->account.display_name ? json_string(session->account.display_name) : NULL);

        json_object_set_new(info, "user_agent", session->account.user_agent ? json_string(session->account.user_agent) : NULL);

        json_object_set_new(info, "identity", session->account.identity ? json_string(session->account.identity) : NULL);

        json_object_set_new(info, "registration_status", json_string(janus_sip_registration_status_string(session->account.registration_status)));

        json_object_set_new(info, "call_status", json_string(janus_sip_call_status_string(session->status)));

        if(session->callee) {

                json_object_set_new(info, "callee", json_string(session->callee ? session->callee : "??"));

                json_object_set_new(info, "auto-ack", json_string(session->media.autoack ? "yes" : "no"));

                json_object_set_new(info, "srtp-required", json_string(session->media.require_srtp ? "yes" : "no"));

                json_object_set_new(info, "sdes-local", json_string(session->media.has_srtp_local ? "yes" : "no"));

                json_object_set_new(info, "sdes-remote", json_string(session->media.has_srtp_remote ? "yes" : "no"));

        }

        if(session->arc || session->vrc || session->arc_peer || session->vrc_peer) {

                json_t *recording = json_object();

                if(session->arc && session->arc->filename)

                        json_object_set_new(recording, "audio", json_string(session->arc->filename));

                if(session->vrc && session->vrc->filename)

                        json_object_set_new(recording, "video", json_string(session->vrc->filename));

                if(session->arc_peer && session->arc_peer->filename)

                        json_object_set_new(recording, "audio-peer", json_string(session->arc_peer->filename));

                if(session->vrc_peer && session->vrc_peer->filename)

                        json_object_set_new(recording, "video-peer", json_string(session->vrc_peer->filename));

                json_object_set_new(info, "recording", recording);

        }

        json_object_set_new(info, "destroyed", json_integer(session->destroyed));

        return info;

}

struct janus_plugin_result *janus_sip_handle_message(janus_plugin_session *handle, char *transaction, json_t *message, json_t *jsep) {

        if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))

                return janus_plugin_result_new(JANUS_PLUGIN_ERROR, g_atomic_int_get(&stopping) ? "Shutting down" : "Plugin not initialized", NULL);

        janus_sip_message *msg = g_malloc0(sizeof(janus_sip_message));

        msg->handle = handle;

        msg->transaction = transaction;

        msg->message = message;

        msg->jsep = jsep;

        g_async_queue_push(messages, msg);

        /* All the requests to this plugin are handled asynchronously */

        return janus_plugin_result_new(JANUS_PLUGIN_OK_WAIT, NULL, NULL);

}

void janus_sip_setup_media(janus_plugin_session *handle) {

        JANUS_LOG(LOG_INFO, "WebRTC media is now available\n");

        if(g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))

                return;

        janus_sip_session *session = (janus_sip_session *)handle->plugin_handle;

        if(!session) {

                JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");

                return;

        }

        if(session->destroyed)

                return;

        g_atomic_int_set(&session->hangingup, 0);

        /* TODO Only relay RTP/RTCP when we get this event */

}

void janus_sip_incoming_rtp(janus_plugin_session *handle, int video, char *buf, int len) {

        if(handle == NULL || handle->stopped || g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))

                return;

        if(gateway) {

                /* Honour the audio/video active flags */

                janus_sip_session *session = (janus_sip_session *)handle->plugin_handle;

                if(!session || session->destroyed) {

                        JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");

                        return;

                }

                if(session->status != janus_sip_call_status_incall)

                        return;

                /* Forward to our SIP peer */

                if(video) {

                        if(!session->media.video_send) {

                                /* Dropping video packet, peer doesn't want to receive it */

                                return;

                        }

                        if(session->media.video_ssrc == 0) {

                                rtp_header *header = (rtp_header *)buf;

                                session->media.video_ssrc = ntohl(header->ssrc);

                                JANUS_LOG(LOG_VERB, "Got SIP video SSRC: %"SCNu32"\n", session->media.video_ssrc);

                        }

                        if(session->media.has_video && session->media.video_rtp_fd != -1) {

                                /* Save the frame if we're recording */

                                janus_recorder_save_frame(session->vrc, buf, len);

                                /* Is SRTP involved? */

                                if(session->media.has_srtp_local) {

                                        char sbuf[2048];

                                        memcpy(&sbuf, buf, len);

                                        int protected = len;

                                        int res = srtp_protect(session->media.video_srtp_out, &sbuf, &protected);

                                        if(res != srtp_err_status_ok) {

                                                rtp_header *header = (rtp_header *)&sbuf;

                                                guint32 timestamp = ntohl(header->timestamp);

                                                guint16 seq = ntohs(header->seq_number);

                                                JANUS_LOG(LOG_ERR, "[SIP-%s] Video SRTP protect error... %s (len=%d-->%d, ts=%"SCNu32", seq=%"SCNu16")...\n",

                                                        session->account.username, janus_srtp_error_str(res), len, protected, timestamp, seq);

                                        } else {

                                                /* Forward the frame to the peer */

                                                send(session->media.video_rtp_fd, sbuf, protected, 0);

                                        }

                                } else {

                                        /* Forward the frame to the peer */

                                        send(session->media.video_rtp_fd, buf, len, 0);

                                }

                        }

                } else {

                        if(!session->media.audio_send) {

                                /* Dropping audio packet, peer doesn't want to receive it */

                                return;

                        }

                        if(session->media.audio_ssrc == 0) {

                                rtp_header *header = (rtp_header *)buf;

                                session->media.audio_ssrc = ntohl(header->ssrc);

                                JANUS_LOG(LOG_VERB, "Got SIP audio SSRC: %"SCNu32"\n", session->media.audio_ssrc);

                        }

                        if(session->media.has_audio && session->media.audio_rtp_fd != -1) {

                                /* Save the frame if we're recording */

                                janus_recorder_save_frame(session->arc, buf, len);

                                /* Is SRTP involved? */

                                if(session->media.has_srtp_local) {

                                        char sbuf[2048];

                                        memcpy(&sbuf, buf, len);

                                        int protected = len;

                                        int res = srtp_protect(session->media.audio_srtp_out, &sbuf, &protected);

                                        if(res != srtp_err_status_ok) {

                                                rtp_header *header = (rtp_header *)&sbuf;

                                                guint32 timestamp = ntohl(header->timestamp);

                                                guint16 seq = ntohs(header->seq_number);

                                                JANUS_LOG(LOG_ERR, "[SIP-%s] Audio SRTP protect error... %s (len=%d-->%d, ts=%"SCNu32", seq=%"SCNu16")...\n",

                                                        session->account.username, janus_srtp_error_str(res), len, protected, timestamp, seq);

                                        } else {

                                                /* Forward the frame to the peer */

                                                send(session->media.audio_rtp_fd, sbuf, protected, 0);

                                        }

                                } else {

                                        /* Forward the frame to the peer */

                                        send(session->media.audio_rtp_fd, buf, len, 0);

                                }

                        }

                }

        }

}

void janus_sip_incoming_rtcp(janus_plugin_session *handle, int video, char *buf, int len) {

        if(handle == NULL || handle->stopped || g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))

                return;

        if(gateway) {

                janus_sip_session *session = (janus_sip_session *)handle->plugin_handle;

                if(!session || session->destroyed) {

                        JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");

                        return;

                }

                if(session->status != janus_sip_call_status_incall)

                        return;

                /* Forward to our SIP peer */

                if(video) {

                        if(session->media.has_video && session->media.video_rtcp_fd != -1) {

                                /* Fix SSRCs as the gateway does */

                                JANUS_LOG(LOG_HUGE, "[SIP] Fixing SSRCs (local %u, peer %u)\n",

                                        session->media.video_ssrc, session->media.video_ssrc_peer);

                                janus_rtcp_fix_ssrc(NULL, (char *)buf, len, 1, session->media.video_ssrc, session->media.video_ssrc_peer);

                                /* Is SRTP involved? */

                                if(session->media.has_srtp_local) {

                                        char sbuf[2048];

                                        memcpy(&sbuf, buf, len);

                                        int protected = len;

                                        int res = srtp_protect_rtcp(session->media.video_srtp_out, &sbuf, &protected);

                                        if(res != srtp_err_status_ok) {

                                                JANUS_LOG(LOG_ERR, "[SIP-%s] Video SRTCP protect error... %s (len=%d-->%d)...\n",

                                                        session->account.username, janus_srtp_error_str(res), len, protected);

                                        } else {

                                                /* Forward the message to the peer */

                                                send(session->media.video_rtcp_fd, sbuf, protected, 0);

                                        }

                                } else {

                                        /* Forward the message to the peer */

                                        send(session->media.video_rtcp_fd, buf, len, 0);

                                }

                        }

                } else {

                        if(session->media.has_audio && session->media.audio_rtcp_fd != -1) {

                                /* Fix SSRCs as the gateway does */

                                JANUS_LOG(LOG_HUGE, "[SIP] Fixing SSRCs (local %u, peer %u)\n",