Home page | Mailing list | Docs

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

Asterisk developer's documentation :: Codename Pineapple

---

res_features.c File Reference

---

Detailed Description

Routines implementing call features as call pickup, parking and transfer.

Author:

Mark Spencer <markster@digium.com>

Definition in file res_features.c.

#include "asterisk.h"
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/causes.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/app.h"
#include "asterisk/say.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/utils.h"
#include "asterisk/adsi.h"
#include "asterisk/devicestate.h"
#include "asterisk/monitor.h"

Include dependency graph for res_features.c:

Go to the source code of this file.

Data Structures
struct	ast_bridge_thread_obj
struct	parkeduser
Defines
#define	AST_MAX_WATCHERS   256
#define	DEFAULT_FEATURE_DIGIT_TIMEOUT   500
#define	DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER   15000
#define	DEFAULT_PARK_TIME   45000
#define	DEFAULT_TRANSFER_DIGIT_TIMEOUT   3000
#define	FEATURE_RETURN_HANGUP   -1
#define	FEATURE_RETURN_NO_HANGUP_PEER   AST_PBX_NO_HANGUP_PEER
#define	FEATURE_RETURN_PASSDIGITS   21
#define	FEATURE_RETURN_PBX_KEEPALIVE   AST_PBX_KEEPALIVE
#define	FEATURE_RETURN_STOREDIGITS   22
#define	FEATURE_RETURN_SUCCESS   23
#define	FEATURE_RETURN_SUCCESSBREAK   0
#define	FEATURE_SENSE_CHAN   (1 << 0)
#define	FEATURE_SENSE_PEER   (1 << 1)
#define	FEATURES_COUNT   (sizeof(builtin_features) / sizeof(builtin_features[0]))
Enumerations
enum	{   AST_FEATURE_FLAG_NEEDSDTMF = (1 << 0), AST_FEATURE_FLAG_ONPEER = (1 << 1), AST_FEATURE_FLAG_ONSELF = (1 << 2), AST_FEATURE_FLAG_BYCALLEE = (1 << 3),   AST_FEATURE_FLAG_BYCALLER = (1 << 4), AST_FEATURE_FLAG_BYBOTH = (3 << 3) }
Functions
static int	adsi_announce_park (struct ast_channel *chan, char *parkingexten)
int	ast_bridge_call (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config)
	Bridge a call, optionally allowing redirection.
