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/monitor.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"

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) }

enum	{ OPT_ARG_CALLEE_GO_ON = 0, OPT_ARG_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLER, 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	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 }

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)

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)
	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 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 ouput 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)

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)

static int	get_member_status (struct call_queue *q, int max_penalty, int min_penalty, int raise_penalty, enum empty_conditions conditions, int devstate)
	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_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 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	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	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_qac_dep (struct ast_channel chan, const char cmd, char data, char buf, size_t len)
	Get the total number of members in a specific queue (Deprecated) 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	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_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_caller_abandon_type,.to_ami=queue_caller_abandon_to_ami,)

	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_member_status_type,.to_ami=queue_member_status_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_removed_type,.to_ami=queue_member_removed_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_ringinuse_type,.to_ami=queue_member_ringinuse_to_ami,)

	STASIS_MESSAGE_TYPE_DEFN_LOCAL (queue_agent_called_type,.to_ami=queue_agent_called_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_complete_type,.to_ami=queue_agent_complete_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,)

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 macro, 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, .optional_modules = "res_monitor", }

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_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	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 }, [ '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_dep

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 char *	realtime_ringinuse_field
	name of the ringinuse field in the realtime database More...

static int	realtime_rules
	queuesrules.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	update_cdr
	queues.conf [general] option More...

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@toad.net:

Per-queue holdtime calculation
Estimated holdtime announcement
Position announcement
Abandoned/completed call counters
Failout timer passed as optional app parameter
Optional monitoring of calls, started when call is answered

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 1639 of file app_queue.c.

Referenced by queue_set_param().

◆ ANNOUNCEHOLDTIME_ONCE

#define ANNOUNCEHOLDTIME_ONCE 2

Definition at line 1640 of file app_queue.c.

Referenced by queue_set_param(), and say_position().

◆ ANNOUNCEPOSITION_LIMIT

#define ANNOUNCEPOSITION_LIMIT 4

We not announce position more than <limit>

Definition at line 1657 of file app_queue.c.

Referenced by queue_set_param(), and say_position().

◆ ANNOUNCEPOSITION_MORE_THAN

#define ANNOUNCEPOSITION_MORE_THAN 3

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

Definition at line 1656 of file app_queue.c.

Referenced by queue_set_param(), and say_position().

◆ ANNOUNCEPOSITION_NO

#define ANNOUNCEPOSITION_NO 2

We don't announce position

Definition at line 1655 of file app_queue.c.

Referenced by queue_set_param().

◆ ANNOUNCEPOSITION_YES

#define ANNOUNCEPOSITION_YES 1

We announce position

Definition at line 1654 of file app_queue.c.

Referenced by init_queue(), queue_set_param(), and say_position().

◆ AST_MAX_WATCHERS

#define AST_MAX_WATCHERS 256

Definition at line 4920 of file app_queue.c.

Referenced by wait_for_answer().

◆ 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 1437 of file app_queue.c.

Referenced by init_queue().

◆ DEFAULT_RETRY

#define DEFAULT_RETRY 5

Definition at line 1429 of file app_queue.c.

Referenced by init_queue(), and queue_set_param().

◆ DEFAULT_TIMEOUT

#define DEFAULT_TIMEOUT 15

Definition at line 1430 of file app_queue.c.

Referenced by init_queue(), and queue_set_param().

◆ MAX_CALL_ATTEMPT_BUCKETS

#define MAX_CALL_ATTEMPT_BUCKETS 353

Definition at line 2379 of file app_queue.c.

Referenced by load_module().

◆ MAX_PERIODIC_ANNOUNCEMENTS

#define MAX_PERIODIC_ANNOUNCEMENTS 10

The maximum periodic announcements we can have

Definition at line 1432 of file app_queue.c.

Referenced by destroy_queue(), init_queue(), and queue_set_param().

◆ MAX_QUEUE_BUCKETS

#define MAX_QUEUE_BUCKETS 53

Definition at line 1439 of file app_queue.c.

Referenced by load_module().

◆ QUEUE_EVENT_VARIABLES

#define QUEUE_EVENT_VARIABLES 3

Definition at line 1641 of file app_queue.c.

◆ QUEUE_PAUSED_DEVSTATE

#define QUEUE_PAUSED_DEVSTATE AST_DEVICE_INUSE

Definition at line 3347 of file app_queue.c.

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

◆ queue_ref

#define queue_ref ( q ) ao2_bump(q)

Definition at line 1921 of file app_queue.c.

Referenced by insert_entry(), and queue_stasis_data_alloc().

◆ queue_t_ref

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

Definition at line 1923 of file app_queue.c.

Referenced by leave_queue(), and try_calling().

◆ queue_t_unref

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

◆ QUEUE_UNKNOWN_PAUSED_DEVSTATE

#define QUEUE_UNKNOWN_PAUSED_DEVSTATE AST_DEVICE_NOT_INUSE

Definition at line 3349 of file app_queue.c.

Referenced by member_remove_from_queue().

◆ QUEUE_UNPAUSED_DEVSTATE

#define QUEUE_UNPAUSED_DEVSTATE AST_DEVICE_NOT_INUSE

Definition at line 3348 of file app_queue.c.

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

◆ queue_unref

#define queue_unref ( q ) ({ ao2_cleanup(q); NULL; })

Definition at line 1922 of file app_queue.c.

Referenced by queue_exec(), queue_stasis_data_destructor(), and set_member_value().

◆ queues_t_link

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

Definition at line 1925 of file app_queue.c.

Referenced by find_queue_by_name_rt(), and reload_single_queue().

◆ queues_t_unlink

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

Definition at line 1926 of file app_queue.c.

Referenced by find_queue_by_name_rt(), and leave_queue().

◆ RECHECK

#define RECHECK 1

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

Definition at line 1431 of file app_queue.c.

Referenced by wait_our_turn().

◆ RES_EXISTS

#define RES_EXISTS (-1)

Entry already exists

Definition at line 1442 of file app_queue.c.

Referenced by add_to_queue(), aqm_exec(), handle_queue_add_member(), handle_queue_remove_member(), manager_add_queue_member(), manager_remove_queue_member(), remove_from_queue(), and rqm_exec().

◆ RES_NOSUCHQUEUE

#define RES_NOSUCHQUEUE (-3)

No such queue

Definition at line 1444 of file app_queue.c.

Referenced by add_to_queue(), aqm_exec(), change_priority_caller_on_queue(), handle_queue_add_member(), handle_queue_change_priority_caller(), handle_queue_remove_member(), manager_add_queue_member(), manager_change_priority_caller_on_queue(), manager_remove_queue_member(), remove_from_queue(), and rqm_exec().

◆ RES_NOT_CALLER

#define RES_NOT_CALLER (-5)

Caller not found

Definition at line 1446 of file app_queue.c.

Referenced by change_priority_caller_on_queue(), handle_queue_change_priority_caller(), and manager_change_priority_caller_on_queue().

◆ RES_NOT_DYNAMIC

#define RES_NOT_DYNAMIC (-4)

Member is not dynamic

Definition at line 1445 of file app_queue.c.

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

◆ RES_OKAY

#define RES_OKAY 0

Action completed

Definition at line 1441 of file app_queue.c.

Referenced by add_to_queue(), aqm_exec(), change_priority_caller_on_queue(), handle_queue_add_member(), handle_queue_change_priority_caller(), handle_queue_remove_member(), manager_add_queue_member(), manager_change_priority_caller_on_queue(), manager_remove_queue_member(), remove_from_queue(), and rqm_exec().

◆ RES_OUTOFMEMORY

#define RES_OUTOFMEMORY (-2)

Out of memory

Definition at line 1443 of file app_queue.c.

Referenced by add_to_queue(), aqm_exec(), handle_queue_add_member(), handle_queue_remove_member(), manager_add_queue_member(), manager_remove_queue_member(), and reload_queue_members().

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

Definition at line 1325 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),
 };

