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.