[asterisk-commits] file: branch file/rtp_engine r130782 - in /team/file/rtp_engine: channels/ in...

SVN commits to the Asterisk project asterisk-commits at lists.digium.com
Mon Jul 14 12:30:36 CDT 2008


Author: file
Date: Mon Jul 14 12:30:35 2008
New Revision: 130782

URL: http://svn.digium.com/view/asterisk?view=rev&rev=130782
Log:
Add core RTP engine components for doing both local and remote bridging.

Modified:
    team/file/rtp_engine/channels/chan_sip.c
    team/file/rtp_engine/include/asterisk/rtp_engine.h
    team/file/rtp_engine/main/rtp_engine.c

Modified: team/file/rtp_engine/channels/chan_sip.c
URL: http://svn.digium.com/view/asterisk/team/file/rtp_engine/channels/chan_sip.c?view=diff&rev=130782&r1=130781&r2=130782
==============================================================================
--- team/file/rtp_engine/channels/chan_sip.c (original)
+++ team/file/rtp_engine/channels/chan_sip.c Mon Jul 14 12:30:35 2008
@@ -2165,7 +2165,6 @@
 static enum st_mode st_get_mode(struct sip_pvt *);
 static struct sip_st_dlg* sip_st_alloc(struct sip_pvt *const p);
 
-
 /*! \brief Definition of this channel for PBX channel registration */
 static const struct ast_channel_tech sip_tech = {
 	.type = "SIP",
@@ -2187,7 +2186,7 @@
 	.fixup = sip_fixup,			/* called with chan locked */
 	.send_digit_begin = sip_senddigit_begin,	/* called with chan unlocked */
 	.send_digit_end = sip_senddigit_end,
-//	.bridge = ast_rtp_bridge,			/* XXX chan unlocked ? */
+	.bridge = ast_rtp_instance_bridge,			/* XXX chan unlocked ? */
 //	.early_bridge = ast_rtp_early_bridge,
 	.send_text = sip_sendtext,		/* called with chan locked */
 	.func_channel_read = acf_channel_read,
@@ -21586,6 +21585,173 @@
 	}
 }
 
