PeerStreamer-ng

/*! \file   janus_sipre.c

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

 * \copyright GNU General Public License v3

 * \brief  Janus SIPre plugin (libre)

 * \details  This is basically a clone of the SIPre plugin, with the key

 * difference being that it uses \c libre (http://creytiv.com/re.html)

 * instead of Sofia SIP for its internal stack. As such, it provides an

 * alternative for those who don't want to, or can't, use the Sofia-based

 * SIP plugin. The API it exposes is exactly the same, meaning it should

 * be pretty straightforward to switch from one plugin to another on the

 * client side. The configuration file looks exactly the same as well.

 *

 * \section sipapi SIPre Plugin API

 *

 * All requests you can send in the SIPre 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 <sys/socket.h>

#include <netdb.h>

#include <poll.h>

#include <jansson.h>

#include <re_types.h>

#include <re_fmt.h>

#include <re_mbuf.h>

#include <re_msg.h>

#include <re_list.h>

#include <re_sa.h>

#include <re_main.h>

#include <re_mem.h>

#include <re_mqueue.h>

#include <re_sdp.h>

#include <re_uri.h>

#include <re_sip.h>

#include <re_sipreg.h>

#include <re_sipsess.h>

#include <re_srtp.h>

#include <re_tmr.h>

#include <re_tls.h>

#include <re_dns.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_SIPRE_VERSION                        1

#define JANUS_SIPRE_VERSION_STRING        "0.0.1"

#define JANUS_SIPRE_DESCRIPTION                "This is a simple SIP plugin for Janus (based on libre instead of Sofia), allowing WebRTC peers to register at a SIP server and call SIP user agents through the gateway."

#define JANUS_SIPRE_NAME                        "JANUS SIPre plugin"

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

#define JANUS_SIPRE_PACKAGE                        "janus.plugin.sipre"

/* Plugin methods */

janus_plugin *create(void);

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

void janus_sipre_destroy(void);

int janus_sipre_get_api_compatibility(void);

int janus_sipre_get_version(void);

const char *janus_sipre_get_version_string(void);

const char *janus_sipre_get_description(void);

const char *janus_sipre_get_name(void);

const char *janus_sipre_get_author(void);

const char *janus_sipre_get_package(void);

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

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

void janus_sipre_setup_media(janus_plugin_session *handle);

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

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

void janus_sipre_hangup_media(janus_plugin_session *handle);

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

json_t *janus_sipre_query_session(janus_plugin_session *handle);

/* Plugin setup */

static janus_plugin janus_sipre_plugin =

        JANUS_PLUGIN_INIT (

                .init = janus_sipre_init,

                .destroy = janus_sipre_destroy,

                .get_api_compatibility = janus_sipre_get_api_compatibility,

                .get_version = janus_sipre_get_version,

                .get_version_string = janus_sipre_get_version_string,

                .get_description = janus_sipre_get_description,

                .get_name = janus_sipre_get_name,

                .get_author = janus_sipre_get_author,

                .get_package = janus_sipre_get_package,

                .create_session = janus_sipre_create_session,

                .handle_message = janus_sipre_handle_message,

                .setup_media = janus_sipre_setup_media,

                .incoming_rtp = janus_sipre_incoming_rtp,

                .incoming_rtcp = janus_sipre_incoming_rtcp,

                .hangup_media = janus_sipre_hangup_media,

                .destroy_session = janus_sipre_destroy_session,

                .query_session = janus_sipre_query_session,

        );

/* Plugin creator */

janus_plugin *create(void) {

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

        return &janus_sipre_plugin;

}

/* Parameter validation */

static struct janus_json_parameter request_parameters[] = {

        {"request", JANUS_JSON_STRING, JANUS_JSON_PARAM_REQUIRED}

};

static struct janus_json_parameter register_parameters[] = {

        {"type", JANUS_JSON_STRING, 0},

        {"send_register", JANUS_JSON_BOOL, 0},

        {"sips", JANUS_JSON_BOOL, 0},

        {"username", JANUS_JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"secret", JANUS_JSON_STRING, 0},

        {"authuser", JANUS_JSON_STRING, 0},

