--- /dev/null
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2007, Andreas 'MacBrody' Brodmann
+ *
+ * Andreas 'MacBrody' Brodmann <andreas.brodmann@gmail.com>
+ *
+ * Information on how multicast paging works with linksys
+ * phones was used from FreeSWITCH's mod_esf with permission
+ * from Brian West.
+ *
+ * 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 Application to stream a channel's input to a specified uni-/multicast address
+ *
+ * \author Andreas 'MacBrody' Brodmann <andreas.brodmann@gmail.com>
+ *
+ * \ingroup applications
+ */
+
+/*** MODULEINFO
+ <defaultenabled>yes</defaultenabled>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "asterisk/file.h"
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/module.h"
+#include "asterisk/lock.h"
+#include "asterisk/app.h"
+#include "asterisk/config.h"
+#include "asterisk/acl.h"
+
+#define RTP_PT_ULAW 0
+#define RTP_PT_GSM 3
+#define RTP_PT_ALAW 8
+#define RTP_PT_G729 18
+
+/*! \brief Multicast Group Receiver Type object */
+enum grouptype {
+ MGT_BASIC = 1, /*!< simple multicast enabled client/receiver like snom, barix */
+ MGT_LINKSYS = 2, /*!< linksys ipphones; they need a start/stop packet */
+ MGT_CISCO = 3 /*!< cisco phones; they need a http request to their internal web server // NOT YET IMPLEMENTED */
+};
+
+/*! \brief Multicast Group object */
+struct mcast_group {
+ char name[32]; /*!< name of the group */
+ enum grouptype type; /*!< type, see grouptype */
+ int socket; /*!< socket used for streaming to this group (each group has got its own socket */
+ int ttl; /*!< timetolive to be set on this socket */
+ struct sockaddr_in rtp_address; /*!< address/port pair where the traffic is sent to */
+ struct sockaddr_in control_address; /*!< address/port for linksys phones to send the start/stop packet to */
+ AST_LIST_ENTRY(mcast_group) list; /*!< next element int group list */
+};
+
+/*! \brief RTP header object */
+struct rtp_header {
+ uint16_t flags;
+ uint16_t seqno;
+ uint32_t timestamp;
+ uint32_t ssrc;
+};
+
+/*! \brief Control Packet object as used for linksys phones for start/stop packets */
+struct control_packet {
+ uint32_t unique_id; /*!< unique id per command start or stop - not the same for both commands */
+ uint32_t command; /*!< the command: 6=start, 7=stop */
+ uint32_t ip; /*!< multicast address in network byte order */
+ uint32_t port; /*!< udp port to send the data to */
+};
+
+/*! \brief List to hold all the multicast groups defined in the config file */
+static AST_LIST_HEAD_STATIC(groups, mcast_group);
+
+static char *app = "RTPPage";
+static char *synopsis = "RTPPage Application";
+static char *descrip = " RTPPage(direct|multicast, ip:port[&ip:port]|group[&group2[&group3...]][,codec]): Sends the channel's input to the\n"
+"specified group(s) defined in the config file rtppage.conf.\n"
+"The optional codec may be one of the following:\n"
+" ulaw - default\n"
+" alaw\n"
+" gsm\n"
+" g729\n"
+"as long as asterisk does not have to translate or respective translators are\n"
+"installed with your asterisk installation. If none or any other codec is\n"
+"specified the application will fall back to ulaw.\n";
+
+static const char config[] = "rtppage.conf";
+static int default_ttl = -1;
+static unsigned int tos = -1;
+
+/*! \brief Read input from channel and send it to the specified group(s) as rtp traffic */
+static int rtppage_exec(struct ast_channel *chan, void *data)
+{
+ int res = 0;
+ struct ast_module_user *u = NULL;
+ struct ast_frame *f = NULL;
+ char *parse = NULL;
+ char *rest = NULL, *cur = NULL;
+ char *rest2 = NULL;
+ char *ip = NULL, *port = NULL;
+ int ms = -1;
+ unsigned char *databuf = NULL;
+ struct sockaddr_in destaddr;
+ struct mcast_group *group;
+ struct control_packet cpk;
+ struct rtp_header *rtph = NULL;
+ uint8_t rtp_pt = RTP_PT_ULAW;
+ int chan_format = AST_FORMAT_ULAW;
+ uint16_t rtpflags = 0;
+ int ttl = 0;
+ int pagetype = 0;
+ AST_LIST_HEAD(, mcast_group) activegroups;
+
+ /* init active groups */
+ activegroups.first = NULL;
+ activegroups.last = NULL;
+ activegroups.lock = AST_MUTEX_INIT_VALUE;
+
+ /* you can specify three arguments:
+ * 1) pagetype (0 = direct, 1 = multicast)
+ * 2) groups, e.g. NameOfGroup or Name1&Name2 etc) / or ip:port in case of direct
+ * 3) optional: codec, if specified and valid
+ * this codec will be used for streaming
+ */
+ AST_DECLARE_APP_ARGS(args,
+ AST_APP_ARG(pagetype);
+ AST_APP_ARG(groups);
+ AST_APP_ARG(codec);
+ );
+
+ /* make sure there is at least one parameter */
+ if (ast_strlen_zero(data)) {
+ ast_log(LOG_WARNING, "%s requires argument (group(s)[,codec])\n", app);
+ return -1;
+ }
+
+ parse = ast_strdupa(data);
+ AST_STANDARD_APP_ARGS(args, parse);
+
+ /* pagetype is a mandatory parameter */
+ if (!args.pagetype) {
+ ast_log(LOG_WARNING, "%s requires arguments (pagetype, group(s) | ip:port[,codec])\n", app);
+ return(-1);
+ }
+ if (!strcasecmp(args.pagetype, "direct")) {
+ pagetype = 0;
+ } else if (!strcasecmp(args.pagetype, "multicast")) {
+ pagetype = 1;
+ } else {
+ ast_log(LOG_ERROR, "%s is an invalid grouptype! valid types are: direct, multicast.\n", args.pagetype);
+ return(-1);
+ }
+
+ /* group is a mandatory parameter */
+ if (!args.groups) {
+ ast_log(LOG_WARNING, "%s requires arguments (pagetype, group(s) | ip:port[,codec])\n", app);
+ return(-1);
+ }
+
+ /* setup variables for the desired codec */
+ if (args.codec) {
+ if (!strcasecmp(args.codec, "ulaw")) {
+ /* use default settings */
+ } else if (!strcasecmp(args.codec, "alaw")) {
+ rtp_pt = RTP_PT_ALAW;
+ chan_format = AST_FORMAT_ALAW;
+ } else if (!strcasecmp(args.codec, "gsm")) {
+ rtp_pt = RTP_PT_GSM;
+ chan_format = AST_FORMAT_GSM;
+ } else if (!strcasecmp(args.codec, "g729")) {
+ rtp_pt = RTP_PT_G729;
+ chan_format = AST_FORMAT_G729A;
+ } else {
+ /* use ulaw as fallback */
+ rtp_pt = RTP_PT_ULAW;
+ chan_format = AST_FORMAT_ULAW;
+ }
+ }
+
+ u = ast_module_user_add(chan);
+
+ /* Check if the channel is answered, if not
+ * do answer it */
+ if (chan->_state != AST_STATE_UP) {
+ res = ast_answer(chan);
+ if (res) {
+ ast_log(LOG_WARNING, "Could not answer channel '%s'\n", chan->name);
+ goto end;
+ }
+ }
+
+ /* allocate memory for the rtp send buffer */
+ if ((databuf = ast_calloc(1, 172)) == NULL) {
+ ast_log(LOG_WARNING, "Failed to allocate memory for the data buffer, give up\n");
+ goto end;
+ }
+
+ /* initialize rtp buffer header
+ * with rtp version and
+ * payload type
+ */
+ rtph = (struct rtp_header *)databuf;
+ rtpflags = (0x02 << 14); /* rtp v2 */
+ rtpflags = (rtpflags & 0xFF80) | rtp_pt;
+ rtph->flags = htons(rtpflags);
+ rtph->ssrc = htonl((u_long)time(NULL));
+
+ /* first create a temporary table for this page session
+ * containing all groups which will be used
+ */
+ AST_LIST_LOCK(&groups);
+ rest = ast_strdup(args.groups);
+ if (pagetype == 0) {
+ /* a direct page call. this can actually be used
+ * for multicast paging too by passing the ip:port as
+ * argument 2
+ */
+ while ((cur = strsep(&rest, "&"))) {
+ struct mcast_group *agroup = ast_calloc(1, sizeof(*agroup));
+ rest2 = ast_strdup(cur);
+ ip = strsep(&rest2, ":");
+ port = strsep(&rest2, ":");
+ if (ip == NULL || port == NULL) {
+ ast_log(LOG_WARNING, "invalid ip:port pair in call to RTPPage (%s)!\n", cur);
+ free(agroup);
+ continue;
+ }
+ agroup->rtp_address.sin_family = AF_INET;
+ agroup->rtp_address.sin_port = htons(atoi(port));
+ if (inet_pton(AF_INET, ip, &agroup->rtp_address.sin_addr) <= 0) {
+ ast_log(LOG_WARNING, "invalid ip in call to RTPPage (%s)!\n", cur);
+ free(agroup);
+ continue;
+ }
+ agroup->type = MGT_BASIC;
+ agroup->socket = -1;
+ agroup->ttl = -1;
+ AST_LIST_INSERT_TAIL(&activegroups, agroup, list);
+ }
+ } else if (pagetype == 1) {
+ /* a multicast page call */
+ while ((cur = strsep(&rest, "&"))) {
+ AST_LIST_TRAVERSE(&groups, group, list) {
+ if (!strcasecmp(group->name, cur)) {
+ struct mcast_group *agroup = ast_calloc(1, sizeof(*agroup));
+ memcpy(agroup->name, group->name, 32);
+ agroup->type = group->type;
+ agroup->socket = group->socket;
+ agroup->ttl = group->ttl;
+ memcpy(&agroup->rtp_address, &group->rtp_address, sizeof(agroup->rtp_address));
+ memcpy(&agroup->control_address, &group->control_address, sizeof(agroup->control_address));
+ AST_LIST_INSERT_TAIL(&activegroups, agroup, list);
+ }
+ }
+ }
+ }
+ AST_LIST_UNLOCK(&groups);
+
+ /* now initialize these groups, e.g. create a udp socket for each,
+ * set ttl and tos if requested by config, and
+ * in case of linksys type groups send the multicast start signal
+ */
+ AST_LIST_TRAVERSE(&activegroups, group, list) {
+ group->socket = socket(AF_INET, SOCK_DGRAM, 0);
+ /* set ttl if configured
+ * ttl can be configured either globally in the
+ * category 'general' or locally within
+ * the respective groups
+ */
+ if (group->ttl >= 0 || default_ttl >= 0) {
+ ttl = default_ttl;
+ if (group->ttl >= 0) {
+ ttl = group->ttl;
+ }
+ if (setsockopt(group->socket, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)) < 0) {
+ ast_log(LOG_WARNING, "Failed to set ttl on socket for group %s!\n", group->name);
+ }
+ }
+ /* set tos if requested
+ * tos can only be configured globally ('general')
+ */
+ if (tos >= 0) {
+ if (setsockopt(group->socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
+ ast_log(LOG_WARNING, "Failed to set tos field on socket for group %s!\n", group->name);
+ }
+ }
+ /* for linksys device groups send multicast start command */
+ if (group->type == MGT_LINKSYS) {
+ cpk.unique_id = htonl((u_long)time(NULL));
+ cpk.command = htonl(6); /* multicast start command */
+ memcpy(&cpk.ip, &group->rtp_address.sin_addr, sizeof(cpk.ip));
+ cpk.port = htonl(ntohs(group->rtp_address.sin_port));
+ memcpy(&destaddr, &group->control_address, sizeof(destaddr));
+ sendto(group->socket, &cpk, sizeof(cpk), 0, (struct sockaddr *)&destaddr, sizeof(destaddr));
+ sendto(group->socket, &cpk, sizeof(cpk), 0, (struct sockaddr *)&destaddr, sizeof(destaddr));
+ }
+ }
+
+ /* Set read format as configured - this codec will be used for streaming */
+ res = ast_set_read_format(chan, chan_format);
+ if (res < 0) {
+ ast_log(LOG_WARNING, "Unable to set channel read mode, giving up\n");
+ res = -1;
+ goto end;
+ }
+
+ /* Play a beep to let the caller know he can start talking */
+ res = ast_streamfile(chan, "beep", chan->language);
+ if (!res) {
+ res = ast_waitstream(chan, "");
+ } else {
+ ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", chan->name);
+ }
+ ast_stopstream(chan);
+
+ /* main loop:
+ * read frames from the input channel and, if they are voice frames,
+ * send them to all requested multi-/unicast listeners.
+ */
+ for (;;) {
+ ms = ast_waitfor(chan, 1000);
+ if (ms < 0) {
+ ast_log(LOG_DEBUG, "Hangup detected\n");
+ goto end;
+ }
+ f = ast_read(chan);
+ if (!f)
+ break;
+
+ /* if the speaker pressed '#', then quit */
+ if ((f->frametype == AST_FRAME_DTMF) && (f->subclass == '#')) {
+ res = 0;
+ ast_frfree(f);
+ ast_log(LOG_DEBUG, "Received DTMF key: %d\n", f->subclass);
+ goto end;
+ }
+
+ if (f->frametype == AST_FRAME_VOICE) {
+ /* update the rtp header */
+ rtph = (struct rtp_header *)databuf;
+ rtph->seqno = htons(f->seqno);
+ rtph->timestamp = htonl(f->ts * 8);
+ memcpy(databuf+12, f->data, f->datalen);
+
+ /* now send that frame to the destination groups */
+ AST_LIST_TRAVERSE(&activegroups, group, list) {
+ memcpy(&destaddr, &group->rtp_address, sizeof(destaddr));
+ if (sendto(group->socket, databuf, f->datalen+12, 0, (struct sockaddr *)&destaddr, sizeof(destaddr)) <= 0) {
+ ast_log(LOG_DEBUG, "sendto() failed!\n");
+ }
+ }
+ }
+ ast_frfree(f);
+ f = NULL;
+ }
+
+end:
+
+ /* send a stop multicast signal to all linksys devices */
+ AST_LIST_TRAVERSE(&activegroups, group, list) {
+ if (group->socket > 0) {
+ if (group->type == MGT_LINKSYS) {
+ cpk.unique_id = htonl((u_long)time(NULL));
+ cpk.command = htonl(7); /* multicast stop command */
+ memcpy(&cpk.ip, &group->rtp_address.sin_addr, sizeof(cpk.ip));
+ cpk.port = htonl(ntohs(group->rtp_address.sin_port));
+ memcpy(&destaddr, &group->control_address, sizeof(destaddr));
+ sendto(group->socket, &cpk, 8, 0, (struct sockaddr *)&destaddr, sizeof(destaddr));
+ sendto(group->socket, &cpk, 8, 0, (struct sockaddr *)&destaddr, sizeof(destaddr));
+ }
+ close(group->socket);
+ }
+ }
+
+ /* free activegroups list */
+ while ((group = AST_LIST_REMOVE_HEAD(&activegroups, list))) {
+ free(group);
+ }
+
+ /* free the rtp data buffer */
+ if (databuf != NULL) {
+ free(databuf);
+ }
+
+ ast_module_user_remove(u);
+ ast_log(LOG_DEBUG, "Exit RTPPage(%s)\n", args.groups);
+
+ return res;
+}
+
+static int load_config(int reload) {
+
+ int res = 0;
+ const char *cat = NULL;
+ struct ast_config *cfg = NULL;
+ struct mcast_group *group = NULL;
+ const char *var = NULL;
+ struct ast_flags config_flags = { 0 };
+
+ AST_LIST_LOCK(&groups);
+ if (reload) {
+ /* if this is a reload, then free the config structure before
+ * filling it again
+ */
+ while ((group = AST_LIST_REMOVE_HEAD(&groups, list))) {
+ free(group);
+ }
+
+ /* reset default_ttl & tos */
+ default_ttl = -1; /* means not set */
+ tos = -1;
+ }
+
+ /* load config file */
+ if (!(cfg = ast_config_load(config, config_flags))) {
+ ast_log(LOG_NOTICE, "Failed to load config!\n");
+ AST_LIST_UNLOCK(&groups);
+ return(-1);
+ }
+
+ while ((cat = ast_category_browse(cfg, cat)) != NULL) {
+ /* 'general' is reserved for generic options */
+ if (!strcasecmp(cat, "general")) {
+ var = ast_variable_retrieve(cfg, cat, "ttl");
+ if (var) {
+ default_ttl = atoi(var);
+ }
+ var = ast_variable_retrieve(cfg, cat, "tos");
+ if (var) {
+ ast_str2tos(var, &tos);
+ }
+ continue;
+ }
+
+ group = ast_calloc(1, sizeof(*group));
+ var = ast_variable_retrieve(cfg, cat, "type");
+ if (!strcasecmp(var, "basic")) {
+ ast_copy_string(group->name, cat, sizeof(group->name));
+ group->type = MGT_BASIC;
+ group->socket = -1;
+ group->ttl = -1;
+ if (ast_variable_retrieve(cfg, cat, "ttl") != NULL) {
+ group->ttl = atoi(ast_variable_retrieve(cfg, cat, "ttl"));
+ }
+ memset(&group->rtp_address, 0, sizeof(group->rtp_address));
+ group->rtp_address.sin_family = AF_INET;
+ group->rtp_address.sin_port = htons(atoi(ast_variable_retrieve(cfg, cat, "rtp_port")));
+ if (inet_pton(AF_INET, ast_variable_retrieve(cfg, cat, "rtp_address"), &group->rtp_address.sin_addr) <= 0) {
+ ast_log(LOG_NOTICE, "Invalid ip address in group %s!\n", cat);
+ ast_free(group);
+ group = NULL;
+ continue;
+ }
+ } else if (!strcasecmp(var, "linksys")) {
+ ast_copy_string(group->name, cat, sizeof(group->name));
+ group->type = MGT_LINKSYS;
+ group->socket = -1;
+ group->ttl = -1;
+ if (ast_variable_retrieve(cfg, cat, "ttl") != NULL) {
+ group->ttl = atoi(ast_variable_retrieve(cfg, cat, "ttl"));
+ }
+ memset(&group->rtp_address, 0, sizeof(group->rtp_address));
+ group->rtp_address.sin_family = AF_INET;
+ group->rtp_address.sin_port = htons(atoi(ast_variable_retrieve(cfg, cat, "rtp_port")));
+ if (inet_pton(AF_INET, ast_variable_retrieve(cfg, cat, "rtp_address"), &group->rtp_address.sin_addr) <= 0) {
+ ast_log(LOG_NOTICE, "Invalid ip address in group %s!\n", cat);
+ ast_free(group);
+ group = NULL;
+ continue;
+ }
+ memset(&group->control_address, 0, sizeof(group->control_address));
+ group->control_address.sin_family = AF_INET;
+ group->control_address.sin_port = htons(atoi(ast_variable_retrieve(cfg, cat, "control_port")));
+ if (inet_pton(AF_INET, ast_variable_retrieve(cfg, cat, "control_address"), &group->control_address.sin_addr) <= 0) {
+ ast_log(LOG_NOTICE, "Invalid ip address in group %s!\n", cat);
+ ast_free(group);
+ group = NULL;
+ continue;
+ }
+ } else {
+ group->type = -1;
+ group->socket = -1;
+ group->ttl = -1;
+ ast_log(LOG_NOTICE, "Invalid mcast group %s!\n", cat);
+ continue;
+ }
+
+ /* now add it to the linked list */
+ AST_LIST_INSERT_TAIL(&groups, group, list);
+ ast_log(LOG_NOTICE, "loaded category %s\n", group->name);
+ group = NULL;
+ var = NULL;
+ }
+
+ AST_LIST_UNLOCK(&groups);
+
+ ast_config_destroy(cfg);
+
+ return(res);
+}
+
+static int unload_module(void)
+{
+ int res;
+ res = ast_unregister_application(app);
+ ast_module_user_hangup_all();
+ return res;
+}
+
+static int load_module(void)
+{
+
+ load_config(0);
+ return ast_register_application(app, rtppage_exec, synopsis, descrip);
+}
+
+static int reload(void)
+{
+ return load_config(1);
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RTPPage Application",
+ .load = load_module,
+ .unload = unload_module,
+ .reload = reload,
+);
+
+
projects / asterisk/asterisk.git / commitdiff