static void *	ast_bridge_call_thread (void *data)
static void	ast_bridge_call_thread_launch (void *data)
static int	ast_feature_interpret (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
static struct ast_channel *	ast_feature_request_and_dial (struct ast_channel *caller, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name)
static	AST_LIST_HEAD_STATIC (feature_list, ast_call_feature)
int	ast_masq_park_call (struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
	Park a call via a masqueraded channel.
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS,"Call Features Resource",.load=load_module,.unload=unload_module,.reload=reload,)
	AST_MUTEX_DEFINE_STATIC (parking_lock)
int	ast_park_call (struct ast_channel *chan, struct ast_channel *peer, int timeout, int *extout)
	Park a call and read back parked location.
char *	ast_parking_ext (void)
	Determine system parking extension Returns the call parking extension for drivers that provide special call parking help.
int	ast_pickup_call (struct ast_channel *chan)
	Pickup a call.
char *	ast_pickup_ext (void)
	Determine system call pickup extension.
void	ast_register_feature (struct ast_call_feature *feature)
	register new feature into feature_set
void	ast_unregister_feature (struct ast_call_feature *feature)
	unregister feature from feature_set
static void	ast_unregister_features (void)
	Remove all features in the list.
static int	builtin_atxfer (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
static int	builtin_automonitor (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
static int	builtin_blindtransfer (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
static int	builtin_disconnect (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
static int	builtin_parkcall (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
	support routing for one touch call parking
static int	check_compat (struct ast_channel *c, struct ast_channel *newchan)
static void	check_goto_on_transfer (struct ast_channel *chan)
static void *	do_parking_thread (void *ignore)
	Take care of parked calls and unpark them if needed.
static int	feature_exec_app (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
	exec an app by feature
static struct ast_call_feature *	find_feature (char *name)
	find a feature by name
static int	finishup (struct ast_channel *chan)
static int	handle_parkedcalls (int fd, int argc, char *argv[])
static int	handle_showfeatures (int fd, int argc, char *argv[])
static int	load_config (void)
static int	load_module (void)
static int	manager_park (struct mansession *s, const struct message *m)
static int	manager_parking_status (struct mansession *s, const struct message *m)
	Dump lot status.
static int	metermaidstate (const char *data)
	metermaids callback from devicestate.c
static void	notify_metermaids (char *exten, char *context)
	Notify metermaids that we've changed an extension.
static void	park_add_hints (char *context, int start, int stop)
	Add parking hints for all defined parking lots.
static int	park_call_exec (struct ast_channel *chan, void *data)
	Park a call.
static int	park_exec (struct ast_channel *chan, void *data)
	Pickup parked call.
static void	post_manager_event (const char *s, char *parkingexten, struct ast_channel *chan)
static const char *	real_ctx (struct ast_channel *transferer, struct ast_channel *transferee)
	Find the context for the transfer.
static int	reload (void)
static int	remap_feature (const char *name, const char *value)
static void	set_c_e_p (struct ast_channel *chan, const char *context, const char *ext, int pri)
	store context, priority and extension
static void	set_config_flags (struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config)
static void	set_peers (struct ast_channel **caller, struct ast_channel **callee, struct ast_channel *peer, struct ast_channel *chan, int sense)
	set caller and callee according to the direction
static int	unload_module (void)
static void	unmap_features (void)
Variables
static int	adsipark
static int	atxfernoanswertimeout
ast_call_feature	builtin_features []
static struct ast_cli_entry	cli_features []
static int	comebacktoorigin = 1
static char	courtesytone [256]
static char *	descrip
static char *	descrip2
static int	featuredigittimeout
static char	mandescr_park []
static struct ast_app *	monitor_app = NULL
static int	monitor_ok = 1
static int	parkaddhints = 0
static char *	parkcall = "Park"
static char *	parkedcall = "ParkedCall"
static int	parkedcalltransfers = 0
static int	parkedplay = 0
static int	parkfindnext
static char	parking_con [AST_MAX_EXTENSION]
static char	parking_con_dial [AST_MAX_EXTENSION]
static char	parking_ext [AST_MAX_EXTENSION]
static int	parking_offset
static int	parking_start
static int	parking_stop
static pthread_t	parking_thread
static struct parkeduser *	parkinglot
static int	parkingtime = DEFAULT_PARK_TIME
static char	parkmohclass [MAX_MUSICCLASS]
static char	pickup_ext [AST_MAX_EXTENSION]
static char *	registrar = "res_features"
static char	showfeatures_help []
static char	showparked_help []
static char *	synopsis = "Answer a parked call"
static char *	synopsis2 = "Park yourself"
static int	transferdigittimeout
static char	xferfailsound [256]
static char	xfersound [256]

---

Define Documentation

#define AST_MAX_WATCHERS   256

Definition at line 67 of file res_features.c.

#define DEFAULT_FEATURE_DIGIT_TIMEOUT   500

Definition at line 64 of file res_features.c. Referenced by load_config().

#define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER   15000

Definition at line 65 of file res_features.c. Referenced by load_config().

#define DEFAULT_PARK_TIME   45000

Definition at line 62 of file res_features.c.

#define DEFAULT_TRANSFER_DIGIT_TIMEOUT   3000

Definition at line 63 of file res_features.c. Referenced by load_config().

#define FEATURE_RETURN_HANGUP   -1

Definition at line 468 of file res_features.c. Referenced by builtin_disconnect().

#define FEATURE_RETURN_NO_HANGUP_PEER   AST_PBX_NO_HANGUP_PEER

Definition at line 471 of file res_features.c. Referenced by feature_exec_app().

#define FEATURE_RETURN_PASSDIGITS   21

Definition at line 472 of file res_features.c. Referenced by ast_bridge_call(), ast_feature_interpret(), and feature_exec_app().

#define FEATURE_RETURN_PBX_KEEPALIVE   AST_PBX_KEEPALIVE

Definition at line 470 of file res_features.c. Referenced by feature_exec_app().

#define FEATURE_RETURN_STOREDIGITS   22

Definition at line 473 of file res_features.c.

#define FEATURE_RETURN_SUCCESS   23

Definition at line 474 of file res_features.c. Referenced by ast_bridge_call(), builtin_atxfer(), builtin_automonitor(), builtin_blindtransfer(), and feature_exec_app().

#define FEATURE_RETURN_SUCCESSBREAK   0

Definition at line 469 of file res_features.c. Referenced by feature_exec_app().

#define FEATURE_SENSE_CHAN   (1 << 0)

Definition at line 476 of file res_features.c. Referenced by ast_bridge_call(), ast_feature_interpret(), builtin_parkcall(), and feature_exec_app().

#define FEATURE_SENSE_PEER   (1 << 1)

Definition at line 477 of file res_features.c. Referenced by ast_bridge_call(), and set_peers().

#define FEATURES_COUNT   (sizeof(builtin_features) / sizeof(builtin_features[0]))

Definition at line 868 of file res_features.c. Referenced by ast_feature_interpret(), ast_feature_request_and_dial(), remap_feature(), set_config_flags(), and unmap_features().

---

Enumeration Type Documentation

anonymous enum

Enumerator: AST_FEATURE_FLAG_NEEDSDTMF  AST_FEATURE_FLAG_ONPEER  AST_FEATURE_FLAG_ONSELF  AST_FEATURE_FLAG_BYCALLEE  AST_FEATURE_FLAG_BYCALLER  AST_FEATURE_FLAG_BYBOTH  Definition at line 69 of file res_features.c. { AST_FEATURE_FLAG_NEEDSDTMF = (1 << 0), AST_FEATURE_FLAG_ONPEER = (1 << 1), AST_FEATURE_FLAG_ONSELF = (1 << 2), AST_FEATURE_FLAG_BYCALLEE = (1 << 3), AST_FEATURE_FLAG_BYCALLER = (1 << 4), AST_FEATURE_FLAG_BYBOTH = (3 << 3), };

---

Function Documentation

static int adsi_announce_park (  struct ast_channel *  chan, char *  parkingexten )  [static]

Definition at line 260 of file res_features.c. References ADSI_JUST_CENT, ast_adsi_load_session(), and ast_adsi_print(). { int res; int justify[5] = {ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT}; char tmp[256]; char *message[5] = {NULL, NULL, NULL, NULL, NULL}; snprintf(tmp, sizeof(tmp), "Parked on %s", parkingexten); message[0] = tmp; res = ast_adsi_load_session(chan, NULL, 0, 1); if (res == -1) return res; return ast_adsi_print(chan, message, justify, 1); }

int ast_bridge_call (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config )

Bridge a call, optionally allowing redirection. append the event to featurecode. we rely on the string being zero-filled, and not overflowing it. Todo: XXX how do we guarantee the latter ? Definition at line 1289 of file res_features.c. References ast_channel::appl, ast_answer(), ast_cdr_appenduserfield(), ast_cdr_setuserfield(), ast_channel_bridge(), ast_channel_setoption(), ast_clear_flag, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_OPTION, AST_CONTROL_RINGING, ast_dtmf_stream(), ast_feature_interpret(), AST_FEATURE_PLAY_WARNING, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_DTMF_BEGIN, ast_frfree(), ast_indicate(), ast_log(), AST_OPTION_FLAG_REQUEST, ast_strdupa, ast_strlen_zero(), ast_channel::cdr, config, ast_option_header::data, ast_frame::data, ast_channel::data, ast_frame::datalen, FEATURE_MAX_LEN, FEATURE_RETURN_PASSDIGITS, FEATURE_RETURN_SUCCESS, FEATURE_SENSE_CHAN, FEATURE_SENSE_PEER, ast_option_header::flag, ast_frame::frametype, free, LOG_DEBUG, LOG_WARNING, monitor_app, ast_option_header::option, option_debug, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), pbx_exec(), pbx_findapp(), set_config_flags(), ast_frame::subclass, and ast_cdr::userfield. Referenced by ast_bridge_call_thread(), builtin_atxfer(), and park_exec(). { /* Copy voice back and forth between the two channels. Give the peer the ability to transfer calls with '#<extension' syntax. */ struct ast_frame *f; struct ast_channel *who; char chan_featurecode[FEATURE_MAX_LEN + 1]=""; char peer_featurecode[FEATURE_MAX_LEN + 1]=""; int res; int diff; int hasfeatures=0; int hadfeatures=0; struct ast_option_header *aoh; struct ast_bridge_config backup_config; memset(&backup_config, 0, sizeof(backup_config)); config->start_time = ast_tvnow(); if (chan && peer) { pbx_builtin_setvar_helper(chan, "BRIDGEPEER", peer->name); pbx_builtin_setvar_helper(peer, "BRIDGEPEER", chan->name); } else if (chan) pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", NULL); if (monitor_ok) { const char *monitor_exec; struct ast_channel *src = NULL; if (!monitor_app) { if (!(monitor_app = pbx_findapp("Monitor"))) monitor_ok=0; } if ((monitor_exec = pbx_builtin_getvar_helper(chan, "AUTO_MONITOR"))) src = chan; else if ((monitor_exec = pbx_builtin_getvar_helper(peer, "AUTO_MONITOR"))) src = peer; if (monitor_app && src) { char *tmp = ast_strdupa(monitor_exec); pbx_exec(src, monitor_app, tmp); } } set_config_flags(chan, peer, config); config->firstpass = 1; /* Answer if need be */ if (ast_answer(chan)) return -1; peer->appl = "Bridged Call"; peer->data = chan->name; /* copy the userfield from the B-leg to A-leg if applicable */ if (chan->cdr && peer->cdr && !ast_strlen_zero(peer->cdr->userfield)) { char tmp[256]; if (!ast_strlen_zero(chan->cdr->userfield)) { snprintf(tmp, sizeof(tmp), "%s;%s", chan->cdr->userfield, peer->cdr->userfield); ast_cdr_appenduserfield(chan, tmp); } else ast_cdr_setuserfield(chan, peer->cdr->userfield); /* free the peer's cdr without ast_cdr_free complaining */ free(peer->cdr); peer->cdr = NULL; } for (;;) { struct ast_channel *other; /* used later */ res = ast_channel_bridge(chan, peer, config, &f, &who); if (config->feature_timer) { /* Update time limit for next pass */ diff = ast_tvdiff_ms(ast_tvnow(), config->start_time); config->feature_timer -= diff; if (hasfeatures) { /* Running on backup config, meaning a feature might be being activated, but that's no excuse to keep things going indefinitely! */ if (backup_config.feature_timer && ((backup_config.feature_timer -= diff) <= 0)) { if (option_debug) ast_log(LOG_DEBUG, "Timed out, realtime this time!\n"); config->feature_timer = 0; who = chan; if (f) ast_frfree(f); f = NULL; res = 0; } else if (config->feature_timer <= 0) { /* Not *really* out of time, just out of time for digits to come in for features. */ if (option_debug) ast_log(LOG_DEBUG, "Timed out for feature!\n"); if (!ast_strlen_zero(peer_featurecode)) { ast_dtmf_stream(chan, peer, peer_featurecode, 0); memset(peer_featurecode, 0, sizeof(peer_featurecode)); } if (!ast_strlen_zero(chan_featurecode)) { ast_dtmf_stream(peer, chan, chan_featurecode, 0); memset(chan_featurecode, 0, sizeof(chan_featurecode)); } if (f) ast_frfree(f); hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode); if (!hasfeatures) { /* Restore original (possibly time modified) bridge config */ memcpy(config, &backup_config, sizeof(struct ast_bridge_config)); memset(&backup_config, 0, sizeof(backup_config)); } hadfeatures = hasfeatures; /* Continue as we were */ continue; } else if (!f) { /* The bridge returned without a frame and there is a feature in progress. * However, we don't think the feature has quite yet timed out, so just * go back into the bridge. */ continue; } } else { if (config->feature_timer <=0) { /* We ran out of time */ config->feature_timer = 0; who = chan; if (f) ast_frfree(f); f = NULL; res = 0; } } } if (res < 0) { ast_log(LOG_WARNING, "Bridge failed on channels %s and %s\n", chan->name, peer->name); return -1; } if (!f || (f->frametype == AST_FRAME_CONTROL && (f->subclass == AST_CONTROL_HANGUP || f->subclass == AST_CONTROL_BUSY || f->subclass == AST_CONTROL_CONGESTION ) ) ) { res = -1; break; } /* many things should be sent to the 'other' channel */ other = (who == chan) ? peer : chan; if (f->frametype == AST_FRAME_CONTROL) { if (f->subclass == AST_CONTROL_RINGING) ast_indicate(other, AST_CONTROL_RINGING); else if (f->subclass == -1) ast_indicate(other, -1); else if (f->subclass == AST_CONTROL_FLASH) ast_indicate(other, AST_CONTROL_FLASH); else if (f->subclass == AST_CONTROL_OPTION) { aoh = f->data; /* Forward option Requests */ if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) ast_channel_setoption(other, ntohs(aoh->option), aoh->data, f->datalen - sizeof(struct ast_option_header), 0); } } else if (f->frametype == AST_FRAME_DTMF_BEGIN) { /* eat it */ } else if (f->frametype == AST_FRAME_DTMF) { char *featurecode; int sense; hadfeatures = hasfeatures; /* This cannot overrun because the longest feature is one shorter than our buffer */ if (who == chan) { sense = FEATURE_SENSE_CHAN; featurecode = chan_featurecode; } else { sense = FEATURE_SENSE_PEER; featurecode = peer_featurecode; } /*! append the event to featurecode. we rely on the string being zero-filled, and * not overflowing it. * \todo XXX how do we guarantee the latter ? */ featurecode[strlen(featurecode)] = f->subclass; /* Get rid of the frame before we start doing "stuff" with the channels */ ast_frfree(f); f = NULL; config->feature_timer = backup_config.feature_timer; res = ast_feature_interpret(chan, peer, config, featurecode, sense); switch(res) { case FEATURE_RETURN_PASSDIGITS: ast_dtmf_stream(other, who, featurecode, 0); /* Fall through */ case FEATURE_RETURN_SUCCESS: memset(featurecode, 0, sizeof(chan_featurecode)); break; } if (res >= FEATURE_RETURN_PASSDIGITS) { res = 0; } else break; hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode); if (hadfeatures && !hasfeatures) { /* Restore backup */ memcpy(config, &backup_config, sizeof(struct ast_bridge_config)); memset(&backup_config, 0, sizeof(struct ast_bridge_config)); } else if (hasfeatures) { if (!hadfeatures) { /* Backup configuration */ memcpy(&backup_config, config, sizeof(struct ast_bridge_config)); /* Setup temporary config options */ config->play_warning = 0; ast_clear_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING); ast_clear_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING); config->warning_freq = 0; config->warning_sound = NULL; config->end_sound = NULL; config->start_sound = NULL; config->firstpass = 0; } config->start_time = ast_tvnow(); config->feature_timer = featuredigittimeout; if (option_debug) ast_log(LOG_DEBUG, "Set time limit to %ld\n", config->feature_timer); } } if (f) ast_frfree(f); } return res; }

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

Todo: XXX for safety Definition at line 221 of file res_features.c. References ast_channel::appl, ast_bridge_call(), ast_cdr_reset(), ast_cdr_setdestchan(), ast_hangup(), ast_bridge_thread_obj::bconfig, ast_channel::cdr, ast_bridge_thread_obj::chan, ast_channel::data, free, and ast_bridge_thread_obj::peer. Referenced by ast_bridge_call_thread_launch(). { struct ast_bridge_thread_obj *tobj = data; tobj->chan->appl = "Transferred Call"; tobj->chan->data = tobj->peer->name; tobj->peer->appl = "Transferred Call"; tobj->peer->data = tobj->chan->name; if (tobj->chan->cdr) { ast_cdr_reset(tobj->chan->cdr, NULL); ast_cdr_setdestchan(tobj->chan->cdr, tobj->peer->name); } if (tobj->peer->cdr) { ast_cdr_reset(tobj->peer->cdr, NULL); ast_cdr_setdestchan(tobj->peer->cdr, tobj->chan->name); } ast_bridge_call(tobj->peer, tobj->chan, &tobj->bconfig); ast_hangup(tobj->chan); ast_hangup(tobj->peer); bzero(tobj, sizeof(*tobj)); /*! \todo XXX for safety */ free(tobj); return NULL; }

static void ast_bridge_call_thread_launch (  void *  data  )  [static]

Definition at line 246 of file res_features.c. References ast_bridge_call_thread(), ast_pthread_create, and thread. Referenced by builtin_atxfer(). { pthread_t thread; pthread_attr_t attr; struct sched_param sched; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); ast_pthread_create(&thread, &attr,ast_bridge_call_thread, data); pthread_attr_destroy(&attr); memset(&sched, 0, sizeof(sched)); pthread_setschedparam(thread, SCHED_RR, &sched); }

static int ast_feature_interpret (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

Definition at line 1028 of file res_features.c. References ast_copy_flags, AST_FLAGS_ALL, ast_log(), ast_strlen_zero(), ast_test_flag, builtin_features, config, exten, ast_call_feature::feature_mask, FEATURE_RETURN_PASSDIGITS, FEATURE_SENSE_CHAN, FEATURES_COUNT, ast_channel::flags, LOG_DEBUG, ast_call_feature::operation, option_debug, and pbx_builtin_getvar_helper(). Referenced by ast_bridge_call(). { int x; struct ast_flags features; int res = FEATURE_RETURN_PASSDIGITS; struct ast_call_feature *feature; const char *dynamic_features=pbx_builtin_getvar_helper(chan,"DYNAMIC_FEATURES"); if (sense == FEATURE_SENSE_CHAN) ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL); else ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL); if (option_debug > 2) ast_log(LOG_DEBUG, "Feature interpret: chan=%s, peer=%s, sense=%d, features=%d\n", chan->name, peer->name, sense, features.flags); for (x=0; x < FEATURES_COUNT; x++) { if ((ast_test_flag(&features, builtin_features[x].feature_mask)) && !ast_strlen_zero(builtin_features[x].exten)) { /* Feature is up for consideration */ if (!strcmp(builtin_features[x].exten, code)) { res = builtin_features[x].operation(chan, peer, config, code, sense); break; } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) { if (res == FEATURE_RETURN_PASSDIGITS) res = FEATURE_RETURN_STOREDIGITS; } } } if (!ast_strlen_zero(dynamic_features)) { char *tmp = ast_strdupa(dynamic_features); char *tok; while ((tok = strsep(&tmp, "#")) != NULL) { feature = find_feature(tok); if (feature) { /* Feature is up for consideration */ if (!strcmp(feature->exten, code)) { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 " Feature Found: %s exten: %s\n",feature->sname, tok); res = feature->operation(chan, peer, config, code, sense); break; } else if (!strncmp(feature->exten, code, strlen(code))) { res = FEATURE_RETURN_STOREDIGITS; } } } } return res; }

static struct ast_channel * ast_feature_request_and_dial (  struct ast_channel *  caller, const char *  type, int  format, void *  data, int  timeout, int *  outstate, const char *  cid_num, const char *  cid_name )  [static]

Todo: XXX Check - this is very similar to the code in channel.c Definition at line 1119 of file res_features.c. References ast_channel::_softhangup, ast_call(), ast_channel_inherit_variables(), ast_check_hangup(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_RINGING, AST_CONTROL_UNHOLD, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_TEXT, ast_frfree(), ast_indicate(), ast_log(), ast_read(), ast_request(), ast_set_callerid(), AST_STATE_UP, ast_verbose(), ast_waitfor_n(), builtin_features, ast_call_feature::exten, FEATURES_COUNT, ast_frame::frametype, len, LOG_NOTICE, option_verbose, pbx_builtin_setvar_helper(), ast_frame::subclass, and VERBOSE_PREFIX_3. Referenced by builtin_atxfer(). { int state = 0; int cause = 0; int to; struct ast_channel *chan; struct ast_channel *monitor_chans[2]; struct ast_channel *active_channel; int res = 0, ready = 0; if ((chan = ast_request(type, format, data, &cause))) { ast_set_callerid(chan, cid_num, cid_name, cid_num); ast_channel_inherit_variables(caller, chan); pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", caller->name); if (!ast_call(chan, data, timeout)) { struct timeval started; int x, len = 0; char *disconnect_code = NULL, *dialed_code = NULL; ast_indicate(caller, AST_CONTROL_RINGING); /* support dialing of the featuremap disconnect code while performing an attended tranfer */ for (x=0; x < FEATURES_COUNT; x++) { if (strcasecmp(builtin_features[x].sname, "disconnect")) continue; disconnect_code = builtin_features[x].exten; len = strlen(disconnect_code) + 1; dialed_code = alloca(len); memset(dialed_code, 0, len); break; } x = 0; started = ast_tvnow(); to = timeout; while (!ast_check_hangup(caller) && timeout && (chan->_state != AST_STATE_UP)) { struct ast_frame *f = NULL; monitor_chans[0] = caller; monitor_chans[1] = chan; active_channel = ast_waitfor_n(monitor_chans, 2, &to); /* see if the timeout has been violated */ if(ast_tvdiff_ms(ast_tvnow(), started) > timeout) { state = AST_CONTROL_UNHOLD; ast_log(LOG_NOTICE, "We exceeded our AT-timeout\n"); break; /*doh! timeout*/ } if (!active_channel) continue; if (chan && (chan == active_channel)){ f = ast_read(chan); if (f == NULL) { /*doh! where'd he go?*/ state = AST_CONTROL_HANGUP; res = 0; break; } if (f->frametype == AST_FRAME_CONTROL || f->frametype == AST_FRAME_DTMF || f->frametype == AST_FRAME_TEXT) { if (f->subclass == AST_CONTROL_RINGING) { state = f->subclass; if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "%s is ringing\n", chan->name); ast_indicate(caller, AST_CONTROL_RINGING); } else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) { state = f->subclass; if (option_verbose > 2) ast_verbose( VERBOSE_PREFIX_3 "%s is busy\n", chan->name); ast_indicate(caller, AST_CONTROL_BUSY); ast_frfree(f); f = NULL; break; } else if (f->subclass == AST_CONTROL_ANSWER) { /* This is what we are hoping for */ state = f->subclass; ast_frfree(f); f = NULL; ready=1; break; } else { ast_log(LOG_NOTICE, "Don't know what to do about control frame: %d\n", f->subclass); } /* else who cares */ } } else if (caller && (active_channel == caller)) { f = ast_read(caller); if (f == NULL) { /*doh! where'd he go?*/ if (caller->_softhangup && !chan->_softhangup) { /* make this a blind transfer */ ready = 1; break; } state = AST_CONTROL_HANGUP; res = 0; break; } if (f->frametype == AST_FRAME_DTMF) { dialed_code[x++] = f->subclass; dialed_code[x] = '\0'; if (strlen(dialed_code) == len) { x = 0; } else if (x && strncmp(dialed_code, disconnect_code, x)) { x = 0; dialed_code[x] = '\0'; } if (*dialed_code && !strcmp(dialed_code, disconnect_code)) { /* Caller Canceled the call */ state = AST_CONTROL_UNHOLD; ast_frfree(f); f = NULL; break; } } } if (f) ast_frfree(f); } /* end while */ } else ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data); } else { ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data); switch(cause) { case AST_CAUSE_BUSY: state = AST_CONTROL_BUSY; break; case AST_CAUSE_CONGESTION: state = AST_CONTROL_CONGESTION; break; } } ast_indicate(caller, -1); if (chan && ready) { if (chan->_state == AST_STATE_UP) state = AST_CONTROL_ANSWER; res = 0; } else if(chan) { res = -1; ast_hangup(chan); chan = NULL; } else { res = -1; } if (outstate) *outstate = state; if (chan && res <= 0) { if (chan->cdr || (chan->cdr = ast_cdr_alloc())) { char tmp[256]; ast_cdr_init(chan->cdr, chan); snprintf(tmp, 256, "%s/%s", type, (char *)data); ast_cdr_setapp(chan->cdr,"Dial",tmp); ast_cdr_update(chan); ast_cdr_start(chan->cdr); ast_cdr_end(chan->cdr); /* If the cause wasn't handled properly */ if (ast_cdr_disposition(chan->cdr,chan->hangupcause)) ast_cdr_failed(chan->cdr); } else { ast_log(LOG_WARNING, "Unable to create Call Detail Record\n"); } } return chan; }

