parking_manager.c File Reference

Call Parking Manager Actions and Events. More...

#include "asterisk.h"
#include "res_parking.h"
#include "asterisk/config.h"
#include "asterisk/config_options.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/astobj2.h"
#include "asterisk/features.h"
#include "asterisk/manager.h"
#include "asterisk/bridge.h"

Include dependency graph for parking_manager.c:

Go to the source code of this file.

Data Structures
struct	park_list_data

Functions
int	load_parking_manager (void)
	Register manager actions and setup subscriptions for stasis events. More...
static int	manager_append_event_parking_lot_data_cb (void *obj, void *arg, void *data, int flags)
static struct ast_str *	manager_build_parked_call_string (const struct ast_parked_call_payload *payload)
	Builds a manager string based on the contents of a parked call payload. More...
static int	manager_park (struct mansession *s, const struct message *m)
static void	manager_park_bridged (struct mansession *s, const struct message *m, struct ast_channel *chan, struct ast_channel *parker_chan, const char *parkinglot, int timeout_override)
static void	manager_park_unbridged (struct mansession *s, const struct message *m, struct ast_channel *chan, const char *parkinglot, int timeout_override)
static int	manager_parking_lot_list (struct mansession *s, const struct message *m)
static int	manager_parking_status (struct mansession *s, const struct message *m)
static void	manager_parking_status_all_lots (struct mansession *s, const struct message *m, const char *id_text)
static void	manager_parking_status_single_lot (struct mansession *s, const struct message *m, const char *id_text, const char *lot_name)
static void	parked_call_message_response (struct ast_parked_call_payload *parked_call)
static struct ast_parked_call_payload *	parked_call_payload_from_failure (struct ast_channel *chan)
static struct ast_parked_call_payload *	parked_call_payload_from_parked_user (struct parked_user *pu, enum ast_parked_call_event_type event_type)
static void	parking_event_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	parking_manager_disable_stasis (void)
static void	parking_manager_enable_stasis (void)
void	publish_parked_call (struct parked_user *pu, enum ast_parked_call_event_type event_type)
	Publish a stasis parked call message for a given parked user. More...
void	publish_parked_call_failure (struct ast_channel *parkee)
	Publish a stasis parked call message for the channel indicating failure to park. More...
void	unload_parking_manager (void)
	Unregister manager actions and remove subscriptions for stasis events. More...

Variables
static struct stasis_subscription *	parking_sub
	subscription to the parking lot topic More...

Detailed Description

Call Parking Manager Actions and Events.

Author

Jonathan Rose jrose.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file parking_manager.c.

Function Documentation

load_parking_manager()

int load_parking_manager

(

void

)

Register manager actions and setup subscriptions for stasis events.

Since

12.0.0

Definition at line 694 of file parking_manager.c.

References ast_manager_register_xml, EVENT_FLAG_CALL, manager_park(), manager_parking_lot_list(), manager_parking_status(), and parking_manager_enable_stasis().

Referenced by load_module().

{
 int res;

 res = ast_manager_register_xml("Parkinglots", EVENT_FLAG_CALL, manager_parking_lot_list);
 res |= ast_manager_register_xml("ParkedCalls", EVENT_FLAG_CALL, manager_parking_status);
 res |= ast_manager_register_xml("Park", EVENT_FLAG_CALL, manager_park);
 parking_manager_enable_stasis();
 return res ? -1 : 0;
}

manager_append_event_parking_lot_data_cb()

static int manager_append_event_parking_lot_data_cb ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 397 of file parking_manager.c.

References astman_append(), parking_lot::cfg, park_list_data::count, park_list_data::id_text, parking_lot::name, parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, and parking_lot_cfg::parkingtime.

Referenced by manager_parking_lot_list().

