Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:09 2007

Asterisk developer's documentation :: Codename Pineapple

---

chan_mgcp.c File Reference

---

Detailed Description

Implementation of Media Gateway Control Protocol.

Author:

Mark Spencer <markster@digium.com>

See also

• MGCP configuration

Definition in file chan_mgcp.c.

#include "asterisk.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <netdb.h>
#include <sys/signal.h>
#include <signal.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <ctype.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/rtp.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/cli.h"
#include "asterisk/say.h"
#include "asterisk/cdr.h"
#include "asterisk/astdb.h"
#include "asterisk/features.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/dsp.h"
#include "asterisk/devicestate.h"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"

Include dependency graph for chan_mgcp.c:

Go to the source code of this file.

Data Structures
struct	mgcp_endpoint
struct	mgcp_gateway
struct	mgcp_message
	mgcp_message: MGCP message for queuing up More...
struct	mgcp_request
struct	mgcp_response
struct	mgcp_subchannel
Defines
#define	CANREINVITE   1
#define	DEFAULT_EXPIRY   120
#define	DEFAULT_MGCP_CA_PORT   2727
#define	DEFAULT_MGCP_GW_PORT   2427
#define	DEFAULT_RETRANS   1000
#define	INADDR_NONE   (in_addr_t)(-1)
#define	IPTOS_MINCOST   0x02
#define	MAX_EXPIRY   3600
#define	MAX_RETRANS   5
#define	MAX_SUBS   2
#define	MGCP_CX_CONF   3
#define	MGCP_CX_CONFERENCE   3
#define	MGCP_CX_INACTIVE   4
#define	MGCP_CX_MUTE   4
#define	MGCP_CX_RECVONLY   1
#define	MGCP_CX_SENDONLY   0
#define	MGCP_CX_SENDRECV   2
#define	MGCP_DTMF_HYBRID   (1 << 2)
#define	MGCP_DTMF_INBAND   (1 << 1)
#define	MGCP_DTMF_RFC2833   (1 << 0)
#define	MGCP_MAX_HEADERS   64
#define	MGCP_MAX_LINES   64
#define	MGCP_MAX_PACKET   1500
#define	MGCP_OFFHOOK   2
#define	MGCP_ONHOOK   1
#define	MGCP_SUBCHANNEL_MAGIC   "!978!"
#define	MGCPDUMPER
#define	RESPONSE_TIMEOUT   30
#define	SUB_ALT   1
#define	SUB_REAL   0
#define	TYPE_LINE   2
#define	TYPE_TRUNK   1
Enumerations
enum	{   MGCP_CMD_EPCF, MGCP_CMD_CRCX, MGCP_CMD_MDCX, MGCP_CMD_DLCX,   MGCP_CMD_RQNT, MGCP_CMD_NTFY, MGCP_CMD_AUEP, MGCP_CMD_AUCX,   MGCP_CMD_RSIP }
Functions
static char *	__get_header (struct mgcp_request *req, char *name, int *start)
static int	__mgcp_xmit (struct mgcp_gateway *gw, char *data, int len)
static int	add_header (struct mgcp_request *req, char *var, char *value)
static int	add_line (struct mgcp_request *req, char *line)
static int	add_sdp (struct mgcp_request *resp, struct mgcp_subchannel *sub, struct ast_rtp *rtp)
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT,"Media Gateway Control Protocol (MGCP)",.load=load_module,.unload=unload_module,.reload=reload,)
	AST_MUTEX_DEFINE_STATIC (gatelock)
	gatelock: mutex for gateway/endpoint lists
	AST_MUTEX_DEFINE_STATIC (mgcp_reload_lock)
	AST_MUTEX_DEFINE_STATIC (monlock)
	AST_MUTEX_DEFINE_STATIC (netlock)
static int	attempt_transfer (struct mgcp_endpoint *p)
static struct mgcp_gateway *	build_gateway (char *cat, struct ast_variable *v)
	build_gateway: parse mgcp.conf and create gateway/endpoint structures
static char *	control2str (int ind)
static void	destroy_endpoint (struct mgcp_endpoint *e)
static void	destroy_gateway (struct mgcp_gateway *g)
static void *	do_monitor (void *data)
static void	dump_cmd_queues (struct mgcp_endpoint *p, struct mgcp_subchannel *sub)
	dump_cmd_queues: (SC:) cleanup pending commands
static void	dump_queue (struct mgcp_gateway *gw, struct mgcp_endpoint *p)
static int	find_and_retrans (struct mgcp_subchannel *sub, struct mgcp_request *req)
static struct mgcp_request *	find_command (struct mgcp_endpoint *p, struct mgcp_subchannel *sub, struct mgcp_request **queue, ast_mutex_t *l, int ident)
	find_command: (SC:) remove command transaction from queue
static struct mgcp_subchannel *	find_subchannel_and_lock (char *name, int msgid, struct sockaddr_in *sin)
static char *	get_csv (char *c, int *len, char **next)
	get_csv: (SC:) get comma separated value
static char *	get_header (struct mgcp_request *req, char *name)
static char *	get_sdp (struct mgcp_request *req, char *name)
static char *	get_sdp_by_line (char *line, char *name, int nameLen)
static char *	get_sdp_iterate (int *iterator, struct mgcp_request *req, char *name)
static void	handle_hd_hf (struct mgcp_subchannel *sub, char *ev)
static int	handle_request (struct mgcp_subchannel *sub, struct mgcp_request *req, struct sockaddr_in *sin)
static void	handle_response (struct mgcp_endpoint *p, struct mgcp_subchannel *sub, int result, unsigned int ident, struct mgcp_request *resp)
static int	has_voicemail (struct mgcp_endpoint *p)
static int	init_req (struct mgcp_endpoint *p, struct mgcp_request *req, char *verb)
static int	init_resp (struct mgcp_request *req, char *resp, struct mgcp_request *orig, char *resprest)
static int	load_module (void)
	load_module: PBX load module - initialization ---
static int	mgcp_answer (struct ast_channel *ast)
static int	mgcp_audit_endpoint (int fd, int argc, char *argv[])
static int	mgcp_call (struct ast_channel *ast, char *dest, int timeout)
static int	mgcp_devicestate (void *data)
	mgcp_devicestate: channel callback for device status monitoring
static int	mgcp_do_debug (int fd, int argc, char *argv[])
static int	mgcp_do_reload (void)
	mgcp_do_reload: Reload module
