res_rtp_multicast.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2009, Digium, Inc.
 *
 * Joshua Colp <[email protected]>
 * Andreas 'MacBrody' Brodmann <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*!
 * \file
 *
 * \brief Multicast RTP Engine
 *
 * \author Joshua Colp <[email protected]>
 * \author Andreas 'MacBrody' Brodmann <[email protected]>
 *
 * \ingroup rtp_engines
 */

/*** MODULEINFO
 <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <sys/time.h>
#include <signal.h>
#include <fcntl.h>
#include <math.h>

#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/channel.h"
#include "asterisk/acl.h"
#include "asterisk/config.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/unaligned.h"
#include "asterisk/module.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/format_cache.h"
#include "asterisk/multicast_rtp.h"
#include "asterisk/app.h"
#include "asterisk/smoother.h"

/*! Command value used for Linksys paging to indicate we are starting */
#define LINKSYS_MCAST_STARTCMD 6

/*! Command value used for Linksys paging to indicate we are stopping */
#define LINKSYS_MCAST_STOPCMD 7

/*! \brief Type of paging to do */
enum multicast_type {
 /*! Type has not been set yet */
 MULTICAST_TYPE_UNSPECIFIED = 0,
 /*! Simple multicast enabled client/receiver paging like Snom and Barix uses */
 MULTICAST_TYPE_BASIC,
 /*! More advanced Linksys type paging which requires a start and stop packet */
 MULTICAST_TYPE_LINKSYS,
};

/*! \brief Structure for a Linksys control packet */
struct multicast_control_packet {
 /*! Unique identifier for the control packet */
 uint32_t unique_id;
 /*! Actual command in the control packet */
 uint32_t command;
 /*! IP address for the RTP */
 uint32_t ip;
 /*! Port for the RTP */
 uint32_t port;
};

/*! \brief Structure for a multicast paging instance */
struct multicast_rtp {
 /*! TYpe of multicast paging this instance is doing */
 enum multicast_type type;
 /*! Socket used for sending the audio on */
 int socket;
 /*! Synchronization source value, used when creating/sending the RTP packet */
 unsigned int ssrc;
 /*! Sequence number, used when creating/sending the RTP packet */
 uint16_t seqno;
 unsigned int lastts;
 struct timeval txcore;
 struct ast_smoother *smoother;
};

#define MAX_TIMESTAMP_SKEW 640

enum {
 OPT_CODEC = (1 << 0),
 OPT_LOOP = (1 << 1),
 OPT_TTL = (1 << 2),
 OPT_IF = (1 << 3),
};

enum {
 OPT_ARG_CODEC = 0,
 OPT_ARG_LOOP,
 OPT_ARG_TTL,
 OPT_ARG_IF,
 OPT_ARG_ARRAY_SIZE,
};

AST_APP_OPTIONS(multicast_rtp_options, BEGIN_OPTIONS
 /*! Set the codec to be used for multicast RTP */
 AST_APP_OPTION_ARG('c', OPT_CODEC, OPT_ARG_CODEC),
 /*! Set whether multicast RTP is looped back to the sender */
 AST_APP_OPTION_ARG('l', OPT_LOOP, OPT_ARG_LOOP),
 /*! Set the hop count for multicast RTP */
 AST_APP_OPTION_ARG('t', OPT_TTL, OPT_ARG_TTL),
 /*! Set the interface from which multicast RTP is sent */
 AST_APP_OPTION_ARG('i', OPT_IF, OPT_ARG_IF),
END_OPTIONS );

struct ast_multicast_rtp_options {
 char *type;
 char *options;
 struct ast_format *fmt;
 struct ast_flags opts;
 char *opt_args[OPT_ARG_ARRAY_SIZE];
 /*! The type and options are stored in this buffer */
 char buf[0];
};

struct ast_multicast_rtp_options *ast_multicast_rtp_create_options(const char *type,
 const char *options)
{
 struct ast_multicast_rtp_options *mcast_options;
 char *pos;

 mcast_options = ast_calloc(1, sizeof(*mcast_options)
 + strlen(type)
 + strlen(S_OR(options, "")) + 2);
 if (!mcast_options) {
 return NULL;
 }

 pos = mcast_options->buf;

 /* Safe */
 strcpy(pos, type);
 mcast_options->type = pos;
 pos += strlen(type) + 1;

 if (!ast_strlen_zero(options)) {
 strcpy(pos, options); /* Safe */
 }
 mcast_options->options = pos;

 if (ast_app_parse_options(multicast_rtp_options, &mcast_options->opts,
 mcast_options->opt_args, mcast_options->options)) {
 ast_log(LOG_WARNING, "Error parsing multicast RTP options\n");
 ast_multicast_rtp_free_options(mcast_options);
 return NULL;
 }

 return mcast_options;
}