static AST_LIST_HEAD_STATIC (  feature_list  , ast_call_feature  )  [static]

int ast_masq_park_call (  struct ast_channel *  rchan, struct ast_channel *  host, int  timeout, int *  extout )

Park a call via a masqueraded channel. Parameters: rchan  the real channel to be parked host  the channel to have the parking read to Masquerade the channel rchan into a new, empty channel which is then parked with ast_park_call timeout  is a timeout in milliseconds extout  is a parameter to an int that will hold the parked location, or NULL if you want Definition at line 439 of file res_features.c. References ast_channel_alloc(), ast_channel_masquerade(), ast_frfree(), ast_log(), ast_park_call(), ast_read(), AST_STATE_DOWN, ast_channel::context, ast_channel::exten, LOG_WARNING, ast_channel::priority, ast_channel::readformat, set_c_e_p(), and ast_channel::writeformat. Referenced by manager_park(), mgcp_ss(), and ss_thread(). { struct ast_channel *chan; struct ast_frame *f; /* Make a new, fake channel that we'll use to masquerade in the real one */ if (!(chan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "Parked/%s",rchan->name))) { ast_log(LOG_WARNING, "Unable to create parked channel\n"); return -1; } /* Make formats okay */ chan->readformat = rchan->readformat; chan->writeformat = rchan->writeformat; ast_channel_masquerade(chan, rchan); /* Setup the extensions and such */ set_c_e_p(chan, rchan->context, rchan->exten, rchan->priority); /* Make the masq execute */ f = ast_read(chan); if (f) ast_frfree(f); ast_park_call(chan, peer, timeout, extout); return 0; }

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_GLOBAL_SYMBOLS  , "Call Features Resource"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

AST_MUTEX_DEFINE_STATIC (  parking_lock   )

protects all static variables above

int ast_park_call (  struct ast_channel *  chan, struct ast_channel *  peer, int  timeout, int *  extout )

Park a call and read back parked location. Note: We put the user in the parking list, then wake up the parking thread to be sure it looks after these channels too Definition at line 311 of file res_features.c. References ast_calloc, ast_exists_extension(), ast_log(), ast_mutex_lock(), ast_strlen_zero(), LOG_WARNING, parkeduser::next, parkinglot, parkeduser::parkingnum, and pbx_builtin_getvar_helper(). Referenced by ast_masq_park_call(), builtin_blindtransfer(), builtin_parkcall(), iax_park_thread(), park_call_exec(), and sip_park_thread(). { struct parkeduser *pu, *cur; int i, x = -1, parking_range; struct ast_context *con; const char *parkingexten; /* Allocate memory for parking data */ if (!(pu = ast_calloc(1, sizeof(*pu)))) return -1; /* Lock parking lot */ ast_mutex_lock(&parking_lock); /* Check for channel variable PARKINGEXTEN */ parkingexten = pbx_builtin_getvar_helper(chan, "PARKINGEXTEN"); if (!ast_strlen_zero(parkingexten)) { if (ast_exists_extension(NULL, parking_con, parkingexten, 1, NULL)) { ast_log(LOG_WARNING, "Requested parking extension already exists: %s@%s\n", parkingexten, parking_con); return 0; /* Continue execution if possible */ } ast_copy_string(pu->parkingexten, parkingexten, sizeof(pu->parkingexten)); } else { /* Select parking space within range */ parking_range = parking_stop - parking_start+1; for (i = 0; i < parking_range; i++) { x = (i + parking_offset) % parking_range + parking_start; cur = parkinglot; while(cur) { if (cur->parkingnum == x) break; cur = cur->next; } if (!cur) break; } if (!(i < parking_range)) { ast_log(LOG_WARNING, "No more parking spaces\n"); free(pu); ast_mutex_unlock(&parking_lock); return -1; } /* Set pointer for next parking */ if (parkfindnext) parking_offset = x - parking_start + 1; } chan->appl = "Parked Call"; chan->data = NULL; pu->chan = chan; /* Put the parked channel on hold if we have two different channels */ if (chan != peer) { ast_indicate_data(pu->chan, AST_CONTROL_HOLD, S_OR(parkmohclass, NULL), !ast_strlen_zero(parkmohclass) ? strlen(parkmohclass) + 1 : 0); } pu->start = ast_tvnow(); pu->parkingnum = x; pu->parkingtime = (timeout > 0) ? timeout : parkingtime; if (extout) *extout = x; if (peer) ast_copy_string(pu->peername, peer->name, sizeof(pu->peername)); /* Remember what had been dialed, so that if the parking expires, we try to come back to the same place */ ast_copy_string(pu->context, S_OR(chan->macrocontext, chan->context), sizeof(pu->context)); ast_copy_string(pu->exten, S_OR(chan->macroexten, chan->exten), sizeof(pu->exten)); pu->priority = chan->macropriority ? chan->macropriority : chan->priority; pu->next = parkinglot; parkinglot = pu; /* If parking a channel directly, don't quiet yet get parking running on it */ if (peer == chan) pu->notquiteyet = 1; ast_mutex_unlock(&parking_lock); /* Wake up the (presumably select()ing) thread */ pthread_kill(parking_thread, SIGURG); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Parked %s on %d@%s. Will timeout back to extension [%s] %s, %d in %d seconds\n", pu->chan->name, pu->parkingnum, parking_con, pu->context, pu->exten, pu->priority, (pu->parkingtime/1000)); if (pu->parkingnum != -1) snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", x); manager_event(EVENT_FLAG_CALL, "ParkedCall", "Exten: %s\r\n" "Channel: %s\r\n" "From: %s\r\n" "Timeout: %ld\r\n" "CallerIDNum: %s\r\n" "CallerIDName: %s\r\n", pu->parkingexten, pu->chan->name, peer ? peer->name : "", (long)pu->start.tv_sec + (long)(pu->parkingtime/1000) - (long)time(NULL), S_OR(pu->chan->cid.cid_num, "<unknown>"), S_OR(pu->chan->cid.cid_name, "<unknown>") ); if (peer && adsipark && ast_adsi_available(peer)) { adsi_announce_park(peer, pu->parkingexten); /* Only supports parking numbers */ ast_adsi_unload_session(peer); } con = ast_context_find(parking_con); if (!con) con = ast_context_create(NULL, parking_con, registrar); if (!con) /* Still no context? Bad */ ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parking_con); else { /* Add extension to context */ if (!ast_add_extension2(con, 1, pu->parkingexten, 1, NULL, NULL, parkedcall, strdup(pu->parkingexten), ast_free, registrar)) notify_metermaids(pu->parkingexten, parking_con); } /* Tell the peer channel the number of the parking space */ if (peer && pu->parkingnum != -1) /* Only say number if it's a number */ ast_say_digits(peer, pu->parkingnum, "", peer->language); if (pu->notquiteyet) { /* Wake up parking thread if we're really done */ ast_indicate_data(pu->chan, AST_CONTROL_HOLD, S_OR(parkmohclass, NULL), !ast_strlen_zero(parkmohclass) ? strlen(parkmohclass) + 1 : 0); pu->notquiteyet = 0; pthread_kill(parking_thread, SIGURG); } return 0; }

char* ast_parking_ext (  void   )

Determine system parking extension Returns the call parking extension for drivers that provide special call parking help. Definition at line 157 of file res_features.c. Referenced by builtin_blindtransfer(), dp_lookup(), handle_request_refer(), mgcp_ss(), socket_process(), and ss_thread(). { return parking_ext; }

int ast_pickup_call (  struct ast_channel *  chan  )

Pickup a call. Definition at line 2045 of file res_features.c. References ast_channel::_state, ast_answer(), ast_channel_masquerade(), ast_channel_unlock, ast_channel_walk_locked(), AST_CONTROL_ANSWER, ast_log(), ast_queue_control(), AST_STATE_RING, AST_STATE_RINGING, ast_channel::callgroup, LOG_DEBUG, LOG_WARNING, option_debug, ast_channel::pbx, and ast_channel::pickupgroup. Referenced by cb_events(), handle_request_invite(), mgcp_ss(), and ss_thread(). { struct ast_channel *cur = NULL; int res = -1; while ( (cur = ast_channel_walk_locked(cur)) != NULL) { if (!cur->pbx && (cur != chan) && (chan->pickupgroup & cur->callgroup) && ((cur->_state == AST_STATE_RINGING) || (cur->_state == AST_STATE_RING))) { break; } ast_channel_unlock(cur); } if (cur) { if (option_debug) ast_log(LOG_DEBUG, "Call pickup on chan '%s' by '%s'\n",cur->name, chan->name); res = ast_answer(chan); if (res) ast_log(LOG_WARNING, "Unable to answer '%s'\n", chan->name); res = ast_queue_control(chan, AST_CONTROL_ANSWER); if (res) ast_log(LOG_WARNING, "Unable to queue answer on '%s'\n", chan->name); res = ast_channel_masquerade(cur, chan); if (res) ast_log(LOG_WARNING, "Unable to masquerade '%s' into '%s'\n", chan->name, cur->name); /* Done */ ast_channel_unlock(cur); } else { if (option_debug) ast_log(LOG_DEBUG, "No call pickup possible...\n"); } return res; }