        {"headers", JANUS_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", JANUS_JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"autoack", JANUS_JSON_BOOL, 0},

        {"headers", JANUS_JSON_OBJECT, 0},

        {"srtp", JANUS_JSON_STRING, 0}

};

static struct janus_json_parameter accept_parameters[] = {

        {"srtp", JANUS_JSON_STRING, 0}

};

static struct janus_json_parameter recording_parameters[] = {

        {"action", JANUS_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", JANUS_JSON_STRING, 0}

};

static struct janus_json_parameter dtmf_info_parameters[] = {

        {"digit", JANUS_JSON_STRING, JANUS_JSON_PARAM_REQUIRED},

        {"duration", JANUS_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 gboolean behind_nat = FALSE;

static char *user_agent;

#define JANUS_DEFAULT_REGISTER_TTL        3600

static uint32_t register_ttl = JANUS_DEFAULT_REGISTER_TTL;

static GThread *handler_thread;

static GThread *watchdog;

static void *janus_sipre_handler(void *data);

typedef struct janus_sipre_message {

        janus_plugin_session *handle;

        char *transaction;

        json_t *message;

        json_t *jsep;

} janus_sipre_message;

static GAsyncQueue *messages = NULL;

static janus_sipre_message exit_message;

static void janus_sipre_message_free(janus_sipre_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);

}

/* libre SIP stack */

static volatile int libre_inited = 0;

GThread *sipstack_thread = NULL;

/* Message queue */

static struct mqueue *mq = NULL;

void janus_sipre_mqueue_handler(int id, void *data, void *arg);

typedef enum janus_sipre_mqueue_event {

        janus_sipre_mqueue_event_do_init,

        janus_sipre_mqueue_event_do_register,

        janus_sipre_mqueue_event_do_unregister,

        janus_sipre_mqueue_event_do_call,

        janus_sipre_mqueue_event_do_accept,

        janus_sipre_mqueue_event_do_rcode,

        janus_sipre_mqueue_event_do_update,

        janus_sipre_mqueue_event_do_info,

        janus_sipre_mqueue_event_do_message,

        janus_sipre_mqueue_event_do_bye,

        janus_sipre_mqueue_event_do_destroy,

        /* TODO Add other events here */

        janus_sipre_mqueue_event_do_exit

} janus_sipre_mqueue_event;

static const char *janus_sipre_mqueue_event_string(janus_sipre_mqueue_event event) {

        switch(event) {

                case janus_sipre_mqueue_event_do_init:

                        return "init";

                case janus_sipre_mqueue_event_do_register:

                        return "register";

                case janus_sipre_mqueue_event_do_unregister:

                        return "unregister";

                case janus_sipre_mqueue_event_do_call:

                        return "call";

                case janus_sipre_mqueue_event_do_accept:

                        return "accept";

                case janus_sipre_mqueue_event_do_rcode:

                        return "rcode";

                case janus_sipre_mqueue_event_do_update:

                        return "update";

                case janus_sipre_mqueue_event_do_info:

                        return "info";

                case janus_sipre_mqueue_event_do_message:

                        return "message";

                case janus_sipre_mqueue_event_do_bye:

                        return "bye";

                case janus_sipre_mqueue_event_do_destroy:

                        return "destroy";

                case janus_sipre_mqueue_event_do_exit:

                        return "exit";

                default:

                        return "unknown";

        }

}

typedef struct janus_sipre_mqueue_payload {

        void *session;                                /* The session this event refers to */

        const struct sip_msg *msg;        /* The SIP message this refers to, if any */

        int rcode;                                        /* The error code to send back, if any */

        void *data;                                        /* Payload specific data */

} janus_sipre_mqueue_payload;

static janus_sipre_mqueue_payload *janus_sipre_mqueue_payload_create(void *session, const struct sip_msg *msg, int rcode, void *data) {

        janus_sipre_mqueue_payload *payload = g_malloc0(sizeof(janus_sipre_mqueue_payload));

        payload->session = session;

        payload->msg = msg;

        payload->rcode = rcode;

        payload->data = data;

        return payload;

}

/* Helper to quickly get the reason associated to response codes */

static const char *janus_sipre_error_reason(int rcode) {

        switch(rcode) {

                case 100: return "Trying";

                case 180: return "Ringing";

                case 181: return "Call is Being Forwarded";

                case 182: return "Queued";

                case 183: return "Session in Progress";

                case 199: return "Early Dialog Terminated";

                case 200: return "OK";

                case 202: return "Accepted";

                case 204: return "No Notification";

                case 300: return "Multiple Choices";

                case 301: return "Moved Permanently";

                case 302: return "Moved Temporarily";

                case 305: return "Use Proxy";

                case 380: return "Alternative Service";

                case 400: return "Bad Request";

                case 401: return "Unauthorized";

                case 402: return "Payment Required";

                case 403: return "Forbidden";

                case 404: return "Not Found";

                case 405: return "Method Not Allowed";

                case 406: return "Not Acceptable";

                case 407: return "Proxy Authentication Required";

                case 408: return "Request Timeout";

                case 409: return "Conflict";

                case 410: return "Gone";

                case 411: return "Length Required";

                case 412: return "Conditional Request Failed";

                case 413: return "Request Entity Too Large";

                case 414: return "Request-URI Too Long";

                case 415: return "Unsupported Media Type";

                case 416: return "Unsupported URI Scheme";

                case 417: return "Unknown Resource-Priority";

                case 420: return "Bad Extension";

                case 421: return "Extension Required";

                case 422: return "Session Interval Too Small";

                case 423: return "Interval Too Brief";

                case 424: return "Bad Location Information";

                case 428: return "Use Identity Header";

                case 429: return "Provide Referrer Identity";

                case 430: return "Flow Failed";

                case 433: return "Anonymity Disallowed";

                case 436: return "Bad Identity-Info";

                case 437: return "Unsupported Certificate";

                case 438: return "Invalid Identity Header";

                case 439: return "First Hop Lacks Outbound Support";

                case 470: return "Consent Needed";

                case 480: return "Temporarily Unavailable";

                case 481: return "Call/Transaction Does Not Exist";

                case 482: return "Loop Detected.";

                case 483: return "Too Many Hops";

                case 484: return "Address Incomplete";

                case 485: return "Ambiguous";

                case 486: return "Busy Here";

                case 487: return "Request Terminated";

                case 488: return "Not Acceptable Here";

                case 489: return "Bad Event";

                case 491: return "Request Pending";

                case 493: return "Undecipherable";

                case 494: return "Security Agreement Required";

                case 500: return "Server Internal Error";

                case 501: return "Not Implemented";

                case 502: return "Bad Gateway";

                case 503: return "Service Unavailable";

                case 504: return "Server Time-out";

                case 505: return "Version Not Supported";

                case 513: return "Message Too Large";

                case 580: return "Precondition Failure";

                case 600: return "Busy Everywhere";

                case 603: return "Decline";

                case 604: return "Does Not Exist Anywhere";

                case 606: return "Not Acceptable";

                default: return "Unknown Error";

        }

}

/* Registration info */

typedef enum {

        janus_sipre_registration_status_disabled = -2,

        janus_sipre_registration_status_failed = -1,

        janus_sipre_registration_status_unregistered = 0,

        janus_sipre_registration_status_registering,

        janus_sipre_registration_status_registered,

        janus_sipre_registration_status_unregistering,

} janus_sipre_registration_status;

static const char *janus_sipre_registration_status_string(janus_sipre_registration_status status) {

        switch(status) {

                case janus_sipre_registration_status_disabled:

                        return "disabled";

                case janus_sipre_registration_status_failed:

                        return "failed";

                case janus_sipre_registration_status_unregistered:

                        return "unregistered";

                case janus_sipre_registration_status_registering:

                        return "registering";

                case janus_sipre_registration_status_registered:

                        return "registered";

                case janus_sipre_registration_status_unregistering:

                        return "unregistering";

                default:

                        return "unknown";

        }

}

typedef enum {

        janus_sipre_call_status_idle = 0,

        janus_sipre_call_status_inviting,

        janus_sipre_call_status_invited,

        janus_sipre_call_status_incall,

        janus_sipre_call_status_closing,

} janus_sipre_call_status;

static const char *janus_sipre_call_status_string(janus_sipre_call_status status) {

        switch(status) {

                case janus_sipre_call_status_idle:

                        return "idle";

                case janus_sipre_call_status_inviting:

                        return "inviting";

                case janus_sipre_call_status_invited:

                        return "invited";

                case janus_sipre_call_status_incall:

                        return "incall";

                case janus_sipre_call_status_closing:

                        return "closing";

                default:

                        return "unknown";

        }

}

typedef enum {

        janus_sipre_secret_type_plaintext = 1,

        janus_sipre_secret_type_hashed = 2,

        janus_sipre_secret_type_unknown

} janus_sipre_secret_type;

typedef struct janus_sipre_account {

        char *identity;

        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_sipre_secret_type secret_type;

        int sip_port;

        char *proxy;

        char *outbound_proxy;

        janus_sipre_registration_status registration_status;

} janus_sipre_account;

typedef struct janus_sipre_stack {

        struct sip *sipstack;                                /* SIP stack */

        struct tls *tls;                                        /* TLS transport, if needed */

        struct sipsess *sess;                                /* SIP session */

        struct sipsess_sock *sess_sock;                /* SIP session socket */

        struct sipreg *reg;                                        /* SIP registration */

        struct dnsc *dns_client;                        /* DNS client */

        uint32_t expires;                                        /* Registration interval (seconds) */

        const struct sip_msg *invite;                /* Current INVITE */

        void *session;                                                /* Opaque pointer to the plugin session */

} janus_sipre_stack;

typedef struct janus_sipre_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_sipre_media;

typedef struct janus_sipre_session {

        janus_plugin_session *handle;

        janus_sipre_stack stack;

        janus_sipre_account account;

        janus_sipre_call_status status;

        janus_sipre_media media;

        char *transaction;

        char *callee;

        char *callid;

        char *temp_sdp;

        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_sipre_session;

static GHashTable *sessions;

static GList *old_sessions;

static GHashTable *identities;

static GHashTable *callids;

static janus_mutex sessions_mutex;

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

static int janus_sipre_srtp_set_local(janus_sipre_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_sipre_srtp_set_remote(janus_sipre_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_sipre_srtp_cleanup(janus_sipre_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;

}

/* libre event thread */

gpointer janus_sipre_stack_thread(gpointer user_data);

/* libre callbacks */

int janus_sipre_cb_auth(char **user, char **pass, const char *realm, void *arg);

void janus_sipre_cb_register(int err, const struct sip_msg *msg, void *arg);

void janus_sipre_cb_progress(const struct sip_msg *msg, void *arg);

void janus_sipre_cb_incoming(const struct sip_msg *msg, void *arg);

int janus_sipre_cb_offer(struct mbuf **mbp, const struct sip_msg *msg, void *arg);

int janus_sipre_cb_answer(const struct sip_msg *msg, void *arg);

void janus_sipre_cb_established(const struct sip_msg *msg, void *arg);

void janus_sipre_cb_info(struct sip *sip, const struct sip_msg *msg, void *arg);

void janus_sipre_cb_closed(int err, const struct sip_msg *msg, void *arg);

void janus_sipre_cb_exit(void *arg);

/* URI parsing utilities */

static int janus_sipre_parse_uri(const char *uri) {

        if(uri == NULL)

                return -1;

        struct sip_addr addr;

        struct pl pluri;

        pl_set_str(&pluri, uri);

        if(sip_addr_decode(&addr, &pluri) != 0)

                return -1;

        return 0;

}

static char *janus_sipre_get_uri_username(const char *uri) {

        if(uri == NULL)

                return NULL;

        struct sip_addr addr;

        struct pl pluri;

        pl_set_str(&pluri, uri);

        if(sip_addr_decode(&addr, &pluri) != 0)

                return NULL;

        char *at = strchr(addr.uri.user.p, '@');

        if(at != NULL)

                *(at) = '\0';

        char *username = g_strdup(addr.uri.user.p);

        if(at != NULL)

                *(at) = '@';

        return username;

}

static char *janus_sipre_get_uri_host(const char *uri) {

        if(uri == NULL)

                return NULL;

        struct sip_addr addr;

        struct pl pluri;

        pl_set_str(&pluri, uri);

        if(sip_addr_decode(&addr, &pluri) != 0)

                return NULL;

        return g_strdup(addr.uri.host.p);

}

static uint16_t janus_sipre_get_uri_port(const char *uri) {

        if(uri == NULL)

                return 0;

        struct sip_addr addr;

        struct pl pluri;

        pl_set_str(&pluri, uri);

        if(sip_addr_decode(&addr, &pluri) != 0)

                return 0;

        return addr.uri.port;

}

/* SDP parsing and manipulation */

void janus_sipre_sdp_process(janus_sipre_session *session, janus_sdp *sdp, gboolean answer, gboolean update, gboolean *changed);

char *janus_sipre_sdp_manipulate(janus_sipre_session *session, janus_sdp *sdp, gboolean answer);

/* Media */

static int janus_sipre_allocate_local_ports(janus_sipre_session *session);

static void *janus_sipre_relay_thread(void *data);

/* Error codes */

#define JANUS_SIPRE_ERROR_UNKNOWN_ERROR                499

#define JANUS_SIPRE_ERROR_NO_MESSAGE                        440

#define JANUS_SIPRE_ERROR_INVALID_JSON                441

#define JANUS_SIPRE_ERROR_INVALID_REQUEST                442

#define JANUS_SIPRE_ERROR_MISSING_ELEMENT                443

#define JANUS_SIPRE_ERROR_INVALID_ELEMENT                444

#define JANUS_SIPRE_ERROR_ALREADY_REGISTERED        445

#define JANUS_SIPRE_ERROR_INVALID_ADDRESS                446

#define JANUS_SIPRE_ERROR_WRONG_STATE                        447

#define JANUS_SIPRE_ERROR_MISSING_SDP                        448

#define JANUS_SIPRE_ERROR_LIBRE_ERROR                449

#define JANUS_SIPRE_ERROR_IO_ERROR                        450

#define JANUS_SIPRE_ERROR_RECORDING_ERROR                451

#define JANUS_SIPRE_ERROR_TOO_STRICT                        452

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

static void *janus_sipre_watchdog(void *data) {

        JANUS_LOG(LOG_INFO, "SIPre 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 SIPre sessions...\n", g_list_length(old_sessions));

                        while(sl) {

                                janus_sipre_session *session = (janus_sipre_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 SIPre session\n");

                                        GList *rm = sl->next;

                                        old_sessions = g_list_delete_link(old_sessions, sl);

                                        sl = rm;

                                        sipsess_close_all(session->stack.sess_sock);

                                        sip_close(session->stack.sipstack, FALSE);

                                        session->stack.sipstack = NULL;

                                        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.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_sipre_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, "SIPre watchdog stopped\n");

        return NULL;

}

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

static char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

static void janus_sipre_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';

        }

}

#ifdef HAVE_LIBRE_SIPTRACE

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

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

static void janus_sipre_msg_logger(bool tx, enum sip_transp tp, const struct sa *src, const struct sa *dst,

                const uint8_t *pkt, size_t len, void *arg) {

        /* Access the session this message refers to */

        janus_sipre_session *session = (janus_sipre_session *)arg;

        /* Print the SIP message */

        char sip_msg[2048];

        g_snprintf(sip_msg, sizeof(sip_msg), "%.*s", (int)len, (char *)pkt);

        /* Shoot the event */

        json_t *info = json_object();

        json_object_set_new(info, "event", json_string(tx ? "sip-out" : "sip-in"));

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

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

}

#endif

/* Plugin implementation */

int janus_sipre_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_SIPRE_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", "register_ttl");

                if(item && item->value) {

                        register_ttl = atol(item->value);

                        if(register_ttl <= 0) {

                                JANUS_LOG(LOG_WARN, "Invalid value of register_ttl, using default instead\n");

                                register_ttl = JANUS_DEFAULT_REGISTER_TTL;

                        }

                }

                JANUS_LOG(LOG_VERB, "SIPre 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 SIPre Plugin "JANUS_SIPRE_VERSION_STRING);

                }

                JANUS_LOG(LOG_VERB, "SIPre 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_SIPRE_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

        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_sipre_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("sipre watchdog", &janus_sipre_watchdog, NULL, &error);

        if(error != NULL) {

                g_atomic_int_set(&initialized, 0);

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

                return -1;

        }

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

        handler_thread = g_thread_try_new("sipre handler", janus_sipre_handler, NULL, &error);

        if(error != NULL) {

                g_atomic_int_set(&initialized, 0);

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

                return -1;

        }

        /* Launch the thread that will handle the libre initialization and event loop */

        g_atomic_int_set(&libre_inited, 0);

        sipstack_thread = g_thread_try_new("sipre loop", janus_sipre_stack_thread, NULL, &error);

        if(error != NULL) {

                g_atomic_int_set(&initialized, 0);

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

                return -1;

        }

        /* Let's wait for the libre initialization to complete */

        while(g_atomic_int_get(&libre_inited) == 0)

                g_usleep(100000);

        if(g_atomic_int_get(&libre_inited) == -1) {

                g_atomic_int_set(&initialized, 0);

                JANUS_LOG(LOG_ERR, "Got error trying to initialize libre...\n");

                return -1;

        }

#ifndef HAVE_LIBRE_SIPTRACE

        JANUS_LOG(LOG_WARN, "sip_set_trace() was not found in libre... "

                "The tracing of SIP incoming/outgoing SIP messages when using the SIPre plugin will not be available to Event Handlers. "

                "In case you're interested in that, apply this patch on your libre installation and recompile the plugin: "

                "https://raw.githubusercontent.com/alfredh/patches/master/re-sip-trace.patch\n");

#endif

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

        return 0;

}

void janus_sipre_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;

        }