◆ anonymous enum

anonymous enum

Enumerator
OPT_ARG_CALLEE_GO_ON
OPT_ARG_PREDIAL_CALLEE
OPT_ARG_PREDIAL_CALLER
OPT_ARG_ARRAY_SIZE

Definition at line 1349 of file app_queue.c.

      {
    OPT_ARG_CALLEE_GO_ON = 0,
    OPT_ARG_PREDIAL_CALLEE,
    OPT_ARG_PREDIAL_CALLER,
    /* 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 1381 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 1392 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 5853 of file app_queue.c.

                            {
    CALLER,
    AGENT,
    TRANSFER
 };

◆ 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 1622 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 1633 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 1398 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

Definition at line 1498 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_timeout_priority

enum queue_timeout_priority

Enumerator
TIMEOUT_PRIORITY_APP
TIMEOUT_PRIORITY_CONF

Definition at line 1523 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 9655 of file app_queue.c.

References ao2_container_count(), ao2_iterator_destroy(), AO2_ITERATOR_DONTLOCK, ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_t_iterator_next, ao2_unlock, ast_category_browse(), ast_channel_name(), ast_check_realtime(), ast_config_destroy(), AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, ast_devstate2str(), ast_load_realtime_multientry(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), ast_strlen_zero, ast_term_color(), ast_term_reset(), ast_variable_retrieve(), member::calls, call_queue::callsabandoned, call_queue::callsabandonedinsl, call_queue::callscompleted, call_queue::callscompletedinsl, queue_ent::chan, CLI_SHOWUSAGE, CLI_SUCCESS, COLOR_BLACK, COLOR_BROWN, COLOR_CYAN, COLOR_GREEN, COLOR_MAGENTA, COLOR_RED, call_queue::count, do_print(), member::dynamic, find_load_queue_rt_friendly(), call_queue::head, call_queue::holdtime, int2strat(), member::interface, member::lastcall, member::lastpause, 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, queue_t_unref, member::realtime, call_queue::realtime, member::reason_paused, member::ringinuse, SENTINEL, 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 queue_show().

 {
    struct call_queue *q;
    struct ast_str *out = ast_str_alloca(512);
    int found = 0;
    time_t now = time(NULL);
    struct ao2_iterator queue_iter;
    struct ao2_iterator mem_iter;
 
    if (argc != 2 && argc != 3) {
       return CLI_SHOWUSAGE;
    }
 
    if (argc == 3) { /* specific queue */
       if ((q = find_load_queue_rt_friendly(argv[2]))) {
          queue_t_unref(q, "Done with temporary pointer");
       }
    } else 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 ((q = find_load_queue_rt_friendly(queuename))) {
                queue_t_unref(q, "Done with temporary pointer");
             }
          }
          ast_config_destroy(cfg);
       }
    }
 
    ao2_lock(queues);
    queue_iter = ao2_iterator_init(queues, AO2_ITERATOR_DONTLOCK);
    while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
       float sl;
       float sl2;
 
       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 (argc < 3 && 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");
       }
 
       if (argc == 3 && strcasecmp(q->name, argv[2])) {
          ao2_unlock(q);
          queue_t_unref(q, "Done with iterator");
          continue;
       }
       found = 1;
 
       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");
             }
             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 */
       ao2_unlock(q);
       queue_t_unref(q, "Done with iterator"); /* Unref the iterator's reference */
    }
    ao2_iterator_destroy(&queue_iter);
    ao2_unlock(queues);
    if (!found) {
       if (argc == 3) {
          ast_str_set(&out, 0, "No such queue: %s.", argv[2]);
       } else {
          ast_str_set(&out, 0, "No queues.");
       }
       do_print(s, fd, ast_str_buffer(out));
    }
    return CLI_SUCCESS;
 }

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 11470 of file app_queue.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 11470 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 7373 of file app_queue.c.

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(), interface_exists(), is_member_available(), member_add_to_queue(), call_queue::name, NULL, queue_member_blob_create(), queue_publish_member_blob(), queue_t_unref, member::reason_paused, RES_EXISTS, RES_NOSUCHQUEUE, RES_OKAY, RES_OUTOFMEMORY, and call_queue::ringinuse.

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

 {
    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;
 }