char* ast_pickup_ext (  void   )

Determine system call pickup extension. Definition at line 162 of file res_features.c. Referenced by cb_events(), get_destination(), handle_request_invite(), handle_showfeatures(), mgcp_ss(), and ss_thread(). { return pickup_ext; }

void ast_register_feature (  struct ast_call_feature *  feature  )

register new feature into feature_set Parameters: feature  an ast_call_feature object which contains a keysequence and a callback function which is called when this keysequence is pressed during a call. Definition at line 883 of file res_features.c. References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_verbose(), LOG_NOTICE, option_verbose, ast_call_feature::sname, and VERBOSE_PREFIX_2. { if (!feature) { ast_log(LOG_NOTICE,"You didn't pass a feature!\n"); return; } AST_LIST_LOCK(&feature_list); AST_LIST_INSERT_HEAD(&feature_list,feature,feature_entry); AST_LIST_UNLOCK(&feature_list); if (option_verbose >= 2) ast_verbose(VERBOSE_PREFIX_2 "Registered Feature '%s'\n",feature->sname); }

void ast_unregister_feature (  struct ast_call_feature *  feature  )

unregister feature from feature_set Parameters: feature  the ast_call_feature object which was registered before Definition at line 899 of file res_features.c. References AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, and free. { if (!feature) return; AST_LIST_LOCK(&feature_list); AST_LIST_REMOVE(&feature_list,feature,feature_entry); AST_LIST_UNLOCK(&feature_list); free(feature); }

static void ast_unregister_features (  void   )  [static]

Remove all features in the list. Definition at line 911 of file res_features.c. References AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, and free. { struct ast_call_feature *feature; AST_LIST_LOCK(&feature_list); while ((feature = AST_LIST_REMOVE_HEAD(&feature_list,feature_entry))) free(feature); AST_LIST_UNLOCK(&feature_list); }

static int builtin_atxfer (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

Definition at line 731 of file res_features.c. References ast_channel::_softhangup, ast_channel::_state, ast_app_dtget(), ast_autoservice_start(), ast_autoservice_stop(), ast_best_codec(), ast_bridge_call(), ast_bridge_call_thread_launch(), ast_calloc, ast_channel_alloc(), ast_channel_masquerade(), ast_check_hangup(), ast_clear_flag, AST_CONTROL_BUSY, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_DIGIT_ANY, ast_exists_extension(), ast_explicit_goto(), AST_FEATURE_DISCONNECT, ast_feature_request_and_dial(), AST_FLAGS_ALL, ast_frfree(), ast_hangup(), ast_indicate(), ast_log(), ast_read(), ast_set_flag, AST_STATE_DOWN, AST_STATE_UP, ast_stream_and_wait(), ast_waitfordigit(), ast_bridge_thread_obj::bconfig, ast_bridge_thread_obj::chan, check_compat(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, config, ast_channel::context, ast_channel::exten, FEATURE_RETURN_SUCCESS, ast_bridge_config::features_callee, ast_bridge_config::features_caller, finishup(), LOG_DEBUG, LOG_WARNING, ast_channel::nativeformats, option_debug, ast_bridge_thread_obj::peer, ast_channel::priority, ast_channel::readformat, real_ctx(), set_peers(), and ast_channel::writeformat. { struct ast_channel *transferer; struct ast_channel *transferee; const char *transferer_real_context; char xferto[256] = ""; int res; int outstate=0; struct ast_channel *newchan; struct ast_channel *xferchan; struct ast_bridge_thread_obj *tobj; struct ast_bridge_config bconfig; struct ast_frame *f; int l; if (option_debug) ast_log(LOG_DEBUG, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense); set_peers(&transferer, &transferee, peer, chan, sense); transferer_real_context = real_ctx(transferer, transferee); /* Start autoservice on chan while we talk to the originator */ ast_autoservice_start(transferee); ast_indicate(transferee, AST_CONTROL_HOLD); /* Transfer */ res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY); if (res < 0) { finishup(transferee); return res; } if (res > 0) /* If they've typed a digit already, handle it */ xferto[0] = (char) res; /* this is specific of atxfer */ res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout); if (res < 0) { /* hangup, would be 0 for invalid and 1 for valid */ finishup(transferee); return res; } if (res == 0) { ast_log(LOG_WARNING, "Did not read data.\n"); finishup(transferee); if (ast_stream_and_wait(transferer, "beeperr", "")) return -1; return FEATURE_RETURN_SUCCESS; } /* valid extension, res == 1 */ if (!ast_exists_extension(transferer, transferer_real_context, xferto, 1, transferer->cid.cid_num)) { ast_log(LOG_WARNING, "Extension %s does not exist in context %s\n",xferto,transferer_real_context); finishup(transferee); if (ast_stream_and_wait(transferer, "beeperr", "")) return -1; return FEATURE_RETURN_SUCCESS; } l = strlen(xferto); snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context); /* append context */ newchan = ast_feature_request_and_dial(transferer, "Local", ast_best_codec(transferer->nativeformats), xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name); ast_indicate(transferer, -1); if (!newchan) { finishup(transferee); /* any reason besides user requested cancel and busy triggers the failed sound */ if (outstate != AST_CONTROL_UNHOLD && outstate != AST_CONTROL_BUSY && ast_stream_and_wait(transferer, xferfailsound, "")) return -1; return FEATURE_RETURN_SUCCESS; } if (check_compat(transferer, newchan)) return -1; memset(&bconfig,0,sizeof(struct ast_bridge_config)); ast_set_flag(&(bconfig.features_caller), AST_FEATURE_DISCONNECT); ast_set_flag(&(bconfig.features_callee), AST_FEATURE_DISCONNECT); res = ast_bridge_call(transferer, newchan, &bconfig); if (newchan->_softhangup || newchan->_state != AST_STATE_UP || !transferer->_softhangup) { ast_hangup(newchan); if (ast_stream_and_wait(transferer, xfersound, "")) ast_log(LOG_WARNING, "Failed to play transfer sound!\n"); finishup(transferee); transferer->_softhangup = 0; return FEATURE_RETURN_SUCCESS; } if (check_compat(transferee, newchan)) return -1; ast_indicate(transferee, AST_CONTROL_UNHOLD); if ((ast_autoservice_stop(transferee) < 0) || (ast_waitfordigit(transferee, 100) < 0) || (ast_waitfordigit(newchan, 100) < 0) || ast_check_hangup(transferee) || ast_check_hangup(newchan)) { ast_hangup(newchan); return -1; } xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "Transfered/%s", transferee->name); if (!xferchan) { ast_hangup(newchan); return -1; } /* Make formats okay */ xferchan->readformat = transferee->readformat; xferchan->writeformat = transferee->writeformat; ast_channel_masquerade(xferchan, transferee); ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority); xferchan->_state = AST_STATE_UP; ast_clear_flag(xferchan, AST_FLAGS_ALL); xferchan->_softhangup = 0; if ((f = ast_read(xferchan))) ast_frfree(f); newchan->_state = AST_STATE_UP; ast_clear_flag(newchan, AST_FLAGS_ALL); newchan->_softhangup = 0; tobj = ast_calloc(1, sizeof(struct ast_bridge_thread_obj)); if (!tobj) { ast_hangup(xferchan); ast_hangup(newchan); return -1; } tobj->chan = xferchan; tobj->peer = newchan; tobj->bconfig = *config; if (ast_stream_and_wait(newchan, xfersound, "")) ast_log(LOG_WARNING, "Failed to play transfer sound!\n"); ast_bridge_call_thread_launch(tobj); return -1; /* XXX meaning the channel is bridged ? */ }

static int builtin_automonitor (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

Definition at line 528 of file res_features.c. References ast_autoservice_start(), ast_autoservice_stop(), ast_log(), ast_monitor_stop(), ast_strdupa, ast_stream_and_wait(), ast_strlen_zero(), ast_verbose(), ast_channel::cid, ast_callerid::cid_num, FEATURE_RETURN_SUCCESS, len, LOG_ERROR, LOG_WARNING, ast_channel::monitor, monitor_app, option_verbose, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), pbx_exec(), pbx_findapp(), S_OR, set_peers(), and VERBOSE_PREFIX_3. { char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL; int x = 0; size_t len; struct ast_channel *caller_chan, *callee_chan; if (!monitor_ok) { ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n"); return -1; } if (!monitor_app && !(monitor_app = pbx_findapp("Monitor"))) { monitor_ok = 0; ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n"); return -1; } set_peers(&caller_chan, &callee_chan, peer, chan, sense); if (!ast_strlen_zero(courtesytone)) { if (ast_autoservice_start(callee_chan)) return -1; if (ast_stream_and_wait(caller_chan, courtesytone, "")) { ast_log(LOG_WARNING, "Failed to play courtesy tone!\n"); ast_autoservice_stop(callee_chan); return -1; } if (ast_autoservice_stop(callee_chan)) return -1; } if (callee_chan->monitor) { if (option_verbose > 3) ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to stop recording call.\n", code); ast_monitor_stop(callee_chan, 1); return FEATURE_RETURN_SUCCESS; } if (caller_chan && callee_chan) { const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_FORMAT"); const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR"); if (!touch_format) touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_FORMAT"); if (!touch_monitor) touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR"); if (touch_monitor) { len = strlen(touch_monitor) + 50; args = alloca(len); touch_filename = alloca(len); snprintf(touch_filename, len, "auto-%ld-%s", (long)time(NULL), touch_monitor); snprintf(args, len, "%s|%s|m", (touch_format) ? touch_format : "wav", touch_filename); } else { caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name)); callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name)); len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50; args = alloca(len); touch_filename = alloca(len); snprintf(touch_filename, len, "auto-%ld-%s-%s", (long)time(NULL), caller_chan_id, callee_chan_id); snprintf(args, len, "%s|%s|m", S_OR(touch_format, "wav"), touch_filename); } for( x = 0; x < strlen(args); x++) { if (args[x] == '/') args[x] = '-'; } if (option_verbose > 3) ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to record call. filename: %s\n", code, args); pbx_exec(callee_chan, monitor_app, args); pbx_builtin_setvar_helper(callee_chan, "TOUCH_MONITOR_OUTPUT", touch_filename); pbx_builtin_setvar_helper(caller_chan, "TOUCH_MONITOR_OUTPUT", touch_filename); return FEATURE_RETURN_SUCCESS; } ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n"); return -1; }