{
 struct parking_lot *curlot = obj;
 struct mansession *s = arg;
 struct park_list_data *list_data = data;

 astman_append(s, "Event: Parkinglot\r\n"
 "%s" /* The Action ID */
 "Name: %s\r\n"
 "StartSpace: %d\r\n"
 "StopSpace: %d\r\n"
 "Timeout: %u\r\n"
 "\r\n",
 list_data->id_text,
 curlot->name,
 curlot->cfg->parking_start,
 curlot->cfg->parking_stop,
 curlot->cfg->parkingtime);
 ++list_data->count;

 return 0;
}

manager_build_parked_call_string()

static struct ast_str* manager_build_parked_call_string ( const struct ast_parked_call_payload *  payload )

static

Builds a manager string based on the contents of a parked call payload.

Definition at line 215 of file parking_manager.c.

References ast_free, ast_manager_build_channel_state_string_prefix(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_parked_call_payload::duration, NULL, out, ast_parked_call_payload::parkee, ast_parked_call_payload::parker_dial_string, ast_parked_call_payload::parkinglot, ast_parked_call_payload::parkingspace, RAII_VAR, ast_parked_call_payload::retriever, and ast_parked_call_payload::timeout.

Referenced by manager_parking_status_all_lots(), manager_parking_status_single_lot(), and parked_call_message_response().

{
 struct ast_str *out = ast_str_create(1024);
 RAII_VAR(struct ast_str *, parkee_string, NULL, ast_free);
 RAII_VAR(struct ast_str *, retriever_string, NULL, ast_free);

 if (!out) {
 return NULL;
 }

 parkee_string = ast_manager_build_channel_state_string_prefix(payload->parkee, "Parkee");
 if (!parkee_string) {
 ast_free(out);
 return NULL;
 }

 if (payload->retriever) {
 retriever_string = ast_manager_build_channel_state_string_prefix(payload->retriever, "Retriever");
 if (!retriever_string) {
 ast_free(out);
 return NULL;
 }
 }

 ast_str_set(&out, 0,
 "%s" /* parkee channel state */
 "%s" /* retriever channel state (when available) */
 "ParkerDialString: %s\r\n"
 "Parkinglot: %s\r\n"
 "ParkingSpace: %u\r\n"
 "ParkingTimeout: %lu\r\n"
 "ParkingDuration: %lu\r\n",

 ast_str_buffer(parkee_string),
 retriever_string ? ast_str_buffer(retriever_string) : "",
 payload->parker_dial_string,
 payload->parkinglot,
 payload->parkingspace,
 payload->timeout,
 payload->duration);

 return out;
}

manager_park()

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

static

Definition at line 519 of file parking_manager.c.

References ao2_cleanup, ast_bridge_set_transfer_variables(), ast_channel_bridge_peer(), ast_channel_cleanup, ast_channel_get_by_name(), ast_channel_lock, ast_channel_name(), ast_channel_uniqueid(), ast_channel_unlock, ast_strlen_zero, astman_get_header(), astman_send_error(), buf, ast_bridge_channel::chan, create_parked_subscription(), manager_park_bridged(), manager_park_unbridged(), MAX, NULL, parkinglot, RAII_VAR, S_OR, and timeout.

Referenced by load_parking_manager().

{
 const char *channel = astman_get_header(m, "Channel");
 const char *timeout_channel = S_OR(astman_get_header(m, "TimeoutChannel"), astman_get_header(m, "Channel2"));
 const char *announce_channel = astman_get_header(m, "AnnounceChannel");
 const char *timeout = astman_get_header(m, "Timeout");
 const char *parkinglot = astman_get_header(m, "Parkinglot");
 char buf[BUFSIZ];
 int timeout_override = -1;

 RAII_VAR(struct ast_channel *, parker_chan, NULL, ao2_cleanup);
 RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "Channel not specified");
 return 0;
 }

 if (!ast_strlen_zero(timeout)) {
 if (sscanf(timeout, "%30d", &timeout_override) != 1 || timeout_override < 0) {
 astman_send_error(s, m, "Invalid Timeout value.");
 return 0;
 }

 if (timeout_override) {
 /* If greater than zero, convert to seconds for internal use. Must be >= 1 second. */
 timeout_override = MAX(1, timeout_override / 1000);
 }
 }

 if (!(chan = ast_channel_get_by_name(channel))) {
 snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel);
 astman_send_error(s, m, buf);
 return 0;
 }

 if (!ast_strlen_zero(timeout_channel)) {
 ast_channel_lock(chan);
 ast_bridge_set_transfer_variables(chan, timeout_channel, 0);
 ast_channel_unlock(chan);
 }

 parker_chan = ast_channel_bridge_peer(chan);
 if (!parker_chan || strcmp(ast_channel_name(parker_chan), timeout_channel)) {
 if (!ast_strlen_zero(announce_channel)) {
 struct ast_channel *announce_chan = ast_channel_get_by_name(announce_channel);
 if (!announce_channel) {
 astman_send_error(s, m, "AnnounceChannel does not exist");
 return 0;
 }

 create_parked_subscription(announce_chan, ast_channel_uniqueid(chan), 0);
 ast_channel_cleanup(announce_chan);
 }

 manager_park_unbridged(s, m, chan, parkinglot, timeout_override);
 return 0;
 }

 if (!ast_strlen_zero(announce_channel) && strcmp(announce_channel, timeout_channel)) {
 /* When using an announce_channel in bridge mode, only add the announce channel if it isn't
 * the same as the timeout channel (which will play announcements anyway) */
 struct ast_channel *announce_chan = ast_channel_get_by_name(announce_channel);
 if (!announce_channel) {
 astman_send_error(s, m, "AnnounceChannel does not exist");
 return 0;
 }

 create_parked_subscription(announce_chan, ast_channel_uniqueid(chan), 0);
 ast_channel_cleanup(announce_chan);
 }

 manager_park_bridged(s, m, chan, parker_chan, parkinglot, timeout_override);
 return 0;
}

