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 728 of file parking_manager.c.

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

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

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 426 of file parking_manager.c.

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

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

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 244 of file parking_manager.c.

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

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

manager_park()

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

static

Definition at line 548 of file parking_manager.c.

{
    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");
    const char *parkingspace = astman_get_header(m, "ParkingSpace");
    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);
    }
    
    if (!ast_strlen_zero(parkingspace)) {
        pbx_builtin_setvar_helper(chan, "PARKINGEXTEN", parkingspace);
    }
    
    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;
}

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, pbx_builtin_setvar_helper(), RAII_VAR, and S_OR.

Referenced by load_parking_manager().

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 502 of file parking_manager.c.

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

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(), ast_bridge_channel::chan, and create_parked_subscription().

Referenced by manager_park().

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 481 of file parking_manager.c.

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

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

Referenced by manager_park().

manager_parking_lot_list()

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

static

Definition at line 449 of file parking_manager.c.

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

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

manager_parking_status()

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

static

Definition at line 401 of file parking_manager.c.

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

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

Referenced by load_parking_manager().

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 338 of file parking_manager.c.

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

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

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 288 of file parking_manager.c.

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

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

parked_call_message_response()

static void parked_call_message_response ( struct ast_parked_call_payload *  parked_call )

static

Definition at line 673 of file parking_manager.c.

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

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

parked_call_payload_from_failure()

static struct ast_parked_call_payload * parked_call_payload_from_failure ( struct ast_channel *  chan )

static

Definition at line 207 of file parking_manager.c.

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

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

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 221 of file parking_manager.c.

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

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 ast_parked_call_payload::timeout.

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

parking_event_cb()

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

static

Definition at line 711 of file parking_manager.c.

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

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

Referenced by parking_manager_enable_stasis().

parking_manager_disable_stasis()

static void parking_manager_disable_stasis ( void  )

static

Definition at line 739 of file parking_manager.c.

{
    parking_sub = stasis_unsubscribe_and_join(parking_sub);
}

References parking_sub, and stasis_unsubscribe_and_join().

Referenced by unload_parking_manager().

parking_manager_enable_stasis()

static void parking_manager_enable_stasis ( void  )

static

Definition at line 719 of file parking_manager.c.

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

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

Referenced by load_parking_manager().

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 651 of file parking_manager.c.

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

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

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 629 of file parking_manager.c.

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

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

unload_parking_manager()

void unload_parking_manager

(

void

)

Unregister manager actions and remove subscriptions for stasis events.

Since

12.0.0

Definition at line 744 of file parking_manager.c.

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

References ast_manager_unregister(), and parking_manager_disable_stasis().

Referenced by unload_module().

Variable Documentation

parking_sub

struct stasis_subscription* parking_sub

static

subscription to the parking lot topic

Definition at line 205 of file parking_manager.c.

Referenced by parking_manager_disable_stasis(), and parking_manager_enable_stasis().