static int builtin_blindtransfer (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

Todo: XXX Maybe we should have another message here instead of invalid extension XXX Definition at line 639 of file res_features.c. References ast_app_dtget(), ast_async_goto(), ast_autoservice_start(), AST_CONTROL_HOLD, AST_DIGIT_ANY, ast_exists_extension(), ast_indicate(), ast_log(), ast_park_call(), ast_parking_ext(), AST_PBX_KEEPALIVE, AST_PBX_NO_HANGUP_PEER, ast_stopstream(), ast_stream_and_wait(), ast_verbose(), check_goto_on_transfer(), ast_channel::cid, ast_callerid::cid_num, FEATURE_RETURN_SUCCESS, finishup(), LOG_WARNING, option_verbose, ast_channel::pbx, pbx_builtin_setvar_helper(), real_ctx(), set_c_e_p(), set_peers(), VERBOSE_PREFIX_2, and VERBOSE_PREFIX_3. { struct ast_channel *transferer; struct ast_channel *transferee; const char *transferer_real_context; char xferto[256]; int res; set_peers(&transferer, &transferee, peer, chan, sense); transferer_real_context = real_ctx(transferer, transferee); /* Start autoservice on chan while we talk to the originator */ ast_autoservice_start(transferee); ast_indicate(transferee, AST_CONTROL_HOLD); memset(xferto, 0, sizeof(xferto)); /* Transfer */ res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY); if (res < 0) { finishup(transferee); return -1; /* error ? */ } if (res > 0) /* If they've typed a digit already, handle it */ xferto[0] = (char) res; ast_stopstream(transferer); res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout); if (res < 0) { /* hangup, would be 0 for invalid and 1 for valid */ finishup(transferee); return res; } if (!strcmp(xferto, ast_parking_ext())) { res = finishup(transferee); if (res) res = -1; else if (!ast_park_call(transferee, transferer, 0, NULL)) { /* success */ /* We return non-zero, but tell the PBX not to hang the channel when the thread dies -- We have to be careful now though. We are responsible for hanging up the channel, else it will never be hung up! */ return (transferer == peer) ? AST_PBX_KEEPALIVE : AST_PBX_NO_HANGUP_PEER; } else { ast_log(LOG_WARNING, "Unable to park call %s\n", transferee->name); } /*! \todo XXX Maybe we should have another message here instead of invalid extension XXX */ } else if (ast_exists_extension(transferee, transferer_real_context, xferto, 1, transferer->cid.cid_num)) { pbx_builtin_setvar_helper(peer, "BLINDTRANSFER", chan->name); pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", peer->name); res=finishup(transferee); if (!transferee->pbx) { /* Doh! Use our handy async_goto functions */ if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Transferring %s to '%s' (context %s) priority 1\n" ,transferee->name, xferto, transferer_real_context); if (ast_async_goto(transferee, transferer_real_context, xferto, 1)) ast_log(LOG_WARNING, "Async goto failed :-(\n"); res = -1; } else { /* Set the channel's new extension, since it exists, using transferer context */ set_c_e_p(transferee, transferer_real_context, xferto, 0); } check_goto_on_transfer(transferer); return res; } else { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Unable to find extension '%s' in context '%s'\n", xferto, transferer_real_context); } if (ast_stream_and_wait(transferer, xferfailsound, AST_DIGIT_ANY) < 0 ) { finishup(transferee); return -1; } ast_stopstream(transferer); res = finishup(transferee); if (res) { if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Hungup during autoservice stop on '%s'\n", transferee->name); return res; } return FEATURE_RETURN_SUCCESS; }