manager_park_bridged()

static void manager_park_bridged ( struct mansession *  s, const struct message *  m, struct ast_channel *  chan, struct ast_channel *  parker_chan, const char *  parkinglot, int  timeout_override  )

static

Definition at line 473 of file parking_manager.c.

References ao2_cleanup, ast_asprintf, ast_bridge_channel_write_park(), ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, ast_free, astman_send_ack(), astman_send_error(), and create_parked_subscription().

Referenced by manager_park().

{
 struct ast_bridge_channel *bridge_channel;
 char *app_data;

 if (timeout_override != -1) {
 if (ast_asprintf(&app_data, "%s,t(%d)", parkinglot, timeout_override) == -1) {
 astman_send_error(s, m, "Park action failed\n");
 return;
 }
 } else {
 if (ast_asprintf(&app_data, "%s", parkinglot) == -1) {
 astman_send_error(s, m, "Park action failed\n");
 return;
 }
 }

 ast_channel_lock(parker_chan);
 bridge_channel = ast_channel_get_bridge_channel(parker_chan);
 ast_channel_unlock(parker_chan);

 if (!bridge_channel) {
 ast_free(app_data);
 astman_send_error(s, m, "Park action failed\n");
 return;
 }

 /* Subscribe to park messages for the channel being parked */
 if (create_parked_subscription(parker_chan, ast_channel_uniqueid(chan), 1)) {
 ast_free(app_data);
 astman_send_error(s, m, "Park action failed\n");
 ao2_cleanup(bridge_channel);
 return;
 }

 ast_bridge_channel_write_park(bridge_channel, ast_channel_uniqueid(chan),
 ast_channel_uniqueid(parker_chan), app_data);

 ast_free(app_data);

 astman_send_ack(s, m, "Park successful\n");
 ao2_cleanup(bridge_channel);
}

manager_park_unbridged()

static void manager_park_unbridged ( struct mansession *  s, const struct message *  m, struct ast_channel *  chan, const char *  parkinglot, int  timeout_override  )