+static enum ast_rtp_glue_result sip_get_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
+{
+        struct sip_pvt *p = NULL;
+        enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_LOCAL;
+
+        if (!(p = chan->tech_pvt)) {
+                return AST_RTP_GLUE_RESULT_FORBID;
+	}
+
+        sip_pvt_lock(p);
+        if (!(p->rtp)) {
+                sip_pvt_unlock(p);
+                return AST_RTP_GLUE_RESULT_FORBID;
+        }
+
+        *instance = p->rtp;
+	
+        if (!ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT)) {
+                res = AST_RTP_GLUE_RESULT_LOCAL;
+	} else if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE)) {
+                res = AST_RTP_GLUE_RESULT_REMOTE;
+	} else if (ast_test_flag(&global_jbconf, AST_JB_FORCED)) {
+                res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+
+        sip_pvt_unlock(p);
+
+        return res;
+}
+
+static enum ast_rtp_glue_result sip_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
+{
+	struct sip_pvt *p = NULL;
+	enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_FORBID;
+
+	if (!(p = chan->tech_pvt)) {
+		return AST_RTP_GLUE_RESULT_FORBID;
+	}
+
+	sip_pvt_lock(p);
+	if (!(p->vrtp)) {
+		sip_pvt_unlock(p);
+		return AST_RTP_GLUE_RESULT_FORBID;
+	}
+
+	*instance = p->vrtp;
+
+	if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE)) {
+		res = AST_RTP_GLUE_RESULT_REMOTE;
+	}
+
+	sip_pvt_unlock(p);
+
+	return res;
+}
+
+static enum ast_rtp_glue_result sip_get_trtp_peer(struct ast_channel *chan, struct ast_rtp_instance **instance)
+{
+        struct sip_pvt *p = NULL;
+        enum ast_rtp_glue_result res = AST_RTP_GLUE_RESULT_FORBID;
+
+        if (!(p = chan->tech_pvt)) {
+                return AST_RTP_GLUE_RESULT_FORBID;
+        }
+
+        sip_pvt_lock(p);
+        if (!(p->trtp)) {
+                sip_pvt_unlock(p);
+                return AST_RTP_GLUE_RESULT_FORBID;
+        }
+
+        *instance = p->trtp;
+
+        if (ast_test_flag(&p->flags[0], SIP_CAN_REINVITE)) {
+                res = AST_RTP_GLUE_RESULT_REMOTE;
+        }
+
+        sip_pvt_unlock(p);
+
+        return res;
+}
+
+static int sip_set_rtp_peer(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, int codecs, int nat_active)
+{
+        struct sip_pvt *p;
+        int changed = 0;
+
+        p = chan->tech_pvt;
+        if (!p)
+                return -1;
+
+        /* Disable early RTP bridge  */
+        if (chan->_state != AST_STATE_UP && !global_directrtpsetup)     /* We are in early state */
+                return 0;
+
+        sip_pvt_lock(p);
+        if (p->alreadygone) {
+                /* If we're destroyed, don't bother */
+                sip_pvt_unlock(p);
+                return 0;
+        }
+
+        /* if this peer cannot handle reinvites of the media stream to devices
+           that are known to be behind a NAT, then stop the process now
+	*/
+        if (nat_active && !ast_test_flag(&p->flags[0], SIP_CAN_REINVITE_NAT)) {
+                sip_pvt_unlock(p);
+                return 0;
+        }
+
+        if (instance) {
+                changed |= ast_rtp_instance_get_remote_address(instance, &p->redirip);
+        } else if (p->redirip.sin_addr.s_addr || ntohs(p->redirip.sin_port) != 0) {
+                memset(&p->redirip, 0, sizeof(p->redirip));
+                changed = 1;
+        }
+        if (vinstance) {
+                changed |= ast_rtp_instance_get_remote_address(vinstance, &p->vredirip);
+        } else if (p->vredirip.sin_addr.s_addr || ntohs(p->vredirip.sin_port) != 0) {
+                memset(&p->vredirip, 0, sizeof(p->vredirip));
+                changed = 1;
+        }
+        if (tinstance) {
+                changed |= ast_rtp_instance_get_remote_address(tinstance, &p->tredirip);
+        } else if (p->tredirip.sin_addr.s_addr || ntohs(p->tredirip.sin_port) != 0) {
+                memset(&p->tredirip, 0, sizeof(p->tredirip));
+                changed = 1;
+        }
+        if (codecs && (p->redircodecs != codecs)) {
+                p->redircodecs = codecs;
+                changed = 1;
+        }
+        if (changed && !ast_test_flag(&p->flags[0], SIP_GOTREFER) && !ast_test_flag(&p->flags[0], SIP_DEFER_BYE_ON_TRANSFER)) {
+                if (chan->_state != AST_STATE_UP) {     /* We are in early state */
+                        if (p->do_history)
+                                append_history(p, "ExtInv", "Initial invite sent with remote bridge proposal.");
+                        ast_debug(1, "Early remote bridge setting SIP '%s' - Sending media to %s\n", p->callid, ast_inet_ntoa(instance ? p->redirip.sin_addr : p->ourip.sin_addr));
+                } else if (!p->pendinginvite) {         /* We are up, and have no outstanding invite */
+                        ast_debug(3, "Sending reinvite on SIP '%s' - It's audio soon redirected to IP %s\n", p->callid, ast_inet_ntoa(instance ? p->redirip.sin_addr : p->ourip.sin_addr));
+                        transmit_reinvite_with_sdp(p, FALSE, FALSE);
+                } else if (!ast_test_flag(&p->flags[0], SIP_PENDINGBYE)) {
+                        ast_debug(3, "Deferring reinvite on SIP '%s' - It's audio will be redirected to IP %s\n", p->callid, ast_inet_ntoa(instance ? p->redirip.sin_addr : p->ourip.sin_addr));
+                        /* We have a pending Invite. Send re-invite when we're done with the invite */
+                        ast_set_flag(&p->flags[0], SIP_NEEDREINVITE);
+                }
+        }
+        /* Reset lastrtprx timer */
+        p->lastrtprx = p->lastrtptx = time(NULL);
+        sip_pvt_unlock(p);
+        return 0;
+}
+
+static int sip_get_codec(struct ast_channel *chan)
+{
+	struct sip_pvt *p = chan->tech_pvt;
+        return p->peercapability ? p->peercapability : p->capability;
+}
+
+static struct ast_rtp_glue sip_rtp_glue = {
+	.type = "SIP",
+	.get_rtp_info = sip_get_rtp_peer,
+	.get_vrtp_info = sip_get_vrtp_peer,
+	.get_trtp_info = sip_get_trtp_peer,
+	.update_peer = sip_set_rtp_peer,
+	.get_codec = sip_get_codec,
+};
+
 static char *synopsis_dtmfmode = "Change the dtmfmode for a SIP call";
 static char *descrip_dtmfmode = "  SIPDtmfMode(inband|info|rfc2833): Changes the dtmfmode for a SIP call\n";
 static char *app_dtmfmode = "SIPDtmfMode";
@@ -21939,6 +22105,9 @@
 	/* Tell the UDPTL subdriver that we're here */
 	ast_udptl_proto_register(&sip_udptl);
 