static int builtin_disconnect (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

Definition at line 612 of file res_features.c. References ast_verbose(), FEATURE_RETURN_HANGUP, option_verbose, and VERBOSE_PREFIX_3. { if (option_verbose > 3) ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to disconnect call.\n", code); return FEATURE_RETURN_HANGUP; }

static int builtin_parkcall (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

support routing for one touch call parking Definition at line 495 of file res_features.c. References ast_channel::_state, ast_answer(), ast_module_user_add, ast_module_user_remove, ast_park_call(), AST_PBX_KEEPALIVE, AST_PBX_NO_HANGUP_PEER, ast_safe_sleep(), AST_STATE_UP, ast_module_user::chan, ast_channel::exten, FEATURE_SENSE_CHAN, ast_channel::priority, and set_peers(). { struct ast_channel *parker; struct ast_channel *parkee; int res = 0; struct ast_module_user *u; u = ast_module_user_add(chan); set_peers(&parker, &parkee, peer, chan, sense); /* Setup the exten/priority to be s/1 since we don't know where this call should return */ strcpy(chan->exten, "s"); chan->priority = 1; if (chan->_state != AST_STATE_UP) res = ast_answer(chan); if (!res) res = ast_safe_sleep(chan, 1000); if (!res) res = ast_park_call(parkee, parker, 0, NULL); ast_module_user_remove(u); if (!res) { if (sense == FEATURE_SENSE_CHAN) res = AST_PBX_NO_HANGUP_PEER; else res = AST_PBX_KEEPALIVE; } return res; }

static int check_compat (  struct ast_channel *  c, struct ast_channel *  newchan )  [static]

Definition at line 720 of file res_features.c. References ast_channel_make_compatible(), ast_hangup(), ast_log(), and LOG_WARNING. Referenced by builtin_atxfer(). { if (ast_channel_make_compatible(c, newchan) < 0) { ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", c->name, newchan->name); ast_hangup(newchan); return -1; } return 0; }

static void check_goto_on_transfer (  struct ast_channel *  chan  )  [static]

Definition at line 182 of file res_features.c. References ast_channel_alloc(), AST_STATE_DOWN, ast_strdupa, ast_strlen_zero(), and pbx_builtin_getvar_helper(). Referenced by builtin_blindtransfer(). { struct ast_channel *xferchan; const char *val = pbx_builtin_getvar_helper(chan, "GOTO_ON_BLINDXFR"); char *x, *goto_on_transfer; struct ast_frame *f; if (ast_strlen_zero(val)) return; goto_on_transfer = ast_strdupa(val); if (!(xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, chan->name))) return; for (x = goto_on_transfer; x && *x; x++) { if (*x == '^') *x = '|'; } /* Make formats okay */ xferchan->readformat = chan->readformat; xferchan->writeformat = chan->writeformat; ast_channel_masquerade(xferchan, chan); ast_parseable_goto(xferchan, goto_on_transfer); xferchan->_state = AST_STATE_UP; ast_clear_flag(xferchan, AST_FLAGS_ALL); xferchan->_softhangup = 0; if ((f = ast_read(xferchan))) { ast_frfree(f); f = NULL; ast_pbx_start(xferchan); } else { ast_hangup(xferchan); } }

static void* do_parking_thread (  void *  ignore  )  [static]

Take care of parked calls and unpark them if needed. Todo: XXX Maybe we could do something with packets, like dial "0" for operator or something XXX Todo: XXX Ick: jumping into an else statement??? XXX Definition at line 1525 of file res_features.c. References ast_add_extension2(), ast_clear_flag, ast_context_create(), ast_context_find(), ast_context_remove_extension2(), AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_FLAG_EXCEPTION, AST_FRAME_CONTROL, ast_free, ast_frfree(), ast_hangup(), ast_indicate(), ast_indicate_data(), ast_log(), AST_MAX_EXTENSION, AST_MAX_FDS, ast_mutex_lock(), ast_pbx_start(), ast_read(), ast_set_flag, ast_strdupa, ast_strlen_zero(), ast_verbose(), parkeduser::chan, ast_channel::context, parkeduser::context, ast_channel::exten, parkeduser::exten, ast_channel::fds, free, LOG_DEBUG, LOG_ERROR, LOG_WARNING, parkeduser::moh_trys, parkeduser::next, notify_metermaids(), parkeduser::notquiteyet, option_debug, option_verbose, parkeduser::parkingexten, parkinglot, parkeduser::parkingnum, parkeduser::parkingtime, pbx_builtin_setvar_helper(), parkeduser::peername, post_manager_event(), ast_channel::priority, parkeduser::priority, S_OR, set_c_e_p(), parkeduser::start, strdup, and VERBOSE_PREFIX_2. Referenced by load_module(). { char parkingslot[AST_MAX_EXTENSION]; fd_set rfds, efds; /* results from previous select, to be preserved across loops. */ FD_ZERO(&rfds); FD_ZERO(&efds); for (;;) { struct parkeduser *pu, *pl, *pt = NULL; int ms = -1; /* select timeout, uninitialized */ int max = -1; /* max fd, none there yet */ fd_set nrfds, nefds; /* args for the next select */ FD_ZERO(&nrfds); FD_ZERO(&nefds); ast_mutex_lock(&parking_lock); pl = NULL; pu = parkinglot; /* navigate the list with prev-cur pointers to support removals */ while (pu) { struct ast_channel *chan = pu->chan; /* shorthand */ int tms; /* timeout for this item */ int x; /* fd index in channel */ struct ast_context *con; if (pu->notquiteyet) { /* Pretend this one isn't here yet */ pl = pu; pu = pu->next; continue; } tms = ast_tvdiff_ms(ast_tvnow(), pu->start); if (tms > pu->parkingtime) { ast_indicate(chan, AST_CONTROL_UNHOLD); /* Get chan, exten from derived kludge */ if (pu->peername[0]) { char *peername = ast_strdupa(pu->peername); char *cp = strrchr(peername, '-'); if (cp) *cp = 0; con = ast_context_find(parking_con_dial); if (!con) { con = ast_context_create(NULL, parking_con_dial, registrar); if (!con) ast_log(LOG_ERROR, "Parking dial context '%s' does not exist and unable to create\n", parking_con_dial); } if (con) { char returnexten[AST_MAX_EXTENSION]; snprintf(returnexten, sizeof(returnexten), "%s||t", peername); ast_add_extension2(con, 1, peername, 1, NULL, NULL, "Dial", strdup(returnexten), ast_free, registrar); } if (comebacktoorigin) { set_c_e_p(chan, parking_con_dial, peername, 1); } else { ast_log(LOG_WARNING, "now going to parkedcallstimeout,s,1 | ps is %d\n",pu->parkingnum); snprintf(parkingslot, sizeof(parkingslot), "%d", pu->parkingnum); pbx_builtin_setvar_helper(pu->chan, "PARKINGSLOT", parkingslot); set_c_e_p(chan, "parkedcallstimeout", peername, 1); } } else { /* They've been waiting too long, send them back to where they came. Theoretically they should have their original extensions and such, but we copy to be on the safe side */ set_c_e_p(chan, pu->context, pu->exten, pu->priority); } post_manager_event("ParkedCallTimeOut", pu->parkingexten, chan); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Timeout for %s parked on %d. Returning to %s,%s,%d\n", chan->name, pu->parkingnum, chan->context, chan->exten, chan->priority); /* Start up the PBX, or hang them up */ if (ast_pbx_start(chan)) { ast_log(LOG_WARNING, "Unable to restart the PBX for user on '%s', hanging them up...\n", chan->name); ast_hangup(chan); } /* And take them out of the parking lot */ if (pl) pl->next = pu->next; else parkinglot = pu->next; pt = pu; pu = pu->next; con = ast_context_find(parking_con); if (con) { if (ast_context_remove_extension2(con, pt->parkingexten, 1, NULL)) ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n"); else notify_metermaids(pt->parkingexten, parking_con); } else ast_log(LOG_WARNING, "Whoa, no parking context?\n"); free(pt); } else { /* still within parking time, process descriptors */ for (x = 0; x < AST_MAX_FDS; x++) { struct ast_frame *f; if (chan->fds[x] == -1 || (!FD_ISSET(chan->fds[x], &rfds) && !FD_ISSET(chan->fds[x], &efds))) continue; /* nothing on this descriptor */ if (FD_ISSET(chan->fds[x], &efds)) ast_set_flag(chan, AST_FLAG_EXCEPTION); else ast_clear_flag(chan, AST_FLAG_EXCEPTION); chan->fdno = x; /* See if they need servicing */ f = ast_read(chan); if (!f || (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)) { if (f) ast_frfree(f); post_manager_event("ParkedCallGiveUp", pu->parkingexten, chan); /* There's a problem, hang them up*/ if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "%s got tired of being parked\n", chan->name); ast_hangup(chan); /* And take them out of the parking lot */ if (pl) pl->next = pu->next; else parkinglot = pu->next; pt = pu; pu = pu->next; con = ast_context_find(parking_con); if (con) { if (ast_context_remove_extension2(con, pt->parkingexten, 1, NULL)) ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n"); else notify_metermaids(pt->parkingexten, parking_con); } else ast_log(LOG_WARNING, "Whoa, no parking context?\n"); free(pt); break; } else { /*! \todo XXX Maybe we could do something with packets, like dial "0" for operator or something XXX */ ast_frfree(f); if (pu->moh_trys < 3 && !chan->generatordata) { if (option_debug) ast_log(LOG_DEBUG, "MOH on parked call stopped by outside source. Restarting.\n"); ast_indicate_data(pu->chan, AST_CONTROL_HOLD, S_OR(parkmohclass, NULL), !ast_strlen_zero(parkmohclass) ? strlen(parkmohclass) + 1 : 0); pu->moh_trys++; } goto std; /*! \todo XXX Ick: jumping into an else statement??? XXX */ } } /* end for */ if (x >= AST_MAX_FDS) { std: for (x=0; x<AST_MAX_FDS; x++) { /* mark fds for next round */ if (chan->fds[x] > -1) { FD_SET(chan->fds[x], &nrfds); FD_SET(chan->fds[x], &nefds); if (chan->fds[x] > max) max = chan->fds[x]; } } /* Keep track of our shortest wait */ if (tms < ms || ms < 0) ms = tms; pl = pu; pu = pu->next; } } } /* end while */ ast_mutex_unlock(&parking_lock); rfds = nrfds; efds = nefds; { struct timeval tv = ast_samp2tv(ms, 1000); /* Wait for something to happen */ ast_select(max + 1, &rfds, NULL, &efds, (ms > -1) ? &tv : NULL); } pthread_testcancel(); } return NULL; /* Never reached */ }

static int feature_exec_app (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config, char *  code, int  sense )  [static]

exec an app by feature Todo: XXX should probably return res Definition at line 937 of file res_features.c. References ast_call_feature::app, app, ast_call_feature::app_args, ast_autoservice_start(), ast_autoservice_stop(), AST_FEATURE_FLAG_BYCALLEE, AST_FEATURE_FLAG_BYCALLER, AST_FEATURE_FLAG_ONSELF, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_moh_start(), ast_moh_stop(), AST_PBX_KEEPALIVE, AST_PBX_NO_HANGUP_PEER, ast_strlen_zero(), ast_test_flag, ast_call_feature::exten, FEATURE_RETURN_NO_HANGUP_PEER, FEATURE_RETURN_PASSDIGITS, FEATURE_RETURN_PBX_KEEPALIVE, FEATURE_RETURN_SUCCESS, FEATURE_RETURN_SUCCESSBREAK, FEATURE_SENSE_CHAN, LOG_NOTICE, LOG_WARNING, ast_call_feature::moh_class, pbx_exec(), and pbx_findapp(). { struct ast_app *app; struct ast_call_feature *feature; struct ast_channel *work, *idle; int res; AST_LIST_LOCK(&feature_list); AST_LIST_TRAVERSE(&feature_list, feature, feature_entry) { if (!strcasecmp(feature->exten, code)) break; } AST_LIST_UNLOCK(&feature_list); if (!feature) { /* shouldn't ever happen! */ ast_log(LOG_NOTICE, "Found feature before, but at execing we've lost it??\n"); return -1; } if (sense == FEATURE_SENSE_CHAN) { if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER)) return FEATURE_RETURN_PASSDIGITS; if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) { work = chan; idle = peer; } else { work = peer; idle = chan; } } else { if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE)) return FEATURE_RETURN_PASSDIGITS; if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) { work = peer; idle = chan; } else { work = chan; idle = peer; } } if (!(app = pbx_findapp(feature->app))) { ast_log(LOG_WARNING, "Could not find application (%s)\n", feature->app); return -2; } ast_autoservice_start(idle); if (!ast_strlen_zero(feature->moh_class)) ast_moh_start(idle, feature->moh_class, NULL); res = pbx_exec(work, app, feature->app_args); if (!ast_strlen_zero(feature->moh_class)) ast_moh_stop(idle); ast_autoservice_stop(idle); if (res == AST_PBX_KEEPALIVE) return FEATURE_RETURN_PBX_KEEPALIVE; else if (res == AST_PBX_NO_HANGUP_PEER) return FEATURE_RETURN_NO_HANGUP_PEER; else if (res) return FEATURE_RETURN_SUCCESSBREAK; return FEATURE_RETURN_SUCCESS; /*! \todo XXX should probably return res */ }

static struct ast_call_feature* find_feature (  char *  name  )  [static]

find a feature by name Definition at line 922 of file res_features.c. References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, and ast_call_feature::sname. { struct ast_call_feature *tmp; AST_LIST_LOCK(&feature_list); AST_LIST_TRAVERSE(&feature_list, tmp, feature_entry) { if (!strcasecmp(tmp->sname, name)) break; } AST_LIST_UNLOCK(&feature_list); return tmp; }

static int finishup (  struct ast_channel *  chan  )  [static]

Definition at line 619 of file res_features.c. References ast_autoservice_stop(), AST_CONTROL_UNHOLD, and ast_indicate(). Referenced by builtin_atxfer(), and builtin_blindtransfer(). { ast_indicate(chan, AST_CONTROL_UNHOLD); return ast_autoservice_stop(chan); }

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

Definition at line 1904 of file res_features.c. References ast_cli(), ast_mutex_lock(), parkeduser::chan, parkeduser::context, parkeduser::exten, parkeduser::next, parkeduser::parkingexten, parkinglot, parkeduser::parkingtime, parkeduser::priority, and parkeduser::start. { struct parkeduser *cur; int numparked = 0; ast_cli(fd, "%4s %25s (%-15s %-12s %-4s) %-6s \n", "Num", "Channel" , "Context", "Extension", "Pri", "Timeout"); ast_mutex_lock(&parking_lock); for (cur = parkinglot; cur; cur = cur->next) { ast_cli(fd, "%-10.10s %25s (%-15s %-12s %-4d) %6lds\n" ,cur->parkingexten, cur->chan->name, cur->context, cur->exten ,cur->priority, cur->start.tv_sec + (cur->parkingtime/1000) - time(NULL)); numparked++; } ast_mutex_unlock(&parking_lock); ast_cli(fd, "%d parked call%s.\n", numparked, ESS(numparked)); return RESULT_SUCCESS; }

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

Definition at line 1859 of file res_features.c. References ast_cli(), ast_pickup_ext(), builtin_features, ast_call_feature::default_exten, exten, ast_call_feature::fname, and format. { int i; int fcount; struct ast_call_feature *feature; char format[] = "%-25s %-7s %-7s\n"; ast_cli(fd, format, "Builtin Feature", "Default", "Current"); ast_cli(fd, format, "---------------", "-------", "-------"); ast_cli(fd, format, "Pickup", "*8", ast_pickup_ext()); /* default hardcoded above, so we'll hardcode it here */ fcount = sizeof(builtin_features) / sizeof(builtin_features[0]); for (i = 0; i < fcount; i++) { ast_cli(fd, format, builtin_features[i].fname, builtin_features[i].default_exten, builtin_features[i].exten); } ast_cli(fd, "\n"); ast_cli(fd, format, "Dynamic Feature", "Default", "Current"); ast_cli(fd, format, "---------------", "-------", "-------"); if (AST_LIST_EMPTY(&feature_list)) { ast_cli(fd, "(none)\n"); } else { AST_LIST_LOCK(&feature_list); AST_LIST_TRAVERSE(&feature_list, feature, feature_entry) { ast_cli(fd, format, feature->sname, "no def", feature->exten); } AST_LIST_UNLOCK(&feature_list); } ast_cli(fd, "\nCall parking\n"); ast_cli(fd, "------------\n"); ast_cli(fd,"%-20s: %s\n", "Parking extension", parking_ext); ast_cli(fd,"%-20s: %s\n", "Parking context", parking_con); ast_cli(fd,"%-20s: %d-%d\n", "Parked call extensions", parking_start, parking_stop); ast_cli(fd,"\n"); return RESULT_SUCCESS; }

static int load_config (  void   )  [static]

Todo: XXX var_name or app_args ? Definition at line 2095 of file res_features.c. References ast_config_load(), ast_log(), AST_MAX_EXTENSION, AST_MODULE_LOAD_DECLINE, ast_strlen_zero(), ast_variable_browse(), DEFAULT_FEATURE_DIGIT_TIMEOUT, DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER, DEFAULT_TRANSFER_DIGIT_TIMEOUT, LOG_WARNING, and var. Referenced by load_module(), and reload(). { int start = 0, end = 0; int res; struct ast_context *con = NULL; struct ast_config *cfg = NULL; struct ast_variable *var = NULL; char old_parking_ext[AST_MAX_EXTENSION]; char old_parking_con[AST_MAX_EXTENSION] = ""; if (!ast_strlen_zero(parking_con)) { strcpy(old_parking_ext, parking_ext); strcpy(old_parking_con, parking_con); } /* Reset to defaults */ strcpy(parking_con, "parkedcalls"); strcpy(parking_con_dial, "park-dial"); strcpy(parking_ext, "700"); strcpy(pickup_ext, "*8"); strcpy(parkmohclass, "default"); courtesytone[0] = '\0'; strcpy(xfersound, "beep"); strcpy(xferfailsound, "pbx-invalid"); parking_start = 701; parking_stop = 750; parkfindnext = 0; adsipark = 0; comebacktoorigin = 1; parkaddhints = 0; parkedcalltransfers = 0; transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT; featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT; atxfernoanswertimeout = DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER; cfg = ast_config_load("features.conf"); if (!cfg) { ast_log(LOG_WARNING,"Could not load features.conf\n"); return AST_MODULE_LOAD_DECLINE; } for (var = ast_variable_browse(cfg, "general"); var; var = var->next) { if (!strcasecmp(var->name, "parkext")) { ast_copy_string(parking_ext, var->value, sizeof(parking_ext)); } else if (!strcasecmp(var->name, "context")) { ast_copy_string(parking_con, var->value, sizeof(parking_con)); } else if (!strcasecmp(var->name, "parkingtime")) { if ((sscanf(var->value, "%d", &parkingtime) != 1) || (parkingtime < 1)) { ast_log(LOG_WARNING, "%s is not a valid parkingtime\n", var->value); parkingtime = DEFAULT_PARK_TIME; } else parkingtime = parkingtime * 1000; } else if (!strcasecmp(var->name, "parkpos")) { if (sscanf(var->value, "%d-%d", &start, &end) != 2) { ast_log(LOG_WARNING, "Format for parking positions is a-b, where a and b are numbers at line %d of parking.conf\n", var->lineno); } else { parking_start = start; parking_stop = end; } } else if (!strcasecmp(var->name, "findslot")) { parkfindnext = (!strcasecmp(var->value, "next")); } else if (!strcasecmp(var->name, "parkinghints")) { parkaddhints = ast_true(var->value); } else if (!strcasecmp(var->name, "parkedcalltransfers")) { parkedcalltransfers = ast_true(var->value); } else if (!strcasecmp(var->name, "adsipark")) { adsipark = ast_true(var->value); } else if (!strcasecmp(var->name, "transferdigittimeout")) { if ((sscanf(var->value, "%d", &transferdigittimeout) != 1) || (transferdigittimeout < 1)) { ast_log(LOG_WARNING, "%s is not a valid transferdigittimeout\n", var->value); transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT; } else transferdigittimeout = transferdigittimeout * 1000; } else if (!strcasecmp(var->name, "featuredigittimeout")) { if ((sscanf(var->value, "%d", &featuredigittimeout) != 1) || (featuredigittimeout < 1)) { ast_log(LOG_WARNING, "%s is not a valid featuredigittimeout\n", var->value); featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT; } } else if (!strcasecmp(var->name, "atxfernoanswertimeout")) { if ((sscanf(var->value, "%d", &atxfernoanswertimeout) != 1) || (atxfernoanswertimeout < 1)) { ast_log(LOG_WARNING, "%s is not a valid atxfernoanswertimeout\n", var->value); atxfernoanswertimeout = DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER; } else atxfernoanswertimeout = atxfernoanswertimeout * 1000; } else if (!strcasecmp(var->name, "courtesytone")) { ast_copy_string(courtesytone, var->value, sizeof(courtesytone)); } else if (!strcasecmp(var->name, "parkedplay")) { if (!strcasecmp(var->value, "both")) parkedplay = 2; else if (!strcasecmp(var->value, "parked")) parkedplay = 1; else parkedplay = 0; } else if (!strcasecmp(var->name, "xfersound")) { ast_copy_string(xfersound, var->value, sizeof(xfersound)); } else if (!strcasecmp(var->name, "xferfailsound")) { ast_copy_string(xferfailsound, var->value, sizeof(xferfailsound)); } else if (!strcasecmp(var->name, "pickupexten")) { ast_copy_string(pickup_ext, var->value, sizeof(pickup_ext)); } else if (!strcasecmp(var->name, "comebacktoorigin")) { comebacktoorigin = ast_true(var->value); } else if (!strcasecmp(var->name, "parkedmusicclass")) { ast_copy_string(parkmohclass, var->value, sizeof(parkmohclass)); } } unmap_features(); for (var = ast_variable_browse(cfg, "featuremap"); var; var = var->next) { if (remap_feature(var->name, var->value)) ast_log(LOG_NOTICE, "Unknown feature '%s'\n", var->name); } /* Map a key combination to an application*/ ast_unregister_features(); for (var = ast_variable_browse(cfg, "applicationmap"); var; var = var->next) { char *tmp_val = ast_strdupa(var->value); char *exten, *activateon, *activatedby, *app, *app_args, *moh_class; struct ast_call_feature *feature; /* strsep() sets the argument to NULL if match not found, and it * is safe to use it with a NULL argument, so we don't check * between calls. */ exten = strsep(&tmp_val,","); activatedby = strsep(&tmp_val,","); app = strsep(&tmp_val,","); app_args = strsep(&tmp_val,","); moh_class = strsep(&tmp_val,","); activateon = strsep(&activatedby, "/"); /*! \todo XXX var_name or app_args ? */ if (ast_strlen_zero(app) || ast_strlen_zero(exten) || ast_strlen_zero(activateon) || ast_strlen_zero(var->name)) { ast_log(LOG_NOTICE, "Please check the feature Mapping Syntax, either extension, name, or app aren't provided %s %s %s %s\n", app, exten, activateon, var->name); continue; } if ((feature = find_feature(var->name))) { ast_log(LOG_WARNING, "Dynamic Feature '%s' specified more than once!\n", var->name); continue; } if (!(feature = ast_calloc(1, sizeof(*feature)))) continue; ast_copy_string(feature->sname, var->name, FEATURE_SNAME_LEN); ast_copy_string(feature->app, app, FEATURE_APP_LEN); ast_copy_string(feature->exten, exten, FEATURE_EXTEN_LEN); if (app_args) ast_copy_string(feature->app_args, app_args, FEATURE_APP_ARGS_LEN); if (moh_class) ast_copy_string(feature->moh_class, moh_class, FEATURE_MOH_LEN); ast_copy_string(feature->exten, exten, sizeof(feature->exten)); feature->operation = feature_exec_app; ast_set_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF); /* Allow caller and calle to be specified for backwards compatability */ if (!strcasecmp(activateon, "self") || !strcasecmp(activateon, "caller")) ast_set_flag(feature, AST_FEATURE_FLAG_ONSELF); else if (!strcasecmp(activateon, "peer") || !strcasecmp(activateon, "callee")) ast_set_flag(feature, AST_FEATURE_FLAG_ONPEER); else { ast_log(LOG_NOTICE, "Invalid 'ActivateOn' specification for feature '%s'," " must be 'self', or 'peer'\n", var->name); continue; } if (ast_strlen_zero(activatedby)) ast_set_flag(feature, AST_FEATURE_FLAG_BYBOTH); else if (!strcasecmp(activatedby, "caller")) ast_set_flag(feature, AST_FEATURE_FLAG_BYCALLER); else if (!strcasecmp(activatedby, "callee")) ast_set_flag(feature, AST_FEATURE_FLAG_BYCALLEE); else if (!strcasecmp(activatedby, "both")) ast_set_flag(feature, AST_FEATURE_FLAG_BYBOTH); else { ast_log(LOG_NOTICE, "Invalid 'ActivatedBy' specification for feature '%s'," " must be 'caller', or 'callee', or 'both'\n", var->name); continue; } ast_register_feature(feature); if (option_verbose >= 1) ast_verbose(VERBOSE_PREFIX_2 "Mapping Feature '%s' to app '%s(%s)' with code '%s'\n", var->name, app, app_args, exten); } ast_config_destroy(cfg); /* Remove the old parking extension */ if (!ast_strlen_zero(old_parking_con) && (con = ast_context_find(old_parking_con))) { if(ast_context_remove_extension2(con, old_parking_ext, 1, registrar)) notify_metermaids(old_parking_ext, old_parking_con); if (option_debug) ast_log(LOG_DEBUG, "Removed old parking extension %s@%s\n", old_parking_ext, old_parking_con); } if (!(con = ast_context_find(parking_con)) && !(con = ast_context_create(NULL, parking_con, registrar))) { ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parking_con); return -1; } res = ast_add_extension2(con, 1, ast_parking_ext(), 1, NULL, NULL, parkcall, NULL, NULL, registrar); if (parkaddhints) park_add_hints(parking_con, parking_start, parking_stop); if (!res) notify_metermaids(ast_parking_ext(), parking_con); return res; }