static

Definition at line 452 of file parking_manager.c.

References ao2_cleanup, ast_bridge_add_channel(), astman_send_ack(), astman_send_error(), NULL, and park_common_setup().

Referenced by manager_park().

{
 struct ast_bridge *parking_bridge = park_common_setup(chan,
 chan, parkinglot, NULL, 0, 0, timeout_override, 1);

 if (!parking_bridge) {
 astman_send_error(s, m, "Park action failed\n");
 return;
 }

 if (ast_bridge_add_channel(parking_bridge, chan, NULL, 0, NULL)) {
 astman_send_error(s, m, "Park action failed\n");
 ao2_cleanup(parking_bridge);
 return;
 }

 astman_send_ack(s, m, "Park successful\n");
 ao2_cleanup(parking_bridge);
}

manager_parking_lot_list()

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

static

Definition at line 420 of file parking_manager.c.

References ao2_callback_data, ast_log, ast_strlen_zero, astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), park_list_data::count, get_parking_lot_container(), park_list_data::id_text, LOG_ERROR, manager_append_event_parking_lot_data_cb(), OBJ_MULTIPLE, and OBJ_NODATA.

Referenced by load_parking_manager().

{
 const char *id = astman_get_header(m, "ActionID");
 struct ao2_container *lot_container;
 char id_text[256];
 struct park_list_data list_data;

 id_text[0] = '\0';
 if (!ast_strlen_zero(id)) {
 snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
 }

 lot_container = get_parking_lot_container();
 if (!lot_container) {
 ast_log(LOG_ERROR, "Failed to obtain parking lot list. Action canceled.\n");
 astman_send_error(s, m, "Could not create parking lot list");
 return 0;
 }

 astman_send_listack(s, m, "Parking lots will follow", "start");

 list_data.id_text = id_text;
 list_data.count = 0;
 ao2_callback_data(lot_container, OBJ_MULTIPLE | OBJ_NODATA,
 manager_append_event_parking_lot_data_cb, s, &list_data);

 astman_send_list_complete_start(s, m, "ParkinglotsComplete", list_data.count);
 astman_send_list_complete_end(s);

 return 0;
}

manager_parking_status()

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

static

Definition at line 372 of file parking_manager.c.

References ast_strlen_zero, astman_get_header(), manager_parking_status_all_lots(), and manager_parking_status_single_lot().

Referenced by load_parking_manager().

{
 const char *id = astman_get_header(m, "ActionID");
 const char *lot_name = astman_get_header(m, "ParkingLot");
 char id_text[256];

 id_text[0] = '\0';
 if (!ast_strlen_zero(id)) {
 snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
 }

 if (!ast_strlen_zero(lot_name)) {
 manager_parking_status_single_lot(s, m, id_text, lot_name);
 } else {
 manager_parking_status_all_lots(s, m, id_text);
 }

 return 0;
}

manager_parking_status_all_lots()

static void manager_parking_status_all_lots ( struct mansession *  s, const struct message *  m, const char *  id_text  )

static

Definition at line 309 of file parking_manager.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_free, ast_log, ast_str_buffer(), astman_append(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), get_parking_lot_container(), LOG_ERROR, manager_build_parked_call_string(), NULL, PARKED_CALL, parked_call_payload_from_parked_user(), parking_lot::parked_users, RAII_VAR, and total.

Referenced by manager_parking_status().