        /* Break the libre loop */

        mqueue_push(mq, janus_sipre_mqueue_event_do_exit, NULL);

        if(sipstack_thread != NULL) {

                g_thread_join(sipstack_thread);

                sipstack_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);

        g_free(local_ip);

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

}

int janus_sipre_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_sipre_get_version(void) {

        return JANUS_SIPRE_VERSION;

}

const char *janus_sipre_get_version_string(void) {

        return JANUS_SIPRE_VERSION_STRING;

}

const char *janus_sipre_get_description(void) {

        return JANUS_SIPRE_DESCRIPTION;

}

const char *janus_sipre_get_name(void) {

        return JANUS_SIPRE_NAME;

}

const char *janus_sipre_get_author(void) {

        return JANUS_SIPRE_AUTHOR;

}

const char *janus_sipre_get_package(void) {

        return JANUS_SIPRE_PACKAGE;

}

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

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

                *error = -1;

                return;

        }

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

        session->handle = handle;

        session->account.identity = NULL;

        session->account.sips = TRUE;

        session->account.username = NULL;

        session->account.display_name = NULL;

        session->account.authuser = NULL;

        session->account.secret = NULL;

        session->account.secret_type = janus_sipre_secret_type_unknown;

        session->account.sip_port = 0;

        session->account.proxy = NULL;