◆ alloc_queue()

static struct call_queue* alloc_queue ( const char * queuename )

static

Definition at line 3531 of file app_queue.c.

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

Referenced by find_queue_by_name_rt(), and reload_single_queue().

 {
    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;
 }

◆ aqm_exec()

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

static

AddQueueMember application.

Definition at line 8017 of file app_queue.c.

References add_to_queue(), args, AST_APP_ARG, 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, member::interface, LOG_ERROR, LOG_NOTICE, LOG_WARNING, member::membername, NULL, options, parse(), pbx_builtin_setvar_helper(), member::penalty, RES_EXISTS, RES_NOSUCHQUEUE, RES_OKAY, RES_OUTOFMEMORY, member::state_interface, tmp(), and member::wrapuptime.

Referenced by load_module().

 {
    int res=-1;
    char *parse, *tmp, *temppos = 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 wrapuptime;
 
    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 (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, 0, queue_persistent_members, args.state_interface, NULL, 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", "");
       } else {
          ast_queue_log(args.queuename, ast_channel_uniqueid(chan), args.membername, "ADDMEMBER", "%s", "");
       }
       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;
 }

◆ AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM ( void )

Definition at line 11470 of file app_queue.c.

◆ autopause2int()

static int autopause2int ( const char * autopause )