static int	mgcp_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static enum ast_rtp_get_result	mgcp_get_rtp_peer (struct ast_channel *chan, struct ast_rtp **rtp)
static int	mgcp_hangup (struct ast_channel *ast)
static int	mgcp_indicate (struct ast_channel *ast, int ind, const void *data, size_t datalen)
static struct ast_channel *	mgcp_new (struct mgcp_subchannel *sub, int state)
static int	mgcp_no_debug (int fd, int argc, char *argv[])
static int	mgcp_postrequest (struct mgcp_endpoint *p, struct mgcp_subchannel *sub, char *data, int len, unsigned int seqno)
static void	mgcp_queue_control (struct mgcp_subchannel *sub, int control)
static void	mgcp_queue_frame (struct mgcp_subchannel *sub, struct ast_frame *f)
static void	mgcp_queue_hangup (struct mgcp_subchannel *sub)
static struct ast_frame *	mgcp_read (struct ast_channel *ast)
static int	mgcp_reload (int fd, int argc, char *argv[])
static struct ast_channel *	mgcp_request (const char *type, int format, void *data, int *cause)
static struct ast_frame *	mgcp_rtp_read (struct mgcp_subchannel *sub)
static int	mgcp_senddigit_begin (struct ast_channel *ast, char digit)
static int	mgcp_senddigit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	mgcp_set_rtp_peer (struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
static int	mgcp_show_endpoints (int fd, int argc, char *argv[])
static void *	mgcp_ss (void *data)
static int	mgcp_write (struct ast_channel *ast, struct ast_frame *frame)
static int	mgcpsock_read (int *id, int fd, short events, void *ignore)
static void	parse (struct mgcp_request *req)
static int	process_sdp (struct mgcp_subchannel *sub, struct mgcp_request *req)
static void	prune_gateways (void)
static int	reload (void)
static int	reload_config (void)
static int	reqprep (struct mgcp_request *req, struct mgcp_endpoint *p, char *verb)
static int	resend_response (struct mgcp_subchannel *sub, struct mgcp_response *resp)
static int	respprep (struct mgcp_request *resp, struct mgcp_endpoint *p, char *msg, struct mgcp_request *req, char *msgrest)
static int	restart_monitor (void)
	Start the channel monitor thread.
static int	retrans_pkt (void *data)
static void	sdpLineNum_iterator_init (int *iterator)
static int	send_request (struct mgcp_endpoint *p, struct mgcp_subchannel *sub, struct mgcp_request *req, unsigned int seqno)
static int	send_response (struct mgcp_subchannel *sub, struct mgcp_request *req)
static void	start_rtp (struct mgcp_subchannel *sub)
static int	transmit_audit_endpoint (struct mgcp_endpoint *p)
static int	transmit_connect_with_sdp (struct mgcp_subchannel *sub, struct ast_rtp *rtp)
static int	transmit_connection_del (struct mgcp_subchannel *sub)
static int	transmit_connection_del_w_params (struct mgcp_endpoint *p, char *callid, char *cxident)
static int	transmit_modify_request (struct mgcp_subchannel *sub)
static int	transmit_modify_with_sdp (struct mgcp_subchannel *sub, struct ast_rtp *rtp, int codecs)
static int	transmit_notify_request (struct mgcp_subchannel *sub, char *tone)
static int	transmit_notify_request_with_callerid (struct mgcp_subchannel *sub, char *tone, char *callernum, char *callername)
static int	transmit_response (struct mgcp_subchannel *sub, char *msg, struct mgcp_request *req, char *msgrest)
static int	unalloc_sub (struct mgcp_subchannel *sub)
static int	unload_module (void)
Variables
static struct in_addr	__ourip
static char	accountcode [AST_MAX_ACCOUNT_CODE] = ""
static int	adsi = 0
static int	amaflags = 0
static const char	audit_endpoint_usage []
static struct sockaddr_in	bindaddr
static int	callreturn = 0
static int	callwaiting = 0
static int	cancallforward = 0
static int	canreinvite = CANREINVITE
static int	capability = AST_FORMAT_ULAW
static char	cid_name [AST_MAX_EXTENSION] = ""
static char	cid_num [AST_MAX_EXTENSION] = ""
static struct ast_cli_entry	cli_mgcp []
static const char	config [] = "mgcp.conf"
static char	context [AST_MAX_EXTENSION] = "default"
static ast_group_t	cur_callergroup = 0
static ast_group_t	cur_pickupgroup = 0
static const char	debug_usage []
static struct ast_jb_conf	default_jbconf
static int	dtmfmode = 0
static int	firstdigittimeout = 16000
static struct mgcp_gateway *	gateways
static int	gendigittimeout = 8000
static struct ast_jb_conf	global_jbconf
static int	immediate = 0
static struct io_context *	io
static char	language [MAX_LANGUAGE] = ""
static char	mailbox [AST_MAX_EXTENSION]
static int	matchdigittimeout = 3000
static char *	mgcp_cxmodes []
static const char	mgcp_reload_usage []
static int	mgcp_reloading = 0
static struct ast_rtp_protocol	mgcp_rtp
static const struct ast_channel_tech	mgcp_tech
static int	mgcpdebug = 0
static int	mgcpsock = -1
static int *	mgcpsock_read_id = NULL
static pthread_t	monitor_thread = AST_PTHREADT_NULL
static char	musicclass [MAX_MUSICCLASS] = ""
static int	nat = 0
static const char	no_debug_usage []
static int	nonCodecCapability = AST_RTP_DTMF
static unsigned int	oseq
static char	ourhost [MAXHOSTNAMELEN]
static int	ourport
static struct sched_context *	sched
static const char	show_endpoints_usage []
static int	singlepath = 0
static int	slowsequence = 0
static const char	tdesc [] = "Media Gateway Control Protocol (MGCP)"
static int	threewaycalling = 0
static int	tos = 0
static int	transfer = 0

---

Define Documentation

#define CANREINVITE   1

Definition at line 93 of file chan_mgcp.c. Referenced by build_gateway().

#define DEFAULT_EXPIRY   120

Definition at line 91 of file chan_mgcp.c. Referenced by reload_config().

#define DEFAULT_MGCP_CA_PORT   2727

From RFC 2705 Definition at line 117 of file chan_mgcp.c. Referenced by reload_config().

#define DEFAULT_MGCP_GW_PORT   2427

From RFC 2705 Definition at line 116 of file chan_mgcp.c.

#define DEFAULT_RETRANS   1000

How frequently to retransmit Definition at line 119 of file chan_mgcp.c. Referenced by __sip_reliable_xmit(), mgcp_postrequest(), and retrans_pkt().

#define INADDR_NONE   (in_addr_t)(-1)

Definition at line 96 of file chan_mgcp.c. Referenced by build_gateway().

#define IPTOS_MINCOST   0x02

Definition at line 81 of file chan_mgcp.c.

#define MAX_EXPIRY   3600

Definition at line 92 of file chan_mgcp.c.

#define MAX_RETRANS   5

Try only 5 times for retransmissions Definition at line 120 of file chan_mgcp.c. Referenced by retrans_pkt().

#define MAX_SUBS   2

Definition at line 272 of file chan_mgcp.c. Referenced by build_gateway(), and destroy_endpoint().

#define MGCP_CX_CONF   3

Definition at line 126 of file chan_mgcp.c. Referenced by handle_request().

#define MGCP_CX_CONFERENCE   3

Definition at line 127 of file chan_mgcp.c.

#define MGCP_CX_INACTIVE   4

Definition at line 129 of file chan_mgcp.c. Referenced by build_gateway(), mgcp_hangup(), and unalloc_sub().

#define MGCP_CX_MUTE   4

Definition at line 128 of file chan_mgcp.c. Referenced by handle_request().

#define MGCP_CX_RECVONLY   1

Definition at line 124 of file chan_mgcp.c. Referenced by handle_request(), mgcp_call(), and mgcp_hangup().

#define MGCP_CX_SENDONLY   0

MGCP rtp stream modes { Definition at line 123 of file chan_mgcp.c.

#define MGCP_CX_SENDRECV   2

Definition at line 125 of file chan_mgcp.c. Referenced by handle_hd_hf(), handle_request(), mgcp_answer(), and mgcp_call().

#define MGCP_DTMF_HYBRID   (1 << 2)

Definition at line 114 of file chan_mgcp.c. Referenced by build_gateway(), mgcp_hangup(), mgcp_new(), and mgcp_ss().

#define MGCP_DTMF_INBAND   (1 << 1)

Definition at line 113 of file chan_mgcp.c. Referenced by build_gateway(), mgcp_hangup(), mgcp_new(), mgcp_rtp_read(), mgcp_ss(), transmit_modify_request(), transmit_notify_request(), and transmit_notify_request_with_callerid().

#define MGCP_DTMF_RFC2833   (1 << 0)

Definition at line 112 of file chan_mgcp.c. Referenced by build_gateway(), and mgcp_rtp_read().

#define MGCP_MAX_HEADERS   64

The private structures of the mgcp channels are linked for ! selecting outgoing channels Definition at line 231 of file chan_mgcp.c. Referenced by add_header(), init_req(), init_resp(), and parse().

#define MGCP_MAX_LINES   64

Definition at line 232 of file chan_mgcp.c. Referenced by add_line(), and parse().

#define MGCP_MAX_PACKET   1500

Also from RFC 2543, should sub headers tho Definition at line 118 of file chan_mgcp.c.

#define MGCP_OFFHOOK   2

Definition at line 306 of file chan_mgcp.c. Referenced by handle_hd_hf(), handle_request(), handle_response(), mgcp_call(), mgcp_hangup(), transmit_modify_request(), transmit_notify_request(), and transmit_notify_request_with_callerid().

#define MGCP_ONHOOK   1

Definition at line 305 of file chan_mgcp.c. Referenced by build_gateway(), do_monitor(), handle_request(), handle_response(), mgcp_call(), mgcp_hangup(), mgcp_request(), transmit_modify_request(), transmit_notify_request(), and transmit_notify_request_with_callerid().

#define MGCP_SUBCHANNEL_MAGIC   "!978!"

subchannel magic string. Needed to prove that any subchannel pointer passed by asterisk really points to a valid subchannel memory area. Ugly.. But serves the purpose for the time being. Definition at line 283 of file chan_mgcp.c. Referenced by build_gateway(), and mgcp_hangup().

#define MGCPDUMPER

Definition at line 90 of file chan_mgcp.c.

#define RESPONSE_TIMEOUT   30

in seconds Definition at line 262 of file chan_mgcp.c. Referenced by find_and_retrans().

#define SUB_ALT   1

Definition at line 275 of file chan_mgcp.c.

#define SUB_REAL   0

Definition at line 274 of file chan_mgcp.c.

#define TYPE_LINE   2

Definition at line 309 of file chan_mgcp.c. Referenced by build_device(), build_gateway(), do_monitor(), mgcp_call(), and skinny_hangup().

#define TYPE_TRUNK   1

Definition at line 308 of file chan_mgcp.c. Referenced by build_device(), and build_gateway().

---

Enumeration Type Documentation

anonymous enum

Enumerator: MGCP_CMD_EPCF  MGCP_CMD_CRCX  MGCP_CMD_MDCX  MGCP_CMD_DLCX  MGCP_CMD_RQNT  MGCP_CMD_NTFY  MGCP_CMD_AUEP  MGCP_CMD_AUCX  MGCP_CMD_RSIP  Definition at line 140 of file chan_mgcp.c. { MGCP_CMD_EPCF, MGCP_CMD_CRCX, MGCP_CMD_MDCX, MGCP_CMD_DLCX, MGCP_CMD_RQNT, MGCP_CMD_NTFY, MGCP_CMD_AUEP, MGCP_CMD_AUCX, MGCP_CMD_RSIP };

---

Function Documentation

static char* __get_header (  struct mgcp_request *  req, char *  name, int *  start )  [static]

Definition at line 1543 of file chan_mgcp.c. References mgcp_request::header, mgcp_request::headers, and len. Referenced by build_route(), copy_all_header(), copy_via_headers(), func_header_read(), get_header(), and handle_response_register(). { int x; int len = strlen(name); char *r; for (x=*start;x<req->headers;x++) { if (!strncasecmp(req->header[x], name, len) && (req->header[x][len] == ':')) { r = req->header[x] + len + 1; while(*r && (*r < 33)) r++; *start = x+1; return r; } } /* Don't return NULL, so get_header is always a valid pointer */ return ""; }

static int __mgcp_xmit (  struct mgcp_gateway *  gw, char *  data, int  len )  [static]

Definition at line 487 of file chan_mgcp.c. References mgcp_gateway::addr, ast_log(), mgcp_gateway::defaddr, and LOG_WARNING. Referenced by mgcp_postrequest(), resend_response(), retrans_pkt(), and send_response(). { int res; if (gw->addr.sin_addr.s_addr) res=sendto(mgcpsock, data, len, 0, (struct sockaddr *)&gw->addr, sizeof(struct sockaddr_in)); else res=sendto(mgcpsock, data, len, 0, (struct sockaddr *)&gw->defaddr, sizeof(struct sockaddr_in)); if (res != len) { ast_log(LOG_WARNING, "mgcp_xmit returned %d: %s\n", res, strerror(errno)); } return res; }

static int add_header (  struct mgcp_request *  req, char *  var, char *  value )  [static]

Definition at line 1894 of file chan_mgcp.c. References ast_log(), mgcp_request::data, mgcp_request::header, mgcp_request::headers, mgcp_request::len, mgcp_request::lines, LOG_WARNING, and MGCP_MAX_HEADERS. Referenced by __transmit_response(), add_digit(), add_header_contentLength(), add_t38_sdp(), add_text(), add_vidupdate(), append_date(), append_maxforwards(), copy_all_header(), copy_header(), copy_via_headers(), reqprep(), respprep(), transmit_audit_endpoint(), transmit_connection_del(), transmit_connection_del_w_params(), transmit_invite(), transmit_modify_request(), transmit_notify_request(), transmit_notify_request_with_callerid(), transmit_notify_with_mwi(), transmit_notify_with_sipfrag(), transmit_refer(), transmit_register(), transmit_reinvite_with_sdp(), transmit_request_with_auth(), transmit_response_with_allow(), transmit_response_with_attachment(), transmit_response_with_auth(), transmit_response_with_unsupported(), and transmit_state_notify(). { if (req->len >= sizeof(req->data) - 4) { ast_log(LOG_WARNING, "Out of space, can't add anymore\n"); return -1; } if (req->lines) { ast_log(LOG_WARNING, "Can't add more headers when lines have been added\n"); return -1; } req->header[req->headers] = req->data + req->len; snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s: %s\r\n", var, value); req->len += strlen(req->header[req->headers]); if (req->headers < MGCP_MAX_HEADERS) req->headers++; else { ast_log(LOG_WARNING, "Out of header space\n"); return -1; } return 0; }

static int add_line (  struct mgcp_request *  req, char *  line )  [static]

Definition at line 1916 of file chan_mgcp.c. References ast_log(), mgcp_request::data, mgcp_request::len, mgcp_request::line, mgcp_request::lines, LOG_WARNING, and MGCP_MAX_LINES. Referenced by add_digit(), add_t38_sdp(), add_text(), add_vidupdate(), transmit_notify_with_mwi(), transmit_notify_with_sipfrag(), and transmit_state_notify(). { if (req->len >= sizeof(req->data) - 4) { ast_log(LOG_WARNING, "Out of space, can't add anymore\n"); return -1; } if (!req->lines) { /* Add extra empty return */ snprintf(req->data + req->len, sizeof(req->data) - req->len, "\r\n"); req->len += strlen(req->data + req->len); } req->line[req->lines] = req->data + req->len; snprintf(req->line[req->lines], sizeof(req->data) - req->len, "%s", line); req->len += strlen(req->line[req->lines]); if (req->lines < MGCP_MAX_LINES) req->lines++; else { ast_log(LOG_WARNING, "Out of line space\n"); return -1; } return 0; }

static int add_sdp (  struct mgcp_request *  resp, struct mgcp_subchannel *  sub, struct ast_rtp *  rtp )  [static]

Definition at line 2018 of file chan_mgcp.c. References AST_FORMAT_MAX_AUDIO, ast_inet_ntoa(), ast_log(), ast_rtp_get_peer(), ast_rtp_get_us(), ast_verbose(), mgcp_endpoint::capability, len, LOG_WARNING, mgcpdebug, mgcp_gateway::ourip, mgcp_endpoint::parent, mgcp_subchannel::parent, mgcp_subchannel::rtp, s, mgcp_endpoint::sub, and mgcp_subchannel::tmpdest. Referenced by transmit_invite(), transmit_reinvite_with_sdp(), transmit_response_with_attachment(), and transmit_response_with_sdp(). { int len; int codec; char costr[80]; struct sockaddr_in sin; char v[256]; char s[256]; char o[256]; char c[256]; char t[256]; char m[256] = ""; char a[1024] = ""; int x; struct sockaddr_in dest; struct mgcp_endpoint *p = sub->parent; /* XXX We break with the "recommendation" and send our IP, in order that our peer doesn't have to ast_gethostbyname() us XXX */ len = 0; if (!sub->rtp) { ast_log(LOG_WARNING, "No way to add SDP without an RTP structure\n"); return -1; } ast_rtp_get_us(sub->rtp, &sin); if (rtp) { ast_rtp_get_peer(rtp, &dest); } else { if (sub->tmpdest.sin_addr.s_addr) { dest.sin_addr = sub->tmpdest.sin_addr; dest.sin_port = sub->tmpdest.sin_port; /* Reset temporary destination */ memset(&sub->tmpdest, 0, sizeof(sub->tmpdest)); } else { dest.sin_addr = p->parent->ourip; dest.sin_port = sin.sin_port; } } if (mgcpdebug) { ast_verbose("We're at %s port %d\n", ast_inet_ntoa(p->parent->ourip), ntohs(sin.sin_port)); } snprintf(v, sizeof(v), "v=0\r\n"); snprintf(o, sizeof(o), "o=root %d %d IN IP4 %s\r\n", getpid(), getpid(), ast_inet_ntoa(dest.sin_addr)); snprintf(s, sizeof(s), "s=session\r\n"); snprintf(c, sizeof(c), "c=IN IP4 %s\r\n", ast_inet_ntoa(dest.sin_addr)); snprintf(t, sizeof(t), "t=0 0\r\n"); snprintf(m, sizeof(m), "m=audio %d RTP/AVP", ntohs(dest.sin_port)); for (x = 1; x <= AST_FORMAT_MAX_AUDIO; x <<= 1) { if (p->capability & x) { if (mgcpdebug) { ast_verbose("Answering with capability %d\n", x); } codec = ast_rtp_lookup_code(sub->rtp, 1, x); if (codec > -1) { snprintf(costr, sizeof(costr), " %d", codec); strncat(m, costr, sizeof(m) - strlen(m) - 1); snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(1, x, 0)); strncat(a, costr, sizeof(a) - strlen(a) - 1); } } } for (x = 1; x <= AST_RTP_MAX; x <<= 1) { if (p->nonCodecCapability & x) { if (mgcpdebug) { ast_verbose("Answering with non-codec capability %d\n", x); } codec = ast_rtp_lookup_code(sub->rtp, 0, x); if (codec > -1) { snprintf(costr, sizeof(costr), " %d", codec); strncat(m, costr, sizeof(m) - strlen(m) - 1); snprintf(costr, sizeof(costr), "a=rtpmap:%d %s/8000\r\n", codec, ast_rtp_lookup_mime_subtype(0, x, 0)); strncat(a, costr, sizeof(a) - strlen(a) - 1); if (x == AST_RTP_DTMF) { /* Indicate we support DTMF... Not sure about 16, but MSN supports it so dang it, we will too... */ snprintf(costr, sizeof costr, "a=fmtp:%d 0-16\r\n", codec); strncat(a, costr, sizeof(a) - strlen(a) - 1); } } } } strncat(m, "\r\n", sizeof(m) - strlen(m) - 1); len = strlen(v) + strlen(s) + strlen(o) + strlen(c) + strlen(t) + strlen(m) + strlen(a); snprintf(costr, sizeof(costr), "%d", len); add_line(resp, v); add_line(resp, o); add_line(resp, s); add_line(resp, c); add_line(resp, t); add_line(resp, m); add_line(resp, a); return 0; }

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_DEFAULT  , "Media Gateway Control Protocol (MGCP)"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

AST_MUTEX_DEFINE_STATIC (  gatelock   )

gatelock: mutex for gateway/endpoint lists

AST_MUTEX_DEFINE_STATIC (  mgcp_reload_lock   )

AST_MUTEX_DEFINE_STATIC (  monlock   )

AST_MUTEX_DEFINE_STATIC (  netlock   )

Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical.

static int attempt_transfer (  struct mgcp_endpoint *  p  )  [static]

Definition at line 2870 of file chan_mgcp.c. References ast_channel::_softhangup, ast_channel::_state, mgcp_subchannel::alreadygone, ast_bridged_channel(), ast_channel_masquerade(), AST_CONTROL_RINGING, AST_CONTROL_UNHOLD, ast_indicate(), ast_log(), ast_queue_control(), AST_SOFTHANGUP_DEV, AST_STATE_RINGING, ast_verbose(), mgcp_subchannel::id, LOG_DEBUG, LOG_WARNING, mgcp_queue_hangup(), mgcp_gateway::name, mgcp_endpoint::name, mgcp_subchannel::next, option_verbose, mgcp_subchannel::owner, mgcp_endpoint::parent, mgcp_endpoint::sub, unalloc_sub(), and VERBOSE_PREFIX_3. Referenced by handle_onhook_message(), handle_request(), handle_soft_key_event_message(), local_attended_transfer(), and zt_handle_event(). { /* ************************* * I hope this works. * Copied out of chan_zap * Cross your fingers * *************************/ /* In order to transfer, we need at least one of the channels to actually be in a call bridge. We can't conference two applications together (but then, why would we want to?) */ if (ast_bridged_channel(p->sub->owner)) { /* The three-way person we're about to transfer to could still be in MOH, so stop if now if appropriate */ if (ast_bridged_channel(p->sub->next->owner)) ast_queue_control(p->sub->next->owner, AST_CONTROL_UNHOLD); if (p->sub->owner->_state == AST_STATE_RINGING) { ast_indicate(ast_bridged_channel(p->sub->next->owner), AST_CONTROL_RINGING); } if (ast_channel_masquerade(p->sub->next->owner, ast_bridged_channel(p->sub->owner))) { ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n", ast_bridged_channel(p->sub->owner)->name, p->sub->next->owner->name); return -1; } /* Orphan the channel */ unalloc_sub(p->sub->next); } else if (ast_bridged_channel(p->sub->next->owner)) { if (p->sub->owner->_state == AST_STATE_RINGING) { ast_indicate(ast_bridged_channel(p->sub->next->owner), AST_CONTROL_RINGING); } ast_queue_control(p->sub->next->owner, AST_CONTROL_UNHOLD); if (ast_channel_masquerade(p->sub->owner, ast_bridged_channel(p->sub->next->owner))) { ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n", ast_bridged_channel(p->sub->next->owner)->name, p->sub->owner->name); return -1; } /*swap_subs(p, SUB_THREEWAY, SUB_REAL);*/ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Swapping %d for %d on %s@%s\n", p->sub->id, p->sub->next->id, p->name, p->parent->name); } p->sub = p->sub->next; unalloc_sub(p->sub->next); /* Tell the caller not to hangup */ return 1; } else { if (option_debug) ast_log(LOG_DEBUG, "Neither %s nor %s are in a bridge, nothing to transfer\n", p->sub->owner->name, p->sub->next->owner->name); p->sub->next->owner->_softhangup |= AST_SOFTHANGUP_DEV; if (p->sub->next->owner) { p->sub->next->alreadygone = 1; mgcp_queue_hangup(p->sub->next); } } return 0; }

static struct mgcp_gateway* build_gateway (  char *  cat, struct ast_variable *  v )  [static]

build_gateway: parse mgcp.conf and create gateway/endpoint structures Definition at line 3569 of file chan_mgcp.c. References mgcp_endpoint::accountcode, accountcode, mgcp_gateway::addr, mgcp_endpoint::adsi, adsi, mgcp_endpoint::amaflags, amaflags, ast_append_ha(), ast_callerid_split(), ast_cdr_amaflags2int(), ast_get_group(), ast_get_ip(), ast_log(), ast_mutex_destroy(), ast_mutex_init(), ast_random(), ast_sched_del(), ast_strlen_zero(), ast_true(), ast_verbose(), mgcp_endpoint::callgroup, mgcp_endpoint::callreturn, callreturn, mgcp_endpoint::callwaiting, callwaiting, mgcp_endpoint::cancallforward, cancallforward, mgcp_endpoint::canreinvite, CANREINVITE, canreinvite, capability, mgcp_endpoint::capability, mgcp_endpoint::cid_name, cid_name, mgcp_endpoint::cid_num, cid_num, mgcp_endpoint::context, context, cur_callergroup, cur_pickupgroup, mgcp_subchannel::cx_queue_lock, mgcp_subchannel::cxmode, mgcp_gateway::defaddr, mgcp_endpoint::delme, mgcp_gateway::delme, mgcp_endpoint::dtmfmode, dtmfmode, mgcp_gateway::dynamic, mgcp_gateway::endpoints, mgcp_gateway::expire, free, gateways, mgcp_gateway::ha, mgcp_endpoint::hascallwaiting, mgcp_endpoint::hookstate, mgcp_subchannel::id, mgcp_endpoint::immediate, immediate, INADDR_NONE, mgcp_endpoint::language, language, ast_variable::lineno, mgcp_subchannel::lock, LOG_WARNING, mgcp_subchannel::magic, mgcp_endpoint::mailbox, mailbox, malloc, MAX_SUBS, MGCP_CX_INACTIVE, MGCP_DTMF_HYBRID, MGCP_DTMF_INBAND, MGCP_DTMF_RFC2833, MGCP_ONHOOK, MGCP_SUBCHANNEL_MAGIC, mgcp_gateway::msgs_lock, mgcp_endpoint::msgstate, mgcp_endpoint::musicclass, musicclass, mgcp_endpoint::name, ast_variable::name, mgcp_gateway::name, mgcp_subchannel::nat, nat, mgcp_subchannel::next, mgcp_endpoint::next, mgcp_gateway::next, mgcp_endpoint::onhooktime, mgcp_subchannel::parent, mgcp_endpoint::parent, mgcp_endpoint::pickupgroup, mgcp_endpoint::rqnt_ident, mgcp_subchannel::rtp, mgcp_endpoint::singlepath, singlepath, mgcp_endpoint::slowsequence, slowsequence, mgcp_endpoint::sub, mgcp_endpoint::threewaycalling, threewaycalling, mgcp_endpoint::transfer, transfer, mgcp_subchannel::txident, mgcp_endpoint::type, TYPE_LINE, TYPE_TRUNK, ast_variable::value, VERBOSE_PREFIX_3, and mgcp_gateway::wcardep. Referenced by reload_config(). { struct mgcp_gateway *gw; struct mgcp_endpoint *e; struct mgcp_subchannel *sub; /*char txident[80];*/ int i=0, y=0; int gw_reload = 0; int ep_reload = 0; canreinvite = CANREINVITE; /* locate existing gateway */ gw = gateways; while (gw) { if (!strcasecmp(cat, gw->name)) { /* gateway already exists */ gw->delme = 0; gw_reload = 1; break; } gw = gw->next; } if (!gw) gw = malloc(sizeof(struct mgcp_gateway)); if (gw) { if (!gw_reload) { memset(gw, 0, sizeof(struct mgcp_gateway)); gw->expire = -1; gw->retransid = -1; /* SC */ ast_mutex_init(&gw->msgs_lock); ast_copy_string(gw->name, cat, sizeof(gw->name)); /* check if the name is numeric ip */ if ((strchr(gw->name, '.')) && inet_addr(gw->name) != INADDR_NONE) gw->isnamedottedip = 1; } while(v) { if (!strcasecmp(v->name, "host")) { if (!strcasecmp(v->value, "dynamic")) { /* They'll register with us */ gw->dynamic = 1; memset(&gw->addr.sin_addr, 0, 4); if (gw->addr.sin_port) { /* If we've already got a port, make it the default rather than absolute */ gw->defaddr.sin_port = gw->addr.sin_port; gw->addr.sin_port = 0; } } else { /* Non-dynamic. Make sure we become that way if we're not */ if (gw->expire > -1) ast_sched_del(sched, gw->expire); gw->expire = -1; gw->dynamic = 0; if (ast_get_ip(&gw->addr, v->value)) { if (!gw_reload) { ast_mutex_destroy(&gw->msgs_lock); free(gw); } return NULL; } } } else if (!strcasecmp(v->name, "defaultip")) { if (ast_get_ip(&gw->defaddr, v->value)) { if (!gw_reload) { ast_mutex_destroy(&gw->msgs_lock); free(gw); } return NULL; } } else if (!strcasecmp(v->name, "permit") || !strcasecmp(v->name, "deny")) { gw->ha = ast_append_ha(v->name, v->value, gw->ha, NULL); } else if (!strcasecmp(v->name, "port")) { gw->addr.sin_port = htons(atoi(v->value)); } else if (!strcasecmp(v->name, "context")) { ast_copy_string(context, v->value, sizeof(context)); } else if (!strcasecmp(v->name, "dtmfmode")) { if (!strcasecmp(v->value, "inband")) dtmfmode = MGCP_DTMF_INBAND; else if (!strcasecmp(v->value, "rfc2833")) dtmfmode = MGCP_DTMF_RFC2833; else if (!strcasecmp(v->value, "hybrid")) dtmfmode = MGCP_DTMF_HYBRID; else if (!strcasecmp(v->value, "none")) dtmfmode = 0; else ast_log(LOG_WARNING, "'%s' is not a valid DTMF mode at line %d\n", v->value, v->lineno); } else if (!strcasecmp(v->name, "nat")) { nat = ast_true(v->value); } else if (!strcasecmp(v->name, "callerid")) { if (!strcasecmp(v->value, "asreceived")) { cid_num[0] = '\0'; cid_name[0] = '\0'; } else { ast_callerid_split(v->value, cid_name, sizeof(cid_name), cid_num, sizeof(cid_num)); } } else if (!strcasecmp(v->name, "language")) { ast_copy_string(language, v->value, sizeof(language)); } else if (!strcasecmp(v->name, "accountcode")) { ast_copy_string(accountcode, v->value, sizeof(accountcode)); } else if (!strcasecmp(v->name, "amaflags")) { y = ast_cdr_amaflags2int(v->value); if (y < 0) { ast_log(LOG_WARNING, "Invalid AMA flags: %s at line %d\n", v->value, v->lineno); } else { amaflags = y; } } else if (!strcasecmp(v->name, "musiconhold")) { ast_copy_string(musicclass, v->value, sizeof(musicclass)); } else if (!strcasecmp(v->name, "callgroup")) { cur_callergroup = ast_get_group(v->value); } else if (!strcasecmp(v->name, "pickupgroup")) { cur_pickupgroup = ast_get_group(v->value); } else if (!strcasecmp(v->name, "immediate")) { immediate = ast_true(v->value); } else if (!strcasecmp(v->name, "cancallforward")) { cancallforward = ast_true(v->value); } else if (!strcasecmp(v->name, "singlepath")) { singlepath = ast_true(v->value); } else if (!strcasecmp(v->name, "canreinvite")) { canreinvite = ast_true(v->value); } else if (!strcasecmp(v->name, "mailbox")) { ast_copy_string(mailbox, v->value, sizeof(mailbox)); } else if (!strcasecmp(v->name, "adsi")) { adsi = ast_true(v->value); } else if (!strcasecmp(v->name, "callreturn")) { callreturn = ast_true(v->value); } else if (!strcasecmp(v->name, "callwaiting")) { callwaiting = ast_true(v->value); } else if (!strcasecmp(v->name, "slowsequence")) { slowsequence = ast_true(v->value); } else if (!strcasecmp(v->name, "transfer")) { transfer = ast_true(v->value); } else if (!strcasecmp(v->name, "threewaycalling")) { threewaycalling = ast_true(v->value); } else if (!strcasecmp(v->name, "wcardep")) { /* locate existing endpoint */ e = gw->endpoints; while (e) { if (!strcasecmp(v->value, e->name)) { /* endpoint already exists */ e->delme = 0; ep_reload = 1; break; } e = e->next; } if (!e) { /* Allocate wildcard endpoint */ e = malloc(sizeof(struct mgcp_endpoint)); ep_reload = 0; } if (e) { if (!ep_reload) { memset(e, 0, sizeof(struct mgcp_endpoint)); ast_mutex_init(&e->lock); ast_mutex_init(&e->rqnt_queue_lock); ast_mutex_init(&e->cmd_queue_lock); ast_copy_string(e->name, v->value, sizeof(e->name)); e->needaudit = 1; } ast_copy_string(gw->wcardep, v->value, sizeof(gw->wcardep)); /* XXX Should we really check for uniqueness?? XXX */ ast_copy_string(e->accountcode, accountcode, sizeof(e->accountcode)); ast_copy_string(e->context, context, sizeof(e->context)); ast_copy_string(e->cid_num, cid_num, sizeof(e->cid_num)); ast_copy_string(e->cid_name, cid_name, sizeof(e->cid_name)); ast_copy_string(e->language, language, sizeof(e->language)); ast_copy_string(e->musicclass, musicclass, sizeof(e->musicclass)); ast_copy_string(e->mailbox, mailbox, sizeof(e->mailbox)); snprintf(e->rqnt_ident, sizeof(e->rqnt_ident), "%08lx", ast_random()); e->msgstate = -1; e->amaflags = amaflags; e->capability = capability; e->parent = gw; e->dtmfmode = dtmfmode; if (!ep_reload && e->sub && e->sub->rtp) e->dtmfmode |= MGCP_DTMF_INBAND; e->adsi = adsi; e->type = TYPE_LINE; e->immediate = immediate; e->callgroup=cur_callergroup; e->pickupgroup=cur_pickupgroup; e->callreturn = callreturn; e->cancallforward = cancallforward; e->singlepath = singlepath; e->canreinvite = canreinvite; e->callwaiting = callwaiting; e->hascallwaiting = callwaiting; e->slowsequence = slowsequence; e->transfer = transfer; e->threewaycalling = threewaycalling; e->onhooktime = time(NULL); /* ASSUME we're onhook */ e->hookstate = MGCP_ONHOOK; if (!ep_reload) { /*snprintf(txident, sizeof(txident), "%08lx", ast_random());*/ for (i = 0; i < MAX_SUBS; i++) { sub = malloc(sizeof(struct mgcp_subchannel)); if (sub) { ast_verbose(VERBOSE_PREFIX_3 "Allocating subchannel '%d' on %s@%s\n", i, e->name, gw->name); memset(sub, 0, sizeof(struct mgcp_subchannel)); ast_mutex_init(&sub->lock); ast_mutex_init(&sub->cx_queue_lock); sub->parent = e; sub->id = i; snprintf(sub->txident, sizeof(sub->txident), "%08lx", ast_random()); /*stnrcpy(sub->txident, txident, sizeof(sub->txident) - 1);*/ sub->cxmode = MGCP_CX_INACTIVE; sub->nat = nat; sub->next = e->sub; e->sub = sub; } else { /* XXX Should find a way to clean up our memory */ ast_log(LOG_WARNING, "Out of memory allocating subchannel\n"); return NULL; } } /* Make out subs a circular linked list so we can always sping through the whole bunch */ sub = e->sub; /* find the end of the list */ while(sub->next){ sub = sub->next; } /* set the last sub->next to the first sub */ sub->next = e->sub; e->next = gw->endpoints; gw->endpoints = e; } } } else if (!strcasecmp(v->name, "trunk") || !strcasecmp(v->name, "line")) { /* locate existing endpoint */ e = gw->endpoints; while (e) { if (!strcasecmp(v->value, e->name)) { /* endpoint already exists */ e->delme = 0; ep_reload = 1; break; } e = e->next; } if (!e) { e = malloc(sizeof(struct mgcp_endpoint)); ep_reload = 0; } if (e) { if (!ep_reload) { memset(e, 0, sizeof(struct mgcp_endpoint)); ast_mutex_init(&e->lock); ast_mutex_init(&e->rqnt_queue_lock); ast_mutex_init(&e->cmd_queue_lock); ast_copy_string(e->name, v->value, sizeof(e->name)); e->needaudit = 1; } /* XXX Should we really check for uniqueness?? XXX */ ast_copy_string(e->accountcode, accountcode, sizeof(e->accountcode)); ast_copy_string(e->context, context, sizeof(e->context)); ast_copy_string(e->cid_num, cid_num, sizeof(e->cid_num)); ast_copy_string(e->cid_name, cid_name, sizeof(e->cid_name)); ast_copy_string(e->language, language, sizeof(e->language)); ast_copy_string(e->musicclass, musicclass, sizeof(e->musicclass)); ast_copy_string(e->mailbox, mailbox, sizeof(e->mailbox)); if (!ast_strlen_zero(mailbox)) { ast_verbose(VERBOSE_PREFIX_3 "Setting mailbox '%s' on %s@%s\n", mailbox, gw->name, e->name); } if (!ep_reload) { /* XXX potential issue due to reload */ e->msgstate = -1; e->parent = gw; } e->amaflags = amaflags; e->capability = capability; e->dtmfmode = dtmfmode; e->adsi = adsi; if (!strcasecmp(v->name, "trunk")) e->type = TYPE_TRUNK; else e->type = TYPE_LINE; e->immediate = immediate; e->callgroup=cur_callergroup; e->pickupgroup=cur_pickupgroup; e->callreturn = callreturn; e->cancallforward = cancallforward; e->canreinvite = canreinvite; e->singlepath = singlepath; e->callwaiting = callwaiting; e->hascallwaiting = callwaiting; e->slowsequence = slowsequence; e->transfer = transfer; e->threewaycalling = threewaycalling; if (!ep_reload) { e->onhooktime = time(NULL); /* ASSUME we're onhook */ e->hookstate = MGCP_ONHOOK; snprintf(e->rqnt_ident, sizeof(e->rqnt_ident), "%08lx", ast_random()); } for (i = 0, sub = NULL; i < MAX_SUBS; i++) { if (!ep_reload) { sub = malloc(sizeof(struct mgcp_subchannel)); } else { if (!sub) sub = e->sub; else sub = sub->next; } if (sub) { if (!ep_reload) { ast_verbose(VERBOSE_PREFIX_3 "Allocating subchannel '%d' on %s@%s\n", i, e->name, gw->name); memset(sub, 0, sizeof(struct mgcp_subchannel)); ast_mutex_init(&sub->lock); ast_mutex_init(&sub->cx_queue_lock); ast_copy_string(sub->magic, MGCP_SUBCHANNEL_MAGIC, sizeof(sub->magic)); sub->parent = e; sub->id = i; snprintf(sub->txident, sizeof(sub->txident), "%08lx", ast_random()); sub->cxmode = MGCP_CX_INACTIVE; sub->next = e->sub; e->sub = sub; } sub->nat = nat; } else { /* XXX Should find a way to clean up our memory */ ast_log(LOG_WARNING, "Out of memory allocating subchannel\n"); return NULL; } } if (!ep_reload) { /* Make out subs a circular linked list so we can always sping through the whole bunch */ sub = e->sub; /* find the end of the list */ while (sub->next) { sub = sub->next; } /* set the last sub->next to the first sub */ sub->next = e->sub; e->next = gw->endpoints; gw->endpoints = e; } } } else ast_log(LOG_WARNING, "Don't know keyword '%s' at line %d\n", v->name, v->lineno); v = v->next; } } if (!ntohl(gw->addr.sin_addr.s_addr) && !gw->dynamic) { ast_log(LOG_WARNING, "Gateway '%s' lacks IP address and isn't dynamic\n", gw->name); if (!gw_reload) { ast_mutex_destroy(&gw->msgs_lock); free(gw); } return NULL; } gw->defaddr.sin_family = AF_INET; gw->addr.sin_family = AF_INET; if (gw->defaddr.sin_addr.s_addr && !ntohs(gw->defaddr.sin_port)) gw->defaddr.sin_port = htons(DEFAULT_MGCP_GW_PORT); if (gw->addr.sin_addr.s_addr && !ntohs(gw->addr.sin_port)) gw->addr.sin_port = htons(DEFAULT_MGCP_GW_PORT); if (gw->addr.sin_addr.s_addr) if (ast_ouraddrfor(&gw->addr.sin_addr, &gw->ourip)) memcpy(&gw->ourip, &__ourip, sizeof(gw->ourip)); return (gw_reload ? NULL : gw); }

static char* control2str (  int  ind  )  [static]

Definition at line 1357 of file chan_mgcp.c. References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_TAKEOFFHOOK, and AST_CONTROL_WINK. Referenced by mgcp_indicate(), and skinny_indicate(). { switch (ind) { case AST_CONTROL_HANGUP: return "Other end has hungup"; case AST_CONTROL_RING: return "Local ring"; case AST_CONTROL_RINGING: return "Remote end is ringing"; case AST_CONTROL_ANSWER: return "Remote end has answered"; case AST_CONTROL_BUSY: return "Remote end is busy"; case AST_CONTROL_TAKEOFFHOOK: return "Make it go off hook"; case AST_CONTROL_OFFHOOK: return "Line is off hook"; case AST_CONTROL_CONGESTION: return "Congestion (circuits busy)"; case AST_CONTROL_FLASH: return "Flash hook"; case AST_CONTROL_WINK: return "Wink"; case AST_CONTROL_OPTION: return "Set a low-level option"; case AST_CONTROL_RADIO_KEY: return "Key Radio"; case AST_CONTROL_RADIO_UNKEY: return "Un-Key Radio"; } return "UNKNOWN"; }

static void destroy_endpoint (  struct mgcp_endpoint *  e  )  [static]

Definition at line 3980 of file chan_mgcp.c. References ast_mutex_lock(), ast_strlen_zero(), mgcp_subchannel::cxident, mgcp_subchannel::lock, MAX_SUBS, mgcp_subchannel::next, s, mgcp_endpoint::sub, and transmit_connection_del(). Referenced by prune_gateways(). { struct mgcp_subchannel *sub = e->sub->next, *s; int i; for (i = 0; i < MAX_SUBS; i++) { ast_mutex_lock(&sub->lock); if (!ast_strlen_zero(sub->cxident)) { transmit_connection_del(sub); } if (sub->rtp) { ast_rtp_destroy(sub->rtp); sub->rtp = NULL; } memset(sub->magic, 0, sizeof(sub->magic)); mgcp_queue_hangup(sub); dump_cmd_queues(NULL, sub); ast_mutex_unlock(&sub->lock); sub = sub->next; } if (e->dsp) { ast_dsp_free(e->dsp); } dump_queue(e->parent, e); dump_cmd_queues(e, NULL); sub = e->sub; for (i = 0; (i < MAX_SUBS) && sub; i++) { s = sub; sub = sub->next; ast_mutex_destroy(&s->lock); ast_mutex_destroy(&s->cx_queue_lock); free(s); } ast_mutex_destroy(&e->lock); ast_mutex_destroy(&e->rqnt_queue_lock); ast_mutex_destroy(&e->cmd_queue_lock); free(e); }

static void destroy_gateway (  struct mgcp_gateway *  g  )  [static]

Definition at line 4022 of file chan_mgcp.c. References ast_free_ha(), dump_queue(), free, and mgcp_gateway::ha. { if (g->ha) ast_free_ha(g->ha); dump_queue(g, NULL); free (g); }

static void* do_monitor (  void *  data  )  [static]

Definition at line 3398 of file chan_mgcp.c. References ast_io_add(), AST_IO_IN, ast_io_wait(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_runq(), ast_sched_wait(), ast_verbose(), mgcp_gateway::endpoints, gateways, has_voicemail(), io, mgcp_do_reload(), MGCP_ONHOOK, mgcp_reloading, mgcpsock, mgcpsock_read(), option_verbose, transmit_notify_request(), TYPE_LINE, and VERBOSE_PREFIX_1. { int res; int reloading; /*struct mgcp_gateway *g;*/ /*struct mgcp_endpoint *e;*/ /*time_t thispass = 0, lastpass = 0;*/ /* Add an I/O event to our UDP socket */ if (mgcpsock > -1) mgcpsock_read_id = ast_io_add(io, mgcpsock, mgcpsock_read, AST_IO_IN, NULL); /* This thread monitors all the frame relay interfaces which are not yet in use (and thus do not have a separate thread) indefinitely */ /* From here on out, we die whenever asked */ for(;;) { /* Check for a reload request */ ast_mutex_lock(&mgcp_reload_lock); reloading = mgcp_reloading; mgcp_reloading = 0; ast_mutex_unlock(&mgcp_reload_lock); if (reloading) { if (option_verbose > 0) ast_verbose(VERBOSE_PREFIX_1 "Reloading MGCP\n"); mgcp_do_reload(); /* Add an I/O event to our UDP socket */ if (mgcpsock > -1) mgcpsock_read_id = ast_io_add(io, mgcpsock, mgcpsock_read, AST_IO_IN, NULL); } /* Check for interfaces needing to be killed */ /* Don't let anybody kill us right away. Nobody should lock the interface list and wait for the monitor list, but the other way around is okay. */ ast_mutex_lock(&monlock); /* Lock the network interface */ ast_mutex_lock(&netlock); #if 0 /* XXX THIS IS COMPLETELY HOSED */ /* The gateway goes into a state of panic */ /* If the vmwi indicator is sent while it is reseting interfaces */ lastpass = thispass; thispass = time(NULL); g = gateways; while(g) { if (thispass != lastpass) { e = g->endpoints; while(e) { if (e->type == TYPE_LINE) { res = has_voicemail(e); if ((e->msgstate != res) && (e->hookstate == MGCP_ONHOOK) && (!e->rtp)){ if (res) { transmit_notify_request(e, "L/vmwi(+)"); } else { transmit_notify_request(e, "L/vmwi(-)"); } e->msgstate = res; e->onhooktime = thispass; } } e = e->next; } } g = g->next; } #endif /* Okay, now that we know what to do, release the network lock */ ast_mutex_unlock(&netlock); /* And from now on, we're okay to be killed, so release the monitor lock as well */ ast_mutex_unlock(&monlock); pthread_testcancel(); /* Wait for sched or io */ res = ast_sched_wait(sched); /* copied from chan_sip.c */ if ((res < 0) || (res > 1000)) res = 1000; res = ast_io_wait(io, res); ast_mutex_lock(&monlock); if (res >= 0) ast_sched_runq(sched); ast_mutex_unlock(&monlock); } /* Never reached */ return NULL; }

static void dump_cmd_queues (  struct mgcp_endpoint *  p, struct mgcp_subchannel *  sub )  [static]

dump_cmd_queues: (SC:) cleanup pending commands Definition at line 2354 of file chan_mgcp.c. References ast_mutex_lock(), ast_mutex_unlock(), mgcp_endpoint::cmd_queue, mgcp_endpoint::cmd_queue_lock, mgcp_subchannel::cx_queue, mgcp_subchannel::cx_queue_lock, free, mgcp_subchannel::next, mgcp_request::next, mgcp_endpoint::rqnt_queue, mgcp_endpoint::rqnt_queue_lock, and mgcp_endpoint::sub. Referenced by handle_request(), handle_response(), and unalloc_sub(). { struct mgcp_request *t, *q; if (p) { ast_mutex_lock(&p->rqnt_queue_lock); for (q = p->rqnt_queue; q; t = q->next, free(q), q=t); p->rqnt_queue = NULL; ast_mutex_unlock(&p->rqnt_queue_lock); ast_mutex_lock(&p->cmd_queue_lock); for (q = p->cmd_queue; q; t = q->next, free(q), q=t); p->cmd_queue = NULL; ast_mutex_unlock(&p->cmd_queue_lock); ast_mutex_lock(&p->sub->cx_queue_lock); for (q = p->sub->cx_queue; q; t = q->next, free(q), q=t); p->sub->cx_queue = NULL; ast_mutex_unlock(&p->sub->cx_queue_lock); ast_mutex_lock(&p->sub->next->cx_queue_lock); for (q = p->sub->next->cx_queue; q; t = q->next, free(q), q=t); p->sub->next->cx_queue = NULL; ast_mutex_unlock(&p->sub->next->cx_queue_lock); } else if (sub) { ast_mutex_lock(&sub->cx_queue_lock); for (q = sub->cx_queue; q; t = q->next, free(q), q=t); sub->cx_queue = NULL; ast_mutex_unlock(&sub->cx_queue_lock); } }

static void dump_queue (  struct mgcp_gateway *  gw, struct mgcp_endpoint *  p )  [static]

Definition at line 527 of file chan_mgcp.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), free, LOG_NOTICE, mgcp_gateway::msgs, mgcp_gateway::msgs_lock, mgcp_gateway::name, and mgcp_message::next. Referenced by destroy_gateway(), and handle_request(). { struct mgcp_message *cur, *q = NULL, *w, *prev; ast_mutex_lock(&gw->msgs_lock); prev = NULL, cur = gw->msgs; while (cur) { if (!p || cur->owner_ep == p) { if (prev) prev->next = cur->next; else gw->msgs = cur->next; ast_log(LOG_NOTICE, "Removing message from %s transaction %u\n", gw->name, cur->seqno); w = cur; cur = cur->next; if (q) { w->next = q; } else { w->next = NULL; } q = w; } else { prev = cur, cur=cur->next; } } ast_mutex_unlock(&gw->msgs_lock); while (q) { cur = q; q = q->next; free(cur); } }

static int find_and_retrans (  struct mgcp_subchannel *  sub, struct mgcp_request *  req )  [static]

Definition at line 3275 of file chan_mgcp.c. References answer, free, mgcp_request::identifier, mgcp_response::next, mgcp_endpoint::parent, mgcp_subchannel::parent, resend_response(), RESPONSE_TIMEOUT, and mgcp_gateway::responses. Referenced by mgcpsock_read(). { int seqno=0; time_t now; struct mgcp_response *prev = NULL, *cur, *next, *answer=NULL; time(&now); if (sscanf(req->identifier, "%d", &seqno) != 1) seqno = 0; cur = sub->parent->parent->responses; while(cur) { next = cur->next; if (now - cur->whensent > RESPONSE_TIMEOUT) { /* Delete this entry */ if (prev) prev->next = next; else sub->parent->parent->responses = next; free(cur); } else { if (seqno == cur->seqno) answer = cur; prev = cur; } cur = next; } if (answer) { resend_response(sub, answer); return 1; } return 0; }

static struct mgcp_request* find_command (  struct mgcp_endpoint *  p, struct mgcp_subchannel *  sub, struct mgcp_request **  queue, ast_mutex_t *  l, int  ident )  [static]

find_command: (SC:) remove command transaction from queue Definition at line 2388 of file chan_mgcp.c. References mgcp_gateway::addr, ast_inet_ntoa(), ast_mutex_lock(), ast_verbose(), mgcp_request::next, and mgcp_endpoint::parent. Referenced by agi_handle_command(), handle_response(), and handle_showagi(). { struct mgcp_request *prev, *req; ast_mutex_lock(l); for (prev = NULL, req = *queue; req; prev = req, req = req->next) { if (req->trid == ident) { /* remove from queue */ if (!prev) *queue = req->next; else prev->next = req->next; /* send next pending command */ if (*queue) { if (mgcpdebug) { ast_verbose("Posting Queued Request:\n%s to %s:%d\n", (*queue)->data, ast_inet_ntoa(p->parent->addr.sin_addr), ntohs(p->parent->addr.sin_port)); } mgcp_postrequest(p, sub, (*queue)->data, (*queue)->len, (*queue)->trid); } break; } } ast_mutex_unlock(l); return req; }

static struct mgcp_subchannel* find_subchannel_and_lock (  char *  name, int  msgid, struct sockaddr_in *  sin )  [static]

Definition at line 1590 of file chan_mgcp.c. References __ourip, mgcp_gateway::addr, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_ouraddrfor(), ast_verbose(), mgcp_gateway::defaddr, mgcp_gateway::dynamic, mgcp_gateway::endpoints, gateways, mgcp_subchannel::id, mgcp_subchannel::lock, LOG_DEBUG, LOG_NOTICE, mgcp_endpoint::name, mgcp_gateway::name, mgcp_endpoint::next, mgcp_subchannel::next, mgcp_gateway::next, option_debug, option_verbose, mgcp_gateway::ourip, mgcp_endpoint::sub, and VERBOSE_PREFIX_3. Referenced by mgcp_request(), and mgcpsock_read(). { struct mgcp_endpoint *p = NULL; struct mgcp_subchannel *sub = NULL; struct mgcp_gateway *g; char tmp[256] = ""; char *at = NULL, *c; int found = 0; if (name) { ast_copy_string(tmp, name, sizeof(tmp)); at = strchr(tmp, '@'); if (!at) { ast_log(LOG_NOTICE, "Endpoint '%s' has no at sign!\n", name); return NULL; } *at++ = '\0'; } ast_mutex_lock(&gatelock); if (at && (at[0] == '[')) { at++; c = strrchr(at, ']'); if (c) *c = '\0'; } g = gateways; while(g) { if ((!name || !strcasecmp(g->name, at)) && (sin || g->addr.sin_addr.s_addr || g->defaddr.sin_addr.s_addr)) { /* Found the gateway. If it's dynamic, save it's address -- now for the endpoint */ if (sin && g->dynamic && name) { if ((g->addr.sin_addr.s_addr != sin->sin_addr.s_addr) || (g->addr.sin_port != sin->sin_port)) { memcpy(&g->addr, sin, sizeof(g->addr)); if (ast_ouraddrfor(&g->addr.sin_addr, &g->ourip)) memcpy(&g->ourip, &__ourip, sizeof(g->ourip)); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Registered MGCP gateway '%s' at %s port %d\n", g->name, ast_inet_ntoa(g->addr.sin_addr), ntohs(g->addr.sin_port)); } } /* not dynamic, check if the name matches */ else if (name) { if (strcasecmp(g->name, at)) { g = g->next; continue; } } /* not dynamic, no name, check if the addr matches */ else if (!name && sin) { if ((g->addr.sin_addr.s_addr != sin->sin_addr.s_addr) || (g->addr.sin_port != sin->sin_port)) { g = g->next; continue; } } else { g = g->next; continue; } /* SC */ p = g->endpoints; while(p) { if (option_debug) ast_log(LOG_DEBUG, "Searching on %s@%s for subchannel\n", p->name, g->name); if (msgid) { #if 0 /* new transport mech */ sub = p->sub; do { if (option_debug) ast_log(LOG_DEBUG, "Searching on %s@%s-%d for subchannel with lastout: %d\n", p->name, g->name, sub->id, msgid); if (sub->lastout == msgid) { if (option_debug) ast_log(LOG_DEBUG, "Found subchannel sub%d to handle request %d sub->lastout: %d\n", sub->id, msgid, sub->lastout); found = 1; break; } sub = sub->next; } while (sub != p->sub); if (found) { break; } #endif /* SC */ sub = p->sub; found = 1; /* SC */ break; } else if (name && !strcasecmp(p->name, tmp)) { if (option_debug) ast_log(LOG_DEBUG, "Coundn't determine subchannel, assuming current master %s@%s-%d\n", p->name, g->name, p->sub->id); sub = p->sub; found = 1; break; } p = p->next; } if (sub && found) { ast_mutex_lock(&sub->lock); break; } } g = g->next; } ast_mutex_unlock(&gatelock); if (!sub) { if (name) { if (g) ast_log(LOG_NOTICE, "Endpoint '%s' not found on gateway '%s'\n", tmp, at); else ast_log(LOG_NOTICE, "Gateway '%s' (and thus its endpoint '%s') does not exist\n", at, tmp); } } return sub; }

static char* get_csv (  char *  c, int *  len, char **  next )  [static]

get_csv: (SC:) get comma separated value Definition at line 1569 of file chan_mgcp.c. References s. Referenced by handle_response(). { char *s; *next = NULL, *len = 0; if (!c) return NULL; while (*c && (*c < 33 || *c == ',')) c++; s = c; while (*c && (*c >= 33 && *c != ',')) c++, (*len)++; *next = c; if (*len == 0) s = NULL, *next = NULL; return s; }

static char* get_header (  struct mgcp_request *  req, char *  name )  [static]

Definition at line 1562 of file chan_mgcp.c. References __get_header(). Referenced by __transmit_response(), append_send_history(), check_auth(), check_user_full(), check_via(), copy_header(), extract_uri(), find_call(), find_sdp(), get_also_info(), get_destination(), get_rdnis(), get_refer_info(), gettag(), handle_request(), handle_request_bye(), handle_request_info(), handle_request_invite(), handle_request_notify(), handle_request_register(), handle_request_subscribe(), handle_response(), handle_response_bye(), handle_response_invite(), handle_response_refer(), handle_response_register(), match_or_create_dialog(), parse_moved_contact(), parse_ok_contact(), parse_register_contact(), process_sip_queue(), receive_message(), register_verify(), reply_digest(), reqprep(), respprep(), send_request(), send_response(), sip_sipredirect(), transmit_refer(), transmit_response_with_auth(), transmit_response_with_sdp(), transmit_response_with_t38_sdp(), and transmit_state_notify(). { int start = 0; return __get_header(req, name, &start); }

static char* get_sdp (  struct mgcp_request *  req, char *  name )  [static]

Definition at line 1514 of file chan_mgcp.c. References get_sdp_by_line(), len, mgcp_request::line, and mgcp_request::lines. Referenced by process_sdp(). { int x; int len = strlen(name); char *r; for (x=0; x<req->lines; x++) { r = get_sdp_by_line(req->line[x], name, len); if (r[0] != '\0') return r; } return ""; }

static char* get_sdp_by_line (  char *  line, char *  name, int  nameLen )  [static]

Definition at line 1504 of file chan_mgcp.c. Referenced by get_sdp(), and get_sdp_iterate(). { if (strncasecmp(line, name, nameLen) == 0 && line[nameLen] == '=') { char* r = line + nameLen + 1; while (*r && (*r < 33)) ++r; return r; } return ""; }

static char* get_sdp_iterate (  int *  iterator, struct mgcp_request *  req, char *  name )  [static]

Definition at line 1532 of file chan_mgcp.c. References get_sdp_by_line(), len, and mgcp_request::line. Referenced by get_sdp(), and process_sdp(). { int len = strlen(name); char *r; while (*iterator < req->lines) { r = get_sdp_by_line(req->line[(*iterator)++], name, len); if (r[0] != '\0') return r; } return ""; }

static void handle_hd_hf (  struct mgcp_subchannel *  sub, char *  ev )  [static]

Definition at line 2927 of file chan_mgcp.c. References ast_bridged_channel(), AST_CONTROL_ANSWER, AST_CONTROL_UNHOLD, ast_hangup(), ast_log(), ast_pthread_create, ast_queue_control(), AST_STATE_DOWN, AST_STATE_RING, mgcp_subchannel::cxmode, has_voicemail(), mgcp_endpoint::hookstate, mgcp_endpoint::immediate, LOG_WARNING, MGCP_CX_SENDRECV, mgcp_new(), MGCP_OFFHOOK, mgcp_queue_control(), mgcp_ss(), mgcp_gateway::name, mgcp_endpoint::name, mgcp_subchannel::outgoing, mgcp_subchannel::owner, mgcp_endpoint::parent, mgcp_subchannel::parent, mgcp_subchannel::rtp, start_rtp(), mgcp_endpoint::sub, transmit_modify_request(), and transmit_notify_request(). Referenced by handle_request(). { struct mgcp_endpoint *p = sub->parent; struct ast_channel *c; pthread_t t; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); /* Off hook / answer */ if (sub->outgoing) { /* Answered */ if (sub->owner) { if (ast_bridged_channel(sub->owner)) ast_queue_control(sub->owner, AST_CONTROL_UNHOLD); sub->cxmode = MGCP_CX_SENDRECV; if (!sub->rtp) { start_rtp(sub); } else { transmit_modify_request(sub); } /*transmit_notify_request(sub, "aw");*/ transmit_notify_request(sub, ""); mgcp_queue_control(sub, AST_CONTROL_ANSWER); } } else { /* Start switch */ /*sub->cxmode = MGCP_CX_SENDRECV;*/ if (!sub->owner) { if (!sub->rtp) { start_rtp(sub); } else { transmit_modify_request(sub); } if (p->immediate) { /* The channel is immediately up. Start right away */ #ifdef DLINK_BUGGY_FIRMWARE transmit_notify_request(sub, "rt"); #else transmit_notify_request(sub, "G/rt"); #endif c = mgcp_new(sub, AST_STATE_RING); if (!c) { ast_log(LOG_WARNING, "Unable to start PBX on channel %s@%s\n", p->name, p->parent->name); transmit_notify_request(sub, "G/cg"); ast_hangup(c); } } else { if (has_voicemail(p)) { transmit_notify_request(sub, "L/sl"); } else { transmit_notify_request(sub, "L/dl"); } c = mgcp_new(sub, AST_STATE_DOWN); if (c) { if (ast_pthread_create(&t, &attr, mgcp_ss, c)) { ast_log(LOG_WARNING, "Unable to create switch thread: %s\n", strerror(errno)); ast_hangup(c); } } else { ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n", p->name, p->parent->name); } } } else { if (p->hookstate == MGCP_OFFHOOK) { ast_log(LOG_WARNING, "Off hook, but already have owner on %s@%s\n", p->name, p->parent->name); } else { ast_log(LOG_WARNING, "On hook, but already have owner on %s@%s\n", p->name, p->parent->name); ast_log(LOG_WARNING, "If we're onhook why are we here trying to handle a hd or hf?\n"); } if (ast_bridged_channel(sub->owner)) ast_queue_control(sub->owner, AST_CONTROL_UNHOLD); sub->cxmode = MGCP_CX_SENDRECV; if (!sub->rtp) { start_rtp(sub); } else { transmit_modify_request(sub); } /*transmit_notify_request(sub, "aw");*/ transmit_notify_request(sub, ""); /*ast_queue_control(sub->owner, AST_CONTROL_ANSWER);*/ } } }

static int handle_request (  struct mgcp_subchannel *  sub, struct mgcp_request *  req, struct sockaddr_in *  sin )  [static]

Definition at line 3012 of file chan_mgcp.c. References ast_channel::_state, mgcp_subchannel::alreadygone, ast_bridged_channel(), AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_FRAME_DTMF, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_control(), AST_STATE_DOWN, ast_verbose(), attempt_transfer(), mgcp_endpoint::callwaiting, mgcp_endpoint::curtone, mgcp_subchannel::cxmode, dump_cmd_queues(), dump_queue(), mgcp_gateway::endpoints, ast_frame::frametype, get_header(), handle_hd_hf(), has_voicemail(), mgcp_endpoint::hascallwaiting, mgcp_endpoint::hidecallerid, mgcp_endpoint::hookstate, mgcp_subchannel::id, mgcp_subchannel::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, MGCP_CX_CONF, MGCP_CX_MUTE, MGCP_CX_RECVONLY, MGCP_CX_SENDRECV, MGCP_OFFHOOK, MGCP_ONHOOK, mgcp_queue_frame(), mgcp_queue_hangup(), mgcp_gateway::name, mgcp_endpoint::name, mgcp_subchannel::next, mgcp_endpoint::next, option_verbose, mgcp_subchannel::outgoing, mgcp_subchannel::owner, mgcp_endpoint::parent, mgcp_subchannel::parent, mgcp_subchannel::rtp, s, ast_frame::src, mgcp_endpoint::sub, ast_frame::subclass, mgcp_endpoint::threewaycalling, mgcp_endpoint::transfer, transmit_audit_endpoint(), transmit_connection_del(), transmit_modify_request(), transmit_notify_request(), transmit_response(), mgcp_request::verb, VERBOSE_PREFIX_3, and mgcp_gateway::wcardep. Referenced by mgcpsock_read(), and process_sip_queue(). { char *ev, *s; struct ast_frame f = { 0, }; struct mgcp_endpoint *p = sub->parent; struct mgcp_gateway *g = NULL; int res; if (mgcpdebug) { ast_verbose("Handling request '%s' on %s@%s\n", req->verb, p->name, p->parent->name); } /* Clear out potential response */ if (!strcasecmp(req->verb, "RSIP")) { /* Test if this RSIP request is just a keepalive */ if(!strcasecmp( get_header(req, "RM"), "X-keepalive")) { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Received keepalive request from %s@%s\n", p->name, p->parent->name); transmit_response(sub, "200", req, "OK"); } else { dump_queue(p->parent, p); dump_cmd_queues(p, NULL); if (option_verbose > 2 && (strcmp(p->name, p->parent->wcardep) != 0)) { ast_verbose(VERBOSE_PREFIX_3 "Resetting interface %s@%s\n", p->name, p->parent->name); } /* For RSIP on wildcard we reset all endpoints */ if (!strcmp(p->name, p->parent->wcardep)) { /* Reset all endpoints */ struct mgcp_endpoint *tmp_ep; g = p->parent; tmp_ep = g->endpoints; while (tmp_ep) { /*if ((strcmp(tmp_ep->name, "*") != 0) && (strcmp(tmp_ep->name, "aaln/" "*") != 0)) {*/ if (strcmp(tmp_ep->name, g->wcardep) != 0) { struct mgcp_subchannel *tmp_sub, *first_sub; if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Resetting interface %s@%s\n", tmp_ep->name, p->parent->name); } first_sub = tmp_ep->sub; tmp_sub = tmp_ep->sub; while (tmp_sub) { mgcp_queue_hangup(tmp_sub); tmp_sub = tmp_sub->next; if (tmp_sub == first_sub) break; } } tmp_ep = tmp_ep->next; } } else if (sub->owner) { mgcp_queue_hangup(sub); } transmit_response(sub, "200", req, "OK"); /* We dont send NTFY or AUEP to wildcard ep */ if (strcmp(p->name, p->parent->wcardep) != 0) { transmit_notify_request(sub, ""); /* Audit endpoint. Idea is to prevent lost lines due to race conditions */ transmit_audit_endpoint(p); } } } else if (!strcasecmp(req->verb, "NTFY")) { /* Acknowledge and be sure we keep looking for the same things */ transmit_response(sub, "200", req, "OK"); /* Notified of an event */ ev = get_header(req, "O"); s = strchr(ev, '/'); if (s) ev = s + 1; if (option_debug) ast_log(LOG_DEBUG, "Endpoint '%s@%s-%d' observed '%s'\n", p->name, p->parent->name, sub->id, ev); /* Keep looking for events unless this was a hangup */ if (strcasecmp(ev, "hu") && strcasecmp(ev, "hd") && strcasecmp(ev, "ping")) { transmit_notify_request(sub, p->curtone); } if (!strcasecmp(ev, "hd")) { p->hookstate = MGCP_OFFHOOK; sub->cxmode = MGCP_CX_SENDRECV; handle_hd_hf(sub, ev); } else if (!strcasecmp(ev, "hf")) { /* We can assume we are offhook if we received a hookflash */ /* First let's just do call wait and ignore threeway */ /* We're currently in charge */ if (p->hookstate != MGCP_OFFHOOK) { /* Cisco c7940 sends hf even if the phone is onhook */ /* Thanks to point on IRC for pointing this out */ return -1; } /* do not let * conference two down channels */ if (sub->owner && sub->owner->_state == AST_STATE_DOWN && !sub->next->owner) return -1; if (p->callwaiting || p->transfer || p->threewaycalling) { if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Swapping %d for %d on %s@%s\n", p->sub->id, p->sub->next->id, p->name, p->parent->name); } p->sub = p->sub->next; /* transfer control to our next subchannel */ if (!sub->next->owner) { /* plave the first call on hold and start up a new call */ sub->cxmode = MGCP_CX_MUTE; if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP Muting %d on %s@%s\n", sub->id, p->name, p->parent->name); } transmit_modify_request(sub); if (sub->owner && ast_bridged_channel(sub->owner)) ast_queue_control(sub->owner, AST_CONTROL_HOLD); sub->next->cxmode = MGCP_CX_RECVONLY; handle_hd_hf(sub->next, ev); } else if (sub->owner && sub->next->owner) { /* We've got two active calls lets decide whether or not to conference or just flip flop */ if ((!sub->outgoing) && (!sub->next->outgoing)) { /* We made both calls lets conferenct */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP Conferencing %d and %d on %s@%s\n", sub->id, sub->next->id, p->name, p->parent->name); } sub->cxmode = MGCP_CX_CONF; sub->next->cxmode = MGCP_CX_CONF; if (ast_bridged_channel(sub->next->owner)) ast_queue_control(sub->next->owner, AST_CONTROL_UNHOLD); transmit_modify_request(sub); transmit_modify_request(sub->next); } else { /* Let's flipflop between calls */ /* XXX Need to check for state up ??? */ /* XXX Need a way to indicate the current call, or maybe the call that's waiting */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "We didn't make one of the calls FLIPFLOP %d and %d on %s@%s\n", sub->id, sub->next->id, p->name, p->parent->name); } sub->cxmode = MGCP_CX_MUTE; if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP Muting %d on %s@%s\n", sub->id, p->name, p->parent->name); } transmit_modify_request(sub); if (ast_bridged_channel(sub->owner)) ast_queue_control(sub->owner, AST_CONTROL_HOLD); if (ast_bridged_channel(sub->next->owner)) ast_queue_control(sub->next->owner, AST_CONTROL_HOLD); handle_hd_hf(sub->next, ev); } } else { /* We've most likely lost one of our calls find an active call and bring it up */ if (sub->owner) { p->sub = sub; } else if (sub->next->owner) { p->sub = sub->next; } else { /* We seem to have lost both our calls */ /* XXX - What do we do now? */ return -1; } if (ast_bridged_channel(p->sub->owner)) ast_queue_control(p->sub->owner, AST_CONTROL_UNHOLD); p->sub->cxmode = MGCP_CX_SENDRECV; transmit_modify_request(p->sub); } } else { ast_log(LOG_WARNING, "Callwaiting, call transfer or threeway calling not enabled on endpoint %s@%s\n", p->name, p->parent->name); } } else if (!strcasecmp(ev, "hu")) { p->hookstate = MGCP_ONHOOK; sub->cxmode = MGCP_CX_RECVONLY; if (option_debug) ast_log(LOG_DEBUG, "MGCP %s@%s Went on hook\n", p->name, p->parent->name); /* Do we need to send MDCX before a DLCX ? if (sub->rtp) { transmit_modify_request(sub); } */ if (p->transfer && (sub->owner && sub->next->owner) && ((!sub->outgoing) || (!sub->next->outgoing))) { /* We're allowed to transfer, we have two avtive calls and */ /* we made at least one of the calls. Let's try and transfer */ ast_mutex_lock(&p->sub->next->lock); res = attempt_transfer(p); if (res < 0) { if (p->sub->next->owner) { sub->next->alreadygone = 1; mgcp_queue_hangup(sub->next); } } else if (res) { ast_log(LOG_WARNING, "Transfer attempt failed\n"); ast_mutex_unlock(&p->sub->next->lock); return -1; } ast_mutex_unlock(&p->sub->next->lock); } else { /* Hangup the current call */ /* If there is another active call, mgcp_hangup will ring the phone with the other call */ if (sub->owner) { sub->alreadygone = 1; mgcp_queue_hangup(sub); } else { /* verbose level check */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s-%d) ast_channel already destroyed, resending DLCX.\n", p->name, p->parent->name, sub->id); } /* Instruct the other side to remove the connection since it apparently * * still thinks the channel is active. * * For Cisco IAD2421 /BAK/ */ transmit_connection_del(sub); } } if ((p->hookstate == MGCP_ONHOOK) && (!sub->rtp) && (!sub->next->rtp)) { p->hidecallerid = 0; if (p->hascallwaiting && !p->callwaiting) { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Enabling call waiting on MGCP/%s@%s-%d\n", p->name, p->parent->name, sub->id); p->callwaiting = -1; } if (has_voicemail(p)) { if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s) set vmwi(+)\n", p->name, p->parent->name); } transmit_notify_request(sub, "L/vmwi(+)"); } else { if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP handle_request(%s@%s) set vmwi(-)\n", p->name, p->parent->name); } transmit_notify_request(sub, "L/vmwi(-)"); } } } else if ((strlen(ev) == 1) && (((ev[0] >= '0') && (ev[0] <= '9')) || ((ev[0] >= 'A') && (ev[0] <= 'D')) || (ev[0] == '*') || (ev[0] == '#'))) { f.frametype = AST_FRAME_DTMF; f.subclass = ev[0]; f.src = "mgcp"; if (sub->owner) { /* XXX MUST queue this frame to all subs in threeway call if threeway call is active */ mgcp_queue_frame(sub, &f); ast_mutex_lock(&sub->next->lock); if (sub->next->owner) { mgcp_queue_frame(sub->next, &f); } ast_mutex_unlock(&sub->next->lock); } if (strstr(p->curtone, "wt") && (ev[0] == 'A')) { memset(p->curtone, 0, sizeof(p->curtone)); } } else if (!strcasecmp(ev, "T")) { /* Digit timeout -- unimportant */ } else if (!strcasecmp(ev, "ping")) { /* ping -- unimportant */ } else { ast_log(LOG_NOTICE, "Received unknown event '%s' from %s@%s\n", ev, p->name, p->parent->name); } } else { ast_log(LOG_WARNING, "Unknown verb '%s' received from %s\n", req->verb, ast_inet_ntoa(sin->sin_addr)); transmit_response(sub, "510", req, "Unknown verb"); } return 0; }

static void handle_response (  struct mgcp_endpoint *  p, struct mgcp_subchannel *  sub, int  result, unsigned int  ident, struct mgcp_request *  resp )  [static]

Definition at line 2419 of file chan_mgcp.c. References ast_log(), ast_strlen_zero(), ast_verbose(), mgcp_request::cmd, mgcp_endpoint::cmd_queue, mgcp_endpoint::cmd_queue_lock, mgcp_subchannel::cx_queue, mgcp_subchannel::cx_queue_lock, mgcp_subchannel::cxident, dump_cmd_queues(), find_command(), free, get_csv(), get_header(), mgcp_endpoint::hookstate, mgcp_subchannel::id, len, mgcp_request::lines, LOG_NOTICE, LOG_WARNING, MGCP_CMD_AUEP, MGCP_CMD_CRCX, MGCP_OFFHOOK, MGCP_ONHOOK, mgcp_queue_hangup(), mgcp_endpoint::name, mgcp_gateway::name, mgcp_subchannel::next, option_verbose, mgcp_subchannel::owner, mgcp_endpoint::parent, process_sdp(), mgcp_endpoint::rqnt_queue, mgcp_endpoint::rqnt_queue_lock, mgcp_subchannel::rtp, mgcp_endpoint::slowsequence, start_rtp(), mgcp_endpoint::sub, mgcp_subchannel::tmpdest, transmit_connection_del(), transmit_connection_del_w_params(), transmit_modify_with_sdp(), transmit_notify_request(), and VERBOSE_PREFIX_3. Referenced by handle_request(), mgcpsock_read(), and retrans_pkt(). { char *c; struct mgcp_request *req; struct mgcp_gateway *gw = p->parent; if (result < 200) { /* provisional response */ return; } if (p->slowsequence) req = find_command(p, sub, &p->cmd_queue, &p->cmd_queue_lock, ident); else if (sub) req = find_command(p, sub, &sub->cx_queue, &sub->cx_queue_lock, ident); else if (!(req = find_command(p, sub, &p->rqnt_queue, &p->rqnt_queue_lock, ident))) req = find_command(p, sub, &p->cmd_queue, &p->cmd_queue_lock, ident); if (!req) { if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "No command found on [%s] for transaction %d. Ignoring...\n", gw->name, ident); } return; } if (p && (result >= 400) && (result <= 599)) { switch (result) { case 401: p->hookstate = MGCP_OFFHOOK; break; case 402: p->hookstate = MGCP_ONHOOK; break; case 406: ast_log(LOG_NOTICE, "Transaction %d timed out\n", ident); break; case 407: ast_log(LOG_NOTICE, "Transaction %d aborted\n", ident); break; } if (sub) { if (sub->owner) { ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", result, p->name, p->parent->name, sub ? sub->id:-1); mgcp_queue_hangup(sub); } } else { if (p->sub->next->owner) { ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", result, p->name, p->parent->name, sub ? sub->id:-1); mgcp_queue_hangup(p->sub); } if (p->sub->owner) { ast_log(LOG_NOTICE, "Terminating on result %d from %s@%s-%d\n", result, p->name, p->parent->name, sub ? sub->id:-1); mgcp_queue_hangup(p->sub); } dump_cmd_queues(p, NULL); } } if (resp) { if (req->cmd == MGCP_CMD_CRCX) { if ((c = get_header(resp, "I"))) { if (!ast_strlen_zero(c) && sub) { /* if we are hanging up do not process this conn. */ if (sub->owner) { if (!ast_strlen_zero(sub->cxident)) { if (strcasecmp(c, sub->cxident)) { ast_log(LOG_WARNING, "Subchannel already has a cxident. sub->cxident: %s requested %s\n", sub->cxident, c); } } ast_copy_string(sub->cxident, c, sizeof(sub->cxident)); if (sub->tmpdest.sin_addr.s_addr) { transmit_modify_with_sdp(sub, NULL, 0); } } else { /* XXX delete this one callid and conn id may already be lost. so the following del conn may have a side effect of cleaning up the next subchannel */ transmit_connection_del(sub); } } } } if (req->cmd == MGCP_CMD_AUEP) { /* check stale connection ids */ if ((c = get_header(resp, "I"))) { char *v, *n; int len; while ((v = get_csv(c, &len, &n))) { if (len) { if (strncasecmp(v, p->sub->cxident, len) && strncasecmp(v, p->sub->next->cxident, len)) { /* connection id not found. delete it */ char cxident[80] = ""; if (len > (sizeof(cxident) - 1)) len = sizeof(cxident) - 1; ast_copy_string(cxident, v, len); if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Non existing connection id %s on %s@%s \n", cxident, p->name, gw->name); } transmit_connection_del_w_params(p, NULL, cxident); } } c = n; } } /* Try to determine the hookstate returned from an audit endpoint command */ if ((c = get_header(resp, "ES"))) { if (!ast_strlen_zero(c)) { if (strstr(c, "hu")) { if (p->hookstate != MGCP_ONHOOK) { /* XXX cleanup if we think we are offhook XXX */ if ((p->sub->owner || p->sub->next->owner ) && p->hookstate == MGCP_OFFHOOK) mgcp_queue_hangup(sub); p->hookstate = MGCP_ONHOOK; /* update the requested events according to the new hookstate */ transmit_notify_request(p->sub, ""); /* verbose level check */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Setting hookstate of %s@%s to ONHOOK\n", p->name, gw->name); } } } else if (strstr(c, "hd")) { if (p->hookstate != MGCP_OFFHOOK) { p->hookstate = MGCP_OFFHOOK; /* update the requested events according to the new hookstate */ transmit_notify_request(p->sub, ""); /* verbose level check */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "Setting hookstate of %s@%s to OFFHOOK\n", p->name, gw->name); } } } } } } if (resp && resp->lines) { /* do not process sdp if we are hanging up. this may be a late response */ if (sub && sub->owner) { if (!sub->rtp) start_rtp(sub); if (sub->rtp) process_sdp(sub, resp); } } } free(req); }