        session->account.outbound_proxy = NULL;

        session->account.registration_status = janus_sipre_registration_status_unregistered;

        session->status = janus_sipre_call_status_idle;

        memset(&session->stack, 0, sizeof(janus_sipre_stack));

        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;

        mqueue_push(mq, janus_sipre_mqueue_event_do_init, janus_sipre_mqueue_payload_create(session, NULL, 0, NULL));

        janus_mutex_lock(&sessions_mutex);

        g_hash_table_insert(sessions, handle, session);

        janus_mutex_unlock(&sessions_mutex);

        return;

}

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

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

                *error = -1;

                return;

        }

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

        if(!session) {

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

                *error = -2;

                return;

        }

        janus_mutex_lock(&sessions_mutex);

        if(!session->destroyed) {

                g_hash_table_remove(sessions, handle);

                janus_sipre_hangup_media(handle);

                session->destroyed = janus_get_monotonic_time();

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

                /* Unregister */

                mqueue_push(mq, janus_sipre_mqueue_event_do_unregister, janus_sipre_mqueue_payload_create(session, NULL, 0, NULL));

                /* Destroy re-related stuff for this SIP session */

                mqueue_push(mq, janus_sipre_mqueue_event_do_destroy, janus_sipre_mqueue_payload_create(session, NULL, 0, NULL));

                /* 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_sipre_query_session(janus_plugin_session *handle) {

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

                return NULL;

        }

        janus_sipre_session *session = (janus_sipre_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, "identity", session->account.identity ? json_string(session->account.identity) : NULL);

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

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