static

Definition at line 1816 of file app_queue.c.

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

Referenced by queue_set_param().

 {
    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;
 }

◆ 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 5775 of file app_queue.c.

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().

 {
    /* 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;
 }

◆ callattempt_free()

static void callattempt_free ( struct callattempt * doomed )

static

Definition at line 4225 of file app_queue.c.

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().

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

◆ can_ring_entry()

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

static

Definition at line 4385 of file app_queue.c.

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

Referenced by ring_entry().

 {
    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 (!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;
 }

◆ change_priority_caller_on_queue()

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

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 7426 of file app_queue.c.

References ao2_lock, ao2_unlock, ast_channel_name(), ast_debug, queue_ent::chan, find_load_queue_rt_friendly(), call_queue::head, queue_ent::next, queue_ent::prio, priority, RES_NOSUCHQUEUE, RES_NOT_CALLER, and RES_OKAY.

Referenced by handle_queue_change_priority_caller(), and manager_change_priority_caller_on_queue().

 {
    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) == 0) {
          ast_debug(1, "%s Caller new prioriry %d in queue %s\n",
                       caller, priority, queuename);
          qe->prio = priority;
          res = RES_OKAY;
       }
    }
    ao2_unlock(q);
    return res;
 }

◆ clear_queue()

static void clear_queue ( struct call_queue * q )

static

Definition at line 2860 of file app_queue.c.

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().

 {
    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);
    }
 }

◆ 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

void

Definition at line 9593 of file app_queue.c.

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

Referenced by reload_handler().

 {
    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;
 }

◆ compare_weight()

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

static

Definition at line 4320 of file app_queue.c.

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, and call_queue::weight.

Referenced by can_ring_entry().

 {
    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;
 }

◆ 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 9894 of file app_queue.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_t_iterator_next, ast_strdup, call_queue::name, NULL, queue_t_unref, 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().

 {
    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;
 }

◆ complete_queue_add_member()

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

static

Definition at line 10391 of file app_queue.c.

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

Referenced by handle_queue_add_member().

 {
    /* 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;
    }
 }

◆ complete_queue_pause_member()

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

static

Definition at line 10764 of file app_queue.c.

References ast_strdup, complete_queue(), and NULL.

Referenced by handle_queue_pause_member().

 {
    /* 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;
    }
 }

◆ complete_queue_remove_member()

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

static

Definition at line 10604 of file app_queue.c.

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 tmp().

Referenced by handle_queue_remove_member().

 {
    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;
 }

◆ complete_queue_rule_show()

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

static

Definition at line 10959 of file app_queue.c.

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().

 {
    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;
 }

◆ 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 10838 of file app_queue.c.

References ast_strdup, complete_queue(), and NULL.

Referenced by handle_queue_set_member_penalty(), and handle_queue_set_member_ringinuse().

 {
    /* 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;
    }
 }

◆ complete_queue_show()

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

static

Definition at line 9931 of file app_queue.c.

References complete_queue(), and NULL.

Referenced by queue_show().

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

◆ compress_char()

static int compress_char ( const char c )

static

Definition at line 2727 of file app_queue.c.

Referenced by member_hash_fn().

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

◆ 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 8132 of file app_queue.c.

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, penalty_rule::time, and tmp().

Referenced by queue_exec().

 {
    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);
 }

◆ 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 2683 of file app_queue.c.

References ao2_alloc, ast_copy_string(), ast_extension_state_add(), ast_log, ast_strdupa, ast_strlen_zero, context, destroy_queue_member_cb(), exten, extension_state_cb(), get_queue_member_status(), member::interface, member::lastpause, LOG_WARNING, 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(), tmp(), and member::wrapuptime.

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

 {
    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 */
       }
       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;
 }