{
 struct parked_user *curuser;
 struct ao2_container *lot_container;
 struct ao2_iterator iter_lots;
 struct ao2_iterator iter_users;
 struct parking_lot *curlot;
 int total = 0;

 lot_container = get_parking_lot_container();
 if (!lot_container) {
 ast_log(LOG_ERROR, "Failed to obtain parking lot list. Action canceled.\n");
 astman_send_error(s, m, "Could not create parking lot list");
 return;
 }

 astman_send_listack(s, m, "Parked calls will follow", "start");

 iter_lots = ao2_iterator_init(lot_container, 0);
 while ((curlot = ao2_iterator_next(&iter_lots))) {
 iter_users = ao2_iterator_init(curlot->parked_users, 0);
 while ((curuser = ao2_iterator_next(&iter_users))) {
 RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
 RAII_VAR(struct ast_str *, parked_call_string, NULL, ast_free);

 payload = parked_call_payload_from_parked_user(curuser, PARKED_CALL);
 if (!payload) {
 ao2_ref(curuser, -1);
 ao2_iterator_destroy(&iter_users);
 ao2_ref(curlot, -1);
 goto abort_list;
 }

 parked_call_string = manager_build_parked_call_string(payload);
 if (!parked_call_string) {
 ao2_ref(curuser, -1);
 ao2_iterator_destroy(&iter_users);
 ao2_ref(curlot, -1);
 goto abort_list;
 }

 total++;

 astman_append(s, "Event: ParkedCall\r\n"
 "%s" /* The parked call string */
 "%s" /* The action ID */
 "\r\n",
 ast_str_buffer(parked_call_string),
 id_text);

 ao2_ref(curuser, -1);
 }
 ao2_iterator_destroy(&iter_users);
 ao2_ref(curlot, -1);
 }
abort_list:
 ao2_iterator_destroy(&iter_lots);

 astman_send_list_complete_start(s, m, "ParkedCallsComplete", total);
 astman_append(s, "Total: %d\r\n", total);
 astman_send_list_complete_end(s);
}

manager_parking_status_single_lot()

static void manager_parking_status_single_lot ( struct mansession *  s, const struct message *  m, const char *  id_text, const char *  lot_name  )

static

Definition at line 259 of file parking_manager.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_free, ast_str_buffer(), astman_append(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), manager_build_parked_call_string(), NULL, PARKED_CALL, parked_call_payload_from_parked_user(), parking_lot_find_by_name(), RAII_VAR, and total.

Referenced by manager_parking_status().

{
 RAII_VAR(struct parking_lot *, curlot, NULL, ao2_cleanup);
 struct parked_user *curuser;
 struct ao2_iterator iter_users;
 int total = 0;

 curlot = parking_lot_find_by_name(lot_name);
 if (!curlot) {
 astman_send_error(s, m, "Requested parking lot could not be found.");
 return;
 }

 astman_send_listack(s, m, "Parked calls will follow", "start");

 iter_users = ao2_iterator_init(curlot->parked_users, 0);
 while ((curuser = ao2_iterator_next(&iter_users))) {
 RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
 RAII_VAR(struct ast_str *, parked_call_string, NULL, ast_free);

 payload = parked_call_payload_from_parked_user(curuser, PARKED_CALL);
 if (!payload) {
 ao2_ref(curuser, -1);
 break;
 }

 parked_call_string = manager_build_parked_call_string(payload);
 if (!parked_call_string) {
 ao2_ref(curuser, -1);
 break;
 }

 total++;

 astman_append(s, "Event: ParkedCall\r\n"
 "%s" /* The parked call string */
 "%s" /* The action ID */
 "\r\n",
 ast_str_buffer(parked_call_string),
 id_text);

 ao2_ref(curuser, -1);
 }
 ao2_iterator_destroy(&iter_users);

 astman_send_list_complete_start(s, m, "ParkedCallsComplete", total);
 astman_append(s, "Total: %d\r\n", total);
 astman_send_list_complete_end(s);
}

parked_call_message_response()

static void parked_call_message_response ( struct ast_parked_call_payload *  parked_call )

static

Definition at line 639 of file parking_manager.c.

