app_queue.c File Reference

True call queues with optional send URL on answer. More...

#include "asterisk.h"
#include <sys/time.h>
#include <signal.h>
#include <netinet/in.h>
#include <ctype.h>
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/say.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/config.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/astdb.h"
#include "asterisk/devicestate.h"
#include "asterisk/stringfields.h"
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/aoc.h"
#include "asterisk/callerid.h"
#include "asterisk/term.h"
#include "asterisk/dial.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/bridge_after.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/core_local.h"
#include "asterisk/mixmonitor.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/max_forwards.h"

Include dependency graph for app_queue.c:

Go to the source code of this file.

Data Structures
struct	autopause
struct	call_queue
struct	callattempt
	We define a custom "local user" structure because we use it not only for keeping track of what is in use but also for keeping track of who we're dialing. More...
struct	local_optimization
	Structure representing relevant data during a local channel optimization. More...
struct	member
struct	penalty_rule
struct	queue_end_bridge
struct	queue_ent
struct	queue_stasis_data
	User data for stasis subscriptions used for queue calls. More...
struct	rule_list
struct	rule_lists
struct	strategy

Macros
#define	ANNOUNCEHOLDTIME_ALWAYS   1
#define	ANNOUNCEHOLDTIME_ONCE   2
#define	ANNOUNCEPOSITION_LIMIT   4
#define	ANNOUNCEPOSITION_MORE_THAN   3
#define	ANNOUNCEPOSITION_NO   2
#define	ANNOUNCEPOSITION_YES   1
#define	AST_MAX_WATCHERS   256
#define	DEFAULT_MIN_ANNOUNCE_FREQUENCY   15
	The minimum number of seconds between position announcements. More...
#define	DEFAULT_RETRY   5
#define	DEFAULT_TIMEOUT   15
#define	MAX_CALL_ATTEMPT_BUCKETS   353
#define	MAX_PERIODIC_ANNOUNCEMENTS   10
#define	MAX_QUEUE_BUCKETS   53
#define	QUEUE_EVENT_VARIABLES   3
#define	QUEUE_PAUSED_DEVSTATE   AST_DEVICE_INUSE
#define	queue_ref(q)   ao2_bump(q)
#define	queue_t_ref(q, tag)   ao2_t_bump(q, tag)
#define	queue_t_unref(q, tag)   ({ ao2_t_cleanup(q, tag); NULL; })
#define	QUEUE_UNKNOWN_PAUSED_DEVSTATE   AST_DEVICE_NOT_INUSE
#define	QUEUE_UNPAUSED_DEVSTATE   AST_DEVICE_NOT_INUSE
#define	queue_unref(q)   ({ ao2_cleanup(q); NULL; })
#define	queues_t_link(c, q, tag)   ao2_t_link(c, q, tag)
#define	queues_t_unlink(c, q, tag)   ao2_t_unlink(c, q, tag)
#define	RECHECK   1
#define	RES_EXISTS   (-1)
#define	RES_NOSUCHQUEUE   (-3)
#define	RES_NOT_CALLER   (-5)
#define	RES_NOT_DYNAMIC   (-4)
#define	RES_OKAY   0
#define	RES_OUTOFMEMORY   (-2)

Enumerations
enum	{   OPT_MARK_AS_ANSWERED = (1 << 0) , OPT_GO_ON = (1 << 1) , OPT_DATA_QUALITY = (1 << 2) , OPT_CALLEE_GO_ON = (1 << 3) ,   OPT_CALLEE_HANGUP = (1 << 4) , OPT_CALLER_HANGUP = (1 << 5) , OPT_IGNORE_CALL_FW = (1 << 6) , OPT_IGNORE_CONNECTEDLINE = (1 << 7) ,   OPT_CALLEE_PARK = (1 << 8) , OPT_CALLER_PARK = (1 << 9) , OPT_NO_RETRY = (1 << 10) , OPT_RINGING = (1 << 11) ,   OPT_RING_WHEN_RINGING = (1 << 12) , OPT_CALLEE_TRANSFER = (1 << 13) , OPT_CALLER_TRANSFER = (1 << 14) , OPT_CALLEE_AUTOMIXMON = (1 << 15) ,   OPT_CALLER_AUTOMIXMON = (1 << 16) , OPT_CALLEE_AUTOMON = (1 << 17) , OPT_CALLER_AUTOMON = (1 << 18) , OPT_PREDIAL_CALLEE = (1 << 19) ,   OPT_PREDIAL_CALLER = (1 << 20) , OPT_MUSICONHOLD_CLASS = (1 << 21) }
enum	{   OPT_ARG_CALLEE_GO_ON = 0 , OPT_ARG_PREDIAL_CALLEE , OPT_ARG_PREDIAL_CALLER , OPT_ARG_MUSICONHOLD_CLASS ,   OPT_ARG_ARRAY_SIZE }
enum	{   QUEUE_STRATEGY_RINGALL = 0 , QUEUE_STRATEGY_LEASTRECENT , QUEUE_STRATEGY_FEWESTCALLS , QUEUE_STRATEGY_RANDOM ,   QUEUE_STRATEGY_RRMEMORY , QUEUE_STRATEGY_LINEAR , QUEUE_STRATEGY_WRANDOM , QUEUE_STRATEGY_RRORDERED }
enum	{ QUEUE_AUTOPAUSE_OFF = 0 , QUEUE_AUTOPAUSE_ON , QUEUE_AUTOPAUSE_ALL }
enum	agent_complete_reason { CALLER , AGENT , TRANSFER }
enum	aqm_args { AQM_OPT_ARG_PAUSE_REASON = 0 , AQM_OPT_ARG_ARRAY_SIZE }
enum	aqm_flags { AQMFLAG_PAUSED = (1 << 1) , AQMFLAG_REASON = (1 << 2) }
enum	empty_conditions {   QUEUE_EMPTY_PENALTY = (1 << 0) , QUEUE_EMPTY_PAUSED = (1 << 1) , QUEUE_EMPTY_INUSE = (1 << 2) , QUEUE_EMPTY_RINGING = (1 << 3) ,   QUEUE_EMPTY_UNAVAILABLE = (1 << 4) , QUEUE_EMPTY_INVALID = (1 << 5) , QUEUE_EMPTY_UNKNOWN = (1 << 6) , QUEUE_EMPTY_WRAPUP = (1 << 7) }
enum	member_properties { MEMBER_PENALTY = 0 , MEMBER_RINGINUSE = 1 }
enum	queue_reload_mask { QUEUE_RELOAD_PARAMETERS = (1 << 0) , QUEUE_RELOAD_MEMBER = (1 << 1) , QUEUE_RELOAD_RULES = (1 << 2) , QUEUE_RESET_STATS = (1 << 3) }
enum	queue_result {   QUEUE_UNKNOWN = 0 , QUEUE_TIMEOUT = 1 , QUEUE_JOINEMPTY = 2 , QUEUE_LEAVEEMPTY = 3 ,   QUEUE_JOINUNAVAIL = 4 , QUEUE_LEAVEUNAVAIL = 5 , QUEUE_FULL = 6 , QUEUE_CONTINUE = 7 ,   QUEUE_WITHDRAW = 8 }
enum	queue_timeout_priority { TIMEOUT_PRIORITY_APP , TIMEOUT_PRIORITY_CONF }

Functions
static char *	__queues_show (struct mansession *s, int fd, int argc, const char *const *argv)
	Show queue(s) status and statistics. More...
static void	__reg_module (void)
static void	__unreg_module (void)
static int	add_to_queue (const char *queuename, const char *interface, const char *membername, int penalty, int paused, int dump, const char *state_interface, const char *reason_paused, int wrapuptime)
	Add member to queue. More...
static struct call_queue *	alloc_queue (const char *queuename)
	AO2_STRING_FIELD_SORT_FN (call_queue, name)
static int	aqm_exec (struct ast_channel *chan, const char *data)
	AddQueueMember application. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	autopause2int (const char *autopause)
static int	calc_metric (struct call_queue *q, struct member *mem, int pos, struct queue_ent *qe, struct callattempt *tmp)
	Calculate the metric of each member in the outgoing callattempts. More...
static void	callattempt_free (struct callattempt *doomed)
static int	can_ring_entry (struct queue_ent *qe, struct callattempt *call)
static int	change_priority_caller_on_queue (const char *queuename, const char *caller, int priority, int immediate)
	Change priority caller into a queue. More...
static void	clear_queue (struct call_queue *q)
static int	clear_stats (const char *queuename)
	Facilitates resetting statistics for a queue. More...
static int	compare_weight (struct call_queue *rq, struct member *member)
static char *	complete_queue (const char *line, const char *word, int pos, int state, ptrdiff_t word_list_offset)
	Check if a given word is in a space-delimited list. More...
static char *	complete_queue_add_member (const char *line, const char *word, int pos, int state)
static char *	complete_queue_pause_member (const char *line, const char *word, int pos, int state)
static char *	complete_queue_remove_member (const char *line, const char *word, int pos, int state)
static char *	complete_queue_rule_show (const char *line, const char *word, int pos, int state)
static char *	complete_queue_set_member_value (const char *line, const char *word, int pos, int state)
static char *	complete_queue_show (const char *line, const char *word, int pos, int state)
static int	compress_char (const char c)
static int	context_included (const char *parent, const char *child)
	Returns if one context includes another context. More...
static void	copy_rules (struct queue_ent *qe, const char *rulename)
	Copy rule from global list into specified queue. More...
static struct member *	create_queue_member (const char *interface, const char *membername, int penalty, int paused, const char *state_interface, int ringinuse, int wrapuptime)
	allocate space for new queue member and set fields based on parameters passed More...
static void	destroy_queue (void *obj)
	Free queue's member list then its string fields. More...
static void	destroy_queue_member_cb (void *obj)
static void	device_state_cb (void *unused, struct stasis_subscription *sub, struct stasis_message *msg)
	set a member's status based on device state of that member's interface More...
static void	do_hang (struct callattempt *o)
	common hangup actions More...
static void	do_print (struct mansession *s, int fd, const char *str)
	direct output to manager or cli with proper terminator More...
static void	dump_queue_members (struct call_queue *pm_queue)
	Dump all members in a specific queue to the database. More...
static void	end_bridge_callback (void *data)
static void	end_bridge_callback_data_fixup (struct ast_bridge_config *bconfig, struct ast_channel *originator, struct ast_channel *terminator)
static void	escape_and_substitute (struct ast_channel *chan, const char *input, char *output, size_t size)
static int	extension_state_cb (const char *context, const char *exten, struct ast_state_cb_info *info, void *data)
static int	extensionstate2devicestate (int state)
	Helper function which converts from extension state to device state values. More...
static struct callattempt *	find_best (struct callattempt *outgoing)
	find the entry with the best metric, or NULL More...
static struct call_queue *	find_load_queue_rt_friendly (const char *queuename)
static struct member *	find_member_by_queuename_and_interface (const char *queuename, const char *interface)
	Find a member by looking up queuename and interface. More...
static struct call_queue *	find_queue_by_name_rt (const char *queuename, struct ast_variable *queue_vars, struct ast_config *member_config)
	Reload a single queue via realtime. More...
static void	free_members (struct call_queue *q, int all)
	Iterate through queue's member list and delete them. More...
static struct member *	get_interface_helper (struct call_queue *q, const char *interface)
static int	get_member_penalty (char *queuename, char *interface)
	Gets members penalty. More...
static int	get_member_status (struct call_queue *q, int max_penalty, int min_penalty, int raise_penalty, enum empty_conditions conditions, int devstate, int raise_respect_min)
	Check if members are available. More...
static int	get_queue_member_status (struct member *cur)
	Return the current state of a member. More...
static int	get_wrapuptime (struct call_queue *q, struct member *member)
	Return wrapuptime. More...
static void	handle_attended_transfer (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
	Handle an attended transfer event. More...
static void	handle_blind_transfer (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
	Handle a blind transfer event. More...
static void	handle_bridge_enter (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	handle_hangup (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	handle_local_optimization_begin (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	handle_local_optimization_end (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	handle_masquerade (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static char *	handle_queue_add_member (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_change_priority_caller (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_pause_member (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_remove_member (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_reset (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_rule_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_set_member_penalty (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_queue_set_member_ringinuse (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	hangupcalls (struct queue_ent *qe, struct callattempt *outgoing, struct ast_channel *exception, int cancel_answered_elsewhere)
	Hang up a list of outgoing calls. More...
static void	init_queue (struct call_queue *q)
	Initialize Queue default values. More...
static void	insert_entry (struct call_queue *q, struct queue_ent *prev, struct queue_ent *new, int *pos)
	Insert the 'new' entry after the 'prev' entry of queue 'q'. More...
static int	insert_penaltychange (const char *list_name, const char *content, const int linenum)
	Change queue penalty by adding rule. More...
static const char *	int2strat (int strategy)
static struct member *	interface_exists (struct call_queue *q, const char *interface)
static int	is_longest_waiting_caller (struct queue_ent *caller, struct member *member)
static int	is_member_available (struct call_queue *q, struct member *mem)
static int	is_our_turn (struct queue_ent *qe)
	Check if we should start attempting to call queue members. More...
static int	join_queue (char *queuename, struct queue_ent *qe, enum queue_result *reason, int position)
static int	kill_dead_members (void *obj, void *arg, int flags)
static int	kill_if_unfound (void *obj, void *arg, int flags)
static void	leave_queue (struct queue_ent *qe)
	Caller leaving queue. More...
static int	load_module (void)
	Load the module. More...
static void	load_realtime_queues (const char *queuename)
static int	load_realtime_rules (void)
	Load queue rules from realtime. More...
static void	log_attended_transfer (struct queue_stasis_data *queue_data, struct ast_attended_transfer_message *atxfer_msg)
static int	manager_add_queue_member (struct mansession *s, const struct message *m)
static int	manager_change_priority_caller_on_queue (struct mansession *s, const struct message *m)
static int	manager_pause_queue_member (struct mansession *s, const struct message *m)
static int	manager_queue_log_custom (struct mansession *s, const struct message *m)
static int	manager_queue_member_penalty (struct mansession *s, const struct message *m)
static int	manager_queue_member_ringinuse (struct mansession *s, const struct message *m)
static int	manager_queue_reload (struct mansession *s, const struct message *m)
static int	manager_queue_reset (struct mansession *s, const struct message *m)
static int	manager_queue_rule_show (struct mansession *s, const struct message *m)
static int	manager_queues_status (struct mansession *s, const struct message *m)
	Queue status info via AMI. More...
static int	manager_queues_summary (struct mansession *s, const struct message *m)
	Summary of queue info via the AMI. More...
static int	manager_remove_queue_member (struct mansession *s, const struct message *m)
static int	manager_request_withdraw_caller_from_queue (struct mansession *s, const struct message *m)
static int	mark_member_dead (void *obj, void *arg, int flags)
static int	mark_unfound (void *obj, void *arg, int flags)
static void	member_add_to_queue (struct call_queue *queue, struct member *mem)
static int	member_cmp_fn (void *obj1, void *obj2, int flags)
static int	member_hash_fn (const void *obj, const int flags)
static void	member_remove_from_queue (struct call_queue *queue, struct member *mem)
static int	member_status_available (int status)
static int	num_available_members (struct call_queue *q)
	Get the number of members available to accept a call. More...
static void	parse_empty_options (const char *value, enum empty_conditions *empty, int joinempty)
static int	pending_members_cmp (void *obj, void *arg, int flags)
static int	pending_members_hash (const void *obj, const int flags)
static void	pending_members_remove (struct member *mem)
static int	play_file (struct ast_channel *chan, const char *filename)
static int	pqm_exec (struct ast_channel *chan, const char *data)
	PauseQueueMember application. More...
static void	print_queue (struct mansession *s, int fd, struct call_queue *q)
	Print a single queue to AMI or the CLI. More...
static void	publish_dial_end_event (struct ast_channel *in, struct callattempt *outgoing, struct ast_channel *exception, const char *status)
static int	publish_queue_member_pause (struct call_queue *q, struct member *member)
static int	ql_exec (struct ast_channel *chan, const char *data)
	QueueLog application. More...
static struct ast_manager_event_blob *	queue_agent_called_to_ami (struct stasis_message *message)
static void	queue_agent_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static struct ast_manager_event_blob *	queue_agent_complete_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_agent_connect_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_agent_dump_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_agent_ringnoanswer_to_ami (struct stasis_message *message)
static void	queue_bridge_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static struct ast_manager_event_blob *	queue_caller_abandon_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_caller_join_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_caller_leave_to_ami (struct stasis_message *message)
static void	queue_channel_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static struct ast_manager_event_blob *	queue_channel_to_ami (const char *type, struct stasis_message *message)
static int	queue_cmp_cb (void *obj, void *arg, int flags)
static int	queue_delme_members_decrement_followers (void *obj, void *arg, int flag)
static int	queue_exec (struct ast_channel *chan, const char *data)
	The starting point for all queue calls. More...
static int	queue_function_exists (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Check if a given queue exists. More...
static int	queue_function_mem_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Get number either busy / free / ready or total members of a specific queue. More...
static int	queue_function_mem_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Dialplan function QUEUE_MEMBER() Sets the members penalty / paused / ringinuse. More...
static int	queue_function_memberpenalty_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Dialplan function QUEUE_MEMBER_PENALTY() Gets the members penalty. More...
static int	queue_function_memberpenalty_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Dialplan function QUEUE_MEMBER_PENALTY() Sets the members penalty. More...
static int	queue_function_queuegetchannel (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Dialplan function QUEUE_GET_CHANNEL() Get caller channel waiting at specified position in the queue. More...
static int	queue_function_queuememberlist (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Dialplan function QUEUE_MEMBER_LIST() Get list of members in a specific queue. More...
static int	queue_function_queuewaitingcount (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	Dialplan function QUEUE_WAITING_COUNT() Get number callers waiting in a specific queue. More...
static int	queue_function_var (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	create interface var with all queue details. More...
static int	queue_hash_cb (const void *obj, const int flags)
static struct ast_manager_event_blob *	queue_member_added_to_ami (struct stasis_message *message)
static struct ast_json *	queue_member_blob_create (struct call_queue *q, struct member *mem)
static int	queue_member_decrement_followers (void *obj, void *arg, int flag)
static void	queue_member_follower_removal (struct call_queue *queue, struct member *mem)
static struct ast_manager_event_blob *	queue_member_pause_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_member_penalty_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_member_removed_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_member_ringinuse_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_member_status_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	queue_member_to_ami (const char *type, struct stasis_message *message)
static struct ast_manager_event_blob *	queue_multi_channel_to_ami (const char *type, struct stasis_message *message)
static void	queue_publish_member_blob (struct stasis_message_type *type, struct ast_json *blob)
static void	queue_publish_multi_channel_blob (struct ast_channel *caller, struct ast_channel *agent, struct stasis_message_type *type, struct ast_json *blob)
static void	queue_publish_multi_channel_snapshot_blob (struct stasis_topic *topic, struct ast_channel_snapshot *caller_snapshot, struct ast_channel_snapshot *agent_snapshot, struct stasis_message_type *type, struct ast_json *blob)
static void	queue_reset_global_params (void)
static void	queue_rules_reset_global_params (void)
static void	queue_rules_set_global_params (struct ast_config *cfg)
static void	queue_set_global_params (struct ast_config *cfg)
static void	queue_set_param (struct call_queue *q, const char *param, const char *val, int linenum, int failunknown)
	Configure a queue parameter. More...
static char *	queue_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct queue_stasis_data *	queue_stasis_data_alloc (struct queue_ent *qe, struct ast_channel *peer, struct member *mem, time_t holdstart, time_t starttime, int callcompletedinsl)
static void	queue_stasis_data_destructor (void *obj)
static int	qupd_exec (struct ast_channel *chan, const char *data)
	Update Queue with data of an outgoing call. More...
static void	recalc_holdtime (struct queue_ent *qe, int newholdtime)
static void	record_abandoned (struct queue_ent *qe)
	Record that a caller gave up on waiting in queue. More...
static int	reload (void)
static int	reload_handler (int reload, struct ast_flags *mask, const char *queuename)
	The command center for all reload operations. More...
static void	reload_queue_members (void)
	Reload dynamic queue members persisted into the astdb. More...
static int	reload_queue_rules (int reload)
	Reload the rules defined in queuerules.conf. More...
static int	reload_queues (int reload, struct ast_flags *mask, const char *queuename)
	reload the queues.conf file More...
static void	reload_single_member (const char *memberdata, struct call_queue *q)
	reload information pertaining to a single member More...
static void	reload_single_queue (struct ast_config *cfg, struct ast_flags *mask, const char *queuename)
	Reload information pertaining to a particular queue. More...
static int	remove_from_queue (const char *queuename, const char *interface)
	Remove member from queue. More...
static void	remove_stasis_subscriptions (struct queue_stasis_data *queue_data)
static int	request_withdraw_caller_from_queue (const char *queuename, const char *caller, const char *withdraw_info)
	Request to withdraw a caller from a queue. More...
static int	ring_entry (struct queue_ent *qe, struct callattempt *tmp, int *busies)
	Part 2 of ring_one. More...
static int	ring_one (struct queue_ent *qe, struct callattempt *outgoing, int *busies)
	Place a call to a queue member. More...
static void	rna (int rnatime, struct queue_ent *qe, struct ast_channel *peer, char *interface, char *membername, int autopause)
	RNA == Ring No Answer. Common code that is executed when we try a queue member and they don't answer. More...
static int	rqm_exec (struct ast_channel *chan, const char *data)
	RemoveQueueMember application. More...
static void	rt_handle_member_record (struct call_queue *q, char *category, struct ast_config *member_config)
	Find rt member record to update otherwise create one. More...
static int	say_periodic_announcement (struct queue_ent *qe, int ringing)
	Playback announcement to queued members if period has elapsed. More...
static int	say_position (struct queue_ent *qe, int ringing)
static void	send_agent_complete (const char *queuename, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const struct member *member, time_t holdstart, time_t callstart, enum agent_complete_reason rsn)
	Send out AMI message with member call completion status information. More...
static int	set_member_paused (const char *queuename, const char *interface, const char *reason, int paused)
static int	set_member_penalty_help_members (struct call_queue *q, const char *interface, int penalty)
static int	set_member_ringinuse_help_members (struct call_queue *q, const char *interface, int ringinuse)
static int	set_member_value (const char *queuename, const char *interface, int property, int value)
static int	set_member_value_help_members (struct call_queue *q, const char *interface, int property, int value)
static void	set_queue_member_pause (struct call_queue *q, struct member *mem, const char *reason, int paused)
static void	set_queue_member_ringinuse (struct call_queue *q, struct member *mem, int ringinuse)
static void	set_queue_result (struct ast_channel *chan, enum queue_result res)
	sets the QUEUESTATUS channel variable More...
static void	set_queue_variables (struct call_queue *q, struct ast_channel *chan)
	Set variables of queue. More...
static void	setup_mixmonitor (struct queue_ent *qe, const char *filename)
static void	setup_peer_after_bridge_goto (struct ast_channel *chan, struct ast_channel *peer, struct ast_flags *opts, char *opt_args[])
static int	setup_stasis_subs (struct queue_ent *qe, struct ast_channel *peer, struct member *mem, time_t holdstart, time_t starttime, int callcompletedinsl)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_called_type,.to_ami=queue_agent_called_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_complete_type,.to_ami=queue_agent_complete_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_connect_type,.to_ami=queue_agent_connect_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_dump_type,.to_ami=queue_agent_dump_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_ringnoanswer_type,.to_ami=queue_agent_ringnoanswer_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_caller_abandon_type,.to_ami=queue_caller_abandon_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_caller_join_type,.to_ami=queue_caller_join_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_caller_leave_type,.to_ami=queue_caller_leave_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_added_type,.to_ami=queue_member_added_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_pause_type,.to_ami=queue_member_pause_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_penalty_type,.to_ami=queue_member_penalty_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_removed_type,.to_ami=queue_member_removed_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_ringinuse_type,.to_ami=queue_member_ringinuse_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_status_type,.to_ami=queue_member_status_to_ami,)
static int	store_next_lin (struct queue_ent *qe, struct callattempt *outgoing)
	Search for best metric and add to Linear queue. More...
static int	store_next_rr (struct queue_ent *qe, struct callattempt *outgoing)
	Search for best metric and add to Round Robbin queue. More...
static int	strat2int (const char *strategy)
static int	try_calling (struct queue_ent *qe, struct ast_flags opts, char **opt_args, char *announceoverride, const char *url, int *tries, int *noption, const char *agi, const char *gosub, int ringing)
static int	unload_module (void)
static void	update_connected_line_from_peer (struct ast_channel *chan, struct ast_channel *peer, int is_caller)
static void	update_qe_rule (struct queue_ent *qe)
	update rules for queues More...
static int	update_queue (struct call_queue *q, struct member *member, int callcompletedinsl, time_t starttime)
	update the queue status More...
static int	update_realtime_member_field (struct member *mem, const char *queue_name, const char *field, const char *value)
static void	update_realtime_members (struct call_queue *q)
static void	update_status (struct call_queue *q, struct member *m, const int status)
	set a member's status based on device state of that member's state_interface. More...
static int	upqm_exec (struct ast_channel *chan, const char *data)
	UnpauseQueueMember application. More...
static int	valid_exit (struct queue_ent *qe, char digit)
	Check for valid exit from queue via goto. More...
static int	wait_a_bit (struct queue_ent *qe)
static struct callattempt *	wait_for_answer (struct queue_ent *qe, struct callattempt *outgoing, int *to, char *digit, int prebusies, int caller_disconnect, int forwardsallowed)
	Wait for a member to answer the call. More...
static int	wait_our_turn (struct queue_ent *qe, int ringing, enum queue_result *reason)
	The waiting areas for callers who are not actively calling members. More...
static int	word_in_list (const char *list, const char *word)
	Check if a given word is in a space-delimited list. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "True Call Queueing" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_CONSUMER, }
static struct stasis_message_router *	agent_router
static char *	app = "Queue"
static char *	app_aqm = "AddQueueMember"
static char *	app_pqm = "PauseQueueMember"
static char *	app_ql = "QueueLog"
static char *	app_qupd = "QueueUpdate"
static char *	app_rqm = "RemoveQueueMember"
static char *	app_upqm = "UnpauseQueueMember"
static const struct ast_app_option	aqm_opts [128] = { [ 'p' ] = { .flag = AQMFLAG_PAUSED }, [ 'r' ] = { .flag = AQMFLAG_REASON , .arg_index = AQM_OPT_ARG_PAUSE_REASON + 1 }, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static int	autofill_default
	queues.conf [general] option More...
static const struct autopause	autopausesmodes []
static struct ast_cli_entry	cli_queue []
static struct stasis_subscription *	device_state_sub
	Subscription to device state change messages. More...
static int	force_longest_waiting_caller
	queues.conf [general] option More...
static int	log_caller_id_name
	queues.conf [general] option More...
static int	log_membername_as_agent
	queues.conf [general] option More...
static int	montype_default
	queues.conf [general] option More...
static int	negative_penalty_invalid
	queues.conf [general] option More...
static struct ao2_container *	pending_members
static const char *const	pm_family = "Queue/PersistentMembers"
	Persistent Members astdb family. More...
static const struct ast_app_option	queue_exec_options [128] = { [ 'b' ] = { .flag = OPT_PREDIAL_CALLEE , .arg_index = OPT_ARG_PREDIAL_CALLEE + 1 }, [ 'B' ] = { .flag = OPT_PREDIAL_CALLER , .arg_index = OPT_ARG_PREDIAL_CALLER + 1 }, [ 'C' ] = { .flag = OPT_MARK_AS_ANSWERED }, [ 'c' ] = { .flag = OPT_GO_ON }, [ 'd' ] = { .flag = OPT_DATA_QUALITY }, [ 'F' ] = { .flag = OPT_CALLEE_GO_ON , .arg_index = OPT_ARG_CALLEE_GO_ON + 1 }, [ 'h' ] = { .flag = OPT_CALLEE_HANGUP }, [ 'H' ] = { .flag = OPT_CALLER_HANGUP }, [ 'i' ] = { .flag = OPT_IGNORE_CALL_FW }, [ 'I' ] = { .flag = OPT_IGNORE_CONNECTEDLINE }, [ 'k' ] = { .flag = OPT_CALLEE_PARK }, [ 'K' ] = { .flag = OPT_CALLER_PARK }, [ 'm' ] = { .flag = OPT_MUSICONHOLD_CLASS , .arg_index = OPT_ARG_MUSICONHOLD_CLASS + 1 }, [ 'n' ] = { .flag = OPT_NO_RETRY }, [ 'r' ] = { .flag = OPT_RINGING }, [ 'R' ] = { .flag = OPT_RING_WHEN_RINGING }, [ 't' ] = { .flag = OPT_CALLEE_TRANSFER }, [ 'T' ] = { .flag = OPT_CALLER_TRANSFER }, [ 'x' ] = { .flag = OPT_CALLEE_AUTOMIXMON }, [ 'X' ] = { .flag = OPT_CALLER_AUTOMIXMON }, [ 'w' ] = { .flag = OPT_CALLEE_AUTOMON }, [ 'W' ] = { .flag = OPT_CALLER_AUTOMON }, }
static int	queue_persistent_members
	queues.conf [general] option More...
struct {
enum queue_result   id
char *   text
}	queue_results []
static struct ast_custom_function	queueexists_function
static struct ast_custom_function	queuegetchannel_function
static struct ast_custom_function	queuemembercount_function
static struct ast_custom_function	queuememberlist_function
static struct ast_custom_function	queuememberpenalty_function
static struct ao2_container *	queues
static struct ast_custom_function	queuevar_function
static struct ast_custom_function	queuewaitingcount_function
static int	realtime_reason_paused
	does realtime backend support reason_paused More...
static char *	realtime_ringinuse_field
	name of the ringinuse field in the realtime database More...
static int	realtime_rules
	queuerules.conf [general] option More...
static struct rule_lists	rule_lists = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static int	shared_lastcall
	queues.conf [general] option More...
static const struct strategy	strategies []
static struct stasis_forward *	topic_forwarder
static int	use_weight
	Records that one or more queues use weight. More...

Detailed Description

True call queues with optional send URL on answer.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Development notes

Note

2004-11-25: Persistent Dynamic Members added by: NetNation Communications (www.netnation.com) Kevin Lindsay kevin.nosp@m.l@ne.nosp@m.tnati.nosp@m.on.c.nosp@m.om

Each dynamic agent in each queue is now stored in the astdb. When asterisk is restarted, each agent will be automatically readded into their recorded queues. This feature can be configured with the 'persistent_members=<1|0>' setting in the '[general]' category in queues.conf. The default is on.

Note

2004-06-04: Priorities in queues added by inAccess Networks (work funded by Hellas On Line (HOL) www.hol.gr).

These features added by David C. Troy dave@.nosp@m.toad.nosp@m..net:

• Per-queue holdtime calculation
• Estimated holdtime announcement
• Position announcement
• Abandoned/completed call counters
• Failout timer passed as optional app parameter

Patch Version 1.07 2003-12-24 01

Added servicelevel statistic by Michiel Betel michi.nosp@m.el@b.nosp@m.etel..nosp@m.nl Added Priority jumping code for adding and removing queue members by Jonathan Stanton aster.nosp@m.isk@.nosp@m.doilo.nosp@m.okli.nosp@m.keica.nosp@m.re.c.nosp@m.om

Fixed to work with CVS as of 2004-02-25 and released as 1.07a by Matthew Enger m.eng.nosp@m.er@x.nosp@m.i.com.nosp@m..au

Definition in file app_queue.c.

Macro Definition Documentation

ANNOUNCEHOLDTIME_ALWAYS

#define ANNOUNCEHOLDTIME_ALWAYS   1

Definition at line 1898 of file app_queue.c.

ANNOUNCEHOLDTIME_ONCE

#define ANNOUNCEHOLDTIME_ONCE   2

Definition at line 1899 of file app_queue.c.

ANNOUNCEPOSITION_LIMIT

#define ANNOUNCEPOSITION_LIMIT   4

We not announce position more than <limit>

Definition at line 1917 of file app_queue.c.

ANNOUNCEPOSITION_MORE_THAN

#define ANNOUNCEPOSITION_MORE_THAN   3

We say "Currently there are more than <limit>"

Definition at line 1916 of file app_queue.c.

ANNOUNCEPOSITION_NO

#define ANNOUNCEPOSITION_NO   2

We don't announce position

Definition at line 1915 of file app_queue.c.

ANNOUNCEPOSITION_YES

#define ANNOUNCEPOSITION_YES   1

We announce position

Definition at line 1914 of file app_queue.c.

AST_MAX_WATCHERS

#define AST_MAX_WATCHERS   256

Definition at line 5339 of file app_queue.c.

DEFAULT_MIN_ANNOUNCE_FREQUENCY

#define DEFAULT_MIN_ANNOUNCE_FREQUENCY   15

The minimum number of seconds between position announcements.

Note

The default value of 15 provides backwards compatibility.

Definition at line 1684 of file app_queue.c.

DEFAULT_RETRY

#define DEFAULT_RETRY   5

Definition at line 1676 of file app_queue.c.

DEFAULT_TIMEOUT

#define DEFAULT_TIMEOUT   15

Definition at line 1677 of file app_queue.c.

MAX_CALL_ATTEMPT_BUCKETS

#define MAX_CALL_ATTEMPT_BUCKETS   353

Definition at line 2647 of file app_queue.c.

MAX_PERIODIC_ANNOUNCEMENTS

#define MAX_PERIODIC_ANNOUNCEMENTS   10

The maximum periodic announcements we can have

Definition at line 1679 of file app_queue.c.

MAX_QUEUE_BUCKETS

#define MAX_QUEUE_BUCKETS   53

Definition at line 1686 of file app_queue.c.

QUEUE_EVENT_VARIABLES

#define QUEUE_EVENT_VARIABLES   3

Definition at line 1900 of file app_queue.c.

QUEUE_PAUSED_DEVSTATE

#define QUEUE_PAUSED_DEVSTATE   AST_DEVICE_INUSE

Definition at line 3684 of file app_queue.c.

queue_ref

#define queue_ref

(

q

)

ao2_bump(q)

Definition at line 2183 of file app_queue.c.

queue_t_ref

#define queue_t_ref	(		q,
			tag
	)		ao2_t_bump(q, tag)

Definition at line 2185 of file app_queue.c.

queue_t_unref

#define queue_t_unref	(		q,
			tag
	)		({ ao2_t_cleanup(q, tag); NULL; })

Definition at line 2186 of file app_queue.c.

QUEUE_UNKNOWN_PAUSED_DEVSTATE

#define QUEUE_UNKNOWN_PAUSED_DEVSTATE   AST_DEVICE_NOT_INUSE

Definition at line 3686 of file app_queue.c.

QUEUE_UNPAUSED_DEVSTATE

#define QUEUE_UNPAUSED_DEVSTATE   AST_DEVICE_NOT_INUSE

Definition at line 3685 of file app_queue.c.

queue_unref

#define queue_unref

(

q

)

({ ao2_cleanup(q); NULL; })

Definition at line 2184 of file app_queue.c.

queues_t_link

#define queues_t_link	(		c,
			q,
			tag
	)		ao2_t_link(c, q, tag)

Definition at line 2187 of file app_queue.c.

queues_t_unlink

#define queues_t_unlink	(		c,
			q,
			tag
	)		ao2_t_unlink(c, q, tag)

Definition at line 2188 of file app_queue.c.

RECHECK

#define RECHECK   1

Recheck every second to see we we're at the top yet

Definition at line 1678 of file app_queue.c.

RES_EXISTS

#define RES_EXISTS   (-1)

Entry already exists

Definition at line 1689 of file app_queue.c.

RES_NOSUCHQUEUE

#define RES_NOSUCHQUEUE   (-3)

No such queue

Definition at line 1691 of file app_queue.c.

RES_NOT_CALLER

#define RES_NOT_CALLER   (-5)

Caller not found

Definition at line 1693 of file app_queue.c.

RES_NOT_DYNAMIC

#define RES_NOT_DYNAMIC   (-4)

Member is not dynamic

Definition at line 1692 of file app_queue.c.

RES_OKAY

#define RES_OKAY   0

Action completed

Definition at line 1688 of file app_queue.c.

RES_OUTOFMEMORY

#define RES_OUTOFMEMORY   (-2)

Out of memory

Definition at line 1690 of file app_queue.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Please read before modifying this file.

There are three locks which are regularly used throughout this file, the queue list lock, the lock for each individual queue, and the interface list lock. Please be extra careful to always lock in the following order 1) queue list lock 2) individual queue lock 3) interface list lock This order has sort of "evolved" over the lifetime of this application, but it is now in place this way, so please adhere to this order!

Enumerator
OPT_MARK_AS_ANSWERED
OPT_GO_ON
OPT_DATA_QUALITY
OPT_CALLEE_GO_ON
OPT_CALLEE_HANGUP
OPT_CALLER_HANGUP
OPT_IGNORE_CALL_FW
OPT_IGNORE_CONNECTEDLINE
OPT_CALLEE_PARK
OPT_CALLER_PARK
OPT_NO_RETRY
OPT_RINGING
OPT_RING_WHEN_RINGING
OPT_CALLEE_TRANSFER
OPT_CALLER_TRANSFER
OPT_CALLEE_AUTOMIXMON
OPT_CALLER_AUTOMIXMON
OPT_CALLEE_AUTOMON
OPT_CALLER_AUTOMON
OPT_PREDIAL_CALLEE
OPT_PREDIAL_CALLER
OPT_MUSICONHOLD_CLASS

Definition at line 1553 of file app_queue.c.

     {
    OPT_MARK_AS_ANSWERED =       (1 << 0),
    OPT_GO_ON =                  (1 << 1),
    OPT_DATA_QUALITY =           (1 << 2),
    OPT_CALLEE_GO_ON =           (1 << 3),
    OPT_CALLEE_HANGUP =          (1 << 4),
    OPT_CALLER_HANGUP =          (1 << 5),
    OPT_IGNORE_CALL_FW =         (1 << 6),
    OPT_IGNORE_CONNECTEDLINE =   (1 << 7),
    OPT_CALLEE_PARK =            (1 << 8),
    OPT_CALLER_PARK =            (1 << 9),
    OPT_NO_RETRY =               (1 << 10),
    OPT_RINGING =                (1 << 11),
    OPT_RING_WHEN_RINGING =      (1 << 12),
    OPT_CALLEE_TRANSFER =        (1 << 13),
    OPT_CALLER_TRANSFER =        (1 << 14),
    OPT_CALLEE_AUTOMIXMON =      (1 << 15),
    OPT_CALLER_AUTOMIXMON =      (1 << 16),
    OPT_CALLEE_AUTOMON =         (1 << 17),
    OPT_CALLER_AUTOMON =         (1 << 18),
    OPT_PREDIAL_CALLEE =         (1 << 19),
    OPT_PREDIAL_CALLER =         (1 << 20),
    OPT_MUSICONHOLD_CLASS =      (1 << 21),
};

anonymous enum

anonymous enum

Enumerator
OPT_ARG_CALLEE_GO_ON
OPT_ARG_PREDIAL_CALLEE
OPT_ARG_PREDIAL_CALLER
OPT_ARG_MUSICONHOLD_CLASS
OPT_ARG_ARRAY_SIZE

Definition at line 1578 of file app_queue.c.

     {
    OPT_ARG_CALLEE_GO_ON = 0,
    OPT_ARG_PREDIAL_CALLEE,
    OPT_ARG_PREDIAL_CALLER,
    OPT_ARG_MUSICONHOLD_CLASS,
    /* note: this entry _MUST_ be the last one in the enum */
    OPT_ARG_ARRAY_SIZE
};

anonymous enum

anonymous enum

Enumerator
QUEUE_STRATEGY_RINGALL
QUEUE_STRATEGY_LEASTRECENT
QUEUE_STRATEGY_FEWESTCALLS
QUEUE_STRATEGY_RANDOM
QUEUE_STRATEGY_RRMEMORY
QUEUE_STRATEGY_LINEAR
QUEUE_STRATEGY_WRANDOM
QUEUE_STRATEGY_RRORDERED

Definition at line 1628 of file app_queue.c.

     {
    QUEUE_STRATEGY_RINGALL = 0,
    QUEUE_STRATEGY_LEASTRECENT,
    QUEUE_STRATEGY_FEWESTCALLS,
    QUEUE_STRATEGY_RANDOM,
    QUEUE_STRATEGY_RRMEMORY,
    QUEUE_STRATEGY_LINEAR,
    QUEUE_STRATEGY_WRANDOM,
    QUEUE_STRATEGY_RRORDERED,
};

anonymous enum

anonymous enum

Enumerator
QUEUE_AUTOPAUSE_OFF
QUEUE_AUTOPAUSE_ON
QUEUE_AUTOPAUSE_ALL

Definition at line 1639 of file app_queue.c.

     {
    QUEUE_AUTOPAUSE_OFF = 0,
    QUEUE_AUTOPAUSE_ON,
    QUEUE_AUTOPAUSE_ALL
};

agent_complete_reason

enum agent_complete_reason

Enumerator
CALLER
AGENT
TRANSFER

Definition at line 6270 of file app_queue.c.

                           {
    CALLER,
    AGENT,
    TRANSFER
};

aqm_args

enum aqm_args

Enumerator
AQM_OPT_ARG_PAUSE_REASON
AQM_OPT_ARG_ARRAY_SIZE

Definition at line 1618 of file app_queue.c.

              {
    AQM_OPT_ARG_PAUSE_REASON = 0,
    AQM_OPT_ARG_ARRAY_SIZE, /* Always last element of the enum */
};

aqm_flags

enum aqm_flags

Enumerator
AQMFLAG_PAUSED
AQMFLAG_REASON

Definition at line 1613 of file app_queue.c.

               {
    AQMFLAG_PAUSED = (1 << 1),
    AQMFLAG_REASON = (1 << 2),
};

empty_conditions

enum empty_conditions

Enumerator
QUEUE_EMPTY_PENALTY
QUEUE_EMPTY_PAUSED
QUEUE_EMPTY_INUSE
QUEUE_EMPTY_RINGING
QUEUE_EMPTY_UNAVAILABLE
QUEUE_EMPTY_INVALID
QUEUE_EMPTY_UNKNOWN
QUEUE_EMPTY_WRAPUP

Definition at line 1881 of file app_queue.c.

                      {
    QUEUE_EMPTY_PENALTY = (1 << 0),
    QUEUE_EMPTY_PAUSED = (1 << 1),
    QUEUE_EMPTY_INUSE = (1 << 2),
    QUEUE_EMPTY_RINGING = (1 << 3),
    QUEUE_EMPTY_UNAVAILABLE = (1 << 4),
    QUEUE_EMPTY_INVALID = (1 << 5),
    QUEUE_EMPTY_UNKNOWN = (1 << 6),
    QUEUE_EMPTY_WRAPUP = (1 << 7),
};

member_properties

enum member_properties

Enumerator
MEMBER_PENALTY
MEMBER_RINGINUSE

Definition at line 1892 of file app_queue.c.

                       {
    MEMBER_PENALTY = 0,
    MEMBER_RINGINUSE = 1,
};

queue_reload_mask

enum queue_reload_mask

Enumerator
QUEUE_RELOAD_PARAMETERS
QUEUE_RELOAD_MEMBER
QUEUE_RELOAD_RULES
QUEUE_RESET_STATS

Definition at line 1645 of file app_queue.c.

                       {
    QUEUE_RELOAD_PARAMETERS = (1 << 0),
    QUEUE_RELOAD_MEMBER = (1 << 1),
    QUEUE_RELOAD_RULES = (1 << 2),
    QUEUE_RESET_STATS = (1 << 3),
};

queue_result

enum queue_result

Enumerator
QUEUE_UNKNOWN
QUEUE_TIMEOUT
QUEUE_JOINEMPTY
QUEUE_LEAVEEMPTY
QUEUE_JOINUNAVAIL
QUEUE_LEAVEUNAVAIL
QUEUE_FULL
QUEUE_CONTINUE
QUEUE_WITHDRAW

Definition at line 1751 of file app_queue.c.

                  {
    QUEUE_UNKNOWN = 0,
    QUEUE_TIMEOUT = 1,
    QUEUE_JOINEMPTY = 2,
    QUEUE_LEAVEEMPTY = 3,
    QUEUE_JOINUNAVAIL = 4,
    QUEUE_LEAVEUNAVAIL = 5,
    QUEUE_FULL = 6,
    QUEUE_CONTINUE = 7,
    QUEUE_WITHDRAW = 8,
};

queue_timeout_priority

enum queue_timeout_priority

Enumerator
TIMEOUT_PRIORITY_APP
TIMEOUT_PRIORITY_CONF

Definition at line 1778 of file app_queue.c.

                            {
    TIMEOUT_PRIORITY_APP,
    TIMEOUT_PRIORITY_CONF,
};

Function Documentation

__queues_show()

static char * __queues_show ( struct mansession *  s, int  fd, int  argc, const char *const *  argv  )

static

Show queue(s) status and statistics.

List the queues strategy, calls processed, members logged in, other queue statistics such as avg hold time.

Definition at line 10302 of file app_queue.c.

{
    struct call_queue *q;
    struct ast_str *out = ast_str_alloca(512);
    struct ao2_container *sorted_queues;
 
    struct ao2_iterator queue_iter;
    int found = 0;
 
    if (argc != 2 && argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    if (argc == 3)  { /* specific queue */
        if ((q = find_load_queue_rt_friendly(argv[2]))) {
            ao2_lock(q);
            print_queue(s, fd, q);
            ao2_unlock(q);
            queue_unref(q);
        } else {
            ast_str_set(&out, 0, "No such queue: %s.", argv[2]);
            do_print(s, fd, ast_str_buffer(out));
        }
        return CLI_SUCCESS;
    }
 
    if (ast_check_realtime("queues")) {
        /* This block is to find any queues which are defined in realtime but
         * which have not yet been added to the in-core container
         */
        struct ast_config *cfg = ast_load_realtime_multientry("queues", "name LIKE", "%", SENTINEL);
        if (cfg) {
            char *category = NULL;
            while ((category = ast_category_browse(cfg, category))) {
                const char *queuename = ast_variable_retrieve(cfg, category, "name");
                if (ast_strlen_zero(queuename)) {
                    ast_log(LOG_WARNING, "Ignoring realtime queue with a NULL or empty 'name.'\n");
                    continue;
                }
                if ((q = find_load_queue_rt_friendly(queuename))) {
                    queue_t_unref(q, "Done with temporary pointer");
                }
            }
            ast_config_destroy(cfg);
        }
    }
 
    /*
     * Snapping a copy of the container prevents having to lock both the queues container
     * and the queue itself at the same time.  It also allows us to sort the entries.
     */
    sorted_queues = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, call_queue_sort_fn, NULL);
    if (!sorted_queues) {
        return CLI_SUCCESS;
    }
    if (ao2_container_dup(sorted_queues, queues, 0)) {
        ao2_ref(sorted_queues, -1);
        return CLI_SUCCESS;
    }
 
    /*
     * No need to lock the container since it's temporary and static.
     * We also unlink the entries as we use them so the container is
     * empty when the iterator finishes.  We can then just unref the container.
     */
    queue_iter = ao2_iterator_init(sorted_queues, AO2_ITERATOR_DONTLOCK | AO2_ITERATOR_UNLINK);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        struct call_queue *realtime_queue = NULL;
        ao2_lock(q);
        /* This check is to make sure we don't print information for realtime
         * queues which have been deleted from realtime but which have not yet
         * been deleted from the in-core container. Only do this if we're not
         * looking for a specific queue.
         */
        if (q->realtime) {
            realtime_queue = find_load_queue_rt_friendly(q->name);
            if (!realtime_queue) {
                ao2_unlock(q);
                queue_t_unref(q, "Done with iterator");
                continue;
            }
            queue_t_unref(realtime_queue, "Queue is already in memory");
        }
 
        found = 1;
        print_queue(s, fd, q);
 
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator"); /* Unref the iterator's reference */
    }
    ao2_iterator_destroy(&queue_iter);
    ao2_ref(sorted_queues, -1);
    if (!found) {
        ast_str_set(&out, 0, "No queues.");
        do_print(s, fd, ast_str_buffer(out));
    }
    return CLI_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_container_alloc_rbtree, ao2_container_dup(), ao2_iterator_destroy(), AO2_ITERATOR_DONTLOCK, ao2_iterator_init(), AO2_ITERATOR_UNLINK, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_category_browse(), ast_check_realtime(), ast_config_destroy(), ast_load_realtime_multientry(), ast_log, ast_str_alloca, ast_str_buffer(), ast_str_set(), ast_strlen_zero(), ast_variable_retrieve(), CLI_SHOWUSAGE, CLI_SUCCESS, do_print(), find_load_queue_rt_friendly(), call_queue::found, LOG_WARNING, call_queue::name, NULL, out, print_queue(), queue_t_unref, queue_unref, queues, call_queue::realtime, and SENTINEL.

Referenced by queue_show().

__reg_module()

static void __reg_module ( void  )

static

Definition at line 12117 of file app_queue.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 12117 of file app_queue.c.

add_to_queue()

static int add_to_queue ( const char *  queuename, const char *  interface, const char *  membername, int  penalty, int  paused, int  dump, const char *  state_interface, const char *  reason_paused, int  wrapuptime  )

static

Add member to queue.

Return values

RES_NOT_DYNAMIC	when they aren't a RT member
RES_NOSUCHQUEUE	queue does not exist
RES_OKAY	added member from queue
RES_EXISTS	queue exists but no members
RES_OUT_OF_MEMORY	queue exists but not enough memory to create member

Note

Ensure the appropriate realtime queue is loaded. Note that this short-circuits if the queue is already in memory.

Definition at line 7741 of file app_queue.c.

{
    struct call_queue *q;
    struct member *new_member, *old_member;
    int res = RES_NOSUCHQUEUE;
 
    /*! \note Ensure the appropriate realtime queue is loaded.  Note that this
     * short-circuits if the queue is already in memory. */
    if (!(q = find_load_queue_rt_friendly(queuename))) {
        return res;
    }
 
    ao2_lock(q);
    if ((old_member = interface_exists(q, interface)) == NULL) {
        if ((new_member = create_queue_member(interface, membername, penalty, paused, state_interface, q->ringinuse, wrapuptime))) {
            new_member->dynamic = 1;
            if (reason_paused) {
                ast_copy_string(new_member->reason_paused, reason_paused, sizeof(new_member->reason_paused));
            }
            member_add_to_queue(q, new_member);
            queue_publish_member_blob(queue_member_added_type(), queue_member_blob_create(q, new_member));
 
            if (is_member_available(q, new_member)) {
                ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
            }
 
            ao2_ref(new_member, -1);
            new_member = NULL;
 
            if (dump) {
                dump_queue_members(q);
            }
 
            res = RES_OKAY;
        } else {
            res = RES_OUTOFMEMORY;
        }
    } else {
        ao2_ref(old_member, -1);
        res = RES_EXISTS;
    }
    ao2_unlock(q);
    queue_t_unref(q, "Expiring temporary reference");
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_copy_string(), AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), create_queue_member(), dump_queue_members(), member::dynamic, find_load_queue_rt_friendly(), member::interface, interface_exists(), is_member_available(), member_add_to_queue(), member::membername, call_queue::name, NULL, member::paused, member::penalty, queue_member_blob_create(), queue_publish_member_blob(), queue_t_unref, member::reason_paused, RES_EXISTS, RES_NOSUCHQUEUE, RES_OKAY, RES_OUTOFMEMORY, call_queue::ringinuse, member::state_interface, and member::wrapuptime.

Referenced by aqm_exec(), handle_queue_add_member(), manager_add_queue_member(), and reload_queue_members().

alloc_queue()

static struct call_queue * alloc_queue ( const char *  queuename )

static

Definition at line 3875 of file app_queue.c.

{
    struct call_queue *q;
 
    if ((q = ao2_t_alloc(sizeof(*q), destroy_queue, "Allocate queue"))) {
        if (ast_string_field_init(q, 64)) {
            queue_t_unref(q, "String field allocation failed");
            return NULL;
        }
        ast_string_field_set(q, name, queuename);
    }
    return q;
}

References ao2_t_alloc, ast_string_field_init, ast_string_field_set, destroy_queue(), name, NULL, and queue_t_unref.

Referenced by find_queue_by_name_rt(), and reload_single_queue().

AO2_STRING_FIELD_SORT_FN()

AO2_STRING_FIELD_SORT_FN	(	call_queue	,
		name
	)

aqm_exec()

static int aqm_exec ( struct ast_channel *  chan, const char *  data  )

static

AddQueueMember application.

Definition at line 8502 of file app_queue.c.

{
    int res=-1;
    char *parse, *tmp, *temppos = NULL, *reason = NULL;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
        AST_APP_ARG(penalty);
        AST_APP_ARG(options);
        AST_APP_ARG(membername);
        AST_APP_ARG(state_interface);
        AST_APP_ARG(wrapuptime);
    );
    int penalty = 0;
    int paused = 0;
    int wrapuptime;
    struct ast_flags flags = { 0 };
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "AddQueueMember requires an argument (queuename[,interface[,penalty[,options[,membername[,stateinterface][,wrapuptime]]]]])\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (args.options) {
        char *opts[AQM_OPT_ARG_ARRAY_SIZE] = { NULL, };
        ast_app_parse_options(aqm_opts, &flags, opts, args.options);
        if (ast_test_flag(&flags, AQMFLAG_PAUSED)) {
            paused = 1;
            if (ast_test_flag(&flags, AQMFLAG_REASON) && !ast_strlen_zero(opts[AQM_OPT_ARG_PAUSE_REASON])) {
                reason = ast_strdupa(opts[AQM_OPT_ARG_PAUSE_REASON]);
            }
        }
    }
 
    if (ast_strlen_zero(args.interface)) {
        args.interface = ast_strdupa(ast_channel_name(chan));
        temppos = strrchr(args.interface, '-');
        if (temppos) {
            *temppos = '\0';
        }
    }
 
    if (!ast_strlen_zero(args.penalty)) {
        if ((sscanf(args.penalty, "%30d", &penalty) != 1) || penalty < 0) {
            ast_log(LOG_WARNING, "Penalty '%s' is invalid, must be an integer >= 0\n", args.penalty);
            penalty = 0;
        }
    }
 
    if (!ast_strlen_zero(args.wrapuptime)) {
        tmp = args.wrapuptime;
        ast_strip(tmp);
        wrapuptime = atoi(tmp);
        if (wrapuptime < 0) {
            wrapuptime = 0;
        }
    } else {
        wrapuptime = 0;
    }
 
    switch (add_to_queue(args.queuename, args.interface, args.membername, penalty, paused, queue_persistent_members, args.state_interface, reason, wrapuptime)) {
    case RES_OKAY:
        if (ast_strlen_zero(args.membername) || !log_membername_as_agent) {
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), args.interface, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        } else {
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), args.membername, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        }
        ast_log(LOG_NOTICE, "Added interface '%s' to queue '%s'\n", args.interface, args.queuename);
        pbx_builtin_setvar_helper(chan, "AQMSTATUS", "ADDED");
        res = 0;
        break;
    case RES_EXISTS:
        ast_log(LOG_WARNING, "Unable to add interface '%s' to queue '%s': Already there\n", args.interface, args.queuename);
        pbx_builtin_setvar_helper(chan, "AQMSTATUS", "MEMBERALREADY");
        res = 0;
        break;
    case RES_NOSUCHQUEUE:
        ast_log(LOG_WARNING, "Unable to add interface to queue '%s': No such queue\n", args.queuename);
        pbx_builtin_setvar_helper(chan, "AQMSTATUS", "NOSUCHQUEUE");
        res = 0;
        break;
    case RES_OUTOFMEMORY:
        ast_log(LOG_ERROR, "Out of memory adding interface %s to queue %s\n", args.interface, args.queuename);
        break;
    }
 
    return res;
}

References add_to_queue(), AQM_OPT_ARG_ARRAY_SIZE, AQM_OPT_ARG_PAUSE_REASON, aqm_opts, AQMFLAG_PAUSED, AQMFLAG_REASON, args, AST_APP_ARG, ast_app_parse_options(), ast_channel_name(), ast_channel_uniqueid(), AST_DECLARE_APP_ARGS, ast_log, ast_queue_log(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strip(), ast_strlen_zero(), ast_test_flag, ast_flags::flags, member::interface, LOG_ERROR, log_membername_as_agent, LOG_NOTICE, LOG_WARNING, member::membername, NULL, options, member::paused, pbx_builtin_setvar_helper(), member::penalty, queue_persistent_members, RES_EXISTS, RES_NOSUCHQUEUE, RES_OKAY, RES_OUTOFMEMORY, member::state_interface, and member::wrapuptime.

Referenced by load_module().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 12117 of file app_queue.c.

autopause2int()

static int autopause2int ( const char *  autopause )

static

Definition at line 2076 of file app_queue.c.

{
    int x;
    /*This 'double check' that default value is OFF */
    if (ast_strlen_zero(autopause)) {
        return QUEUE_AUTOPAUSE_OFF;
    }
 
    /*This 'double check' is to ensure old values works */
    if(ast_true(autopause)) {
        return QUEUE_AUTOPAUSE_ON;
    }
 
    for (x = 0; x < ARRAY_LEN(autopausesmodes); x++) {
        if (!strcasecmp(autopause, autopausesmodes[x].name)) {
            return autopausesmodes[x].autopause;
        }
    }
 
    /*This 'double check' that default value is OFF */
    return QUEUE_AUTOPAUSE_OFF;
}

References ARRAY_LEN, ast_strlen_zero(), ast_true(), autopause::autopause, autopausesmodes, name, QUEUE_AUTOPAUSE_OFF, and QUEUE_AUTOPAUSE_ON.

Referenced by queue_set_param().

calc_metric()

static int calc_metric ( struct call_queue *  q, struct member *  mem, int  pos, struct queue_ent *  qe, struct callattempt *  tmp  )

static

Calculate the metric of each member in the outgoing callattempts.

A numeric metric is given to each member depending on the ring strategy used by the queue. Members with lower metrics will be called before members with higher metrics

Return values

-1	if penalties are exceeded
0	otherwise

Definition at line 6192 of file app_queue.c.

{
    /* disregarding penalty on too few members? */
    int membercount = ao2_container_count(q->members);
    unsigned char usepenalty = (membercount <= q->penaltymemberslimit) ? 0 : 1;
    int penalty = mem->penalty;
 
    if (usepenalty) {
        if (qe->raise_penalty != INT_MAX && penalty < qe->raise_penalty) {
            /* Low penalty is raised up to the current minimum */
            penalty = qe->raise_penalty;
        }
        if ((qe->max_penalty != INT_MAX && penalty > qe->max_penalty) ||
            (qe->min_penalty != INT_MAX && penalty < qe->min_penalty)) {
            return -1;
        }
    } else {
        ast_debug(1, "Disregarding penalty, %d members and %d in penaltymemberslimit.\n",
              membercount, q->penaltymemberslimit);
    }
 
    switch (q->strategy) {
    case QUEUE_STRATEGY_RINGALL:
        /* Everyone equal, except for penalty */
        tmp->metric = penalty * 1000000 * usepenalty;
        break;
    case QUEUE_STRATEGY_LINEAR:
        if (pos < qe->linpos) {
            tmp->metric = 1000 + pos;
        } else {
            if (pos > qe->linpos) {
                /* Indicate there is another priority */
                qe->linwrapped = 1;
            }
            tmp->metric = pos;
        }
        tmp->metric += penalty * 1000000 * usepenalty;
        break;
    case QUEUE_STRATEGY_RRORDERED:
    case QUEUE_STRATEGY_RRMEMORY:
        pos = mem->queuepos;
        if (pos < q->rrpos) {
            tmp->metric = 1000 + pos;
        } else {
            if (pos > q->rrpos) {
                /* Indicate there is another priority */
                q->wrapped = 1;
            }
            tmp->metric = pos;
        }
        tmp->metric += penalty * 1000000 * usepenalty;
        break;
    case QUEUE_STRATEGY_RANDOM:
        tmp->metric = ast_random() % 1000;
        tmp->metric += penalty * 1000000 * usepenalty;
        break;
    case QUEUE_STRATEGY_WRANDOM:
        tmp->metric = ast_random() % ((1 + penalty) * 1000);
        break;
    case QUEUE_STRATEGY_FEWESTCALLS:
        tmp->metric = mem->calls;
        tmp->metric += penalty * 1000000 * usepenalty;
        break;
    case QUEUE_STRATEGY_LEASTRECENT:
        if (!mem->lastcall) {
            tmp->metric = 0;
        } else {
            tmp->metric = 1000000 - (time(NULL) - mem->lastcall);
        }
        tmp->metric += penalty * 1000000 * usepenalty;
        break;
    default:
        ast_log(LOG_WARNING, "Can't calculate metric for unknown strategy %d\n", q->strategy);
        break;
    }
    return 0;
}

References ao2_container_count(), ast_debug, ast_log, ast_random(), member::calls, member::lastcall, queue_ent::linpos, queue_ent::linwrapped, LOG_WARNING, queue_ent::max_penalty, call_queue::members, callattempt::metric, queue_ent::min_penalty, NULL, member::penalty, call_queue::penaltymemberslimit, QUEUE_STRATEGY_FEWESTCALLS, QUEUE_STRATEGY_LEASTRECENT, QUEUE_STRATEGY_LINEAR, QUEUE_STRATEGY_RANDOM, QUEUE_STRATEGY_RINGALL, QUEUE_STRATEGY_RRMEMORY, QUEUE_STRATEGY_RRORDERED, QUEUE_STRATEGY_WRANDOM, member::queuepos, queue_ent::raise_penalty, call_queue::rrpos, call_queue::strategy, and call_queue::wrapped.

Referenced by try_calling().

callattempt_free()

static void callattempt_free ( struct callattempt *  doomed )

static

Definition at line 4595 of file app_queue.c.

{
    if (doomed->member) {
        ao2_ref(doomed->member, -1);
    }
    ast_party_connected_line_free(&doomed->connected);
    ast_free(doomed->orig_chan_name);
    ast_free(doomed);
}

References ao2_ref, ast_free, ast_party_connected_line_free(), callattempt::connected, callattempt::member, and callattempt::orig_chan_name.

Referenced by hangupcalls(), and try_calling().

can_ring_entry()

static int can_ring_entry ( struct queue_ent *  qe, struct callattempt *  call  )

static

Definition at line 4805 of file app_queue.c.

{
    struct member *memberp = call->member;
    int wrapuptime;
 
    if (memberp->paused) {
        ast_debug(1, "%s paused, can't receive call\n", call->interface);
        return 0;
    }
 
    if (!memberp->ringinuse && !member_status_available(memberp->status)) {
        ast_debug(1, "%s not available, can't receive call\n", call->interface);
        return 0;
    }
 
    if (memberp->lastqueue) {
        wrapuptime = get_wrapuptime(memberp->lastqueue, memberp);
    } else {
        wrapuptime = get_wrapuptime(qe->parent, memberp);
    }
    if (wrapuptime && (time(NULL) - memberp->lastcall) < wrapuptime) {
        ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n",
            (memberp->lastqueue ? memberp->lastqueue->name : qe->parent->name),
            call->interface);
        return 0;
    }
 
    if (use_weight && compare_weight(qe->parent, memberp)) {
        ast_debug(1, "Priority queue delaying call to %s:%s\n",
            qe->parent->name, call->interface);
        return 0;
    }
 
    if (force_longest_waiting_caller && !is_longest_waiting_caller(qe, memberp)) {
        ast_debug(1, "Another caller was waiting longer; delaying call to %s:%s\n",
                  qe->parent->name, call->interface);
        return 0;
    }
 
    if (!memberp->ringinuse) {
        struct member *mem;
 
        ao2_lock(pending_members);
 
        mem = ao2_find(pending_members, memberp,
                  OBJ_SEARCH_OBJECT | OBJ_NOLOCK);
        if (mem) {
            /*
             * If found that means this member is currently being attempted
             * from another calling thread, so stop trying from this thread
             */
            ast_debug(1, "%s has another call trying, can't receive call\n",
                  call->interface);
            ao2_ref(mem, -1);
            ao2_unlock(pending_members);
            return 0;
        }
 
        /*
         * If not found add it to the container so another queue
         * won't attempt to call this member at the same time.
         */
        ast_debug(3, "Add %s to pending_members\n", memberp->membername);
        ao2_link(pending_members, memberp);
        ao2_unlock(pending_members);
 
        /*
         * The queue member is available.  Get current status to be sure
         * because the device state and extension state callbacks may
         * not have updated the status yet.
         */
        if (!member_status_available(get_queue_member_status(memberp))) {
            ast_debug(1, "%s actually not available, can't receive call\n",
                call->interface);
            pending_members_remove(memberp);
            return 0;
        }
    }
 
    return 1;
}

References ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlock, ast_debug, call(), compare_weight(), force_longest_waiting_caller, get_queue_member_status(), get_wrapuptime(), is_longest_waiting_caller(), member::lastcall, member::lastqueue, member_status_available(), member::membername, call_queue::name, NULL, OBJ_NOLOCK, OBJ_SEARCH_OBJECT, queue_ent::parent, member::paused, pending_members, pending_members_remove(), member::ringinuse, member::status, use_weight, and member::wrapuptime.

Referenced by ring_entry().

change_priority_caller_on_queue()

static int change_priority_caller_on_queue ( const char *  queuename, const char *  caller, int  priority, int  immediate  )

static

Change priority caller into a queue.

Return values

RES_NOSUCHQUEUE	queue does not exist
RES_OKAY	change priority
RES_NOT_CALLER	queue exists but no caller

Note

Ensure the appropriate realtime queue is loaded. Note that this short-circuits if the queue is already in memory.

Definition at line 7794 of file app_queue.c.

{
    struct call_queue *q;
    struct queue_ent *current, *prev = NULL, *caller_qe = NULL;
    int res = RES_NOSUCHQUEUE;
 
    /*! \note Ensure the appropriate realtime queue is loaded.  Note that this
     * short-circuits if the queue is already in memory. */
    if (!(q = find_load_queue_rt_friendly(queuename))) {
        return res;
    }
 
    ao2_lock(q);
    res = RES_NOT_CALLER;
    for (current = q->head; current; current = current->next) {
        if (strcmp(ast_channel_name(current->chan), caller) == 0) {
            ast_debug(1, "%s Caller new priority %d in queue %s\n",
                         caller, priority, queuename);
            current->prio = priority;
            if (immediate) {
                /* This caller is being immediately moved in the queue so remove them */
                if (prev) {
                    prev->next = current->next;
                } else {
                    q->head = current->next;
                }
                caller_qe = current;
                /* The position for all callers is not recalculated in here as it will
                 * be updated when the moved caller is inserted back into the queue
                 */
            }
            res = RES_OKAY;
            break;
        } else if (immediate) {
            prev = current;
        }
    }
 
    if (caller_qe) {
        int inserted = 0, pos = 0;
 
        /* If a caller queue entry exists, we are applying their priority immediately
         * and have to reinsert them at the correct position.
         */
        prev = NULL;
        current = q->head;
        while (current) {
            if (!inserted && (caller_qe->prio > current->prio)) {
                insert_entry(q, prev, caller_qe, &pos);
                inserted = 1;
            }
 
            /* We always update the position as it may have changed */
            current->pos = ++pos;
 
            /* Move to the next caller in the queue */
            prev = current;
            current = current->next;
        }
 
        if (!inserted) {
            insert_entry(q, prev, caller_qe, &pos);
        }
    }
 
    ao2_unlock(q);
    return res;
}

References ao2_lock, ao2_unlock, ast_channel_name(), ast_debug, current, find_load_queue_rt_friendly(), call_queue::head, insert_entry(), queue_ent::next, NULL, queue_ent::pos, priority, RES_NOSUCHQUEUE, RES_NOT_CALLER, and RES_OKAY.

Referenced by handle_queue_change_priority_caller(), and manager_change_priority_caller_on_queue().

clear_queue()

static void clear_queue ( struct call_queue *  q )

static

Definition at line 3184 of file app_queue.c.

{
    q->holdtime = 0;
    q->callscompleted = 0;
    q->callsabandoned = 0;
    q->callscompletedinsl = 0;
    q->callsabandonedinsl = 0;
    q->talktime = 0;
 
    if (q->members) {
        struct member *mem;
        struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
        while ((mem = ao2_iterator_next(&mem_iter))) {
            mem->calls = 0;
            mem->callcompletedinsl = 0;
            mem->lastcall = 0;
            mem->starttime = 0;
            ao2_ref(mem, -1);
        }
        ao2_iterator_destroy(&mem_iter);
    }
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, member::callcompletedinsl, member::calls, call_queue::callsabandoned, call_queue::callsabandonedinsl, call_queue::callscompleted, call_queue::callscompletedinsl, call_queue::holdtime, member::lastcall, call_queue::members, member::starttime, and call_queue::talktime.

Referenced by clear_stats(), and find_queue_by_name_rt().

clear_stats()

static int clear_stats ( const char *  queuename )

static

Facilitates resetting statistics for a queue.

This function actually does not reset any statistics, but rather finds a call_queue struct which corresponds to the passed-in queue name and passes that structure to the clear_queue function. If no queuename is passed in, then all queues will have their statistics reset.

Parameters

queuename

The name of the queue to reset the statistics for. If this is NULL or zero-length, then this means to reset the statistics for all queues

Return values

0

always

Definition at line 10137 of file app_queue.c.

{
    struct call_queue *q;
    struct ao2_iterator queue_iter;
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        ao2_lock(q);
        if (ast_strlen_zero(queuename) || !strcasecmp(q->name, queuename))
            clear_queue(q);
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_lock, ao2_t_iterator_next, ao2_unlock, ast_strlen_zero(), clear_queue(), call_queue::name, queue_t_unref, and queues.

Referenced by reload_handler().

compare_weight()

static int compare_weight ( struct call_queue *  rq, struct member *  member  )

static

Definition at line 4690 of file app_queue.c.

{
    struct call_queue *q;
    struct member *mem;
    int found = 0;
    struct ao2_iterator queue_iter;
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        if (q == rq) { /* don't check myself, could deadlock */
            queue_t_unref(q, "Done with iterator");
            continue;
        }
        ao2_lock(q);
        if (q->count && q->members) {
            if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
                ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
                if (q->weight > rq->weight && q->count >= num_available_members(q)) {
                    ast_debug(1, "Queue '%s' (weight %d, calls %d) is preferred over '%s' (weight %d, calls %d)\n", q->name, q->weight, q->count, rq->name, rq->weight, rq->count);
                    found = 1;
                }
                ao2_ref(mem, -1);
            }
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
        if (found) {
            break;
        }
    }
    ao2_iterator_destroy(&queue_iter);
    return found;
}

References ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_debug, call_queue::count, member::interface, call_queue::members, call_queue::name, num_available_members(), OBJ_POINTER, queue_t_unref, queues, and call_queue::weight.

Referenced by can_ring_entry().

complete_queue()

static char * complete_queue ( const char *  line, const char *  word, int  pos, int  state, ptrdiff_t  word_list_offset  )

static

Check if a given word is in a space-delimited list.

Parameters

line	The line as typed not including the current word being completed
word	The word currently being completed
pos	The number of completed words in line
state	The nth desired completion option
word_list_offset	Offset into the line where the list of queues begins. If non-zero, queues in the list will not be offered for further completion.

Returns

Returns the queue tab-completion for the given word and state

Definition at line 10473 of file app_queue.c.

{
    struct call_queue *q;
    char *ret = NULL;
    int which = 0;
    int wordlen = strlen(word);
    struct ao2_iterator queue_iter;
    const char *word_list = NULL;
 
    /* for certain commands, already completed items should be left out of
     * the list */
    if (word_list_offset && strlen(line) >= word_list_offset) {
        word_list = line + word_list_offset;
    }
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        if (!strncasecmp(word, q->name, wordlen) && ++which > state
            && (!word_list_offset || !word_in_list(word_list, q->name))) {
            ret = ast_strdup(q->name);
            queue_t_unref(q, "Done with iterator");
            break;
        }
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
 
    /* Pretend "rules" is at the end of the queues list in certain
     * circumstances since it is an alternate command that should be
     * tab-completable for "queue show" */
    if (!ret && which == state && !wordlen && !strncmp("queue show", line, 10)) {
        ret = ast_strdup("rules");
    }
 
    return ret;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_strdup, call_queue::name, NULL, queue_t_unref, queues, and word_in_list().

Referenced by complete_queue_add_member(), complete_queue_pause_member(), complete_queue_remove_member(), complete_queue_set_member_value(), complete_queue_show(), handle_queue_reload(), and handle_queue_reset().

complete_queue_add_member()

static char * complete_queue_add_member ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 10980 of file app_queue.c.

{
    /* 0 - queue; 1 - add; 2 - member; 3 - <interface>; 4 - to; 5 - <queue>; 6 - penalty; 7 - <penalty>; 8 - as; 9 - <membername> */
    switch (pos) {
    case 3: /* Don't attempt to complete name of interface (infinite possibilities) */
        return NULL;
    case 4: /* only one possible match, "to" */
        return state == 0 ? ast_strdup("to") : NULL;
    case 5: /* <queue> */
        return complete_queue(line, word, pos, state, 0);
    case 6: /* only one possible match, "penalty" */
        return state == 0 ? ast_strdup("penalty") : NULL;
    case 7:
        if (0 <= state && state < 100) {      /* 0-99 */
            char *num;
            if ((num = ast_malloc(3))) {
                sprintf(num, "%d", state);
            }
            return num;
        } else {
            return NULL;
        }
    case 8: /* only one possible match, "as" */
        return state == 0 ? ast_strdup("as") : NULL;
    case 9: /* Don't attempt to complete name of member (infinite possibilities) */
        return NULL;
    default:
        return NULL;
    }
}

References ast_malloc, ast_strdup, complete_queue(), and NULL.

Referenced by handle_queue_add_member().

complete_queue_pause_member()

static char * complete_queue_pause_member ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 11405 of file app_queue.c.

{
    /* 0 - queue; 1 - pause; 2 - member; 3 - <interface>; 4 - queue; 5 - <queue>; 6 - reason; 7 - <reason> */
    switch (pos) {
    case 3: /* Don't attempt to complete name of interface (infinite possibilities) */
        return NULL;
    case 4: /* only one possible match, "queue" */
        return state == 0 ? ast_strdup("queue") : NULL;
    case 5: /* <queue> */
        return complete_queue(line, word, pos, state, 0);
    case 6: /* "reason" */
        return state == 0 ? ast_strdup("reason") : NULL;
    case 7: /* Can't autocomplete a reason, since it's 100% customizeable */
        return NULL;
    default:
        return NULL;
    }
}

References ast_strdup, complete_queue(), and NULL.

Referenced by handle_queue_pause_member().

complete_queue_remove_member()

static char * complete_queue_remove_member ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 11240 of file app_queue.c.

{
    int which = 0;
    struct call_queue *q;
    struct member *m;
    struct ao2_iterator queue_iter;
    struct ao2_iterator mem_iter;
    int wordlen = strlen(word);
 
    /* 0 - queue; 1 - remove; 2 - member; 3 - <member>; 4 - from; 5 - <queue> */
    if (pos > 5 || pos < 3) {
        return NULL;
    }
    if (pos == 4) {   /* only one possible match, 'from' */
        return (state == 0 ? ast_strdup("from") : NULL);
    }
 
    if (pos == 5) {   /* No need to duplicate code */
        return complete_queue(line, word, pos, state, 0);
    }
 
    /* here is the case for 3, <member> */
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        ao2_lock(q);
        mem_iter = ao2_iterator_init(q->members, 0);
        while ((m = ao2_iterator_next(&mem_iter))) {
            if (!strncasecmp(word, m->membername, wordlen) && ++which > state) {
                char *tmp;
                tmp = ast_strdup(m->interface);
                ao2_ref(m, -1);
                ao2_iterator_destroy(&mem_iter);
                ao2_unlock(q);
                queue_t_unref(q, "Done with iterator, returning interface name");
                ao2_iterator_destroy(&queue_iter);
                return tmp;
            }
            ao2_ref(m, -1);
        }
        ao2_iterator_destroy(&mem_iter);
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
 
    return NULL;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_strdup, complete_queue(), member::interface, member::membername, call_queue::members, NULL, queue_t_unref, and queues.

Referenced by handle_queue_remove_member().

complete_queue_rule_show()

static char * complete_queue_rule_show ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 11600 of file app_queue.c.

{
    int which = 0;
    struct rule_list *rl_iter;
    int wordlen = strlen(word);
    char *ret = NULL;
    if (pos != 3) /* Wha? */ {
        return NULL;
    }
 
    AST_LIST_LOCK(&rule_lists);
    AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
        if (!strncasecmp(word, rl_iter->name, wordlen) && ++which > state) {
            ret = ast_strdup(rl_iter->name);
            break;
        }
    }
    AST_LIST_UNLOCK(&rule_lists);
 
    return ret;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, rule_list::list, rule_list::name, and NULL.

Referenced by handle_queue_rule_show().

complete_queue_set_member_value()

static char * complete_queue_set_member_value ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 11479 of file app_queue.c.

{
    /* 0 - queue; 1 - set; 2 - penalty/ringinuse; 3 - <value>; 4 - on; 5 - <member>; 6 - in; 7 - <queue>;*/
    switch (pos) {
    case 4:
        if (state == 0) {
            return ast_strdup("on");
        } else {
            return NULL;
        }
    case 6:
        if (state == 0) {
            return ast_strdup("in");
        } else {
            return NULL;
        }
    case 7:
        return complete_queue(line, word, pos, state, 0);
    default:
        return NULL;
    }
}

References ast_strdup, complete_queue(), and NULL.

Referenced by handle_queue_set_member_penalty(), and handle_queue_set_member_ringinuse().

complete_queue_show()

static char * complete_queue_show ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 10510 of file app_queue.c.

{
    if (pos == 2) {
        return complete_queue(line, word, pos, state, 0);
    }
    return NULL;
}

References complete_queue(), and NULL.

Referenced by queue_show().

compress_char()

static int compress_char ( const char  c )

static

Definition at line 3043 of file app_queue.c.

{
    if (c < 32) {
        return 0;
    } else if (c > 96) {
        return c - 64;
    }
    return c - 32;
}

References c.

Referenced by member_hash_fn().

context_included()

static int context_included ( const char *  parent, const char *  child  )

static

Returns if one context includes another context.

Parameters

parent	Parent context to search for child
child	Context to check for inclusion in parent

This function recursively checks if the context child is included in the context parent.

Return values

1	if child is included in parent
0	if not

Definition at line 2910 of file app_queue.c.

{
    struct ast_context *c = NULL;
 
    c = ast_context_find(parent);
    if (!c) {
        /* well, if parent doesn't exist, how can the child be included in it? */
        return 0;
    }
    if (!strcmp(ast_get_context_name(c), parent)) {
        /* found the context of the hint app_queue is using. Now, see
            if that context includes the one that just changed state */
        struct ast_include *inc = NULL;
 
        while ((inc = (struct ast_include*) ast_walk_context_includes(c, inc))) {
            const char *includename = ast_get_include_name(inc);
            if (!strcasecmp(child, includename)) {
                return 1;
            }
            /* recurse on this context, for nested includes. The
                PBX extension parser will prevent infinite recursion. */
            if (context_included(includename, child)) {
                return 1;
            }
        }
    }
    return 0;
}

References ast_context_find(), ast_get_context_name(), ast_get_include_name(), ast_walk_context_includes(), c, context_included(), and NULL.

Referenced by context_included(), and extension_state_cb().

copy_rules()

static void copy_rules ( struct queue_ent *  qe, const char *  rulename  )

static

Copy rule from global list into specified queue.

Definition at line 8630 of file app_queue.c.

{
    struct penalty_rule *pr_iter;
    struct rule_list *rl_iter;
    const char *tmp = ast_strlen_zero(rulename) ? qe->parent->defaultrule : rulename;
    AST_LIST_LOCK(&rule_lists);
    AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
        if (!strcasecmp(rl_iter->name, tmp)) {
            break;
        }
    }
    if (rl_iter) {
        AST_LIST_TRAVERSE(&rl_iter->rules, pr_iter, list) {
            struct penalty_rule *new_pr = ast_calloc(1, sizeof(*new_pr));
            if (!new_pr) {
                ast_log(LOG_ERROR, "Memory allocation error when copying penalty rules! Aborting!\n");
                break;
            }
            new_pr->time = pr_iter->time;
            new_pr->max_value = pr_iter->max_value;
            new_pr->min_value = pr_iter->min_value;
            new_pr->raise_value = pr_iter->raise_value;
            new_pr->max_relative = pr_iter->max_relative;
            new_pr->min_relative = pr_iter->min_relative;
            new_pr->raise_relative = pr_iter->raise_relative;
            AST_LIST_INSERT_TAIL(&qe->qe_rules, new_pr, list);
        }
    }
    AST_LIST_UNLOCK(&rule_lists);
}

References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_strlen_zero(), call_queue::defaultrule, penalty_rule::list, rule_list::list, LOG_ERROR, penalty_rule::max_relative, penalty_rule::max_value, penalty_rule::min_relative, penalty_rule::min_value, rule_list::name, queue_ent::parent, queue_ent::qe_rules, penalty_rule::raise_relative, penalty_rule::raise_value, rule_list::rules, and penalty_rule::time.

Referenced by queue_exec().

create_queue_member()

static struct member * create_queue_member ( const char *  interface, const char *  membername, int  penalty, int  paused, const char *  state_interface, int  ringinuse, int  wrapuptime  )

static

allocate space for new queue member and set fields based on parameters passed

Definition at line 2998 of file app_queue.c.

{
    struct member *cur;
 
    if ((cur = ao2_alloc(sizeof(*cur), destroy_queue_member_cb))) {
        cur->ringinuse = ringinuse;
        cur->penalty = penalty;
        cur->paused = paused;
        cur->wrapuptime = wrapuptime;
        if (paused) {
            time(&cur->lastpause); /* Update time of last pause */
        }
        time(&cur->logintime);
        ast_copy_string(cur->interface, interface, sizeof(cur->interface));
        if (!ast_strlen_zero(state_interface)) {
            ast_copy_string(cur->state_interface, state_interface, sizeof(cur->state_interface));
        } else {
            ast_copy_string(cur->state_interface, interface, sizeof(cur->state_interface));
        }
        if (!ast_strlen_zero(membername)) {
            ast_copy_string(cur->membername, membername, sizeof(cur->membername));
        } else {
            ast_copy_string(cur->membername, interface, sizeof(cur->membername));
        }
        if (!strchr(cur->interface, '/')) {
            ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
        }
        if (!strncmp(cur->state_interface, "hint:", 5)) {
            char *tmp = ast_strdupa(cur->state_interface), *context = tmp;
            char *exten = strsep(&context, "@") + 5;
 
            ast_copy_string(cur->state_exten, exten, sizeof(cur->state_exten));
            ast_copy_string(cur->state_context, S_OR(context, "default"), sizeof(cur->state_context));
 
            cur->state_id = ast_extension_state_add(cur->state_context, cur->state_exten, extension_state_cb, NULL);
        } else {
            cur->state_id = -1;
        }
        cur->status = get_queue_member_status(cur);
    }
 
    return cur;
}

References ao2_alloc, ast_copy_string(), ast_extension_state_add(), ast_log, ast_strdupa, ast_strlen_zero(), voicemailpwcheck::context, destroy_queue_member_cb(), extension_state_cb(), get_queue_member_status(), member::interface, member::lastpause, LOG_WARNING, member::logintime, member::membername, NULL, member::paused, member::penalty, member::ringinuse, S_OR, member::state_context, member::state_exten, member::state_id, member::state_interface, member::status, strsep(), and member::wrapuptime.

Referenced by add_to_queue(), reload_single_member(), and rt_handle_member_record().

destroy_queue()

static void destroy_queue ( void *  obj )

static

Free queue's member list then its string fields.

Definition at line 3860 of file app_queue.c.

{
    struct call_queue *q = obj;
    int i;
 
    free_members(q, 1);
    ast_string_field_free_memory(q);
    for (i = 0; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
        if (q->sound_periodicannounce[i]) {
            ast_free(q->sound_periodicannounce[i]);
        }
    }
    ao2_ref(q->members, -1);
}

References ao2_ref, ast_free, ast_string_field_free_memory, free_members(), MAX_PERIODIC_ANNOUNCEMENTS, call_queue::members, and call_queue::sound_periodicannounce.

Referenced by alloc_queue().

destroy_queue_member_cb()

static void destroy_queue_member_cb ( void *  obj )

static

Definition at line 2988 of file app_queue.c.

{
    struct member *mem = obj;
 
    if (mem->state_id != -1) {
        ast_extension_state_del(mem->state_id, extension_state_cb);
    }
}

References ast_extension_state_del(), extension_state_cb(), and member::state_id.

Referenced by create_queue_member().

device_state_cb()

static void device_state_cb ( void *  unused, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

set a member's status based on device state of that member's interface

Definition at line 2774 of file app_queue.c.

{
    struct ao2_iterator miter, qiter;
    struct ast_device_state_message *dev_state;
    struct member *m;
    struct call_queue *q;
    char interface[80], *slash_pos;
    int found = 0;          /* Found this member in any queue */
    int found_member;       /* Found this member in this queue */
    int avail = 0;          /* Found an available member in this queue */
 
    if (ast_device_state_message_type() != stasis_message_type(msg)) {
        return;
    }
 
    dev_state = stasis_message_data(msg);
    if (dev_state->eid) {
        /* ignore non-aggregate states */
        return;
    }
 
    qiter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&qiter, "Iterate over queues"))) {
        ao2_lock(q);
 
        avail = 0;
        found_member = 0;
        miter = ao2_iterator_init(q->members, 0);
        for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
            if (!found_member) {
                ast_copy_string(interface, m->state_interface, sizeof(interface));
 
                if ((slash_pos = strchr(interface, '/'))) {
                    if (!strncasecmp(interface, "Local/", 6) && (slash_pos = strchr(slash_pos + 1, '/'))) {
                        *slash_pos = '\0';
                    }
                }
 
                if (!strcasecmp(interface, dev_state->device)) {
                    found_member = 1;
                    update_status(q, m, dev_state->state);
                }
            }
 
            /* check every member until we find one NOT_INUSE */
            if (!avail) {
                avail = is_member_available(q, m);
            }
            if (avail && found_member) {
                /* early exit as we've found an available member and the member of interest */
                ao2_ref(m, -1);
                break;
            }
        }
 
        if (found_member) {
            found = 1;
            if (avail) {
                ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
            } else {
                ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
            }
        }
 
        ao2_iterator_destroy(&miter);
 
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&qiter);
 
    if (found) {
        ast_debug(1, "Device '%s' changed to state '%u' (%s)\n",
            dev_state->device,
            dev_state->state,
            ast_devstate2str(dev_state->state));
    } else {
        ast_debug(3, "Device '%s' changed to state '%u' (%s) but we don't care because they're not a member of any queue.\n",
            dev_state->device,
            dev_state->state,
            ast_devstate2str(dev_state->state));
    }
 
    return;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_copy_string(), ast_debug, AST_DEVICE_INUSE, AST_DEVICE_NOT_INUSE, ast_device_state_message_type(), ast_devstate2str(), AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_device_state_message::device, ast_device_state_message::eid, call_queue::found, is_member_available(), call_queue::members, call_queue::name, queue_t_unref, queues, stasis_message_data(), stasis_message_type(), ast_device_state_message::state, member::state_interface, and update_status().

Referenced by load_module().

do_hang()

static void do_hang ( struct callattempt *  o )

static

common hangup actions

Definition at line 4775 of file app_queue.c.

{
    o->stillgoing = 0;
    ast_hangup(o->chan);
    pending_members_remove(o->member);
    o->chan = NULL;
}

References ast_hangup(), callattempt::chan, callattempt::member, NULL, pending_members_remove(), and callattempt::stillgoing.

Referenced by ring_entry(), and wait_for_answer().

do_print()

static void do_print ( struct mansession *  s, int  fd, const char *  str  )

static

direct output to manager or cli with proper terminator

Definition at line 10184 of file app_queue.c.

{
    if (s) {
        astman_append(s, "%s\r\n", str);
    } else {
        ast_cli(fd, "%s\n", str);
    }
}

References ast_cli(), astman_append(), and str.

Referenced by __queues_show(), and print_queue().

dump_queue_members()

static void dump_queue_members ( struct call_queue *  pm_queue )

static

Dump all members in a specific queue to the database.

<pm_family>/<queuename> = <interface>;<penalty>;<paused>;<state_interface>[|...]

Definition at line 7633 of file app_queue.c.

{
    struct member *cur_member;
    struct ast_str *value;
    struct ao2_iterator mem_iter;
 
    if (!pm_queue) {
        return;
    }
 
    /* 4K is a reasonable default for most applications, but we grow to
     * accommodate more if necessary. */
    if (!(value = ast_str_create(4096))) {
        return;
    }
 
    mem_iter = ao2_iterator_init(pm_queue->members, 0);
    while ((cur_member = ao2_iterator_next(&mem_iter))) {
        if (!cur_member->dynamic) {
            ao2_ref(cur_member, -1);
            continue;
        }
 
        ast_str_append(&value, 0, "%s%s;%d;%d;%s;%s;%s;%d",
            ast_str_strlen(value) ? "|" : "",
            cur_member->interface,
            cur_member->penalty,
            cur_member->paused,
            cur_member->membername,
            cur_member->state_interface,
            cur_member->reason_paused,
            cur_member->wrapuptime);
 
        ao2_ref(cur_member, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    if (ast_str_strlen(value) && !cur_member) {
        if (ast_db_put(pm_family, pm_queue->name, ast_str_buffer(value))) {
            ast_log(LOG_WARNING, "failed to create persistent dynamic entry!\n");
        }
    } else {
        /* Delete the entry if the queue is empty or there is an error */
        ast_db_del(pm_family, pm_queue->name);
    }
 
    ast_free(value);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_db_del(), ast_db_put(), ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_strlen(), member::dynamic, member::interface, LOG_WARNING, member::membername, call_queue::members, call_queue::name, member::paused, member::penalty, pm_family, member::reason_paused, member::state_interface, value, and member::wrapuptime.

Referenced by add_to_queue(), remove_from_queue(), and set_queue_member_pause().

end_bridge_callback()

static void end_bridge_callback ( void *  data )

static

Definition at line 6982 of file app_queue.c.

{
    struct queue_end_bridge *qeb = data;
    struct call_queue *q = qeb->q;
    struct ast_channel *chan = qeb->chan;
 
    if (ao2_ref(qeb, -1) == 1) {
        set_queue_variables(q, chan);
        /* This unrefs the reference we made in try_calling when we allocated qeb */
        queue_t_unref(q, "Expire bridge_config reference");
    }
}

References ao2_ref, queue_end_bridge::chan, queue_end_bridge::q, queue_t_unref, and set_queue_variables().

Referenced by try_calling().

end_bridge_callback_data_fixup()

static void end_bridge_callback_data_fixup ( struct ast_bridge_config *  bconfig, struct ast_channel *  originator, struct ast_channel *  terminator  )

static

Definition at line 6975 of file app_queue.c.

{
    struct queue_end_bridge *qeb = bconfig->end_bridge_callback_data;
    ao2_ref(qeb, +1);
    qeb->chan = originator;
}

References ao2_ref, queue_end_bridge::chan, and ast_bridge_config::end_bridge_callback_data.

Referenced by try_calling().

escape_and_substitute()

static void escape_and_substitute ( struct ast_channel *  chan, const char *  input, char *  output, size_t  size  )

static

Definition at line 7022 of file app_queue.c.

{
    const char *m = input;
    char escaped[size];
    char *p;
 
    for (p = escaped; p < escaped + size - 1; p++, m++) {
        switch (*m) {
        case '^':
            if (*(m + 1) == '{') {
                *p = '$';
            }
            break;
        case ',':
            *p++ = '\\';
            /* Fall through */
        default:
            *p = *m;
        }
        if (*m == '\0')
            break;
    }
 
    if (p == escaped + size) {
        escaped[size - 1] = '\0';
    }
 
    pbx_substitute_variables_helper(chan, escaped, output, size - 1);
}

References input(), and pbx_substitute_variables_helper().

Referenced by setup_mixmonitor().

extension_state_cb()

static int extension_state_cb ( const char *  context, const char *  exten, struct ast_state_cb_info *  info, void *  data  )

static

Definition at line 2939 of file app_queue.c.

{
    struct ao2_iterator miter, qiter;
    struct member *m;
    struct call_queue *q;
    int state = info->exten_state;
    int found = 0, device_state = extensionstate2devicestate(state);
 
    /* only interested in extension state updates involving device states */
    if (info->reason != AST_HINT_UPDATE_DEVICE) {
        return 0;
    }
 
    qiter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&qiter, "Iterate through queues"))) {
        ao2_lock(q);
 
        miter = ao2_iterator_init(q->members, 0);
        for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
            if (!strcmp(m->state_exten, exten) &&
                (!strcmp(m->state_context, context) || context_included(m->state_context, context))) {
                /* context could be included in m->state_context. We need to check. */
                found = 1;
                update_status(q, m, device_state);
            }
        }
        ao2_iterator_destroy(&miter);
 
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&qiter);
 
    if (found) {
        ast_debug(1, "Extension '%s@%s' changed to state '%d' (%s)\n", exten, context, device_state, ast_devstate2str(device_state));
    } else {
        ast_debug(3, "Extension '%s@%s' changed to state '%d' (%s) but we don't care because they're not a member of any queue.\n",
              exten, context, device_state, ast_devstate2str(device_state));
    }
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_debug, ast_devstate2str(), AST_HINT_UPDATE_DEVICE, voicemailpwcheck::context, context_included(), extensionstate2devicestate(), call_queue::found, sip_to_pjsip::info(), call_queue::members, queue_t_unref, queues, member::state_context, member::state_exten, and update_status().

Referenced by create_queue_member(), and destroy_queue_member_cb().

extensionstate2devicestate()

static int extensionstate2devicestate ( int  state )

static

Helper function which converts from extension state to device state values.

Definition at line 2861 of file app_queue.c.

{
    switch (state) {
    case AST_EXTENSION_NOT_INUSE:
        state = AST_DEVICE_NOT_INUSE;
        break;
    case AST_EXTENSION_INUSE:
        state = AST_DEVICE_INUSE;
        break;
    case AST_EXTENSION_BUSY:
        state = AST_DEVICE_BUSY;
        break;
    case AST_EXTENSION_RINGING:
        state = AST_DEVICE_RINGING;
        break;
    case AST_EXTENSION_INUSE | AST_EXTENSION_RINGING:
        state = AST_DEVICE_RINGINUSE;
        break;
    case AST_EXTENSION_ONHOLD:
        state = AST_DEVICE_ONHOLD;
        break;
    case AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD:
        state = AST_DEVICE_INUSE;
        break;
    case AST_EXTENSION_UNAVAILABLE:
        state = AST_DEVICE_UNAVAILABLE;
        break;
    case AST_EXTENSION_REMOVED:
    case AST_EXTENSION_DEACTIVATED:
    default:
        state = AST_DEVICE_INVALID;
        break;
    }
 
    return state;
}

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_UNAVAILABLE, AST_EXTENSION_BUSY, AST_EXTENSION_DEACTIVATED, AST_EXTENSION_INUSE, AST_EXTENSION_NOT_INUSE, AST_EXTENSION_ONHOLD, AST_EXTENSION_REMOVED, AST_EXTENSION_RINGING, AST_EXTENSION_UNAVAILABLE, and state.

Referenced by extension_state_cb(), and get_queue_member_status().

find_best()

static struct callattempt * find_best ( struct callattempt *  outgoing )

static

find the entry with the best metric, or NULL

Definition at line 5033 of file app_queue.c.

{
    struct callattempt *best = NULL, *cur;
 
    for (cur = outgoing; cur; cur = cur->q_next) {
        if (cur->stillgoing &&                  /* Not already done */
            !cur->chan &&                   /* Isn't already going */
            (!best || cur->metric < best->metric)) {        /* We haven't found one yet, or it's better */
            best = cur;
        }
    }
 
    return best;
}

References callattempt::metric, and NULL.

Referenced by ring_one(), store_next_lin(), and store_next_rr().

find_load_queue_rt_friendly()

static struct call_queue * find_load_queue_rt_friendly ( const char *  queuename )

static

note

Note

Load from realtime before taking the "queues" container lock, to avoid blocking all queue operations while waiting for the DB.

This will be two separate database transactions, so we might see queue parameters as they were before another process changed the queue and member list as it was after the change. Thus we might see an empty member list when a queue is deleted. In practise, this is unlikely to cause a problem.

Definition at line 4043 of file app_queue.c.

{
    struct ast_variable *queue_vars;
    struct ast_config *member_config = NULL;
    struct call_queue *q = NULL, tmpq = {
        .name = queuename,
    };
    int prev_weight = 0;
 
    /* Find the queue in the in-core list first. */
    q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Look for queue in memory first");
 
    if (!q || q->realtime) {
        /*! \note Load from realtime before taking the "queues" container lock, to avoid blocking all
           queue operations while waiting for the DB.
 
           This will be two separate database transactions, so we might
           see queue parameters as they were before another process
           changed the queue and member list as it was after the change.
           Thus we might see an empty member list when a queue is
           deleted. In practise, this is unlikely to cause a problem. */
 
        queue_vars = ast_load_realtime("queues", "name", queuename, SENTINEL);
        if (queue_vars) {
            member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", queuename, SENTINEL);
            if (!member_config) {
                ast_debug(1, "No queue_members defined in config extconfig.conf\n");
                member_config = ast_config_new();
            }
        }
        if (q) {
            prev_weight = q->weight ? 1 : 0;
            queue_t_unref(q, "Need to find realtime queue");
        }
 
        q = find_queue_by_name_rt(queuename, queue_vars, member_config);
        ast_config_destroy(member_config);
        ast_variables_destroy(queue_vars);
 
        /* update the use_weight value if the queue's has gained or lost a weight */
        if (q) {
            if (!q->weight && prev_weight) {
                ast_atomic_fetchadd_int(&use_weight, -1);
            }
            if (q->weight && !prev_weight) {
                ast_atomic_fetchadd_int(&use_weight, +1);
            }
        }
        /* Other cases will end up with the proper value for use_weight */
    } else {
        update_realtime_members(q);
    }
    return q;
}

References ao2_t_find, ast_atomic_fetchadd_int(), ast_config_destroy(), ast_config_new(), ast_debug, ast_load_realtime(), ast_load_realtime_multientry(), ast_variables_destroy(), find_queue_by_name_rt(), NULL, OBJ_POINTER, queue_t_unref, queues, call_queue::realtime, SENTINEL, update_realtime_members(), use_weight, and call_queue::weight.

Referenced by __queues_show(), add_to_queue(), change_priority_caller_on_queue(), find_member_by_queuename_and_interface(), get_member_penalty(), join_queue(), load_realtime_queues(), queue_function_exists(), queue_function_mem_read(), queue_function_queuememberlist(), queue_function_var(), qupd_exec(), reload_queue_members(), request_withdraw_caller_from_queue(), and set_member_value().

find_member_by_queuename_and_interface()

static struct member * find_member_by_queuename_and_interface ( const char *  queuename, const char *  interface  )

static

Find a member by looking up queuename and interface.

Returns

member or NULL if member not found.

Definition at line 12097 of file app_queue.c.

{
    struct member *mem = NULL;
    struct call_queue *q;
 
    if ((q = find_load_queue_rt_friendly(queuename))) {
        ao2_lock(q);
        mem = ao2_find(q->members, interface, OBJ_KEY);
        ao2_unlock(q);
        queue_t_unref(q, "Expiring temporary reference.");
    }
    return mem;
}

References ao2_find, ao2_lock, ao2_unlock, find_load_queue_rt_friendly(), call_queue::members, NULL, OBJ_KEY, and queue_t_unref.

Referenced by handle_queue_remove_member(), manager_remove_queue_member(), and rqm_exec().

find_queue_by_name_rt()

static struct call_queue * find_queue_by_name_rt ( const char *  queuename, struct ast_variable *  queue_vars, struct ast_config *  member_config  )

static

Reload a single queue via realtime.

Check for statically defined queue first, check if deleted RT queue, check for new RT queue, if queue vars are not defined init them with defaults. reload RT queue vars, set RT queue members dead and reload them, return finished queue.

Return values

the	queue,
NULL	if it doesn't exist.

Note

Should be called with the "queues" container locked.

Note

Hmm, can't seem to distinguish a DB failure from a not found condition... So we might delete an in-core queue in case of DB failure.

Definition at line 3899 of file app_queue.c.

{
    struct ast_variable *v;
    struct call_queue *q, tmpq = {
        .name = queuename,
    };
    struct member *m;
    struct ao2_iterator mem_iter;
    char *category = NULL;
    const char *tmp_name;
    char *tmp;
    char tmpbuf[64];    /* Must be longer than the longest queue param name. */
 
    /* Static queues override realtime. */
    if ((q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Check if static queue exists"))) {
        ao2_lock(q);
        if (!q->realtime) {
            if (q->dead) {
                ao2_unlock(q);
                queue_t_unref(q, "Queue is dead; can't return it");
                return NULL;
            }
            ast_log(LOG_WARNING, "Static queue '%s' already exists. Not loading from realtime\n", q->name);
            ao2_unlock(q);
            return q;
        }
    } else if (!member_config) {
        /* Not found in the list, and it's not realtime ... */
        return NULL;
    }
    /* Check if queue is defined in realtime. */
    if (!queue_vars) {
        /* Delete queue from in-core list if it has been deleted in realtime. */
        if (q) {
            /*! \note Hmm, can't seem to distinguish a DB failure from a not
               found condition... So we might delete an in-core queue
               in case of DB failure. */
            ast_debug(1, "Queue %s not found in realtime.\n", queuename);
 
            q->dead = 1;
            /* Delete if unused (else will be deleted when last caller leaves). */
            queues_t_unlink(queues, q, "Unused; removing from container");
            ao2_unlock(q);
            queue_t_unref(q, "Queue is dead; can't return it");
        }
        return NULL;
    }
 
    /* Create a new queue if an in-core entry does not exist yet. */
    if (!q) {
        struct ast_variable *tmpvar = NULL;
        if (!(q = alloc_queue(queuename))) {
            return NULL;
        }
        ao2_lock(q);
        clear_queue(q);
        q->realtime = 1;
        /*Before we initialize the queue, we need to set the strategy, so that linear strategy
         * will allocate the members properly
         */
        for (tmpvar = queue_vars; tmpvar; tmpvar = tmpvar->next) {
            if (!strcasecmp(tmpvar->name, "strategy")) {
                q->strategy = strat2int(tmpvar->value);
                if (q->strategy < 0) {
                    ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
                    tmpvar->value, q->name);
                    q->strategy = QUEUE_STRATEGY_RINGALL;
                }
                break;
            }
        }
        /* We traversed all variables and didn't find a strategy */
        if (!tmpvar) {
            q->strategy = QUEUE_STRATEGY_RINGALL;
        }
        queues_t_link(queues, q, "Add queue to container");
    }
    init_queue(q);      /* Ensure defaults for all parameters not set explicitly. */
 
    memset(tmpbuf, 0, sizeof(tmpbuf));
    for (v = queue_vars; v; v = v->next) {
        /* Convert to dashes `-' from underscores `_' as the latter are more SQL friendly. */
        if (strchr(v->name, '_')) {
            ast_copy_string(tmpbuf, v->name, sizeof(tmpbuf));
            tmp_name = tmpbuf;
            tmp = tmpbuf;
            while ((tmp = strchr(tmp, '_'))) {
                *tmp++ = '-';
            }
        } else {
            tmp_name = v->name;
        }
 
        /* NULL values don't get returned from realtime; blank values should
         * still get set.  If someone doesn't want a value to be set, they
         * should set the realtime column to NULL, not blank. */
        queue_set_param(q, tmp_name, v->value, -1, 0);
    }
 
    /* Temporarily set realtime members dead so we can detect deleted ones. */
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((m = ao2_iterator_next(&mem_iter))) {
        if (m->realtime) {
            m->dead = 1;
        }
        ao2_ref(m, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    while ((category = ast_category_browse(member_config, category))) {
        rt_handle_member_record(q, category, member_config);
    }
 
    /* Delete all realtime members that have been deleted in DB. */
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((m = ao2_iterator_next(&mem_iter))) {
        if (m->dead) {
            if (ast_strlen_zero(m->membername) || !log_membername_as_agent) {
                ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
            } else {
                ast_queue_log(q->name, "REALTIME", m->membername, "REMOVEMEMBER", "%s", "");
            }
            member_remove_from_queue(q, m);
        }
        ao2_ref(m, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    ao2_unlock(q);
 
    return q;
}

References alloc_queue(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_find, ao2_unlock, ast_category_browse(), ast_copy_string(), ast_debug, ast_log, ast_queue_log(), ast_strlen_zero(), clear_queue(), member::dead, call_queue::dead, init_queue(), member::interface, log_membername_as_agent, LOG_WARNING, member_remove_from_queue(), member::membername, call_queue::members, call_queue::name, ast_variable::name, ast_variable::next, NULL, OBJ_POINTER, queue_set_param(), QUEUE_STRATEGY_RINGALL, queue_t_unref, queues, queues_t_link, queues_t_unlink, member::realtime, call_queue::realtime, rt_handle_member_record(), strat2int(), call_queue::strategy, and ast_variable::value.

Referenced by find_load_queue_rt_friendly().

free_members()

static void free_members ( struct call_queue *  q, int  all  )

static

Iterate through queue's member list and delete them.

Definition at line 3844 of file app_queue.c.

{
    /* Free non-dynamic members */
    struct member *cur;
    struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
 
    while ((cur = ao2_iterator_next(&mem_iter))) {
        if (all || !cur->dynamic) {
            member_remove_from_queue(q, cur);
        }
        ao2_ref(cur, -1);
    }
    ao2_iterator_destroy(&mem_iter);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, member::dynamic, member_remove_from_queue(), and call_queue::members.

Referenced by destroy_queue().

get_interface_helper()

static struct member * get_interface_helper ( struct call_queue *  q, const char *  interface  )

static

Definition at line 9176 of file app_queue.c.

{
    struct member *m;
 
    if (ast_strlen_zero(interface)) {
        ast_log(LOG_ERROR, "QUEUE_MEMBER: Missing required interface argument.\n");
        return NULL;
    }
 
    m = interface_exists(q, interface);
    if (!m) {
        ast_log(LOG_ERROR, "Queue member interface '%s' not in queue '%s'.\n",
            interface, q->name);
    }
    return m;
}

References ast_log, ast_strlen_zero(), member::interface, interface_exists(), LOG_ERROR, call_queue::name, and NULL.

Referenced by queue_function_mem_read().

get_member_penalty()

static int get_member_penalty ( char *  queuename, char *  interface  )

static

Gets members penalty.

Returns

Return the members penalty or RESULT_FAILURE on error.

Definition at line 8217 of file app_queue.c.

{
    int foundqueue = 0, penalty;
    struct call_queue *q;
    struct member *mem;
 
    if ((q = find_load_queue_rt_friendly(queuename))) {
        foundqueue = 1;
        ao2_lock(q);
        if ((mem = interface_exists(q, interface))) {
            penalty = mem->penalty;
            ao2_ref(mem, -1);
            ao2_unlock(q);
            queue_t_unref(q, "Search complete");
            return penalty;
        }
        ao2_unlock(q);
        queue_t_unref(q, "Search complete");
    }
 
    /* some useful debugging */
    if (foundqueue) {
        ast_log (LOG_ERROR, "Invalid queuename\n");
    } else {
        ast_log (LOG_ERROR, "Invalid interface\n");
    }
 
    return RESULT_FAILURE;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_log, find_load_queue_rt_friendly(), member::interface, interface_exists(), LOG_ERROR, member::penalty, queue_t_unref, and RESULT_FAILURE.

Referenced by queue_function_memberpenalty_read().

get_member_status()

static int get_member_status ( struct call_queue *  q, int  max_penalty, int  min_penalty, int  raise_penalty, enum empty_conditions  conditions, int  devstate, int  raise_respect_min  )

static

Check if members are available.

This function checks to see if members are available to be called. If any member is available, the function immediately returns 0. If no members are available, then -1 is returned.

Definition at line 2550 of file app_queue.c.

{
    struct member *member;
    struct ao2_iterator mem_iter;
 
    ao2_lock(q);
    mem_iter = ao2_iterator_init(q->members, 0);
    for (; (member = ao2_iterator_next(&mem_iter)); ao2_ref(member, -1)) {
        int penalty = member->penalty;
        if (raise_penalty != INT_MAX && penalty < raise_penalty) {
            /* Check if we should respect minimum penalty threshold */
            if (raise_respect_min && penalty < min_penalty) {
                ast_debug(4, "%s penalty %d not raised (below min %d)\n", member->membername, penalty, min_penalty);
            } else {
                ast_debug(4, "%s is having his penalty raised up from %d to %d\n", member->membername, penalty, raise_penalty);
                penalty = raise_penalty;
            }
        }
        if ((max_penalty != INT_MAX && penalty > max_penalty) || (min_penalty != INT_MAX && penalty < min_penalty)) {
            if (conditions & QUEUE_EMPTY_PENALTY) {
                ast_debug(4, "%s is unavailable because his penalty is not between %d and %d\n", member->membername, min_penalty, max_penalty);
                continue;
            }
        }
 
        switch (devstate ? ast_device_state(member->state_interface) : member->status) {
        case AST_DEVICE_INVALID:
            if (conditions & QUEUE_EMPTY_INVALID) {
                ast_debug(4, "%s is unavailable because his device state is 'invalid'\n", member->membername);
                break;
            }
            goto default_case;
        case AST_DEVICE_UNAVAILABLE:
            if (conditions & QUEUE_EMPTY_UNAVAILABLE) {
                ast_debug(4, "%s is unavailable because his device state is 'unavailable'\n", member->membername);
                break;
            }
            goto default_case;
        case AST_DEVICE_INUSE:
            if (conditions & QUEUE_EMPTY_INUSE) {
                ast_debug(4, "%s is unavailable because his device state is 'inuse'\n", member->membername);
                break;
            }
            goto default_case;
        case AST_DEVICE_RINGING:
            if (conditions & QUEUE_EMPTY_RINGING) {
                ast_debug(4, "%s is unavailable because his device state is 'ringing'\n", member->membername);
                break;
            }
            goto default_case;
        case AST_DEVICE_UNKNOWN:
            if (conditions & QUEUE_EMPTY_UNKNOWN) {
                ast_debug(4, "%s is unavailable because his device state is 'unknown'\n", member->membername);
                break;
            }
            /* Fall-through */
        default:
        default_case:
            if (member->paused && (conditions & QUEUE_EMPTY_PAUSED)) {
                ast_debug(4, "%s is unavailable because he is paused'\n", member->membername);
                break;
            } else if ((conditions & QUEUE_EMPTY_WRAPUP)
                && member->lastcall
                && get_wrapuptime(q, member)
                && (time(NULL) - get_wrapuptime(q, member) < member->lastcall)) {
                ast_debug(4, "%s is unavailable because it has only been %d seconds since his last call (wrapup time is %d)\n",
                    member->membername, (int) (time(NULL) - member->lastcall), get_wrapuptime(q, member));
                break;
            } else {
                ao2_ref(member, -1);
                ao2_iterator_destroy(&mem_iter);
                ao2_unlock(q);
                ast_debug(4, "%s is available.\n", member->membername);
                return 0;
            }
            break;
        }
    }
    ao2_iterator_destroy(&mem_iter);
    ao2_unlock(q);
 
    if (!devstate && (conditions & QUEUE_EMPTY_RINGING)) {
        /* member state still may be RINGING due to lag in event message - check again with device state */
        return get_member_status(q, max_penalty, min_penalty, raise_penalty, conditions, 1, raise_respect_min);
    }
    return -1;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_debug, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_RINGING, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, get_member_status(), get_wrapuptime(), member::lastcall, member::membername, call_queue::members, NULL, member::paused, member::penalty, QUEUE_EMPTY_INUSE, QUEUE_EMPTY_INVALID, QUEUE_EMPTY_PAUSED, QUEUE_EMPTY_PENALTY, QUEUE_EMPTY_RINGING, QUEUE_EMPTY_UNAVAILABLE, QUEUE_EMPTY_UNKNOWN, QUEUE_EMPTY_WRAPUP, member::state_interface, and member::status.

Referenced by get_member_status(), join_queue(), queue_exec(), and wait_our_turn().

get_queue_member_status()

static int get_queue_member_status ( struct member *  cur )

static

Return the current state of a member.

Definition at line 2983 of file app_queue.c.

{
    return ast_strlen_zero(cur->state_exten) ? ast_device_state(cur->state_interface) : extensionstate2devicestate(ast_extension_state(NULL, cur->state_context, cur->state_exten));
}

References ast_extension_state(), ast_strlen_zero(), extensionstate2devicestate(), NULL, member::state_context, member::state_exten, and member::state_interface.

Referenced by can_ring_entry(), create_queue_member(), and kill_dead_members().

get_wrapuptime()

static int get_wrapuptime ( struct call_queue *  q, struct member *  member  )

static

Return wrapuptime.

This function checks if wrapuptime in member is set and return this value. Otherwise return value the wrapuptime in the queue configuration

Returns

integer value

Definition at line 2119 of file app_queue.c.

{
    if (member->wrapuptime) {
        return member->wrapuptime;
    }
    return q->wrapuptime;
}

References member::wrapuptime, and call_queue::wrapuptime.

Referenced by can_ring_entry(), get_member_status(), is_member_available(), and queue_function_mem_read().

handle_attended_transfer()

static void handle_attended_transfer ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Handle an attended transfer event.

This event is important in order to be able to log the end of the call to the queue log and to stasis.

Parameters

userdata	Data pertaining to the particular call in the queue.
sub	The stasis subscription on which the message occurred.
msg	The stasis message for the attended transfer event.

Definition at line 6616 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_attended_transfer_message *atxfer_msg = stasis_message_data(msg);
    RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, member_snapshot, NULL, ao2_cleanup);
 
    if (atxfer_msg->result != AST_BRIDGE_TRANSFER_SUCCESS ||
            atxfer_msg->dest_type == AST_ATTENDED_TRANSFER_DEST_THREEWAY) {
        return;
    }
 
    ao2_lock(queue_data);
 
    if (queue_data->dying) {
        ao2_unlock(queue_data);
        return;
    }
 
    if (ast_strlen_zero(queue_data->bridge_uniqueid)) {
        ao2_unlock(queue_data);
        return;
    }
 
    if ((!atxfer_msg->to_transferee.bridge_snapshot || strcmp(queue_data->bridge_uniqueid,
                    atxfer_msg->to_transferee.bridge_snapshot->uniqueid)) &&
             (!atxfer_msg->to_transfer_target.bridge_snapshot || strcmp(queue_data->bridge_uniqueid,
                 atxfer_msg->to_transfer_target.bridge_snapshot->uniqueid))) {
        ao2_unlock(queue_data);
        return;
    }
 
    caller_snapshot = ast_channel_snapshot_get_latest(queue_data->caller_uniqueid);
    member_snapshot = ast_channel_snapshot_get_latest(queue_data->member_uniqueid);
 
    ao2_unlock(queue_data);
 
    ast_debug(3, "Detected attended transfer in queue %s\n", queue_data->queue->name);
    log_attended_transfer(queue_data, atxfer_msg);
 
    send_agent_complete(queue_data->queue->name, caller_snapshot, member_snapshot, queue_data->member,
            queue_data->holdstart, queue_data->starttime, TRANSFER);
    update_queue(queue_data->queue, queue_data->member, queue_data->callcompletedinsl,
            queue_data->starttime);
    remove_stasis_subscriptions(queue_data);
}

References ao2_cleanup, ao2_lock, ao2_unlock, AST_ATTENDED_TRANSFER_DEST_THREEWAY, AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_snapshot_get_latest(), ast_debug, ast_strlen_zero(), ast_bridge_channel_snapshot_pair::bridge_snapshot, queue_stasis_data::bridge_uniqueid, queue_stasis_data::callcompletedinsl, queue_stasis_data::caller_uniqueid, ast_attended_transfer_message::dest_type, queue_stasis_data::dying, queue_stasis_data::holdstart, log_attended_transfer(), queue_stasis_data::member, queue_stasis_data::member_uniqueid, call_queue::name, NULL, queue_stasis_data::queue, RAII_VAR, remove_stasis_subscriptions(), ast_attended_transfer_message::result, send_agent_complete(), queue_stasis_data::starttime, stasis_message_data(), ast_attended_transfer_message::to_transfer_target, ast_attended_transfer_message::to_transferee, TRANSFER, ast_bridge_snapshot::uniqueid, and update_queue().

Referenced by setup_stasis_subs().

handle_blind_transfer()

static void handle_blind_transfer ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Handle a blind transfer event.

This event is important in order to be able to log the end of the call to the queue log and to stasis.

Parameters

userdata	Data pertaining to the particular call in the queue.
sub	The stasis subscription on which the message occurred.
msg	The stasis message for the blind transfer event

Definition at line 6557 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_blind_transfer_message *transfer_msg = stasis_message_data(msg);
    const char *exten;
    const char *context;
    RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, member_snapshot, NULL, ao2_cleanup);
 
    if (transfer_msg->result != AST_BRIDGE_TRANSFER_SUCCESS) {
        return;
    }
 
    ao2_lock(queue_data);
 
    if (queue_data->dying) {
        ao2_unlock(queue_data);
        return;
    }
 
    if (ast_strlen_zero(queue_data->bridge_uniqueid) ||
            strcmp(queue_data->bridge_uniqueid, transfer_msg->bridge->uniqueid)) {
        ao2_unlock(queue_data);
        return;
    }
 
    caller_snapshot = ast_channel_snapshot_get_latest(queue_data->caller_uniqueid);
    member_snapshot = ast_channel_snapshot_get_latest(queue_data->member_uniqueid);
 
    ao2_unlock(queue_data);
 
    exten = transfer_msg->exten;
    context = transfer_msg->context;
 
    ast_debug(3, "Detected blind transfer in queue %s\n", queue_data->queue->name);
    ast_queue_log(queue_data->queue->name, queue_data->caller_uniqueid, queue_data->member->membername,
            "BLINDTRANSFER", "%s|%s|%ld|%ld|%d",
            exten, context,
            (long) (queue_data->starttime - queue_data->holdstart),
            (long) (time(NULL) - queue_data->starttime), queue_data->caller_pos);
 
    send_agent_complete(queue_data->queue->name, caller_snapshot, member_snapshot, queue_data->member,
            queue_data->holdstart, queue_data->starttime, TRANSFER);
    update_queue(queue_data->queue, queue_data->member, queue_data->callcompletedinsl,
            queue_data->starttime);
    remove_stasis_subscriptions(queue_data);
}

References ao2_cleanup, ao2_lock, ao2_unlock, AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_snapshot_get_latest(), ast_debug, ast_queue_log(), ast_strlen_zero(), ast_blind_transfer_message::bridge, queue_stasis_data::bridge_uniqueid, queue_stasis_data::callcompletedinsl, queue_stasis_data::caller_pos, queue_stasis_data::caller_uniqueid, voicemailpwcheck::context, ast_blind_transfer_message::context, queue_stasis_data::dying, ast_blind_transfer_message::exten, queue_stasis_data::holdstart, queue_stasis_data::member, queue_stasis_data::member_uniqueid, member::membername, call_queue::name, NULL, queue_stasis_data::queue, RAII_VAR, remove_stasis_subscriptions(), ast_blind_transfer_message::result, send_agent_complete(), queue_stasis_data::starttime, stasis_message_data(), TRANSFER, ast_bridge_snapshot::uniqueid, and update_queue().

Referenced by setup_stasis_subs().

handle_bridge_enter()

static void handle_bridge_enter ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6524 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_bridge_blob *enter_blob = stasis_message_data(msg);
    SCOPED_AO2LOCK(lock, queue_data);
 
    if (queue_data->dying) {
        return;
    }
 
    if (!ast_strlen_zero(queue_data->bridge_uniqueid)) {
        return;
    }
 
    if (!strcmp(enter_blob->channel->base->uniqueid, queue_data->caller_uniqueid)) {
        ast_string_field_set(queue_data, bridge_uniqueid,
                enter_blob->bridge->uniqueid);
        ast_debug(3, "Detected entry of caller channel %s into bridge %s\n",
                enter_blob->channel->base->name, queue_data->bridge_uniqueid);
    }
}

References ast_debug, ast_string_field_set, ast_strlen_zero(), ast_channel_snapshot::base, ast_bridge_blob::bridge, queue_stasis_data::bridge_uniqueid, queue_stasis_data::caller_uniqueid, ast_bridge_blob::channel, queue_stasis_data::dying, lock, ast_channel_snapshot_base::name, SCOPED_AO2LOCK, stasis_message_data(), ast_bridge_snapshot::uniqueid, and ast_channel_snapshot_base::uniqueid.

Referenced by setup_stasis_subs().

handle_hangup()

static void handle_hangup ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6805 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_channel_blob *channel_blob = stasis_message_data(msg);
    RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, member_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
    enum agent_complete_reason reason;
 
    ao2_lock(queue_data);
 
    if (queue_data->dying) {
        ao2_unlock(queue_data);
        return;
    }
 
    if (!strcmp(channel_blob->snapshot->base->uniqueid, queue_data->caller_uniqueid)) {
        reason = CALLER;
    } else if (!strcmp(channel_blob->snapshot->base->uniqueid, queue_data->member_uniqueid)) {
        reason = AGENT;
    } else {
        ao2_unlock(queue_data);
        return;
    }
 
    chan = ast_channel_get_by_name(channel_blob->snapshot->base->name);
    if (chan && (ast_channel_has_role(chan, AST_TRANSFERER_ROLE_NAME) ||
             !ast_strlen_zero(pbx_builtin_getvar_helper(chan, "ATTENDEDTRANSFER")) ||
             !ast_strlen_zero(pbx_builtin_getvar_helper(chan, "BLINDTRANSFER")))) {
        /* Channel that is hanging up is doing it as part of a transfer.
         * We'll get a transfer event later
         */
        ao2_unlock(queue_data);
        return;
    }
 
    caller_snapshot = ast_channel_snapshot_get_latest(queue_data->caller_uniqueid);
    member_snapshot = ast_channel_snapshot_get_latest(queue_data->member_uniqueid);
 
    ao2_unlock(queue_data);
 
    ast_debug(3, "Detected hangup of queue %s channel %s\n", reason == CALLER ? "caller" : "member",
            channel_blob->snapshot->base->name);
 
    ast_queue_log(queue_data->queue->name, queue_data->caller_uniqueid, queue_data->member->membername,
            reason == CALLER ? "COMPLETECALLER" : "COMPLETEAGENT", "%ld|%ld|%d",
        (long) (queue_data->starttime - queue_data->holdstart),
        (long) (time(NULL) - queue_data->starttime), queue_data->caller_pos);
 
    send_agent_complete(queue_data->queue->name, caller_snapshot, member_snapshot, queue_data->member,
            queue_data->holdstart, queue_data->starttime, reason);
    update_queue(queue_data->queue, queue_data->member, queue_data->callcompletedinsl,
            queue_data->starttime);
    remove_stasis_subscriptions(queue_data);
}

References AGENT, ao2_cleanup, ao2_lock, ao2_unlock, ast_channel_get_by_name(), ast_channel_has_role(), ast_channel_snapshot_get_latest(), ast_debug, ast_queue_log(), ast_strlen_zero(), AST_TRANSFERER_ROLE_NAME, ast_channel_snapshot::base, queue_stasis_data::callcompletedinsl, CALLER, queue_stasis_data::caller_pos, queue_stasis_data::caller_uniqueid, queue_stasis_data::dying, queue_stasis_data::holdstart, queue_stasis_data::member, queue_stasis_data::member_uniqueid, member::membername, call_queue::name, ast_channel_snapshot_base::name, NULL, pbx_builtin_getvar_helper(), queue_stasis_data::queue, RAII_VAR, remove_stasis_subscriptions(), send_agent_complete(), ast_channel_blob::snapshot, queue_stasis_data::starttime, stasis_message_data(), ast_channel_snapshot_base::uniqueid, and update_queue().

Referenced by setup_stasis_subs().

handle_local_optimization_begin()

static void handle_local_optimization_begin ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6690 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_multi_channel_blob *optimization_blob = stasis_message_data(msg);
    struct ast_channel_snapshot *local_one = ast_multi_channel_blob_get_channel(optimization_blob, "1");
    struct ast_channel_snapshot *local_two = ast_multi_channel_blob_get_channel(optimization_blob, "2");
    struct ast_channel_snapshot *source = ast_multi_channel_blob_get_channel(optimization_blob, "source");
    struct local_optimization *optimization;
    unsigned int id;
    SCOPED_AO2LOCK(lock, queue_data);
 
    if (queue_data->dying) {
        return;
    }
 
    if (!strcmp(local_one->base->uniqueid, queue_data->member_uniqueid)) {
        optimization = &queue_data->member_optimize;
    } else if (!strcmp(local_two->base->uniqueid, queue_data->caller_uniqueid)) {
        optimization = &queue_data->caller_optimize;
    } else {
        return;
    }
 
    /* We only allow move-swap optimizations, so there had BETTER be a source */
    ast_assert(source != NULL);
 
    optimization->source_chan_uniqueid = ast_strdup(source->base->uniqueid);
    if (!optimization->source_chan_uniqueid) {
        ast_log(LOG_ERROR, "Unable to track local channel optimization for channel %s. Expect further errors\n", local_one->base->name);
        return;
    }
    id = ast_json_integer_get(ast_json_object_get(ast_multi_channel_blob_get_json(optimization_blob), "id"));
 
    optimization->id = id;
    optimization->in_progress = 1;
}

References ast_assert, ast_json_integer_get(), ast_json_object_get(), ast_log, ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), ast_strdup, ast_channel_snapshot::base, queue_stasis_data::caller_optimize, queue_stasis_data::caller_uniqueid, queue_stasis_data::dying, id, local_optimization::id, local_optimization::in_progress, lock, LOG_ERROR, queue_stasis_data::member_optimize, queue_stasis_data::member_uniqueid, ast_channel_snapshot_base::name, NULL, SCOPED_AO2LOCK, local_optimization::source_chan_uniqueid, stasis_message_data(), and ast_channel_snapshot_base::uniqueid.

Referenced by setup_stasis_subs().

handle_local_optimization_end()

static void handle_local_optimization_end ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6741 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_multi_channel_blob *optimization_blob = stasis_message_data(msg);
    struct ast_channel_snapshot *local_one = ast_multi_channel_blob_get_channel(optimization_blob, "1");
    struct ast_channel_snapshot *local_two = ast_multi_channel_blob_get_channel(optimization_blob, "2");
    struct local_optimization *optimization;
    int is_caller;
    unsigned int id;
    SCOPED_AO2LOCK(lock, queue_data);
 
    if (queue_data->dying) {
        return;
    }
 
    if (!strcmp(local_one->base->uniqueid, queue_data->member_uniqueid)) {
        optimization = &queue_data->member_optimize;
        is_caller = 0;
    } else if (!strcmp(local_two->base->uniqueid, queue_data->caller_uniqueid)) {
        optimization = &queue_data->caller_optimize;
        is_caller = 1;
    } else {
        return;
    }
 
    id = ast_json_integer_get(ast_json_object_get(ast_multi_channel_blob_get_json(optimization_blob), "id"));
 
    if (!optimization->in_progress) {
        ast_log(LOG_WARNING, "Told of a local optimization end when we had no previous begin\n");
        return;
    }
 
    if (id != optimization->id) {
        ast_log(LOG_WARNING, "Local optimization end event ID does not match begin (%u != %u)\n",
                id, optimization->id);
        return;
    }
 
    if (is_caller) {
        ast_debug(3, "Local optimization: Changing queue caller uniqueid from %s to %s\n",
                queue_data->caller_uniqueid, optimization->source_chan_uniqueid);
        ast_string_field_set(queue_data, caller_uniqueid, optimization->source_chan_uniqueid);
    } else {
        ast_debug(3, "Local optimization: Changing queue member uniqueid from %s to %s\n",
                queue_data->member_uniqueid, optimization->source_chan_uniqueid);
        ast_string_field_set(queue_data, member_uniqueid, optimization->source_chan_uniqueid);
    }
 
    optimization->in_progress = 0;
}

References ast_debug, ast_json_integer_get(), ast_json_object_get(), ast_log, ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), ast_string_field_set, ast_channel_snapshot::base, queue_stasis_data::caller_optimize, queue_stasis_data::caller_uniqueid, queue_stasis_data::dying, id, local_optimization::id, local_optimization::in_progress, lock, LOG_WARNING, queue_stasis_data::member_optimize, queue_stasis_data::member_uniqueid, SCOPED_AO2LOCK, local_optimization::source_chan_uniqueid, stasis_message_data(), and ast_channel_snapshot_base::uniqueid.

Referenced by setup_stasis_subs().

handle_masquerade()

static void handle_masquerade ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6862 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = userdata;
    struct ast_channel_blob *channel_blob = stasis_message_data(msg);
    const char *new_channel_id;
 
    new_channel_id = ast_json_string_get(ast_json_object_get(channel_blob->blob, "newchanneluniqueid"));
 
    ao2_lock(queue_data);
 
    if (queue_data->dying) {
        ao2_unlock(queue_data);
        return;
    }
 
    if (!strcmp(channel_blob->snapshot->base->uniqueid, queue_data->caller_uniqueid)) {
        ast_debug(1, "Replacing caller channel %s with %s due to masquerade\n", queue_data->caller_uniqueid, new_channel_id);
        ast_string_field_set(queue_data, caller_uniqueid, new_channel_id);
    } else if (!strcmp(channel_blob->snapshot->base->uniqueid, queue_data->member_uniqueid)) {
        ast_debug(1, "Replacing member channel %s with %s due to masquerade\n", queue_data->member_uniqueid, new_channel_id);
        ast_string_field_set(queue_data, member_uniqueid, new_channel_id);
    }
 
    ao2_unlock(queue_data);
}

References ao2_lock, ao2_unlock, ast_debug, ast_json_object_get(), ast_json_string_get(), ast_string_field_set, ast_channel_snapshot::base, ast_channel_blob::blob, queue_stasis_data::caller_uniqueid, queue_stasis_data::dying, queue_stasis_data::member_uniqueid, ast_channel_blob::snapshot, stasis_message_data(), and ast_channel_snapshot_base::uniqueid.

Referenced by setup_stasis_subs().

handle_queue_add_member()

static char * handle_queue_add_member ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11155 of file app_queue.c.

{
    const char *queuename, *interface, *membername = NULL, *state_interface = NULL, *reason = NULL;
    int penalty, paused = 0;
 
    switch ( cmd ) {
    case CLI_INIT:
        e->command = "queue add member";
        e->usage =
            "Usage: queue add member <dial string> to <queue> [penalty <penalty> [as <membername> [state_interface <interface> [paused <reason>]]]]\n"
            "       Add a dial string (Such as a channel,e.g. SIP/6001) to a queue with optionally:  a penalty, membername and a state_interface\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_add_member(a->line, a->word, a->pos, a->n);
    }
 
    if ((a->argc != 6) && (a->argc != 8) && (a->argc != 10) && (a->argc != 12) && (a->argc != 14)) {
        return CLI_SHOWUSAGE;
    } else if (strcmp(a->argv[4], "to")) {
        return CLI_SHOWUSAGE;
    } else if ((a->argc >= 8) && strcmp(a->argv[6], "penalty")) {
        return CLI_SHOWUSAGE;
    } else if ((a->argc >= 10) && strcmp(a->argv[8], "as")) {
        return CLI_SHOWUSAGE;
    } else if ((a->argc == 12) && strcmp(a->argv[10], "state_interface")) {
        return CLI_SHOWUSAGE;
    } else if ((a->argc == 14) && strcmp(a->argv[12], "paused")) {
        return CLI_SHOWUSAGE;
    }
 
    queuename = a->argv[5];
    interface = a->argv[3];
    if (a->argc >= 8) {
        if (sscanf(a->argv[7], "%30d", &penalty) == 1) {
            if (penalty < 0) {
                ast_cli(a->fd, "Penalty must be >= 0\n");
                penalty = 0;
            }
        } else {
            ast_cli(a->fd, "Penalty must be an integer >= 0\n");
            penalty = 0;
        }
    } else {
        penalty = 0;
    }
 
    if (a->argc >= 10) {
        membername = a->argv[9];
    }
 
    if (a->argc >= 12) {
        state_interface = a->argv[11];
    }
 
    if (a->argc >= 14) {
        paused = 1;
        reason = a->argv[13];
    }
 
    switch (add_to_queue(queuename, interface, membername, penalty, paused, queue_persistent_members, state_interface, reason, 0)) {
    case RES_OKAY:
        if (ast_strlen_zero(membername) || !log_membername_as_agent) {
            ast_queue_log(queuename, "CLI", interface, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        } else {
            ast_queue_log(queuename, "CLI", membername, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        }
        ast_cli(a->fd, "Added interface '%s' to queue '%s'\n", interface, queuename);
        return CLI_SUCCESS;
    case RES_EXISTS:
        ast_cli(a->fd, "Unable to add interface '%s' to queue '%s': Already there\n", interface, queuename);
        return CLI_FAILURE;
    case RES_NOSUCHQUEUE:
        ast_cli(a->fd, "Unable to add interface to queue '%s': No such queue\n", queuename);
        return CLI_FAILURE;
    case RES_OUTOFMEMORY:
        ast_cli(a->fd, "Out of memory\n");
        return CLI_FAILURE;
    case RES_NOT_DYNAMIC:
        ast_cli(a->fd, "Member not dynamic\n");
        return CLI_FAILURE;
    default:
        return CLI_FAILURE;
    }
}

References a, add_to_queue(), ast_cli(), ast_queue_log(), ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_add_member(), log_membername_as_agent, NULL, queue_persistent_members, RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_DYNAMIC, RES_OKAY, RES_OUTOFMEMORY, and ast_cli_entry::usage.

handle_queue_change_priority_caller()

static char * handle_queue_change_priority_caller ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11351 of file app_queue.c.

{
    const char *queuename, *caller;
    int priority, immediate = 0;
    char *res = CLI_FAILURE;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue priority caller";
        e->usage =
            "Usage: queue priority caller <channel> on <queue> to <priority> [immediate]\n"
            "       Change the priority of a channel on a queue, optionally applying the change in relation to existing callers.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc < 8) {
        return CLI_SHOWUSAGE;
    } else if (strcmp(a->argv[4], "on")) {
        return CLI_SHOWUSAGE;
    } else if (strcmp(a->argv[6], "to")) {
        return CLI_SHOWUSAGE;
    } else if (sscanf(a->argv[7], "%30d", &priority) != 1) {
        ast_log (LOG_ERROR, "<priority> parameter must be an integer.\n");
        return CLI_SHOWUSAGE;
    } else if (a->argc == 9) {
        if (strcmp(a->argv[8], "immediate")) {
            return CLI_SHOWUSAGE;
        }
        immediate = 1;
    }
 
    caller = a->argv[3];
    queuename = a->argv[5];
 
    switch (change_priority_caller_on_queue(queuename, caller, priority, immediate)) {
    case RES_OKAY:
        res = CLI_SUCCESS;
        break;
    case RES_NOSUCHQUEUE:
        ast_cli(a->fd, "Unable change priority caller %s on queue '%s': No such queue\n", caller, queuename);
        break;
    case RES_NOT_CALLER:
        ast_cli(a->fd, "Unable to change priority caller '%s' on queue '%s': Not there\n", caller, queuename);
 
        break;
    }
 
    return res;
}

References a, ast_cli(), ast_log, change_priority_caller_on_queue(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, LOG_ERROR, NULL, priority, RES_NOSUCHQUEUE, RES_NOT_CALLER, RES_OKAY, and ast_cli_entry::usage.

handle_queue_pause_member()

static char * handle_queue_pause_member ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11424 of file app_queue.c.

{
    const char *queuename, *interface, *reason;
    int paused;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue {pause|unpause} member";
        e->usage =
            "Usage: queue {pause|unpause} member <member> [queue <queue> [reason <reason>]]\n"
            "   Pause or unpause a queue member. Not specifying a particular queue\n"
            "   will pause or unpause a member across all queues to which the member\n"
            "   belongs.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_pause_member(a->line, a-> word, a->pos, a->n);
    }
 
    if (a->argc < 4 || a->argc == 5 || a->argc == 7 || a->argc > 8) {
        return CLI_SHOWUSAGE;
    } else if (a->argc >= 5 && strcmp(a->argv[4], "queue")) {
        return CLI_SHOWUSAGE;
    } else if (a->argc == 8 && strcmp(a->argv[6], "reason")) {
        return CLI_SHOWUSAGE;
    }
 
 
    interface = a->argv[3];
    queuename = a->argc >= 6 ? a->argv[5] : NULL;
    reason = a->argc == 8 ? a->argv[7] : NULL;
    paused = !strcasecmp(a->argv[1], "pause");
 
    if (set_member_paused(queuename, interface, reason, paused) == RESULT_SUCCESS) {
        ast_cli(a->fd, "%spaused interface '%s'", paused ? "" : "un", interface);
        if (!ast_strlen_zero(queuename)) {
            ast_cli(a->fd, " in queue '%s'", queuename);
        }
        if (!ast_strlen_zero(reason)) {
            ast_cli(a->fd, " for reason '%s'", reason);
        }
        ast_cli(a->fd, "\n");
        return CLI_SUCCESS;
    } else {
        ast_cli(a->fd, "Unable to %spause interface '%s'", paused ? "" : "un", interface);
        if (!ast_strlen_zero(queuename)) {
            ast_cli(a->fd, " in queue '%s'", queuename);
        }
        if (!ast_strlen_zero(reason)) {
            ast_cli(a->fd, " for reason '%s'", reason);
        }
        ast_cli(a->fd, "\n");
        return CLI_FAILURE;
    }
}

References a, ast_cli(), ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_pause_member(), NULL, RESULT_SUCCESS, set_member_paused(), and ast_cli_entry::usage.

handle_queue_reload()

static char * handle_queue_reload ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11696 of file app_queue.c.

{
    struct ast_flags mask = {0,};
    int i;
 
    switch (cmd) {
        case CLI_INIT:
            e->command = "queue reload {parameters|members|rules|all}";
            e->usage =
                "Usage: queue reload {parameters|members|rules|all} [<queuenames>]\n"
                "Reload queues. If <queuenames> are specified, only reload information pertaining\n"
                "to <queuenames>. One of 'parameters,' 'members,' 'rules,' or 'all' must be\n"
                "specified in order to know what information to reload. Below is an explanation\n"
                "of each of these qualifiers.\n"
                "\n"
                "\t'members' - reload queue members from queues.conf\n"
                "\t'parameters' - reload all queue options except for queue members\n"
                "\t'rules' - reload the queuerules.conf file\n"
                "\t'all' - reload queue rules, parameters, and members\n"
                "\n"
                "Note: the 'rules' qualifier here cannot actually be applied to a specific queue.\n"
                "Use of the 'rules' qualifier causes queuerules.conf to be reloaded. Even if only\n"
                "one queue is specified when using this command, reloading queue rules may cause\n"
                "other queues to be affected\n";
            return NULL;
        case CLI_GENERATE:
            if (a->pos >= 3) {
                /* find the point at which the list of queue names starts */
                const char *command_end = a->line + strlen("queue reload ");
                command_end = strchr(command_end, ' ');
                if (!command_end) {
                    command_end = a->line + strlen(a->line);
                }
                return complete_queue(a->line, a->word, a->pos, a->n, command_end - a->line);
            } else {
                return NULL;
            }
    }
 
    if (a->argc < 3)
        return CLI_SHOWUSAGE;
 
    if (!strcasecmp(a->argv[2], "rules")) {
        ast_set_flag(&mask, QUEUE_RELOAD_RULES);
    } else if (!strcasecmp(a->argv[2], "members")) {
        ast_set_flag(&mask, QUEUE_RELOAD_MEMBER);
    } else if (!strcasecmp(a->argv[2], "parameters")) {
        ast_set_flag(&mask, QUEUE_RELOAD_PARAMETERS);
    } else if (!strcasecmp(a->argv[2], "all")) {
        ast_set_flag(&mask, AST_FLAGS_ALL & ~QUEUE_RESET_STATS);
    }
 
    if (a->argc == 3) {
        reload_handler(1, &mask, NULL);
        return CLI_SUCCESS;
    }
 
    for (i = 3; i < a->argc; ++i) {
        reload_handler(1, &mask, a->argv[i]);
    }
 
    return CLI_SUCCESS;
}

References a, AST_FLAGS_ALL, ast_set_flag, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue(), NULL, QUEUE_RELOAD_MEMBER, QUEUE_RELOAD_PARAMETERS, QUEUE_RELOAD_RULES, QUEUE_RESET_STATS, reload_handler(), and ast_cli_entry::usage.

handle_queue_remove_member()

static char * handle_queue_remove_member ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11288 of file app_queue.c.

{
    const char *queuename, *interface;
    struct member *mem = NULL;
    char *res = CLI_FAILURE;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue remove member";
        e->usage =
            "Usage: queue remove member <channel> from <queue>\n"
            "       Remove a specific channel from a queue.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_remove_member(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 6) {
        return CLI_SHOWUSAGE;
    } else if (strcmp(a->argv[4], "from")) {
        return CLI_SHOWUSAGE;
    }
 
    queuename = a->argv[5];
    interface = a->argv[3];
 
    if (log_membername_as_agent) {
        mem = find_member_by_queuename_and_interface(queuename, interface);
    }
 
    switch (remove_from_queue(queuename, interface)) {
    case RES_OKAY:
        if (!mem || ast_strlen_zero(mem->membername)) {
            ast_queue_log(queuename, "CLI", interface, "REMOVEMEMBER", "%s", "");
        } else {
            ast_queue_log(queuename, "CLI", mem->membername, "REMOVEMEMBER", "%s", "");
        }
        ast_cli(a->fd, "Removed interface %s from queue '%s'\n", interface, queuename);
        res = CLI_SUCCESS;
        break;
    case RES_EXISTS:
        ast_cli(a->fd, "Unable to remove interface '%s' from queue '%s': Not there\n", interface, queuename);
        break;
    case RES_NOSUCHQUEUE:
        ast_cli(a->fd, "Unable to remove interface from queue '%s': No such queue\n", queuename);
        break;
    case RES_OUTOFMEMORY:
        ast_cli(a->fd, "Out of memory\n");
        break;
    case RES_NOT_DYNAMIC:
        ast_cli(a->fd, "Unable to remove interface '%s' from queue '%s': Member is not dynamic\n", interface, queuename);
        break;
    }
 
    if (mem) {
        ao2_ref(mem, -1);
    }
 
    return res;
}

References a, ao2_ref, ast_cli(), ast_queue_log(), ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_remove_member(), find_member_by_queuename_and_interface(), log_membername_as_agent, member::membername, NULL, remove_from_queue(), RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_DYNAMIC, RES_OKAY, RES_OUTOFMEMORY, and ast_cli_entry::usage.

handle_queue_reset()

static char * handle_queue_reset ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11657 of file app_queue.c.

{
    struct ast_flags mask = {QUEUE_RESET_STATS,};
    int i;
 
    switch (cmd) {
        case CLI_INIT:
            e->command = "queue reset stats";
            e->usage =
                "Usage: queue reset stats [<queuenames>]\n"
                "\n"
                "Issuing this command will reset statistics for\n"
                "<queuenames>, or for all queues if no queue is\n"
                "specified.\n";
            return NULL;
        case CLI_GENERATE:
            if (a->pos >= 3) {
                return complete_queue(a->line, a->word, a->pos, a->n, 17);
            } else {
                return NULL;
            }
    }
 
    if (a->argc < 3) {
        return CLI_SHOWUSAGE;
    }
 
    if (a->argc == 3) {
        reload_handler(1, &mask, NULL);
        return CLI_SUCCESS;
    }
 
    for (i = 3; i < a->argc; ++i) {
        reload_handler(1, &mask, a->argv[i]);
    }
 
    return CLI_SUCCESS;
}

References a, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue(), NULL, QUEUE_RESET_STATS, reload_handler(), and ast_cli_entry::usage.

handle_queue_rule_show()

static char * handle_queue_rule_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11622 of file app_queue.c.

{
    const char *rule;
    struct rule_list *rl_iter;
    struct penalty_rule *pr_iter;
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue show rules";
        e->usage =
        "Usage: queue show rules [rulename]\n"
        "   Show the list of rules associated with rulename. If no\n"
        "   rulename is specified, list all rules defined in queuerules.conf\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_rule_show(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 3 && a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    rule = a->argc == 4 ? a->argv[3] : "";
    AST_LIST_LOCK(&rule_lists);
    AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
        if (ast_strlen_zero(rule) || !strcasecmp(rl_iter->name, rule)) {
            ast_cli(a->fd, "Rule: %s\n", rl_iter->name);
            AST_LIST_TRAVERSE(&rl_iter->rules, pr_iter, list) {
                ast_cli(a->fd, "\tAfter %d seconds, adjust QUEUE_MAX_PENALTY %s %d, adjust QUEUE_MIN_PENALTY %s %d and adjust QUEUE_RAISE_PENALTY %s %d\n", pr_iter->time, pr_iter->max_relative ? "by" : "to", pr_iter->max_value, pr_iter->min_relative ? "by" : "to", pr_iter->min_value, pr_iter->raise_relative ? "by" : "to", pr_iter->raise_value);
            }
        }
    }
    AST_LIST_UNLOCK(&rule_lists);
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_rule_show(), penalty_rule::list, penalty_rule::max_relative, penalty_rule::max_value, penalty_rule::min_relative, penalty_rule::min_value, rule_list::name, NULL, penalty_rule::raise_relative, penalty_rule::raise_value, rule_list::rules, penalty_rule::time, and ast_cli_entry::usage.

handle_queue_set_member_penalty()

static char * handle_queue_set_member_penalty ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11559 of file app_queue.c.

{
    const char *queuename = NULL, *interface;
    int penalty = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue set penalty";
        e->usage =
        "Usage: queue set penalty <penalty> on <interface> [in <queue>]\n"
        "   Set a member's penalty in the queue specified. If no queue is specified\n"
        "   then that interface's penalty is set in all queues to which that interface is a member\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_set_member_value(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 6 && a->argc != 8) {
        return CLI_SHOWUSAGE;
    } else if (strcmp(a->argv[4], "on") || (a->argc > 6 && strcmp(a->argv[6], "in"))) {
        return CLI_SHOWUSAGE;
    }
 
    if (a->argc == 8) {
        queuename = a->argv[7];
    }
    interface = a->argv[5];
    penalty = atoi(a->argv[3]);
 
    switch (set_member_value(queuename, interface, MEMBER_PENALTY, penalty)) {
    case RESULT_SUCCESS:
        ast_cli(a->fd, "Set penalty on interface '%s' from queue '%s'\n", interface, queuename);
        return CLI_SUCCESS;
    case RESULT_FAILURE:
        ast_cli(a->fd, "Failed to set penalty on interface '%s' from queue '%s'\n", interface, queuename);
        return CLI_FAILURE;
    default:
        return CLI_FAILURE;
    }
}

References a, ast_cli(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_set_member_value(), MEMBER_PENALTY, NULL, RESULT_FAILURE, RESULT_SUCCESS, set_member_value(), and ast_cli_entry::usage.

handle_queue_set_member_ringinuse()

static char * handle_queue_set_member_ringinuse ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 11502 of file app_queue.c.

{
    const char *queuename = NULL, *interface;
    int ringinuse;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "queue set ringinuse";
        e->usage =
        "Usage: queue set ringinuse <yes/no> on <interface> [in <queue>]\n"
        "   Set a member's ringinuse in the queue specified. If no queue is specified\n"
        "   then that interface's penalty is set in all queues to which that interface is a member.\n";
        break;
        return NULL;
    case CLI_GENERATE:
        return complete_queue_set_member_value(a->line, a->word, a->pos, a->n);
    }
 
    /* Sensible argument counts */
    if (a->argc != 6 && a->argc != 8) {
        return CLI_SHOWUSAGE;
    }
 
    /* Uses proper indicational words */
    if (strcmp(a->argv[4], "on") || (a->argc > 6 && strcmp(a->argv[6], "in"))) {
        return CLI_SHOWUSAGE;
    }
 
    /* Set the queue name if applicable */
    if (a->argc == 8) {
        queuename = a->argv[7];
    }
 
    /* Interface being set */
    interface = a->argv[5];
 
    /* Check and set the ringinuse value */
    if (ast_true(a->argv[3])) {
        ringinuse = 1;
    } else if (ast_false(a->argv[3])) {
        ringinuse = 0;
    } else {
        return CLI_SHOWUSAGE;
    }
 
    switch (set_member_value(queuename, interface, MEMBER_RINGINUSE, ringinuse)) {
    case RESULT_SUCCESS:
        ast_cli(a->fd, "Set ringinuse on interface '%s' from queue '%s'\n", interface, queuename);
        return CLI_SUCCESS;
    case RESULT_FAILURE:
        ast_cli(a->fd, "Failed to set ringinuse on interface '%s' from queue '%s'\n", interface, queuename);
        return CLI_FAILURE;
    default:
        return CLI_FAILURE;
    }
}

References a, ast_cli(), ast_false(), ast_true(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_queue_set_member_value(), MEMBER_RINGINUSE, NULL, RESULT_FAILURE, RESULT_SUCCESS, set_member_value(), and ast_cli_entry::usage.

hangupcalls()

static void hangupcalls ( struct queue_ent *  qe, struct callattempt *  outgoing, struct ast_channel *  exception, int  cancel_answered_elsewhere  )

static

Hang up a list of outgoing calls.

Definition at line 4617 of file app_queue.c.

{
    struct callattempt *oo;
 
    while (outgoing) {
        /* If someone else answered the call we should indicate this in the CANCEL */
        /* Hangup any existing lines we have open */
        if (outgoing->chan && (outgoing->chan != exception)) {
            if (exception || cancel_answered_elsewhere) {
                ast_channel_hangupcause_set(outgoing->chan, AST_CAUSE_ANSWERED_ELSEWHERE);
            }
            ast_channel_publish_dial(qe->chan, outgoing->chan, outgoing->interface, "CANCEL");
 
            /* When dialing channels it is possible that they may not ever
             * leave the not in use state (Local channels in particular) by
             * the time we cancel them. If this occurs but we know they were
             * dialed we explicitly remove them from the pending members
             * container so that subsequent call attempts occur.
             */
            if (outgoing->member->status == AST_DEVICE_NOT_INUSE) {
                pending_members_remove(outgoing->member);
            }
 
            ast_hangup(outgoing->chan);
        }
        oo = outgoing;
        outgoing = outgoing->q_next;
        ast_aoc_destroy_decoded(oo->aoc_s_rate_list);
        callattempt_free(oo);
    }
}

References callattempt::aoc_s_rate_list, ast_aoc_destroy_decoded(), AST_CAUSE_ANSWERED_ELSEWHERE, ast_channel_hangupcause_set(), ast_channel_publish_dial(), AST_DEVICE_NOT_INUSE, ast_hangup(), callattempt_free(), queue_ent::chan, and pending_members_remove().

Referenced by try_calling().

init_queue()

static void init_queue ( struct call_queue *  q )

static

Initialize Queue default values.

Note

the queue's lock must be held before executing this function

Definition at line 3082 of file app_queue.c.

{
    int i;
    struct penalty_rule *pr_iter;
 
    q->dead = 0;
    q->retry = DEFAULT_RETRY;
    q->timeout = DEFAULT_TIMEOUT;
    q->maxlen = 0;
 
    ast_string_field_set(q, announce, "");
    ast_string_field_set(q, context, "");
    ast_string_field_set(q, membergosub, "");
    ast_string_field_set(q, defaultrule, "");
 
    q->announcefrequency = 0;
    q->minannouncefrequency = DEFAULT_MIN_ANNOUNCE_FREQUENCY;
    q->announceholdtime = 1;
    q->announceposition_only_up = 0;
    q->announcepositionlimit = 10; /* Default 10 positions */
    q->announceposition = ANNOUNCEPOSITION_YES; /* Default yes */
    q->roundingseconds = 0; /* Default - don't announce seconds */
    q->servicelevel = 0;
    q->ringinuse = 1;
    q->announce_to_first_user = 0;
    q->setinterfacevar = 0;
    q->setqueuevar = 0;
    q->setqueueentryvar = 0;
    q->autofill = autofill_default;
    q->monfmt[0] = '\0';
    q->reportholdtime = 0;
    q->wrapuptime = 0;
    q->penaltymemberslimit = 0;
    q->joinempty = 0;
    q->leavewhenempty = 0;
    q->memberdelay = 0;
    q->weight = 0;
    q->timeoutrestart = 0;
    q->periodicannouncefrequency = 0;
    q->periodicannouncestartdelay = -1;
    q->randomperiodicannounce = 0;
    q->numperiodicannounce = 0;
    q->relativeperiodicannounce = 0;
    q->autopause = QUEUE_AUTOPAUSE_OFF;
    q->autopausebusy = 0;
    q->autopauseunavail = 0;
    q->timeoutpriority = TIMEOUT_PRIORITY_APP;
    q->autopausedelay = 0;
    q->log_restricted_caller_id = 1;
    if (!q->members) {
        if (q->strategy == QUEUE_STRATEGY_LINEAR || q->strategy == QUEUE_STRATEGY_RRORDERED) {
            /* linear strategy depends on order, so we have to place all members in a list */
            q->members = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, member_cmp_fn);
        } else {
            q->members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
                member_hash_fn, NULL, member_cmp_fn);
        }
    }
    q->found = 1;
 
    ast_string_field_set(q, moh, "");
    ast_string_field_set(q, sound_next, "queue-youarenext");
    ast_string_field_set(q, sound_thereare, "queue-thereare");
    ast_string_field_set(q, sound_calls, "queue-callswaiting");
    ast_string_field_set(q, queue_quantity1, "queue-quantity1");
    ast_string_field_set(q, queue_quantity2, "queue-quantity2");
    ast_string_field_set(q, sound_holdtime, "queue-holdtime");
    ast_string_field_set(q, sound_minutes, "queue-minutes");
    ast_string_field_set(q, sound_minute, "queue-minute");
    ast_string_field_set(q, sound_seconds, "queue-seconds");
    ast_string_field_set(q, sound_thanks, "queue-thankyou");
    ast_string_field_set(q, sound_callerannounce, "");
    ast_string_field_set(q, sound_reporthold, "queue-reporthold");
 
    if (!q->sound_periodicannounce[0]) {
        q->sound_periodicannounce[0] = ast_str_create(32);
    }
 
    if (q->sound_periodicannounce[0]) {
        ast_str_set(&q->sound_periodicannounce[0], 0, "queue-periodic-announce");
    }
 
    for (i = 1; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
        if (q->sound_periodicannounce[i]) {
            ast_str_set(&q->sound_periodicannounce[i], 0, "%s", "");
        }
    }
 
    while ((pr_iter = AST_LIST_REMOVE_HEAD(&q->rules,list))) {
        ast_free(pr_iter);
    }
 
    /* On restart assume no members are available.
     * The queue_avail hint is a boolean state to indicate whether a member is available or not.
     *
     * This seems counter intuitive, but is required to light a BLF
     * AST_DEVICE_INUSE indicates no members are available.
     * AST_DEVICE_NOT_INUSE indicates a member is available.
     */
    ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
}

References call_queue::announce_to_first_user, call_queue::announcefrequency, call_queue::announceholdtime, call_queue::announceposition, call_queue::announceposition_only_up, ANNOUNCEPOSITION_YES, call_queue::announcepositionlimit, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_container_alloc_list, AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_free, AST_LIST_REMOVE_HEAD, ast_str_create, ast_str_set(), ast_string_field_set, call_queue::autofill, autofill_default, call_queue::autopause, call_queue::autopausebusy, call_queue::autopausedelay, call_queue::autopauseunavail, voicemailpwcheck::context, call_queue::dead, DEFAULT_MIN_ANNOUNCE_FREQUENCY, DEFAULT_RETRY, DEFAULT_TIMEOUT, call_queue::found, call_queue::joinempty, call_queue::leavewhenempty, penalty_rule::list, call_queue::log_restricted_caller_id, MAX_PERIODIC_ANNOUNCEMENTS, call_queue::maxlen, member_cmp_fn(), member_hash_fn(), call_queue::memberdelay, call_queue::members, call_queue::minannouncefrequency, call_queue::monfmt, call_queue::name, NULL, call_queue::numperiodicannounce, call_queue::penaltymemberslimit, call_queue::periodicannouncefrequency, call_queue::periodicannouncestartdelay, QUEUE_AUTOPAUSE_OFF, QUEUE_STRATEGY_LINEAR, QUEUE_STRATEGY_RRORDERED, call_queue::randomperiodicannounce, call_queue::relativeperiodicannounce, call_queue::reportholdtime, call_queue::retry, call_queue::ringinuse, call_queue::roundingseconds, call_queue::rules, call_queue::servicelevel, call_queue::setinterfacevar, call_queue::setqueueentryvar, call_queue::setqueuevar, call_queue::sound_periodicannounce, call_queue::strategy, call_queue::timeout, TIMEOUT_PRIORITY_APP, call_queue::timeoutpriority, call_queue::timeoutrestart, call_queue::weight, and call_queue::wrapuptime.

Referenced by find_queue_by_name_rt(), and reload_single_queue().

insert_entry()

static void insert_entry ( struct call_queue *  q, struct queue_ent *  prev, struct queue_ent *  new, int *  pos  )

inlinestatic

Insert the 'new' entry after the 'prev' entry of queue 'q'.

Definition at line 2217 of file app_queue.c.

{
    struct queue_ent *cur;
 
    if (!q || !new)
        return;
    if (prev) {
        cur = prev->next;
        prev->next = new;
    } else {
        cur = q->head;
        q->head = new;
    }
    new->next = cur;
 
    /* every queue_ent must have a reference to it's parent call_queue, this
     * reference does not go away until the end of the queue_ent's life, meaning
     * that even when the queue_ent leaves the call_queue this ref must remain. */
    if (!new->parent) {
        queue_ref(q);
        new->parent = q;
    }
    new->pos = ++(*pos);
    new->opos = *pos;
}

References call_queue::head, queue_ent::next, queue_ent::pos, and queue_ref.

Referenced by change_priority_caller_on_queue(), and join_queue().

insert_penaltychange()

static int insert_penaltychange ( const char *  list_name, const char *  content, const int  linenum  )

static

Change queue penalty by adding rule.

Check rule for errors with time or formatting, see if rule is relative to rest of queue, iterate list of rules to find correct insertion point, insert and return.

Return values

-1	on failure
0	on success

Note

Call this with the rule_lists locked

Definition at line 3216 of file app_queue.c.

{
    char *timestr, *maxstr, *minstr, *raisestr, *contentdup;
    struct penalty_rule *rule = NULL, *rule_iter;
    struct rule_list *rl_iter;
    int penaltychangetime, inserted = 0;
 
    if (!(rule = ast_calloc(1, sizeof(*rule)))) {
        return -1;
    }
 
    contentdup = ast_strdupa(content);
 
    if (!(maxstr = strchr(contentdup, ','))) {
        ast_log(LOG_WARNING, "Improperly formatted penaltychange rule at line %d. Ignoring.\n", linenum);
        ast_free(rule);
        return -1;
    }
 
    *maxstr++ = '\0';
    if ((minstr = strchr(maxstr,','))) {
        *minstr++ = '\0';
        if ((raisestr = strchr(minstr,','))) {
            *raisestr++ = '\0';
        }
    } else {
        raisestr = NULL;
    }
 
    timestr = contentdup;
    if ((penaltychangetime = atoi(timestr)) < 0) {
        ast_log(LOG_WARNING, "Improper time parameter specified for penaltychange rule at line %d. Ignoring.\n", linenum);
        ast_free(rule);
        return -1;
    }
 
    rule->time = penaltychangetime;
 
    /* The last check will evaluate true if either no penalty change is indicated for a given rule
     * OR if a min penalty change is indicated but no max penalty change is */
    if (*maxstr == '+' || *maxstr == '-' || *maxstr == '\0') {
        rule->max_relative = 1;
    }
 
    rule->max_value = atoi(maxstr);
 
    if (!ast_strlen_zero(minstr)) {
        if (*minstr == '+' || *minstr == '-') {
            rule->min_relative = 1;
        }
        rule->min_value = atoi(minstr);
    } else { /*there was no minimum specified, so assume this means no change*/
        rule->min_relative = 1;
    }
 
    if (!ast_strlen_zero(raisestr)) {
        rule->raise_respect_min = 0;  /* Initialize to 0 */
        if (*raisestr == 'r') {
            rule->raise_respect_min = 1;               /* Set the flag */
            raisestr++;
        }
        if (*raisestr == '+' || *raisestr == '-') {
            rule->raise_relative = 1;
        }
        rule->raise_value = atoi(raisestr);
    } else { /*there was no raise specified, so assume this means no change*/
        rule->raise_relative = 1;
    }
 
    /*We have the rule made, now we need to insert it where it belongs*/
    AST_LIST_TRAVERSE(&rule_lists, rl_iter, list){
        if (strcasecmp(rl_iter->name, list_name)) {
            continue;
        }
 
        AST_LIST_TRAVERSE_SAFE_BEGIN(&rl_iter->rules, rule_iter, list) {
            if (rule->time < rule_iter->time) {
                AST_LIST_INSERT_BEFORE_CURRENT(rule, list);
                inserted = 1;
                break;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
 
        if (!inserted) {
            AST_LIST_INSERT_TAIL(&rl_iter->rules, rule, list);
            inserted = 1;
        }
 
        break;
    }
 
    if (!inserted) {
        ast_log(LOG_WARNING, "Unknown rule list name %s; ignoring.\n", list_name);
        ast_free(rule);
        return -1;
    }
    return 0;
}

References ast_calloc, ast_free, AST_LIST_INSERT_BEFORE_CURRENT, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, ast_strdupa, ast_strlen_zero(), rule_list::list, LOG_WARNING, rule_list::name, NULL, and rule_list::rules.

Referenced by reload_queue_rules().

int2strat()

static const char * int2strat ( int  strategy )

static

Definition at line 2050 of file app_queue.c.

{
    int x;
 
    for (x = 0; x < ARRAY_LEN(strategies); x++) {
        if (strategy == strategies[x].strategy) {
            return strategies[x].name;
        }
    }
 
    return "<unknown>";
}

References ARRAY_LEN, strategy::name, and strategies.

Referenced by manager_queues_status(), print_queue(), queue_function_var(), and set_queue_variables().

interface_exists()

static struct member * interface_exists ( struct call_queue *  q, const char *  interface  )

static

Definition at line 7606 of file app_queue.c.

{
    struct member *mem;
    struct ao2_iterator mem_iter;
 
    if (!q) {
        return NULL;
    }
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((mem = ao2_iterator_next(&mem_iter))) {
        if (!strcasecmp(interface, mem->interface)) {
            ao2_iterator_destroy(&mem_iter);
            return mem;
        }
        ao2_ref(mem, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    return NULL;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, member::interface, call_queue::members, and NULL.

Referenced by add_to_queue(), get_interface_helper(), get_member_penalty(), rna(), set_member_paused(), set_member_penalty_help_members(), and set_member_ringinuse_help_members().

is_longest_waiting_caller()

static int is_longest_waiting_caller ( struct queue_ent *  caller, struct member *  member  )

static

Definition at line 4724 of file app_queue.c.

{
    struct call_queue *q;
    struct member *mem;
    int is_longest_waiting = 1;
    struct ao2_iterator queue_iter;
    struct queue_ent *ch;
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        if (q == caller->parent) { /* don't check myself, could deadlock */
            queue_t_unref(q, "Done with iterator");
            continue;
        }
        ao2_lock(q);
        /*
         * If the other queue has equal weight, see if we should let that handle
         * their call first. If weights are not equal, compare_weights will step in.
         */
        if (q->weight == caller->parent->weight && q->count && q->members) {
            if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
                ast_debug(2, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
 
                /* Does this queue have a caller that's been waiting longer? */
                ch = q->head;
                while (ch) {
                    /* If ch->pending, the other call (which may be waiting for a longer period of time),
                     * is already ringing at another agent. Ignore such callers; otherwise, all agents
                     * will be unused until the first caller is picked up.
                     */
                    if (ch->start < caller->start && !ch->pending) {
                        ast_debug(1, "Queue %s has a call at position %i that's been waiting longer (%li vs %li)\n",
                                  q->name, ch->pos, ch->start, caller->start);
                        is_longest_waiting = 0;
                        break;
                    }
                    ch = ch->next;
                }
            }
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
        if (!is_longest_waiting) {
            break;
        }
    }
    ao2_iterator_destroy(&queue_iter);
    return is_longest_waiting;
}

References ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_lock, ao2_t_iterator_next, ao2_unlock, ast_debug, call_queue::count, call_queue::head, member::interface, call_queue::members, call_queue::name, queue_ent::next, OBJ_POINTER, queue_ent::parent, queue_ent::pending, queue_ent::pos, queue_t_unref, queues, queue_ent::start, and call_queue::weight.

Referenced by can_ring_entry().

is_member_available()

static int is_member_available ( struct call_queue *  q, struct member *  mem  )

static

Definition at line 2739 of file app_queue.c.

{
    int available = 0;
    int wrapuptime;
 
    switch (mem->status) {
        case AST_DEVICE_INVALID:
        case AST_DEVICE_UNAVAILABLE:
            break;
        case AST_DEVICE_INUSE:
        case AST_DEVICE_BUSY:
        case AST_DEVICE_RINGING:
        case AST_DEVICE_RINGINUSE:
        case AST_DEVICE_ONHOLD:
            if (!mem->ringinuse) {
                break;
            }
            /* else fall through */
        case AST_DEVICE_NOT_INUSE:
        case AST_DEVICE_UNKNOWN:
            if (!mem->paused) {
                available = 1;
            }
            break;
    }
 
    /* Let wrapuptimes override device state availability */
    wrapuptime = get_wrapuptime(q, mem);
    if (mem->lastcall && wrapuptime && (time(NULL) - wrapuptime < mem->lastcall)) {
        available = 0;
    }
    return available;
}

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, available(), get_wrapuptime(), member::lastcall, NULL, member::paused, member::ringinuse, member::status, and member::wrapuptime.

Referenced by add_to_queue(), device_state_cb(), num_available_members(), and set_queue_member_pause().

is_our_turn()

static int is_our_turn ( struct queue_ent *  qe )

static

Check if we should start attempting to call queue members.

A simple process, really. Count the number of members who are available to take our call and then see if we are in a position in the queue at which a member could accept our call.

Parameters

[in]

qe

The caller who wants to know if it is his turn

Return values

0	It is not our turn
1	It is our turn

Definition at line 5893 of file app_queue.c.

{
    struct queue_ent *ch;
    int res;
    int avl;
    int idx = 0;
    /* This needs a lock. How many members are available to be served? */
    ao2_lock(qe->parent);
 
    avl = num_available_members(qe->parent);
 
    ch = qe->parent->head;
 
    ast_debug(1, "There %s %d available %s.\n", avl != 1 ? "are" : "is", avl, avl != 1 ? "members" : "member");
 
    while ((idx < avl) && (ch) && (ch != qe)) {
        if (!ch->pending) {
            idx++;
        }
        ch = ch->next;
    }
 
    ao2_unlock(qe->parent);
    /* If the queue entry is within avl [the number of available members] calls from the top ...
     * Autofill and position check added to support autofill=no (as only calls
     * from the front of the queue are valid when autofill is disabled)
     */
    if (ch && idx < avl && (qe->parent->autofill || qe->pos == 1)) {
        ast_debug(1, "It's our turn (%s).\n", ast_channel_name(qe->chan));
        res = 1;
    } else {
        ast_debug(1, "It's not our turn (%s).\n", ast_channel_name(qe->chan));
        res = 0;
    }
 
    /* Update realtime members if this is the first call and number of avalable members is 0 */
    if (avl == 0 && qe->pos == 1) {
        update_realtime_members(qe->parent);
    }
 
    return res;
}

References ao2_lock, ao2_unlock, ast_channel_name(), ast_debug, call_queue::autofill, queue_ent::chan, call_queue::head, queue_ent::next, num_available_members(), queue_ent::parent, queue_ent::pending, queue_ent::pos, and update_realtime_members().

Referenced by queue_exec(), and wait_our_turn().

join_queue()

static int join_queue ( char *  queuename, struct queue_ent *  qe, enum queue_result *  reason, int  position  )

static

Definition at line 4207 of file app_queue.c.

{
    struct call_queue *q;
    struct queue_ent *cur, *prev = NULL;
    int res = -1;
    int pos = 0;
    int inserted = 0;
 
    if (!(q = find_load_queue_rt_friendly(queuename))) {
        return res;
    }
    ao2_lock(q);
 
    /* This is our one */
    if (q->joinempty) {
        int status = 0;
        if ((status = get_member_status(q, qe->max_penalty, qe->min_penalty, qe->raise_penalty, q->joinempty, 0, qe->raise_respect_min))) {
            *reason = QUEUE_JOINEMPTY;
            ao2_unlock(q);
            queue_t_unref(q, "Done with realtime queue");
            return res;
        }
    }
    if (*reason == QUEUE_UNKNOWN && q->maxlen && (q->count >= q->maxlen)) {
        *reason = QUEUE_FULL;
    } else if (*reason == QUEUE_UNKNOWN) {
        RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
        /* There's space for us, put us at the right position inside
         * the queue.
         * Take into account the priority of the calling user */
        inserted = 0;
        prev = NULL;
        cur = q->head;
        while (cur) {
            /* We have higher priority than the current user, enter
             * before him, after all the other users with priority
             * higher or equal to our priority. */
            if ((!inserted) && (qe->prio > cur->prio)) {
                insert_entry(q, prev, qe, &pos);
                inserted = 1;
            }
            /* <= is necessary for the position comparison because it may not be possible to enter
             * at our desired position since higher-priority callers may have taken the position we want
             */
            if (!inserted && (qe->prio >= cur->prio) && position && (position <= pos + 1)) {
                insert_entry(q, prev, qe, &pos);
                inserted = 1;
                /*pos is incremented inside insert_entry, so don't need to add 1 here*/
                if (position < pos) {
                    ast_log(LOG_NOTICE, "Asked to be inserted at position %d but forced into position %d due to higher priority callers\n", position, pos);
                }
            }
            cur->pos = ++pos;
            prev = cur;
            cur = cur->next;
        }
        /* No luck, join at the end of the queue */
        if (!inserted) {
            insert_entry(q, prev, qe, &pos);
        }
        ast_copy_string(qe->moh, q->moh, sizeof(qe->moh));
        ast_copy_string(qe->announce, q->announce, sizeof(qe->announce));
        ast_copy_string(qe->context, q->context, sizeof(qe->context));
        q->count++;
        if (q->count == 1) {
            ast_devstate_changed(AST_DEVICE_RINGING, AST_DEVSTATE_CACHABLE, "Queue:%s", q->name);
        }
 
        res = 0;
 
        blob = ast_json_pack("{s: s, s: i, s: i}",
                     "Queue", q->name,
                     "Position", qe->pos,
                     "Count", q->count);
        ast_channel_publish_cached_blob(qe->chan, queue_caller_join_type(), blob);
        ast_debug(1, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, ast_channel_name(qe->chan), qe->pos );
    }
    ao2_unlock(q);
    queue_t_unref(q, "Done with realtime queue");
 
    return res;
}

References queue_ent::announce, call_queue::announce, ao2_lock, ao2_unlock, ast_channel_name(), ast_channel_publish_cached_blob(), ast_copy_string(), ast_debug, AST_DEVICE_RINGING, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_json_pack(), ast_json_unref(), ast_log, queue_ent::chan, queue_ent::context, call_queue::context, call_queue::count, find_load_queue_rt_friendly(), get_member_status(), call_queue::head, insert_entry(), call_queue::joinempty, LOG_NOTICE, queue_ent::max_penalty, call_queue::maxlen, queue_ent::min_penalty, queue_ent::moh, call_queue::moh, call_queue::name, queue_ent::next, NULL, queue_ent::pos, queue_ent::prio, QUEUE_FULL, QUEUE_JOINEMPTY, queue_t_unref, QUEUE_UNKNOWN, RAII_VAR, queue_ent::raise_penalty, queue_ent::raise_respect_min, and status.

Referenced by queue_exec().

kill_dead_members()

static int kill_dead_members ( void *  obj, void *  arg, int  flags  )

static

Definition at line 9901 of file app_queue.c.

{
    struct member *member = obj;
 
    if (!member->delme) {
        member->status = get_queue_member_status(member);
        return 0;
    } else {
        return CMP_MATCH;
    }
}

References CMP_MATCH, member::delme, get_queue_member_status(), and member::status.

Referenced by reload_single_queue().

kill_if_unfound()

static int kill_if_unfound ( void *  obj, void *  arg, int  flags  )

static

Definition at line 10056 of file app_queue.c.

{
    struct call_queue *q = obj;
    char *queuename = arg;
    if (!q->realtime && !q->found && (ast_strlen_zero(queuename) || !strcasecmp(queuename, q->name))) {
        q->dead = 1;
        return CMP_MATCH;
    } else {
        return 0;
    }
}

References ast_strlen_zero(), CMP_MATCH, call_queue::dead, call_queue::found, call_queue::name, and call_queue::realtime.

Referenced by reload_queues().

leave_queue()

static void leave_queue ( struct queue_ent *  qe )

static

Caller leaving queue.

Search the queue to find the leaving client, if found remove from queue create manager event, move others up the queue.

Definition at line 4520 of file app_queue.c.

{
    struct call_queue *q;
    struct queue_ent *current, *prev = NULL;
    struct penalty_rule *pr_iter;
    int pos = 0;
 
    if (!(q = qe->parent)) {
        return;
    }
    queue_t_ref(q, "Copy queue pointer from queue entry");
    ao2_lock(q);
 
    prev = NULL;
    for (current = q->head; current; current = current->next) {
        if (current == qe) {
            RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
            char posstr[20];
            q->count--;
            if (!q->count) {
                ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s", q->name);
            }
 
            blob = ast_json_pack("{s: s, s: i, s: i}",
                         "Queue", q->name,
                         "Position", qe->pos,
                         "Count", q->count);
            ast_channel_publish_cached_blob(qe->chan, queue_caller_leave_type(), blob);
            ast_debug(1, "Queue '%s' Leave, Channel '%s'\n", q->name, ast_channel_name(qe->chan));
            /* Take us out of the queue */
            if (prev) {
                prev->next = current->next;
            } else {
                q->head = current->next;
            }
            /* Free penalty rules */
            while ((pr_iter = AST_LIST_REMOVE_HEAD(&qe->qe_rules, list))) {
                ast_free(pr_iter);
            }
            qe->pr = NULL;
            snprintf(posstr, sizeof(posstr), "%d", qe->pos);
            pbx_builtin_setvar_helper(qe->chan, "QUEUEPOSITION", posstr);
        } else {
            /* Renumber the people after us in the queue based on a new count */
            current->pos = ++pos;
            prev = current;
        }
    }
    ao2_unlock(q);
 
    /*If the queue is a realtime queue, check to see if it's still defined in real time*/
    if (q->realtime) {
        struct ast_variable *var;
        if (!(var = ast_load_realtime("queues", "name", q->name, SENTINEL))) {
            q->dead = 1;
        } else {
            ast_variables_destroy(var);
        }
    }
 
    if (q->dead) {
        /* It's dead and nobody is in it, so kill it */
        queues_t_unlink(queues, q, "Queue is now dead; remove it from the container");
    }
    /* unref the explicit ref earlier in the function */
    queue_t_unref(q, "Expire copied reference");
}

References ao2_lock, ao2_unlock, ast_channel_name(), ast_channel_publish_cached_blob(), ast_debug, AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_free, ast_json_pack(), ast_json_unref(), AST_LIST_REMOVE_HEAD, ast_load_realtime(), ast_variables_destroy(), queue_ent::chan, call_queue::count, current, call_queue::dead, call_queue::head, penalty_rule::list, call_queue::name, queue_ent::next, NULL, queue_ent::parent, pbx_builtin_setvar_helper(), queue_ent::pos, queue_ent::pr, queue_ent::qe_rules, queue_t_ref, queue_t_unref, queues, queues_t_unlink, RAII_VAR, call_queue::realtime, SENTINEL, and var.

Referenced by queue_exec(), and try_calling().

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 11930 of file app_queue.c.

{
    int err = 0;
    struct ast_flags mask = {AST_FLAGS_ALL, };
    struct ast_config *member_config;
    struct stasis_topic *queue_topic;
    struct stasis_topic *manager_topic;
 
    queues = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_QUEUE_BUCKETS,
        queue_hash_cb, NULL, queue_cmp_cb);
    if (!queues) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    pending_members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        MAX_CALL_ATTEMPT_BUCKETS, pending_members_hash, NULL, pending_members_cmp);
    if (!pending_members) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    use_weight = 0;
 
    if (reload_handler(0, &mask, NULL)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_realtime_require_field("queue_members", "paused", RQ_INTEGER1, 1, "uniqueid", RQ_UINTEGER2, 5, "reason_paused", RQ_CHAR, 80, SENTINEL);
 
    /*
     * This section is used to determine which name for 'ringinuse' to use in realtime members
     * Necessary for supporting older setups.
     *
     * It also checks if 'reason_paused' exists in the realtime backend
     */
    member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name LIKE", "%", SENTINEL);
    if (!member_config) {
        realtime_ringinuse_field = "ringinuse";
    } else {
        const char *config_val;
 
        if ((config_val = ast_variable_retrieve(member_config, NULL, "ringinuse"))) {
            ast_log(LOG_NOTICE, "ringinuse field entries found in queue_members table. Using 'ringinuse'\n");
            realtime_ringinuse_field = "ringinuse";
        } else if ((config_val = ast_variable_retrieve(member_config, NULL, "ignorebusy"))) {
            ast_log(LOG_NOTICE, "ignorebusy field found in queue_members table with no ringinuse field. Using 'ignorebusy'\n");
            realtime_ringinuse_field = "ignorebusy";
        } else {
            ast_log(LOG_NOTICE, "No entries were found for ringinuse/ignorebusy in queue_members table. Using 'ringinuse'\n");
            realtime_ringinuse_field = "ringinuse";
        }
 
        if (ast_variable_retrieve(member_config, NULL, "reason_paused")) {
            realtime_reason_paused = 1;
        }
    }
    ast_config_destroy(member_config);
 
    if (queue_persistent_members) {
        reload_queue_members();
    }
 
    err |= ast_cli_register_multiple(cli_queue, ARRAY_LEN(cli_queue));
    err |= ast_register_application_xml(app, queue_exec);
    err |= ast_register_application_xml(app_aqm, aqm_exec);
    err |= ast_register_application_xml(app_rqm, rqm_exec);
    err |= ast_register_application_xml(app_pqm, pqm_exec);
    err |= ast_register_application_xml(app_upqm, upqm_exec);
    err |= ast_register_application_xml(app_ql, ql_exec);
    err |= ast_register_application_xml(app_qupd, qupd_exec);
    err |= ast_manager_register_xml("QueueStatus", 0, manager_queues_status);
    err |= ast_manager_register_xml("QueueSummary", 0, manager_queues_summary);
    err |= ast_manager_register_xml("QueueAdd", EVENT_FLAG_AGENT, manager_add_queue_member);
    err |= ast_manager_register_xml("QueueRemove", EVENT_FLAG_AGENT, manager_remove_queue_member);
    err |= ast_manager_register_xml("QueuePause", EVENT_FLAG_AGENT, manager_pause_queue_member);
    err |= ast_manager_register_xml("QueueLog", EVENT_FLAG_AGENT, manager_queue_log_custom);
    err |= ast_manager_register_xml("QueuePenalty", EVENT_FLAG_AGENT, manager_queue_member_penalty);
    err |= ast_manager_register_xml("QueueMemberRingInUse", EVENT_FLAG_AGENT, manager_queue_member_ringinuse);
    err |= ast_manager_register_xml("QueueRule", 0, manager_queue_rule_show);
    err |= ast_manager_register_xml("QueueReload", 0, manager_queue_reload);
    err |= ast_manager_register_xml("QueueReset", 0, manager_queue_reset);
    err |= ast_manager_register_xml("QueueChangePriorityCaller", 0,  manager_change_priority_caller_on_queue);
    err |= ast_manager_register_xml("QueueWithdrawCaller", 0,  manager_request_withdraw_caller_from_queue);
    err |= ast_custom_function_register(&queuevar_function);
    err |= ast_custom_function_register(&queueexists_function);
    err |= ast_custom_function_register(&queuemembercount_function);
    err |= ast_custom_function_register(&queuememberlist_function);
    err |= ast_custom_function_register(&queuegetchannel_function);
    err |= ast_custom_function_register(&queuewaitingcount_function);
    err |= ast_custom_function_register(&queuememberpenalty_function);
 
    /* in the following subscribe call, do I use DEVICE_STATE, or DEVICE_STATE_CHANGE? */
    device_state_sub = stasis_subscribe(ast_device_state_topic_all(), device_state_cb, NULL);
    if (!device_state_sub) {
        err = -1;
    }
    stasis_subscription_accept_message_type(device_state_sub, ast_device_state_message_type());
    stasis_subscription_set_filter(device_state_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    manager_topic = ast_manager_get_topic();
    queue_topic = ast_queue_topic_all();
    if (!manager_topic || !queue_topic) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    topic_forwarder = stasis_forward_all(queue_topic, manager_topic);
    if (!topic_forwarder) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!ast_channel_agent_login_type()
        || !ast_channel_agent_logoff_type()) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    agent_router = stasis_message_router_create(ast_channel_topic_all());
    if (!agent_router) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    err |= stasis_message_router_add(agent_router,
        ast_channel_agent_login_type(),
        queue_agent_cb,
        NULL);
    err |= stasis_message_router_add(agent_router,
        ast_channel_agent_logoff_type(),
        queue_agent_cb,
        NULL);
 
    err |= STASIS_MESSAGE_TYPE_INIT(queue_caller_join_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_caller_leave_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_caller_abandon_type);
 
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_status_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_added_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_removed_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_pause_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_penalty_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_member_ringinuse_type);
 
    err |= STASIS_MESSAGE_TYPE_INIT(queue_agent_called_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_agent_connect_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_agent_complete_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_agent_dump_type);
    err |= STASIS_MESSAGE_TYPE_INIT(queue_agent_ringnoanswer_type);
 
    if (err) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    return AST_MODULE_LOAD_SUCCESS;
}

References agent_router, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, app, app_aqm, app_pqm, app_ql, app_qupd, app_rqm, app_upqm, aqm_exec(), ARRAY_LEN, ast_channel_agent_login_type(), ast_channel_agent_logoff_type(), ast_channel_topic_all(), ast_cli_register_multiple, ast_config_destroy(), ast_custom_function_register, ast_device_state_message_type(), ast_device_state_topic_all(), AST_FLAGS_ALL, ast_load_realtime_multientry(), ast_log, ast_manager_get_topic(), ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_queue_topic_all(), ast_realtime_require_field(), ast_register_application_xml, ast_variable_retrieve(), cli_queue, device_state_cb(), device_state_sub, EVENT_FLAG_AGENT, LOG_NOTICE, manager_add_queue_member(), manager_change_priority_caller_on_queue(), manager_pause_queue_member(), manager_queue_log_custom(), manager_queue_member_penalty(), manager_queue_member_ringinuse(), manager_queue_reload(), manager_queue_reset(), manager_queue_rule_show(), manager_queues_status(), manager_queues_summary(), manager_remove_queue_member(), manager_request_withdraw_caller_from_queue(), manager_topic, MAX_CALL_ATTEMPT_BUCKETS, MAX_QUEUE_BUCKETS, NULL, pending_members, pending_members_cmp(), pending_members_hash(), pqm_exec(), ql_exec(), queue_agent_cb(), queue_cmp_cb(), queue_exec(), queue_hash_cb(), queue_persistent_members, queueexists_function, queuegetchannel_function, queuemembercount_function, queuememberlist_function, queuememberpenalty_function, queues, queuevar_function, queuewaitingcount_function, qupd_exec(), realtime_reason_paused, realtime_ringinuse_field, reload_handler(), reload_queue_members(), RQ_CHAR, RQ_INTEGER1, RQ_UINTEGER2, rqm_exec(), SENTINEL, stasis_forward_all(), stasis_message_router_add(), stasis_message_router_create, STASIS_MESSAGE_TYPE_INIT, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), topic_forwarder, unload_module(), upqm_exec(), and use_weight.

load_realtime_queues()

static void load_realtime_queues ( const char *  queuename )

static

Definition at line 4104 of file app_queue.c.

{
    struct ast_config *cfg = NULL;
    char *category = NULL;
    const char *name = NULL;
    struct call_queue *q = NULL;
 
    if (!ast_check_realtime("queues")) {
        return;
    }
 
    if (ast_strlen_zero(queuename)) {
        if ((cfg = ast_load_realtime_multientry("queues", "name LIKE", "%", SENTINEL))) {
            while ((category = ast_category_browse(cfg, category))) {
                name = ast_variable_retrieve(cfg, category, "name");
                if (!ast_strlen_zero(name) && (q = find_load_queue_rt_friendly(name))) {
                    queue_unref(q);
                }
            }
            ast_config_destroy(cfg);
        }
    } else {
        if ((q = find_load_queue_rt_friendly(queuename))) {
            queue_unref(q);
        }
    }
}

References ast_category_browse(), ast_check_realtime(), ast_config_destroy(), ast_load_realtime_multientry(), ast_strlen_zero(), ast_variable_retrieve(), find_load_queue_rt_friendly(), name, NULL, queue_unref, and SENTINEL.

Referenced by manager_queues_status(), manager_queues_summary(), and set_member_paused().

load_realtime_rules()

static int load_realtime_rules ( void  )

static

Load queue rules from realtime.

Check rule for errors with time or formatting, see if rule is relative to rest of queue, iterate list of rules to find correct insertion point, insert and return.

Return values

-1	on failure
0	on success

Note

Call this with the rule_lists locked

Definition at line 3325 of file app_queue.c.

{
    struct ast_config *cfg;
        struct rule_list *rl_iter, *new_rl;
        struct penalty_rule *pr_iter;
        char *rulecat = NULL;
 
    if (!ast_check_realtime("queue_rules")) {
        ast_log(LOG_WARNING, "Missing \"queue_rules\" in extconfig.conf\n");
        return 0;
    }
    if (!(cfg = ast_load_realtime_multientry("queue_rules", "rule_name LIKE", "%", SENTINEL))) {
        ast_log(LOG_WARNING, "Failed to load queue rules from realtime\n");
        return 0;
    }
    while ((rulecat = ast_category_browse(cfg, rulecat))) {
        const char *timestr, *maxstr, *minstr, *raisestr, *rule_name;
        int penaltychangetime, rule_exists = 0, inserted = 0;
        int max_penalty = 0, min_penalty = 0, raise_penalty = 0;
        int min_relative = 0, max_relative = 0, raise_relative = 0;
        struct penalty_rule *new_penalty_rule = NULL;
 
        rule_name = ast_variable_retrieve(cfg, rulecat, "rule_name");
        if (ast_strlen_zero(rule_name)) {
            continue;
        }
 
        AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
            if (!(strcasecmp(rl_iter->name, rule_name))) {
                rule_exists = 1;
                new_rl = rl_iter;
                break;
            }
        }
        if (!rule_exists) {
            if (!(new_rl = ast_calloc(1, sizeof(*new_rl)))) {
                ast_config_destroy(cfg);
                return -1;
            }
            ast_copy_string(new_rl->name, rule_name, sizeof(new_rl->name));
            AST_LIST_INSERT_TAIL(&rule_lists, new_rl, list);
        }
        timestr = ast_variable_retrieve(cfg, rulecat, "time");
        if (!(timestr) || sscanf(timestr, "%30d", &penaltychangetime) != 1) {
            ast_log(LOG_NOTICE, "Failed to parse time (%s) for one of the %s rules, skipping it\n",
                (ast_strlen_zero(timestr) ? "invalid value" : timestr), rule_name);
            continue;
        }
        if (!(new_penalty_rule = ast_calloc(1, sizeof(*new_penalty_rule)))) {
            ast_config_destroy(cfg);
            return -1;
        }
        if (!(maxstr = ast_variable_retrieve(cfg, rulecat, "max_penalty")) ||
            ast_strlen_zero(maxstr) || sscanf(maxstr, "%30d", &max_penalty) != 1) {
            max_penalty = 0;
            max_relative = 1;
        } else {
            if (*maxstr == '+' || *maxstr == '-') {
                max_relative = 1;
            }
        }
        if (!(minstr = ast_variable_retrieve(cfg, rulecat, "min_penalty")) ||
            ast_strlen_zero(minstr) || sscanf(minstr, "%30d", &min_penalty) != 1) {
            min_penalty = 0;
            min_relative = 1;
        } else {
            if (*minstr == '+' || *minstr == '-') {
                min_relative = 1;
            }
        }
        if (!(raisestr = ast_variable_retrieve(cfg, rulecat, "raise_penalty")) ||
            ast_strlen_zero(raisestr) ) {
            raise_penalty = 0;
            raise_relative = 1;
        } else {
            if (*raisestr == 'r') {
                new_penalty_rule->raise_respect_min = 1;
                raisestr++;
            } else {
                new_penalty_rule->raise_respect_min = 0;
            }
            if (*raisestr == '+' || *raisestr == '-') {
                raise_relative = 1;
            } 
            if (sscanf(raisestr, "%30d", &raise_penalty) != 1) {
                raise_penalty = 0;
                raise_relative = 1;
            }
        }
        new_penalty_rule->time = penaltychangetime;
        new_penalty_rule->max_relative = max_relative;
        new_penalty_rule->max_value = max_penalty;
        new_penalty_rule->min_relative = min_relative;
        new_penalty_rule->min_value = min_penalty;
        new_penalty_rule->raise_relative = raise_relative;
        new_penalty_rule->raise_value = raise_penalty;
        AST_LIST_TRAVERSE_SAFE_BEGIN(&new_rl->rules, pr_iter, list) {
            if (new_penalty_rule->time < pr_iter->time) {
                AST_LIST_INSERT_BEFORE_CURRENT(new_penalty_rule, list);
                inserted = 1;
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
        if (!inserted) {
            AST_LIST_INSERT_TAIL(&new_rl->rules, new_penalty_rule, list);
        }
    }
 
    ast_config_destroy(cfg);
    return 0;
}

References ast_calloc, ast_category_browse(), ast_check_realtime(), ast_config_destroy(), ast_copy_string(), AST_LIST_INSERT_BEFORE_CURRENT, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_load_realtime_multientry(), ast_log, ast_strlen_zero(), ast_variable_retrieve(), penalty_rule::list, LOG_NOTICE, LOG_WARNING, penalty_rule::max_relative, penalty_rule::max_value, penalty_rule::min_relative, penalty_rule::min_value, rule_list::name, NULL, penalty_rule::raise_relative, penalty_rule::raise_respect_min, penalty_rule::raise_value, rule_list::rules, SENTINEL, and penalty_rule::time.

Referenced by reload_queue_rules().

log_attended_transfer()

static void log_attended_transfer ( struct queue_stasis_data *  queue_data, struct ast_attended_transfer_message *  atxfer_msg  )

static

Definition at line 6478 of file app_queue.c.

{
    RAII_VAR(struct ast_str *, transfer_str, ast_str_create(32), ast_free);
 
    if (!transfer_str) {
        ast_log(LOG_WARNING, "Unable to log attended transfer to queue log\n");
        return;
    }
 
    switch (atxfer_msg->dest_type) {
    case AST_ATTENDED_TRANSFER_DEST_BRIDGE_MERGE:
        ast_str_set(&transfer_str, 0, "BRIDGE|%s", atxfer_msg->dest.bridge);
        break;
    case AST_ATTENDED_TRANSFER_DEST_APP:
    case AST_ATTENDED_TRANSFER_DEST_LOCAL_APP:
        ast_str_set(&transfer_str, 0, "APP|%s", atxfer_msg->dest.app);
        break;
    case AST_ATTENDED_TRANSFER_DEST_LINK:
        ast_str_set(&transfer_str, 0, "LINK|%s|%s", atxfer_msg->dest.links[0]->base->name,
                atxfer_msg->dest.links[1]->base->name);
        break;
    case AST_ATTENDED_TRANSFER_DEST_THREEWAY:
    case AST_ATTENDED_TRANSFER_DEST_FAIL:
        /* Threeways are headed off and should not be logged here */
        ast_assert(0);
        return;
    }
 
    ast_queue_log(queue_data->queue->name, queue_data->caller_uniqueid, queue_data->member->membername, "ATTENDEDTRANSFER", "%s|%ld|%ld|%d",
            ast_str_buffer(transfer_str),
            (long) (queue_data->starttime - queue_data->holdstart),
            (long) (time(NULL) - queue_data->starttime), queue_data->caller_pos);
}

References ast_attended_transfer_message::app, ast_assert, AST_ATTENDED_TRANSFER_DEST_APP, AST_ATTENDED_TRANSFER_DEST_BRIDGE_MERGE, AST_ATTENDED_TRANSFER_DEST_FAIL, AST_ATTENDED_TRANSFER_DEST_LINK, AST_ATTENDED_TRANSFER_DEST_LOCAL_APP, AST_ATTENDED_TRANSFER_DEST_THREEWAY, ast_free, ast_log, ast_queue_log(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_channel_snapshot::base, ast_attended_transfer_message::bridge, queue_stasis_data::caller_pos, queue_stasis_data::caller_uniqueid, ast_attended_transfer_message::dest, ast_attended_transfer_message::dest_type, queue_stasis_data::holdstart, ast_attended_transfer_message::links, LOG_WARNING, queue_stasis_data::member, member::membername, call_queue::name, ast_channel_snapshot_base::name, NULL, queue_stasis_data::queue, RAII_VAR, and queue_stasis_data::starttime.

Referenced by handle_attended_transfer().

manager_add_queue_member()

static int manager_add_queue_member ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10775 of file app_queue.c.

{
    const char *queuename, *interface, *penalty_s, *paused_s, *reason, *membername, *state_interface, *wrapuptime_s;
    int paused, penalty, wrapuptime = 0;
 
    queuename = astman_get_header(m, "Queue");
    interface = astman_get_header(m, "Interface");
    penalty_s = astman_get_header(m, "Penalty");
    paused_s = astman_get_header(m, "Paused");
    reason = astman_get_header(m, "Reason");                          /* Optional */
    membername = astman_get_header(m, "MemberName");
    state_interface = astman_get_header(m, "StateInterface");
    wrapuptime_s = astman_get_header(m, "Wrapuptime");
 
    if (ast_strlen_zero(queuename)) {
        astman_send_error(s, m, "'Queue' not specified.");
        return 0;
    }
 
    if (ast_strlen_zero(interface)) {
        astman_send_error(s, m, "'Interface' not specified.");
        return 0;
    }
 
    if (ast_strlen_zero(penalty_s)) {
        penalty = 0;
    } else if (sscanf(penalty_s, "%30d", &penalty) != 1 || penalty < 0) {
        penalty = 0;
    }
 
    if (ast_strlen_zero(wrapuptime_s)) {
        wrapuptime = 0;
    } else if (sscanf(wrapuptime_s, "%30d", &wrapuptime) != 1 || wrapuptime < 0) {
        wrapuptime = 0;
    }
 
    if (ast_strlen_zero(paused_s)) {
        paused = 0;
    } else {
        paused = abs(ast_true(paused_s));
    }
 
    switch (add_to_queue(queuename, interface, membername, penalty, paused, queue_persistent_members, state_interface, reason, wrapuptime)) {
    case RES_OKAY:
        if (ast_strlen_zero(membername) || !log_membername_as_agent) {
            ast_queue_log(queuename, "MANAGER", interface, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        } else {
            ast_queue_log(queuename, "MANAGER", membername, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
        }
        astman_send_ack(s, m, "Added interface to queue");
        break;
    case RES_EXISTS:
        astman_send_error(s, m, "Unable to add interface: Already there");
        break;
    case RES_NOSUCHQUEUE:
        astman_send_error(s, m, "Unable to add interface to queue: No such queue");
        break;
    case RES_OUTOFMEMORY:
        astman_send_error(s, m, "Out of memory");
        break;
    }
 
    return 0;
}

References abs, add_to_queue(), ast_queue_log(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), log_membername_as_agent, queue_persistent_members, RES_EXISTS, RES_NOSUCHQUEUE, RES_OKAY, and RES_OUTOFMEMORY.

Referenced by load_module().

manager_change_priority_caller_on_queue()

static int manager_change_priority_caller_on_queue ( struct mansession *  s, const struct message *  m  )

static

Definition at line 11071 of file app_queue.c.

{
    const char *queuename, *caller, *priority_s, *immediate_s;
    int priority = 0, immediate = 0;
 
    queuename = astman_get_header(m, "Queue");
    caller = astman_get_header(m, "Caller");
    priority_s = astman_get_header(m, "Priority");
    immediate_s = astman_get_header(m, "Immediate");
 
    if (ast_strlen_zero(queuename)) {
        astman_send_error(s, m, "'Queue' not specified.");
        return 0;
    }
 
    if (ast_strlen_zero(caller)) {
        astman_send_error(s, m, "'Caller' not specified.");
        return 0;
    }
 
    if (ast_strlen_zero(priority_s)) {
        astman_send_error(s, m, "'Priority' not specified.");
        return 0;
    } else if (sscanf(priority_s, "%30d", &priority) != 1) {
        astman_send_error(s, m, "'Priority' need integer.");
        return 0;
    }
 
    if (!ast_strlen_zero(immediate_s)) {
        immediate = ast_true(immediate_s);
    }
 
    switch (change_priority_caller_on_queue(queuename, caller, priority, immediate)) {
    case RES_OKAY:
        astman_send_ack(s, m, "Priority change for caller on queue");
        break;
    case RES_NOSUCHQUEUE:
        astman_send_error(s, m, "Unable to change priority caller on queue: No such queue");
        break;
    case RES_NOT_CALLER:
        astman_send_error(s, m, "Unable to change priority caller on queue: No such caller");
        break;
    }
 
    return 0;
}

References ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), change_priority_caller_on_queue(), priority, RES_NOSUCHQUEUE, RES_NOT_CALLER, and RES_OKAY.

Referenced by load_module().

manager_pause_queue_member()

static int manager_pause_queue_member ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10887 of file app_queue.c.

{
    const char *queuename, *interface, *paused_s, *reason;
    int paused;
 
    interface = astman_get_header(m, "Interface");
    paused_s = astman_get_header(m, "Paused");
    queuename = astman_get_header(m, "Queue");      /* Optional - if not supplied, pause the given Interface in all queues */
    reason = astman_get_header(m, "Reason");        /* Optional */
 
    if (ast_strlen_zero(interface) || ast_strlen_zero(paused_s)) {
        astman_send_error(s, m, "Need 'Interface' and 'Paused' parameters.");
        return 0;
    }
 
    paused = abs(ast_true(paused_s));
 
    if (set_member_paused(queuename, interface, reason, paused)) {
        astman_send_error(s, m, "Interface not found");
    } else {
        astman_send_ack(s, m, paused ? "Interface paused successfully" : "Interface unpaused successfully");
    }
    return 0;
}

References abs, ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), and set_member_paused().

Referenced by load_module().

manager_queue_log_custom()

static int manager_queue_log_custom ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10912 of file app_queue.c.

{
    const char *queuename, *event, *message, *interface, *uniqueid;
 
    queuename = astman_get_header(m, "Queue");
    uniqueid = astman_get_header(m, "UniqueId");
    interface = astman_get_header(m, "Interface");
    event = astman_get_header(m, "Event");
    message = astman_get_header(m, "Message");
 
    if (ast_strlen_zero(queuename) || ast_strlen_zero(event)) {
        astman_send_error(s, m, "Need 'Queue' and 'Event' parameters.");
        return 0;
    }
 
    ast_queue_log(queuename, S_OR(uniqueid, "NONE"), interface, event, "%s", message);
    astman_send_ack(s, m, "Event added successfully");
 
    return 0;
}

References ast_queue_log(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), and S_OR.

Referenced by load_module().

manager_queue_member_penalty()

static int manager_queue_member_penalty ( struct mansession *  s, const struct message *  m  )

static

Definition at line 11045 of file app_queue.c.

{
    const char *queuename, *interface, *penalty_s;
    int penalty;
 
    interface = astman_get_header(m, "Interface");
    penalty_s = astman_get_header(m, "Penalty");
    /* Optional - if not supplied, set the penalty value for the given Interface in all queues */
    queuename = astman_get_header(m, "Queue");
 
    if (ast_strlen_zero(interface) || ast_strlen_zero(penalty_s)) {
        astman_send_error(s, m, "Need 'Interface' and 'Penalty' parameters.");
        return 0;
    }
 
    penalty = atoi(penalty_s);
 
    if (set_member_value((char *)queuename, (char *)interface, MEMBER_PENALTY, penalty)) {
        astman_send_error(s, m, "Invalid interface, queuename or penalty");
    } else {
        astman_send_ack(s, m, "Interface penalty set successfully");
    }
 
    return 0;
}

References ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), MEMBER_PENALTY, and set_member_value().

Referenced by load_module().

manager_queue_member_ringinuse()

static int manager_queue_member_ringinuse ( struct mansession *  s, const struct message *  m  )

static

Definition at line 11011 of file app_queue.c.

{
    const char *queuename, *interface, *ringinuse_s;
    int ringinuse;
 
    interface = astman_get_header(m, "Interface");
    ringinuse_s = astman_get_header(m, "RingInUse");
 
    /* Optional - if not supplied, set the ringinuse value for the given Interface in all queues */
    queuename = astman_get_header(m, "Queue");
 
    if (ast_strlen_zero(interface) || ast_strlen_zero(ringinuse_s)) {
        astman_send_error(s, m, "Need 'Interface' and 'RingInUse' parameters.");
        return 0;
    }
 
    if (ast_true(ringinuse_s)) {
        ringinuse = 1;
    } else if (ast_false(ringinuse_s)) {
        ringinuse = 0;
    } else {
        astman_send_error(s, m, "'RingInUse' parameter must be a truth value (yes/no, on/off, 0/1, etc)");
        return 0;
    }
 
    if (set_member_value(queuename, interface, MEMBER_RINGINUSE, ringinuse)) {
        astman_send_error(s, m, "Invalid interface, queuename, or ringinuse value\n");
    } else {
        astman_send_ack(s, m, "Interface ringinuse set successfully");
    }
 
    return 0;
}

References ast_false(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), MEMBER_RINGINUSE, and set_member_value().

Referenced by load_module().

manager_queue_reload()

static int manager_queue_reload ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10933 of file app_queue.c.

{
    struct ast_flags mask = {0,};
    const char *queuename = NULL;
    int header_found = 0;
 
    queuename = astman_get_header(m, "Queue");
    if (!strcasecmp(S_OR(astman_get_header(m, "Members"), ""), "yes")) {
        ast_set_flag(&mask, QUEUE_RELOAD_MEMBER);
        header_found = 1;
    }
    if (!strcasecmp(S_OR(astman_get_header(m, "Rules"), ""), "yes")) {
        ast_set_flag(&mask, QUEUE_RELOAD_RULES);
        header_found = 1;
    }
    if (!strcasecmp(S_OR(astman_get_header(m, "Parameters"), ""), "yes")) {
        ast_set_flag(&mask, QUEUE_RELOAD_PARAMETERS);
        header_found = 1;
    }
 
    if (!header_found) {
        ast_set_flag(&mask, AST_FLAGS_ALL & ~QUEUE_RESET_STATS);
    }
 
    if (!reload_handler(1, &mask, queuename)) {
        astman_send_ack(s, m, "Queue reloaded successfully");
    } else {
        astman_send_error(s, m, "Error encountered while reloading queue");
    }
    return 0;
}

References AST_FLAGS_ALL, ast_set_flag, astman_get_header(), astman_send_ack(), astman_send_error(), NULL, QUEUE_RELOAD_MEMBER, QUEUE_RELOAD_PARAMETERS, QUEUE_RELOAD_RULES, QUEUE_RESET_STATS, reload_handler(), and S_OR.

Referenced by load_module().

manager_queue_reset()

static int manager_queue_reset ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10965 of file app_queue.c.

{
    const char *queuename = NULL;
    struct ast_flags mask = {QUEUE_RESET_STATS,};
 
    queuename = astman_get_header(m, "Queue");
 
    if (!reload_handler(1, &mask, queuename)) {
        astman_send_ack(s, m, "Queue stats reset successfully");
    } else {
        astman_send_error(s, m, "Error encountered while resetting queue stats");
    }
    return 0;
}

References astman_get_header(), astman_send_ack(), astman_send_error(), NULL, QUEUE_RESET_STATS, and reload_handler().

Referenced by load_module().

manager_queue_rule_show()

static int manager_queue_rule_show ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10534 of file app_queue.c.

{
    const char *rule = astman_get_header(m, "Rule");
    const char *id = astman_get_header(m, "ActionID");
    struct rule_list *rl_iter;
    struct penalty_rule *pr_iter;
 
    astman_append(s, "Response: Success\r\n");
    if (!ast_strlen_zero(id)) {
        astman_append(s, "ActionID: %s\r\n", id);
    }
 
    AST_LIST_LOCK(&rule_lists);
    AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
        if (ast_strlen_zero(rule) || !strcasecmp(rule, rl_iter->name)) {
            astman_append(s, "RuleList: %s\r\n", rl_iter->name);
            AST_LIST_TRAVERSE(&rl_iter->rules, pr_iter, list) {
                astman_append(s, "Rule: %d,%s%d,%s%d\r\n", pr_iter->time, pr_iter->max_relative && pr_iter->max_value >= 0 ? "+" : "", pr_iter->max_value, pr_iter->min_relative && pr_iter->min_value >= 0 ? "+" : "", pr_iter->min_value );
            }
            if (!ast_strlen_zero(rule)) {
                break;
            }
        }
    }
    AST_LIST_UNLOCK(&rule_lists);
 
    /*
     * Two blank lines instead of one because the Response and
     * ActionID headers used to not be present.
     */
    astman_append(s, "\r\n\r\n");
 
    return RESULT_SUCCESS;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), astman_append(), astman_get_header(), penalty_rule::list, penalty_rule::max_relative, penalty_rule::max_value, penalty_rule::min_relative, penalty_rule::min_value, rule_list::name, RESULT_SUCCESS, rule_list::rules, and penalty_rule::time.

Referenced by load_module().

manager_queues_status()

static int manager_queues_status ( struct mansession *  s, const struct message *  m  )

static

Queue status info via AMI.

Definition at line 10652 of file app_queue.c.

{
    time_t now;
    int pos;
    int q_items = 0;
    const char *id = astman_get_header(m,"ActionID");
    const char *queuefilter = astman_get_header(m,"Queue");
    const char *memberfilter = astman_get_header(m,"Member");
    char idText[256];
    struct call_queue *q;
    struct queue_ent *qe;
    float sl = 0;
    float sl2 = 0;
    struct member *mem;
    struct ao2_iterator queue_iter;
    struct ao2_iterator mem_iter;
 
    if (ast_check_realtime("queues")) {
        load_realtime_queues(queuefilter);
    }
 
    astman_send_listack(s, m, "Queue status will follow", "start");
    time(&now);
    idText[0] = '\0';
    if (!ast_strlen_zero(id)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
    }
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        ao2_lock(q);
 
        /* List queue properties */
        if (ast_strlen_zero(queuefilter) || !strcasecmp(q->name, queuefilter)) {
            sl = ((q->callscompleted > 0) ? 100 * ((float)q->callscompletedinsl / (float)q->callscompleted) : 0);
            sl2 = (((q->callscompleted + q->callsabandoned) > 0) ? 100 * (((float)q->callsabandonedinsl + (float)q->callscompletedinsl) / ((float)q->callsabandoned + (float)q->callscompleted)) : 0);
 
            astman_append(s, "Event: QueueParams\r\n"
                "Queue: %s\r\n"
                "Max: %d\r\n"
                "Strategy: %s\r\n"
                "Calls: %d\r\n"
                "Holdtime: %d\r\n"
                "TalkTime: %d\r\n"
                "Completed: %d\r\n"
                "Abandoned: %d\r\n"
                "ServiceLevel: %d\r\n"
                "ServicelevelPerf: %2.1f\r\n"
                "ServicelevelPerf2: %2.1f\r\n"
                "Weight: %d\r\n"
                "%s"
                "\r\n",
                q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted,
                q->callsabandoned, q->servicelevel, sl, sl2, q->weight, idText);
            ++q_items;
 
            /* List Queue Members */
            mem_iter = ao2_iterator_init(q->members, 0);
            while ((mem = ao2_iterator_next(&mem_iter))) {
                if (ast_strlen_zero(memberfilter) || !strcmp(mem->interface, memberfilter) || !strcmp(mem->membername, memberfilter)) {
                    astman_append(s, "Event: QueueMember\r\n"
                        "Queue: %s\r\n"
                        "Name: %s\r\n"
                        "Location: %s\r\n"
                        "StateInterface: %s\r\n"
                        "Membership: %s\r\n"
                        "Penalty: %d\r\n"
                        "CallsTaken: %d\r\n"
                        "LastCall: %d\r\n"
                        "LastPause: %d\r\n"
                        "LoginTime: %d\r\n"
                        "InCall: %d\r\n"
                        "Status: %d\r\n"
                        "Paused: %d\r\n"
                        "PausedReason: %s\r\n"
                        "Wrapuptime: %d\r\n"
                        "%s"
                        "\r\n",
                        q->name, mem->membername, mem->interface, mem->state_interface, mem->dynamic ? "dynamic" : "static",
                        mem->penalty, mem->calls, (int)mem->lastcall, (int)mem->lastpause, (int)mem->logintime, mem->starttime ? 1 : 0, mem->status,
                        mem->paused, mem->reason_paused, mem->wrapuptime, idText);
                    ++q_items;
                }
                ao2_ref(mem, -1);
            }
            ao2_iterator_destroy(&mem_iter);
 
            /* List Queue Entries */
            pos = 1;
            for (qe = q->head; qe; qe = qe->next) {
                astman_append(s, "Event: QueueEntry\r\n"
                    "Queue: %s\r\n"
                    "Position: %d\r\n"
                    "Channel: %s\r\n"
                    "Uniqueid: %s\r\n"
                    "CallerIDNum: %s\r\n"
                    "CallerIDName: %s\r\n"
                    "ConnectedLineNum: %s\r\n"
                    "ConnectedLineName: %s\r\n"
                    "Wait: %ld\r\n"
                    "Priority: %d\r\n"
                    "%s"
                    "\r\n",
                    q->name, pos++, ast_channel_name(qe->chan), ast_channel_uniqueid(qe->chan),
                    S_COR(ast_channel_caller(qe->chan)->id.number.valid, ast_channel_caller(qe->chan)->id.number.str, "unknown"),
                    S_COR(ast_channel_caller(qe->chan)->id.name.valid, ast_channel_caller(qe->chan)->id.name.str, "unknown"),
                    S_COR(ast_channel_connected(qe->chan)->id.number.valid, ast_channel_connected(qe->chan)->id.number.str, "unknown"),
                    S_COR(ast_channel_connected(qe->chan)->id.name.valid, ast_channel_connected(qe->chan)->id.name.str, "unknown"),
                    (long) (now - qe->start), qe->prio, idText);
                ++q_items;
            }
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
 
    astman_send_list_complete_start(s, m, "QueueStatusComplete", q_items);
    astman_send_list_complete_end(s);
 
    return RESULT_SUCCESS;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_channel_caller(), ast_channel_connected(), ast_channel_name(), ast_channel_uniqueid(), ast_check_realtime(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), member::calls, call_queue::callsabandoned, call_queue::callsabandonedinsl, call_queue::callscompleted, call_queue::callscompletedinsl, queue_ent::chan, call_queue::count, member::dynamic, call_queue::head, call_queue::holdtime, ast_party_caller::id, ast_party_connected_line::id, int2strat(), member::interface, member::lastcall, member::lastpause, load_realtime_queues(), member::logintime, call_queue::maxlen, member::membername, call_queue::members, call_queue::name, ast_party_id::name, queue_ent::next, ast_party_id::number, member::paused, member::penalty, queue_ent::prio, queue_t_unref, queues, member::reason_paused, RESULT_SUCCESS, S_COR, call_queue::servicelevel, queue_ent::start, member::starttime, member::state_interface, member::status, ast_party_name::str, ast_party_number::str, call_queue::strategy, call_queue::talktime, ast_party_name::valid, ast_party_number::valid, call_queue::weight, and member::wrapuptime.

Referenced by load_module().

manager_queues_summary()

static int manager_queues_summary ( struct mansession *  s, const struct message *  m  )

static

Summary of queue info via the AMI.

Definition at line 10570 of file app_queue.c.

{
    time_t now;
    int qmemcount = 0;
    int qmemavail = 0;
    int qchancount = 0;
    int qlongestholdtime = 0;
    int qsummaries = 0;
    const char *id = astman_get_header(m, "ActionID");
    const char *queuefilter = astman_get_header(m, "Queue");
    char idText[256];
    struct call_queue *q;
    struct queue_ent *qe;
    struct member *mem;
    struct ao2_iterator queue_iter;
    struct ao2_iterator mem_iter;
 
    if (ast_check_realtime("queues")) {
        load_realtime_queues(queuefilter);
    }
 
    astman_send_listack(s, m, "Queue summary will follow", "start");
    time(&now);
    idText[0] = '\0';
    if (!ast_strlen_zero(id)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
    }
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
        ao2_lock(q);
 
        /* List queue properties */
        if (ast_strlen_zero(queuefilter) || !strcasecmp(q->name, queuefilter)) {
            /* Reset the necessary local variables if no queuefilter is set*/
            qmemcount = 0;
            qmemavail = 0;
            qchancount = 0;
            qlongestholdtime = 0;
 
            /* List Queue Members */
            mem_iter = ao2_iterator_init(q->members, 0);
            while ((mem = ao2_iterator_next(&mem_iter))) {
                if ((mem->status != AST_DEVICE_UNAVAILABLE) && (mem->status != AST_DEVICE_INVALID)) {
                    ++qmemcount;
                    if (member_status_available(mem->status) && !mem->paused) {
                        ++qmemavail;
                    }
                }
                ao2_ref(mem, -1);
            }
            ao2_iterator_destroy(&mem_iter);
            for (qe = q->head; qe; qe = qe->next) {
                if ((now - qe->start) > qlongestholdtime) {
                    qlongestholdtime = now - qe->start;
                }
                ++qchancount;
            }
            astman_append(s, "Event: QueueSummary\r\n"
                "Queue: %s\r\n"
                "LoggedIn: %d\r\n"
                "Available: %d\r\n"
                "Callers: %d\r\n"
                "HoldTime: %d\r\n"
                "TalkTime: %d\r\n"
                "LongestHoldTime: %d\r\n"
                "%s"
                "\r\n",
                q->name, qmemcount, qmemavail, qchancount, q->holdtime, q->talktime, qlongestholdtime, idText);
            ++qsummaries;
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
 
    astman_send_list_complete_start(s, m, "QueueSummaryComplete", qsummaries);
    astman_send_list_complete_end(s);
 
    return RESULT_SUCCESS;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_check_realtime(), AST_DEVICE_INVALID, AST_DEVICE_UNAVAILABLE, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), call_queue::head, call_queue::holdtime, load_realtime_queues(), member_status_available(), call_queue::members, call_queue::name, queue_ent::next, member::paused, queue_t_unref, queues, RESULT_SUCCESS, queue_ent::start, member::status, and call_queue::talktime.

Referenced by load_module().

manager_remove_queue_member()

static int manager_remove_queue_member ( struct mansession *  s, const struct message *  m  )

static

Definition at line 10840 of file app_queue.c.

{
    const char *queuename, *interface;
    struct member *mem = NULL;
 
    queuename = astman_get_header(m, "Queue");
    interface = astman_get_header(m, "Interface");
 
    if (ast_strlen_zero(queuename) || ast_strlen_zero(interface)) {
        astman_send_error(s, m, "Need 'Queue' and 'Interface' parameters.");
        return 0;
    }
 
    if (log_membername_as_agent) {
        mem = find_member_by_queuename_and_interface(queuename, interface);
    }
 
    switch (remove_from_queue(queuename, interface)) {
    case RES_OKAY:
        if (!mem || ast_strlen_zero(mem->membername)) {
            ast_queue_log(queuename, "MANAGER", interface, "REMOVEMEMBER", "%s", "");
        } else {
            ast_queue_log(queuename, "MANAGER", mem->membername, "REMOVEMEMBER", "%s", "");
        }
        astman_send_ack(s, m, "Removed interface from queue");
        break;
    case RES_EXISTS:
        astman_send_error(s, m, "Unable to remove interface: Not there");
        break;
    case RES_NOSUCHQUEUE:
        astman_send_error(s, m, "Unable to remove interface from queue: No such queue");
        break;
    case RES_OUTOFMEMORY:
        astman_send_error(s, m, "Out of memory");
        break;
    case RES_NOT_DYNAMIC:
        astman_send_error(s, m, "Member not dynamic");
        break;
    }
 
    if (mem) {
        ao2_ref(mem, -1);
    }
 
    return 0;
}

References ao2_ref, ast_queue_log(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), find_member_by_queuename_and_interface(), log_membername_as_agent, member::membername, NULL, remove_from_queue(), RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_DYNAMIC, RES_OKAY, and RES_OUTOFMEMORY.

Referenced by load_module().

manager_request_withdraw_caller_from_queue()

static int manager_request_withdraw_caller_from_queue ( struct mansession *  s, const struct message *  m  )

static

Definition at line 11118 of file app_queue.c.

{
    const char *queuename, *caller, *withdraw_info;
 
    queuename = astman_get_header(m, "Queue");
    caller = astman_get_header(m, "Caller");
    withdraw_info = astman_get_header(m, "WithdrawInfo");
 
    if (ast_strlen_zero(queuename)) {
        astman_send_error(s, m, "'Queue' not specified.");
        return 0;
    }
 
    if (ast_strlen_zero(caller)) {
        astman_send_error(s, m, "'Caller' not specified.");
        return 0;
    }
 
    switch (request_withdraw_caller_from_queue(queuename, caller, withdraw_info)) {
    case RES_OKAY:
        astman_send_ack(s, m, "Withdraw requested successfully");
        break;
    case RES_NOSUCHQUEUE:
        astman_send_error(s, m, "Unable to request withdraw from queue: No such queue");
        break;
    case RES_NOT_CALLER:
        astman_send_error(s, m, "Unable to request withdraw from queue: No such caller");
        break;
    case RES_EXISTS:
        astman_send_error(s, m, "Unable to request withdraw from queue: Already requested");
        break;
    }
 
    return 0;
}

References ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), request_withdraw_caller_from_queue(), RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_CALLER, and RES_OKAY.

Referenced by load_module().

mark_member_dead()

static int mark_member_dead ( void *  obj, void *  arg, int  flags  )

static

Definition at line 9892 of file app_queue.c.

{
    struct member *member = obj;
    if (!member->dynamic && !member->realtime) {
        member->delme = 1;
    }
    return 0;
}

References member::delme, member::dynamic, and member::realtime.

Referenced by reload_single_queue().

mark_unfound()

static int mark_unfound ( void *  obj, void *  arg, int  flags  )

static

Definition at line 10046 of file app_queue.c.

{
    struct call_queue *q = obj;
    char *queuename = arg;
    if (!q->realtime && (ast_strlen_zero(queuename) || !strcasecmp(queuename, q->name))) {
        q->found = 0;
    }
    return 0;
}

References ast_strlen_zero(), call_queue::found, call_queue::name, and call_queue::realtime.

Referenced by reload_queues().

member_add_to_queue()

static void member_add_to_queue ( struct call_queue *  queue, struct member *  mem  )

static

Definition at line 3694 of file app_queue.c.

{
    ao2_lock(queue->members);
    mem->queuepos = ao2_container_count(queue->members);
    ao2_link(queue->members, mem);
    ast_devstate_changed(mem->paused ? QUEUE_PAUSED_DEVSTATE : QUEUE_UNPAUSED_DEVSTATE,
        AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", queue->name, mem->interface);
    ao2_unlock(queue->members);
}

References ao2_container_count(), ao2_link, ao2_lock, ao2_unlock, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), member::interface, call_queue::members, call_queue::name, member::paused, QUEUE_PAUSED_DEVSTATE, QUEUE_UNPAUSED_DEVSTATE, and member::queuepos.

Referenced by add_to_queue(), reload_single_member(), and rt_handle_member_record().

member_cmp_fn()

static int member_cmp_fn ( void *  obj1, void *  obj2, int  flags  )

static

Definition at line 3069 of file app_queue.c.

{
    struct member *mem1 = obj1;
    struct member *mem2 = obj2;
    const char *interface = (flags & OBJ_KEY) ? obj2 : mem2->interface;
 
    return strcasecmp(mem1->interface, interface) ? 0 : CMP_MATCH | CMP_STOP;
}

References CMP_MATCH, CMP_STOP, member::interface, and OBJ_KEY.

Referenced by init_queue().

member_hash_fn()

static int member_hash_fn ( const void *  obj, const int  flags  )

static

Definition at line 3053 of file app_queue.c.

{
    const struct member *mem = obj;
    const char *interface = (flags & OBJ_KEY) ? obj : mem->interface;
    const char *chname = strchr(interface, '/');
    int ret = 0, i;
 
    if (!chname) {
        chname = interface;
    }
    for (i = 0; i < 5 && chname[i]; i++) {
        ret += compress_char(chname[i]) << (i * 6);
    }
    return ret;
}

References compress_char(), member::interface, and OBJ_KEY.

Referenced by init_queue().

member_remove_from_queue()

static void member_remove_from_queue ( struct call_queue *  queue, struct member *  mem  )

static

Definition at line 3710 of file app_queue.c.

{
    pending_members_remove(mem);
    ao2_lock(queue->members);
    ast_devstate_changed(QUEUE_UNKNOWN_PAUSED_DEVSTATE, AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", queue->name, mem->interface);
    queue_member_follower_removal(queue, mem);
    ao2_unlink(queue->members, mem);
    ao2_unlock(queue->members);
}

References ao2_lock, ao2_unlink, ao2_unlock, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), member::interface, call_queue::members, call_queue::name, pending_members_remove(), queue_member_follower_removal(), and QUEUE_UNKNOWN_PAUSED_DEVSTATE.

Referenced by find_queue_by_name_rt(), free_members(), remove_from_queue(), and update_realtime_members().

member_status_available()

static int member_status_available ( int  status )

static

Definition at line 4791 of file app_queue.c.

{
    return status == AST_DEVICE_NOT_INUSE || status == AST_DEVICE_UNKNOWN;
}

References AST_DEVICE_NOT_INUSE, AST_DEVICE_UNKNOWN, and status.

Referenced by can_ring_entry(), and manager_queues_summary().

num_available_members()

static int num_available_members ( struct call_queue *  q )

static

Get the number of members available to accept a call.

Note

The queue passed in should be locked prior to this function call

Parameters

[in]

q

The queue for which we are counting the number of available members

Returns

Return the number of available members in queue q

Definition at line 4657 of file app_queue.c.

{
    struct member *mem;
    int avl = 0;
    struct ao2_iterator mem_iter;
 
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((mem = ao2_iterator_next(&mem_iter))) {
 
        avl += is_member_available(q, mem);
        ao2_ref(mem, -1);
 
        /* If autofill is not enabled or if the queue's strategy is ringall, then
         * we really don't care about the number of available members so much as we
         * do that there is at least one available.
         *
         * In fact, we purposely will return from this function stating that only
         * one member is available if either of those conditions hold. That way,
         * functions which determine what action to take based on the number of available
         * members will operate properly. The reasoning is that even if multiple
         * members are available, only the head caller can actually be serviced.
         */
        if ((!q->autofill || q->strategy == QUEUE_STRATEGY_RINGALL) && avl) {
            break;
        }
    }
    ao2_iterator_destroy(&mem_iter);
 
    return avl;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, call_queue::autofill, is_member_available(), call_queue::members, QUEUE_STRATEGY_RINGALL, and call_queue::strategy.

Referenced by compare_weight(), is_our_turn(), remove_from_queue(), and set_queue_member_pause().

parse_empty_options()

static void parse_empty_options ( const char *  value, enum empty_conditions *  empty, int  joinempty  )

static

Definition at line 3437 of file app_queue.c.

{
    char *value_copy = ast_strdupa(value);
    char *option = NULL;
    while ((option = strsep(&value_copy, ","))) {
        if (!strcasecmp(option, "paused")) {
            *empty |= QUEUE_EMPTY_PAUSED;
        } else if (!strcasecmp(option, "penalty")) {
            *empty |= QUEUE_EMPTY_PENALTY;
        } else if (!strcasecmp(option, "inuse")) {
            *empty |= QUEUE_EMPTY_INUSE;
        } else if (!strcasecmp(option, "ringing")) {
            *empty |= QUEUE_EMPTY_RINGING;
        } else if (!strcasecmp(option, "invalid")) {
            *empty |= QUEUE_EMPTY_INVALID;
        } else if (!strcasecmp(option, "wrapup")) {
            *empty |= QUEUE_EMPTY_WRAPUP;
        } else if (!strcasecmp(option, "unavailable")) {
            *empty |= QUEUE_EMPTY_UNAVAILABLE;
        } else if (!strcasecmp(option, "unknown")) {
            *empty |= QUEUE_EMPTY_UNKNOWN;
        } else if (!strcasecmp(option, "loose")) {
            *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID);
        } else if (!strcasecmp(option, "strict")) {
            *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED | QUEUE_EMPTY_UNAVAILABLE);
        } else if ((ast_false(option) && joinempty) || (ast_true(option) && !joinempty)) {
            *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED);
        } else if ((ast_false(option) && !joinempty) || (ast_true(option) && joinempty)) {
            *empty = 0;
        } else {
            ast_log(LOG_WARNING, "Unknown option %s for '%s'\n", option, joinempty ? "joinempty" : "leavewhenempty");
        }
    }
}

References ast_false(), ast_log, ast_strdupa, ast_true(), LOG_WARNING, NULL, QUEUE_EMPTY_INUSE, QUEUE_EMPTY_INVALID, QUEUE_EMPTY_PAUSED, QUEUE_EMPTY_PENALTY, QUEUE_EMPTY_RINGING, QUEUE_EMPTY_UNAVAILABLE, QUEUE_EMPTY_UNKNOWN, QUEUE_EMPTY_WRAPUP, strsep(), and value.

Referenced by queue_set_param().

pending_members_cmp()

static int pending_members_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2669 of file app_queue.c.

{
    const struct member *object_left = obj;
    const struct member *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->interface;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcasecmp(object_left->interface, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /* Not supported by container. */
        ast_assert(0);
        return 0;
    default:
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

References ast_assert, CMP_MATCH, member::interface, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

pending_members_hash()

static int pending_members_hash ( const void *  obj, const int  flags  )

static

Definition at line 2649 of file app_queue.c.

{
    const struct member *object;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        object = obj;
        key = object->interface;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by load_module().

pending_members_remove()

static void pending_members_remove ( struct member *  mem )

static

Definition at line 2697 of file app_queue.c.

{
    ast_debug(3, "Removed %s from pending_members\n", mem->membername);
    ao2_find(pending_members, mem, OBJ_POINTER | OBJ_NODATA | OBJ_UNLINK);
}

References ao2_find, ast_debug, member::membername, OBJ_NODATA, OBJ_POINTER, OBJ_UNLINK, and pending_members.

Referenced by can_ring_entry(), do_hang(), hangupcalls(), member_remove_from_queue(), ring_entry(), try_calling(), update_queue(), and update_status().

play_file()

static int play_file ( struct ast_channel *  chan, const char *  filename  )

static

Definition at line 4291 of file app_queue.c.

{
    int res;
 
    if (ast_strlen_zero(filename)) {
        return 0;
    }
 
    if (!ast_fileexists(filename, NULL, ast_channel_language(chan))) {
        return 0;
    }
 
    ast_stopstream(chan);
 
    res = ast_streamfile(chan, filename, ast_channel_language(chan));
    if (!res) {
        res = ast_waitstream(chan, AST_DIGIT_ANY);
    }
 
    ast_stopstream(chan);
 
    return res;
}

References ast_channel_language(), AST_DIGIT_ANY, ast_fileexists(), ast_stopstream(), ast_streamfile(), ast_strlen_zero(), ast_waitstream(), queue_ent::chan, and NULL.

Referenced by say_periodic_announcement(), say_position(), and try_calling().

pqm_exec()

static int pqm_exec ( struct ast_channel *  chan, const char *  data  )

static

PauseQueueMember application.

Definition at line 8359 of file app_queue.c.

{
    char *parse;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
        AST_APP_ARG(options);
        AST_APP_ARG(reason);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "PauseQueueMember requires an argument ([queuename],interface[,options][,reason])\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.interface)) {
        ast_log(LOG_WARNING, "Missing interface argument to PauseQueueMember ([queuename],interface[,options[,reason]])\n");
        return -1;
    }
 
    if (set_member_paused(args.queuename, args.interface, args.reason, 1)) {
        ast_log(LOG_WARNING, "Attempt to pause interface %s, not found\n", args.interface);
        pbx_builtin_setvar_helper(chan, "PQMSTATUS", "NOTFOUND");
        return 0;
    }
 
    pbx_builtin_setvar_helper(chan, "PQMSTATUS", "PAUSED");
 
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), LOG_WARNING, options, pbx_builtin_setvar_helper(), and set_member_paused().

Referenced by load_module().

print_queue()

static void print_queue ( struct mansession *  s, int  fd, struct call_queue *  q  )

static

Print a single queue to AMI or the CLI.

Definition at line 10194 of file app_queue.c.

{
    float sl;
    float sl2;
    struct ao2_iterator mem_iter;
    struct ast_str *out = ast_str_alloca(512);
    time_t now = time(NULL);
 
    ast_str_set(&out, 0, "%s has %d calls (max ", q->name, q->count);
    if (q->maxlen) {
        ast_str_append(&out, 0, "%d", q->maxlen);
    } else {
        ast_str_append(&out, 0, "unlimited");
    }
    sl = 0;
    sl2 = 0;
    if (q->callscompleted > 0) {
        sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
    }
    if (q->callscompleted + q->callsabandoned > 0) {
        sl2 =100 * (((float)q->callsabandonedinsl + (float)q->callscompletedinsl) / ((float)q->callsabandoned + (float)q->callscompleted));
    }
 
    ast_str_append(&out, 0, ") in '%s' strategy (%ds holdtime, %ds talktime), W:%d, C:%d, A:%d, SL:%2.1f%%, SL2:%2.1f%% within %ds",
        int2strat(q->strategy), q->holdtime, q->talktime, q->weight, q->callscompleted, q->callsabandoned, sl, sl2, q->servicelevel);
    do_print(s, fd, ast_str_buffer(out));
    if (!ao2_container_count(q->members)) {
        do_print(s, fd, "   No Members");
    } else {
        struct member *mem;
 
        do_print(s, fd, "   Members: ");
        mem_iter = ao2_iterator_init(q->members, 0);
        while ((mem = ao2_iterator_next(&mem_iter))) {
            ast_str_set(&out, 0, "      %s", mem->membername);
            if (strcasecmp(mem->membername, mem->interface)) {
                ast_str_append(&out, 0, " (%s", mem->interface);
                if (!ast_strlen_zero(mem->state_interface)
                    && strcmp(mem->state_interface, mem->interface)) {
                    ast_str_append(&out, 0, " from %s", mem->state_interface);
                }
                ast_str_append(&out, 0, ")");
            }
            if (mem->penalty) {
                ast_str_append(&out, 0, " with penalty %d", mem->penalty);
            }
 
            ast_str_append(&out, 0, " (ringinuse %s)", mem->ringinuse ? "enabled" : "disabled");
 
            ast_str_append(&out, 0, "%s%s%s%s%s%s%s%s%s",
                mem->dynamic ? ast_term_color(COLOR_CYAN, COLOR_BLACK) : "", mem->dynamic ? " (dynamic)" : "", ast_term_reset(),
                mem->realtime ? ast_term_color(COLOR_MAGENTA, COLOR_BLACK) : "", mem->realtime ? " (realtime)" : "", ast_term_reset(),
                mem->starttime ? ast_term_color(COLOR_BROWN, COLOR_BLACK) : "", mem->starttime ? " (in call)" : "", ast_term_reset());
 
            if (mem->paused) {
                ast_str_append(&out, 0, " %s(paused%s%s was %ld secs ago)%s",
                    ast_term_color(COLOR_BROWN, COLOR_BLACK),
                    ast_strlen_zero(mem->reason_paused) ? "" : ":",
                    ast_strlen_zero(mem->reason_paused) ? "" : mem->reason_paused,
                    (long) (now - mem->lastpause),
                    ast_term_reset());
            }
 
            ast_str_append(&out, 0, " (%s%s%s)",
                ast_term_color(
                    mem->status == AST_DEVICE_UNAVAILABLE || mem->status == AST_DEVICE_UNKNOWN ?
                        COLOR_RED : COLOR_GREEN, COLOR_BLACK),
                    ast_devstate2str(mem->status), ast_term_reset());
            if (mem->calls) {
                ast_str_append(&out, 0, " has taken %d calls (last was %ld secs ago)",
                    mem->calls, (long) (now - mem->lastcall));
            } else {
                ast_str_append(&out, 0, " has taken no calls yet");
            }
            ast_str_append(&out, 0, " %s(login was %ld secs ago)%s",
                ast_term_color(COLOR_BROWN, COLOR_BLACK),
                (long) (now - mem->logintime),
                ast_term_reset());
            do_print(s, fd, ast_str_buffer(out));
            ao2_ref(mem, -1);
        }
        ao2_iterator_destroy(&mem_iter);
    }
    if (!q->head) {
        do_print(s, fd, "   No Callers");
    } else {
        struct queue_ent *qe;
        int pos = 1;
 
        do_print(s, fd, "   Callers: ");
        for (qe = q->head; qe; qe = qe->next) {
            ast_str_set(&out, 0, "      %d. %s (wait: %ld:%2.2ld, prio: %d)",
                pos++, ast_channel_name(qe->chan), (long) (now - qe->start) / 60,
                (long) (now - qe->start) % 60, qe->prio);
            do_print(s, fd, ast_str_buffer(out));
        }
    }
    do_print(s, fd, "");    /* blank line between entries */
}

References ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_name(), AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, ast_devstate2str(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_strlen_zero(), ast_term_color(), ast_term_reset(), member::calls, call_queue::callsabandoned, call_queue::callsabandonedinsl, call_queue::callscompleted, call_queue::callscompletedinsl, queue_ent::chan, COLOR_BLACK, COLOR_BROWN, COLOR_CYAN, COLOR_GREEN, COLOR_MAGENTA, COLOR_RED, call_queue::count, do_print(), member::dynamic, call_queue::head, call_queue::holdtime, int2strat(), member::interface, member::lastcall, member::lastpause, member::logintime, call_queue::maxlen, member::membername, call_queue::members, call_queue::name, queue_ent::next, NULL, out, member::paused, member::penalty, queue_ent::pos, queue_ent::prio, member::realtime, member::reason_paused, member::ringinuse, call_queue::servicelevel, queue_ent::start, member::starttime, member::state_interface, member::status, call_queue::strategy, call_queue::talktime, and call_queue::weight.

Referenced by __queues_show().

publish_dial_end_event()

static void publish_dial_end_event ( struct ast_channel *  in, struct callattempt *  outgoing, struct ast_channel *  exception, const char *  status  )

static

Definition at line 4605 of file app_queue.c.

{
    struct callattempt *cur;
 
    for (cur = outgoing; cur; cur = cur->q_next) {
        if (cur->chan && cur->chan != exception) {
            ast_channel_publish_dial(in, cur->chan, NULL, status);
        }
    }
}

References ast_channel_publish_dial(), callattempt::chan, in, NULL, callattempt::q_next, and status.

Referenced by ring_entry(), and wait_for_answer().

publish_queue_member_pause()

static int publish_queue_member_pause ( struct call_queue *  q, struct member *  member  )

static

Definition at line 7909 of file app_queue.c.

{
    struct ast_json *json_blob = queue_member_blob_create(q, member);
 
    if (!json_blob) {
        return -1;
    }
 
    queue_publish_member_blob(queue_member_pause_type(), json_blob);
 
    return 0;
}

References queue_member_blob_create(), and queue_publish_member_blob().

Referenced by set_queue_member_pause().

ql_exec()

static int ql_exec ( struct ast_channel *  chan, const char *  data  )

static

QueueLog application.

Definition at line 8596 of file app_queue.c.

{
    char *parse;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(uniqueid);
        AST_APP_ARG(membername);
        AST_APP_ARG(event);
        AST_APP_ARG(params);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "QueueLog requires arguments (queuename,uniqueid,membername,event[,additionalinfo]\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.queuename) || ast_strlen_zero(args.uniqueid)
        || ast_strlen_zero(args.membername) || ast_strlen_zero(args.event)) {
        ast_log(LOG_WARNING, "QueueLog requires arguments (queuename,uniqueid,membername,event[,additionalinfo])\n");
        return -1;
    }
 
    ast_queue_log(args.queuename, args.uniqueid, args.membername, args.event,
        "%s", args.params ? args.params : "");
 
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, ast_queue_log(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), and LOG_WARNING.

Referenced by load_module().

queue_agent_called_to_ami()

static struct ast_manager_event_blob * queue_agent_called_to_ami ( struct stasis_message *  message )

static

Definition at line 2392 of file app_queue.c.

{
    return queue_multi_channel_to_ami("AgentCalled", message);
}

References queue_multi_channel_to_ami().

queue_agent_cb()

static void queue_agent_cb ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6308 of file app_queue.c.

{
    struct ast_channel_blob *agent_blob;
 
    agent_blob = stasis_message_data(msg);
 
    if (ast_channel_agent_login_type() == stasis_message_type(msg)) {
        ast_queue_log("NONE", agent_blob->snapshot->base->uniqueid,
            ast_json_string_get(ast_json_object_get(agent_blob->blob, "agent")),
            "AGENTLOGIN", "%s", agent_blob->snapshot->base->name);
    } else if (ast_channel_agent_logoff_type() == stasis_message_type(msg)) {
        ast_queue_log("NONE", agent_blob->snapshot->base->uniqueid,
            ast_json_string_get(ast_json_object_get(agent_blob->blob, "agent")),
            "AGENTLOGOFF", "%s|%ld", agent_blob->snapshot->base->name,
            (long) ast_json_integer_get(ast_json_object_get(agent_blob->blob, "logintime")));
    }
}

References ast_channel_agent_login_type(), ast_channel_agent_logoff_type(), ast_json_integer_get(), ast_json_object_get(), ast_json_string_get(), ast_queue_log(), ast_channel_snapshot::base, ast_channel_blob::blob, ast_channel_snapshot_base::name, ast_channel_blob::snapshot, stasis_message_data(), stasis_message_type(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

queue_agent_complete_to_ami()

static struct ast_manager_event_blob * queue_agent_complete_to_ami ( struct stasis_message *  message )

static

Definition at line 2402 of file app_queue.c.

{
    return queue_multi_channel_to_ami("AgentComplete", message);
}

References queue_multi_channel_to_ami().

queue_agent_connect_to_ami()

static struct ast_manager_event_blob * queue_agent_connect_to_ami ( struct stasis_message *  message )

static

Definition at line 2397 of file app_queue.c.

{
    return queue_multi_channel_to_ami("AgentConnect", message);
}

References queue_multi_channel_to_ami().

queue_agent_dump_to_ami()

static struct ast_manager_event_blob * queue_agent_dump_to_ami ( struct stasis_message *  message )

static

Definition at line 2407 of file app_queue.c.

{
    return queue_multi_channel_to_ami("AgentDump", message);
}

References queue_multi_channel_to_ami().

queue_agent_ringnoanswer_to_ami()

static struct ast_manager_event_blob * queue_agent_ringnoanswer_to_ami ( struct stasis_message *  message )

static

Definition at line 2412 of file app_queue.c.

{
    return queue_multi_channel_to_ami("AgentRingNoAnswer", message);
}

References queue_multi_channel_to_ami().

queue_bridge_cb()

static void queue_bridge_cb ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6671 of file app_queue.c.

{
    if (stasis_subscription_final_message(sub, msg)) {
        ao2_cleanup(userdata);
    }
}

References ao2_cleanup, stasis_subscription_final_message(), and sub.

Referenced by setup_stasis_subs().

queue_caller_abandon_to_ami()

static struct ast_manager_event_blob * queue_caller_abandon_to_ami ( struct stasis_message *  message )

static

Definition at line 2272 of file app_queue.c.

{
    return queue_channel_to_ami("QueueCallerAbandon", message);
}

References queue_channel_to_ami().

queue_caller_join_to_ami()

static struct ast_manager_event_blob * queue_caller_join_to_ami ( struct stasis_message *  message )

static

Definition at line 2262 of file app_queue.c.

{
    return queue_channel_to_ami("QueueCallerJoin", message);
}

References queue_channel_to_ami().

queue_caller_leave_to_ami()

static struct ast_manager_event_blob * queue_caller_leave_to_ami ( struct stasis_message *  message )

static

Definition at line 2267 of file app_queue.c.

{
    return queue_channel_to_ami("QueueCallerLeave", message);
}

References queue_channel_to_ami().

queue_channel_cb()

static void queue_channel_cb ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 6896 of file app_queue.c.

{
    if (stasis_subscription_final_message(sub, msg)) {
        ao2_cleanup(userdata);
    }
}

References ao2_cleanup, stasis_subscription_final_message(), and sub.

Referenced by setup_stasis_subs().

queue_channel_to_ami()

static struct ast_manager_event_blob * queue_channel_to_ami ( const char *  type, struct stasis_message *  message  )

static

Definition at line 2243 of file app_queue.c.

{
    struct ast_channel_blob *obj = stasis_message_data(message);
    RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
    RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    event_string = ast_manager_str_from_json_object(obj->blob, NULL);
    if (!channel_string || !event_string) {
        return NULL;
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
        "%s"
        "%s",
        ast_str_buffer(channel_string),
        ast_str_buffer(event_string));
}

References ast_free, ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_manager_str_from_json_object(), ast_str_buffer(), ast_channel_blob::blob, EVENT_FLAG_AGENT, NULL, RAII_VAR, ast_channel_blob::snapshot, stasis_message_data(), and type.

Referenced by queue_caller_abandon_to_ami(), queue_caller_join_to_ami(), and queue_caller_leave_to_ami().

queue_cmp_cb()

static int queue_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 2106 of file app_queue.c.

{
    struct call_queue *q = obj, *q2 = arg;
    return !strcasecmp(q->name, q2->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, and call_queue::name.

Referenced by load_module().

queue_delme_members_decrement_followers()

static int queue_delme_members_decrement_followers ( void *  obj, void *  arg, int  flag  )

static

Definition at line 2152 of file app_queue.c.

{
    struct member *mem = obj;
    struct call_queue *queue = arg;
    int rrpos = mem->queuepos;
 
    if (mem->delme) {
        ao2_callback(queue->members, OBJ_NODATA | OBJ_MULTIPLE, queue_member_decrement_followers, &rrpos);
    }
 
    return 0;
}

References ao2_callback, member::delme, call_queue::members, OBJ_MULTIPLE, OBJ_NODATA, queue_member_decrement_followers(), member::queuepos, and call_queue::rrpos.

Referenced by reload_single_queue().

queue_exec()

static int queue_exec ( struct ast_channel *  chan, const char *  data  )

static

The starting point for all queue calls.

The process involved here is to

1. Parse the options specified in the call to Queue()
2. Join the queue
3. Wait in a loop until it is our turn to try calling a queue member
4. Attempt to call a queue member
5. If 4. did not result in a bridged call, then check for between call options such as periodic announcements etc.
6. Try 4 again unless some condition (such as an expiration time) causes us to exit the queue.

Definition at line 8673 of file app_queue.c.

{
    int res=-1;
    int ringing=0;
    const char *user_priority;
    const char *max_penalty_str;
    const char *min_penalty_str;
    const char *raise_penalty_str;
    int prio;
    int qcontinue = 0;
    int max_penalty, min_penalty, raise_penalty;
    enum queue_result reason = QUEUE_UNKNOWN;
    /* whether to exit Queue application after the timeout hits */
    int tries = 0;
    int noption = 0;
    char *parse;
    int makeannouncement = 0;
    int position = 0;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(options);
        AST_APP_ARG(url);
        AST_APP_ARG(announceoverride);
        AST_APP_ARG(queuetimeoutstr);
        AST_APP_ARG(agi);
        AST_APP_ARG(gosub);
        AST_APP_ARG(rule);
        AST_APP_ARG(position);
    );
    /* Our queue entry */
    struct queue_ent qe = { 0 };
    struct ast_flags opts = { 0, };
    char *opt_args[OPT_ARG_ARRAY_SIZE];
    int max_forwards;
    int cid_allow;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "Queue requires an argument: queuename[,options[,URL[,announceoverride[,timeout[,agi[,gosub[,rule[,position]]]]]]]]\n");
        return -1;
    }
 
    ast_channel_lock(chan);
    max_forwards = ast_max_forwards_get(chan);
    ast_channel_unlock(chan);
 
    if (max_forwards <= 0) {
        ast_log(LOG_WARNING, "Channel '%s' cannot enter queue. Max forwards exceeded\n", ast_channel_name(chan));
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    ast_debug(1, "queue: %s, options: %s, url: %s, announce: %s, timeout: %s, agi: %s, gosub: %s, rule: %s, position: %s\n",
        args.queuename,
        S_OR(args.options, ""),
        S_OR(args.url, ""),
        S_OR(args.announceoverride, ""),
        S_OR(args.queuetimeoutstr, ""),
        S_OR(args.agi, ""),
        S_OR(args.gosub, ""),
        S_OR(args.rule, ""),
        S_OR(args.position, ""));
 
    if (!ast_strlen_zero(args.options)) {
        ast_app_parse_options(queue_exec_options, &opts, opt_args, args.options);
    }
 
    /* Setup our queue entry */
    qe.start = time(NULL);
 
    pbx_builtin_setvar_helper(chan, "ABANDONED", NULL);
 
    /* set the expire time based on the supplied timeout; */
    if (!ast_strlen_zero(args.queuetimeoutstr)) {
        qe.expire = qe.start + atoi(args.queuetimeoutstr);
    } else {
        qe.expire = 0;
    }
 
    /* Get the priority from the variable ${QUEUE_PRIO} */
    ast_channel_lock(chan);
    user_priority = pbx_builtin_getvar_helper(chan, "QUEUE_PRIO");
    if (user_priority) {
        if (sscanf(user_priority, "%30d", &prio) == 1) {
            ast_debug(1, "%s: Got priority %d from ${QUEUE_PRIO}.\n", ast_channel_name(chan), prio);
        } else {
            ast_log(LOG_WARNING, "${QUEUE_PRIO}: Invalid value (%s), channel %s.\n",
                user_priority, ast_channel_name(chan));
            prio = 0;
        }
    } else {
        ast_debug(3, "NO QUEUE_PRIO variable found. Using default.\n");
        prio = 0;
    }
 
    /* Get the maximum penalty from the variable ${QUEUE_MAX_PENALTY} */
 
    if ((max_penalty_str = pbx_builtin_getvar_helper(chan, "QUEUE_MAX_PENALTY"))) {
        if (sscanf(max_penalty_str, "%30d", &max_penalty) == 1) {
            ast_debug(1, "%s: Got max penalty %d from ${QUEUE_MAX_PENALTY}.\n", ast_channel_name(chan), max_penalty);
        } else {
            ast_log(LOG_WARNING, "${QUEUE_MAX_PENALTY}: Invalid value (%s), channel %s.\n",
                max_penalty_str, ast_channel_name(chan));
            max_penalty = INT_MAX;
        }
    } else {
        max_penalty = INT_MAX;
    }
 
    if ((min_penalty_str = pbx_builtin_getvar_helper(chan, "QUEUE_MIN_PENALTY"))) {
        if (sscanf(min_penalty_str, "%30d", &min_penalty) == 1) {
            ast_debug(1, "%s: Got min penalty %d from ${QUEUE_MIN_PENALTY}.\n", ast_channel_name(chan), min_penalty);
        } else {
            ast_log(LOG_WARNING, "${QUEUE_MIN_PENALTY}: Invalid value (%s), channel %s.\n",
                min_penalty_str, ast_channel_name(chan));
            min_penalty = INT_MAX;
        }
    } else {
        min_penalty = INT_MAX;
    }
 
    if ((raise_penalty_str = pbx_builtin_getvar_helper(chan, "QUEUE_RAISE_PENALTY"))) {
         if (*raise_penalty_str == 'r') {
            qe.raise_respect_min = 1;
            raise_penalty_str++;
        } else {
            qe.raise_respect_min = 0;
        }
        if (sscanf(raise_penalty_str, "%30d", &raise_penalty) == 1) {
            ast_debug(1, "%s: Got raise penalty %s%d from ${QUEUE_RAISE_PENALTY}.\n", ast_channel_name(chan), qe.raise_respect_min ? "r" : "", raise_penalty);
        } else {
            ast_log(LOG_WARNING, "${QUEUE_RAISE_PENALTY}: Invalid value (%s), channel %s.\n",
                raise_penalty_str, ast_channel_name(chan));
            raise_penalty = INT_MAX;
        }
    } else {
        raise_penalty = INT_MAX;
    }
    ast_channel_unlock(chan);
 
    if (ast_test_flag(&opts, OPT_RINGING)) {
        ringing = 1;
    }
 
    if (ringing != 1 && ast_test_flag(&opts, OPT_RING_WHEN_RINGING)) {
        qe.ring_when_ringing = 1;
    }
 
    if (ast_test_flag(&opts, OPT_GO_ON)) {
        qcontinue = 1;
    }
 
    if (args.position) {
        position = atoi(args.position);
        if (position < 0) {
            ast_log(LOG_WARNING, "Invalid position '%s' given for call to queue '%s'. Assuming no preference for position\n", args.position, args.queuename);
            position = 0;
        }
    }
 
    ast_debug(1, "queue: %s, expires: %ld, priority: %d\n",
        args.queuename, (long)qe.expire, prio);
 
    qe.chan = chan;
    qe.prio = prio;
    qe.max_penalty = max_penalty;
    qe.min_penalty = min_penalty;
    qe.raise_penalty = raise_penalty;
    qe.last_pos_said = 0;
    qe.last_pos = 0;
    qe.last_periodic_announce_time = time(NULL);
    qe.last_periodic_announce_sound = 0;
    qe.valid_digits = 0;
    if (join_queue(args.queuename, &qe, &reason, position)) {
        ast_log(LOG_WARNING, "Unable to join queue '%s'\n", args.queuename);
        set_queue_result(chan, reason);
        return 0;
    }
    ast_assert(qe.parent != NULL);
 
    if (qe.parent->periodicannouncestartdelay >= 0) {
        qe.last_periodic_announce_time += qe.parent->periodicannouncestartdelay;
        qe.last_periodic_announce_time -= qe.parent->periodicannouncefrequency;
    }
 
    cid_allow = qe.parent->log_restricted_caller_id || ((ast_party_id_presentation(&ast_channel_caller(chan)->id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED);
    
    if (log_caller_id_name) {
        char *escaped_cidname = NULL;
        /* Ensure caller ID name is valid and not NULL before processing */
        if (cid_allow && ast_channel_caller(chan)->id.name.valid && ast_channel_caller(chan)->id.name.str) {
            escaped_cidname = ast_strdupa(ast_channel_caller(chan)->id.name.str);
            /* Only iterate if '|' is found */
            if (strchr(escaped_cidname, '|')) {
                for (char *p = escaped_cidname; *p; p++) {
                    if (*p == '|') {
                        *p = '_';
                    }
                }
            }
        }
 
        ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "ENTERQUEUE", "%s|%s|%d|%s",
            S_OR(args.url, ""),
            S_COR(cid_allow && ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""),
            qe.opos,
            S_OR(escaped_cidname, ""));
    } else {
        ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "ENTERQUEUE", "%s|%s|%d",
            S_OR(args.url, ""),
            S_COR(cid_allow && ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""),
            qe.opos);
    }
    
    /* PREDIAL: Preprocess any callee gosub arguments. */
    if (ast_test_flag(&opts, OPT_PREDIAL_CALLEE)
        && !ast_strlen_zero(opt_args[OPT_ARG_PREDIAL_CALLEE])) {
        ast_replace_subargument_delimiter(opt_args[OPT_ARG_PREDIAL_CALLEE]);
        qe.predial_callee = opt_args[OPT_ARG_PREDIAL_CALLEE];
    }
 
    /* PREDIAL: Run gosub on the caller's channel */
    if (ast_test_flag(&opts, OPT_PREDIAL_CALLER)
        && !ast_strlen_zero(opt_args[OPT_ARG_PREDIAL_CALLER])) {
        ast_replace_subargument_delimiter(opt_args[OPT_ARG_PREDIAL_CALLER]);
        ast_app_exec_sub(NULL, chan, opt_args[OPT_ARG_PREDIAL_CALLER], 0);
    }
 
    /* Music on hold class override */
    if (ast_test_flag(&opts, OPT_MUSICONHOLD_CLASS)
        && !ast_strlen_zero(opt_args[OPT_ARG_MUSICONHOLD_CLASS])) {
        ast_copy_string(qe.moh, opt_args[OPT_ARG_MUSICONHOLD_CLASS], sizeof(qe.moh));
    }
 
    copy_rules(&qe, args.rule);
    qe.pr = AST_LIST_FIRST(&qe.qe_rules);
check_turns:
    if (ringing) {
        ast_indicate(chan, AST_CONTROL_RINGING);
    } else {
        ast_moh_start(chan, qe.moh, NULL);
    }
 
    /* This is the wait loop for callers 2 through maxlen */
    res = wait_our_turn(&qe, ringing, &reason);
    if (res) {
        goto stop;
    }
 
    makeannouncement = qe.parent->announce_to_first_user;
 
    for (;;) {
        /* This is the wait loop for the head caller*/
        /* To exit, they may get their call answered; */
        /* they may dial a digit from the queue context; */
        /* or, they may timeout. */
 
        /* A request to withdraw this call from the queue arrived */
        if (qe.withdraw) {
            reason = QUEUE_WITHDRAW;
            res = 1;
            break;
        }
 
        /* Leave if we have exceeded our queuetimeout */
        if (qe.expire && (time(NULL) >= qe.expire)) {
            record_abandoned(&qe);
            reason = QUEUE_TIMEOUT;
            res = 0;
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan),"NONE", "EXITWITHTIMEOUT", "%d|%d|%ld",
                qe.pos, qe.opos, (long) (time(NULL) - qe.start));
            break;
        }
 
        if (makeannouncement) {
            /* Make a position announcement, if enabled */
            if (qe.parent->announcefrequency) {
                if ((res = say_position(&qe, ringing))) {
                    goto stop;
                }
            }
        }
        makeannouncement = 1;
 
        /* Make a periodic announcement, if enabled */
        if (qe.parent->periodicannouncefrequency) {
            if ((res = say_periodic_announcement(&qe, ringing))) {
                goto stop;
            }
        }
 
        /* A request to withdraw this call from the queue arrived */
        if (qe.withdraw) {
            reason = QUEUE_WITHDRAW;
            res = 1;
            break;
        }
 
        /* Leave if we have exceeded our queuetimeout */
        if (qe.expire && (time(NULL) >= qe.expire)) {
            record_abandoned(&qe);
            reason = QUEUE_TIMEOUT;
            res = 0;
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "EXITWITHTIMEOUT",
                "%d|%d|%ld", qe.pos, qe.opos, (long) (time(NULL) - qe.start));
            break;
        }
 
        /* see if we need to move to the next penalty level for this queue */
        while (qe.pr && ((time(NULL) - qe.start) > qe.pr->time)) {
            update_qe_rule(&qe);
        }
 
        /* Try calling all queue members for 'timeout' seconds */
        res = try_calling(&qe, opts, opt_args, args.announceoverride, args.url, &tries, &noption, args.agi, args.gosub, ringing);
        if (res) {
            goto stop;
        }
 
        if (qe.parent->leavewhenempty) {
            int status = 0;
            if ((status = get_member_status(qe.parent, qe.max_penalty, qe.min_penalty, qe.raise_penalty, qe.parent->leavewhenempty, 0, qe.raise_respect_min))) {
                record_abandoned(&qe);
                reason = QUEUE_LEAVEEMPTY;
                ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "EXITEMPTY", "%d|%d|%ld", qe.pos, qe.opos, (long)(time(NULL) - qe.start));
                res = 0;
                break;
            }
        }
 
        /* exit after 'timeout' cycle if 'n' option enabled */
        if (noption && tries >= ao2_container_count(qe.parent->members)) {
            ast_verb(3, "Exiting on time-out cycle\n");
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "EXITWITHTIMEOUT",
                "%d|%d|%ld", qe.pos, qe.opos, (long) (time(NULL) - qe.start));
            record_abandoned(&qe);
            reason = QUEUE_TIMEOUT;
            res = 0;
            break;
        }
 
 
        /* Leave if we have exceeded our queuetimeout */
        if (qe.expire && (time(NULL) >= qe.expire)) {
            record_abandoned(&qe);
            reason = QUEUE_TIMEOUT;
            res = 0;
            ast_queue_log(qe.parent->name, ast_channel_uniqueid(qe.chan),"NONE", "EXITWITHTIMEOUT", "%d|%d|%ld", qe.pos, qe.opos, (long) (time(NULL) - qe.start));
            break;
        }
 
        /* OK, we didn't get anybody; wait for 'retry' seconds; may get a digit to exit with */
        res = wait_a_bit(&qe);
        if (res) {
            goto stop;
        }
 
        /* If using dynamic realtime members, we should regenerate the member list for this queue */
        update_realtime_members(qe.parent);
 
        /* Since this is a priority queue and
         * it is not sure that we are still at the head
         * of the queue, go and check for our turn again.
         */
        if (!is_our_turn(&qe)) {
            ast_debug(1, "Darn priorities, going back in queue (%s)!\n", ast_channel_name(qe.chan));
            goto check_turns;
        }
    }
 
stop:
    if (res) {
        if (reason == QUEUE_WITHDRAW) {
            record_abandoned(&qe);
            ast_queue_log(qe.parent->name, ast_channel_uniqueid(qe.chan), "NONE", "WITHDRAW", "%d|%d|%ld|%.40s", qe.pos, qe.opos, (long) (time(NULL) - qe.start), qe.withdraw_info ? qe.withdraw_info : "");
            if (qe.withdraw_info) {
                pbx_builtin_setvar_helper(qe.chan, "QUEUE_WITHDRAW_INFO", qe.withdraw_info);
            }
            res = 0;
        } else if (res < 0) {
            if (!qe.handled) {
                record_abandoned(&qe);
                ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "ABANDON",
                    "%d|%d|%ld", qe.pos, qe.opos,
                    (long) (time(NULL) - qe.start));
                res = -1;
            } else if (reason == QUEUE_LEAVEEMPTY) {
                /* Return back to dialplan, don't hang up */
                res = 0;
            } else if (qcontinue) {
                reason = QUEUE_CONTINUE;
                res = 0;
            }
        } else if (qe.valid_digits) {
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), "NONE", "EXITWITHKEY",
                "%s|%d|%d|%ld", qe.digits, qe.pos, qe.opos, (long) (time(NULL) - qe.start));
        }
    }
 
    /* Free the optional withdraw info if present */
    /* This is done here to catch all cases. e.g. if the call eventually wasn't withdrawn, e.g. answered */
    if (qe.withdraw_info) {
        ast_free(qe.withdraw_info);
        qe.withdraw_info = NULL;
    }
 
    /* Don't allow return code > 0 */
    if (res >= 0) {
        res = 0;
        if (ringing) {
            ast_indicate(chan, -1);
        } else {
            ast_moh_stop(chan);
        }
        ast_stopstream(chan);
    }
 
    set_queue_variables(qe.parent, qe.chan);
 
    leave_queue(&qe);
    if (reason != QUEUE_UNKNOWN)
        set_queue_result(chan, reason);
 
    /*
     * every queue_ent is given a reference to it's parent
     * call_queue when it joins the queue.  This ref must be taken
     * away right before the queue_ent is destroyed.  In this case
     * the queue_ent is about to be returned on the stack
     */
    qe.parent = queue_unref(qe.parent);
 
    return res;
}

References call_queue::announce_to_first_user, call_queue::announcefrequency, ao2_container_count(), args, AST_APP_ARG, ast_app_exec_sub(), ast_app_parse_options(), ast_assert, ast_channel_caller(), ast_channel_lock, ast_channel_name(), ast_channel_uniqueid(), ast_channel_unlock, AST_CONTROL_RINGING, ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, ast_free, ast_indicate(), AST_LIST_FIRST, ast_log, ast_max_forwards_get(), ast_moh_start(), ast_moh_stop(), ast_party_id_presentation(), AST_PRES_ALLOWED, AST_PRES_RESTRICTION, ast_queue_log(), ast_replace_subargument_delimiter(), AST_STANDARD_APP_ARGS, ast_stopstream(), ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_verb, queue_ent::chan, copy_rules(), queue_ent::digits, queue_ent::expire, get_member_status(), queue_ent::handled, ast_party_caller::id, is_our_turn(), join_queue(), queue_ent::last_periodic_announce_sound, queue_ent::last_periodic_announce_time, queue_ent::last_pos, queue_ent::last_pos_said, leave_queue(), call_queue::leavewhenempty, log_caller_id_name, call_queue::log_restricted_caller_id, LOG_WARNING, queue_ent::max_penalty, call_queue::members, queue_ent::min_penalty, queue_ent::moh, name, call_queue::name, ast_party_id::name, NULL, queue_ent::opos, OPT_ARG_ARRAY_SIZE, OPT_ARG_MUSICONHOLD_CLASS, OPT_ARG_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLER, OPT_GO_ON, OPT_MUSICONHOLD_CLASS, OPT_PREDIAL_CALLEE, OPT_PREDIAL_CALLER, OPT_RING_WHEN_RINGING, OPT_RINGING, options, queue_ent::parent, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), call_queue::periodicannouncefrequency, call_queue::periodicannouncestartdelay, queue_ent::pos, queue_ent::pr, queue_ent::predial_callee, queue_ent::prio, queue_ent::qe_rules, QUEUE_CONTINUE, queue_exec_options, QUEUE_LEAVEEMPTY, QUEUE_TIMEOUT, QUEUE_UNKNOWN, queue_unref, QUEUE_WITHDRAW, queue_ent::raise_penalty, queue_ent::raise_respect_min, record_abandoned(), queue_ent::ring_when_ringing, ringing(), S_COR, S_OR, say_periodic_announcement(), say_position(), set_queue_result(), set_queue_variables(), queue_ent::start, status, stop, ast_party_name::str, penalty_rule::time, try_calling(), update_qe_rule(), update_realtime_members(), url, ast_party_name::valid, queue_ent::valid_digits, wait_a_bit(), wait_our_turn(), queue_ent::withdraw, and queue_ent::withdraw_info.

Referenced by load_module().

queue_function_exists()

static int queue_function_exists ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Check if a given queue exists.

Definition at line 9157 of file app_queue.c.

{
    struct call_queue *q;
 
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "%s requires an argument: queuename\n", cmd);
        return -1;
    }
    q = find_load_queue_rt_friendly(data);
    snprintf(buf, len, "%d", q != NULL? 1 : 0);
    if (q) {
        queue_t_unref(q, "Done with temporary reference in QUEUE_EXISTS()");
    }
 
    return 0;
}

References ast_log, ast_strlen_zero(), buf, find_load_queue_rt_friendly(), len(), LOG_ERROR, NULL, and queue_t_unref.

queue_function_mem_read()

static int queue_function_mem_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Get number either busy / free / ready or total members of a specific queue.

Get or set member properties penalty / paused / ringinuse

Return values

number	of members (busy / free / ready / total) or member info (penalty / paused / ringinuse)
-1	on error

Definition at line 9199 of file app_queue.c.

{
    int count = 0;
    struct member *m;
    struct ao2_iterator mem_iter;
    struct call_queue *q;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(option);
        AST_APP_ARG(interface);
    );
    /* Make sure the returned value on error is zero length string. */
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR,
            "Missing required argument. %s(<queuename>,<option>[,<interface>])\n",
            cmd);
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    if (ast_strlen_zero(args.queuename) || ast_strlen_zero(args.option)) {
        ast_log(LOG_ERROR,
            "Missing required argument. %s(<queuename>,<option>[,<interface>])\n",
            cmd);
        return -1;
    }
 
    if ((q = find_load_queue_rt_friendly(args.queuename))) {
        ao2_lock(q);
        if (!strcasecmp(args.option, "logged")) {
            mem_iter = ao2_iterator_init(q->members, 0);
            while ((m = ao2_iterator_next(&mem_iter))) {
                /* Count the agents who are logged in and presently answering calls */
                if ((m->status != AST_DEVICE_UNAVAILABLE) && (m->status != AST_DEVICE_INVALID)) {
                    count++;
                }
                ao2_ref(m, -1);
            }
            ao2_iterator_destroy(&mem_iter);
        } else if (!strcasecmp(args.option, "free")) {
            mem_iter = ao2_iterator_init(q->members, 0);
            while ((m = ao2_iterator_next(&mem_iter))) {
                /* Count the agents who are logged in and presently answering calls */
                if ((m->status == AST_DEVICE_NOT_INUSE) && (!m->paused)) {
                    count++;
                }
                ao2_ref(m, -1);
            }
            ao2_iterator_destroy(&mem_iter);
        } else if (!strcasecmp(args.option, "ready")) {
            time_t now;
            time(&now);
            mem_iter = ao2_iterator_init(q->members, 0);
            while ((m = ao2_iterator_next(&mem_iter))) {
                /* Count the agents who are logged in, not paused and not wrapping up */
                if ((m->status == AST_DEVICE_NOT_INUSE) && (!m->paused) &&
                        !(m->lastcall && get_wrapuptime(q, m) && ((now - get_wrapuptime(q, m)) < m->lastcall))) {
                    count++;
                }
                ao2_ref(m, -1);
            }
            ao2_iterator_destroy(&mem_iter);
        } else if (!strcasecmp(args.option, "count")) {
            count = ao2_container_count(q->members);
        } else if (!strcasecmp(args.option, "penalty")) {
            m = get_interface_helper(q, args.interface);
            if (m) {
                count = m->penalty;
                ao2_ref(m, -1);
            }
        } else if (!strcasecmp(args.option, "paused")) {
            m = get_interface_helper(q, args.interface);
            if (m) {
                count = m->paused;
                ao2_ref(m, -1);
            }
        } else if ((!strcasecmp(args.option, "ignorebusy") /* ignorebusy is legacy */
            || !strcasecmp(args.option, "ringinuse"))) {
            m = get_interface_helper(q, args.interface);
            if (m) {
                count = m->ringinuse;
                ao2_ref(m, -1);
            }
        } else {
            ast_log(LOG_ERROR, "%s: Invalid option '%s' provided.\n", cmd, args.option);
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with temporary reference in QUEUE_MEMBER()");
    } else {
        ast_log(LOG_WARNING, "queue %s was not found\n", args.queuename);
    }
 
    snprintf(buf, len, "%d", count);
 
    return 0;
}

References ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, call_queue::count, find_load_queue_rt_friendly(), get_interface_helper(), get_wrapuptime(), member::lastcall, len(), LOG_ERROR, LOG_WARNING, call_queue::members, member::paused, member::penalty, queue_t_unref, member::ringinuse, and member::status.

queue_function_mem_write()

static int queue_function_mem_write ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Dialplan function QUEUE_MEMBER() Sets the members penalty / paused / ringinuse.

Definition at line 9301 of file app_queue.c.

{
    int memvalue;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(option);
        AST_APP_ARG(interface);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR,
            "Missing required argument. %s([<queuename>],<option>,<interface>)\n",
            cmd);
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    if (ast_strlen_zero(args.option)
        || ast_strlen_zero(args.interface)) {
        ast_log(LOG_ERROR,
            "Missing required argument. %s([<queuename>],<option>,<interface>)\n",
            cmd);
        return -1;
    }
 
    /*
     * If queuename is empty then the option will be
     * set for the interface in all queues.
     */
 
    memvalue = atoi(value);
    if (!strcasecmp(args.option, "penalty")) {
        if (set_member_value(args.queuename, args.interface, MEMBER_PENALTY, memvalue)) {
            ast_log(LOG_ERROR, "Invalid interface, queue, or penalty\n");
            return -1;
        }
    } else if (!strcasecmp(args.option, "paused")) {
        memvalue = (memvalue <= 0) ? 0 : 1;
        if (set_member_paused(args.queuename, args.interface, NULL, memvalue)) {
            ast_log(LOG_ERROR, "Invalid interface or queue\n");
            return -1;
        }
    } else if (!strcasecmp(args.option, "ignorebusy") /* ignorebusy is legacy */
        || !strcasecmp(args.option, "ringinuse")) {
        memvalue = (memvalue <= 0) ? 0 : 1;
        if (set_member_value(args.queuename, args.interface, MEMBER_RINGINUSE, memvalue)) {
            ast_log(LOG_ERROR, "Invalid interface or queue\n");
            return -1;
        }
    } else {
        ast_log(LOG_ERROR, "%s: Invalid option '%s' provided.\n", cmd, args.option);
        return -1;
    }
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), LOG_ERROR, MEMBER_PENALTY, MEMBER_RINGINUSE, NULL, set_member_paused(), set_member_value(), and value.

queue_function_memberpenalty_read()

static int queue_function_memberpenalty_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Dialplan function QUEUE_MEMBER_PENALTY() Gets the members penalty.

Definition at line 9524 of file app_queue.c.

{
    int penalty;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
    );
    /* Make sure the returned value on error is NULL. */
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "Missing argument. QUEUE_MEMBER_PENALTY(<queuename>,<interface>)\n");
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    if (args.argc < 2) {
        ast_log(LOG_ERROR, "Missing argument. QUEUE_MEMBER_PENALTY(<queuename>,<interface>)\n");
        return -1;
    }
 
    penalty = get_member_penalty (args.queuename, args.interface);
 
    if (penalty >= 0) { /* remember that buf is already '\0' */
        snprintf (buf, len, "%d", penalty);
    }
 
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, get_member_penalty(), len(), and LOG_ERROR.

queue_function_memberpenalty_write()

static int queue_function_memberpenalty_write ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Dialplan function QUEUE_MEMBER_PENALTY() Sets the members penalty.

Definition at line 9556 of file app_queue.c.

{
    int penalty;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "Missing argument. QUEUE_MEMBER_PENALTY(<queuename>,<interface>)\n");
        return -1;
    }
 
    AST_STANDARD_APP_ARGS(args, data);
 
    if (args.argc < 2) {
        ast_log(LOG_ERROR, "Missing argument. QUEUE_MEMBER_PENALTY(<queuename>,<interface>)\n");
        return -1;
    }
 
    penalty = atoi(value);
 
    if (ast_strlen_zero(args.interface)) {
        ast_log (LOG_ERROR, "<interface> parameter can't be null\n");
        return -1;
    }
 
    /* if queuename = NULL then penalty will be set for interface in all the queues. */
    if (set_member_value(args.queuename, args.interface, MEMBER_PENALTY, penalty)) {
        ast_log(LOG_ERROR, "Invalid interface, queue or penalty\n");
        return -1;
    }
 
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), LOG_ERROR, MEMBER_PENALTY, set_member_value(), and value.

queue_function_queuegetchannel()

static int queue_function_queuegetchannel ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Dialplan function QUEUE_GET_CHANNEL() Get caller channel waiting at specified position in the queue.

Definition at line 9360 of file app_queue.c.

{
    int position;
    char *parse;
    struct call_queue *q;
    struct ast_variable *var;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(position);
    );
 
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "Missing argument. QUEUE_GET_CHANNEL(<queuename>,<position>)\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.queuename)) {
        ast_log (LOG_ERROR, "The <queuename> parameter is required.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.position)) {
        position = 1;
    } else {
        if (sscanf(args.position, "%30d", &position) != 1) {
            ast_log (LOG_ERROR, "<position> parameter must be an integer.\n");
            return -1;
        }
        if (position < 1) {
            ast_log (LOG_ERROR, "<position> parameter must be an integer greater than zero.\n");
            return -1;
        }
    }
 
    {
        struct call_queue tmpq = {
            .name = args.queuename,
        };
 
        q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Find for QUEUE_GET_CHANNEL()");
    }
    if (q) {
        ao2_lock(q);
        if (q->count >= position) {
            struct queue_ent *qe;
 
            for (qe = q->head; qe; qe = qe->next) {
                if (qe->pos == position) {
                    ast_copy_string(buf, ast_channel_name(qe->chan), len);
                    break;
                }
            }
        }
        ao2_unlock(q);
        queue_t_unref(q, "Done with reference in QUEUE_GET_CHANNEL()");
        return 0;
    }
 
    var = ast_load_realtime("queues", "name", args.queuename, SENTINEL);
    if (var) {
        /* if the queue is realtime but was not found in memory, this
         * means that the queue had been deleted from memory since it was
         * "dead."
         */
        ast_variables_destroy(var);
        return 0;
    }
 
    ast_log(LOG_WARNING, "queue %s was not found\n", args.queuename);
    return 0;
}

References ao2_lock, ao2_t_find, ao2_unlock, args, AST_APP_ARG, ast_channel_name(), ast_copy_string(), AST_DECLARE_APP_ARGS, ast_load_realtime(), ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_variables_destroy(), buf, queue_ent::chan, call_queue::count, call_queue::head, len(), LOG_ERROR, LOG_WARNING, call_queue::name, queue_ent::next, OBJ_POINTER, queue_ent::pos, queue_t_unref, queues, SENTINEL, and var.

queue_function_queuememberlist()

static int queue_function_queuememberlist ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Dialplan function QUEUE_MEMBER_LIST() Get list of members in a specific queue.

Definition at line 9476 of file app_queue.c.

{
    struct call_queue *q;
    struct member *m;
 
    /* Ensure an otherwise empty list doesn't return garbage */
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "QUEUE_MEMBER_LIST requires an argument: queuename\n");
        return -1;
    }
 
    if ((q = find_load_queue_rt_friendly(data))) {
        int buflen = 0, count = 0;
        struct ao2_iterator mem_iter;
 
        ao2_lock(q);
        mem_iter = ao2_iterator_init(q->members, 0);
        while ((m = ao2_iterator_next(&mem_iter))) {
            /* strcat() is always faster than printf() */
            if (count++) {
                strncat(buf + buflen, ",", len - buflen - 1);
                buflen++;
            }
            strncat(buf + buflen, m->interface, len - buflen - 1);
            buflen += strlen(m->interface);
            /* Safeguard against overflow (negative length) */
            if (buflen >= len - 2) {
                ao2_ref(m, -1);
                ast_log(LOG_WARNING, "Truncating list\n");
                break;
            }
            ao2_ref(m, -1);
        }
        ao2_iterator_destroy(&mem_iter);
        ao2_unlock(q);
        queue_t_unref(q, "Done with QUEUE_MEMBER_LIST()");
    } else
        ast_log(LOG_WARNING, "queue %s was not found\n", data);
 
    /* We should already be terminated, but let's make sure. */
    buf[len - 1] = '\0';
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_log, ast_strlen_zero(), buf, find_load_queue_rt_friendly(), member::interface, len(), LOG_ERROR, LOG_WARNING, call_queue::members, and queue_t_unref.

queue_function_queuewaitingcount()

static int queue_function_queuewaitingcount ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Dialplan function QUEUE_WAITING_COUNT() Get number callers waiting in a specific queue.

Definition at line 9439 of file app_queue.c.

{
    int count = 0;
    struct call_queue *q, tmpq = {
        .name = data,
    };
    struct ast_variable *var = NULL;
 
    buf[0] = '\0';
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "QUEUE_WAITING_COUNT requires an argument: queuename\n");
        return -1;
    }
 
    if ((q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Find for QUEUE_WAITING_COUNT()"))) {
        ao2_lock(q);
        count = q->count;
        ao2_unlock(q);
        queue_t_unref(q, "Done with reference in QUEUE_WAITING_COUNT()");
    } else if ((var = ast_load_realtime("queues", "name", data, SENTINEL))) {
        /* if the queue is realtime but was not found in memory, this
         * means that the queue had been deleted from memory since it was
         * "dead." This means it has a 0 waiting count
         */
        count = 0;
        ast_variables_destroy(var);
    } else {
        ast_log(LOG_WARNING, "queue %s was not found\n", data);
    }
 
    snprintf(buf, len, "%d", count);
 
    return 0;
}

References ao2_lock, ao2_t_find, ao2_unlock, ast_load_realtime(), ast_log, ast_strlen_zero(), ast_variables_destroy(), buf, call_queue::count, len(), LOG_ERROR, LOG_WARNING, call_queue::name, NULL, OBJ_POINTER, queue_t_unref, queues, SENTINEL, and var.

queue_function_var()

static int queue_function_var ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

create interface var with all queue details.

Return values

0	on success
-1	on error

Definition at line 9113 of file app_queue.c.

{
    int res = -1;
    struct call_queue *q;
    char interfacevar[256] = "";
    float sl = 0;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "%s requires an argument: queuename\n", cmd);
        return -1;
    }
 
    if ((q = find_load_queue_rt_friendly(data))) {
        ao2_lock(q);
        if (q->setqueuevar) {
            sl = 0;
            res = 0;
 
            if (q->callscompleted > 0) {
                sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
            }
 
            snprintf(interfacevar, sizeof(interfacevar),
                "QUEUEMAX=%d,QUEUESTRATEGY=%s,QUEUECALLS=%d,QUEUEHOLDTIME=%d,QUEUETALKTIME=%d,QUEUECOMPLETED=%d,QUEUEABANDONED=%d,QUEUESRVLEVEL=%d,QUEUESRVLEVELPERF=%2.1f",
                q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted, q->callsabandoned,  q->servicelevel, sl);
 
            pbx_builtin_setvar_multiple(chan, interfacevar);
        }
 
        ao2_unlock(q);
        queue_t_unref(q, "Done with QUEUE() function");
    } else {
        ast_log(LOG_WARNING, "queue %s was not found\n", data);
    }
 
    snprintf(buf, len, "%d", res);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_log, ast_strlen_zero(), buf, call_queue::callsabandoned, call_queue::callscompleted, call_queue::callscompletedinsl, call_queue::count, find_load_queue_rt_friendly(), call_queue::holdtime, int2strat(), len(), LOG_ERROR, LOG_WARNING, call_queue::maxlen, pbx_builtin_setvar_multiple(), queue_t_unref, call_queue::servicelevel, call_queue::setqueuevar, call_queue::strategy, and call_queue::talktime.

queue_hash_cb()

static int queue_hash_cb ( const void *  obj, const int  flags  )

static

Definition at line 2099 of file app_queue.c.

{
    const struct call_queue *q = obj;
 
    return ast_str_case_hash(q->name);
}

References ast_str_case_hash(), and call_queue::name.

Referenced by load_module().

queue_member_added_to_ami()

static struct ast_manager_event_blob * queue_member_added_to_ami ( struct stasis_message *  message )

static

Definition at line 2307 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberAdded", message);
}

References queue_member_to_ami().

queue_member_blob_create()

static struct ast_json * queue_member_blob_create ( struct call_queue *  q, struct member *  mem  )

static

Definition at line 2523 of file app_queue.c.

{
    return ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: i, s: i, s: i, s: i, s: i, s: i, s: i, s: i, s: s, s: i, s: i}",
        "Queue", q->name,
        "MemberName", mem->membername,
        "Interface", mem->interface,
        "StateInterface", mem->state_interface,
        "Membership", (mem->dynamic ? "dynamic" : (mem->realtime ? "realtime" : "static")),
        "Penalty", mem->penalty,
        "CallsTaken", mem->calls,
        "LastCall", (int)mem->lastcall,
        "LastPause", (int)mem->lastpause,
        "LoginTime", (int)mem->logintime,
        "InCall", mem->starttime ? 1 : 0,
        "Status", mem->status,
        "Paused", mem->paused,
        "PausedReason", mem->reason_paused,
        "Ringinuse", mem->ringinuse,
        "Wrapuptime", mem->wrapuptime);
}

References ast_json_pack(), member::calls, member::dynamic, member::interface, member::lastcall, member::lastpause, member::logintime, member::membername, call_queue::name, member::paused, member::penalty, member::realtime, member::reason_paused, member::ringinuse, member::starttime, member::state_interface, member::status, and member::wrapuptime.

Referenced by add_to_queue(), publish_queue_member_pause(), remove_from_queue(), set_member_penalty_help_members(), set_queue_member_ringinuse(), and update_status().

queue_member_decrement_followers()

static int queue_member_decrement_followers ( void *  obj, void *  arg, int  flag  )

static

Definition at line 2133 of file app_queue.c.

{
    struct member *mem = obj;
    int *decrement_followers_after = arg;
 
    if (mem->queuepos > *decrement_followers_after) {
        mem->queuepos--;
    }
 
    return 0;
}

References member::queuepos.

Referenced by queue_delme_members_decrement_followers(), and queue_member_follower_removal().

queue_member_follower_removal()

static void queue_member_follower_removal ( struct call_queue *  queue, struct member *  mem  )

static

Definition at line 2170 of file app_queue.c.

{
    int pos = mem->queuepos;
 
    /* If the position being removed is less than the current place in the queue, reduce the queue position by one so that we don't skip the member
     * who would have been next otherwise. */
    if (pos < queue->rrpos) {
        queue->rrpos--;
    }
 
    ao2_callback(queue->members, OBJ_NODATA | OBJ_MULTIPLE, queue_member_decrement_followers, &pos);
}

References ao2_callback, call_queue::members, OBJ_MULTIPLE, OBJ_NODATA, queue_member_decrement_followers(), member::queuepos, and call_queue::rrpos.

Referenced by member_remove_from_queue().

queue_member_pause_to_ami()

static struct ast_manager_event_blob * queue_member_pause_to_ami ( struct stasis_message *  message )

static

Definition at line 2317 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberPause", message);
}

References queue_member_to_ami().

queue_member_penalty_to_ami()

static struct ast_manager_event_blob * queue_member_penalty_to_ami ( struct stasis_message *  message )

static

Definition at line 2322 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberPenalty", message);
}

References queue_member_to_ami().

queue_member_removed_to_ami()

static struct ast_manager_event_blob * queue_member_removed_to_ami ( struct stasis_message *  message )

static

Definition at line 2312 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberRemoved", message);
}

References queue_member_to_ami().

queue_member_ringinuse_to_ami()

static struct ast_manager_event_blob * queue_member_ringinuse_to_ami ( struct stasis_message *  message )

static

Definition at line 2327 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberRinginuse", message);
}

References queue_member_to_ami().

queue_member_status_to_ami()

static struct ast_manager_event_blob * queue_member_status_to_ami ( struct stasis_message *  message )

static

Definition at line 2302 of file app_queue.c.

{
    return queue_member_to_ami("QueueMemberStatus", message);
}

References queue_member_to_ami().

queue_member_to_ami()

static struct ast_manager_event_blob * queue_member_to_ami ( const char *  type, struct stasis_message *  message  )

static

Definition at line 2287 of file app_queue.c.

{
    struct ast_json_payload *payload = stasis_message_data(message);
    RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
    event_string = ast_manager_str_from_json_object(payload->json, NULL);
    if (!event_string) {
        return NULL;
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
        "%s",
        ast_str_buffer(event_string));
}

References ast_free, ast_manager_event_blob_create(), ast_manager_str_from_json_object(), ast_str_buffer(), EVENT_FLAG_AGENT, ast_json_payload::json, NULL, RAII_VAR, stasis_message_data(), and type.

Referenced by queue_member_added_to_ami(), queue_member_pause_to_ami(), queue_member_penalty_to_ami(), queue_member_removed_to_ami(), queue_member_ringinuse_to_ami(), and queue_member_status_to_ami().

queue_multi_channel_to_ami()

static struct ast_manager_event_blob * queue_multi_channel_to_ami ( const char *  type, struct stasis_message *  message  )

static

Definition at line 2351 of file app_queue.c.

{
    struct ast_multi_channel_blob *obj = stasis_message_data(message);
    struct ast_channel_snapshot *caller;
    struct ast_channel_snapshot *agent;
    RAII_VAR(struct ast_str *, caller_event_string, NULL, ast_free);
    RAII_VAR(struct ast_str *, agent_event_string, NULL, ast_free);
    RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
    caller = ast_multi_channel_blob_get_channel(obj, "caller");
    if (caller) {
        caller_event_string = ast_manager_build_channel_state_string(caller);
        if (!caller_event_string) {
            ast_log(LOG_NOTICE, "No caller event string, bailing\n");
            return NULL;
        }
    }
 
    agent = ast_multi_channel_blob_get_channel(obj, "agent");
    if (agent) {
        agent_event_string = ast_manager_build_channel_state_string_prefix(agent, "Dest");
        if (!agent_event_string) {
            ast_log(LOG_NOTICE, "No agent event string, bailing\n");
            return NULL;
        }
    }
 
    event_string = ast_manager_str_from_json_object(ast_multi_channel_blob_get_json(obj), NULL);
    if (!event_string) {
        return NULL;
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
        "%s"
        "%s"
        "%s",
        caller_event_string ? ast_str_buffer(caller_event_string) : "",
        agent_event_string ? ast_str_buffer(agent_event_string) : "",
        ast_str_buffer(event_string));
}

References ast_free, ast_log, ast_manager_build_channel_state_string(), ast_manager_build_channel_state_string_prefix(), ast_manager_event_blob_create(), ast_manager_str_from_json_object(), ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), ast_str_buffer(), ast_channel_snapshot::caller, EVENT_FLAG_AGENT, LOG_NOTICE, NULL, RAII_VAR, stasis_message_data(), and type.

Referenced by queue_agent_called_to_ami(), queue_agent_complete_to_ami(), queue_agent_connect_to_ami(), queue_agent_dump_to_ami(), and queue_agent_ringnoanswer_to_ami().

queue_publish_member_blob()

static void queue_publish_member_blob ( struct stasis_message_type *  type, struct ast_json *  blob  )

static

Definition at line 2499 of file app_queue.c.

{
    RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
    if (!blob || !type) {
        ast_json_unref(blob);
        return;
    }
 
    payload = ast_json_payload_create(blob);
    ast_json_unref(blob);
    if (!payload) {
        return;
    }
 
    msg = stasis_message_create(type, payload);
    if (!msg) {
        return;
    }
 
    stasis_publish(ast_manager_get_topic(), msg);
}

References ao2_cleanup, ast_json_payload_create(), ast_json_unref(), ast_manager_get_topic(), NULL, RAII_VAR, stasis_message_create(), stasis_publish(), and type.

Referenced by add_to_queue(), publish_queue_member_pause(), remove_from_queue(), set_member_penalty_help_members(), set_queue_member_ringinuse(), and update_status().

queue_publish_multi_channel_blob()

static void queue_publish_multi_channel_blob ( struct ast_channel *  caller, struct ast_channel *  agent, struct stasis_message_type *  type, struct ast_json *  blob  )

static

Definition at line 2468 of file app_queue.c.

{
    RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, agent_snapshot, NULL, ao2_cleanup);
 
    ast_channel_lock(caller);
    caller_snapshot = ast_channel_snapshot_create(caller);
    ast_channel_unlock(caller);
    ast_channel_lock(agent);
    agent_snapshot = ast_channel_snapshot_create(agent);
    ast_channel_unlock(agent);
 
    if (!caller_snapshot || !agent_snapshot) {
        return;
    }
 
    queue_publish_multi_channel_snapshot_blob(ast_channel_topic(caller), caller_snapshot,
            agent_snapshot, type, blob);
}

References ao2_cleanup, ast_channel_lock, ast_channel_snapshot_create(), ast_channel_topic(), ast_channel_unlock, NULL, queue_publish_multi_channel_snapshot_blob(), RAII_VAR, and type.

Referenced by ring_entry(), rna(), and try_calling().

queue_publish_multi_channel_snapshot_blob()

static void queue_publish_multi_channel_snapshot_blob ( struct stasis_topic *  topic, struct ast_channel_snapshot *  caller_snapshot, struct ast_channel_snapshot *  agent_snapshot, struct stasis_message_type *  type, struct ast_json *  blob  )

static

Definition at line 2433 of file app_queue.c.

{
    RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
    if (!type) {
        return;
    }
 
    payload = ast_multi_channel_blob_create(blob);
    if (!payload) {
        return;
    }
 
    if (caller_snapshot) {
        ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
    } else {
        ast_debug(1, "Empty caller_snapshot; sending incomplete event\n");
    }
 
    if (agent_snapshot) {
        ast_multi_channel_blob_add_channel(payload, "agent", agent_snapshot);
    }
 
    msg = stasis_message_create(type, payload);
    if (!msg) {
        return;
    }
 
    stasis_publish(topic, msg);
}

References ao2_cleanup, ast_debug, ast_multi_channel_blob_add_channel(), ast_multi_channel_blob_create(), NULL, RAII_VAR, stasis_message_create(), stasis_publish(), and type.

Referenced by queue_publish_multi_channel_blob(), and send_agent_complete().

queue_reset_global_params()

static void queue_reset_global_params ( void  )

static

Always set the global queue defaults, even if there is no "general" section in queues.conf

Definition at line 9709 of file app_queue.c.

{
    queue_persistent_members = 0;
    autofill_default = 0;
    montype_default = 0;
    shared_lastcall = 0;
    negative_penalty_invalid = 0;
    log_membername_as_agent = 0;
    force_longest_waiting_caller = 0;
}

References autofill_default, force_longest_waiting_caller, log_membername_as_agent, montype_default, negative_penalty_invalid, queue_persistent_members, and shared_lastcall.

Referenced by reload_queues().

queue_rules_reset_global_params()

static void queue_rules_reset_global_params ( void  )

static

Reset the global queue rules parameters even if there is no "general" section of queuerules.conf

Definition at line 9630 of file app_queue.c.

{
    realtime_rules = 0;
}

References realtime_rules.

Referenced by reload_queue_rules().

queue_rules_set_global_params()

static void queue_rules_set_global_params ( struct ast_config *  cfg )

static

Set the global queue rules parameters as defined in the "general" section of queuerules.conf

Definition at line 9636 of file app_queue.c.

{
    const char *general_val = NULL;
    if ((general_val = ast_variable_retrieve(cfg, "general", "realtime_rules"))) {
        realtime_rules = ast_true(general_val);
    }
}

References ast_true(), ast_variable_retrieve(), NULL, and realtime_rules.

Referenced by reload_queue_rules().

queue_set_global_params()

static void queue_set_global_params ( struct ast_config *  cfg )

static

Set the global queue parameters as defined in the "general" section of queues.conf

Definition at line 9721 of file app_queue.c.

{
    const char *general_val = NULL;
    if ((general_val = ast_variable_retrieve(cfg, "general", "persistentmembers"))) {
        queue_persistent_members = ast_true(general_val);
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "autofill"))) {
        autofill_default = ast_true(general_val);
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "monitor-type"))) {
        if (!strcasecmp(general_val, "mixmonitor"))
            montype_default = 1;
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "shared_lastcall"))) {
        shared_lastcall = ast_true(general_val);
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "negative_penalty_invalid"))) {
        negative_penalty_invalid = ast_true(general_val);
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "log_membername_as_agent"))) {
        log_membername_as_agent = ast_true(general_val);
    }
    if ((general_val = ast_variable_retrieve(cfg, "general", "force_longest_waiting_caller"))) {
        force_longest_waiting_caller = ast_true(general_val);
    }
    /* Apply log-caller-id-name in the same place as other global settings */
    if ((general_val = ast_variable_retrieve(cfg, "general", "log-caller-id-name"))) {
        log_caller_id_name = ast_true(general_val);
    }
}

References ast_true(), ast_variable_retrieve(), autofill_default, force_longest_waiting_caller, log_caller_id_name, log_membername_as_agent, montype_default, negative_penalty_invalid, NULL, queue_persistent_members, and shared_lastcall.

Referenced by reload_queues().

queue_set_param()

static void queue_set_param ( struct call_queue *  q, const char *  param, const char *  val, int  linenum, int  failunknown  )

static

Configure a queue parameter.

The failunknown flag is set for config files (and static realtime) to show errors for unknown parameters. It is cleared for dynamic realtime to allow extra fields in the tables.

Note

For error reporting, line number is passed for .conf static configuration, for Realtime queues, linenum is -1.

Definition at line 3480 of file app_queue.c.

{
    if (!strcasecmp(param, "musicclass") ||
        !strcasecmp(param, "music") || !strcasecmp(param, "musiconhold")) {
        ast_string_field_set(q, moh, val);
    } else if (!strcasecmp(param, "announce")) {
        ast_string_field_set(q, announce, val);
    } else if (!strcasecmp(param, "context")) {
        ast_string_field_set(q, context, val);
    } else if (!strcasecmp(param, "timeout")) {
        q->timeout = atoi(val);
        if (q->timeout < 0) {
            q->timeout = DEFAULT_TIMEOUT;
        }
    } else if (!strcasecmp(param, "ringinuse")) {
        q->ringinuse = ast_true(val);
    } else if (!strcasecmp(param, "setinterfacevar")) {
        q->setinterfacevar = ast_true(val);
    } else if (!strcasecmp(param, "setqueuevar")) {
        q->setqueuevar = ast_true(val);
    } else if (!strcasecmp(param, "setqueueentryvar")) {
        q->setqueueentryvar = ast_true(val);
    } else if (!strcasecmp(param, "monitor-format")) {
        ast_copy_string(q->monfmt, val, sizeof(q->monfmt));
    } else if (!strcasecmp(param, "membergosub")) {
        ast_string_field_set(q, membergosub, val);
    } else if (!strcasecmp(param, "queue-youarenext")) {
        ast_string_field_set(q, sound_next, val);
    } else if (!strcasecmp(param, "queue-thereare")) {
        ast_string_field_set(q, sound_thereare, val);
    } else if (!strcasecmp(param, "queue-callswaiting")) {
        ast_string_field_set(q, sound_calls, val);
    } else if (!strcasecmp(param, "queue-quantity1")) {
        ast_string_field_set(q, queue_quantity1, val);
    } else if (!strcasecmp(param, "queue-quantity2")) {
        ast_string_field_set(q, queue_quantity2, val);
    } else if (!strcasecmp(param, "queue-holdtime")) {
        ast_string_field_set(q, sound_holdtime, val);
    } else if (!strcasecmp(param, "queue-minutes")) {
        ast_string_field_set(q, sound_minutes, val);
    } else if (!strcasecmp(param, "queue-minute")) {
        ast_string_field_set(q, sound_minute, val);
    } else if (!strcasecmp(param, "queue-seconds")) {
        ast_string_field_set(q, sound_seconds, val);
    } else if (!strcasecmp(param, "queue-thankyou")) {
        ast_string_field_set(q, sound_thanks, val);
    } else if (!strcasecmp(param, "queue-callerannounce")) {
        ast_string_field_set(q, sound_callerannounce, val);
    } else if (!strcasecmp(param, "queue-reporthold")) {
        ast_string_field_set(q, sound_reporthold, val);
    } else if (!strcasecmp(param, "announce-frequency")) {
        q->announcefrequency = atoi(val);
    } else if (!strcasecmp(param, "announce-to-first-user")) {
        q->announce_to_first_user = ast_true(val);
    } else if (!strcasecmp(param, "min-announce-frequency")) {
        q->minannouncefrequency = atoi(val);
        ast_debug(1, "%s=%s for queue '%s'\n", param, val, q->name);
    } else if (!strcasecmp(param, "announce-round-seconds")) {
        q->roundingseconds = atoi(val);
        /* Rounding to any other values just doesn't make sense... */
        if (!(q->roundingseconds == 0 || q->roundingseconds == 5 || q->roundingseconds == 10
            || q->roundingseconds == 15 || q->roundingseconds == 20 || q->roundingseconds == 30)) {
            if (linenum >= 0) {
                ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
                    "using 0 instead for queue '%s' at line %d of queues.conf\n",
                    val, param, q->name, linenum);
            } else {
                ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
                    "using 0 instead for queue '%s'\n", val, param, q->name);
            }
            q->roundingseconds=0;
        }
    } else if (!strcasecmp(param, "announce-holdtime")) {
        if (!strcasecmp(val, "once")) {
            q->announceholdtime = ANNOUNCEHOLDTIME_ONCE;
        } else if (ast_true(val)) {
            q->announceholdtime = ANNOUNCEHOLDTIME_ALWAYS;
        } else {
            q->announceholdtime = 0;
        }
    } else if (!strcasecmp(param, "announce-position")) {
        if (!strcasecmp(val, "limit")) {
            q->announceposition = ANNOUNCEPOSITION_LIMIT;
        } else if (!strcasecmp(val, "more")) {
            q->announceposition = ANNOUNCEPOSITION_MORE_THAN;
        } else if (ast_true(val)) {
            q->announceposition = ANNOUNCEPOSITION_YES;
        } else {
            q->announceposition = ANNOUNCEPOSITION_NO;
        }
    } else if (!strcasecmp(param, "announce-position-only-up")) {
        q->announceposition_only_up = ast_true(val);
    } else if (!strcasecmp(param, "announce-position-limit")) {
        q->announcepositionlimit = atoi(val);
    } else if (!strcasecmp(param, "periodic-announce")) {
        if (strchr(val, ',')) {
            char *s, *buf = ast_strdupa(val);
            unsigned int i = 0;
 
            while ((s = strsep(&buf, ",|"))) {
                if (!q->sound_periodicannounce[i]) {
                    q->sound_periodicannounce[i] = ast_str_create(16);
                }
                ast_str_set(&q->sound_periodicannounce[i], 0, "%s", s);
                i++;
                if (i == MAX_PERIODIC_ANNOUNCEMENTS) {
                    break;
                }
            }
            q->numperiodicannounce = i;
        } else {
            ast_str_set(&q->sound_periodicannounce[0], 0, "%s", val);
            q->numperiodicannounce = 1;
        }
    } else if (!strcasecmp(param, "periodic-announce-startdelay")) {
        q->periodicannouncestartdelay = atoi(val);
    } else if (!strcasecmp(param, "periodic-announce-frequency")) {
        q->periodicannouncefrequency = atoi(val);
    } else if (!strcasecmp(param, "relative-periodic-announce")) {
        q->relativeperiodicannounce = ast_true(val);
    } else if (!strcasecmp(param, "random-periodic-announce")) {
        q->randomperiodicannounce = ast_true(val);
    } else if (!strcasecmp(param, "retry")) {
        q->retry = atoi(val);
        if (q->retry <= 0) {
            q->retry = DEFAULT_RETRY;
        }
    } else if (!strcasecmp(param, "wrapuptime")) {
        q->wrapuptime = atoi(val);
    } else if (!strcasecmp(param, "penaltymemberslimit")) {
        if ((sscanf(val, "%10d", &q->penaltymemberslimit) != 1)) {
            q->penaltymemberslimit = 0;
        }
    } else if (!strcasecmp(param, "autofill")) {
        q->autofill = ast_true(val);
    } else if (!strcasecmp(param, "autopause")) {
        q->autopause = autopause2int(val);
    } else if (!strcasecmp(param, "autopausedelay")) {
        q->autopausedelay = atoi(val);
    } else if (!strcasecmp(param, "autopausebusy")) {
        q->autopausebusy = ast_true(val);
    } else if (!strcasecmp(param, "autopauseunavail")) {
        q->autopauseunavail = ast_true(val);
    } else if (!strcasecmp(param, "maxlen")) {
        q->maxlen = atoi(val);
        if (q->maxlen < 0) {
            q->maxlen = 0;
        }
    } else if (!strcasecmp(param, "servicelevel")) {
        q->servicelevel= atoi(val);
    } else if (!strcasecmp(param, "strategy")) {
        int strategy;
 
        /* We are a static queue and already have set this, no need to do it again */
        if (failunknown) {
            return;
        }
        strategy = strat2int(val);
        if (strategy < 0) {
            ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
                val, q->name);
            strategy = QUEUE_STRATEGY_RINGALL;
        }
        if (strategy == q->strategy) {
            return;
        }
        if (strategy == QUEUE_STRATEGY_LINEAR) {
            ast_log(LOG_WARNING, "Changing to the linear strategy currently requires asterisk to be restarted.\n");
            return;
        }
        q->strategy = strategy;
    } else if (!strcasecmp(param, "joinempty")) {
        parse_empty_options(val, &q->joinempty, 1);
    } else if (!strcasecmp(param, "leavewhenempty")) {
        parse_empty_options(val, &q->leavewhenempty, 0);
    } else if (!strcasecmp(param, "reportholdtime")) {
        q->reportholdtime = ast_true(val);
    } else if (!strcasecmp(param, "memberdelay")) {
        q->memberdelay = atoi(val);
    } else if (!strcasecmp(param, "weight")) {
        q->weight = atoi(val);
    } else if (!strcasecmp(param, "timeoutrestart")) {
        q->timeoutrestart = ast_true(val);
    } else if (!strcasecmp(param, "defaultrule")) {
        ast_string_field_set(q, defaultrule, val);
    } else if (!strcasecmp(param, "timeoutpriority")) {
        if (!strcasecmp(val, "conf")) {
            q->timeoutpriority = TIMEOUT_PRIORITY_CONF;
        } else {
            q->timeoutpriority = TIMEOUT_PRIORITY_APP;
        }
    } else if (!strcasecmp(param, "log-restricted-caller-id")) {
        q->log_restricted_caller_id = ast_true(val);
    } else if (failunknown) {
        if (linenum >= 0) {
            ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s at line %d of queues.conf\n",
                q->name, param, linenum);
        } else {
            ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s\n", q->name, param);
        }
    }
}

References call_queue::announce_to_first_user, call_queue::announcefrequency, call_queue::announceholdtime, ANNOUNCEHOLDTIME_ALWAYS, ANNOUNCEHOLDTIME_ONCE, call_queue::announceposition, ANNOUNCEPOSITION_LIMIT, ANNOUNCEPOSITION_MORE_THAN, ANNOUNCEPOSITION_NO, call_queue::announceposition_only_up, ANNOUNCEPOSITION_YES, call_queue::announcepositionlimit, ast_copy_string(), ast_debug, ast_log, ast_str_create, ast_str_set(), ast_strdupa, ast_string_field_set, ast_true(), call_queue::autofill, call_queue::autopause, autopause2int(), call_queue::autopausebusy, call_queue::autopausedelay, call_queue::autopauseunavail, buf, voicemailpwcheck::context, DEFAULT_RETRY, DEFAULT_TIMEOUT, call_queue::joinempty, call_queue::leavewhenempty, call_queue::log_restricted_caller_id, LOG_WARNING, MAX_PERIODIC_ANNOUNCEMENTS, call_queue::maxlen, call_queue::memberdelay, call_queue::minannouncefrequency, call_queue::monfmt, call_queue::name, call_queue::numperiodicannounce, parse_empty_options(), call_queue::penaltymemberslimit, call_queue::periodicannouncefrequency, call_queue::periodicannouncestartdelay, QUEUE_STRATEGY_LINEAR, QUEUE_STRATEGY_RINGALL, call_queue::randomperiodicannounce, call_queue::relativeperiodicannounce, call_queue::reportholdtime, call_queue::retry, call_queue::ringinuse, call_queue::roundingseconds, call_queue::servicelevel, call_queue::setinterfacevar, call_queue::setqueueentryvar, call_queue::setqueuevar, call_queue::sound_periodicannounce, strat2int(), call_queue::strategy, strsep(), call_queue::timeout, TIMEOUT_PRIORITY_APP, TIMEOUT_PRIORITY_CONF, call_queue::timeoutpriority, call_queue::timeoutrestart, call_queue::weight, and call_queue::wrapuptime.

Referenced by find_queue_by_name_rt(), and reload_single_queue().

queue_show()

static char * queue_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 10518 of file app_queue.c.

{
    switch ( cmd ) {
    case CLI_INIT:
        e->command = "queue show";
        e->usage =
            "Usage: queue show\n"
            "       Provides summary information on a specified queue.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_queue_show(a->line, a->word, a->pos, a->n);
    }
 
    return __queues_show(NULL, a->fd, a->argc, a->argv);
}

References __queues_show(), a, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, complete_queue_show(), NULL, and ast_cli_entry::usage.

queue_stasis_data_alloc()

static struct queue_stasis_data * queue_stasis_data_alloc ( struct queue_ent *  qe, struct ast_channel *  peer, struct member *  mem, time_t  holdstart, time_t  starttime, int  callcompletedinsl  )

static

Definition at line 6439 of file app_queue.c.

{
    struct queue_stasis_data *queue_data;
 
    queue_data = ao2_alloc(sizeof(*queue_data), queue_stasis_data_destructor);
    if (!queue_data) {
        return NULL;
    }
 
    if (ast_string_field_init(queue_data, 64)) {
        ao2_cleanup(queue_data);
        return NULL;
    }
 
    ast_string_field_set(queue_data, caller_uniqueid, ast_channel_uniqueid(qe->chan));
    ast_string_field_set(queue_data, member_uniqueid, ast_channel_uniqueid(peer));
    queue_data->queue = queue_ref(qe->parent);
    queue_data->starttime = starttime;
    queue_data->holdstart = holdstart;
    queue_data->callcompletedinsl = callcompletedinsl;
    queue_data->caller_pos = qe->opos;
    ao2_ref(mem, +1);
    queue_data->member = mem;
 
    return queue_data;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_channel_uniqueid(), ast_string_field_init, ast_string_field_set, queue_stasis_data::callcompletedinsl, queue_stasis_data::caller_pos, queue_stasis_data::caller_uniqueid, queue_ent::chan, queue_stasis_data::holdstart, queue_stasis_data::member, queue_stasis_data::member_uniqueid, NULL, queue_ent::opos, queue_ent::parent, queue_stasis_data::queue, queue_ref, queue_stasis_data_destructor(), and queue_stasis_data::starttime.

Referenced by setup_stasis_subs().

queue_stasis_data_destructor()

static void queue_stasis_data_destructor ( void *  obj )

static

Definition at line 6407 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = obj;
 
    /* This can only happen if refcounts for this object have got severely messed up */
    ast_assert(queue_data->bridge_router == NULL);
    ast_assert(queue_data->channel_router == NULL);
 
    ao2_cleanup(queue_data->member);
    queue_unref(queue_data->queue);
    ast_string_field_free_memory(queue_data);
}

References ao2_cleanup, ast_assert, ast_string_field_free_memory, queue_stasis_data::bridge_router, queue_stasis_data::channel_router, queue_stasis_data::member, NULL, queue_stasis_data::queue, and queue_unref.

Referenced by queue_stasis_data_alloc().

qupd_exec()

static int qupd_exec ( struct ast_channel *  chan, const char *  data  )

static

Update Queue with data of an outgoing call.

Definition at line 11763 of file app_queue.c.

{
    int oldtalktime;
    char *parse;
    struct call_queue *q;
    struct member *mem;
    int newtalktime = 0;
 
    AST_DECLARE_APP_ARGS(args,
            AST_APP_ARG(queuename);
            AST_APP_ARG(uniqueid);
            AST_APP_ARG(agent);
            AST_APP_ARG(status);
            AST_APP_ARG(talktime);
            AST_APP_ARG(params););
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "QueueUpdate requires arguments (queuename,uniqueid,agent,status,talktime,params[totaltime,callednumber])\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.queuename) || ast_strlen_zero(args.uniqueid) || ast_strlen_zero(args.agent) || ast_strlen_zero(args.status)) {
        ast_log(LOG_WARNING, "Missing argument to QueueUpdate (queuename,uniqueid,agent,status,talktime,params[totaltime|callednumber])\n");
        return -1;
    }
 
    if (!ast_strlen_zero(args.talktime)) {
        newtalktime = atoi(args.talktime);
    }
 
    q = find_load_queue_rt_friendly(args.queuename);
    if (!q) {
        ast_log(LOG_WARNING, "QueueUpdate could not find requested queue '%s'\n", args.queuename);
        return 0;
    }
 
    ao2_lock(q);
    if (q->members) {
        struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
        while ((mem = ao2_iterator_next(&mem_iter))) {
            if (!strcasecmp(mem->membername, args.agent)) {
                if (!strcasecmp(args.status, "ANSWER")) {
                    oldtalktime = q->talktime;
                    q->talktime = (((oldtalktime << 2) - oldtalktime) + newtalktime) >> 2;
                    time(&mem->lastcall);
                    mem->calls++;
                    mem->lastqueue = q;
                    q->callscompleted++;
 
                    if (newtalktime <= q->servicelevel) {
                        q->callscompletedinsl++;
                    }
                } else {
 
                    time(&mem->lastcall);
                    q->callsabandoned++;
                }
 
                ast_queue_log(args.queuename, args.uniqueid, args.agent, "OUTCALL", "%s|%s|%s", args.status, args.talktime, args.params);
            }
 
            ao2_ref(mem, -1);
        }
 
        ao2_iterator_destroy(&mem_iter);
    }
 
    ao2_unlock(q);
    queue_t_unref(q, "Done with temporary pointer");
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, ast_queue_log(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), member::calls, call_queue::callsabandoned, call_queue::callscompleted, call_queue::callscompletedinsl, find_load_queue_rt_friendly(), member::lastcall, member::lastqueue, LOG_WARNING, member::membername, call_queue::members, queue_t_unref, status, and call_queue::talktime.

Referenced by load_module().

recalc_holdtime()

static void recalc_holdtime ( struct queue_ent *  qe, int  newholdtime  )

static

Definition at line 4497 of file app_queue.c.

{
    int oldvalue;
 
    /* Calculate holdtime using an exponential average */
    /* Thanks to SRT for this contribution */
    /* 2^2 (4) is the filter coefficient; a higher exponent would give old entries more weight */
 
    ao2_lock(qe->parent);
    if ((qe->parent->callscompleted + qe->parent->callsabandoned) == 0) {
        qe->parent->holdtime = newholdtime;
    } else {
        oldvalue = qe->parent->holdtime;
        qe->parent->holdtime = (((oldvalue << 2) - oldvalue) + newholdtime) >> 2;
    }
    ao2_unlock(qe->parent);
}

References ao2_lock, ao2_unlock, call_queue::callsabandoned, call_queue::callscompleted, call_queue::holdtime, and queue_ent::parent.

Referenced by try_calling().

record_abandoned()

static void record_abandoned ( struct queue_ent *  qe )

static

Record that a caller gave up on waiting in queue.

Definition at line 5227 of file app_queue.c.

{
    int callabandonedinsl = 0;
    time_t now;
 
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    pbx_builtin_setvar_helper(qe->chan, "ABANDONED", "TRUE");
 
    set_queue_variables(qe->parent, qe->chan);
    ao2_lock(qe->parent);
    blob = ast_json_pack("{s: s, s: i, s: i, s: i}",
                 "Queue", qe->parent->name,
                 "Position", qe->pos,
                 "OriginalPosition", qe->opos,
                 "HoldTime", (int)(time(NULL) - qe->start));
 
 
    time(&now);
    callabandonedinsl = ((now - qe->start) <= qe->parent->servicelevel);
    if (callabandonedinsl) {
        qe->parent->callsabandonedinsl++;
    }
 
    qe->parent->callsabandoned++;
    ao2_unlock(qe->parent);
 
    ast_channel_publish_cached_blob(qe->chan, queue_caller_abandon_type(), blob);
}

References ao2_lock, ao2_unlock, ast_channel_publish_cached_blob(), ast_json_pack(), ast_json_unref(), call_queue::callsabandoned, call_queue::callsabandonedinsl, queue_ent::chan, call_queue::name, NULL, queue_ent::opos, queue_ent::parent, pbx_builtin_setvar_helper(), queue_ent::pos, RAII_VAR, call_queue::servicelevel, set_queue_variables(), and queue_ent::start.

Referenced by queue_exec(), try_calling(), and wait_our_turn().

reload()

static int reload ( void  )

static

Definition at line 12085 of file app_queue.c.

{
    struct ast_flags mask = {AST_FLAGS_ALL & ~QUEUE_RESET_STATS,};
    ast_unload_realtime("queue_members");
    reload_handler(1, &mask, NULL);
    return 0;
}

References AST_FLAGS_ALL, ast_unload_realtime(), NULL, and reload_handler().

Referenced by reload_handler(), reload_queue_rules(), and reload_queues().

reload_handler()

static int reload_handler ( int  reload, struct ast_flags *  mask, const char *  queuename  )

static

The command center for all reload operations.

Whenever any piece of queue information is to be reloaded, this function is called. It interprets the flags set in the mask parameter and acts based on how they are set.

Parameters

reload	True if we are reloading information, false if we are loading information for the first time.
mask	A bitmask which tells the handler what actions to take
queuename	The name of the queue on which we wish to take action

Return values

0	All reloads were successful
non-zero	There was a failure

Definition at line 10167 of file app_queue.c.

{
    int res = 0;
 
    if (ast_test_flag(mask, QUEUE_RELOAD_RULES)) {
        res |= reload_queue_rules(reload);
    }
    if (ast_test_flag(mask, QUEUE_RESET_STATS)) {
        res |= clear_stats(queuename);
    }
    if (ast_test_flag(mask, (QUEUE_RELOAD_PARAMETERS | QUEUE_RELOAD_MEMBER))) {
        res |= reload_queues(reload, mask, queuename);
    }
    return res;
}

References ast_test_flag, clear_stats(), QUEUE_RELOAD_MEMBER, QUEUE_RELOAD_PARAMETERS, QUEUE_RELOAD_RULES, QUEUE_RESET_STATS, reload(), reload_queue_rules(), and reload_queues().

Referenced by handle_queue_reload(), handle_queue_reset(), load_module(), manager_queue_reload(), manager_queue_reset(), and reload().

reload_queue_members()

static void reload_queue_members ( void  )

static

Reload dynamic queue members persisted into the astdb.

Definition at line 8248 of file app_queue.c.

{
    char *cur_ptr;
    const char *queue_name;
    char *member;
    char *interface;
    char *membername = NULL;
    char *state_interface;
    char *penalty_tok;
    int penalty = 0;
    char *paused_tok;
    int paused = 0;
    char *wrapuptime_tok;
    int wrapuptime = 0;
    char *reason_paused;
    struct ast_db_entry *db_tree;
    struct ast_db_entry *entry;
    struct call_queue *cur_queue;
    char *queue_data;
 
    /* Each key in 'pm_family' is the name of a queue */
    db_tree = ast_db_gettree(pm_family, NULL);
    for (entry = db_tree; entry; entry = entry->next) {
 
        queue_name = entry->key + strlen(pm_family) + 2;
 
        {
            struct call_queue tmpq = {
                .name = queue_name,
            };
            cur_queue = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Reload queue members");
        }
 
        if (!cur_queue) {
            cur_queue = find_load_queue_rt_friendly(queue_name);
        }
 
        if (!cur_queue) {
            /* If the queue no longer exists, remove it from the
             * database */
            ast_log(LOG_WARNING, "Error loading persistent queue: '%s': it does not exist\n", queue_name);
            ast_db_del(pm_family, queue_name);
            continue;
        }
 
        if (ast_db_get_allocated(pm_family, queue_name, &queue_data)) {
            queue_t_unref(cur_queue, "Expire reload reference");
            continue;
        }
 
        cur_ptr = queue_data;
        while ((member = strsep(&cur_ptr, ",|"))) {
            if (ast_strlen_zero(member)) {
                continue;
            }
 
            interface = strsep(&member, ";");
            penalty_tok = strsep(&member, ";");
            paused_tok = strsep(&member, ";");
            membername = strsep(&member, ";");
            state_interface = strsep(&member, ";");
            reason_paused = strsep(&member, ";");
            wrapuptime_tok = strsep(&member, ";");
 
            if (!penalty_tok) {
                ast_log(LOG_WARNING, "Error parsing persistent member string for '%s' (penalty)\n", queue_name);
                break;
            }
            penalty = strtol(penalty_tok, NULL, 10);
            if (errno == ERANGE) {
                ast_log(LOG_WARNING, "Error converting penalty: %s: Out of range.\n", penalty_tok);
                break;
            }
 
            if (!paused_tok) {
                ast_log(LOG_WARNING, "Error parsing persistent member string for '%s' (paused)\n", queue_name);
                break;
            }
            paused = strtol(paused_tok, NULL, 10);
            if ((errno == ERANGE) || paused < 0 || paused > 1) {
                ast_log(LOG_WARNING, "Error converting paused: %s: Expected 0 or 1.\n", paused_tok);
                break;
            }
 
            if (!ast_strlen_zero(wrapuptime_tok)) {
                wrapuptime = strtol(wrapuptime_tok, NULL, 10);
                if (errno == ERANGE) {
                    ast_log(LOG_WARNING, "Error converting wrapuptime: %s: Out of range.\n", wrapuptime_tok);
                    break;
                }
            }
 
            ast_debug(1, "Reload Members: Queue: %s  Member: %s  Name: %s  Penalty: %d  Paused: %d ReasonPause: %s  Wrapuptime: %d\n",
                          queue_name, interface, membername, penalty, paused, reason_paused, wrapuptime);
 
            if (add_to_queue(queue_name, interface, membername, penalty, paused, 0, state_interface, reason_paused, wrapuptime) == RES_OUTOFMEMORY) {
                ast_log(LOG_ERROR, "Out of Memory when reloading persistent queue member\n");
                break;
            }
        }
        queue_t_unref(cur_queue, "Expire reload reference");
        ast_free(queue_data);
    }
 
    if (db_tree) {
        ast_log(LOG_NOTICE, "Queue members successfully reloaded from database.\n");
        ast_db_freetree(db_tree);
    }
}

References add_to_queue(), ao2_t_find, ast_db_del(), ast_db_freetree(), ast_db_get_allocated(), ast_db_gettree(), ast_debug, ast_free, ast_log, ast_strlen_zero(), errno, find_load_queue_rt_friendly(), member::interface, ast_db_entry::key, LOG_ERROR, LOG_NOTICE, LOG_WARNING, member::membername, call_queue::name, ast_db_entry::next, NULL, OBJ_POINTER, member::paused, member::penalty, pm_family, queue_t_unref, queues, member::reason_paused, RES_OUTOFMEMORY, member::state_interface, strsep(), and member::wrapuptime.

Referenced by load_module().

reload_queue_rules()

static int reload_queue_rules ( int  reload )

static

Reload the rules defined in queuerules.conf.

Parameters

reload

If 1, then only process queuerules.conf if the file has changed since the last time we inspected it.

Returns

Always returns AST_MODULE_LOAD_SUCCESS

Definition at line 9650 of file app_queue.c.

{
    struct ast_config *cfg;
    struct rule_list *rl_iter, *new_rl;
    struct penalty_rule *pr_iter;
    char *rulecat = NULL;
    struct ast_variable *rulevar = NULL;
    struct ast_flags config_flags = { (reload && !realtime_rules) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
 
    if (!(cfg = ast_config_load("queuerules.conf", config_flags))) {
        ast_log(LOG_NOTICE, "No queuerules.conf file found, queues will not follow penalty rules\n");
        return AST_MODULE_LOAD_SUCCESS;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        ast_log(LOG_NOTICE, "queuerules.conf has not changed since it was last loaded. Not taking any action.\n");
        return AST_MODULE_LOAD_SUCCESS;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file queuerules.conf is in an invalid format.  Aborting.\n");
        return AST_MODULE_LOAD_SUCCESS;
    }
 
    AST_LIST_LOCK(&rule_lists);
    while ((rl_iter = AST_LIST_REMOVE_HEAD(&rule_lists, list))) {
        while ((pr_iter = AST_LIST_REMOVE_HEAD(&rl_iter->rules, list)))
            ast_free(pr_iter);
        ast_free(rl_iter);
    }
    queue_rules_reset_global_params();
    while ((rulecat = ast_category_browse(cfg, rulecat))) {
        if (!strcasecmp(rulecat, "general")) {
            queue_rules_set_global_params(cfg);
            continue;
        }
        if (!(new_rl = ast_calloc(1, sizeof(*new_rl)))) {
            AST_LIST_UNLOCK(&rule_lists);
            ast_config_destroy(cfg);
            return AST_MODULE_LOAD_DECLINE;
        } else {
            ast_copy_string(new_rl->name, rulecat, sizeof(new_rl->name));
            AST_LIST_INSERT_TAIL(&rule_lists, new_rl, list);
            for (rulevar = ast_variable_browse(cfg, rulecat); rulevar; rulevar = rulevar->next)
                if(!strcasecmp(rulevar->name, "penaltychange"))
                    insert_penaltychange(new_rl->name, rulevar->value, rulevar->lineno);
                else
                    ast_log(LOG_WARNING, "Don't know how to handle rule type '%s' on line %d\n", rulevar->name, rulevar->lineno);
        }
    }
 
    ast_config_destroy(cfg);
 
    if (realtime_rules && load_realtime_rules()) {
        AST_LIST_UNLOCK(&rule_lists);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    AST_LIST_UNLOCK(&rule_lists);
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_calloc, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_copy_string(), ast_free, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_variable_browse(), CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, insert_penaltychange(), ast_variable::lineno, load_realtime_rules(), LOG_ERROR, LOG_NOTICE, LOG_WARNING, rule_list::name, ast_variable::name, ast_variable::next, NULL, queue_rules_reset_global_params(), queue_rules_set_global_params(), realtime_rules, reload(), rule_list::rules, and ast_variable::value.

Referenced by reload_handler().

reload_queues()

static int reload_queues ( int  reload, struct ast_flags *  mask, const char *  queuename  )

static

reload the queues.conf file

This function reloads the information in the general section of the queues.conf file and potentially more, depending on the value of mask.

Parameters

reload	0 if we are calling this the first time, 1 every other time
mask	Gives flags telling us what information to actually reload
queuename	If set to a non-zero string, then only reload information from that particular queue. Otherwise inspect all queues

Return values

-1	Failure occurred
0	All clear!

Definition at line 10080 of file app_queue.c.

{
    struct ast_config *cfg;
    char *cat;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    const int queue_reload = ast_test_flag(mask, QUEUE_RELOAD_PARAMETERS);
 
    if (!(cfg = ast_config_load("queues.conf", config_flags))) {
        ast_log(LOG_NOTICE, "No call queueing config file (queues.conf), so no call queues\n");
        return -1;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file queues.conf is in an invalid format.  Aborting.\n");
        return -1;
    }
 
    /* We've made it here, so it looks like we're doing operations on all queues. */
    ao2_lock(queues);
 
    /* Mark non-realtime queues not found at the beginning. */
    ao2_callback(queues, OBJ_NODATA, mark_unfound, (char *) queuename);
 
    /* Chug through config file. */
    cat = NULL;
    queue_reset_global_params();
    while ((cat = ast_category_browse(cfg, cat)) ) {
        if (!strcasecmp(cat, "general") && queue_reload) {
            queue_set_global_params(cfg);
            continue;
        }
        if (ast_strlen_zero(queuename) || !strcasecmp(cat, queuename))
            reload_single_queue(cfg, mask, cat);
    }
 
    ast_config_destroy(cfg);
    if (queue_reload) {
        /* Unlink and mark dead all non-realtime queues that were not found in the configuration file. */
        ao2_callback(queues, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK | OBJ_NOLOCK, kill_if_unfound, (char *) queuename);
    }
    ao2_unlock(queues);
    return 0;
}

References ao2_callback, ao2_lock, ao2_unlock, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_log, ast_strlen_zero(), ast_test_flag, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, kill_if_unfound(), LOG_ERROR, LOG_NOTICE, mark_unfound(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_NOLOCK, OBJ_UNLINK, QUEUE_RELOAD_PARAMETERS, queue_reset_global_params(), queue_set_global_params(), queues, reload(), and reload_single_queue().

Referenced by reload_handler().

reload_single_member()

static void reload_single_member ( const char *  memberdata, struct call_queue *  q  )

static

reload information pertaining to a single member

This function is called when a member = line is encountered in queues.conf.

Parameters

memberdata	The part after member = in the config file
q	The queue to which this member belongs

Definition at line 9760 of file app_queue.c.

{
    char *membername, *interface, *state_interface, *tmp;
    char *parse;
    struct member *cur, *newm;
    struct member tmpmem;
    int penalty;
    int ringinuse;
    int wrapuptime;
    int paused;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(interface);
        AST_APP_ARG(penalty);
        AST_APP_ARG(membername);
        AST_APP_ARG(state_interface);
        AST_APP_ARG(ringinuse);
        AST_APP_ARG(wrapuptime);
        AST_APP_ARG(paused);
    );
 
    if (ast_strlen_zero(memberdata)) {
        ast_log(LOG_WARNING, "Empty queue member definition. Moving on!\n");
        return;
    }
 
    /* Add a new member */
    parse = ast_strdupa(memberdata);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    interface = args.interface;
    if (!ast_strlen_zero(args.penalty)) {
        tmp = args.penalty;
        ast_strip(tmp);
        penalty = atoi(tmp);
        if (penalty < 0) {
            penalty = 0;
        }
    } else {
        penalty = 0;
    }
 
    if (!ast_strlen_zero(args.membername)) {
        membername = args.membername;
        ast_strip(membername);
    } else {
        membername = interface;
    }
 
    if (!ast_strlen_zero(args.state_interface)) {
        state_interface = args.state_interface;
        ast_strip(state_interface);
    } else {
        state_interface = interface;
    }
 
    if (!ast_strlen_zero(args.ringinuse)) {
        tmp = args.ringinuse;
        ast_strip(tmp);
        if (ast_true(tmp)) {
            ringinuse = 1;
        } else if (ast_false(tmp)) {
            ringinuse = 0;
        } else {
            ast_log(LOG_ERROR, "Member %s has an invalid ringinuse value. Using %s ringinuse value.\n",
                membername, q->name);
            ringinuse = q->ringinuse;
        }
    } else {
        ringinuse = q->ringinuse;
    }
 
    if (!ast_strlen_zero(args.wrapuptime)) {
        tmp = args.wrapuptime;
        ast_strip(tmp);
        wrapuptime = atoi(tmp);
        if (wrapuptime < 0) {
            wrapuptime = 0;
        }
    } else {
        wrapuptime = 0;
    }
 
    if (!ast_strlen_zero(args.paused)) {
        tmp = args.paused;
        ast_strip(tmp);
        if (ast_true(tmp)) {
            paused = 1;
        } else if (ast_false(tmp)) {
            paused = 0;
        } else {
            ast_log(LOG_ERROR, "Member %s has an invalid paused value.\n", membername);
            paused = 0;
        }
    } else {
        paused = 0;
    }
 
    /* Find the old position in the list */
    ast_copy_string(tmpmem.interface, interface, sizeof(tmpmem.interface));
    cur = ao2_find(q->members, &tmpmem, OBJ_POINTER);
 
    if (cur) {
        paused = cur->paused;
    }
 
    if ((newm = create_queue_member(interface, membername, penalty, paused, state_interface, ringinuse, wrapuptime))) {
        newm->wrapuptime = wrapuptime;
        if (cur) {
            ao2_lock(q->members);
            /* Round Robin Queue Position must be copied if this is replacing an existing member */
            newm->queuepos = cur->queuepos;
            /* Don't reset agent stats either */
            newm->calls = cur->calls;
            newm->lastcall = cur->lastcall;
 
            ao2_link(q->members, newm);
            ao2_unlink(q->members, cur);
            ao2_unlock(q->members);
        } else {
            /* Otherwise we need to add using the function that will apply a round robin queue position manually. */
            member_add_to_queue(q, newm);
        }
        ao2_ref(newm, -1);
    }
    newm = NULL;
 
    if (cur) {
        ao2_ref(cur, -1);
    }
}

References ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, args, AST_APP_ARG, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_false(), ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strip(), ast_strlen_zero(), ast_true(), member::calls, create_queue_member(), member::interface, member::lastcall, LOG_ERROR, LOG_WARNING, member_add_to_queue(), member::membername, call_queue::members, call_queue::name, NULL, OBJ_POINTER, member::paused, member::penalty, member::queuepos, member::ringinuse, call_queue::ringinuse, member::state_interface, and member::wrapuptime.

Referenced by reload_single_queue().

reload_single_queue()

static void reload_single_queue ( struct ast_config *  cfg, struct ast_flags *  mask, const char *  queuename  )

static

Reload information pertaining to a particular queue.

Once we have isolated a queue within reload_queues, we call this. This will either reload information for the queue or if we're just reloading member information, we'll just reload that without touching other settings within the queue

Parameters

cfg	The configuration which we are reading
mask	Tells us what information we need to reload
queuename	The name of the queue we are reloading information from

Definition at line 9923 of file app_queue.c.

{
    int new;
    struct call_queue *q = NULL;
    struct member *member;
    /*We're defining a queue*/
    struct call_queue tmpq = {
        .name = queuename,
    };
    const char *tmpvar;
    const int queue_reload = ast_test_flag(mask, QUEUE_RELOAD_PARAMETERS);
    const int member_reload = ast_test_flag(mask, QUEUE_RELOAD_MEMBER);
    int prev_weight = 0;
    struct ast_variable *var;
    struct ao2_iterator mem_iter;
 
    if (!(q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Find queue for reload"))) {
        if (queue_reload) {
            /* Make one then */
            if (!(q = alloc_queue(queuename))) {
                return;
            }
        } else {
            /* Since we're not reloading queues, this means that we found a queue
             * in the configuration file which we don't know about yet. Just return.
             */
            return;
        }
        new = 1;
    } else {
        new = 0;
    }
 
    if (!new) {
        ao2_lock(q);
        prev_weight = q->weight ? 1 : 0;
    }
    /* Check if we already found a queue with this name in the config file */
    if (q->found) {
        ast_log(LOG_WARNING, "Queue '%s' already defined! Skipping!\n", queuename);
        if (!new) {
            /* It should be impossible to *not* hit this case*/
            ao2_unlock(q);
        }
        queue_t_unref(q, "We exist! Expiring temporary pointer");
        return;
    }
    /* Due to the fact that the "linear" strategy will have a different allocation
     * scheme for queue members, we must devise the queue's strategy before other initializations.
     * To be specific, the linear strategy needs to function like a linked list, meaning the ao2
     * container used will have only a single bucket instead of the typical number.
     */
    if (queue_reload) {
        if ((tmpvar = ast_variable_retrieve(cfg, queuename, "strategy"))) {
            q->strategy = strat2int(tmpvar);
            if (q->strategy < 0) {
                ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
                tmpvar, q->name);
                q->strategy = QUEUE_STRATEGY_RINGALL;
            }
        } else {
            q->strategy = QUEUE_STRATEGY_RINGALL;
        }
        init_queue(q);
    }
    if (member_reload) {
        ao2_callback(q->members, OBJ_NODATA, mark_member_dead, NULL);
        q->found = 1;
    }
 
    /* On the first pass we just read the parameters of the queue */
    for (var = ast_variable_browse(cfg, queuename); var; var = var->next) {
        if (queue_reload && strcasecmp(var->name, "member")) {
            queue_set_param(q, var->name, var->value, var->lineno, 1);
        }
    }
 
    /* On the second pass, we read members */
    for (var = ast_variable_browse(cfg, queuename); var; var = var->next) {
        if (member_reload && !strcasecmp(var->name, "member")) {
            reload_single_member(var->value, q);
        }
    }
 
    /* Update ringinuse for dynamic members */
    if (member_reload) {
        ao2_lock(q->members);
        mem_iter = ao2_iterator_init(q->members, AO2_ITERATOR_DONTLOCK);
        while ((member = ao2_iterator_next(&mem_iter))) {
            if (member->dynamic) {
                member->ringinuse = q->ringinuse;
            }
            ao2_ref(member, -1);
        }
        ao2_iterator_destroy(&mem_iter);
        ao2_unlock(q->members);
    }
 
    /* At this point, we've determined if the queue has a weight, so update use_weight
     * as appropriate
     */
    if (!q->weight && prev_weight) {
        ast_atomic_fetchadd_int(&use_weight, -1);
    } else if (q->weight && !prev_weight) {
        ast_atomic_fetchadd_int(&use_weight, +1);
    }
 
    /* Free remaining members marked as delme */
    if (member_reload) {
        ao2_lock(q->members);
        ao2_callback(q->members, OBJ_NODATA | OBJ_MULTIPLE, queue_delme_members_decrement_followers, q);
        ao2_callback(q->members, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, kill_dead_members, q);
        ao2_unlock(q->members);
    }
 
    if (new) {
        queues_t_link(queues, q, "Add queue to container");
    } else {
        ao2_unlock(q);
    }
    queue_t_unref(q, "Expiring creation reference");
}

References alloc_queue(), ao2_callback, ao2_iterator_destroy(), AO2_ITERATOR_DONTLOCK, ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_find, ao2_unlock, ast_atomic_fetchadd_int(), ast_log, ast_test_flag, ast_variable_browse(), ast_variable_retrieve(), member::dynamic, call_queue::found, init_queue(), kill_dead_members(), LOG_WARNING, mark_member_dead(), call_queue::members, call_queue::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_POINTER, OBJ_UNLINK, queue_delme_members_decrement_followers(), QUEUE_RELOAD_MEMBER, QUEUE_RELOAD_PARAMETERS, queue_set_param(), QUEUE_STRATEGY_RINGALL, queue_t_unref, queues, queues_t_link, reload_single_member(), member::ringinuse, call_queue::ringinuse, strat2int(), call_queue::strategy, use_weight, var, and call_queue::weight.

Referenced by reload_queues().

remove_from_queue()

static int remove_from_queue ( const char *  queuename, const char *  interface  )

static

Remove member from queue.

Return values

RES_NOT_DYNAMIC	when they aren't a RT member
RES_NOSUCHQUEUE	queue does not exist
RES_OKAY	removed member from queue
RES_EXISTS	queue exists but no members

Definition at line 7688 of file app_queue.c.

{
    struct call_queue *q, tmpq = {
        .name = queuename,
    };
    struct member *mem, tmpmem;
    int res = RES_NOSUCHQUEUE;
 
    ast_copy_string(tmpmem.interface, interface, sizeof(tmpmem.interface));
    if ((q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Temporary reference for interface removal"))) {
        ao2_lock(q);
        if ((mem = ao2_find(q->members, &tmpmem, OBJ_POINTER))) {
            /* XXX future changes should beware of this assumption!! */
            /*Change Penalty on realtime users*/
            if (mem->realtime && !ast_strlen_zero(mem->rt_uniqueid) && negative_penalty_invalid) {
                update_realtime_member_field(mem, q->name, "penalty", "-1");
            } else if (!mem->dynamic) {
                ao2_ref(mem, -1);
                ao2_unlock(q);
                queue_t_unref(q, "Interface wasn't dynamic, expiring temporary reference");
                return RES_NOT_DYNAMIC;
            }
            queue_publish_member_blob(queue_member_removed_type(), queue_member_blob_create(q, mem));
 
            member_remove_from_queue(q, mem);
            ao2_ref(mem, -1);
 
            if (queue_persistent_members) {
                dump_queue_members(q);
            }
 
            if (!num_available_members(q)) {
                ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
            }
 
            res = RES_OKAY;
        } else {
            res = RES_EXISTS;
        }
        ao2_unlock(q);
        queue_t_unref(q, "Expiring temporary reference");
    }
 
    return res;
}

References ao2_find, ao2_lock, ao2_ref, ao2_t_find, ao2_unlock, ast_copy_string(), AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_strlen_zero(), dump_queue_members(), member::dynamic, member::interface, member_remove_from_queue(), call_queue::members, call_queue::name, negative_penalty_invalid, num_available_members(), OBJ_POINTER, queue_member_blob_create(), queue_persistent_members, queue_publish_member_blob(), queue_t_unref, queues, member::realtime, RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_DYNAMIC, RES_OKAY, member::rt_uniqueid, and update_realtime_member_field().

Referenced by handle_queue_remove_member(), manager_remove_queue_member(), and rqm_exec().

remove_stasis_subscriptions()

static void remove_stasis_subscriptions ( struct queue_stasis_data *  queue_data )

static

Definition at line 6424 of file app_queue.c.

{
    SCOPED_AO2LOCK(lock, queue_data);
 
    queue_data->dying = 1;
    stasis_message_router_unsubscribe(queue_data->bridge_router);
    queue_data->bridge_router = NULL;
    stasis_message_router_unsubscribe(queue_data->channel_router);
    queue_data->channel_router = NULL;
}

References queue_stasis_data::bridge_router, queue_stasis_data::channel_router, queue_stasis_data::dying, lock, NULL, SCOPED_AO2LOCK, and stasis_message_router_unsubscribe().

Referenced by handle_attended_transfer(), handle_blind_transfer(), and handle_hangup().

request_withdraw_caller_from_queue()

static int request_withdraw_caller_from_queue ( const char *  queuename, const char *  caller, const char *  withdraw_info  )

static

Request to withdraw a caller from a queue.

Return values

RES_NOSUCHQUEUE	queue does not exist
RES_OKAY	withdraw request sent
RES_NOT_CALLER	queue exists but no caller
RES_EXISTS	a withdraw request was already sent for this caller (channel) and queue

Note

Ensure the appropriate realtime queue is loaded. Note that this short-circuits if the queue is already in memory.

Definition at line 7870 of file app_queue.c.

{
    struct call_queue *q;
    struct queue_ent *qe;
    int res = RES_NOSUCHQUEUE;
 
    /*! \note Ensure the appropriate realtime queue is loaded.  Note that this
     * short-circuits if the queue is already in memory. */
    if (!(q = find_load_queue_rt_friendly(queuename))) {
        return res;
    }
 
    ao2_lock(q);
    res = RES_NOT_CALLER;
    for (qe = q->head; qe; qe = qe->next) {
        if (!strcmp(ast_channel_name(qe->chan), caller)) {
            if (qe->withdraw) {
                ast_debug(1, "Ignoring duplicate withdraw request of caller %s from queue %s\n", caller, queuename);
                res = RES_EXISTS;
            } else {
                ast_debug(1, "Requested withdraw of caller %s from queue %s\n", caller, queuename);
                /* It is not possible to change the withdraw info by further withdraw requests for this caller (channel)
                   in this queue, so we do not need to worry about a memory leak here. */
                if (withdraw_info) {
                    qe->withdraw_info = ast_strdup(withdraw_info);
                }
                qe->withdraw = 1;
                res = RES_OKAY;
            }
            break;
        }
    }
    ao2_unlock(q);
    queue_unref(q);
 
    return res;
}

References ao2_lock, ao2_unlock, ast_channel_name(), ast_debug, ast_strdup, queue_ent::chan, find_load_queue_rt_friendly(), call_queue::head, queue_ent::next, queue_unref, RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_CALLER, RES_OKAY, queue_ent::withdraw, and queue_ent::withdraw_info.

Referenced by manager_request_withdraw_caller_from_queue().

ring_entry()

static int ring_entry ( struct queue_ent *  qe, struct callattempt *  tmp, int *  busies  )

static

Part 2 of ring_one.

Does error checking before attempting to request a channel and call a member. This function is only called from ring_one(). Failure can occur if:

• Agent on call
• Agent is paused
• Wrapup time not expired
• Priority by another queue

Return values

1	on success to reach a free agent
0	on failure to get agent.

Definition at line 4901 of file app_queue.c.

{
    int res;
    int status;
    char tech[256];
    char *location;
    struct ast_format_cap *nativeformats;
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    /* on entry here, we know that tmp->chan == NULL */
    if (!can_ring_entry(qe, tmp)) {
        tmp->stillgoing = 0;
        ++*busies;
        return 0;
    }
 
    ast_copy_string(tech, tmp->interface, sizeof(tech));
    if ((location = strchr(tech, '/'))) {
        *location++ = '\0';
    } else {
        location = "";
    }
 
    ast_channel_lock(qe->chan);
    nativeformats = ao2_bump(ast_channel_nativeformats(qe->chan));
    ast_channel_unlock(qe->chan);
 
    /* Request the peer */
    tmp->chan = ast_request(tech, nativeformats, NULL, qe->chan, location, &status);
    ao2_cleanup(nativeformats);
    if (!tmp->chan) {           /* If we can't, just go on to the next call */
        ao2_lock(qe->parent);
        qe->parent->rrpos++;
        qe->linpos++;
        ao2_unlock(qe->parent);
 
        pending_members_remove(tmp->member);
 
        publish_dial_end_event(qe->chan, tmp, NULL, "BUSY");
        tmp->stillgoing = 0;
        ++*busies;
        return 0;
    }
 
    ast_channel_lock_both(tmp->chan, qe->chan);
 
    ast_channel_req_accountcodes_precious(tmp->chan, qe->chan,
        AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
    if (qe->cancel_answered_elsewhere) {
        ast_channel_hangupcause_set(tmp->chan, AST_CAUSE_ANSWERED_ELSEWHERE);
    }
    ast_channel_appl_set(tmp->chan, "AppQueue");
    ast_channel_data_set(tmp->chan, "(Outgoing Line)");
    memset(ast_channel_whentohangup(tmp->chan), 0, sizeof(*ast_channel_whentohangup(tmp->chan)));
 
    /* If the new channel has no callerid, try to guess what it should be */
    if (!ast_channel_caller(tmp->chan)->id.number.valid) {
        if (ast_channel_connected(qe->chan)->id.number.valid) {
            struct ast_party_caller caller;
 
            ast_party_caller_set_init(&caller, ast_channel_caller(tmp->chan));
            caller.id = ast_channel_connected(qe->chan)->id;
            caller.ani = ast_channel_connected(qe->chan)->ani;
            ast_channel_set_caller_event(tmp->chan, &caller, NULL);
        } else if (!ast_strlen_zero(ast_channel_dialed(qe->chan)->number.str)) {
            ast_set_callerid(tmp->chan, ast_channel_dialed(qe->chan)->number.str, NULL, NULL);
        } else if (!ast_strlen_zero(ast_channel_exten(qe->chan))) {
            ast_set_callerid(tmp->chan, ast_channel_exten(qe->chan), NULL, NULL);
        }
        tmp->dial_callerid_absent = 1;
    }
 
    ast_party_redirecting_copy(ast_channel_redirecting(tmp->chan), ast_channel_redirecting(qe->chan));
 
    ast_channel_dialed(tmp->chan)->transit_network_select = ast_channel_dialed(qe->chan)->transit_network_select;
 
    ast_connected_line_copy_from_caller(ast_channel_connected(tmp->chan), ast_channel_caller(qe->chan));
 
    /* Inherit specially named variables from parent channel */
    ast_channel_inherit_variables(qe->chan, tmp->chan);
    ast_channel_datastore_inherit(qe->chan, tmp->chan);
    ast_max_forwards_decrement(tmp->chan);
 
    /* Presense of ADSI CPE on outgoing channel follows ours */
    ast_channel_adsicpe_set(tmp->chan, ast_channel_adsicpe(qe->chan));
 
    /* Inherit context and extension */
    ast_channel_dialcontext_set(tmp->chan, ast_channel_context(qe->chan));
    ast_channel_exten_set(tmp->chan, ast_channel_exten(qe->chan));
 
    /* Save the original channel name to detect call pickup masquerading in. */
    tmp->orig_chan_name = ast_strdup(ast_channel_name(tmp->chan));
 
    ast_channel_unlock(tmp->chan);
    ast_channel_unlock(qe->chan);
 
    /* location is tmp->interface where tech/ has been stripped, so it follow the same syntax as DIALEDPEERNUMBER in app_dial.c */
    pbx_builtin_setvar_helper(tmp->chan, "DIALEDPEERNUMBER", strlen(location) ? location : tmp->interface);
 
    /* PREDIAL: Run gosub on the callee's channel */
    if (qe->predial_callee) {
        ast_pre_call(tmp->chan, qe->predial_callee);
    }
 
    /* Place the call, but don't wait on the answer */
    if ((res = ast_call(tmp->chan, location, 0))) {
        /* Again, keep going even if there's an error */
        ast_verb(3, "Couldn't call %s\n", tmp->interface);
        do_hang(tmp);
        ++*busies;
        return 0;
    }
 
    ast_channel_lock_both(tmp->chan, qe->chan);
 
    blob = ast_json_pack("{s: s, s: s, s: s}",
                 "Queue", qe->parent->name,
                 "Interface", tmp->interface,
                 "MemberName", tmp->member->membername);
    queue_publish_multi_channel_blob(qe->chan, tmp->chan, queue_agent_called_type(), blob);
 
    ast_channel_publish_dial(qe->chan, tmp->chan, tmp->interface, NULL);
 
    ast_channel_unlock(tmp->chan);
    ast_channel_unlock(qe->chan);
 
    ast_verb(3, "Called %s\n", tmp->interface);
 
    return 1;
}

References ast_party_caller::ani, ast_party_connected_line::ani, ao2_bump, ao2_cleanup, ao2_lock, ao2_unlock, ast_call(), AST_CAUSE_ANSWERED_ELSEWHERE, ast_channel_adsicpe_set(), ast_channel_appl_set(), ast_channel_caller(), ast_channel_connected(), ast_channel_context(), ast_channel_data_set(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_exten(), ast_channel_exten_set(), ast_channel_hangupcause_set(), ast_channel_inherit_variables(), ast_channel_lock, ast_channel_lock_both, ast_channel_name(), ast_channel_nativeformats(), ast_channel_publish_dial(), ast_channel_redirecting(), ast_channel_req_accountcodes_precious(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, ast_channel_set_caller_event(), ast_channel_unlock, ast_channel_whentohangup(), ast_connected_line_copy_from_caller(), ast_copy_string(), ast_json_pack(), ast_json_unref(), ast_max_forwards_decrement(), ast_party_caller_set_init(), ast_party_redirecting_copy(), ast_pre_call(), ast_request(), ast_set_callerid(), ast_strdup, ast_strlen_zero(), ast_verb, can_ring_entry(), queue_ent::cancel_answered_elsewhere, callattempt::chan, queue_ent::chan, callattempt::dial_callerid_absent, do_hang(), ast_party_caller::id, ast_party_connected_line::id, callattempt::interface, queue_ent::linpos, callattempt::member, member::membername, call_queue::name, NULL, ast_party_id::number, ast_party_dialed::number, callattempt::orig_chan_name, queue_ent::parent, pbx_builtin_setvar_helper(), pending_members_remove(), queue_ent::predial_callee, publish_dial_end_event(), queue_publish_multi_channel_blob(), RAII_VAR, call_queue::rrpos, status, callattempt::stillgoing, ast_party_dialed::str, ast_party_dialed::transit_network_select, and ast_party_number::valid.

Referenced by ring_one().

ring_one()

static int ring_one ( struct queue_ent *  qe, struct callattempt *  outgoing, int *  busies  )

static

Place a call to a queue member.

Once metrics have been calculated for each member, this function is used to place a call to the appropriate member (or members). The low-level channel-handling and error detection is handled in ring_entry

Return values

1	if a member was called successfully
0	otherwise

Definition at line 5058 of file app_queue.c.

{
    int ret = 0;
    struct callattempt *cur;
 
    if (qe->predial_callee) {
        ast_autoservice_start(qe->chan);
        for (cur = outgoing; cur; cur = cur->q_next) {
            if (cur->stillgoing && cur->chan) {
                ast_autoservice_start(cur->chan);
            }
        }
    }
 
    while (ret == 0) {
        struct callattempt *best = find_best(outgoing);
        if (!best) {
            ast_debug(1, "Nobody left to try ringing in queue\n");
            break;
        }
        if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
            /* Ring everyone who shares this best metric (for ringall) */
            for (cur = outgoing; cur; cur = cur->q_next) {
                if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
                    ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
                    ret |= ring_entry(qe, cur, busies);
                    if (qe->predial_callee && cur->chan) {
                        ast_autoservice_start(cur->chan);
                    }
                }
            }
        } else {
            /* Ring just the best channel */
            ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
            ret = ring_entry(qe, best, busies);
            if (qe->predial_callee && best->chan) {
                ast_autoservice_start(best->chan);
            }
        }
 
        /* If we have timed out, break out */
        if (qe->expire && (time(NULL) >= qe->expire)) {
            ast_debug(1, "Queue timed out while ringing members.\n");
            ret = 0;
            break;
        }
    }
    if (qe->predial_callee) {
        for (cur = outgoing; cur; cur = cur->q_next) {
            if (cur->stillgoing && cur->chan) {
                ast_autoservice_stop(cur->chan);
            }
        }
        ast_autoservice_stop(qe->chan);
    }
 
    return ret;
}

References ast_autoservice_start(), ast_autoservice_stop(), ast_debug, callattempt::chan, queue_ent::chan, queue_ent::expire, find_best(), callattempt::interface, callattempt::metric, NULL, queue_ent::parent, queue_ent::predial_callee, callattempt::q_next, QUEUE_STRATEGY_RINGALL, ring_entry(), callattempt::stillgoing, and call_queue::strategy.

Referenced by try_calling(), and wait_for_answer().

rna()

static void rna ( int  rnatime, struct queue_ent *  qe, struct ast_channel *  peer, char *  interface, char *  membername, int  autopause  )

static

RNA == Ring No Answer. Common code that is executed when we try a queue member and they don't answer.

Definition at line 5258 of file app_queue.c.

{
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    ast_verb(3, "Nobody picked up in %d ms\n", rnatime);
 
    /* Stop ringing, and resume MOH if specified */
    if (qe->ring_when_ringing) {
        ast_indicate(qe->chan, -1);
        ast_moh_start(qe->chan, qe->moh, NULL);
    }
 
    blob = ast_json_pack("{s: s, s: s, s: s, s: i}",
                 "Queue", qe->parent->name,
                 "Interface", interface,
                 "MemberName", membername,
                 "RingTime", rnatime);
    queue_publish_multi_channel_blob(qe->chan, peer, queue_agent_ringnoanswer_type(), blob);
 
    ast_queue_log(qe->parent->name, ast_channel_uniqueid(qe->chan), membername, "RINGNOANSWER", "%d", rnatime);
    if (qe->parent->autopause != QUEUE_AUTOPAUSE_OFF && autopause) {
        if (qe->parent->autopausedelay > 0) {
            struct member *mem;
            ao2_lock(qe->parent);
            if ((mem = interface_exists(qe->parent, interface))) {
                time_t idletime = time(&idletime)-mem->lastcall;
                if ((mem->lastcall != 0) && (qe->parent->autopausedelay > idletime)) {
                    ao2_unlock(qe->parent);
                    ao2_ref(mem, -1);
                    return;
                }
                ao2_ref(mem, -1);
            }
            ao2_unlock(qe->parent);
        }
        if (qe->parent->autopause == QUEUE_AUTOPAUSE_ON) {
            if (!set_member_paused(qe->parent->name, interface, "Auto-Pause", 1)) {
                ast_verb(3, "Auto-Pausing Queue Member %s in queue %s since they failed to answer.\n",
                    interface, qe->parent->name);
            } else {
                ast_verb(3, "Failed to pause Queue Member %s in queue %s!\n", interface, qe->parent->name);
            }
        } else {
            /* If queue autopause is mode all, just don't send any queue to stop.
            * the function will stop in all queues */
            if (!set_member_paused("", interface, "Auto-Pause", 1)) {
                ast_verb(3, "Auto-Pausing Queue Member %s in all queues since they failed to answer on queue %s.\n",
                        interface, qe->parent->name);
            } else {
                ast_verb(3, "Failed to pause Queue Member %s in all queues!\n", interface);
            }
        }
    }
    return;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_uniqueid(), ast_indicate(), ast_json_pack(), ast_json_unref(), ast_moh_start(), ast_queue_log(), ast_verb, call_queue::autopause, call_queue::autopausedelay, queue_ent::chan, callattempt::interface, member::interface, interface_exists(), member::lastcall, queue_ent::moh, call_queue::name, NULL, queue_ent::parent, QUEUE_AUTOPAUSE_OFF, QUEUE_AUTOPAUSE_ON, queue_publish_multi_channel_blob(), RAII_VAR, queue_ent::ring_when_ringing, and set_member_paused().

Referenced by wait_for_answer().

rqm_exec()

static int rqm_exec ( struct ast_channel *  chan, const char *  data  )

static

RemoveQueueMember application.

Definition at line 8431 of file app_queue.c.

{
    int res=-1;
    char *parse, *temppos = NULL;
    struct member *mem = NULL;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
    );
 
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "RemoveQueueMember requires an argument (queuename[,interface])\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.interface)) {
        args.interface = ast_strdupa(ast_channel_name(chan));
        temppos = strrchr(args.interface, '-');
        if (temppos) {
            *temppos = '\0';
        }
    }
 
    ast_debug(1, "queue: %s, member: %s\n", args.queuename, args.interface);
 
    if (log_membername_as_agent) {
        mem = find_member_by_queuename_and_interface(args.queuename, args.interface);
    }
 
    switch (remove_from_queue(args.queuename, args.interface)) {
    case RES_OKAY:
        if (!mem || ast_strlen_zero(mem->membername)) {
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), args.interface, "REMOVEMEMBER", "%s", "");
        } else {
            ast_queue_log(args.queuename, ast_channel_uniqueid(chan), mem->membername, "REMOVEMEMBER", "%s", "");
        }
        ast_log(LOG_NOTICE, "Removed interface '%s' from queue '%s'\n", args.interface, args.queuename);
        pbx_builtin_setvar_helper(chan, "RQMSTATUS", "REMOVED");
        res = 0;
        break;
    case RES_EXISTS:
        ast_debug(1, "Unable to remove interface '%s' from queue '%s': Not there\n", args.interface, args.queuename);
        pbx_builtin_setvar_helper(chan, "RQMSTATUS", "NOTINQUEUE");
        res = 0;
        break;
    case RES_NOSUCHQUEUE:
        ast_log(LOG_WARNING, "Unable to remove interface from queue '%s': No such queue\n", args.queuename);
        pbx_builtin_setvar_helper(chan, "RQMSTATUS", "NOSUCHQUEUE");
        res = 0;
        break;
    case RES_NOT_DYNAMIC:
        ast_log(LOG_WARNING, "Unable to remove interface from queue '%s': '%s' is not a dynamic member\n", args.queuename, args.interface);
        pbx_builtin_setvar_helper(chan, "RQMSTATUS", "NOTDYNAMIC");
        res = 0;
        break;
    }
 
    if (mem) {
        ao2_ref(mem, -1);
    }
 
    return res;
}

References ao2_ref, args, AST_APP_ARG, ast_channel_name(), ast_channel_uniqueid(), ast_debug, AST_DECLARE_APP_ARGS, ast_log, ast_queue_log(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), find_member_by_queuename_and_interface(), member::interface, log_membername_as_agent, LOG_NOTICE, LOG_WARNING, member::membername, NULL, pbx_builtin_setvar_helper(), remove_from_queue(), RES_EXISTS, RES_NOSUCHQUEUE, RES_NOT_DYNAMIC, and RES_OKAY.

Referenced by load_module().

rt_handle_member_record()

static void rt_handle_member_record ( struct call_queue *  q, char *  category, struct ast_config *  member_config  )

static

Find rt member record to update otherwise create one.

Search for member in queue, if found update penalty/paused state, if no member exists create one flag it as a RT member and add to queue member list.

Definition at line 3726 of file app_queue.c.

{
    struct member *m;
    struct ao2_iterator mem_iter;
    int penalty = 0;
    int paused  = 0;
    int found = 0;
    int wrapuptime = 0;
    int ringinuse = q->ringinuse;
 
    const char *config_val;
    const char *interface = ast_variable_retrieve(member_config, category, "interface");
    const char *rt_uniqueid = ast_variable_retrieve(member_config, category, "uniqueid");
    const char *membername = S_OR(ast_variable_retrieve(member_config, category, "membername"), interface);
    const char *state_interface = S_OR(ast_variable_retrieve(member_config, category, "state_interface"), interface);
    const char *penalty_str = ast_variable_retrieve(member_config, category, "penalty");
    const char *paused_str = ast_variable_retrieve(member_config, category, "paused");
    const char *wrapuptime_str = ast_variable_retrieve(member_config, category, "wrapuptime");
    const char *reason_paused = ast_variable_retrieve(member_config, category, "reason_paused");
 
    if (ast_strlen_zero(rt_uniqueid)) {
        ast_log(LOG_WARNING, "Realtime field 'uniqueid' is empty for member %s\n",
            S_OR(membername, "NULL"));
        return;
    }
 
    if (ast_strlen_zero(interface)) {
        ast_log(LOG_WARNING, "Realtime field 'interface' is empty for member %s\n",
            S_OR(membername, "NULL"));
        return;
    }
 
    if (penalty_str) {
        penalty = atoi(penalty_str);
        if ((penalty < 0) && negative_penalty_invalid) {
            return;
        } else if (penalty < 0) {
            penalty = 0;
        }
    }
 
    if (paused_str) {
        paused = atoi(paused_str);
        if (paused < 0) {
            paused = 0;
        }
    }
 
    if (wrapuptime_str) {
        wrapuptime = atoi(wrapuptime_str);
        if (wrapuptime < 0) {
            wrapuptime = 0;
        }
    }
 
    if ((config_val = ast_variable_retrieve(member_config, category, realtime_ringinuse_field))) {
        if (ast_true(config_val)) {
            ringinuse = 1;
        } else if (ast_false(config_val)) {
            ringinuse = 0;
        } else {
            ast_log(LOG_WARNING, "Invalid value of '%s' field for %s in queue '%s'\n", realtime_ringinuse_field, interface, q->name);
        }
    }
 
    /* Find member by realtime uniqueid and update */
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((m = ao2_iterator_next(&mem_iter))) {
        if (!strcasecmp(m->rt_uniqueid, rt_uniqueid)) {
            m->dead = 0;    /* Do not delete this one. */
            ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
            if (paused_str) {
                m->paused = paused;
                if (paused && m->lastpause == 0) {
                    time(&m->lastpause); /* XXX: Should this come from realtime? */
                }
                ast_devstate_changed(m->paused ? QUEUE_PAUSED_DEVSTATE : QUEUE_UNPAUSED_DEVSTATE,
                    AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", q->name, m->interface);
            }
            if (strcasecmp(state_interface, m->state_interface)) {
                ast_copy_string(m->state_interface, state_interface, sizeof(m->state_interface));
            }
            m->penalty = penalty;
            m->ringinuse = ringinuse;
            m->wrapuptime = wrapuptime;
            if (realtime_reason_paused) {
                ast_copy_string(m->reason_paused, S_OR(reason_paused, ""), sizeof(m->reason_paused));
            }
            found = 1;
            ao2_ref(m, -1);
            break;
        }
        ao2_ref(m, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    /* Create a new member */
    if (!found) {
        if ((m = create_queue_member(interface, membername, penalty, paused, state_interface, ringinuse, wrapuptime))) {
            m->dead = 0;
            m->realtime = 1;
            ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
            if (!ast_strlen_zero(reason_paused)) {
                ast_copy_string(m->reason_paused, reason_paused, sizeof(m->reason_paused));
            }
            if (!log_membername_as_agent) {
                ast_queue_log(q->name, "REALTIME", m->interface, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
            } else {
                ast_queue_log(q->name, "REALTIME", m->membername, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
            }
            member_add_to_queue(q, m);
            ao2_ref(m, -1);
            m = NULL;
        }
    }
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_copy_string(), AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_false(), ast_log, ast_queue_log(), ast_strlen_zero(), ast_true(), ast_variable_retrieve(), create_queue_member(), member::dead, member::interface, member::lastpause, log_membername_as_agent, LOG_WARNING, member_add_to_queue(), member::membername, call_queue::members, call_queue::name, negative_penalty_invalid, NULL, member::paused, member::penalty, QUEUE_PAUSED_DEVSTATE, QUEUE_UNPAUSED_DEVSTATE, member::realtime, realtime_reason_paused, realtime_ringinuse_field, member::reason_paused, member::ringinuse, call_queue::ringinuse, member::rt_uniqueid, S_OR, member::state_interface, and member::wrapuptime.

Referenced by find_queue_by_name_rt(), and update_realtime_members().

say_periodic_announcement()

static int say_periodic_announcement ( struct queue_ent *  qe, int  ringing  )

static

Playback announcement to queued members if period has elapsed.

Definition at line 5166 of file app_queue.c.

{
    int res = 0;
    time_t now;
 
    /* Get the current time */
    time(&now);
 
    /* Check to see if it is time to announce */
    if ((now - qe->last_periodic_announce_time) < qe->parent->periodicannouncefrequency) {
        return 0;
    }
 
    /* Stop the music on hold so we can play our own file */
    if (ringing) {
        ast_indicate(qe->chan,-1);
    } else {
        ast_moh_stop(qe->chan);
    }
 
    ast_verb(3, "Playing periodic announcement\n");
 
    if (qe->parent->randomperiodicannounce && qe->parent->numperiodicannounce) {
        qe->last_periodic_announce_sound = ((unsigned long) ast_random()) % qe->parent->numperiodicannounce;
    } else if (qe->last_periodic_announce_sound >= qe->parent->numperiodicannounce ||
        ast_str_strlen(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]) == 0) {
        qe->last_periodic_announce_sound = 0;
    }
 
    /* play the announcement */
    res = play_file(qe->chan, ast_str_buffer(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]));
 
    if (res > 0 && !valid_exit(qe, res)) {
        res = 0;
    }
 
    /* Resume Music on Hold if the caller is going to stay in the queue */
    if (!res) {
        if (ringing) {
            ast_indicate(qe->chan, AST_CONTROL_RINGING);
        } else {
            ast_moh_start(qe->chan, qe->moh, NULL);
        }
    }
 
    /* update last_periodic_announce_time */
    if (qe->parent->relativeperiodicannounce) {
        time(&qe->last_periodic_announce_time);
    } else {
        qe->last_periodic_announce_time = now;
    }
 
    /* Update the current periodic announcement to the next announcement */
    if (!qe->parent->randomperiodicannounce) {
        qe->last_periodic_announce_sound++;
    }
 
    return res;
}

References AST_CONTROL_RINGING, ast_indicate(), ast_moh_start(), ast_moh_stop(), ast_random(), ast_str_buffer(), ast_str_strlen(), ast_verb, queue_ent::chan, queue_ent::last_periodic_announce_sound, queue_ent::last_periodic_announce_time, queue_ent::moh, NULL, call_queue::numperiodicannounce, queue_ent::parent, call_queue::periodicannouncefrequency, play_file(), call_queue::randomperiodicannounce, call_queue::relativeperiodicannounce, ringing(), call_queue::sound_periodicannounce, and valid_exit().

Referenced by queue_exec(), and wait_our_turn().

say_position()

static int say_position ( struct queue_ent *  qe, int  ringing  )

static

Definition at line 4355 of file app_queue.c.

{
    int res = 0, say_thanks = 0;
    long avgholdmins, avgholdsecs;
    time_t now;
 
    /* Let minannouncefrequency seconds pass between the start of each position announcement */
    time(&now);
    if ((now - qe->last_pos) < qe->parent->minannouncefrequency) {
        return 0;
    }
 
    /* If either our position has changed, or we are over the freq timer, say position */
    if ((qe->last_pos_said == qe->pos) && ((now - qe->last_pos) < qe->parent->announcefrequency)) {
        return 0;
    }
 
    /* Only announce if the caller's queue position has improved since last time */
    if (qe->parent->announceposition_only_up && qe->last_pos_said > 0 && qe->last_pos_said <= qe->pos) {
        return 0;
    }
 
    if (ringing) {
        ast_indicate(qe->chan,-1);
    } else {
        ast_moh_stop(qe->chan);
    }
 
    if (qe->parent->announceposition == ANNOUNCEPOSITION_YES ||
        qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN ||
        (qe->parent->announceposition == ANNOUNCEPOSITION_LIMIT &&
        qe->pos <= qe->parent->announcepositionlimit)) {
        say_thanks = 1;
        /* Say we're next, if we are */
        if (qe->pos == 1) {
            res = play_file(qe->chan, qe->parent->sound_next);
            if (!res) {
                goto posout;
            }
        /* Say there are more than N callers */
        } else if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit) {
            res = (
                play_file(qe->chan, qe->parent->queue_quantity1) ||
                ast_say_number(qe->chan, qe->parent->announcepositionlimit, AST_DIGIT_ANY,
                        ast_channel_language(qe->chan), NULL) || /* Needs gender */
                play_file(qe->chan, qe->parent->queue_quantity2));
        /* Say there are currently N callers waiting */
        } else {
            res = (
                play_file(qe->chan, qe->parent->sound_thereare) ||
                ast_say_number(qe->chan, qe->pos, AST_DIGIT_ANY,
                        ast_channel_language(qe->chan), "n") || /* Needs gender */
                play_file(qe->chan, qe->parent->sound_calls));
        }
        if (res) {
            goto playout;
        }
    }
    /* Round hold time to nearest minute */
    avgholdmins = labs(((qe->parent->holdtime + 30) - (now - qe->start)) / 60);
 
    /* If they have specified a rounding then round the seconds as well */
    if (qe->parent->roundingseconds) {
        avgholdsecs = (labs(((qe->parent->holdtime + 30) - (now - qe->start))) - 60 * avgholdmins) / qe->parent->roundingseconds;
        avgholdsecs *= qe->parent->roundingseconds;
    } else {
        avgholdsecs = 0;
    }
 
    ast_verb(3, "Hold time for %s is %ld minute(s) %ld seconds\n", qe->parent->name, avgholdmins, avgholdsecs);
 
    /* If the hold time is >1 min, if it's enabled, and if it's not
       supposed to be only once and we have already said it, say it */
    if ((avgholdmins+avgholdsecs) > 0 && qe->parent->announceholdtime &&
        ((qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE && !qe->last_pos) ||
        !(qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE))) {
        say_thanks = 1;
        res = play_file(qe->chan, qe->parent->sound_holdtime);
        if (res) {
            goto playout;
        }
 
        if (avgholdmins >= 1) {
            res = ast_say_number(qe->chan, avgholdmins, AST_DIGIT_ANY, ast_channel_language(qe->chan), "n");
            if (res) {
                goto playout;
            }
 
            if (avgholdmins == 1) {
                res = play_file(qe->chan, qe->parent->sound_minute);
                if (res) {
                    goto playout;
                }
            } else {
                res = play_file(qe->chan, qe->parent->sound_minutes);
                if (res) {
                    goto playout;
                }
            }
        }
        if (avgholdsecs >= 1) {
            res = ast_say_number(qe->chan, avgholdsecs, AST_DIGIT_ANY, ast_channel_language(qe->chan), "n");
            if (res) {
                goto playout;
            }
 
            res = play_file(qe->chan, qe->parent->sound_seconds);
            if (res) {
                goto playout;
            }
        }
    }
 
posout:
    if (qe->parent->announceposition) {
        ast_verb(3, "Told %s in %s their queue position (which was %d)\n",
            ast_channel_name(qe->chan), qe->parent->name, qe->pos);
    }
    if (say_thanks) {
        res = play_file(qe->chan, qe->parent->sound_thanks);
    }
playout:
 
    if ((res > 0 && !valid_exit(qe, res))) {
        res = 0;
    }
 
    /* Set our last_pos indicators */
    qe->last_pos = now;
    qe->last_pos_said = qe->pos;
 
    /* Don't restart music on hold if we're about to exit the caller from the queue */
    if (!res) {
        if (ringing) {
            ast_indicate(qe->chan, AST_CONTROL_RINGING);
        } else {
            ast_moh_start(qe->chan, qe->moh, NULL);
        }
    }
    return res;
}

References call_queue::announcefrequency, call_queue::announceholdtime, ANNOUNCEHOLDTIME_ONCE, call_queue::announceposition, ANNOUNCEPOSITION_LIMIT, ANNOUNCEPOSITION_MORE_THAN, call_queue::announceposition_only_up, ANNOUNCEPOSITION_YES, call_queue::announcepositionlimit, ast_channel_language(), ast_channel_name(), AST_CONTROL_RINGING, AST_DIGIT_ANY, ast_indicate(), ast_moh_start(), ast_moh_stop(), ast_say_number(), ast_verb, queue_ent::chan, call_queue::holdtime, queue_ent::last_pos, queue_ent::last_pos_said, call_queue::minannouncefrequency, queue_ent::moh, call_queue::name, NULL, queue_ent::parent, play_file(), queue_ent::pos, call_queue::queue_quantity1, call_queue::queue_quantity2, ringing(), call_queue::roundingseconds, call_queue::sound_calls, call_queue::sound_holdtime, call_queue::sound_minute, call_queue::sound_minutes, call_queue::sound_next, call_queue::sound_seconds, call_queue::sound_thanks, call_queue::sound_thereare, queue_ent::start, and valid_exit().

Referenced by queue_exec(), and wait_our_turn().

send_agent_complete()

static void send_agent_complete ( const char *  queuename, struct ast_channel_snapshot *  caller, struct ast_channel_snapshot *  peer, const struct member *  member, time_t  holdstart, time_t  callstart, enum agent_complete_reason  rsn  )

static

Send out AMI message with member call completion status information.

Definition at line 6277 of file app_queue.c.

{
    const char *reason = NULL;  /* silence dumb compilers */
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
    switch (rsn) {
    case CALLER:
        reason = "caller";
        break;
    case AGENT:
        reason = "agent";
        break;
    case TRANSFER:
        reason = "transfer";
        break;
    }
 
    blob = ast_json_pack("{s: s, s: s, s: s, s: I, s: I, s: s}",
        "Queue", queuename,
        "Interface", member->interface,
        "MemberName", member->membername,
        "HoldTime", (ast_json_int_t)(callstart - holdstart),
        "TalkTime", (ast_json_int_t)(time(NULL) - callstart),
        "Reason", reason ?: "");
 
    queue_publish_multi_channel_snapshot_blob(ast_queue_topic(queuename), caller, peer,
            queue_agent_complete_type(), blob);
}

References AGENT, ast_json_pack(), ast_json_unref(), ast_queue_topic(), CALLER, member::interface, member::membername, NULL, queue_publish_multi_channel_snapshot_blob(), RAII_VAR, and TRANSFER.

Referenced by handle_attended_transfer(), handle_blind_transfer(), and handle_hangup().

set_member_paused()

static int set_member_paused ( const char *  queuename, const char *  interface, const char *  reason, int  paused  )

static

Definition at line 8000 of file app_queue.c.

{
    int found = 0;
    struct call_queue *q;
    struct ao2_iterator queue_iter;
 
    if (ast_check_realtime("queues")) {
        load_realtime_queues(queuename);
    }
 
    queue_iter = ao2_iterator_init(queues, 0);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate over queues"))) {
        ao2_lock(q);
        if (ast_strlen_zero(queuename) || !strcasecmp(q->name, queuename)) {
            struct member *mem;
 
            if ((mem = interface_exists(q, interface))) {
                /*
                 * Before we do the PAUSE/UNPAUSE, log if this was a
                 * PAUSEALL/UNPAUSEALL but only on the first found entry.
                 */
                ++found;
                if (found == 1
                    && ast_strlen_zero(queuename)) {
                    /*
                     * XXX In all other cases, we use the queue name,
                     * but since this affects all queues, we cannot.
                     */
                    ast_queue_log("NONE", "NONE", mem->membername,
                        (paused ? "PAUSEALL" : "UNPAUSEALL"), "%s", S_OR(reason, ""));
                }
 
                set_queue_member_pause(q, mem, reason, paused);
                ao2_ref(mem, -1);
            }
 
            if (!ast_strlen_zero(queuename)) {
                ao2_unlock(q);
                queue_t_unref(q, "Done with iterator");
                break;
            }
        }
 
        ao2_unlock(q);
        queue_t_unref(q, "Done with iterator");
    }
    ao2_iterator_destroy(&queue_iter);
 
    return found ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_check_realtime(), ast_queue_log(), ast_strlen_zero(), member::interface, interface_exists(), load_realtime_queues(), member::membername, call_queue::name, member::paused, queue_t_unref, queues, RESULT_FAILURE, RESULT_SUCCESS, S_OR, and set_queue_member_pause().

Referenced by handle_queue_pause_member(), manager_pause_queue_member(), pqm_exec(), queue_function_mem_write(), rna(), and upqm_exec().

set_member_penalty_help_members()

static int set_member_penalty_help_members ( struct call_queue *  q, const char *  interface, int  penalty  )

static

Definition at line 8060 of file app_queue.c.

{
    struct member *mem;
    int foundinterface = 0;
 
    ao2_lock(q);
    if ((mem = interface_exists(q, interface))) {
        foundinterface++;
        if (mem->realtime) {
            char rtpenalty[80];
 
            sprintf(rtpenalty, "%i", penalty);
            update_realtime_member_field(mem, q->name, "penalty", rtpenalty);
        }
 
        mem->penalty = penalty;
 
        ast_queue_log(q->name, "NONE", interface, "PENALTY", "%d", penalty);
        queue_publish_member_blob(queue_member_penalty_type(), queue_member_blob_create(q, mem));
        ao2_ref(mem, -1);
    }
    ao2_unlock(q);
 
    return foundinterface;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_queue_log(), member::interface, interface_exists(), call_queue::name, member::penalty, queue_member_blob_create(), queue_publish_member_blob(), member::realtime, and update_realtime_member_field().

Referenced by set_member_value_help_members().

set_member_ringinuse_help_members()

static int set_member_ringinuse_help_members ( struct call_queue *  q, const char *  interface, int  ringinuse  )

static

Definition at line 8109 of file app_queue.c.

{
    struct member *mem;
    int foundinterface = 0;
 
    ao2_lock(q);
    if ((mem = interface_exists(q, interface))) {
        foundinterface++;
        set_queue_member_ringinuse(q, mem, ringinuse);
        ao2_ref(mem, -1);
    }
    ao2_unlock(q);
 
    return foundinterface;
}

References ao2_lock, ao2_ref, ao2_unlock, member::interface, interface_exists(), member::ringinuse, and set_queue_member_ringinuse().

Referenced by set_member_value_help_members().

set_member_value()

static int set_member_value ( const char *  queuename, const char *  interface, int  property, int  value  )

static

Definition at line 8148 of file app_queue.c.

{
    int foundinterface = 0, foundqueue = 0;
    struct call_queue *q;
    struct ast_config *queue_config = NULL;
    struct ao2_iterator queue_iter;
 
    /* property dependent restrictions on values should be checked in this switch */
    switch (property) {
    case MEMBER_PENALTY:
        if (value < 0 && !negative_penalty_invalid) {
            ast_log(LOG_ERROR, "Invalid penalty (%d)\n", value);
            return RESULT_FAILURE;
        }
    }
 
    if (ast_strlen_zero(queuename)) { /* This means we need to iterate through all the queues. */
        if (ast_check_realtime("queues")) {
            queue_config = ast_load_realtime_multientry("queues", "name LIKE", "%", SENTINEL);
            if (queue_config) {
                char *category = NULL;
                while ((category = ast_category_browse(queue_config, category))) {
                    const char *name = ast_variable_retrieve(queue_config, category, "name");
                    if (ast_strlen_zero(name)) {
                        ast_log(LOG_WARNING, "Ignoring realtime queue with a NULL or empty 'name.'\n");
                        continue;
                    }
                    if ((q = find_load_queue_rt_friendly(name))) {
                        foundqueue++;
                        foundinterface += set_member_value_help_members(q, interface, property, value);
                        queue_unref(q);
                    }
                }
 
                ast_config_destroy(queue_config);
            }
        }
 
        /* After hitting realtime queues, go back and get the regular ones. */
        queue_iter = ao2_iterator_init(queues, 0);
        while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
            foundqueue++;
            foundinterface += set_member_value_help_members(q, interface, property, value);
            queue_unref(q);
        }
        ao2_iterator_destroy(&queue_iter);
    } else { /* We actually have a queuename, so we can just act on the single queue. */
        if ((q = find_load_queue_rt_friendly(queuename))) {
            foundqueue++;
            foundinterface += set_member_value_help_members(q, interface, property, value);
            queue_unref(q);
        }
    }
 
    if (foundinterface) {
        return RESULT_SUCCESS;
    } else if (!foundqueue) {
        ast_log (LOG_ERROR, "Invalid queuename\n");
    } else {
        ast_log (LOG_ERROR, "Invalid interface\n");
    }
 
    return RESULT_FAILURE;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_category_browse(), ast_check_realtime(), ast_config_destroy(), ast_load_realtime_multientry(), ast_log, ast_strlen_zero(), ast_variable_retrieve(), find_load_queue_rt_friendly(), LOG_ERROR, LOG_WARNING, MEMBER_PENALTY, name, negative_penalty_invalid, NULL, queue_unref, queues, RESULT_FAILURE, RESULT_SUCCESS, SENTINEL, set_member_value_help_members(), and value.

Referenced by handle_queue_set_member_penalty(), handle_queue_set_member_ringinuse(), manager_queue_member_penalty(), manager_queue_member_ringinuse(), queue_function_mem_write(), and queue_function_memberpenalty_write().

set_member_value_help_members()

static int set_member_value_help_members ( struct call_queue *  q, const char *  interface, int  property, int  value  )

static

Definition at line 8125 of file app_queue.c.

{
    switch(property) {
    case MEMBER_PENALTY:
        return set_member_penalty_help_members(q, interface, value);
 
    case MEMBER_RINGINUSE:
        return set_member_ringinuse_help_members(q, interface, value);
 
    default:
        ast_log(LOG_ERROR, "Attempted to set invalid property\n");
        return 0;
    }
}

References ast_log, member::interface, LOG_ERROR, MEMBER_PENALTY, MEMBER_RINGINUSE, set_member_penalty_help_members(), set_member_ringinuse_help_members(), and value.

Referenced by set_member_value().

set_queue_member_pause()

static void set_queue_member_pause ( struct call_queue *  q, struct member *  mem, const char *  reason, int  paused  )

static

Definition at line 7933 of file app_queue.c.

{
    if (mem->paused == paused) {
        ast_debug(1, "%spausing already-%spaused queue member %s:%s\n",
            (paused ? "" : "un"), (paused ? "" : "un"), q->name, mem->interface);
    }
 
    if (mem->realtime && !ast_strlen_zero(mem->rt_uniqueid)) {
        if (realtime_reason_paused) {
            if (ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, "reason_paused", S_OR(reason, ""), "paused", paused ? "1" : "0", SENTINEL) < 0) {
                ast_log(LOG_WARNING, "Failed update of realtime queue member %s:%s %spause and reason '%s'\n",
                    q->name, mem->interface, (paused ? "" : "un"), S_OR(reason, ""));
            }
        } else {
            if (ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, "paused", paused ? "1" : "0", SENTINEL) < 0) {
                ast_log(LOG_WARNING, "Failed %spause update of realtime queue member %s:%s\n",
                    (paused ? "" : "un"), q->name, mem->interface);
            }
        }
    }
 
    mem->paused = paused;
    if (paused) {
        time(&mem->lastpause); /* update last pause field */
    }
    if (paused && !ast_strlen_zero(reason)) {
        ast_copy_string(mem->reason_paused, reason, sizeof(mem->reason_paused));
    } else {
        /* We end up filling this in again later (temporarily) but we need it
         * empty for now so that the intervening code - specifically
         * dump_queue_members() - has the correct view of things. */
        mem->reason_paused[0] = '\0';
    }
 
    ast_devstate_changed(mem->paused ? QUEUE_PAUSED_DEVSTATE : QUEUE_UNPAUSED_DEVSTATE,
        AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", q->name, mem->interface);
 
    if (queue_persistent_members) {
        dump_queue_members(q);
    }
 
    if (is_member_available(q, mem)) {
        ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE,
            "Queue:%s_avail", q->name);
    } else if (!num_available_members(q)) {
        ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE,
            "Queue:%s_avail", q->name);
    }
 
    if (!paused && !ast_strlen_zero(reason)) {
        /* Because we've been unpaused with a 'reason' we need to ensure that
         * that reason is emitted when the subsequent PauseQueueMember event
         * is raised. So temporarily set it on the member and clear it out
         * again right after. */
        ast_copy_string(mem->reason_paused, reason, sizeof(mem->reason_paused));
    }
 
    ast_queue_log(q->name, "NONE", mem->membername, paused ? "PAUSE" : "UNPAUSE",
        "%s", mem->reason_paused);
 
    publish_queue_member_pause(q, mem);
 
    if (!paused) {
        mem->reason_paused[0] = '\0';
    }
}

References ast_copy_string(), ast_debug, AST_DEVICE_INUSE, AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_log, ast_queue_log(), ast_strlen_zero(), ast_update_realtime(), dump_queue_members(), member::interface, is_member_available(), member::lastpause, LOG_WARNING, member::membername, call_queue::name, num_available_members(), member::paused, publish_queue_member_pause(), QUEUE_PAUSED_DEVSTATE, queue_persistent_members, QUEUE_UNPAUSED_DEVSTATE, member::realtime, realtime_reason_paused, member::reason_paused, member::rt_uniqueid, S_OR, and SENTINEL.

Referenced by set_member_paused().

set_queue_member_ringinuse()

static void set_queue_member_ringinuse ( struct call_queue *  q, struct member *  mem, int  ringinuse  )

static

Definition at line 8096 of file app_queue.c.

{
    if (mem->realtime) {
        update_realtime_member_field(mem, q->name, realtime_ringinuse_field,
            ringinuse ? "1" : "0");
    }
 
    mem->ringinuse = ringinuse;
 
    ast_queue_log(q->name, "NONE", mem->interface, "RINGINUSE", "%d", ringinuse);
    queue_publish_member_blob(queue_member_ringinuse_type(), queue_member_blob_create(q, mem));
}

References ast_queue_log(), member::interface, call_queue::name, queue_member_blob_create(), queue_publish_member_blob(), member::realtime, realtime_ringinuse_field, member::ringinuse, and update_realtime_member_field().

Referenced by set_member_ringinuse_help_members().

set_queue_result()

static void set_queue_result ( struct ast_channel *  chan, enum queue_result  res  )

static

sets the QUEUESTATUS channel variable

Definition at line 2038 of file app_queue.c.

{
    int i;
 
    for (i = 0; i < ARRAY_LEN(queue_results); i++) {
        if (queue_results[i].id == res) {
            pbx_builtin_setvar_helper(chan, "QUEUESTATUS", queue_results[i].text);
            return;
        }
    }
}

References ARRAY_LEN, pbx_builtin_setvar_helper(), queue_results, and text.

Referenced by queue_exec().

set_queue_variables()

static void set_queue_variables ( struct call_queue *  q, struct ast_channel *  chan  )

static

Set variables of queue.

Definition at line 2191 of file app_queue.c.

{
    char interfacevar[256]="";
    float sl = 0;
 
    ao2_lock(q);
 
    if (q->setqueuevar) {
        sl = 0;
        if (q->callscompleted > 0) {
            sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
        }
 
        snprintf(interfacevar, sizeof(interfacevar),
            "QUEUENAME=%s,QUEUEMAX=%d,QUEUESTRATEGY=%s,QUEUECALLS=%d,QUEUEHOLDTIME=%d,QUEUETALKTIME=%d,QUEUECOMPLETED=%d,QUEUEABANDONED=%d,QUEUESRVLEVEL=%d,QUEUESRVLEVELPERF=%2.1f",
            q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted, q->callsabandoned,  q->servicelevel, sl);
 
        ao2_unlock(q);
 
        pbx_builtin_setvar_multiple(chan, interfacevar);
    } else {
        ao2_unlock(q);
    }
}

References ao2_lock, ao2_unlock, call_queue::callsabandoned, call_queue::callscompleted, call_queue::callscompletedinsl, call_queue::count, call_queue::holdtime, int2strat(), call_queue::maxlen, call_queue::name, pbx_builtin_setvar_multiple(), call_queue::servicelevel, call_queue::setqueuevar, call_queue::strategy, and call_queue::talktime.

Referenced by end_bridge_callback(), queue_exec(), record_abandoned(), and try_calling().

setup_mixmonitor()

static void setup_mixmonitor ( struct queue_ent *  qe, const char *  filename  )

static

Definition at line 7053 of file app_queue.c.

{
    char escaped_filename[256];
    char file_with_ext[sizeof(escaped_filename) + sizeof(qe->parent->monfmt)];
    char mixmonargs[1512];
    char escaped_monitor_exec[1024];
    const char *monitor_options;
    const char *monitor_exec;
 
    escaped_monitor_exec[0] = '\0';
 
    if (filename) {
        escape_and_substitute(qe->chan, filename, escaped_filename, sizeof(escaped_filename));
    } else {
        ast_copy_string(escaped_filename, ast_channel_uniqueid(qe->chan), sizeof(escaped_filename));
    }
 
    ast_channel_lock(qe->chan);
    if ((monitor_exec = pbx_builtin_getvar_helper(qe->chan, "MONITOR_EXEC"))) {
        monitor_exec = ast_strdupa(monitor_exec);
    }
    if ((monitor_options = pbx_builtin_getvar_helper(qe->chan, "MONITOR_OPTIONS"))) {
        monitor_options = ast_strdupa(monitor_options);
    } else {
        monitor_options = "";
    }
    ast_channel_unlock(qe->chan);
 
    if (monitor_exec) {
        escape_and_substitute(qe->chan, monitor_exec, escaped_monitor_exec, sizeof(escaped_monitor_exec));
    }
 
    snprintf(file_with_ext, sizeof(file_with_ext), "%s.%s", escaped_filename, qe->parent->monfmt);
 
    if (!ast_strlen_zero(escaped_monitor_exec)) {
        snprintf(mixmonargs, sizeof(mixmonargs), "b%s,%s", monitor_options, escaped_monitor_exec);
    } else {
        snprintf(mixmonargs, sizeof(mixmonargs), "b%s", monitor_options);
    }
 
    ast_debug(1, "Arguments being passed to MixMonitor: %s,%s\n", file_with_ext, mixmonargs);
 
    if (ast_start_mixmonitor(qe->chan, file_with_ext, mixmonargs)) {
        ast_log(LOG_WARNING, "Unable to start mixmonitor. Is the MixMonitor app loaded?\n");
    }
}

References ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, ast_copy_string(), ast_debug, ast_log, ast_start_mixmonitor(), ast_strdupa, ast_strlen_zero(), queue_ent::chan, escape_and_substitute(), LOG_WARNING, call_queue::monfmt, queue_ent::parent, and pbx_builtin_getvar_helper().

Referenced by try_calling().

setup_peer_after_bridge_goto()

static void setup_peer_after_bridge_goto ( struct ast_channel *  chan, struct ast_channel *  peer, struct ast_flags *  opts, char *  opt_args[]  )

static

Definition at line 7005 of file app_queue.c.

{
    const char *context;
    const char *extension;
    int priority;
 
    if (ast_test_flag(opts, OPT_CALLEE_GO_ON)) {
        ast_channel_lock(chan);
        context = ast_strdupa(ast_channel_context(chan));
        extension = ast_strdupa(ast_channel_exten(chan));
        priority = ast_channel_priority(chan);
        ast_channel_unlock(chan);
        ast_bridge_set_after_go_on(peer, context, extension, priority,
            opt_args[OPT_ARG_CALLEE_GO_ON]);
    }
}

References ast_bridge_set_after_go_on(), ast_channel_context(), ast_channel_exten(), ast_channel_lock, ast_channel_priority(), ast_channel_unlock, ast_strdupa, ast_test_flag, voicemailpwcheck::context, OPT_ARG_CALLEE_GO_ON, OPT_CALLEE_GO_ON, and priority.

Referenced by try_calling().

setup_stasis_subs()

static int setup_stasis_subs ( struct queue_ent *  qe, struct ast_channel *  peer, struct member *  mem, time_t  holdstart, time_t  starttime, int  callcompletedinsl  )

static

Definition at line 6921 of file app_queue.c.

{
    struct queue_stasis_data *queue_data = queue_stasis_data_alloc(qe, peer, mem, holdstart, starttime, callcompletedinsl);
 
    if (!queue_data) {
        return -1;
    }
 
    queue_data->bridge_router = stasis_message_router_create_pool(ast_bridge_topic_all());
    if (!queue_data->bridge_router) {
        ao2_ref(queue_data, -1);
        return -1;
    }
 
    stasis_message_router_add(queue_data->bridge_router, ast_channel_entered_bridge_type(),
            handle_bridge_enter, queue_data);
    stasis_message_router_add(queue_data->bridge_router, ast_blind_transfer_type(),
            handle_blind_transfer, queue_data);
    stasis_message_router_add(queue_data->bridge_router, ast_attended_transfer_type(),
            handle_attended_transfer, queue_data);
    stasis_message_router_set_default(queue_data->bridge_router,
            queue_bridge_cb, queue_data);
 
    queue_data->channel_router = stasis_message_router_create_pool(ast_channel_topic_all());
    if (!queue_data->channel_router) {
        /* Unsubscribing from the bridge router will remove the only ref of queue_data,
         * thus beginning the destruction process
         */
        stasis_message_router_unsubscribe(queue_data->bridge_router);
        queue_data->bridge_router = NULL;
        return -1;
    }
 
    ao2_ref(queue_data, +1);
    stasis_message_router_add(queue_data->channel_router, ast_local_optimization_begin_type(),
            handle_local_optimization_begin, queue_data);
    stasis_message_router_add(queue_data->channel_router, ast_local_optimization_end_type(),
            handle_local_optimization_end, queue_data);
    stasis_message_router_add(queue_data->channel_router, ast_channel_hangup_request_type(),
            handle_hangup, queue_data);
    stasis_message_router_add(queue_data->channel_router, ast_channel_masquerade_type(),
            handle_masquerade, queue_data);
    stasis_message_router_set_default(queue_data->channel_router,
            queue_channel_cb, queue_data);
 
    return 0;
}

References ao2_ref, ast_attended_transfer_type(), ast_blind_transfer_type(), ast_bridge_topic_all(), ast_channel_entered_bridge_type(), ast_channel_hangup_request_type(), ast_channel_masquerade_type(), ast_channel_topic_all(), ast_local_optimization_begin_type(), ast_local_optimization_end_type(), queue_stasis_data::bridge_router, queue_stasis_data::callcompletedinsl, queue_stasis_data::channel_router, handle_attended_transfer(), handle_blind_transfer(), handle_bridge_enter(), handle_hangup(), handle_local_optimization_begin(), handle_local_optimization_end(), handle_masquerade(), queue_stasis_data::holdstart, NULL, queue_bridge_cb(), queue_channel_cb(), queue_stasis_data_alloc(), queue_stasis_data::starttime, stasis_message_router_add(), stasis_message_router_create_pool, stasis_message_router_set_default(), and stasis_message_router_unsubscribe().

Referenced by try_calling().

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [1/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_agent_called_type	,
		.	to_ami = queue_agent_called_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [2/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_agent_complete_type	,
		.	to_ami = queue_agent_complete_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [3/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_agent_connect_type	,
		.	to_ami = queue_agent_connect_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [4/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_agent_dump_type	,
		.	to_ami = queue_agent_dump_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [5/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_agent_ringnoanswer_type	,
		.	to_ami = queue_agent_ringnoanswer_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [6/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_caller_abandon_type	,
		.	to_ami = queue_caller_abandon_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [7/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_caller_join_type	,
		.	to_ami = queue_caller_join_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [8/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_caller_leave_type	,
		.	to_ami = queue_caller_leave_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [9/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_added_type	,
		.	to_ami = queue_member_added_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [10/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_pause_type	,
		.	to_ami = queue_member_pause_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [11/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_penalty_type	,
		.	to_ami = queue_member_penalty_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [12/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_removed_type	,
		.	to_ami = queue_member_removed_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [13/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_ringinuse_type	,
		.	to_ami = queue_member_ringinuse_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [14/14]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	queue_member_status_type	,
		.	to_ami = queue_member_status_to_ami
	)

store_next_lin()

static int store_next_lin ( struct queue_ent *  qe, struct callattempt *  outgoing  )

static

Search for best metric and add to Linear queue.

Definition at line 5142 of file app_queue.c.

{
    struct callattempt *best = find_best(outgoing);
 
    if (best) {
        /* Ring just the best channel */
        ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
        qe->linpos = best->metric % 1000;
    } else {
        /* Just increment rrpos */
        if (qe->linwrapped) {
            /* No more channels, start over */
            qe->linpos = 0;
        } else {
            /* Prioritize next entry */
            qe->linpos++;
        }
    }
    qe->linwrapped = 0;
 
    return 0;
}

References ast_debug, find_best(), callattempt::interface, queue_ent::linpos, queue_ent::linwrapped, and callattempt::metric.

Referenced by try_calling().

store_next_rr()

static int store_next_rr ( struct queue_ent *  qe, struct callattempt *  outgoing  )

static

Search for best metric and add to Round Robbin queue.

Definition at line 5118 of file app_queue.c.

{
    struct callattempt *best = find_best(outgoing);
 
    if (best) {
        /* Ring just the best channel */
        ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
        qe->parent->rrpos = best->metric % 1000;
    } else {
        /* Just increment rrpos */
        if (qe->parent->wrapped) {
            /* No more channels, start over */
            qe->parent->rrpos = 0;
        } else {
            /* Prioritize next entry */
            qe->parent->rrpos++;
        }
    }
    qe->parent->wrapped = 0;
 
    return 0;
}

References ast_debug, find_best(), callattempt::interface, callattempt::metric, queue_ent::parent, call_queue::rrpos, and call_queue::wrapped.

Referenced by try_calling().

strat2int()

static int strat2int ( const char *  strategy )

static

Definition at line 2063 of file app_queue.c.

{
    int x;
 
    for (x = 0; x < ARRAY_LEN(strategies); x++) {
        if (!strcasecmp(strategy, strategies[x].name)) {
            return strategies[x].strategy;
        }
    }
 
    return -1;
}

References ARRAY_LEN, name, strategies, and strategy::strategy.

Referenced by find_queue_by_name_rt(), queue_set_param(), and reload_single_queue().

try_calling()

static int try_calling ( struct queue_ent *  qe, struct ast_flags  opts, char **  opt_args, char *  announceoverride, const char *  url, int *  tries, int *  noption, const char *  agi, const char *  gosub, int  ringing  )

static

Definition at line 7126 of file app_queue.c.

{
    struct member *cur;
    struct callattempt *outgoing = NULL; /* the list of calls we are building */
    int to, orig;
    char oldexten[AST_MAX_EXTENSION]="";
    char oldcontext[AST_MAX_CONTEXT]="";
    char queuename[256]="";
    struct ast_channel *peer;
    struct callattempt *lpeer;
    struct member *member;
    struct ast_app *application;
    int res = 0, bridge = 0;
    int numbusies = 0;
    int x=0;
    char *announce = NULL;
    char digit = 0;
    time_t now = time(NULL);
    struct ast_bridge_config bridge_config;
    char nondataquality = 1;
    char *agiexec = NULL;
    char *gosubexec = NULL;
    const char *monitorfilename;
    int forwardsallowed = 1;
    int block_connected_line = 0;
    struct ao2_iterator memi;
    struct queue_end_bridge *queue_end_bridge = NULL;
    int callcompletedinsl;
    time_t starttime;
 
    memset(&bridge_config, 0, sizeof(bridge_config));
    time(&now);
 
    /* If we've already exceeded our timeout, then just stop
     * This should be extremely rare. queue_exec will take care
     * of removing the caller and reporting the timeout as the reason.
     */
    if (qe->expire && now >= qe->expire) {
        res = 0;
        goto out;
    }
 
    if (ast_test_flag(&opts, OPT_CALLEE_TRANSFER)) {
        ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_REDIRECT);
    }
    if (ast_test_flag(&opts, OPT_CALLER_TRANSFER)) {
        ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_REDIRECT);
    }
    if (ast_test_flag(&opts, OPT_CALLEE_AUTOMON)) {
        ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_AUTOMON);
    }
    if (ast_test_flag(&opts, OPT_CALLER_AUTOMON)) {
        ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_AUTOMON);
    }
    if (ast_test_flag(&opts, OPT_DATA_QUALITY)) {
        nondataquality = 0;
    }
    if (ast_test_flag(&opts, OPT_CALLEE_HANGUP)) {
        ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_DISCONNECT);
    }
    if (ast_test_flag(&opts, OPT_CALLER_HANGUP)) {
        ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_DISCONNECT);
    }
    if (ast_test_flag(&opts, OPT_CALLEE_PARK)) {
        ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_PARKCALL);
    }
    if (ast_test_flag(&opts, OPT_CALLER_PARK)) {
        ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_PARKCALL);
    }
    if (ast_test_flag(&opts, OPT_NO_RETRY)) {
        if (qe->parent->strategy == QUEUE_STRATEGY_RRMEMORY || qe->parent->strategy == QUEUE_STRATEGY_LINEAR
            || qe->parent->strategy == QUEUE_STRATEGY_RRORDERED) {
            (*tries)++;
        } else {
            *tries = ao2_container_count(qe->parent->members);
        }
        *noption = 1;
    }
    if (ast_test_flag(&opts, OPT_IGNORE_CALL_FW)) {
        forwardsallowed = 0;
    }
    if (ast_test_flag(&opts, OPT_IGNORE_CONNECTEDLINE)) {
        block_connected_line = 1;
    }
    if (ast_test_flag(&opts, OPT_CALLEE_AUTOMIXMON)) {
        ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_AUTOMIXMON);
    }
    if (ast_test_flag(&opts, OPT_CALLER_AUTOMIXMON)) {
        ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_AUTOMIXMON);
    }
    if (ast_test_flag(&opts, OPT_MARK_AS_ANSWERED)) {
        qe->cancel_answered_elsewhere = 1;
    }
 
    /* if the calling channel has AST_CAUSE_ANSWERED_ELSEWHERE set, make sure this is inherited.
        (this is mainly to support unreal/local channels)
    */
    if (ast_channel_hangupcause(qe->chan) == AST_CAUSE_ANSWERED_ELSEWHERE) {
        qe->cancel_answered_elsewhere = 1;
    }
 
    ao2_lock(qe->parent);
    ast_debug(1, "%s is trying to call a queue member.\n",
                            ast_channel_name(qe->chan));
    ast_copy_string(queuename, qe->parent->name, sizeof(queuename));
    if (!ast_strlen_zero(qe->announce)) {
        announce = qe->announce;
    }
    if (!ast_strlen_zero(announceoverride)) {
        announce = announceoverride;
    }
 
    memi = ao2_iterator_init(qe->parent->members, 0);
    while ((cur = ao2_iterator_next(&memi))) {
        struct callattempt *tmp = ast_calloc(1, sizeof(*tmp));
        if (!tmp) {
            ao2_ref(cur, -1);
            ao2_iterator_destroy(&memi);
            ao2_unlock(qe->parent);
            goto out;
        }
 
        /*
         * Seed the callattempt's connected line information with previously
         * acquired connected line info from the queued channel.  The
         * previously acquired connected line info could have been set
         * through the CONNECTED_LINE dialplan function.
         */
        ast_channel_lock(qe->chan);
        ast_party_connected_line_copy(&tmp->connected, ast_channel_connected(qe->chan));
        ast_channel_unlock(qe->chan);
 
        tmp->block_connected_update = block_connected_line;
        tmp->stillgoing = 1;
        tmp->member = cur; /* Place the reference for cur into callattempt. */
        ast_copy_string(tmp->interface, cur->interface, sizeof(tmp->interface));
        /* Calculate the metric for the appropriate strategy. */
        if (!calc_metric(qe->parent, cur, x++, qe, tmp)) {
            /* Put them in the list of outgoing thingies...  We're ready now.
               XXX If we're forcibly removed, these outgoing calls won't get
               hung up XXX */
            tmp->q_next = outgoing;
            outgoing = tmp;
        } else {
            callattempt_free(tmp);
        }
    }
    ao2_iterator_destroy(&memi);
 
    if (qe->parent->timeoutpriority == TIMEOUT_PRIORITY_APP) {
        /* Application arguments have higher timeout priority (behaviour for <=1.6) */
        if (qe->expire && (!qe->parent->timeout || (qe->expire - now) <= qe->parent->timeout)) {
            to = (qe->expire - now) * 1000;
        } else {
            to = (qe->parent->timeout) ? qe->parent->timeout * 1000 : -1;
        }
    } else {
        /* Config timeout is higher priority thatn application timeout */
        if (qe->expire && qe->expire<=now) {
            to = 0;
        } else if (qe->parent->timeout) {
            to = qe->parent->timeout * 1000;
        } else {
            to = -1;
        }
    }
    orig = to;
    ++qe->pending;
    ao2_unlock(qe->parent);
    /* Call the queue members with the best metric now. */
    ring_one(qe, outgoing, &numbusies);
    lpeer = wait_for_answer(qe, outgoing, &to, &digit, numbusies,
        ast_test_flag(&(bridge_config.features_caller), AST_FEATURE_DISCONNECT),
        forwardsallowed);
 
    ao2_lock(qe->parent);
    if (qe->parent->strategy == QUEUE_STRATEGY_RRMEMORY || qe->parent->strategy == QUEUE_STRATEGY_RRORDERED) {
        store_next_rr(qe, outgoing);
 
    }
    if (qe->parent->strategy == QUEUE_STRATEGY_LINEAR) {
        store_next_lin(qe, outgoing);
    }
    ao2_unlock(qe->parent);
    peer = lpeer ? lpeer->chan : NULL;
    if (!peer) {
        qe->pending = 0;
        if (to) {
            /* Must gotten hung up */
            res = -1;
        } else {
            /* User exited by pressing a digit */
            res = digit;
        }
        if (res == -1) {
            ast_debug(1, "%s: Nobody answered.\n", ast_channel_name(qe->chan));
        }
    } else { /* peer is valid */
        RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
        RAII_VAR(struct ast_str *, interfacevar, ast_str_create(325), ast_free);
        /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
           we will always return with -1 so that it is hung up properly after the
           conversation.  */
        if (!strcmp(ast_channel_tech(qe->chan)->type, "DAHDI")) {
            ast_channel_setoption(qe->chan, AST_OPTION_TONE_VERIFY, &nondataquality, sizeof(nondataquality), 0);
        }
        if (!strcmp(ast_channel_tech(peer)->type, "DAHDI")) {
            ast_channel_setoption(peer, AST_OPTION_TONE_VERIFY, &nondataquality, sizeof(nondataquality), 0);
        }
        /* Update parameters for the queue */
        time(&now);
        recalc_holdtime(qe, (now - qe->start));
        member = lpeer->member;
        ao2_lock(qe->parent);
        callcompletedinsl = member->callcompletedinsl = ((now - qe->start) <= qe->parent->servicelevel);
        ao2_unlock(qe->parent);
        /* Increment the refcount for this member, since we're going to be using it for awhile in here. */
        ao2_ref(member, 1);
        hangupcalls(qe, outgoing, peer, qe->cancel_answered_elsewhere);
        outgoing = NULL;
        if (announce || qe->parent->reportholdtime || qe->parent->memberdelay) {
            int res2;
 
            res2 = ast_autoservice_start(qe->chan);
            if (!res2) {
                if (qe->parent->memberdelay) {
                    ast_log(LOG_NOTICE, "Delaying member connect for %d seconds\n", qe->parent->memberdelay);
                    res2 = ast_safe_sleep(peer, qe->parent->memberdelay * 1000);
                }
                if (!res2 && announce) {
                    char *front;
                    char *announcefiles = ast_strdupa(announce);
                    while ((front = ast_strsep(&announcefiles, '&', AST_STRSEP_STRIP | AST_STRSEP_TRIM))) {
                        if (play_file(peer, front) < 0) {
                            ast_log(LOG_ERROR, "play_file failed for '%s' on %s\n", front, ast_channel_name(peer));
                        }
                    }
                }
                if (!res2 && qe->parent->reportholdtime) {
                    if (!play_file(peer, qe->parent->sound_reporthold)) {
                        long holdtime, holdtimesecs;
 
                        time(&now);
                        holdtime = labs((now - qe->start) / 60);
                        holdtimesecs = labs((now - qe->start) % 60);
                        if (holdtime > 0) {
                            ast_say_number(peer, holdtime, AST_DIGIT_ANY, ast_channel_language(peer), "n");
                            if (play_file(peer, qe->parent->sound_minutes) < 0) {
                                ast_log(LOG_ERROR, "play_file failed for '%s' on %s\n", qe->parent->sound_minutes, ast_channel_name(peer));
                            }
                        }
                        if (holdtimesecs > 1) {
                            ast_say_number(peer, holdtimesecs, AST_DIGIT_ANY, ast_channel_language(peer), "n");
                            if (play_file(peer, qe->parent->sound_seconds) < 0) {
                                ast_log(LOG_ERROR, "play_file failed for '%s' on %s\n", qe->parent->sound_seconds, ast_channel_name(peer));
                            }
                        }
                    }
                }
                ast_autoservice_stop(qe->chan);
            }
            if (ast_check_hangup(peer)) {
                /* Agent must have hung up */
                ast_log(LOG_WARNING, "Agent on %s hungup on the customer.\n", ast_channel_name(peer));
                ast_queue_log(queuename, ast_channel_uniqueid(qe->chan), member->membername, "AGENTDUMP", "%s", "");
 
                blob = ast_json_pack("{s: s, s: s, s: s}",
                             "Queue", queuename,
                             "Interface", member->interface,
                             "MemberName", member->membername);
                queue_publish_multi_channel_blob(qe->chan, peer, queue_agent_dump_type(), blob);
 
                ast_channel_publish_dial(qe->chan, peer, member->interface, ast_hangup_cause_to_dial_status(ast_channel_hangupcause(peer)));
                ast_autoservice_chan_hangup_peer(qe->chan, peer);
                pending_members_remove(member);
                ao2_ref(member, -1);
                goto out;
            } else if (ast_check_hangup(qe->chan)) {
                /* Caller must have hung up just before being connected */
                ast_log(LOG_NOTICE, "Caller was about to talk to agent on %s but the caller hungup.\n", ast_channel_name(peer));
                ast_queue_log(queuename, ast_channel_uniqueid(qe->chan), member->membername, "ABANDON", "%d|%d|%ld", qe->pos, qe->opos, (long) (time(NULL) - qe->start));
                record_abandoned(qe);
                qe->handled = -1;
                ast_channel_publish_dial(qe->chan, peer, member->interface, ast_hangup_cause_to_dial_status(ast_channel_hangupcause(peer)));
                ast_autoservice_chan_hangup_peer(qe->chan, peer);
                pending_members_remove(member);
                ao2_ref(member, -1);
                return -1;
            }
        }
        /* Stop music on hold */
        if (ringing) {
            ast_indicate(qe->chan,-1);
        } else {
            ast_moh_stop(qe->chan);
        }
 
        /* Make sure channels are compatible */
        res = ast_channel_make_compatible(qe->chan, peer);
        if (res < 0) {
            ast_queue_log(queuename, ast_channel_uniqueid(qe->chan), member->membername, "SYSCOMPAT", "%s", "");
            ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", ast_channel_name(qe->chan), ast_channel_name(peer));
            record_abandoned(qe);
            ast_channel_publish_dial(qe->chan, peer, member->interface, ast_hangup_cause_to_dial_status(ast_channel_hangupcause(peer)));
            ast_autoservice_chan_hangup_peer(qe->chan, peer);
            pending_members_remove(member);
            ao2_ref(member, -1);
            return -1;
        }
 
        /* Play announcement to the caller telling it's his turn if defined */
        if (!ast_strlen_zero(qe->parent->sound_callerannounce)) {
            if (play_file(qe->chan, qe->parent->sound_callerannounce)) {
                ast_log(LOG_WARNING, "Announcement file '%s' is unavailable, continuing anyway...\n", qe->parent->sound_callerannounce);
            }
        }
 
        ao2_lock(qe->parent);
        /* if setinterfacevar is defined, make member variables available to the channel */
        /* use  pbx_builtin_setvar to set a load of variables with one call */
        if (qe->parent->setinterfacevar && interfacevar) {
            ast_str_set(&interfacevar, 0, "MEMBERINTERFACE=%s,MEMBERNAME=%s,MEMBERCALLS=%d,MEMBERLASTCALL=%ld,MEMBERPENALTY=%d,MEMBERDYNAMIC=%d,MEMBERREALTIME=%d",
                member->interface, member->membername, member->calls, (long)member->lastcall, member->penalty, member->dynamic, member->realtime);
            pbx_builtin_setvar_multiple(qe->chan, ast_str_buffer(interfacevar));
            pbx_builtin_setvar_multiple(peer, ast_str_buffer(interfacevar));
        }
 
        /* if setqueueentryvar is defined, make queue entry (i.e. the caller) variables available to the channel */
        /* use  pbx_builtin_setvar to set a load of variables with one call */
        if (qe->parent->setqueueentryvar && interfacevar) {
            ast_str_set(&interfacevar, 0, "QEHOLDTIME=%ld,QEORIGINALPOS=%d",
                (long) (time(NULL) - qe->start), qe->opos);
            pbx_builtin_setvar_multiple(qe->chan, ast_str_buffer(interfacevar));
            pbx_builtin_setvar_multiple(peer, ast_str_buffer(interfacevar));
        }
 
        ao2_unlock(qe->parent);
 
        /* try to set queue variables if configured to do so*/
        set_queue_variables(qe->parent, qe->chan);
        set_queue_variables(qe->parent, peer);
 
        setup_peer_after_bridge_goto(qe->chan, peer, &opts, opt_args);
        ast_channel_lock(qe->chan);
        if ((monitorfilename = pbx_builtin_getvar_helper(qe->chan, "MONITOR_FILENAME"))) {
                monitorfilename = ast_strdupa(monitorfilename);
        }
        ast_channel_unlock(qe->chan);
 
        /* Begin Monitoring */
        if (*qe->parent->monfmt) {
            setup_mixmonitor(qe, monitorfilename);
        }
        /* Drop out of the queue at this point, to prepare for next caller */
        leave_queue(qe);
        if (!ast_strlen_zero(url) && ast_channel_supports_html(peer)) {
            ast_debug(1, "app_queue: sendurl=%s.\n", url);
            ast_channel_sendurl(peer, url);
        }
 
        /* run a gosub for this connection if defined. The gosub simply returns, no action is taken on the result */
        /* use gosub from dialplan if passed as a option, otherwise use the default queue gosub */
        if (!ast_strlen_zero(gosub)) {
            gosubexec = ast_strdupa(gosub);
        } else {
            if (qe->parent->membergosub) {
                gosubexec = ast_strdupa(qe->parent->membergosub);
            }
        }
 
        if (!ast_strlen_zero(gosubexec)) {
            char *gosub_args = NULL;
            char *gosub_argstart;
 
            ast_debug(1, "app_queue: gosub=%s.\n", gosubexec);
 
            gosub_argstart = strchr(gosubexec, ',');
            if (gosub_argstart) {
                const char *what_is_s = "s";
                *gosub_argstart = 0;
                if (!ast_exists_extension(peer, gosubexec, "s", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL)) &&
                     ast_exists_extension(peer, gosubexec, "~~s~~", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL))) {
                    what_is_s = "~~s~~";
                }
                if (ast_asprintf(&gosub_args, "%s,%s,1(%s)", gosubexec, what_is_s, gosub_argstart + 1) < 0) {
                    gosub_args = NULL;
                }
                *gosub_argstart = ',';
            } else {
                const char *what_is_s = "s";
                if (!ast_exists_extension(peer, gosubexec, "s", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL)) &&
                     ast_exists_extension(peer, gosubexec, "~~s~~", 1, S_COR(ast_channel_caller(peer)->id.number.valid, ast_channel_caller(peer)->id.number.str, NULL))) {
                    what_is_s = "~~s~~";
                }
                if (ast_asprintf(&gosub_args, "%s,%s,1", gosubexec, what_is_s) < 0) {
                    gosub_args = NULL;
                }
            }
            if (gosub_args) {
                ast_app_exec_sub(qe->chan, peer, gosub_args, 0);
                ast_free(gosub_args);
            } else {
                ast_log(LOG_ERROR, "Could not Allocate string for Gosub arguments -- Gosub Call Aborted!\n");
            }
        }
 
        if (!ast_strlen_zero(agi)) {
            ast_debug(1, "app_queue: agi=%s.\n", agi);
            application = pbx_findapp("agi");
            if (application) {
                agiexec = ast_strdupa(agi);
                pbx_exec(qe->chan, application, agiexec);
            } else {
                ast_log(LOG_WARNING, "Asked to execute an AGI on this channel, but could not find application (agi)!\n");
            }
        }
        qe->handled++;
 
        ast_queue_log(queuename, ast_channel_uniqueid(qe->chan), member->membername, "CONNECT", "%ld|%s|%ld", (long) (time(NULL) - qe->start), ast_channel_uniqueid(peer),
                                                    (long)(orig - to > 0 ? (orig - to) / 1000 : 0));
 
        blob = ast_json_pack("{s: s, s: s, s: s, s: I, s: I}",
                     "Queue", queuename,
                     "Interface", member->interface,
                     "MemberName", member->membername,
                     "HoldTime", (ast_json_int_t)(time(NULL) - qe->start),
                     "RingTime", (ast_json_int_t)(orig - to > 0 ? (orig - to) / 1000 : 0));
        queue_publish_multi_channel_blob(qe->chan, peer, queue_agent_connect_type(), blob);
 
        ast_copy_string(oldcontext, ast_channel_context(qe->chan), sizeof(oldcontext));
        ast_copy_string(oldexten, ast_channel_exten(qe->chan), sizeof(oldexten));
 
        if ((queue_end_bridge = ao2_alloc(sizeof(*queue_end_bridge), NULL))) {
            queue_end_bridge->q = qe->parent;
            queue_end_bridge->chan = qe->chan;
            bridge_config.end_bridge_callback = end_bridge_callback;
            bridge_config.end_bridge_callback_data = queue_end_bridge;
            bridge_config.end_bridge_callback_data_fixup = end_bridge_callback_data_fixup;
            /* Since queue_end_bridge can survive beyond the life of this call to Queue, we need
             * to make sure to increase the refcount of this queue so it cannot be freed until we
             * are done with it. We remove this reference in end_bridge_callback.
             */
            queue_t_ref(qe->parent, "For bridge_config reference");
        }
 
        ao2_lock(qe->parent);
        time(&member->starttime);
        starttime = member->starttime;
        ao2_unlock(qe->parent);
        /* As a queue member may end up in multiple calls at once if a transfer occurs with
         * a Local channel in the mix we pass the current call information (starttime) to the
         * Stasis subscriptions so when they update the queue member data it becomes a noop
         * if this call is no longer between the caller and the queue member.
         */
        setup_stasis_subs(qe, peer, member, qe->start, starttime, callcompletedinsl);
        bridge = ast_bridge_call_with_flags(qe->chan, peer, &bridge_config,
                AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM | AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM);
 
        res = bridge ? bridge : 1;
        ao2_ref(member, -1);
    }
out:
    hangupcalls(qe, outgoing, NULL, qe->cancel_answered_elsewhere);
 
    return res;
}

References queue_ent::announce, ao2_alloc, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_app_exec_sub(), ast_asprintf, ast_autoservice_chan_hangup_peer(), ast_autoservice_start(), ast_autoservice_stop(), ast_bridge_call_with_flags(), AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, ast_calloc, AST_CAUSE_ANSWERED_ELSEWHERE, ast_channel_caller(), ast_channel_connected(), ast_channel_context(), ast_channel_exten(), ast_channel_hangupcause(), ast_channel_language(), ast_channel_lock, ast_channel_make_compatible(), ast_channel_name(), ast_channel_publish_dial(), ast_channel_sendurl(), ast_channel_setoption(), ast_channel_supports_html(), ast_channel_tech(), ast_channel_uniqueid(), ast_channel_unlock, ast_check_hangup(), ast_copy_string(), ast_debug, AST_DIGIT_ANY, ast_exists_extension(), AST_FEATURE_AUTOMIXMON, AST_FEATURE_AUTOMON, AST_FEATURE_DISCONNECT, AST_FEATURE_PARKCALL, AST_FEATURE_REDIRECT, ast_free, ast_hangup_cause_to_dial_status(), ast_indicate(), ast_json_pack(), ast_json_unref(), ast_log, AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_moh_stop(), AST_OPTION_TONE_VERIFY, ast_party_connected_line_copy(), ast_queue_log(), ast_safe_sleep(), ast_say_number(), ast_set_flag, ast_str_buffer(), ast_str_create, ast_str_set(), ast_strdupa, ast_strlen_zero(), ast_strsep(), AST_STRSEP_STRIP, AST_STRSEP_TRIM, ast_test_flag, callattempt::block_connected_update, calc_metric(), callattempt_free(), member::callcompletedinsl, member::calls, queue_ent::cancel_answered_elsewhere, callattempt::chan, queue_ent::chan, queue_end_bridge::chan, callattempt::connected, digit, member::dynamic, end_bridge_callback(), ast_bridge_config::end_bridge_callback, ast_bridge_config::end_bridge_callback_data, end_bridge_callback_data_fixup(), ast_bridge_config::end_bridge_callback_data_fixup, queue_ent::expire, ast_bridge_config::features_callee, ast_bridge_config::features_caller, queue_ent::handled, hangupcalls(), callattempt::interface, member::interface, member::lastcall, leave_queue(), LOG_ERROR, LOG_NOTICE, LOG_WARNING, callattempt::member, call_queue::memberdelay, call_queue::membergosub, member::membername, call_queue::members, call_queue::monfmt, call_queue::name, NULL, queue_ent::opos, OPT_CALLEE_AUTOMIXMON, OPT_CALLEE_AUTOMON, OPT_CALLEE_HANGUP, OPT_CALLEE_PARK, OPT_CALLEE_TRANSFER, OPT_CALLER_AUTOMIXMON, OPT_CALLER_AUTOMON, OPT_CALLER_HANGUP, OPT_CALLER_PARK, OPT_CALLER_TRANSFER, OPT_DATA_QUALITY, OPT_IGNORE_CALL_FW, OPT_IGNORE_CONNECTEDLINE, OPT_MARK_AS_ANSWERED, OPT_NO_RETRY, out, queue_ent::parent, pbx_builtin_getvar_helper(), pbx_builtin_setvar_multiple(), pbx_exec(), pbx_findapp(), member::penalty, queue_ent::pending, pending_members_remove(), play_file(), queue_ent::pos, queue_end_bridge::q, callattempt::q_next, queue_publish_multi_channel_blob(), QUEUE_STRATEGY_LINEAR, QUEUE_STRATEGY_RRMEMORY, QUEUE_STRATEGY_RRORDERED, queue_t_ref, RAII_VAR, member::realtime, recalc_holdtime(), record_abandoned(), call_queue::reportholdtime, ring_one(), ringing(), S_COR, call_queue::servicelevel, set_queue_variables(), call_queue::setinterfacevar, call_queue::setqueueentryvar, setup_mixmonitor(), setup_peer_after_bridge_goto(), setup_stasis_subs(), call_queue::sound_callerannounce, call_queue::sound_minutes, call_queue::sound_reporthold, call_queue::sound_seconds, queue_ent::start, member::starttime, callattempt::stillgoing, store_next_lin(), store_next_rr(), call_queue::strategy, call_queue::timeout, TIMEOUT_PRIORITY_APP, call_queue::timeoutpriority, type, ast_channel_tech::type, url, and wait_for_answer().

Referenced by queue_exec().

unload_module()

static int unload_module ( void  )

static

Definition at line 11856 of file app_queue.c.

{
    stasis_message_router_unsubscribe_and_join(agent_router);
    agent_router = NULL;
 
    topic_forwarder = stasis_forward_cancel(topic_forwarder);
 
    STASIS_MESSAGE_TYPE_CLEANUP(queue_caller_join_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_caller_leave_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_caller_abandon_type);
 
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_status_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_added_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_removed_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_pause_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_penalty_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_member_ringinuse_type);
 
    STASIS_MESSAGE_TYPE_CLEANUP(queue_agent_called_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_agent_connect_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_agent_complete_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_agent_dump_type);
    STASIS_MESSAGE_TYPE_CLEANUP(queue_agent_ringnoanswer_type);
 
    ast_cli_unregister_multiple(cli_queue, ARRAY_LEN(cli_queue));
    ast_manager_unregister("QueueStatus");
    ast_manager_unregister("QueueRule");
    ast_manager_unregister("QueueSummary");
    ast_manager_unregister("QueueAdd");
    ast_manager_unregister("QueueRemove");
    ast_manager_unregister("QueuePause");
    ast_manager_unregister("QueueLog");
    ast_manager_unregister("QueueUpdate");
    ast_manager_unregister("QueuePenalty");
    ast_manager_unregister("QueueReload");
    ast_manager_unregister("QueueReset");
    ast_manager_unregister("QueueMemberRingInUse");
    ast_manager_unregister("QueueChangePriorityCaller");
    ast_manager_unregister("QueueWithdrawCaller");
    ast_unregister_application(app_aqm);
    ast_unregister_application(app_rqm);
    ast_unregister_application(app_pqm);
    ast_unregister_application(app_upqm);
    ast_unregister_application(app_ql);
    ast_unregister_application(app_qupd);
    ast_unregister_application(app);
    ast_custom_function_unregister(&queueexists_function);
    ast_custom_function_unregister(&queuevar_function);
    ast_custom_function_unregister(&queuemembercount_function);
    ast_custom_function_unregister(&queuememberlist_function);
    ast_custom_function_unregister(&queuegetchannel_function);
    ast_custom_function_unregister(&queuewaitingcount_function);
    ast_custom_function_unregister(&queuememberpenalty_function);
 
    device_state_sub = stasis_unsubscribe_and_join(device_state_sub);
 
    ast_unload_realtime("queue_members");
    ao2_cleanup(queues);
    ao2_cleanup(pending_members);
 
    queues = NULL;
    return 0;
}

References agent_router, ao2_cleanup, app, app_aqm, app_pqm, app_ql, app_qupd, app_rqm, app_upqm, ARRAY_LEN, ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_manager_unregister(), ast_unload_realtime(), ast_unregister_application(), cli_queue, device_state_sub, NULL, pending_members, queueexists_function, queuegetchannel_function, queuemembercount_function, queuememberlist_function, queuememberpenalty_function, queues, queuevar_function, queuewaitingcount_function, stasis_forward_cancel(), stasis_message_router_unsubscribe_and_join(), STASIS_MESSAGE_TYPE_CLEANUP, stasis_unsubscribe_and_join(), and topic_forwarder.

Referenced by load_module().

update_connected_line_from_peer()

static void update_connected_line_from_peer ( struct ast_channel *  chan, struct ast_channel *  peer, int  is_caller  )

static

Definition at line 5323 of file app_queue.c.

{
    struct ast_party_connected_line connected_caller;
 
    ast_party_connected_line_init(&connected_caller);
 
    ast_channel_lock(peer);
    ast_connected_line_copy_from_caller(&connected_caller, ast_channel_caller(peer));
    ast_channel_unlock(peer);
    connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
    if (ast_channel_connected_line_sub(peer, chan, &connected_caller, 0)) {
        ast_channel_update_connected_line(chan, &connected_caller, NULL);
    }
    ast_party_connected_line_free(&connected_caller);
}

References ast_channel_caller(), ast_channel_connected_line_sub(), ast_channel_lock, ast_channel_unlock, ast_channel_update_connected_line(), ast_connected_line_copy_from_caller(), AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER, ast_party_connected_line_free(), ast_party_connected_line_init(), NULL, and ast_party_connected_line::source.

Referenced by wait_for_answer().

update_qe_rule()

static void update_qe_rule ( struct queue_ent *  qe )

static

update rules for queues

Calculate min/max penalties making sure if relative they stay within bounds. Update queues penalty and set dialplan vars, goto next list entry.

Definition at line 5942 of file app_queue.c.

{
    int max_penalty = INT_MAX;
 
    if (qe->max_penalty != INT_MAX) {
        char max_penalty_str[20];
 
        if (qe->pr->max_relative) {
            max_penalty = qe->max_penalty + qe->pr->max_value;
        } else {
            max_penalty = qe->pr->max_value;
        }
 
        /* a relative change to the penalty could put it below 0 */
        if (max_penalty < 0) {
            max_penalty = 0;
        }
 
        snprintf(max_penalty_str, sizeof(max_penalty_str), "%d", max_penalty);
        pbx_builtin_setvar_helper(qe->chan, "QUEUE_MAX_PENALTY", max_penalty_str);
        qe->max_penalty = max_penalty;
        ast_debug(3, "Setting max penalty to %d for caller %s since %d seconds have elapsed\n",
            qe->max_penalty, ast_channel_name(qe->chan), qe->pr->time);
    }
 
    if (qe->min_penalty != INT_MAX) {
        char min_penalty_str[20];
        int min_penalty;
 
        if (qe->pr->min_relative) {
            min_penalty = qe->min_penalty + qe->pr->min_value;
        } else {
            min_penalty = qe->pr->min_value;
        }
 
        /* a relative change to the penalty could put it below 0 */
        if (min_penalty < 0) {
            min_penalty = 0;
        }
 
        if (max_penalty != INT_MAX && min_penalty > max_penalty) {
            min_penalty = max_penalty;
        }
 
        snprintf(min_penalty_str, sizeof(min_penalty_str), "%d", min_penalty);
        pbx_builtin_setvar_helper(qe->chan, "QUEUE_MIN_PENALTY", min_penalty_str);
        qe->min_penalty = min_penalty;
        ast_debug(3, "Setting min penalty to %d for caller %s since %d seconds have elapsed\n",
            qe->min_penalty, ast_channel_name(qe->chan), qe->pr->time);
    }
 
    if (qe->raise_penalty != INT_MAX) {
        char raise_penalty_str[20];
        int raise_penalty;
 
        if (qe->pr->raise_relative) {
            raise_penalty = qe->raise_penalty + qe->pr->raise_value;
        } else {
            raise_penalty = qe->pr->raise_value;
        }
 
        /* a relative change to the penalty could put it below 0 */
        if (raise_penalty < 0) {
            raise_penalty = 0;
        }
 
        if (max_penalty != INT_MAX && raise_penalty > max_penalty) {
            raise_penalty = max_penalty;
        }
 
        snprintf(raise_penalty_str, sizeof(raise_penalty_str), "%d", raise_penalty);
        pbx_builtin_setvar_helper(qe->chan, "QUEUE_RAISE_PENALTY", raise_penalty_str);
        qe->raise_penalty = raise_penalty;
        ast_debug(3, "Setting raised penalty to %d for caller %s since %d seconds have elapsed\n",
            qe->raise_penalty, ast_channel_name(qe->chan), qe->pr->time);
    }
 
    qe->pr = AST_LIST_NEXT(qe->pr, list);
}

References ast_channel_name(), ast_debug, AST_LIST_NEXT, queue_ent::chan, queue_ent::max_penalty, penalty_rule::max_relative, penalty_rule::max_value, queue_ent::min_penalty, penalty_rule::min_relative, penalty_rule::min_value, pbx_builtin_setvar_helper(), queue_ent::pr, queue_ent::raise_penalty, penalty_rule::raise_relative, penalty_rule::raise_value, and penalty_rule::time.

Referenced by queue_exec(), and wait_our_turn().

update_queue()

static int update_queue ( struct call_queue *  q, struct member *  member, int  callcompletedinsl, time_t  starttime  )

static

update the queue status

Return values

0

always

Definition at line 6120 of file app_queue.c.

{
    int oldtalktime;
    int newtalktime = time(NULL) - starttime;
    struct member *mem;
    struct call_queue *qtmp;
    struct ao2_iterator queue_iter;
 
    /* It is possible for us to be called when a call has already been considered terminated
     * and data updated, so to ensure we only act on the call that the agent is currently in
     * we check when the call was bridged.
     */
    if (!starttime || (member->starttime != starttime)) {
        return 0;
    }
 
    if (shared_lastcall) {
        queue_iter = ao2_iterator_init(queues, 0);
        while ((qtmp = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
            ao2_lock(qtmp);
            if ((mem = ao2_find(qtmp->members, member, OBJ_POINTER))) {
                time(&mem->lastcall);
                mem->calls++;
                mem->callcompletedinsl = 0;
                mem->starttime = 0;
                mem->lastqueue = q;
                ao2_ref(mem, -1);
            }
            ao2_unlock(qtmp);
            queue_t_unref(qtmp, "Done with iterator");
        }
        ao2_iterator_destroy(&queue_iter);
    } else {
        ao2_lock(q);
        time(&member->lastcall);
        member->callcompletedinsl = 0;
        member->calls++;
        member->starttime = 0;
        member->lastqueue = q;
        ao2_unlock(q);
    }
    /* Member might never experience any direct status change (local
     * channel with forwarding in particular). If that's the case,
     * this is the last chance to remove it from pending or subsequent
     * calls will not occur.
     */
    pending_members_remove(member);
 
    ao2_lock(q);
    q->callscompleted++;
    if (callcompletedinsl) {
        q->callscompletedinsl++;
    }
    if (q->callscompleted == 1) {
        q->talktime = newtalktime;
    } else {
        /* Calculate talktime using the same exponential average as holdtime code */
        oldtalktime = q->talktime;
        q->talktime = (((oldtalktime << 2) - oldtalktime) + newtalktime) >> 2;
    }
    ao2_unlock(q);
    return 0;
}

References ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, member::callcompletedinsl, member::calls, call_queue::callscompleted, call_queue::callscompletedinsl, member::lastcall, member::lastqueue, call_queue::members, NULL, OBJ_POINTER, pending_members_remove(), queue_t_unref, queues, shared_lastcall, member::starttime, and call_queue::talktime.

Referenced by handle_attended_transfer(), handle_blind_transfer(), handle_hangup(), and update_status().

update_realtime_member_field()

static int update_realtime_member_field ( struct member *  mem, const char *  queue_name, const char *  field, const char *  value  )

static

Definition at line 4132 of file app_queue.c.

{
    int ret = -1;
 
    if (ast_strlen_zero(mem->rt_uniqueid)) {
        return ret;
    }
 
    if ((ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, field, value, SENTINEL)) >= 0) {
        ret = 0;
    }
 
    return ret;
}

References ast_strlen_zero(), ast_update_realtime(), member::rt_uniqueid, SENTINEL, and value.

Referenced by remove_from_queue(), set_member_penalty_help_members(), and set_queue_member_ringinuse().

update_realtime_members()

static void update_realtime_members ( struct call_queue *  q )

static

Definition at line 4148 of file app_queue.c.

{
    struct ast_config *member_config = NULL;
    struct member *m;
    char *category = NULL;
    struct ao2_iterator mem_iter;
 
    if (!(member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", q->name , SENTINEL))) {
        /* This queue doesn't have realtime members. If the queue still has any realtime
         * members in memory, they need to be removed.
         */
        ao2_lock(q);
        mem_iter = ao2_iterator_init(q->members, 0);
        while ((m = ao2_iterator_next(&mem_iter))) {
            if (m->realtime) {
                member_remove_from_queue(q, m);
            }
            ao2_ref(m, -1);
        }
        ao2_iterator_destroy(&mem_iter);
        ast_debug(3, "Queue %s has no realtime members defined. No need for update\n", q->name);
        ao2_unlock(q);
        return;
    }
 
    ao2_lock(q);
 
    /* Temporarily set realtime  members dead so we can detect deleted ones.*/
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((m = ao2_iterator_next(&mem_iter))) {
        if (m->realtime) {
            m->dead = 1;
        }
        ao2_ref(m, -1);
    }
    ao2_iterator_destroy(&mem_iter);
 
    while ((category = ast_category_browse(member_config, category))) {
        rt_handle_member_record(q, category, member_config);
    }
 
    /* Delete all realtime members that have been deleted in DB. */
    mem_iter = ao2_iterator_init(q->members, 0);
    while ((m = ao2_iterator_next(&mem_iter))) {
        if (m->dead) {
            if (ast_strlen_zero(m->membername) || !log_membername_as_agent) {
                ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
            } else {
                ast_queue_log(q->name, "REALTIME", m->membername, "REMOVEMEMBER", "%s", "");
            }
            member_remove_from_queue(q, m);
        }
        ao2_ref(m, -1);
    }
    ao2_iterator_destroy(&mem_iter);
    ao2_unlock(q);
    ast_config_destroy(member_config);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_category_browse(), ast_config_destroy(), ast_debug, ast_load_realtime_multientry(), ast_queue_log(), ast_strlen_zero(), member::dead, member::interface, log_membername_as_agent, member_remove_from_queue(), member::membername, call_queue::members, call_queue::name, NULL, member::realtime, rt_handle_member_record(), and SENTINEL.

Referenced by find_load_queue_rt_friendly(), is_our_turn(), and queue_exec().

update_status()

static void update_status ( struct call_queue *  q, struct member *  m, const int  status  )

static

set a member's status based on device state of that member's state_interface.

Lock interface list find sc, iterate through each queues queue_member list for member to update state inside queues

Definition at line 2708 of file app_queue.c.

{
    if (m->status != status) {
        /* If this member has transitioned to being available then update their queue
         * information. If they are currently in a call then the leg to the agent will be
         * considered done and the call finished.
         */
        if (status == AST_DEVICE_NOT_INUSE) {
            update_queue(q, m, m->callcompletedinsl, m->starttime);
        }
 
        m->status = status;
 
        /* Remove the member from the pending members pool only when the status changes.
         * This is not done unconditionally because we can occasionally see multiple
         * device state notifications of not in use after a previous call has ended,
         * including after we have initiated a new call. This is more likely to
         * happen when there is latency in the connection to the member.
         */
        pending_members_remove(m);
 
        queue_publish_member_blob(queue_member_status_type(), queue_member_blob_create(q, m));
    }
}

References AST_DEVICE_NOT_INUSE, member::callcompletedinsl, pending_members_remove(), queue_member_blob_create(), queue_publish_member_blob(), member::starttime, status, member::status, and update_queue().

Referenced by device_state_cb(), and extension_state_cb().

upqm_exec()

static int upqm_exec ( struct ast_channel *  chan, const char *  data  )

static

UnpauseQueueMember application.

Definition at line 8395 of file app_queue.c.

{
    char *parse;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(interface);
        AST_APP_ARG(options);
        AST_APP_ARG(reason);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "UnpauseQueueMember requires an argument ([queuename],interface[,options[,reason]])\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.interface)) {
        ast_log(LOG_WARNING, "Missing interface argument to UnpauseQueueMember ([queuename],interface[,options[,reason]])\n");
        return -1;
    }
 
    if (set_member_paused(args.queuename, args.interface, args.reason, 0)) {
        ast_log(LOG_WARNING, "Attempt to unpause interface %s, not found\n", args.interface);
        pbx_builtin_setvar_helper(chan, "UPQMSTATUS", "NOTFOUND");
        return 0;
    }
 
    pbx_builtin_setvar_helper(chan, "UPQMSTATUS", "UNPAUSED");
 
    return 0;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), LOG_WARNING, options, pbx_builtin_setvar_helper(), and set_member_paused().

Referenced by load_module().

valid_exit()

static int valid_exit ( struct queue_ent *  qe, char  digit  )

static

Check for valid exit from queue via goto.

Return values

0	if failure
1	if successful

Definition at line 4320 of file app_queue.c.

{
    int digitlen = strlen(qe->digits);
 
    /* Prevent possible buffer overflow */
    if (digitlen < sizeof(qe->digits) - 2) {
        qe->digits[digitlen] = digit;
        qe->digits[digitlen + 1] = '\0';
    } else {
        qe->digits[0] = '\0';
        return 0;
    }
 
    /* If there's no context to goto, short-circuit */
    if (ast_strlen_zero(qe->context)) {
        return 0;
    }
 
    /* If the extension is bad, then reset the digits to blank */
    if (!ast_canmatch_extension(qe->chan, qe->context, qe->digits, 1,
        S_COR(ast_channel_caller(qe->chan)->id.number.valid, ast_channel_caller(qe->chan)->id.number.str, NULL))) {
        qe->digits[0] = '\0';
        return 0;
    }
 
    /* We have an exact match */
    if (!ast_goto_if_exists(qe->chan, qe->context, qe->digits, 1)) {
        qe->valid_digits = 1;
        /* Return 1 on a successful goto */
        return 1;
    }
 
    return 0;
}

References ast_canmatch_extension(), ast_channel_caller(), ast_goto_if_exists(), ast_strlen_zero(), queue_ent::chan, queue_ent::context, digit, queue_ent::digits, ast_party_caller::id, NULL, ast_party_id::number, S_COR, ast_party_number::str, ast_party_number::valid, and queue_ent::valid_digits.

Referenced by say_periodic_announcement(), say_position(), wait_a_bit(), wait_for_answer(), and wait_our_turn().

wait_a_bit()

static int wait_a_bit ( struct queue_ent *  qe )

static

Definition at line 7593 of file app_queue.c.

{
    /* Don't need to hold the lock while we setup the outgoing calls */
    int retrywait = qe->parent->retry * 1000;
 
    int res = ast_waitfordigit(qe->chan, retrywait);
    if (res > 0 && !valid_exit(qe, res)) {
        res = 0;
    }
 
    return res;
}

References ast_waitfordigit(), queue_ent::chan, queue_ent::parent, call_queue::retry, and valid_exit().

Referenced by queue_exec().

wait_for_answer()

static struct callattempt * wait_for_answer ( struct queue_ent *  qe, struct callattempt *  outgoing, int *  to, char *  digit, int  prebusies, int  caller_disconnect, int  forwardsallowed  )

static

Wait for a member to answer the call.

Parameters

[in]	qe	the queue_ent corresponding to the caller in the queue
[in]	outgoing	the list of callattempts. Relevant ones will have their chan and stillgoing parameters non-zero
[in]	to	the amount of time (in milliseconds) to wait for a response
[out]	digit	if a user presses a digit to exit the queue, this is the digit the caller pressed
[in]	prebusies	number of busy members calculated prior to calling wait_for_answer
[in]	caller_disconnect	if the 'H' option is used when calling Queue(), this is used to detect if the caller pressed * to disconnect the call
[in]	forwardsallowed	used to detect if we should allow call forwarding, based on the 'i' option to Queue()

Todo:

eventually all call forward logic should be integrated into and replaced by ast_call_forward()

Definition at line 5353 of file app_queue.c.

{
    const char *queue = qe->parent->name;
    struct callattempt *o, *start = NULL, *prev = NULL;
    int status;
    int numbusies = prebusies;
    int numnochan = 0;
    int stillgoing = 0;
    int orig = *to;
    struct ast_frame *f;
    struct callattempt *peer = NULL;
    struct ast_channel *winner;
    struct ast_channel *in = qe->chan;
    char on[80] = "";
    char membername[80] = "";
    long starttime = 0;
    long endtime = 0;
    char *inchan_name;
    struct timeval start_time_tv = ast_tvnow();
    int canceled_by_caller = 0; /* 1 when caller hangs up or press digit or press * */
 
    ast_channel_lock(qe->chan);
    inchan_name = ast_strdupa(ast_channel_name(qe->chan));
    ast_channel_unlock(qe->chan);
 
    starttime = (long) time(NULL);
 
    while ((*to = ast_remaining_ms(start_time_tv, orig)) && !peer) {
        int numlines, retry, pos = 1;
        struct ast_channel *watchers[AST_MAX_WATCHERS];
        watchers[0] = in;
        start = NULL;
 
        for (retry = 0; retry < 2; retry++) {
            numlines = 0;
            for (o = outgoing; o; o = o->q_next) { /* Keep track of important channels */
                if (o->stillgoing) {    /* Keep track of important channels */
                    stillgoing = 1;
                    if (o->chan) {
                        if (pos < AST_MAX_WATCHERS) {
                            watchers[pos++] = o->chan;
                        }
                        if (!start) {
                            start = o;
                        } else {
                            prev->call_next = o;
                        }
                        prev = o;
                    }
                } else if (prev) {
                    prev->call_next = NULL;
                }
                numlines++;
            }
            if (pos > 1 /* found */ || !stillgoing /* nobody listening */ ||
                (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) /* ring would not be delivered */) {
                break;
            }
            /* On "ringall" strategy we only move to the next penalty level
               when *all* ringing phones are done in the current penalty level */
            ring_one(qe, outgoing, &numbusies);
            /* and retry... */
        }
        if (pos == 1 /* not found */) {
            if (numlines == (numbusies + numnochan)) {
                ast_debug(1, "Everyone is busy at this time\n");
            } else {
                ast_debug(3, "No one is answering queue '%s' (%d numlines / %d busies / %d failed channels)\n", queue, numlines, numbusies, numnochan);
            }
            *to = 0;
            return NULL;
        }
 
        /* Poll for events from both the incoming channel as well as any outgoing channels */
        winner = ast_waitfor_n(watchers, pos, to);
 
        /* Service all of the outgoing channels */
        for (o = start; o; o = o->call_next) {
            /* We go with a fixed buffer here instead of using ast_strdupa. Using
             * ast_strdupa in a loop like this one can cause a stack overflow
             */
            char ochan_name[AST_CHANNEL_NAME];
 
            if (o->chan) {
                ast_channel_lock(o->chan);
                ast_copy_string(ochan_name, ast_channel_name(o->chan), sizeof(ochan_name));
                ast_channel_unlock(o->chan);
            }
            if (o->stillgoing && (o->chan) &&  (ast_channel_state(o->chan) == AST_STATE_UP)) {
                if (!peer) {
                    ast_verb(3, "%s answered %s\n", ochan_name, inchan_name);
                    if (o->orig_chan_name
                        && strcmp(o->orig_chan_name, ochan_name)) {
                        /*
                         * The channel name changed so we must generate COLP update.
                         * Likely because a call pickup channel masqueraded in.
                         */
                        update_connected_line_from_peer(in, o->chan, 1);
                    } else if (!o->block_connected_update) {
                        if (o->pending_connected_update) {
                            if (ast_channel_connected_line_sub(o->chan, in, &o->connected, 0)) {
                                ast_channel_update_connected_line(in, &o->connected, NULL);
                            }
                        } else if (!o->dial_callerid_absent) {
                            update_connected_line_from_peer(in, o->chan, 1);
                        }
                    }
                    if (o->aoc_s_rate_list) {
                        size_t encoded_size;
                        struct ast_aoc_encoded *encoded;
                        if ((encoded = ast_aoc_encode(o->aoc_s_rate_list, &encoded_size, o->chan))) {
                            ast_indicate_data(in, AST_CONTROL_AOC, encoded, encoded_size);
                            ast_aoc_destroy_encoded(encoded);
                        }
                    }
                    peer = o;
                }
            } else if (o->chan && (o->chan == winner)) {
 
                ast_copy_string(on, o->member->interface, sizeof(on));
                ast_copy_string(membername, o->member->membername, sizeof(membername));
 
                /* Before processing channel, go ahead and check for forwarding */
                if (!ast_strlen_zero(ast_channel_call_forward(o->chan)) && !forwardsallowed) {
                    ast_verb(3, "Forwarding %s to '%s' prevented.\n", inchan_name, ast_channel_call_forward(o->chan));
                    ast_channel_publish_dial_forward(qe->chan, o->chan, NULL, NULL,
                        "CANCEL", ast_channel_call_forward(o->chan));
                    numnochan++;
                    do_hang(o);
                    winner = NULL;
                    continue;
                } else if (!ast_strlen_zero(ast_channel_call_forward(o->chan))) {
                    struct ast_channel *original = o->chan;
                    char forwarder[AST_CHANNEL_NAME];
                    char tmpchan[256];
                    char *stuff;
                    char *tech;
                    int failed = 0;
 
                    ast_copy_string(tmpchan, ast_channel_call_forward(o->chan), sizeof(tmpchan));
                    ast_copy_string(forwarder, ast_channel_name(o->chan), sizeof(forwarder));
                    if ((stuff = strchr(tmpchan, '/'))) {
                        *stuff++ = '\0';
                        tech = tmpchan;
                    } else {
                        const char *forward_context;
                        ast_channel_lock(o->chan);
                        forward_context = pbx_builtin_getvar_helper(o->chan, "FORWARD_CONTEXT");
                        snprintf(tmpchan, sizeof(tmpchan), "%s@%s", ast_channel_call_forward(o->chan), forward_context ? forward_context : ast_channel_context(o->chan));
                        ast_channel_unlock(o->chan);
                        stuff = tmpchan;
                        tech = "Local";
                    }
                    if (!strcasecmp(tech, "Local")) {
                        /*
                         * Drop the connected line update block for local channels since
                         * this is going to run dialplan and the user can change his
                         * mind about what connected line information he wants to send.
                         */
                        o->block_connected_update = 0;
                    }
 
                    ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", inchan_name, tech, stuff, ochan_name);
                    /* Setup parameters */
                    o->chan = ast_request(tech, ast_channel_nativeformats(in), NULL, in, stuff, &status);
                    if (!o->chan) {
                        ast_log(LOG_NOTICE,
                            "Forwarding failed to create channel to dial '%s/%s'\n",
                            tech, stuff);
                        o->stillgoing = 0;
                        numnochan++;
                    } else {
                        ast_channel_lock_both(o->chan, original);
                        ast_party_redirecting_copy(ast_channel_redirecting(o->chan),
                            ast_channel_redirecting(original));
                        ast_channel_unlock(o->chan);
                        ast_channel_unlock(original);
 
                        ast_channel_lock_both(o->chan, in);
                        ast_channel_inherit_variables(in, o->chan);
                        ast_channel_datastore_inherit(in, o->chan);
                        pbx_builtin_setvar_helper(o->chan, "FORWARDERNAME", forwarder);
                        ast_max_forwards_decrement(o->chan);
 
                        if (o->pending_connected_update) {
                            /*
                             * Re-seed the callattempt's connected line information with
                             * previously acquired connected line info from the queued
                             * channel.  The previously acquired connected line info could
                             * have been set through the CONNECTED_LINE dialplan function.
                             */
                            o->pending_connected_update = 0;
                            ast_party_connected_line_copy(&o->connected, ast_channel_connected(in));
                        }
 
                        ast_free(o->orig_chan_name);
                        o->orig_chan_name = ast_strdup(ast_channel_name(o->chan));
 
                        ast_channel_req_accountcodes(o->chan, in, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
 
                        if (!ast_channel_redirecting(o->chan)->from.number.valid
                            || ast_strlen_zero(ast_channel_redirecting(o->chan)->from.number.str)) {
                            /*
                             * The call was not previously redirected so it is
                             * now redirected from this number.
                             */
                            ast_party_number_free(&ast_channel_redirecting(o->chan)->from.number);
                            ast_party_number_init(&ast_channel_redirecting(o->chan)->from.number);
                            ast_channel_redirecting(o->chan)->from.number.valid = 1;
                            ast_channel_redirecting(o->chan)->from.number.str =
                                ast_strdup(ast_channel_exten(in));
                        }
 
                        ast_channel_dialed(o->chan)->transit_network_select = ast_channel_dialed(in)->transit_network_select;
 
                        o->dial_callerid_absent = !ast_channel_caller(o->chan)->id.number.valid
                            || ast_strlen_zero(ast_channel_caller(o->chan)->id.number.str);
                        ast_connected_line_copy_from_caller(ast_channel_connected(o->chan),
                            ast_channel_caller(in));
 
                        ast_channel_unlock(in);
                        if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL
                            && !o->block_connected_update) {
                            struct ast_party_redirecting redirecting;
 
                            /*
                             * Redirecting updates to the caller make sense only on single
                             * call at a time strategies.
                             *
                             * Need to re-evaluate if calling unlock is still required as we no longer
                             * use macro.
                             */
                            ast_party_redirecting_init(&redirecting);
                            ast_party_redirecting_copy(&redirecting, ast_channel_redirecting(o->chan));
                            ast_channel_unlock(o->chan);
                            if (ast_channel_redirecting_sub(o->chan, in, &redirecting, 0)) {
                                ast_channel_update_redirecting(in, &redirecting, NULL);
                            }
                            ast_party_redirecting_free(&redirecting);
                        } else {
                            ast_channel_unlock(o->chan);
                        }
 
                        if (ast_call(o->chan, stuff, 0)) {
                            ast_log(LOG_NOTICE, "Forwarding failed to dial '%s/%s'\n",
                                tech, stuff);
                            failed = 1;
                        }
                    }
 
                    ast_channel_publish_dial_forward(qe->chan, original, o->chan, NULL,
                        "CANCEL", ast_channel_call_forward(original));
                    if (o->chan) {
                        ast_channel_publish_dial(qe->chan, o->chan, stuff, NULL);
                    }
 
                    if (failed) {
                        do_hang(o);
                        numnochan++;
                    }
 
                    /* Hangup the original channel now, in case we needed it */
                    ast_hangup(winner);
                    continue;
                }
                f = ast_read(winner);
                if (f) {
                    if (f->frametype == AST_FRAME_CONTROL) {
                        switch (f->subclass.integer) {
                        case AST_CONTROL_ANSWER:
                            /* This is our guy if someone answered. */
                            if (!peer) {
                                ast_verb(3, "%s answered %s\n", ochan_name, inchan_name);
                                ast_channel_publish_dial(qe->chan, o->chan, on, "ANSWER");
                                publish_dial_end_event(qe->chan, outgoing, o->chan, "CANCEL");
                                if (o->orig_chan_name
                                    && strcmp(o->orig_chan_name, ochan_name)) {
                                    /*
                                     * The channel name changed so we must generate COLP update.
                                     * Likely because a call pickup channel masqueraded in.
                                     */
                                    update_connected_line_from_peer(in, o->chan, 1);
                                } else if (!o->block_connected_update) {
                                    if (o->pending_connected_update) {
                                        if (ast_channel_connected_line_sub(o->chan, in, &o->connected, 0)) {
                                            ast_channel_update_connected_line(in, &o->connected, NULL);
                                        }
                                    } else if (!o->dial_callerid_absent) {
                                        update_connected_line_from_peer(in, o->chan, 1);
                                    }
                                }
                                if (o->aoc_s_rate_list) {
                                    size_t encoded_size;
                                    struct ast_aoc_encoded *encoded;
                                    if ((encoded = ast_aoc_encode(o->aoc_s_rate_list, &encoded_size, o->chan))) {
                                        ast_indicate_data(in, AST_CONTROL_AOC, encoded, encoded_size);
                                        ast_aoc_destroy_encoded(encoded);
                                    }
                                }
                                peer = o;
                            }
                            break;
                        case AST_CONTROL_BUSY:
                            ast_verb(3, "%s is busy\n", ochan_name);
                            ast_channel_publish_dial(qe->chan, o->chan, on, "BUSY");
                            endtime = (long) time(NULL);
                            endtime -= starttime;
                            rna(endtime * 1000, qe, o->chan, on, membername, qe->parent->autopausebusy);
                            do_hang(o);
                            if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
                                if (qe->parent->timeoutrestart) {
                                    start_time_tv = ast_tvnow();
                                }
                                /* Have enough time for a queue member to answer? */
                                if (ast_remaining_ms(start_time_tv, orig) > 500) {
                                    ring_one(qe, outgoing, &numbusies);
                                    starttime = (long) time(NULL);
                                }
                            }
                            numbusies++;
                            break;
                        case AST_CONTROL_CONGESTION:
                            ast_verb(3, "%s is circuit-busy\n", ochan_name);
                            ast_channel_publish_dial(qe->chan, o->chan, on, "CONGESTION");
                            endtime = (long) time(NULL);
                            endtime -= starttime;
                            rna(endtime * 1000, qe, o->chan, on, membername, qe->parent->autopauseunavail);
                            do_hang(o);
                            if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
                                if (qe->parent->timeoutrestart) {
                                    start_time_tv = ast_tvnow();
                                }
                                if (ast_remaining_ms(start_time_tv, orig) > 500) {
                                    ring_one(qe, outgoing, &numbusies);
                                    starttime = (long) time(NULL);
                                }
                            }
                            numbusies++;
                            break;
                        case AST_CONTROL_RINGING:
                            ast_verb(3, "%s is ringing\n", ochan_name);
 
                            ast_channel_publish_dial(qe->chan, o->chan, on, "RINGING");
 
                            /* Start ring indication when the channel is ringing, if specified */
                            if (qe->ring_when_ringing) {
                                ast_moh_stop(qe->chan);
                                ast_indicate(qe->chan, AST_CONTROL_RINGING);
                            }
                            break;
                        case AST_CONTROL_OFFHOOK:
                            /* Ignore going off hook */
                            break;
                        case AST_CONTROL_CONNECTED_LINE:
                            if (o->block_connected_update) {
                                ast_verb(3, "Connected line update to %s prevented.\n", inchan_name);
                                break;
                            }
                            if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
                                struct ast_party_connected_line connected;
 
                                ast_verb(3, "%s connected line has changed. Saving it until answer for %s\n", ochan_name, inchan_name);
                                ast_party_connected_line_set_init(&connected, &o->connected);
                                ast_connected_line_parse_data(f->data.ptr, f->datalen, &connected);
                                ast_party_connected_line_set(&o->connected, &connected, NULL);
                                ast_party_connected_line_free(&connected);
                                o->pending_connected_update = 1;
                                break;
                            }
 
                            /*
                             * Prevent using the CallerID from the outgoing channel since we
                             * got a connected line update from it.
                             */
                            o->dial_callerid_absent = 1;
 
                            if (ast_channel_connected_line_sub(o->chan, in, f, 1)) {
                                ast_indicate_data(in, AST_CONTROL_CONNECTED_LINE, f->data.ptr, f->datalen);
                            }
                            break;
                        case AST_CONTROL_AOC:
                            {
                                struct ast_aoc_decoded *decoded = ast_aoc_decode(f->data.ptr, f->datalen, o->chan);
                                if (decoded && (ast_aoc_get_msg_type(decoded) == AST_AOC_S)) {
                                    ast_aoc_destroy_decoded(o->aoc_s_rate_list);
                                    o->aoc_s_rate_list = decoded;
                                } else {
                                    ast_aoc_destroy_decoded(decoded);
                                }
                            }
                            break;
                        case AST_CONTROL_REDIRECTING:
                            if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
                                /*
                                 * Redirecting updates to the caller make sense only on single
                                 * call at a time strategies.
                                 */
                                break;
                            }
                            if (o->block_connected_update) {
                                ast_verb(3, "Redirecting update to %s prevented\n",
                                    inchan_name);
                                break;
                            }
                            ast_verb(3, "%s redirecting info has changed, passing it to %s\n",
                                ochan_name, inchan_name);
                            if (ast_channel_redirecting_sub(o->chan, in, f, 1)) {
                                ast_indicate_data(in, AST_CONTROL_REDIRECTING, f->data.ptr, f->datalen);
                            }
                            break;
                        case AST_CONTROL_PVT_CAUSE_CODE:
                            ast_indicate_data(in, AST_CONTROL_PVT_CAUSE_CODE, f->data.ptr, f->datalen);
                            break;
                        default:
                            ast_debug(1, "Dunno what to do with control type %d\n", f->subclass.integer);
                            break;
                        }
                    }
                    ast_frfree(f);
                } else { /* ast_read() returned NULL */
                    endtime = (long) time(NULL) - starttime;
                    ast_channel_publish_dial(qe->chan, o->chan, on, "NOANSWER");
                    rna(endtime * 1000, qe, o->chan, on, membername, 1);
                    do_hang(o);
                    if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
                        if (qe->parent->timeoutrestart) {
                            start_time_tv = ast_tvnow();
                        }
                        if (ast_remaining_ms(start_time_tv, orig) > 500) {
                            ring_one(qe, outgoing, &numbusies);
                            starttime = (long) time(NULL);
                        }
                    }
                }
            }
        }
 
        /* If we received an event from the caller, deal with it. */
        if (winner == in) {
            f = ast_read(in);
            if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass.integer == AST_CONTROL_HANGUP))) {
                /* Got hung up */
                *to = -1;
                if (f) {
                    if (f->data.uint32) {
                        ast_channel_hangupcause_set(in, f->data.uint32);
                    }
                    ast_frfree(f);
                }
                canceled_by_caller = 1;
            } else if ((f->frametype == AST_FRAME_DTMF) && caller_disconnect && (f->subclass.integer == '*')) {
                ast_verb(3, "User hit %c to disconnect call.\n", f->subclass.integer);
                *to = 0;
                ast_frfree(f);
                canceled_by_caller = 1;
            } else if ((f->frametype == AST_FRAME_DTMF) && valid_exit(qe, f->subclass.integer)) {
                ast_verb(3, "User pressed digit: %c\n", f->subclass.integer);
                *to = 0;
                *digit = f->subclass.integer;
                ast_frfree(f);
                canceled_by_caller = 1;
            }
            /* When caller hung up or pressed * or digit. */
            if (canceled_by_caller) {
                publish_dial_end_event(in, outgoing, NULL, "CANCEL");
                for (o = start; o; o = o->call_next) {
                    if (o->chan) {
                        ast_queue_log(qe->parent->name, ast_channel_uniqueid(qe->chan), o->member->membername, "RINGCANCELED", "%d", (int) ast_tvdiff_ms(ast_tvnow(), start_time_tv));
                    }
                }
                return NULL;
            }
 
            /* Send the frame from the in channel to all outgoing channels. */
            for (o = start; o; o = o->call_next) {
                if (!o->stillgoing || !o->chan) {
                    /* This outgoing channel has died so don't send the frame to it. */
                    continue;
                }
                switch (f->frametype) {
                case AST_FRAME_CONTROL:
                    switch (f->subclass.integer) {
                    case AST_CONTROL_CONNECTED_LINE:
                        if (o->block_connected_update) {
                            ast_verb(3, "Connected line update to %s prevented.\n", ast_channel_name(o->chan));
                            break;
                        }
                        if (ast_channel_connected_line_sub(in, o->chan, f, 1)) {
                            ast_indicate_data(o->chan, f->subclass.integer, f->data.ptr, f->datalen);
                        }
                        break;
                    case AST_CONTROL_REDIRECTING:
                        if (o->block_connected_update) {
                            ast_verb(3, "Redirecting update to %s prevented.\n", ast_channel_name(o->chan));
                            break;
                        }
                        if (ast_channel_redirecting_sub(in, o->chan, f, 1)) {
                            ast_indicate_data(o->chan, f->subclass.integer, f->data.ptr, f->datalen);
                        }
                        break;
                    default:
                        /* We are not going to do anything with this frame. */
                        goto skip_frame;
                    }
                    break;
                default:
                    /* We are not going to do anything with this frame. */
                    goto skip_frame;
                }
            }
skip_frame:;
 
            ast_frfree(f);
        }
    }
 
    if (!*to) {
        for (o = start; o; o = o->call_next) {
            if (o->chan) {
                rna(orig, qe, o->chan, o->interface, o->member->membername, 1);
            }
        }
 
        publish_dial_end_event(qe->chan, outgoing, NULL, "NOANSWER");
    }
 
    return peer;
}

References callattempt::aoc_s_rate_list, ast_aoc_decode(), ast_aoc_destroy_decoded(), ast_aoc_destroy_encoded(), ast_aoc_encode(), ast_aoc_get_msg_type(), AST_AOC_S, ast_call(), ast_channel_call_forward(), ast_channel_caller(), ast_channel_connected(), ast_channel_connected_line_sub(), ast_channel_context(), ast_channel_datastore_inherit(), ast_channel_dialed(), ast_channel_exten(), ast_channel_hangupcause_set(), ast_channel_inherit_variables(), ast_channel_lock, ast_channel_lock_both, AST_CHANNEL_NAME, ast_channel_name(), ast_channel_nativeformats(), ast_channel_publish_dial(), ast_channel_publish_dial_forward(), ast_channel_redirecting(), ast_channel_redirecting_sub(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_BRIDGE_PEER, ast_channel_uniqueid(), ast_channel_unlock, ast_channel_update_connected_line(), ast_channel_update_redirecting(), ast_connected_line_copy_from_caller(), ast_connected_line_parse_data(), AST_CONTROL_ANSWER, AST_CONTROL_AOC, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HANGUP, AST_CONTROL_OFFHOOK, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, ast_copy_string(), ast_debug, AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_free, ast_frfree, ast_hangup(), ast_indicate(), ast_indicate_data(), ast_log, ast_max_forwards_decrement(), AST_MAX_WATCHERS, ast_moh_stop(), ast_party_connected_line_copy(), ast_party_connected_line_free(), ast_party_connected_line_set(), ast_party_connected_line_set_init(), ast_party_number_free(), ast_party_number_init(), ast_party_redirecting_copy(), ast_party_redirecting_free(), ast_party_redirecting_init(), ast_queue_log(), ast_read(), ast_remaining_ms(), ast_request(), AST_STATE_UP, ast_strdup, ast_strdupa, ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), ast_verb, ast_waitfor_n(), call_queue::autopausebusy, call_queue::autopauseunavail, callattempt::block_connected_update, callattempt::call_next, callattempt::chan, queue_ent::chan, callattempt::connected, connected, ast_frame::data, ast_frame::datalen, callattempt::dial_callerid_absent, digit, do_hang(), ast_frame::frametype, ast_party_redirecting::from, ast_party_caller::id, in, ast_frame_subclass::integer, callattempt::interface, member::interface, LOG_NOTICE, callattempt::member, member::membername, call_queue::name, NULL, ast_party_id::number, callattempt::orig_chan_name, queue_ent::parent, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), callattempt::pending_connected_update, ast_frame::ptr, publish_dial_end_event(), callattempt::q_next, QUEUE_STRATEGY_RINGALL, ring_one(), queue_ent::ring_when_ringing, rna(), status, callattempt::stillgoing, ast_party_number::str, call_queue::strategy, ast_frame::subclass, ast_channel::tech, call_queue::timeoutrestart, ast_party_dialed::transit_network_select, ast_frame::uint32, update_connected_line_from_peer(), ast_party_number::valid, and valid_exit().

Referenced by try_calling().

wait_our_turn()

static int wait_our_turn ( struct queue_ent *  qe, int  ringing, enum queue_result *  reason  )

static

The waiting areas for callers who are not actively calling members.

This function is one large loop. This function will return if a caller either exits the queue or it becomes that caller's turn to attempt calling queue members. Inside the loop, we service the caller with periodic announcements, holdtime announcements, etc. as configured in queues.conf

Return values

0	if the caller's turn has arrived
-1	if the caller should exit the queue.

Definition at line 6032 of file app_queue.c.

{
    int res = 0;
 
    /* This is the holding pen for callers 2 through maxlen */
    for (;;) {
 
        /* A request to withdraw this call from the queue arrived */
        if (qe->withdraw) {
            *reason = QUEUE_WITHDRAW;
            res = 1;
            break;
        }
 
        if (is_our_turn(qe)) {
            break;
        }
 
        /* If we have timed out, break out */
        if (qe->expire && (time(NULL) >= qe->expire)) {
            *reason = QUEUE_TIMEOUT;
            break;
        }
 
        if (qe->parent->leavewhenempty) {
            int status = 0;
 
            if ((status = get_member_status(qe->parent, qe->max_penalty, qe->min_penalty, qe->raise_penalty, qe->parent->leavewhenempty, 0, qe->raise_respect_min))) {
                record_abandoned(qe);
                *reason = QUEUE_LEAVEEMPTY;
                ast_queue_log(qe->parent->name, ast_channel_uniqueid(qe->chan), "NONE", "EXITEMPTY", "%d|%d|%ld", qe->pos, qe->opos, (long) (time(NULL) - qe->start));
                res = -1;
                qe->handled = -1;
                break;
            }
        }
 
        /* Make a position announcement, if enabled */
        if (qe->parent->announcefrequency &&
            (res = say_position(qe,ringing))) {
            break;
        }
 
        /* If we have timed out, break out */
        if (qe->expire && (time(NULL) >= qe->expire)) {
            *reason = QUEUE_TIMEOUT;
            break;
        }
 
        /* Make a periodic announcement, if enabled */
        if (qe->parent->periodicannouncefrequency &&
            (res = say_periodic_announcement(qe,ringing)))
            break;
 
        /* see if we need to move to the next penalty level for this queue */
        while (qe->pr && ((time(NULL) - qe->start) >= qe->pr->time)) {
            update_qe_rule(qe);
        }
 
        /* If we have timed out, break out */
        if (qe->expire && (time(NULL) >= qe->expire)) {
            *reason = QUEUE_TIMEOUT;
            break;
        }
 
        /* Wait a second before checking again */
        if ((res = ast_waitfordigit(qe->chan, RECHECK * 1000))) {
            if (res > 0 && !valid_exit(qe, res)) {
                res = 0;
            } else {
                break;
            }
        }
 
        /* If we have timed out, break out */
        if (qe->expire && (time(NULL) >= qe->expire)) {
            *reason = QUEUE_TIMEOUT;
            break;
        }
    }
 
    return res;
}

References call_queue::announcefrequency, ast_channel_uniqueid(), ast_queue_log(), ast_waitfordigit(), queue_ent::chan, queue_ent::expire, get_member_status(), queue_ent::handled, is_our_turn(), call_queue::leavewhenempty, queue_ent::max_penalty, queue_ent::min_penalty, call_queue::name, NULL, queue_ent::opos, queue_ent::parent, call_queue::periodicannouncefrequency, queue_ent::pos, queue_ent::pr, QUEUE_LEAVEEMPTY, QUEUE_TIMEOUT, QUEUE_WITHDRAW, queue_ent::raise_penalty, queue_ent::raise_respect_min, RECHECK, record_abandoned(), ringing(), say_periodic_announcement(), say_position(), queue_ent::start, status, penalty_rule::time, update_qe_rule(), valid_exit(), and queue_ent::withdraw.

Referenced by queue_exec().

word_in_list()

static int word_in_list ( const char *  list, const char *  word  )

static

Check if a given word is in a space-delimited list.

Parameters

list	Space delimited list of words
word	The word used to search the list

Note

This function will not return 1 if the word is at the very end of the list (followed immediately by a \0, not a space) since it is used for checking tab-completion and a word at the end is still being tab-completed.

Return values

1	if the word is found
0	if the word is not found

Definition at line 10414 of file app_queue.c.

                                                            {
    int list_len, word_len = strlen(word);
    const char *find, *end_find, *end_list;
 
    /* strip whitespace from front */
    while(isspace(*list)) {
        list++;
    }
 
    while((find = strstr(list, word))) {
        /* beginning of find starts inside another word? */
        if (find != list && *(find - 1) != ' ') {
            list = find;
            /* strip word from front */
            while(!isspace(*list) && *list != '\0') {
                list++;
            }
            /* strip whitespace from front */
            while(isspace(*list)) {
                list++;
            }
            continue;
        }
 
        /* end of find ends inside another word or at very end of list? */
        list_len = strlen(list);
        end_find = find + word_len;
        end_list = list + list_len;
        if (end_find == end_list || *end_find != ' ') {
            list = find;
            /* strip word from front */
            while(!isspace(*list) && *list != '\0') {
                list++;
            }
            /* strip whitespace from front */
            while(isspace(*list)) {
                list++;
            }
            continue;
        }
 
        /* terminating conditions satisfied, word at beginning or separated by ' ' */
        return 1;
    }
 
    return 0;
}

References call_queue::list.

Referenced by complete_queue().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "True Call Queueing" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_CONSUMER, }

static

Definition at line 12117 of file app_queue.c.

agent_router

struct stasis_message_router* agent_router

static

Definition at line 11853 of file app_queue.c.

Referenced by load_module(), and unload_module().

app

char* app = "Queue"

static

Definition at line 1695 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_aqm

char* app_aqm = "AddQueueMember"

static

Definition at line 1697 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_pqm

char* app_pqm = "PauseQueueMember"

static

Definition at line 1701 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_ql

char* app_ql = "QueueLog"

static

Definition at line 1705 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_qupd

char* app_qupd = "QueueUpdate"

static

Definition at line 1707 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_rqm

char* app_rqm = "RemoveQueueMember"

static

Definition at line 1699 of file app_queue.c.

Referenced by load_module(), and unload_module().

app_upqm

char* app_upqm = "UnpauseQueueMember"

static

Definition at line 1703 of file app_queue.c.

Referenced by load_module(), and unload_module().

aqm_opts

const struct ast_app_option aqm_opts[128] = { [ 'p' ] = { .flag = AQMFLAG_PAUSED }, [ 'r' ] = { .flag = AQMFLAG_REASON , .arg_index = AQM_OPT_ARG_PAUSE_REASON + 1 }, }

static

Definition at line 1626 of file app_queue.c.

Referenced by aqm_exec().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 12117 of file app_queue.c.

autofill_default

int autofill_default

static

queues.conf [general] option

Definition at line 1719 of file app_queue.c.

Referenced by init_queue(), queue_reset_global_params(), and queue_set_global_params().

autopausesmodes

const struct autopause autopausesmodes[]

static

Initial value:

= {
    { QUEUE_AUTOPAUSE_OFF,"no" },
    { QUEUE_AUTOPAUSE_ON, "yes" },
    { QUEUE_AUTOPAUSE_ALL,"all" },
}

Referenced by autopause2int().

cli_queue

struct ast_cli_entry cli_queue[]

static

Definition at line 11840 of file app_queue.c.

Referenced by load_module(), and unload_module().

device_state_sub

struct stasis_subscription* device_state_sub

static

Subscription to device state change messages.

Definition at line 1731 of file app_queue.c.

Referenced by load_module(), and unload_module().

force_longest_waiting_caller

int force_longest_waiting_caller

static

queues.conf [general] option

Definition at line 1740 of file app_queue.c.

Referenced by can_ring_entry(), queue_reset_global_params(), and queue_set_global_params().

id

enum queue_result id

Definition at line 1764 of file app_queue.c.

Referenced by OrderedDict::__repr__(), add_action_to_menu_entry(), add_diversion_header(), add_eprofile_to_tdata(), aeap_create(), ast_aeap_message_id(), ast_aoc_set_association_id(), ast_aoc_set_billing_id(), ast_bucket_file_json(), ast_bucket_json(), ast_cc_extension_monitor_add_dialstring(), ast_format_cap_append_by_type(), ast_io_change(), ast_jb_create_framehook(), ast_party_id_presentation(), ast_rtp_instance_extmap_get_id(), ast_sched_del_nonrunning(), ast_sip_modify_id_header(), ast_sip_set_id_from_invite(), bridge_sync_init(), cache_find(), clearcbone(), cleardisplay(), clearflag(), cleartimer(), contact_alloc(), create_new_id_hdr(), digitcollect(), digitdirect(), extension_state_add_destroy(), fetch_callerid_num(), frame_drop_helper(), frame_trace_helper(), generate_content_id_hdr(), handle_local_optimization_begin(), handle_local_optimization_end(), handle_registrations(), idemodulator(), load_engine(), mbl_load_adapter(), mbox(), mwi_mailbox_get(), party_id_build_data(), party_id_read(), party_id_write(), pidf_generate_body_content(), process_extmap_attributes(), process_text_message(), queue_connected_line_update(), session_end_if_disconnected(), session_inv_on_tsx_state_changed(), set_id_from_from(), set_id_from_hdr(), set_id_from_pai(), set_id_from_rpid(), set_state(), setflag(), should_queue_connected_line_update(), showdisplay(), showkeys(), sip_subscription_to_ami(), sorcery_realtime_create(), sorcery_realtime_retrieve_fields(), sorcery_realtime_retrieve_multiple(), sorcery_realtime_update(), startelm(), starttimer(), state_id_by_topic(), try_merge_optimize_out(), try_swap_optimize_out(), and update_incoming_connected_line().

log_caller_id_name

int log_caller_id_name

static

queues.conf [general] option

Definition at line 1743 of file app_queue.c.

Referenced by queue_exec(), and queue_set_global_params().

log_membername_as_agent

int log_membername_as_agent

static

queues.conf [general] option

Definition at line 1737 of file app_queue.c.

Referenced by aqm_exec(), find_queue_by_name_rt(), handle_queue_add_member(), handle_queue_remove_member(), manager_add_queue_member(), manager_remove_queue_member(), queue_reset_global_params(), queue_set_global_params(), rqm_exec(), rt_handle_member_record(), and update_realtime_members().

montype_default

int montype_default

static

queues.conf [general] option

Definition at line 1722 of file app_queue.c.

Referenced by queue_reset_global_params(), and queue_set_global_params().

negative_penalty_invalid

int negative_penalty_invalid

static

queues.conf [general] option

Definition at line 1734 of file app_queue.c.

Referenced by queue_reset_global_params(), queue_set_global_params(), remove_from_queue(), rt_handle_member_record(), and set_member_value().

pending_members

struct ao2_container* pending_members

static

Definition at line 2646 of file app_queue.c.

Referenced by can_ring_entry(), load_module(), pending_members_remove(), and unload_module().

pm_family

const char* const pm_family = "Queue/PersistentMembers"

static

Persistent Members astdb family.

Definition at line 1710 of file app_queue.c.

Referenced by dump_queue_members(), and reload_queue_members().

queue_exec_options

const struct ast_app_option queue_exec_options[128] = { [ 'b' ] = { .flag = OPT_PREDIAL_CALLEE , .arg_index = OPT_ARG_PREDIAL_CALLEE + 1 }, [ 'B' ] = { .flag = OPT_PREDIAL_CALLER , .arg_index = OPT_ARG_PREDIAL_CALLER + 1 }, [ 'C' ] = { .flag = OPT_MARK_AS_ANSWERED }, [ 'c' ] = { .flag = OPT_GO_ON }, [ 'd' ] = { .flag = OPT_DATA_QUALITY }, [ 'F' ] = { .flag = OPT_CALLEE_GO_ON , .arg_index = OPT_ARG_CALLEE_GO_ON + 1 }, [ 'h' ] = { .flag = OPT_CALLEE_HANGUP }, [ 'H' ] = { .flag = OPT_CALLER_HANGUP }, [ 'i' ] = { .flag = OPT_IGNORE_CALL_FW }, [ 'I' ] = { .flag = OPT_IGNORE_CONNECTEDLINE }, [ 'k' ] = { .flag = OPT_CALLEE_PARK }, [ 'K' ] = { .flag = OPT_CALLER_PARK }, [ 'm' ] = { .flag = OPT_MUSICONHOLD_CLASS , .arg_index = OPT_ARG_MUSICONHOLD_CLASS + 1 }, [ 'n' ] = { .flag = OPT_NO_RETRY }, [ 'r' ] = { .flag = OPT_RINGING }, [ 'R' ] = { .flag = OPT_RING_WHEN_RINGING }, [ 't' ] = { .flag = OPT_CALLEE_TRANSFER }, [ 'T' ] = { .flag = OPT_CALLER_TRANSFER }, [ 'x' ] = { .flag = OPT_CALLEE_AUTOMIXMON }, [ 'X' ] = { .flag = OPT_CALLER_AUTOMIXMON }, [ 'w' ] = { .flag = OPT_CALLEE_AUTOMON }, [ 'W' ] = { .flag = OPT_CALLER_AUTOMON }, }

static

Definition at line 1610 of file app_queue.c.

Referenced by queue_exec().

queue_persistent_members

int queue_persistent_members

static

queues.conf [general] option

Definition at line 1713 of file app_queue.c.

Referenced by aqm_exec(), handle_queue_add_member(), load_module(), manager_add_queue_member(), queue_reset_global_params(), queue_set_global_params(), remove_from_queue(), and set_queue_member_pause().

const struct { ... } queue_results[]

Referenced by set_queue_result().

queueexists_function

struct ast_custom_function queueexists_function

static

Initial value:

= {
    .name = "QUEUE_EXISTS",
    .read = queue_function_exists,
}

Definition at line 9592 of file app_queue.c.

Referenced by load_module(), and unload_module().

queuegetchannel_function

struct ast_custom_function queuegetchannel_function

static

Initial value:

= {
    .name = "QUEUE_GET_CHANNEL",
    .read = queue_function_queuegetchannel,
}

Definition at line 9608 of file app_queue.c.

Referenced by load_module(), and unload_module().

queuemembercount_function

struct ast_custom_function queuemembercount_function

static

Initial value:

= {
    .name = "QUEUE_MEMBER",
    .read = queue_function_mem_read,
    .write = queue_function_mem_write,
}

Definition at line 9602 of file app_queue.c.

Referenced by load_module(), and unload_module().

queuememberlist_function

struct ast_custom_function queuememberlist_function

static

Initial value:

= {
    .name = "QUEUE_MEMBER_LIST",
    .read = queue_function_queuememberlist,
}

Definition at line 9618 of file app_queue.c.

Referenced by load_module(), and unload_module().

queuememberpenalty_function

struct ast_custom_function queuememberpenalty_function

static

Initial value:

= {
    .name = "QUEUE_MEMBER_PENALTY",
    .read = queue_function_memberpenalty_read,
    .write = queue_function_memberpenalty_write,
}

Definition at line 9623 of file app_queue.c.

Referenced by load_module(), and unload_module().

queues

struct ao2_container* queues

static

Definition at line 2029 of file app_queue.c.

Referenced by __queues_show(), clear_stats(), compare_weight(), complete_queue(), complete_queue_remove_member(), device_state_cb(), extension_state_cb(), find_load_queue_rt_friendly(), find_queue_by_name_rt(), is_longest_waiting_caller(), leave_queue(), load_module(), manager_queues_status(), manager_queues_summary(), queue_function_queuegetchannel(), queue_function_queuewaitingcount(), reload_queue_members(), reload_queues(), reload_single_queue(), remove_from_queue(), set_member_paused(), set_member_value(), unload_module(), and update_queue().

queuevar_function

struct ast_custom_function queuevar_function

static

Initial value:

= {
    .name = "QUEUE_VARIABLES",
    .read = queue_function_var,
}

Definition at line 9597 of file app_queue.c.

Referenced by load_module(), and unload_module().

queuewaitingcount_function

struct ast_custom_function queuewaitingcount_function

static

Initial value:

= {
    .name = "QUEUE_WAITING_COUNT",
    .read = queue_function_queuewaitingcount,
}

Definition at line 9613 of file app_queue.c.

Referenced by load_module(), and unload_module().

realtime_reason_paused

int realtime_reason_paused

static

does realtime backend support reason_paused

Definition at line 1749 of file app_queue.c.

Referenced by load_module(), rt_handle_member_record(), and set_queue_member_pause().

realtime_ringinuse_field

char* realtime_ringinuse_field

static

name of the ringinuse field in the realtime database

Definition at line 1746 of file app_queue.c.

Referenced by load_module(), rt_handle_member_record(), and set_queue_member_ringinuse().

realtime_rules

int realtime_rules

static

queuerules.conf [general] option

Definition at line 1728 of file app_queue.c.

Referenced by queue_rules_reset_global_params(), queue_rules_set_global_params(), and reload_queue_rules().

rule_lists

struct rule_lists rule_lists = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

shared_lastcall

int shared_lastcall

static

queues.conf [general] option

Definition at line 1725 of file app_queue.c.

Referenced by queue_reset_global_params(), queue_set_global_params(), and update_queue().

strategies

const struct strategy strategies[]

static

Referenced by int2strat(), and strat2int().

text

char* text

Definition at line 1765 of file app_queue.c.

Referenced by __ast_cli_generator(), ast_cli_completion_matches(), ast_cli_completion_vector(), ast_cli_generator(), ast_get_http_method_from_string(), ast_http_auth(), ast_http_create_response(), ast_http_error(), ast_sendtext(), ast_sip_session_add_reason_header(), ast_unreal_sendtext(), ast_xml_free_text(), asterisk_publication_send_refresh(), asterisk_publisher_devstate_cb(), asterisk_publisher_mwistate_cb(), build_regex(), chan_pjsip_sendtext(), check_content_type_in_dialog(), compare(), console_text(), dahdi_sendtext(), 74dc751dfe8e_more_permission_boolean_columns::downgrade(), fake_ami(), fake_json(), festival_exec(), generate_notify_body(), handle_characters(), handle_response_cmgr(), hfp_parse_cmgr(), iax2_sendtext(), iconv_read(), jingle_action_session_terminate(), jingle_send_session_info(), jingle_send_session_terminate(), jingle_sendtext(), originate_exec(), parse_bookmark(), parse_error(), pbcwhere(), send_expansion_text(), send_favorite(), send_text(), send_text_status(), send_texttitle(), sendtext_safe(), set_icon(), set_queue_result(), set_title(), show_main_page(), unistim_sendtext(), xmldoc_get_syntax_config_object(), xmldoc_setpostbr(), xmldoc_string_cleanup(), and xmldoc_string_wrap().

topic_forwarder

struct stasis_forward* topic_forwarder

static

Definition at line 11854 of file app_queue.c.

Referenced by load_module(), and unload_module().

use_weight

int use_weight

static

Records that one or more queues use weight.

Definition at line 1716 of file app_queue.c.

Referenced by can_ring_entry(), find_load_queue_rt_friendly(), load_module(), and reload_single_queue().