◆ destroy_queue()

static void destroy_queue ( void * obj )

static

Free queue's member list then its string fields.

Definition at line 3516 of file app_queue.c.

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().

 {
    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);
 }

◆ destroy_queue_member_cb()

static void destroy_queue_member_cb ( void * obj )

static

Definition at line 2673 of file app_queue.c.

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

Referenced by create_queue_member().

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

◆ 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 2506 of file app_queue.c.

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, stasis_message_data(), stasis_message_type(), ast_device_state_message::state, member::state_interface, and update_status().

Referenced by load_module().

 {
    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;
 }

◆ do_hang()

static void do_hang ( struct callattempt * o )

static

common hangup actions

Definition at line 4355 of file app_queue.c.

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

Referenced by ring_entry(), and wait_for_answer().

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

◆ do_print()

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

static

direct ouput to manager or cli with proper terminator

Definition at line 9640 of file app_queue.c.

References ast_cli(), and astman_append().

Referenced by __queues_show().

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

◆ 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 7265 of file app_queue.c.

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, member::reason_paused, member::state_interface, value, and member::wrapuptime.

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

 {
    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);
 }

◆ end_bridge_callback()

static void end_bridge_callback ( void * data )

static

Definition at line 6571 of file app_queue.c.

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

Referenced by try_calling().

 {
    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");
    }
 }

◆ 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 6564 of file app_queue.c.

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

Referenced by try_calling().

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

◆ escape_and_substitute()

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

static

Definition at line 6613 of file app_queue.c.

References input(), and pbx_substitute_variables_helper().

Referenced by setup_mixmonitor().

 {
    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);
 }

◆ 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 2624 of file app_queue.c.

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, ast_state_cb_info::exten_state, extensionstate2devicestate(), call_queue::found, call_queue::members, queue_t_unref, ast_state_cb_info::reason, member::state_context, member::state_exten, and update_status().

Referenced by create_queue_member(), and destroy_queue_member_cb().

 {
    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_context, context) && !strcmp(m->state_exten, exten)) {
             update_status(q, m, device_state);
             ao2_ref(m, -1);
             found = 1;
             break;
          }
       }
       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;
 }

◆ extensionstate2devicestate()

static int extensionstate2devicestate ( int state )

static

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

Definition at line 2593 of file app_queue.c.

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, 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().

 {
    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_ONHOLD:
       state = AST_DEVICE_ONHOLD;
       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;
 }

◆ find_best()

static struct callattempt* find_best ( struct callattempt * outgoing )

static

find the entry with the best metric, or NULL

Definition at line 4611 of file app_queue.c.

References callattempt::metric, NULL, and callattempt::q_next.

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

 {
    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;
 }

◆ 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 3699 of file app_queue.c.

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, call_queue::realtime, SENTINEL, update_realtime_members(), 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(), queue_function_exists(), queue_function_mem_read(), queue_function_qac_dep(), queue_function_queuememberlist(), queue_function_var(), qupd_exec(), reload_queue_members(), and set_member_value().

 {
    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;
 }

◆ find_member_by_queuename_and_interface()

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

static

Definition at line 11449 of file app_queue.c.

References ao2_find, ao2_lock, ao2_unlock, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_DEVSTATE_CONSUMER, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, find_load_queue_rt_friendly(), load_module(), call_queue::members, NULL, OBJ_KEY, queue_t_unref, reload(), and unload_module().

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

 {
    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;
 }