References ast_free, ast_log, ast_str_buffer(), EVENT_FLAG_CALL, ast_parked_call_payload::event_type, LOG_ERROR, manager_build_parked_call_string(), manager_event, NULL, PARKED_CALL, PARKED_CALL_FAILED, PARKED_CALL_GIVEUP, PARKED_CALL_SWAP, PARKED_CALL_TIMEOUT, PARKED_CALL_UNPARKED, and RAII_VAR.

Referenced by parking_event_cb().

{
 char *event_type = "";
 RAII_VAR(struct ast_str *, parked_call_string, NULL, ast_free);

 switch (parked_call->event_type) {
 case PARKED_CALL:
 event_type = "ParkedCall";
 break;
 case PARKED_CALL_TIMEOUT:
 event_type = "ParkedCallTimeOut";
 break;
 case PARKED_CALL_GIVEUP:
 event_type = "ParkedCallGiveUp";
 break;
 case PARKED_CALL_UNPARKED:
 event_type = "UnParkedCall";
 break;
 case PARKED_CALL_SWAP:
 event_type = "ParkedCallSwap";
 break;
 case PARKED_CALL_FAILED:
 /* PARKED_CALL_FAILED doesn't currently get a message and is used exclusively for bridging */
 return;
 }

 parked_call_string = manager_build_parked_call_string(parked_call);
 if (!parked_call_string) {
 ast_log(LOG_ERROR, "Failed to issue an AMI event of '%s' in response to a stasis message.\n", event_type);
 return;
 }

 manager_event(EVENT_FLAG_CALL, event_type,
 "%s",
 ast_str_buffer(parked_call_string)
 );
}

parked_call_payload_from_failure()

static struct ast_parked_call_payload* parked_call_payload_from_failure ( struct ast_channel *  chan )

static

Definition at line 178 of file parking_manager.c.

References ao2_cleanup, ast_channel_lock, ast_channel_snapshot_create(), ast_channel_unlock, ast_parked_call_payload_create(), NULL, PARKED_CALL_FAILED, and RAII_VAR.

Referenced by publish_parked_call_failure().

{
 RAII_VAR(struct ast_channel_snapshot *, parkee_snapshot, NULL, ao2_cleanup);

 ast_channel_lock(chan);
 parkee_snapshot = ast_channel_snapshot_create(chan);
 ast_channel_unlock(chan);
 if (!parkee_snapshot) {
 return NULL;
 }

 return ast_parked_call_payload_create(PARKED_CALL_FAILED, parkee_snapshot, NULL, NULL, NULL, 0, 0, 0);
}

parked_call_payload_from_parked_user()

static struct ast_parked_call_payload* parked_call_payload_from_parked_user ( struct parked_user *  pu, enum ast_parked_call_event_type  event_type  )

static

Definition at line 192 of file parking_manager.c.

References ao2_cleanup, ast_channel_lock, ast_channel_snapshot_create(), ast_channel_unlock, ast_parked_call_payload_create(), ast_tvnow(), parked_user::chan, ast_parked_call_payload::duration, parked_user::lot, parking_lot::name, NULL, parked_user::parker_dial_string, parked_user::parking_space, RAII_VAR, parked_user::retriever, parked_user::start, parked_user::time_limit, and timeout.

Referenced by manager_parking_status_all_lots(), manager_parking_status_single_lot(), and publish_parked_call().

{
 RAII_VAR(struct ast_channel_snapshot *, parkee_snapshot, NULL, ao2_cleanup);
 long int timeout;
 long int duration;
 struct timeval now = ast_tvnow();
 const char *lot_name = pu->lot->name;

 ast_channel_lock(pu->chan);
 parkee_snapshot = ast_channel_snapshot_create(pu->chan);
 ast_channel_unlock(pu->chan);
 if (!parkee_snapshot) {
 return NULL;
 }

 timeout = pu->start.tv_sec + (long) pu->time_limit - now.tv_sec;
 duration = now.tv_sec - pu->start.tv_sec;

 return ast_parked_call_payload_create(event_type, parkee_snapshot, pu->parker_dial_string, pu->retriever, lot_name, pu->parking_space, timeout, duration);

}