static int load_module (  void   )  [static]

Definition at line 2313 of file res_features.c. References ast_cli_register_multiple(), ast_devstate_prov_add(), ast_manager_register, ast_manager_register2(), ast_pthread_create, ast_register_application(), cli_features, do_parking_thread(), EVENT_FLAG_CALL, load_config(), manager_park(), manager_parking_status(), mandescr_park, metermaidstate(), park_call_exec(), and park_exec(). { int res; memset(parking_ext, 0, sizeof(parking_ext)); memset(parking_con, 0, sizeof(parking_con)); if ((res = load_config())) return res; ast_cli_register_multiple(cli_features, sizeof(cli_features) / sizeof(struct ast_cli_entry)); ast_pthread_create(&parking_thread, NULL, do_parking_thread, NULL); res = ast_register_application(parkedcall, park_exec, synopsis, descrip); if (!res) res = ast_register_application(parkcall, park_call_exec, synopsis2, descrip2); if (!res) { ast_manager_register("ParkedCalls", 0, manager_parking_status, "List parked calls" ); ast_manager_register2("Park", EVENT_FLAG_CALL, manager_park, "Park a channel", mandescr_park); } res |= ast_devstate_prov_add("Park", metermaidstate); return res; }

static int manager_park (  struct mansession *  s, const struct message *  m )  [static]

Definition at line 1990 of file res_features.c. References ast_channel_unlock, ast_get_channel_by_name_locked(), ast_masq_park_call(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), and s. Referenced by load_module(). { const char *channel = astman_get_header(m, "Channel"); const char *channel2 = astman_get_header(m, "Channel2"); const char *timeout = astman_get_header(m, "Timeout"); char buf[BUFSIZ]; int to = 0; int res = 0; int parkExt = 0; struct ast_channel *ch1, *ch2; if (ast_strlen_zero(channel)) { astman_send_error(s, m, "Channel not specified"); return 0; } if (ast_strlen_zero(channel2)) { astman_send_error(s, m, "Channel2 not specified"); return 0; } ch1 = ast_get_channel_by_name_locked(channel); if (!ch1) { snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel); astman_send_error(s, m, buf); return 0; } ch2 = ast_get_channel_by_name_locked(channel2); if (!ch2) { snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel2); astman_send_error(s, m, buf); ast_channel_unlock(ch1); return 0; } if (!ast_strlen_zero(timeout)) { sscanf(timeout, "%d", &to); } res = ast_masq_park_call(ch1, ch2, to, &parkExt); if (!res) { ast_softhangup(ch2, AST_SOFTHANGUP_EXPLICIT); astman_send_ack(s, m, "Park successful"); } else { astman_send_error(s, m, "Park failure"); } ast_channel_unlock(ch1); ast_channel_unlock(ch2); return 0; }

static int manager_parking_status (  struct mansession *  s, const struct message *  m )  [static]

Dump lot status. Definition at line 1943 of file res_features.c. References ast_mutex_lock(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), parkeduser::chan, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, parkeduser::next, parkinglot, parkeduser::parkingnum, parkeduser::parkingtime, parkeduser::peername, s, S_OR, and parkeduser::start. Referenced by load_module(). { struct parkeduser *cur; const char *id = astman_get_header(m,"ActionID"); char idText[256] = ""; if (!ast_strlen_zero(id)) snprintf(idText, 256, "ActionID: %s\r\n", id); astman_send_ack(s, m, "Parked calls will follow"); ast_mutex_lock(&parking_lock); for (cur=parkinglot; cur; cur = cur->next) { astman_append(s, "Event: ParkedCall\r\n" "Exten: %d\r\n" "Channel: %s\r\n" "From: %s\r\n" "Timeout: %ld\r\n" "CallerIDNum: %s\r\n" "CallerIDName: %s\r\n" "%s" "\r\n", cur->parkingnum, cur->chan->name, cur->peername, (long)cur->start.tv_sec + (long)(cur->parkingtime/1000) - (long)time(NULL), S_OR(cur->chan->cid.cid_num, ""), /* XXX in other places it is <unknown> */ S_OR(cur->chan->cid.cid_name, ""), idText); } astman_append(s, "Event: ParkedCallsComplete\r\n" "%s" "\r\n",idText); ast_mutex_unlock(&parking_lock); return RESULT_SUCCESS; }

static int metermaidstate (  const char *  data  )  [static]

metermaids callback from devicestate.c Definition at line 287 of file res_features.c. References AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, ast_exists_extension(), ast_log(), ast_strdupa, context, exten, LOG_DEBUG, option_debug, and strsep(). Referenced by load_module(). { int res = AST_DEVICE_INVALID; char *context = ast_strdupa(data); char *exten; exten = strsep(&context, "@"); if (!context) return res; if (option_debug > 3) ast_log(LOG_DEBUG, "Checking state of exten %s in context %s\n", exten, context); res = ast_exists_extension(NULL, context, exten, 1, NULL); if (!res) return AST_DEVICE_NOT_INUSE; else return AST_DEVICE_INUSE; }

static void notify_metermaids (  char *  exten, char *  context )  [static]

Notify metermaids that we've changed an extension. Definition at line 276 of file res_features.c. References ast_device_state_changed(), ast_log(), LOG_DEBUG, and option_debug. Referenced by do_parking_thread(), and park_exec(). { if (option_debug > 3) ast_log(LOG_DEBUG, "Notification of state change to metermaids %s@%s\n", exten, context); /* Send notification to devicestate subsystem */ ast_device_state_changed("park:%s@%s", exten, context); return; }

static void park_add_hints (  char *  context, int  start, int  stop )  [static]

Add parking hints for all defined parking lots. Definition at line 2081 of file res_features.c. References ast_add_extension(), AST_MAX_EXTENSION, exten, and PRIORITY_HINT. { int numext; char device[AST_MAX_EXTENSION]; char exten[10]; for (numext = start; numext <= stop; numext++) { snprintf(exten, sizeof(exten), "%d", numext); snprintf(device, sizeof(device), "park:%s@%s", exten, context); ast_add_extension(context, 1, exten, PRIORITY_HINT, NULL, NULL, device, NULL, NULL, registrar); } }

static int park_call_exec (  struct ast_channel *  chan, void *  data )  [static]

Park a call. Definition at line 1702 of file res_features.c. References ast_channel::_state, ast_answer(), ast_module_user_add, ast_module_user_remove, ast_park_call(), AST_PBX_KEEPALIVE, ast_safe_sleep(), AST_STATE_UP, ast_module_user::chan, ast_channel::exten, and ast_channel::priority. Referenced by load_module(). { /* Data is unused at the moment but could contain a parking lot context eventually */ int res = 0; struct ast_module_user *u; u = ast_module_user_add(chan); /* Setup the exten/priority to be s/1 since we don't know where this call should return */ strcpy(chan->exten, "s"); chan->priority = 1; /* Answer if call is not up */ if (chan->_state != AST_STATE_UP) res = ast_answer(chan); /* Sleep to allow VoIP streams to settle down */ if (!res) res = ast_safe_sleep(chan, 1000); /* Park the call */ if (!res) res = ast_park_call(chan, chan, 0, NULL); ast_module_user_remove(u); return !res ? AST_PBX_KEEPALIVE : res; }

static int park_exec (  struct ast_channel *  chan, void *  data )  [static]