void ast_multicast_rtp_free_options(struct ast_multicast_rtp_options *mcast_options)
{
 ast_free(mcast_options);
}

struct ast_format *ast_multicast_rtp_options_get_format(struct ast_multicast_rtp_options *mcast_options)
{
 if (ast_test_flag(&mcast_options->opts, OPT_CODEC)
 && !ast_strlen_zero(mcast_options->opt_args[OPT_ARG_CODEC])) {
 return ast_format_cache_get(mcast_options->opt_args[OPT_ARG_CODEC]);
 }

 return NULL;
}

/* Forward Declarations */
static int multicast_rtp_new(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *addr, void *data);
static int multicast_rtp_activate(struct ast_rtp_instance *instance);
static int multicast_rtp_destroy(struct ast_rtp_instance *instance);
static int multicast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
static struct ast_frame *multicast_rtp_read(struct ast_rtp_instance *instance, int rtcp);

/* RTP Engine Declaration */
static struct ast_rtp_engine multicast_rtp_engine = {
 .name = "multicast",
 .new = multicast_rtp_new,
 .activate = multicast_rtp_activate,
 .destroy = multicast_rtp_destroy,
 .write = multicast_rtp_write,
 .read = multicast_rtp_read,
};

static int set_type(struct multicast_rtp *multicast, const char *type)
{
 if (!strcasecmp(type, "basic")) {
 multicast->type = MULTICAST_TYPE_BASIC;
 } else if (!strcasecmp(type, "linksys")) {
 multicast->type = MULTICAST_TYPE_LINKSYS;
 } else {
 ast_log(LOG_WARNING, "Unrecognized multicast type '%s' specified.\n", type);
 return -1;
 }

 return 0;
}

static void set_ttl(int sock, const char *ttl_str)
{
 int ttl;

 if (ast_strlen_zero(ttl_str)) {
 return;
 }

 ast_debug(3, "Setting multicast TTL to %s\n", ttl_str);

 if (sscanf(ttl_str, "%30d", &ttl) < 1) {
 ast_log(LOG_WARNING, "Invalid multicast ttl option '%s'\n", ttl_str);
 return;
 }

 if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
 ast_log(LOG_WARNING, "Could not set multicast ttl to '%s': %s\n",
 ttl_str, strerror(errno));
 }
}

static void set_loop(int sock, const char *loop_str)
{
 unsigned char loop;

 if (ast_strlen_zero(loop_str)) {
 return;
 }

 ast_debug(3, "Setting multicast loop to %s\n", loop_str);

 if (sscanf(loop_str, "%30hhu", &loop) < 1) {
 ast_log(LOG_WARNING, "Invalid multicast loop option '%s'\n", loop_str);
 return;
 }

 if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) < 0) {
 ast_log(LOG_WARNING, "Could not set multicast loop to '%s': %s\n",
 loop_str, strerror(errno));
 }
}

static void set_if(int sock, const char *if_str)
{
 struct in_addr iface;

 if (ast_strlen_zero(if_str)) {
 return;
 }

 ast_debug(3, "Setting multicast if to %s\n", if_str);

 if (!inet_aton(if_str, &iface)) {
 ast_log(LOG_WARNING, "Cannot parse if option '%s'\n", if_str);
 }

 if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF, &iface, sizeof(iface)) < 0) {
 ast_log(LOG_WARNING, "Could not set multicast if to '%s': %s\n",
 if_str, strerror(errno));
 }
}