+	/* Tell the RTP engine about our RTP glue */
+	ast_rtp_glue_register(&sip_rtp_glue);
+
 	/* Register dialplan applications */
 	ast_register_application(app_dtmfmode, sip_dtmfmode, synopsis_dtmfmode, descrip_dtmfmode);
 	ast_register_application(app_sipaddheader, sip_addheader, synopsis_sipaddheader, descrip_sipaddheader);
@@ -22009,6 +22178,9 @@
 	/* Disconnect from UDPTL */
 	ast_udptl_proto_unregister(&sip_udptl);
 
+	/* Disconnect from RTP engine */
+	ast_rtp_glue_unregister(&sip_rtp_glue);
+
 	/* Unregister AMI actions */
 	ast_manager_unregister("SIPpeers");
 	ast_manager_unregister("SIPshowpeer");

Modified: team/file/rtp_engine/include/asterisk/rtp_engine.h
URL: http://svn.digium.com/view/asterisk/team/file/rtp_engine/include/asterisk/rtp_engine.h?view=diff&rev=130782&r1=130781&r2=130782
==============================================================================
--- team/file/rtp_engine/include/asterisk/rtp_engine.h (original)
+++ team/file/rtp_engine/include/asterisk/rtp_engine.h Mon Jul 14 12:30:35 2008
@@ -50,7 +50,7 @@
 
 enum ast_rtp_glue_result {
 	AST_RTP_GLUE_RESULT_FORBID = 0,
-	AST_RTP_GLUE_RESULT_DIRECT,
+	AST_RTP_GLUE_RESULT_REMOTE,
 	AST_RTP_GLUE_RESULT_LOCAL,
 };
 
@@ -92,6 +92,7 @@
 	int (*red_init)(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations); /*!< Callback for initializing RED support */
 	int (*red_buffer)(struct ast_rtp_instance *instance, struct ast_frame *frame);                  /*!< Callback for buffering a frame over RED */
 	struct ast_frame *(*read)(struct ast_rtp_instance *instance, int rtcp);                         /*!< Callback for reading a frame in */
+	int (*local_bridge)(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);    /*!< Locally bridge two RTP instances together */
 	AST_RWLIST_ENTRY(ast_rtp_engine) entry;                                                         /*!< Linked list information */
 };
 
@@ -115,7 +116,14 @@
 };
 
 struct ast_rtp_glue {
-	const char *name; /*!< Name of the channel driver this glue works with */
+	const char *type;
+	struct ast_module *mod;
+	enum ast_rtp_glue_result (*get_rtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
+	enum ast_rtp_glue_result (*get_vrtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
+	enum ast_rtp_glue_result (*get_trtp_info)(struct ast_channel *chan, struct ast_rtp_instance **instance);
+	int (*update_peer)(struct ast_channel *chan, struct ast_rtp_instance *instance, struct ast_rtp_instance *vinstance, struct ast_rtp_instance *tinstance, int codecs, int nat_active);
+	int (*get_codec)(struct ast_channel *chan);
+	AST_RWLIST_ENTRY(ast_rtp_glue) entry; /*!< Linked list information */
 };
 
 #define ast_rtp_engine_register(engine) ast_rtp_engine_register2(engine, ast_module_info->self)
@@ -138,6 +146,27 @@
  * \retval -1 failure
  */
 int ast_rtp_engine_unregister(struct ast_rtp_engine *engine);
+
+#define ast_rtp_glue_register(glue) ast_rtp_glue_register2(glue, ast_module_info->self)
+
+/*! \brief Register RTP glue
+ *
+ * \param glue The glue to register
+ * \param module Module that the RTP glue is part of
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module);
+
+/*! \brief Unregister RTP glue
+ *
+ * \param glue The glue to unregister
+ *
+ * \retval 0 success
+ * \retval -1 failure
+ */
+int ast_rtp_glue_unregister(struct ast_rtp_glue *glue);
 
 /*! \brief Create a new RTP instance
  *
@@ -189,6 +218,9 @@
  */
 int ast_rtp_instance_set_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
 
+/*! \brief Get the address of the remote endpoint that we are sending RTP to */
+int ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address);
+
 /*! \brief Set the value of an RTP instance property
  *
  * \param instance The RTP instance to set the property on
@@ -264,6 +296,9 @@
 /*! \brief Get the file descriptor for an RTP session (or RTCP) */
 int ast_rtp_instance_fd(struct ast_rtp_instance *instance, int rtcp);
 
+/*! \brief Get the RTP glue that binds a channel to the RTP engine */
+struct ast_rtp_glue *ast_rtp_instance_get_glue(const char *type);
+
 /*! \brief Bridge two channels that use RTP instances */
 enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
 

Modified: team/file/rtp_engine/main/rtp_engine.c
URL: http://svn.digium.com/view/asterisk/team/file/rtp_engine/main/rtp_engine.c?view=diff&rev=130782&r1=130781&r2=130782
==============================================================================
--- team/file/rtp_engine/main/rtp_engine.c (original)
+++ team/file/rtp_engine/main/rtp_engine.c Mon Jul 14 12:30:35 2008
@@ -34,6 +34,9 @@
 
 /* List of RTP engines that are currently registered */
 static AST_RWLIST_HEAD_STATIC(engines, ast_rtp_engine);
+
+/* List of RTP glues */
+static AST_RWLIST_HEAD_STATIC(glues, ast_rtp_glue);
 
 /* The following array defines the MIME Media type (and subtype) for each
    of our codecs, or RTP-specific data type. */
@@ -180,6 +183,62 @@
 	return current_engine ? 0 : -1;
 }
 