static int has_voicemail (  struct mgcp_endpoint *  p  )  [static]

Definition at line 453 of file chan_mgcp.c. References ast_app_has_voicemail(), and mgcp_endpoint::mailbox. Referenced by do_monitor(), handle_hd_hf(), handle_init_event(), handle_request(), mgcp_hangup(), mgcp_request(), and zt_handle_event(). { return ast_app_has_voicemail(p->mailbox, NULL); }

static int init_req (  struct mgcp_endpoint *  p, struct mgcp_request *  req, char *  verb )  [static]

Definition at line 1956 of file chan_mgcp.c. References ast_log(), mgcp_request::data, mgcp_request::header, mgcp_request::headers, mgcp_gateway::isnamedottedip, mgcp_request::len, LOG_WARNING, MGCP_MAX_HEADERS, mgcp_gateway::name, mgcp_endpoint::name, oseq, and mgcp_endpoint::parent. Referenced by reqprep(), and transmit_register(). { /* Initialize a response */ if (req->headers || req->len) { ast_log(LOG_WARNING, "Request already initialized?!?\n"); return -1; } req->header[req->headers] = req->data + req->len; /* check if we need brackets around the gw name */ if (p->parent->isnamedottedip) snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %d %s@[%s] MGCP 1.0\r\n", verb, oseq, p->name, p->parent->name); else snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %d %s@%s MGCP 1.0\r\n", verb, oseq, p->name, p->parent->name); req->len += strlen(req->header[req->headers]); if (req->headers < MGCP_MAX_HEADERS) req->headers++; else ast_log(LOG_WARNING, "Out of header space\n"); return 0; }