/*! \brief Function called to create a new multicast instance */
static int multicast_rtp_new(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *addr, void *data)
{
 struct multicast_rtp *multicast;
 struct ast_multicast_rtp_options *mcast_options = data;

 if (!(multicast = ast_calloc(1, sizeof(*multicast)))) {
 return -1;
 }

 if (set_type(multicast, mcast_options->type)) {
 ast_free(multicast);
 return -1;
 }

 if ((multicast->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 ast_free(multicast);
 return -1;
 }

 if (ast_test_flag(&mcast_options->opts, OPT_LOOP)) {
 set_loop(multicast->socket, mcast_options->opt_args[OPT_ARG_LOOP]);
 }

 if (ast_test_flag(&mcast_options->opts, OPT_TTL)) {
 set_ttl(multicast->socket, mcast_options->opt_args[OPT_ARG_TTL]);
 }

 if (ast_test_flag(&mcast_options->opts, OPT_IF)) {
 set_if(multicast->socket, mcast_options->opt_args[OPT_ARG_IF]);
 }

 multicast->ssrc = ast_random();

 ast_rtp_instance_set_data(instance, multicast);

 return 0;
}

static int rtp_get_rate(struct ast_format *format)
{
 return ast_format_cmp(format, ast_format_g722) == AST_FORMAT_CMP_EQUAL ?
 8000 : ast_format_get_sample_rate(format);
}

static unsigned int calc_txstamp(struct multicast_rtp *rtp, struct timeval *delivery)
{
 struct timeval t;
 long ms;

 if (ast_tvzero(rtp->txcore)) {
 rtp->txcore = ast_tvnow();
 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
 }

 t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
 if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
 ms = 0;
 }
 rtp->txcore = t;

 return (unsigned int) ms;
}

/*! \brief Helper function which populates a control packet with useful information and sends it */
static int multicast_send_control_packet(struct ast_rtp_instance *instance, struct multicast_rtp *multicast, int command)
{
 struct multicast_control_packet control_packet = { .unique_id = htonl((u_long)time(NULL)),
 .command = htonl(command),
 };
 struct ast_sockaddr control_address, remote_address;

 ast_rtp_instance_get_local_address(instance, &control_address);
 ast_rtp_instance_get_remote_address(instance, &remote_address);

 /* Ensure the user of us have given us both the control address and destination address */
 if (ast_sockaddr_isnull(&control_address) ||
 ast_sockaddr_isnull(&remote_address)) {
 return -1;
 }

 /* The protocol only supports IPv4. */
 if (ast_sockaddr_is_ipv6(&remote_address)) {
 ast_log(LOG_WARNING, "Cannot send control packet for IPv6 "
 "remote address.\n");
 return -1;
 }

 control_packet.ip = htonl(ast_sockaddr_ipv4(&remote_address));
 control_packet.port = htonl(ast_sockaddr_port(&remote_address));

 /* Based on a recommendation by Brian West who did the FreeSWITCH implementation we send control packets twice */
 ast_sendto(multicast->socket, &control_packet, sizeof(control_packet), 0, &control_address);
 ast_sendto(multicast->socket, &control_packet, sizeof(control_packet), 0, &control_address);

 return 0;
}

/*! \brief Function called to indicate that audio is now going to flow */
static int multicast_rtp_activate(struct ast_rtp_instance *instance)
{
 struct multicast_rtp *multicast = ast_rtp_instance_get_data(instance);

 if (multicast->type != MULTICAST_TYPE_LINKSYS) {
 return 0;
 }

 return multicast_send_control_packet(instance, multicast, LINKSYS_MCAST_STARTCMD);
}

/*! \brief Function called to destroy a multicast instance */
static int multicast_rtp_destroy(struct ast_rtp_instance *instance)
{
 struct multicast_rtp *multicast = ast_rtp_instance_get_data(instance);

 if (multicast->type == MULTICAST_TYPE_LINKSYS) {
 multicast_send_control_packet(instance, multicast, LINKSYS_MCAST_STOPCMD);
 }

 if (multicast->smoother) {
 ast_smoother_free(multicast->smoother);
 }

 close(multicast->socket);

 ast_free(multicast);

 return 0;
}