parking_event_cb()

static void parking_event_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 677 of file parking_manager.c.

References ast_parked_call_type(), parked_call_message_response(), stasis_message_data(), and stasis_message_type().

Referenced by parking_manager_enable_stasis().

{
 if (stasis_message_type(message) == ast_parked_call_type()) {
 struct ast_parked_call_payload *parked_call_message = stasis_message_data(message);
 parked_call_message_response(parked_call_message);
 }
}

parking_manager_disable_stasis()

static void parking_manager_disable_stasis ( void  )

static

Definition at line 705 of file parking_manager.c.

References stasis_unsubscribe_and_join().

Referenced by unload_parking_manager().

{
 parking_sub = stasis_unsubscribe_and_join(parking_sub);
}

parking_manager_enable_stasis()

static void parking_manager_enable_stasis ( void  )

static

Definition at line 685 of file parking_manager.c.

References ast_parked_call_type(), ast_parking_topic(), NULL, parking_event_cb(), stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, and stasis_subscription_set_filter().

Referenced by load_parking_manager().

{
 if (!parking_sub) {
 parking_sub = stasis_subscribe(ast_parking_topic(), parking_event_cb, NULL);
 stasis_subscription_accept_message_type(parking_sub, ast_parked_call_type());
 stasis_subscription_set_filter(parking_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 }
}

publish_parked_call()

void publish_parked_call	(	struct parked_user *	pu,
		enum ast_parked_call_event_type	event_type
	)

Publish a stasis parked call message for a given parked user.

Since

12.0.0

Parameters

pu	pointer to a parked_user that we are generating the message for
event_type	What parked call event type is provoking this message

Definition at line 617 of file parking_manager.c.

References ao2_cleanup, ast_parked_call_type(), ast_parking_topic(), NULL, parked_call_payload_from_parked_user(), RAII_VAR, stasis_message_create(), and stasis_publish().

Referenced by bridge_parking_pull(), and bridge_parking_push().

{
 RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);

 if (!ast_parked_call_type()) {
 return;
 }

 payload = parked_call_payload_from_parked_user(pu, event_type);
 if (!payload) {
 return;
 }

 msg = stasis_message_create(ast_parked_call_type(), payload);
 if (!msg) {
 return;
 }

 stasis_publish(ast_parking_topic(), msg);
}

publish_parked_call_failure()

void publish_parked_call_failure

(

struct ast_channel *

parkee

)

Publish a stasis parked call message for the channel indicating failure to park.

Since

12.0.0

Parameters

parkee

channel belonging to the failed parkee

Definition at line 595 of file parking_manager.c.

References ao2_cleanup, ast_parked_call_type(), ast_parking_topic(), NULL, parked_call_payload_from_failure(), RAII_VAR, stasis_message_create(), and stasis_publish().

Referenced by bridge_parking_push(), park_app_exec(), and parking_park_bridge_channel().

{
 RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);

 if (!ast_parked_call_type()) {
 return;
 }

 payload = parked_call_payload_from_failure(parkee);
 if (!payload) {
 return;
 }

 msg = stasis_message_create(ast_parked_call_type(), payload);
 if (!msg) {
 return;
 }

 stasis_publish(ast_parking_topic(), msg);
}

unload_parking_manager()

void unload_parking_manager

(

void

)

Unregister manager actions and remove subscriptions for stasis events.

Since

12.0.0

Definition at line 710 of file parking_manager.c.

References ast_manager_unregister(), and parking_manager_disable_stasis().

Referenced by unload_module().

{
 ast_manager_unregister("Parkinglots");
 ast_manager_unregister("ParkedCalls");
 ast_manager_unregister("Park");
 parking_manager_disable_stasis();
}

Variable Documentation

parking_sub

struct stasis_subscription* parking_sub

static

subscription to the parking lot topic

Definition at line 176 of file parking_manager.c.