static int init_resp (  struct mgcp_request *  req, char *  resp, struct mgcp_request *  orig, char *  resprest )  [static]

Definition at line 1939 of file chan_mgcp.c. References ast_log(), mgcp_request::data, mgcp_request::header, mgcp_request::headers, mgcp_request::identifier, mgcp_request::len, LOG_WARNING, and MGCP_MAX_HEADERS. Referenced by respprep(). { /* Initialize a response */ if (req->headers || req->len) { ast_log(LOG_WARNING, "Request already initialized?!?\n"); return -1; } req->header[req->headers] = req->data + req->len; snprintf(req->header[req->headers], sizeof(req->data) - req->len, "%s %s %s\r\n", resp, orig->identifier, resprest); req->len += strlen(req->header[req->headers]); if (req->headers < MGCP_MAX_HEADERS) req->headers++; else ast_log(LOG_WARNING, "Out of header space\n"); return 0; }

static int load_module (  void   )  [static]

load_module: PBX load module - initialization --- Definition at line 4257 of file chan_mgcp.c. References ast_channel_register(), ast_cli_register_multiple(), ast_log(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_rtp_proto_register(), cli_mgcp, io, io_context_create(), io_context_destroy(), LOG_ERROR, LOG_WARNING, mgcp_rtp, mgcp_tech, reload_config(), restart_monitor(), sched_context_create(), and sched_context_destroy(). { if (!(sched = sched_context_create())) { ast_log(LOG_WARNING, "Unable to create schedule context\n"); return AST_MODULE_LOAD_FAILURE; } if (!(io = io_context_create())) { ast_log(LOG_WARNING, "Unable to create I/O context\n"); sched_context_destroy(sched); return AST_MODULE_LOAD_FAILURE; } if (reload_config()) return AST_MODULE_LOAD_DECLINE; /* Make sure we can register our mgcp channel type */ if (ast_channel_register(&mgcp_tech)) { ast_log(LOG_ERROR, "Unable to register channel class 'MGCP'\n"); io_context_destroy(io); sched_context_destroy(sched); return AST_MODULE_LOAD_FAILURE; } ast_rtp_proto_register(&mgcp_rtp); ast_cli_register_multiple(cli_mgcp, sizeof(cli_mgcp) / sizeof(struct ast_cli_entry)); /* And start the monitor for the first time */ restart_monitor(); return AST_MODULE_LOAD_SUCCESS; }

static int mgcp_answer (  struct ast_channel *  ast  )  [static]

Definition at line 1162 of file chan_mgcp.c. References ast_channel::_state, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_setstate(), AST_STATE_UP, ast_verbose(), mgcp_subchannel::cxmode, mgcp_subchannel::id, mgcp_subchannel::lock, LOG_DEBUG, MGCP_CX_SENDRECV, mgcp_gateway::name, mgcp_endpoint::name, option_debug, option_verbose, mgcp_endpoint::parent, mgcp_subchannel::parent, mgcp_subchannel::rtp, start_rtp(), mgcp_endpoint::sub, ast_channel::tech_pvt, transmit_modify_request(), transmit_notify_request(), and VERBOSE_PREFIX_3. { int res = 0; struct mgcp_subchannel *sub = ast->tech_pvt; struct mgcp_endpoint *p = sub->parent; ast_mutex_lock(&sub->lock); sub->cxmode = MGCP_CX_SENDRECV; if (!sub->rtp) { start_rtp(sub); } else { transmit_modify_request(sub); } /* verbose level check */ if (option_verbose > 2) { ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_answer(%s) on %s@%s-%d\n", ast->name, p->name, p->parent->name, sub->id); } if (ast->_state != AST_STATE_UP) { ast_setstate(ast, AST_STATE_UP); if (option_debug) ast_log(LOG_DEBUG, "mgcp_answer(%s)\n", ast->name); transmit_notify_request(sub, ""); transmit_modify_request(sub); } ast_mutex_unlock(&sub->lock); return res; }

static int mgcp_audit_endpoint (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1069 of file chan_mgcp.c. References ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), mgcp_gateway::endpoints, gateways, mgcpdebug, mgcp_endpoint::name, mgcp_gateway::name, mgcp_gateway::next, mgcp_endpoint::next, RESULT_SHOWUSAGE, RESULT_SUCCESS, and transmit_audit_endpoint(). { struct mgcp_gateway *g; struct mgcp_endpoint *e; int found = 0; char *ename,*gname, *c; if (!mgcpdebug) { return RESULT_SHOWUSAGE; } if (argc != 4) return RESULT_SHOWUSAGE; /* split the name into parts by null */ ename = argv[3]; gname = ename; while (*gname) { if (*gname == '@') { *gname = 0; gname++; break; } gname++; } if (gname[0] == '[') gname++; if ((c = strrchr(gname, ']'))) *c = '\0'; ast_mutex_lock(&gatelock); g = gateways; while(g) { if (!strcasecmp(g->name, gname)) { e = g->endpoints; while(e) { if (!strcasecmp(e->name, ename)) { found = 1; transmit_audit_endpoint(e); break; } e = e->next; } if (found) { break; } } g = g->next; } if (!found) { ast_cli(fd, " << Could not find endpoint >> "); } ast_mutex_unlock(&gatelock); return RESULT_SUCCESS; }

static int mgcp_call (  struct ast_channel *  ast, char *  dest, int  timeout )  [static]

Definition at line 822 of file chan_mgcp.c. References ast_channel::_state, AST_CONTROL_RINGING, AST_LIST_TRAVERSE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_queue_control(), ast_setstate(), AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RINGING, ast_strlen_zero(), ast_var_name(), ast_var_value(), ast_verbose(), mgcp_subchannel::callid, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, mgcp_subchannel::cxident, mgcp_subchannel::cxmode, mgcp_endpoint::hookstate, mgcp_subchannel::lock, LOG_NOTICE, LOG_WARNING, MGCP_CX_RECVONLY, MGCP_CX_SENDRECV, MGCP_OFFHOOK, MGCP_ONHOOK, mgcpdebug, mgcp_subchannel::next, mgcp_subchannel::outgoing, mgcp_subchannel::owner, mgcp_subchannel::parent, mgcp_subchannel::rtp, start_rtp(), ast_channel::tech_pvt, transmit_modify_request(), transmit_notify_request_with_callerid(), mgcp_endpoint::type, TYPE_LINE, ast_channel::varshead, and VERBOSE_PREFIX_3. { int res; struct mgcp_endpoint *p; struct mgcp_subchannel *sub; char tone[50] = ""; const char *distinctive_ring = NULL; struct varshead *headp; struct ast_var_t *current; if (mgcpdebug) { ast_verbose(VERBOSE_PREFIX_3 "MGCP mgcp_call(%s)\n", ast->name); } sub = ast->tech_pvt; p = sub->parent; headp = &ast->varshead; AST_LIST_TRAVERSE(headp,current,entries) { /* Check whether there is an ALERT_INFO variable */ if (strcasecmp(ast_var_name(current),"ALERT_INFO") == 0) { distinctive_ring = ast_var_value(current); } } ast_mutex_lock(&sub->lock); switch (p->hookstate) { case MGCP_OFFHOOK: if (!ast_strlen_zero(distinctive_ring)) { snprintf(tone, sizeof(tone), "L/wt%s", distinctive_ring); if (mgcpdebug) { ast_verbose(VERBOSE_PREFIX_3 "MGCP distinctive callwait %s\n", tone); } } else { snprintf(tone, sizeof(tone), "L/wt"); if (mgcpdebug) { ast_verbose(VERBOSE_PREFIX_3 "MGCP normal callwait %s\n", tone); } } break; case MGCP_ONHOOK: default: if (!ast_strlen_zero(distinctive_ring)) { snprintf(tone, sizeof(tone), "L/r%s", distinctive_ring); if (mgcpdebug) { ast_verbose(VERBOSE_PREFIX_3 "MGCP distinctive ring %s\n", tone); } } else { snprintf(tone, sizeof(tone), "L/rg"); if (mgcpdebug) { ast_verbose(VERBOSE_PREFIX_3 "MGCP default ring\n"); } } break; } if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) { ast_log(LOG_WARNING, "mgcp_call called on %s, neither down nor reserved\n", ast->name); ast_mutex_unlock(&sub->lock); return -1; } res = 0; sub->outgoing = 1; sub->cxmode = MGCP_CX_RECVONLY; if (p->type == TYPE_LINE) { if (!sub->rtp) { start_rtp(sub); } else { transmit_modify_request(sub); } if (sub->next->owner && !ast_strlen_zero(sub->next->cxident) && !ast_strlen_zero(sub->next->callid)) { /* try to prevent a callwait from disturbing the other connection */ sub->next->cxmode = MGCP_CX_RECVONLY; transmit_modify_request(sub->next); } transmit_notify_request_with_callerid(sub, tone, ast->cid.cid_num, ast->cid.cid_name); ast_setstate(ast, AST_STATE_RINGING); if (sub->next->owner && !ast_strlen_zero(sub->next->cxident) && !ast_strlen_zero(sub->next->callid)) { /* Put the connection back in sendrecv */ sub->next->cxmode = MGCP_CX_SENDRECV; transmit_modify_request(sub->next); } } else { ast_log(LOG_NOTICE, "Don't know how to dial on trunks yet\n"); res = -1; } ast_mutex_unlock(&sub->lock); ast_queue_control(ast, AST_CONTROL_RINGING); return res; }

static int mgcp_devicestate (  void *  data  )  [static]

mgcp_devicestate: channel callback for device status monitoring Parameters: data  tech/resource name of MGCP device to query Callback for device state management in channel subsystem to obtain device status (up/down) of a specific MGCP endpoint Returns: device status result (from devicestate.h) AST_DEVICE_INVALID (not available) or AST_DEVICE_UNKNOWN (available but unknown state) Definition at line 1309 of file chan_mgcp.c. References AST_DEVICE_INVALID, AST_DEVICE_UNKNOWN, ast_mutex_lock(), ast_mutex_unlock(), ast_strdupa, mgcp_gateway::endpoints, error(), gateways, mgcp_endpoint::name, mgcp_gateway::name, mgcp_endpoint::next, and mgcp_gateway::next. { struct mgcp_gateway *g; struct mgcp_endpoint *e = NULL; char *tmp, *endpt, *gw; int ret = AST_DEVICE_INVALID; endpt = ast_strdupa(data); if ((tmp = strchr(endpt, '@'))) { *tmp++ = '\0'; gw = tmp; } else goto error; ast_mutex_lock(&gatelock); g = gateways; while (g) { if (strcasecmp(g->name, gw) == 0) { e = g->endpoints; break; } g = g->next; } if (!e) goto error; while (e) { if (strcasecmp(e->name, endpt) == 0) break; e = e->next; } if (!e) goto error; /* * As long as the gateway/endpoint is valid, we'll * assume that the device is available and its state * can be tracked. */ ret = AST_DEVICE_UNKNOWN; error: ast_mutex_unlock(&gatelock); return ret; }

static int mgcp_do_debug (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1122 of file chan_mgcp.c. References ast_cli(), mgcpdebug, RESULT_SHOWUSAGE, and RESULT_SUCCESS. { if (argc != 3) return RESULT_SHOWUSAGE; mgcpdebug = 1; ast_cli(fd, "MGCP Debugging Enabled\n"); return RESULT_SUCCESS; }

static int mgcp_do_reload (  void   )  [static]

mgcp_do_reload: Reload module Definition at line 4291 of file chan_mgcp.c. References reload_config(). Referenced by do_monitor(). { reload_config(); return 0; }

static int mgcp_fixup (  struct ast_channel *  oldchan, struct ast_channel *  newchan )  [static]

Definition at line 1263 of file chan_mgcp.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), mgcp_subchannel::lock, LOG_NOTICE, LOG_WARNING, mgcp_subchannel::owner, and ast_channel::tech_pvt. { struct mgcp_subchannel *sub = newchan->tech_pvt; ast_mutex_lock(&sub->lock); ast_log(LOG_NOTICE, "mgcp_fixup(%s, %s)\n", oldchan->name, newchan->name); if (sub->owner != oldchan) { ast_mutex_unlock(&sub->lock); ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, sub->owner); return -1; } sub->owner = newchan; ast_mutex_unlock(&sub->lock); return 0; }

static enum ast_rtp_get_result mgcp_get_rtp_peer (  struct ast_channel *  chan, struct ast_rtp **  rtp )  [static]

Definition at line 3947 of file chan_mgcp.c. References AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, mgcp_endpoint::canreinvite, mgcp_subchannel::parent, mgcp_subchannel::rtp, and ast_channel::tech_pvt. { struct mgcp_subchannel *sub = NULL; if (!(sub = chan->tech_pvt) || !(sub->rtp)) return AST_RTP_GET_FAILED; *rtp = sub->rtp; if (sub->parent->canreinvite) return AST_RTP_TRY_NATIVE; else return AST_RTP_TRY_PARTIAL; }

static int mgcp_hangup (  struct ast_channel *  ast  )  [static]

Definition at line 915 of file chan_mgcp.c. References mgcp_subchannel::alreadygone, ast_bridged_channel(), ast_dsp_free(), ast_log(), ast_module_unref(), ast_mutex_lock(), ast_mutex_unlock(), ast_rtp_destroy(), ast_strlen_zero(), ast_verbose(), mgcp_subchannel::callid, mgcp_endpoint::callwaiting, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, mgcp_subchannel::cxident, mgcp_subchannel::cxmode, mgcp_endpoint::dsp, mgcp_endpoint::dtmfmode, has_voicemail(), mgcp_endpoint::hascallwaiting, mgcp_endpoint::hidecallerid, mgcp_endpoint::hookstate, mgcp_subchannel::lock, LOG_DEBUG, mgcp_subchannel::magic, MGCP_CX_INACTIVE, MGCP_CX_RECVONLY, MGCP_DTMF_HYBRID, MGCP_DTMF_INBAND, MGCP_OFFHOOK, MGCP_ONHOOK, MGCP_SUBCHANNEL_MAGIC, mgcpdebug, mgcp_gateway::name, mgcp_endpoint::name, mgcp_subchannel::next, option_debug, option_verbose, mgcp_subchannel::outgoing, mgcp_subchannel::owner, mgcp_endpoint::parent, mgcp_subchannel::parent, mgcp_subchannel::rtp, mgcp_endpoint::sub, ast_channel::tech_pvt, mgcp_subchannel::tmpdest, transmit_connection_del(), transmit_modify_request(), transmit_notify_request(), transmit_notify_request_with_callerid(), VERBOSE_PREFIX_2, and VERBOSE_PREFIX_3. { struct mgcp_subchannel *sub = ast->tech_pvt; struct mgcp_endpoint *p = sub->