static int rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
{
 struct multicast_rtp *multicast = ast_rtp_instance_get_data(instance);
 unsigned int ms = calc_txstamp(multicast, &frame->delivery);
 unsigned char *rtpheader;
 struct ast_sockaddr remote_address = { {0,} };
 int rate = rtp_get_rate(frame->subclass.format) / 1000;
 int hdrlen = 12, mark = 0;

 if (ast_format_cmp(frame->subclass.format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) {
 frame->samples /= 2;
 }

 if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
 multicast->lastts = frame->ts * rate;
 } else {
 /* Try to predict what our timestamp should be */
 int pred = multicast->lastts + frame->samples;

 /* Calculate last TS */
 multicast->lastts = multicast->lastts + ms * rate;
 if (ast_tvzero(frame->delivery)) {
 int delta = abs((int) multicast->lastts - pred);
 if (delta < MAX_TIMESTAMP_SKEW) {
 multicast->lastts = pred;
 } else {
 ast_debug(3, "Difference is %d, ms is %u\n", delta, ms);
 mark = 1;
 }
 }
 }

 /* Construct an RTP header for our packet */
 rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);

 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (multicast->seqno) | (mark << 23)));
 put_unaligned_uint32(rtpheader + 4, htonl(multicast->lastts));
 put_unaligned_uint32(rtpheader + 8, htonl(multicast->ssrc));

 /* Increment sequence number and wrap to 0 if it overflows 16 bits. */
 multicast->seqno = 0xFFFF & (multicast->seqno + 1);

 /* Finally send it out to the eager phones listening for us */
 ast_rtp_instance_get_remote_address(instance, &remote_address);

 if (ast_sendto(multicast->socket, (void *) rtpheader, frame->datalen + hdrlen, 0, &remote_address) < 0) {
 ast_log(LOG_ERROR, "Multicast RTP Transmission error to %s: %s\n",
 ast_sockaddr_stringify(&remote_address),
 strerror(errno));
 return -1;
 }

 return 0;
}

/*! \brief Function called to broadcast some audio on a multicast instance */
static int multicast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
{
 struct multicast_rtp *multicast = ast_rtp_instance_get_data(instance);
 struct ast_format *format;
 struct ast_frame *f;
 int codec;

 /* We only accept audio, nothing else */
 if (frame->frametype != AST_FRAME_VOICE) {
 return 0;
 }

 /* Grab the actual payload number for when we create the RTP packet */
 codec = ast_rtp_codecs_payload_code_tx(ast_rtp_instance_get_codecs(instance),
 1, frame->subclass.format, 0);
 if (codec < 0) {
 return -1;
 }

 format = frame->subclass.format;
 if (!multicast->smoother && ast_format_can_be_smoothed(format)) {
 unsigned int smoother_flags = ast_format_get_smoother_flags(format);
 unsigned int framing_ms = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(instance));

 if (!framing_ms && (smoother_flags & AST_SMOOTHER_FLAG_FORCED)) {
 framing_ms = ast_format_get_default_ms(format);
 }

 if (framing_ms) {
 multicast->smoother = ast_smoother_new((framing_ms * ast_format_get_minimum_bytes(format)) / ast_format_get_minimum_ms(format));
 if (!multicast->smoother) {
 ast_log(LOG_WARNING, "Unable to create smoother: format %s ms: %u len %u\n",
 ast_format_get_name(format), framing_ms, ast_format_get_minimum_bytes(format));
 return -1;
 }
 ast_smoother_set_flags(multicast->smoother, smoother_flags);
 }
 }

 if (multicast->smoother) {
 if (ast_smoother_test_flag(multicast->smoother, AST_SMOOTHER_FLAG_BE)) {
 ast_smoother_feed_be(multicast->smoother, frame);
 } else {
 ast_smoother_feed(multicast->smoother, frame);
 }

 while ((f = ast_smoother_read(multicast->smoother)) && f->data.ptr) {
 rtp_raw_write(instance, f, codec);
 }
 } else {
 int hdrlen = 12;

 /* If we do not have space to construct an RTP header duplicate the frame so we get some */
 if (frame->offset < hdrlen) {
 f = ast_frdup(frame);
 } else {
 f = frame;
 }

 if (f->data.ptr) {
 rtp_raw_write(instance, f, codec);
 }

 if (f != frame) {
 ast_frfree(f);
 }
 }

 return 0;
}

/*! \brief Function called to read from a multicast instance */
static struct ast_frame *multicast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
{
 return &ast_null_frame;
}

static int load_module(void)
{
 if (ast_rtp_engine_register(&multicast_rtp_engine)) {
 return AST_MODULE_LOAD_DECLINE;
 }

 return AST_MODULE_LOAD_SUCCESS;
}

static int unload_module(void)
{
 ast_rtp_engine_unregister(&multicast_rtp_engine);

 return 0;
}

AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Multicast RTP Engine",
 .support_level = AST_MODULE_SUPPORT_CORE,
 .load = load_module,
 .unload = unload_module,
 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
);