Pickup parked call. Todo: XXX we would like to wait on both! Todo: XXX Play a message XXX Definition at line 1731 of file res_features.c. References ast_channel::_state, ast_answer(), ast_bridge_call(), ast_cdr_setdestchan(), ast_channel_make_compatible(), ast_context_find(), ast_context_remove_extension2(), AST_CONTROL_UNHOLD, AST_FEATURE_REDIRECT, ast_hangup(), ast_indicate(), ast_log(), ast_module_user_add, ast_module_user_remove, ast_mutex_lock(), ast_mutex_unlock(), AST_PBX_NO_HANGUP_PEER, ast_set_flag, AST_STATE_UP, ast_stream_and_wait(), ast_streamfile(), ast_strlen_zero(), ast_verbose(), ast_waitstream(), parkeduser::chan, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, config, error(), EVENT_FLAG_CALL, free, LOG_WARNING, manager_event, parkeduser::next, notify_metermaids(), option_verbose, parkeduser::parkingexten, parkinglot, parkeduser::parkingnum, pbx_builtin_setvar_helper(), S_OR, and VERBOSE_PREFIX_3. Referenced by load_module(). { int res = 0; struct ast_module_user *u; struct ast_channel *peer=NULL; struct parkeduser *pu, *pl=NULL; struct ast_context *con; int park; struct ast_bridge_config config; if (!data) { ast_log(LOG_WARNING, "Parkedcall requires an argument (extension number)\n"); return -1; } u = ast_module_user_add(chan); park = atoi((char *)data); ast_mutex_lock(&parking_lock); pu = parkinglot; while(pu) { if (pu->parkingnum == park) { if (pl) pl->next = pu->next; else parkinglot = pu->next; break; } pl = pu; pu = pu->next; } ast_mutex_unlock(&parking_lock); if (pu) { peer = pu->chan; con = ast_context_find(parking_con); if (con) { if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL)) ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n"); else notify_metermaids(pu->parkingexten, parking_con); } else ast_log(LOG_WARNING, "Whoa, no parking context?\n"); manager_event(EVENT_FLAG_CALL, "UnParkedCall", "Exten: %s\r\n" "Channel: %s\r\n" "From: %s\r\n" "CallerIDNum: %s\r\n" "CallerIDName: %s\r\n", pu->parkingexten, pu->chan->name, chan->name, S_OR(pu->chan->cid.cid_num, "<unknown>"), S_OR(pu->chan->cid.cid_name, "<unknown>") ); free(pu); } /* JK02: it helps to answer the channel if not already up */ if (chan->_state != AST_STATE_UP) ast_answer(chan); if (peer) { /* Play a courtesy to the source(s) configured to prefix the bridge connecting */ if (!ast_strlen_zero(courtesytone)) { int error = 0; ast_indicate(peer, AST_CONTROL_UNHOLD); if (parkedplay == 0) { error = ast_stream_and_wait(chan, courtesytone, ""); } else if (parkedplay == 1) { error = ast_stream_and_wait(peer, courtesytone, ""); } else if (parkedplay == 2) { if (!ast_streamfile(chan, courtesytone, chan->language) && !ast_streamfile(peer, courtesytone, chan->language)) { /*! \todo XXX we would like to wait on both! */ res = ast_waitstream(chan, ""); if (res >= 0) res = ast_waitstream(peer, ""); if (res < 0) error = 1; } } if (error) { ast_log(LOG_WARNING, "Failed to play courtesy tone!\n"); ast_hangup(peer); return -1; } } else ast_indicate(peer, AST_CONTROL_UNHOLD); res = ast_channel_make_compatible(chan, peer); if (res < 0) { ast_log(LOG_WARNING, "Could not make channels %s and %s compatible for bridge\n", chan->name, peer->name); ast_hangup(peer); return -1; } /* This runs sorta backwards, since we give the incoming channel control, as if it were the person called. */ if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Channel %s connected to parked call %d\n", chan->name, park); memset(&config, 0, sizeof(struct ast_bridge_config)); if (parkedcalltransfers) { ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT); ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT); } res = ast_bridge_call(chan, peer, &config); pbx_builtin_setvar_helper(chan, "PARKEDCHANNEL", peer->name); ast_cdr_setdestchan(chan->cdr, peer->name); /* Simulate the PBX hanging up */ if (res != AST_PBX_NO_HANGUP_PEER) ast_hangup(peer); return res; } else { /*! \todo XXX Play a message XXX */ if (ast_stream_and_wait(chan, "pbx-invalidpark", "")) ast_log(LOG_WARNING, "ast_streamfile of %s failed on %s\n", "pbx-invalidpark", chan->name); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Channel %s tried to talk to nonexistent parked call %d\n", chan->name, park); res = -1; } ast_module_user_remove(u); return res; }

static void post_manager_event (  const char *  s, char *  parkingexten, struct ast_channel *  chan )  [static]

Definition at line 1510 of file res_features.c. References ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, EVENT_FLAG_CALL, manager_event, and S_OR. Referenced by do_parking_thread(). { manager_event(EVENT_FLAG_CALL, s, "Exten: %s\r\n" "Channel: %s\r\n" "CallerIDNum: %s\r\n" "CallerIDName: %s\r\n\r\n", parkingexten, chan->name, S_OR(chan->cid.cid_num, "<unknown>"), S_OR(chan->cid.cid_name, "<unknown>") ); }

static const char* real_ctx (  struct ast_channel *  transferer, struct ast_channel *  transferee )  [static]

Find the context for the transfer. Definition at line 627 of file res_features.c. References ast_strlen_zero(), ast_channel::context, ast_channel::macrocontext, pbx_builtin_getvar_helper(), and s. Referenced by builtin_atxfer(), and builtin_blindtransfer(). { const char *s = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT"); if (ast_strlen_zero(s)) s = pbx_builtin_getvar_helper(transferee, "TRANSFER_CONTEXT"); if (ast_strlen_zero(s)) /* Use the non-macro context to transfer the call XXX ? */ s = transferer->macrocontext; if (ast_strlen_zero(s)) s = transferer->context; return s; }

static int reload (  void   )  [static]

Definition at line 2308 of file res_features.c. References load_config(). { return load_config(); }

static int remap_feature (  const char *  name, const char *  value )  [static]

Definition at line 1012 of file res_features.c. References ast_verbose(), builtin_features, exten, FEATURES_COUNT, option_verbose, and VERBOSE_PREFIX_2. { int x; int res = -1; for (x = 0; x < FEATURES_COUNT; x++) { if (!strcasecmp(name, builtin_features[x].sname)) { ast_copy_string(builtin_features[x].exten, value, sizeof(builtin_features[x].exten)); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Remapping feature %s (%s) to sequence '%s'\n", builtin_features[x].fname, builtin_features[x].sname, builtin_features[x].exten); res = 0; } else if (!strcmp(value, builtin_features[x].exten)) ast_log(LOG_WARNING, "Sequence '%s' already mapped to function %s (%s) while assigning to %s\n", value, builtin_features[x].fname, builtin_features[x].sname, name); } return res; }

static void set_c_e_p (  struct ast_channel *  chan, const char *  context, const char *  ext, int  pri )  [static]

store context, priority and extension Definition at line 175 of file res_features.c. References ast_channel::context, ast_channel::exten, and ast_channel::priority. Referenced by ast_masq_park_call(), builtin_blindtransfer(), and do_parking_thread(). { ast_copy_string(chan->context, context, sizeof(chan->context)); ast_copy_string(chan->exten, ext, sizeof(chan->exten)); chan->priority = pri; }

static void set_config_flags (  struct ast_channel *  chan, struct ast_channel *  peer, struct ast_bridge_config *  config )  [static]

Definition at line 1082 of file res_features.c. References AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, ast_clear_flag, AST_FEATURE_FLAG_NEEDSDTMF, AST_FLAGS_ALL, ast_set_flag, ast_test_flag, builtin_features, config, ast_call_feature::feature_mask, and FEATURES_COUNT. Referenced by ast_bridge_call(). { int x; ast_clear_flag(config, AST_FLAGS_ALL); for (x = 0; x < FEATURES_COUNT; x++) { if (ast_test_flag(builtin_features + x, AST_FEATURE_FLAG_NEEDSDTMF)) { if (ast_test_flag(&(config->features_caller), builtin_features[x].feature_mask)) ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0); if (ast_test_flag(&(config->features_callee), builtin_features[x].feature_mask)) ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1); } } if (chan && peer && !(ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_0) && ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_1))) { const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"); if (dynamic_features) { char *tmp = ast_strdupa(dynamic_features); char *tok; struct ast_call_feature *feature; /* while we have a feature */ while ((tok = strsep(&tmp, "#"))) { if ((feature = find_feature(tok)) && ast_test_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF)) { if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER)) ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0); if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE)) ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1); } } } } }

static void set_peers (  struct ast_channel **  caller, struct ast_channel **  callee, struct ast_channel *  peer, struct ast_channel *  chan, int  sense )  [static]

set caller and callee according to the direction Definition at line 482 of file res_features.c. References FEATURE_SENSE_PEER. Referenced by builtin_atxfer(), builtin_automonitor(), builtin_blindtransfer(), and builtin_parkcall(). { if (sense == FEATURE_SENSE_PEER) { *caller = peer; *callee = chan; } else { *callee = peer; *caller = chan; } }

static int unload_module (  void   )  [static]

Definition at line 2339 of file res_features.c. References ast_cli_unregister_multiple(), ast_devstate_prov_del(), ast_manager_unregister(), ast_module_user_hangup_all, ast_unregister_application(), and cli_features. { ast_module_user_hangup_all(); ast_manager_unregister("ParkedCalls"); ast_manager_unregister("Park"); ast_cli_unregister_multiple(cli_features, sizeof(cli_features) / sizeof(struct ast_cli_entry)); ast_unregister_application(parkcall); ast_devstate_prov_del("Park"); return ast_unregister_application(parkedcall); }

static void unmap_features (  void   )  [static]

Definition at line 1005 of file res_features.c. References builtin_features, exten, and FEATURES_COUNT. { int x; for (x = 0; x < FEATURES_COUNT; x++) strcpy(builtin_features[x].exten, builtin_features[x].default_exten); }

---

Variable Documentation

int adsipark [static]

Definition at line 99 of file res_features.c.

int atxfernoanswertimeout [static]

Definition at line 105 of file res_features.c.

struct ast_call_feature builtin_features[]

Definition at line 870 of file res_features.c. Referenced by ast_feature_interpret(), ast_feature_request_and_dial(), handle_showfeatures(), remap_feature(), set_config_flags(), and unmap_features().

struct ast_cli_entry cli_features[] [static]

Definition at line 1932 of file res_features.c.

int comebacktoorigin = 1 [static]

Definition at line 103 of file res_features.c.

char courtesytone[256] [static]

Courtesy tone Definition at line 91 of file res_features.c.

char* descrip [static]

Initial value: "ParkedCall(exten):" "Used to connect to a parked call. This application is always\n" "registered internally and does not need to be explicitly added\n" "into the dialplan, although you should include the 'parkedcalls'\n" "context.\n" Definition at line 112 of file res_features.c.

char* descrip2 [static]

Definition at line 122 of file res_features.c.

int featuredigittimeout [static]

Definition at line 102 of file res_features.c.

char mandescr_park[] [static]

Definition at line 1983 of file res_features.c. Referenced by load_module().

struct ast_app* monitor_app = NULL [static]

Definition at line 133 of file res_features.c. Referenced by ast_bridge_call(), and builtin_automonitor().

int monitor_ok = 1 [static]

Definition at line 134 of file res_features.c.

int parkaddhints = 0 [static]

Add parking hints automatically Definition at line 80 of file res_features.c.

char* parkcall = "Park" [static]

Definition at line 118 of file res_features.c.

char* parkedcall = "ParkedCall" [static]

Definition at line 78 of file res_features.c.

int parkedcalltransfers = 0 [static]

Enable DTMF based transfers on bridge when picking up parked calls Definition at line 81 of file res_features.c.

int parkedplay = 0 [static]

Who to play the courtesy tone to Definition at line 92 of file res_features.c.

int parkfindnext [static]

Definition at line 97 of file res_features.c.

char parking_con[AST_MAX_EXTENSION] [static]

Context for which parking is made accessible Definition at line 83 of file res_features.c.

char parking_con_dial[AST_MAX_EXTENSION] [static]

Context for dialback for parking (KLUDGE) Definition at line 84 of file res_features.c.

char parking_ext[AST_MAX_EXTENSION] [static]

Extension you type to park the call Definition at line 85 of file res_features.c.

int parking_offset [static]

Definition at line 96 of file res_features.c.

int parking_start [static]

First available extension for parking Definition at line 88 of file res_features.c.

int parking_stop [static]

Last available extension for parking Definition at line 89 of file res_features.c.

pthread_t parking_thread [static]

Definition at line 155 of file res_features.c.

struct parkeduser* parkinglot [static]

Definition at line 151 of file res_features.c. Referenced by ast_park_call(), do_parking_thread(), handle_parkedcalls(), manager_parking_status(), and park_exec().

int parkingtime = DEFAULT_PARK_TIME [static]

No more than 45 seconds parked before you do something with them Definition at line 82 of file res_features.c.

char parkmohclass[MAX_MUSICCLASS] [static]

Music class used for parking Definition at line 87 of file res_features.c.

char pickup_ext[AST_MAX_EXTENSION] [static]

Call pickup extension Definition at line 86 of file res_features.c.

char* registrar = "res_features" [static]

Registrar for operations Definition at line 107 of file res_features.c.

char showfeatures_help[] [static]

Initial value: "Usage: feature list\n" " Lists currently configured features.\n" Definition at line 1900 of file res_features.c.

char showparked_help[] [static]

Initial value: "Usage: show parkedcalls\n" " Lists currently parked calls.\n" Definition at line 1928 of file res_features.c.

char* synopsis = "Answer a parked call" [static]

Definition at line 110 of file res_features.c.

char* synopsis2 = "Park yourself" [static]

Definition at line 120 of file res_features.c.

int transferdigittimeout [static]

Definition at line 101 of file res_features.c.

char xferfailsound[256] [static]

Call transfer failure sound Definition at line 94 of file