+int ast_rtp_glue_register2(struct ast_rtp_glue *glue, struct ast_module *module)
+{
+	struct ast_rtp_glue *current_glue = NULL;
+
+	if (ast_strlen_zero(glue->type)) {
+		return -1;
+	}
+
+	glue->mod = module;
+
+	AST_RWLIST_WRLOCK(&glues);
+
+	AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
+		if (!strcasecmp(current_glue->type, glue->type)) {
+			ast_log(LOG_WARNING, "RTP glue with the name '%s' has already been registered.\n", glue->type);
+			AST_RWLIST_UNLOCK(&glues);
+			return -1;
+		}
+	}
+
+	AST_RWLIST_INSERT_TAIL(&glues, glue, entry);
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	if (option_verbose > 1) {
+		ast_verbose(VERBOSE_PREFIX_2 "Registered RTP glue '%s'\n", glue->type);
+	}
+
+	return 0;
+}
+
+int ast_rtp_glue_unregister(struct ast_rtp_glue *glue)
+{
+	struct ast_rtp_glue *current_glue = NULL;
+
+	AST_RWLIST_WRLOCK(&glues);
+
+	AST_RWLIST_TRAVERSE(&glues, current_glue, entry) {
+		if (current_glue == glue) {
+			break;
+		}
+	}
+
+	if (current_glue) {
+		AST_LIST_REMOVE(&glues, current_glue, entry);
+	}
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	if (current_glue && option_verbose > 1) {
+		ast_verbose(VERBOSE_PREFIX_2 "Unregistered RTP glue '%s'\n", glue->type);
+	}
+
+	return current_glue ? 0 : -1;
+}
+
 struct ast_rtp_instance *ast_rtp_instance_new(const char *engine_name, struct ast_rtp_glue *glue, struct sched_context *sched, struct sockaddr_in *sin)
 {
 	struct ast_rtp_instance *instance = NULL;
@@ -268,6 +327,18 @@
 
 	if (instance->engine->remote_address_set) {
 		instance->engine->remote_address_set(instance, address);
+	}
+
+	return 0;
+}
+
+int ast_rtp_instance_get_remote_address(struct ast_rtp_instance *instance, struct sockaddr_in *address)
+{
+	if ((address->sin_family != AF_INET) ||
+	    (address->sin_port != instance->remote_address.sin_port) ||
+	    (address->sin_addr.s_addr != instance->remote_address.sin_addr.s_addr)) {
+		memcpy(address, &instance->remote_address, sizeof(address));
+		return 1;
 	}
 
 	return 0;
@@ -560,9 +631,489 @@
 	return instance->engine->fd ? instance->engine->fd(instance, rtcp) : -1;
 }
 