◆ 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 3555 of file app_queue.c.

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_WARNING, member_remove_from_queue(), member::membername, call_queue::members, ast_variable::name, call_queue::name, ast_variable::next, NULL, OBJ_POINTER, queue_set_param(), QUEUE_STRATEGY_RINGALL, queue_t_unref, queues_t_link, queues_t_unlink, member::realtime, call_queue::realtime, rt_handle_member_record(), strat2int(), call_queue::strategy, tmp(), and ast_variable::value.

Referenced by find_load_queue_rt_friendly().

 {
    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;
 }

◆ 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 3500 of file app_queue.c.

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().

 {
    /* 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);
 }

◆ get_interface_helper()

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

static

Definition at line 8610 of file app_queue.c.

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

Referenced by queue_function_mem_read().

 {
    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;
 }

◆ get_member_penalty()

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

static

Definition at line 7732 of file app_queue.c.

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

Referenced by queue_function_memberpenalty_read().

 {
    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 debuging */
    if (foundqueue) {
       ast_log (LOG_ERROR, "Invalid queuename\n");
    } else {
       ast_log (LOG_ERROR, "Invalid interface\n");
    }
 
    return RESULT_FAILURE;
 }

◆ 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
	)

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 2287 of file app_queue.c.

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_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 join_queue(), queue_exec(), and wait_our_turn().

 {
    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) {
          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);
    }
    return -1;
 }

◆ get_queue_member_status()

static int get_queue_member_status ( struct member * cur )

static

Return the current state of a member.

Definition at line 2668 of file app_queue.c.

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().

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

◆ 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 1859 of file app_queue.c.

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

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

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

◆ 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.
topic	The topic for this event.
msg	The stasis message for the attended transfer event.

Definition at line 6202 of file app_queue.c.

Referenced by setup_stasis_subs().

 {
    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);
 }

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ANNOUNCEHOLDTIME_ALWAYS

◆ ANNOUNCEHOLDTIME_ONCE

◆ ANNOUNCEPOSITION_LIMIT

◆ ANNOUNCEPOSITION_MORE_THAN

◆ ANNOUNCEPOSITION_NO

◆ ANNOUNCEPOSITION_YES

◆ AST_MAX_WATCHERS

◆ DEFAULT_MIN_ANNOUNCE_FREQUENCY

◆ DEFAULT_RETRY

◆ DEFAULT_TIMEOUT

◆ MAX_CALL_ATTEMPT_BUCKETS

◆ MAX_PERIODIC_ANNOUNCEMENTS

◆ MAX_QUEUE_BUCKETS

◆ QUEUE_EVENT_VARIABLES

◆ QUEUE_PAUSED_DEVSTATE

◆ queue_ref

◆ queue_t_ref

◆ queue_t_unref

◆ QUEUE_UNKNOWN_PAUSED_DEVSTATE

◆ QUEUE_UNPAUSED_DEVSTATE

◆ queue_unref

◆ queues_t_link

◆ queues_t_unlink

◆ RECHECK

◆ RES_EXISTS

◆ RES_NOSUCHQUEUE

◆ RES_NOT_CALLER

◆ RES_NOT_DYNAMIC

◆ RES_OKAY

◆ RES_OUTOFMEMORY

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ agent_complete_reason

◆ empty_conditions

◆ member_properties

◆ queue_reload_mask

◆ queue_result

◆ queue_timeout_priority

Function Documentation

◆ __queues_show()

◆ __reg_module()

◆ __unreg_module()

◆ add_to_queue()

◆ alloc_queue()

◆ aqm_exec()

◆ AST_MODULE_SELF_SYM()

◆ autopause2int()

◆ calc_metric()

◆ callattempt_free()

◆ can_ring_entry()

◆ change_priority_caller_on_queue()

◆ clear_queue()

◆ clear_stats()

◆ compare_weight()

◆ complete_queue()

◆ complete_queue_add_member()

◆ complete_queue_pause_member()

◆ complete_queue_remove_member()

◆ complete_queue_rule_show()

◆ complete_queue_set_member_value()

◆ complete_queue_show()

◆ compress_char()

◆ copy_rules()

◆ create_queue_member()

◆ destroy_queue()

◆ destroy_queue_member_cb()

◆ device_state_cb()

◆ do_hang()

◆ do_print()

◆ dump_queue_members()