+struct ast_rtp_glue *ast_rtp_instance_get_glue(const char *type)
+{
+	struct ast_rtp_glue *glue = NULL;
+
+	AST_RWLIST_RDLOCK(&glues);
+
+	AST_RWLIST_TRAVERSE(&glues, glue, entry) {
+		if (!strcasecmp(glue->type, type)) {
+			break;
+		}
+	}
+
+	AST_RWLIST_UNLOCK(&glues);
+
+	return glue;
+}
+
+static enum ast_bridge_result local_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
+{
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
+	struct ast_frame *fr = NULL;
+
+	/* Start locally bridging both instances */
+	if (instance0->engine->local_bridge && instance0->engine->local_bridge(instance0, instance1)) {
+		ast_debug(3, "Failed to locally bridge %s to %s, backing out.\n", c0->name, c1->name);
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+	if (instance1->engine->local_bridge && instance1->engine->local_bridge(instance1, instance0)) {
+		ast_debug(3, "Failed to locally bridge %s to %s, backing out.\n", c1->name, c0->name);
+		if (instance0->engine->local_bridge) {
+			instance0->engine->local_bridge(instance0, NULL);
+		}
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	ast_poll_channel_add(c0, c1);
+
+	instance0->bridged = instance1;
+	instance1->bridged = instance0;
+
+	/* Hop into a loop waiting for a frame from either channel */
+	cs[0] = c0;
+	cs[1] = c1;
+	cs[2] = NULL;
+	for (;;) {
+                /* If the underlying formats have changed force this bridge to break */
+                if ((c0->rawreadformat != c1->rawwriteformat) || (c1->rawreadformat != c0->rawwriteformat)) {
+                        ast_debug(3, "rtp-engine-local-bridge: Oooh, formats changed, backing out\n");
+                        res = AST_BRIDGE_FAILED_NOWARN;
+                        break;
+                }
+                /* Check if anything changed */
+                if ((c0->tech_pvt != pvt0) ||
+                    (c1->tech_pvt != pvt1) ||
+                    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
+                    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
+                        ast_debug(3, "rtp-engine-local-bridge: Oooh, something is weird, backing out\n");
+                        /* If a masquerade needs to happen we have to try to read in a frame so that it actually happens. Without this we risk being called again and going into a loop */
+                        if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
+                                ast_frfree(fr);
+                        if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
+                                ast_frfree(fr);
+                        res = AST_BRIDGE_RETRY;
+                        break;
+                }
+                /* Wait on a channel to feed us a frame */
+                if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
+                        if (!timeoutms) {
+                                res = AST_BRIDGE_RETRY;
+                                break;
+                        }
+                        if (option_debug > 2)
+                                ast_log(LOG_NOTICE, "rtp-engine-local-bridge: Ooh, empty read...\n");
+                        if (ast_check_hangup(c0) || ast_check_hangup(c1))
+                                break;
+                        continue;
+                }
+                /* Read in frame from channel */
+                fr = ast_read(who);
+                other = (who == c0) ? c1 : c0;
+                /* Depending on the frame we may need to break out of our bridge */
+                if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
+                            ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
+                            ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
+                        /* Record received frame and who */
+                        *fo = fr;
+                        *rc = who;
+                        ast_debug(3, "rtp-engine-local-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
+                        res = AST_BRIDGE_COMPLETE;
+                        break;
+                } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
+                        if ((fr->subclass == AST_CONTROL_HOLD) ||
+                            (fr->subclass == AST_CONTROL_UNHOLD) ||
+                            (fr->subclass == AST_CONTROL_VIDUPDATE) ||
+                            (fr->subclass == AST_CONTROL_T38) ||
+                            (fr->subclass == AST_CONTROL_SRCUPDATE)) {
+                                /* If we are going on hold, then break callback mode and P2P bridging */
+                                if (fr->subclass == AST_CONTROL_HOLD) {
+					if (instance0->engine->local_bridge) {
+						instance0->engine->local_bridge(instance0, NULL);
+					}
+					if (instance1->engine->local_bridge) {
+						instance1->engine->local_bridge(instance1, NULL);
+					}
+					instance0->bridged = NULL;
+					instance1->bridged = NULL;
+                                } else if (fr->subclass == AST_CONTROL_UNHOLD) {
+					if (instance0->engine->local_bridge) {
+						instance0->engine->local_bridge(instance0, instance1);
+					}
+					if (instance1->engine->local_bridge) {
+						instance1->engine->local_bridge(instance1, instance0);
+					}
+					instance0->bridged = instance1;
+					instance1->bridged = instance0;
+                                }
+                                ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
+                                ast_frfree(fr);
+                        } else {
+                                *fo = fr;
+                                *rc = who;
+                                ast_debug(3, "rtp-engine-local-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
+                                res = AST_BRIDGE_COMPLETE;
+                                break;
+                        }
+                } else {
+                        if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
+                            (fr->frametype == AST_FRAME_DTMF_END) ||
+                            (fr->frametype == AST_FRAME_VOICE) ||
+                            (fr->frametype == AST_FRAME_VIDEO) ||
+                            (fr->frametype == AST_FRAME_IMAGE) ||
+                            (fr->frametype == AST_FRAME_HTML) ||
+                            (fr->frametype == AST_FRAME_MODEM) ||
+                            (fr->frametype == AST_FRAME_TEXT)) {
+                                ast_write(other, fr);
+                        }
+
+                        ast_frfree(fr);
+                }
+                /* Swap priority */
+                cs[2] = cs[0];
+                cs[0] = cs[1];
+                cs[1] = cs[2];
+	}
+
+	/* Stop locally bridging both instances */
+	if (instance0->engine->local_bridge) {
+		instance0->engine->local_bridge(instance0, NULL);
+	}
+	if (instance1->engine->local_bridge) {
+		instance1->engine->local_bridge(instance1, NULL);
+	}
+
+	instance0->bridged = NULL;
+	instance1->bridged = NULL;
+
+	ast_poll_channel_del(c0, c1);
+
+	return res;
+}
+
+static enum ast_bridge_result remote_bridge_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1, struct ast_rtp_instance *vinstance0, struct ast_rtp_instance *vinstance1, struct ast_rtp_instance *tinstance0, struct ast_rtp_instance *tinstance1, struct ast_rtp_glue *glue0, struct ast_rtp_glue *glue1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
+{
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	struct ast_channel *who = NULL, *other = NULL, *cs[3] = { NULL, };
+	int oldcodec0 = codec0, oldcodec1 = codec1;
+        struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
+        struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
+	struct ast_frame *fr = NULL;
+
+        /* Test the first channel */
+        if (!(glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0))) {
+		ast_rtp_instance_get_remote_address(instance1, &ac1);
+		if (vinstance1) {
+			ast_rtp_instance_get_remote_address(vinstance1, &vac1);
+		}
+		if (tinstance1) {
+			ast_rtp_instance_get_remote_address(tinstance1, &tac1);
+		}
+        } else {
+                ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
+	}
+
+        /* Test the second channel */
+        if (!(glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0))) {
+		ast_rtp_instance_get_remote_address(instance0, &ac0);
+		if (vinstance0) {
+			ast_rtp_instance_get_remote_address(instance0, &vac0);
+		}
+		if (tinstance0) {
+			ast_rtp_instance_get_remote_address(instance0, &tac0);
+		}
+        } else {
+                ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
+	}
+
+	ast_channel_unlock(c0);
+	ast_channel_unlock(c1);
+
+	ast_poll_channel_add(c0, c1);
+
+	instance0->bridged = instance1;
+	instance1->bridged = instance0;
+
+	/* Go into a loop handling any stray frames that may come in */
+	cs[0] = c0;
+	cs[1] = c1;
+	cs[2] = NULL;
+	for (;;) {
+                /* Check if anything changed */
+                if ((c0->tech_pvt != pvt0) ||
+                    (c1->tech_pvt != pvt1) ||
+                    (c0->masq || c0->masqr || c1->masq || c1->masqr) ||
+                    (c0->monitor || c0->audiohooks || c1->monitor || c1->audiohooks)) {
+                        ast_debug(1, "Oooh, something is weird, backing out\n");
+			res = AST_BRIDGE_RETRY;
+			break;
+                }
+
+                /* Check if they have changed their address */
+		ast_rtp_instance_get_remote_address(instance1, &t1);
+		if (vinstance1) {
+			ast_rtp_instance_get_remote_address(vinstance1, &vt1);
+		}
+		if (tinstance1) {
+			ast_rtp_instance_get_remote_address(tinstance1, &tt1);
+		}
+		if (glue1->get_codec) {
+			codec1 = glue1->get_codec(c1);
+		}
+
+		ast_rtp_instance_get_remote_address(instance0, &t0);
+		if (vinstance0) {
+			ast_rtp_instance_get_remote_address(vinstance0, &vt0);
+		}
+		if (tinstance0) {
+			ast_rtp_instance_get_remote_address(tinstance0, &tt0);
+		}
+		if (glue0->get_codec) {
+			codec0 = glue0->get_codec(c0);
+		}
+
+                if ((inaddrcmp(&t1, &ac1)) ||
+                    (vinstance1 && inaddrcmp(&vt1, &vac1)) ||
+                    (tinstance1 && inaddrcmp(&tt1, &tac1)) ||
+                    (codec1 != oldcodec1)) {
+                        ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
+                        ast_debug(2, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
+                        ast_debug(2, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
+				  c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
+                        ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
+                        ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
+                        ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
+                        if (glue0->update_peer(c0, t1.sin_addr.s_addr ? instance1 : NULL, vt1.sin_addr.s_addr ? vinstance1 : NULL, tt1.sin_addr.s_addr ? tinstance1 : NULL, codec1, 0))
+                                ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
+                        memcpy(&ac1, &t1, sizeof(ac1));
+                        memcpy(&vac1, &vt1, sizeof(vac1));
+                        memcpy(&tac1, &tt1, sizeof(tac1));
+                        oldcodec1 = codec1;
+                }
+                if ((inaddrcmp(&t0, &ac0)) ||
+                    (vinstance0 && inaddrcmp(&vt0, &vac0)) ||
+                    (tinstance0 && inaddrcmp(&tt0, &tac0))) {
+                        ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
+				  c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
+                        ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
+				  c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
+                        if (glue1->update_peer(c1, t0.sin_addr.s_addr ? instance0 : NULL, vt0.sin_addr.s_addr ? vinstance0 : NULL, tt0.sin_addr.s_addr ? tinstance0 : NULL, codec0, 0))
+                                ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
+                        memcpy(&ac0, &t0, sizeof(ac0));
+                        memcpy(&vac0, &vt0, sizeof(vac0));
+                        memcpy(&tac0, &tt0, sizeof(tac0));
+                        oldcodec0 = codec0;
+                }
+
+                /* Wait for frame to come in on the channels */
+                if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
+                        if (!timeoutms) {
+				res = AST_BRIDGE_RETRY;
+				break;
+                        }
+                        ast_debug(1, "Ooh, empty read...\n");
+                        if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
+                                break;
+			}
+                        continue;
+                }
+                fr = ast_read(who);
+                other = (who == c0) ? c1 : c0;
+                if (!fr || ((fr->frametype == AST_FRAME_DTMF_BEGIN || fr->frametype == AST_FRAME_DTMF_END) &&
+                            (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
+                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
+                        /* Break out of bridge */
+                        *fo = fr;
+                        *rc = who;
+                        ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
+			res = AST_BRIDGE_COMPLETE;
+			break;
+                } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
+                        if ((fr->subclass == AST_CONTROL_HOLD) ||
+                            (fr->subclass == AST_CONTROL_UNHOLD) ||
+                            (fr->subclass == AST_CONTROL_VIDUPDATE) ||
+                            (fr->subclass == AST_CONTROL_T38) ||
+                            (fr->subclass == AST_CONTROL_SRCUPDATE)) {
+                                if (fr->subclass == AST_CONTROL_HOLD) {
+                                        /* If we someone went on hold we want the other side to reinvite back to us */
+                                        if (who == c0)
+                                                glue1->update_peer(c1, NULL, NULL, NULL, 0, 0);
+                                        else
+                                                glue0->update_peer(c0, NULL, NULL, NULL, 0, 0);
+                                } else if (fr->subclass == AST_CONTROL_UNHOLD) {
+                                        /* If they went off hold they should go back to being direct */
+                                        if (who == c0)
+                                                glue1->update_peer(c1, instance0, vinstance0, tinstance0, codec0, 0);
+                                        else
+                                                glue0->update_peer(c0, instance1, vinstance1, tinstance1, codec1, 0);
+                                }
+                                /* Update local address information */
+                                ast_rtp_instance_get_remote_address(instance0, &t0);
+                                memcpy(&ac0, &t0, sizeof(ac0));
+                                ast_rtp_instance_get_remote_address(instance1, &t1);
+                                memcpy(&ac1, &t1, sizeof(ac1));
+                                /* Update codec information */
+                                if (glue0->get_codec && c0->tech_pvt) {
+                                        oldcodec0 = codec0 = glue0->get_codec(c0);
+				}
+                                if (glue1->get_codec && c1->tech_pvt) {
+                                        oldcodec1 = codec1 = glue1->get_codec(c1);
+				}
+                                ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
+                                ast_frfree(fr);
+                        } else {
+                                *fo = fr;
+                                *rc = who;
+                                ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
+                                return AST_BRIDGE_COMPLETE;
+                        }
+                } else {
+                        if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
+                            (fr->frametype == AST_FRAME_DTMF_END) ||
+                            (fr->frametype == AST_FRAME_VOICE) ||
+                            (fr->frametype == AST_FRAME_VIDEO) ||
+                            (fr->frametype == AST_FRAME_IMAGE) ||
+                            (fr->frametype == AST_FRAME_HTML) ||
+                            (fr->frametype == AST_FRAME_MODEM) ||
+                            (fr->frametype == AST_FRAME_TEXT)) {
+                                ast_write(other, fr);
+                        }
+                        ast_frfree(fr);
+                }
+                /* Swap priority */
+                cs[2] = cs[0];
+                cs[0] = cs[1];
+                cs[1] = cs[2];
+	}
+
+	if (glue0->update_peer(c0, NULL, NULL, NULL, 0, 0)) {
+		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
+	}
+	if (glue1->update_peer(c1, NULL, NULL, NULL, 0, 0)) {
+		ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
+	}
+
+	instance0->bridged = NULL;
+	instance1->bridged = NULL;
+
+	ast_poll_channel_del(c0, c1);
+
+	return res;
+}
+
 enum ast_bridge_result ast_rtp_instance_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
 {
-	return AST_BRIDGE_FAILED;
+	struct ast_rtp_instance *instance0, *instance1, *vinstance0, *vinstance1, *tinstance0, *tinstance1;
+	struct ast_rtp_glue *glue0, *glue1;
+	enum ast_rtp_glue_result audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID, video_glue0_res = AST_RTP_GLUE_RESULT_FORBID, text_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_rtp_glue_result audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID, video_glue1_res = AST_RTP_GLUE_RESULT_FORBID, text_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+	enum ast_bridge_result res = AST_BRIDGE_FAILED;
+	int codec0 = 0, codec1 = 0;
+
+	/* Lock both channels so we can look for the glue that binds them together */
+	ast_channel_lock(c0);
+	while (ast_channel_trylock(c1)) {
+		ast_channel_unlock(c0);
+		usleep(1);
+		ast_channel_lock(c0);
+	}
+
+	/* Ensure neither channel got hungup during lock avoidance */
+	if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
+		ast_log(LOG_WARNING, "Got hangup while attempting to bridge '%s' and '%s'\n", c0->name, c1->name);
+                ast_channel_unlock(c0);
+                ast_channel_unlock(c1);
+                return AST_BRIDGE_FAILED;
+        }
+
+	/* Grab glue that binds each channel to something using the RTP engine */
+	if (!(glue0 = ast_rtp_instance_get_glue(c0->tech->type)) || !(glue1 = ast_rtp_instance_get_glue(c1->tech->type))) {
+		ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", glue0 ? c1->name : c0->name);
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED;
+	}
+
+	audio_glue0_res = glue0->get_rtp_info(c0, &instance0);
+	video_glue0_res = glue0->get_vrtp_info ? glue0->get_vrtp_info(c0, &vinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+	text_glue0_res = glue0->get_trtp_info ? glue0->get_trtp_info(c0, &tinstance0) : AST_RTP_GLUE_RESULT_FORBID;
+
+        audio_glue1_res = glue1->get_rtp_info(c1, &instance1);
+        video_glue1_res = glue1->get_vrtp_info ? glue1->get_vrtp_info(c1, &vinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+        text_glue1_res = glue1->get_trtp_info ? glue1->get_trtp_info(c1, &tinstance1) : AST_RTP_GLUE_RESULT_FORBID;
+
+	/* If we are carrying video, and both sides are not going to remotely bridge... fail the native bridge */
+	if (video_glue0_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue0_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue0_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+		audio_glue0_res = AST_RTP_GLUE_RESULT_FORBID;
+	}
+        if (video_glue1_res != AST_RTP_GLUE_RESULT_FORBID && (audio_glue1_res != AST_RTP_GLUE_RESULT_REMOTE || video_glue1_res != AST_RTP_GLUE_RESULT_REMOTE)) {
+                audio_glue1_res = AST_RTP_GLUE_RESULT_FORBID;
+        }
+
+	/* If any sort of bridge is forbidden just completely bail out and go back to generic bridging */
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_FORBID || audio_glue1_res == AST_RTP_GLUE_RESULT_FORBID) {
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+
+        /* If both sides are not using the same method of DTMF transmission
+         * (ie: one is RFC2833, other is INFO... then we can not do direct media.
+         * --------------------------------------------------
+         * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
+         * |-----------|------------|-----------------------|
+         * | Inband    | False      | True                  |
+         * | RFC2833   | True       | True                  |
+         * | SIP INFO  | False      | False                 |
+         * --------------------------------------------------
+	 */
+	if ((instance0->properties[AST_RTP_PROPERTY_DTMF] != instance1->properties[AST_RTP_PROPERTY_DTMF]) || (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) {
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+
+	/* If we have gotten to a local bridge make sure that both sides have the same local bridge callback */
+	if ((audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) && (instance0->engine->local_bridge != instance1->engine->local_bridge)) {
+		ast_channel_unlock(c0);
+		ast_channel_unlock(c1);
+		return AST_BRIDGE_FAILED_NOWARN;
+	}
+
+	/* Make sure that codecs match */
+	codec0 = glue0->get_codec ? glue0->get_codec(c0) : 0;
+	codec1 = glue1->get_codec ? glue1->get_codec(c1) : 0;
+	if (codec0 && codec1 && !(codec0 & codec1)) {
+		ast_debug(3, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
+                ast_channel_unlock(c0);
+                ast_channel_unlock(c1);
+                return AST_BRIDGE_FAILED_NOWARN;
+        }
+	
+	/* Depending on the end result for bridging either do a local bridge or remote bridge */
+	if (audio_glue0_res == AST_RTP_GLUE_RESULT_LOCAL || audio_glue1_res == AST_RTP_GLUE_RESULT_LOCAL) {
+		ast_verb(3, "Locally bridging %s and %s\n", c0->name, c1->name);
+		res = local_bridge_loop(c0, c1, instance0, instance1, timeoutms, flags, fo, rc, c0->tech_pvt, c1->tech_pvt);
+	} else {
+		ast_verb(3, "Remotely bridging %s and %s\n", c0->name, c1->name);
+		res = remote_bridge_loop(c0, c1, instance0, instance1, vinstance0, vinstance1, tinstance0, tinstance1, glue0, glue1, codec0, codec1, timeoutms, flags, fo, rc, c0->tech_pvt, c1->tech_pvt);
+	}
+
+	return res;
 }
 
 int ast_rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)




More information about the asterisk-commits mailing list