static int change_monitor_action(struct mansession *s, struct message *m)
{
struct ast_channel *c = NULL;
char *name = astman_get_header(m, "Channel");
char *fname = astman_get_header(m, "File");
if (ast_strlen_zero(name)) {
astman_send_error(s, m, "No channel specified");
return 0;
}
if (ast_strlen_zero(fname)) {
astman_send_error(s, m, "No filename specified");
return 0;
}
c = ast_get_channel_by_name_locked(name);
if (!c) {
astman_send_error(s, m, "No such channel");
return 0;
}
if (ast_monitor_change_fname(c, fname, 1)) {
astman_send_error(s, m, "Could not change monitored filename of channel");
ast_channel_unlock(c);
return 0;
}
ast_channel_unlock(c);
astman_send_ack(s, m, "Changed monitor filename");
return 0;
}
static int manager_dbdeltree(struct mansession *s, const struct message *m)
{
const char *family = astman_get_header(m, "Family");
const char *key = astman_get_header(m, "Key");
int num_deleted;
if (ast_strlen_zero(family)) {
astman_send_error(s, m, "No family specified.");
return 0;
}
if (!ast_strlen_zero(key)) {
num_deleted = ast_db_deltree(family, key);
} else {
num_deleted = ast_db_deltree(family, NULL);
}
if (num_deleted < 0) {
astman_send_error(s, m, "Database unavailable");
} else if (num_deleted == 0) {
astman_send_error(s, m, "Database entry not found");
} else {
astman_send_ack(s, m, "Key tree deleted successfully");
}
return 0;
}
static int manager_optimize_away(struct mansession *s, const struct message *m)
{
const char *channel;
struct local_pvt *p;
struct local_pvt *found;
struct ast_channel *chan;
channel = astman_get_header(m, "Channel");
if (ast_strlen_zero(channel)) {
astman_send_error(s, m, "'Channel' not specified.");
return 0;
}
chan = ast_channel_get_by_name(channel);
if (!chan) {
astman_send_error(s, m, "Channel does not exist.");
return 0;
}
p = ast_channel_tech_pvt(chan);
ast_channel_unref(chan);
found = p ? ao2_find(locals, p, 0) : NULL;
if (found) {
ao2_lock(found);
ast_clear_flag(&found->base, AST_UNREAL_NO_OPTIMIZATION);
ao2_unlock(found);
ao2_ref(found, -1);
astman_send_ack(s, m, "Queued channel to be optimized away");
} else {
astman_send_error(s, m, "Unable to find channel");
}
return 0;
}
static int do_pause_or_unpause(struct mansession *s, struct message *m, int action)
{
struct ast_channel *c = NULL;
char *name = astman_get_header(m, "Channel");
if (IS_NULL_STRING(name)) {
astman_send_error(s, m, "No channel specified");
return -1;
}
c = ast_get_channel_by_name_locked(name);
if (!c) {
astman_send_error(s, m, "No such channel");
return -1;
}
if (action == MONITOR_ACTION_PAUSE)
ast_monitor_pause(c);
else
ast_monitor_unpause(c);
ast_channel_unlock(c);
astman_send_ack(s, m, "Paused monitoring of the channel");
return 0;
}
/*!
* \internal
* \brief Delete the requested mailboxes.
* \since 12.1.0
*
* \param s AMI session.
* \param m AMI message.
*
* \retval 0 to keep AMI connection.
* \retval -1 to disconnect AMI connection.
*/
static int mwi_mailbox_delete(struct mansession *s, const struct message *m)
{
const char *mailbox_id = astman_get_header(m, "Mailbox");
if (ast_strlen_zero(mailbox_id)) {
astman_send_error(s, m, "Missing mailbox parameter in request");
return 0;
}
if (*mailbox_id == '/') {
struct ast_str *regex_string;
regex_string = ast_str_create(strlen(mailbox_id) + 1);
if (!regex_string) {
astman_send_error(s, m, "Memory Allocation Failure");
return 0;
}
/* Make "/regex/" into "regex" */
if (ast_regex_string_to_regex_pattern(mailbox_id, ®ex_string) != 0) {
astman_send_error_va(s, m, "Mailbox regex format invalid in: %s", mailbox_id);
ast_free(regex_string);
return 0;
}
ast_mwi_mailbox_delete_by_regex(ast_str_buffer(regex_string));
ast_free(regex_string);
} else {
ast_mwi_mailbox_delete(mailbox_id);
}
astman_send_ack(s, m, NULL);
return 0;
}
static int manager_dbput(struct mansession *s, struct message *m)
{
char *family = astman_get_header(m, "Family");
char *key = astman_get_header(m, "Key");
char *val = astman_get_header(m, "Val");
int res;
if (ast_strlen_zero(family)) {
astman_send_error(s, m, "No family specified");
return 0;
}
if (ast_strlen_zero(key)) {
astman_send_error(s, m, "No key specified");
return 0;
}
if (ast_strlen_zero(val)) {
astman_send_error(s, m, "No val specified");
return 0;
}
res = ast_db_put(family, key, val);
if (res) {
astman_send_error(s, m, "Failed to update entry");
} else {
astman_send_ack(s, m, "Updated database successfully");
}
return 0;
}
static int action_setcdruserfield(struct mansession *s, struct message *m)
{
struct cw_channel *c = NULL;
char *userfield = astman_get_header(m, "UserField");
char *channel = astman_get_header(m, "Channel");
char *append = astman_get_header(m, "Append");
if (cw_strlen_zero(channel)) {
astman_send_error(s, m, "No Channel specified");
return 0;
}
if (cw_strlen_zero(userfield)) {
astman_send_error(s, m, "No UserField specified");
return 0;
}
c = cw_get_channel_by_name_locked(channel);
if (!c) {
astman_send_error(s, m, "No such channel");
return 0;
}
if (cw_true(append))
cw_cdr_appenduserfield(c, userfield);
else
cw_cdr_setuserfield(c, userfield);
cw_mutex_unlock(&c->lock);
astman_send_ack(s, m, "CDR Userfield Set");
return 0;
}
static int manager_parking_lot_list(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m, "ActionID");
char id_text[256] = "";
struct ao2_container *lot_container;
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 -1;
}
astman_send_ack(s, m, "Parking lots will follow");
ao2_callback_data(lot_container, OBJ_MULTIPLE | OBJ_NODATA, manager_append_event_parking_lot_data_cb, s, id_text);
astman_append(s,
"Event: ParkinglotsComplete\r\n"
"%s"
"\r\n",id_text);
return RESULT_SUCCESS;
}
/*!
* \interanl
* \brief Completes SIPNotify AMI command in Endpoint mode.
*/
static void manager_notify_endpoint(struct mansession *s,
const struct message *m, const char *endpoint_name)
{
struct ast_variable *vars = astman_get_variables_order(m, ORDER_NATURAL);
if (!strncasecmp(endpoint_name, "sip/", 4)) {
endpoint_name += 4;
}
if (!strncasecmp(endpoint_name, "pjsip/", 6)) {
endpoint_name += 6;
}
switch (push_notify(endpoint_name, vars, notify_ami_data_create)) {
case INVALID_ENDPOINT:
ast_variables_destroy(vars);
astman_send_error_va(s, m, "Unable to retrieve endpoint %s",
endpoint_name);
break;
case ALLOC_ERROR:
ast_variables_destroy(vars);
astman_send_error(s, m, "Unable to allocate NOTIFY task data");
break;
case TASK_PUSH_ERROR:
/* Don't need to destroy vars since it is handled by cleanup in push_notify */
astman_send_error(s, m, "Unable to push NOTIFY task");
break;
case SUCCESS:
astman_send_ack(s, m, "NOTIFY sent");
break;
}
}
static int manager_parking_status_single_lot(struct mansession *s, const struct message *m, const char *id_text, const char *lot_name)
{
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 RESULT_SUCCESS;
}
astman_send_ack(s, m, "Parked calls will follow");
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) {
astman_send_error(s, m, "Failed to retrieve parking data about a parked user.");
return RESULT_FAILURE;
}
parked_call_string = manager_build_parked_call_string(payload);
if (!parked_call_string) {
astman_send_error(s, m, "Failed to retrieve parkingd ata about a parked user.");
return RESULT_FAILURE;
}
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_append(s,
"Event: ParkedCallsComplete\r\n"
"Total: %d\r\n"
"%s"
"\r\n",
total, id_text);
return RESULT_SUCCESS;
}
static int manager_park(struct mansession *s, const struct message *m)
{
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 *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 *, chan, NULL, ao2_cleanup);
RAII_VAR(struct ast_bridge *, parking_bridge, 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 < 0) {
astman_send_error(s, m, "Invalid Timeout value.");
return 0;
}
if (timeout_override > 0) {
/* 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;
}
ast_channel_lock(chan);
if (!ast_strlen_zero(timeout_channel)) {
pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", timeout_channel);
}
ast_channel_unlock(chan);
if (!(parking_bridge = park_common_setup(chan, chan, parkinglot, NULL, 0, 0, timeout_override, 0))) {
astman_send_error(s, m, "Park action failed\n");
return 0;
}
if (ast_bridge_add_channel(parking_bridge, chan, NULL, 0, NULL)) {
astman_send_error(s, m, "Park action failed\n");
return 0;
}
astman_send_ack(s, m, "Park successful\n");
return 0;
}
static int start_monitor_action(struct mansession *s, struct message *m)
{
struct ast_channel *c = NULL;
char *name = astman_get_header(m, "Channel");
char *fname = astman_get_header(m, "File");
char *format = astman_get_header(m, "Format");
char *mix = astman_get_header(m, "Mix");
char *d;
if (ast_strlen_zero(name)) {
astman_send_error(s, m, "No channel specified");
return 0;
}
c = ast_get_channel_by_name_locked(name);
if (!c) {
astman_send_error(s, m, "No such channel");
return 0;
}
if (ast_strlen_zero(fname)) {
/* No filename base specified, default to channel name as per CLI */
fname = malloc (FILENAME_MAX);
if (!fname) {
astman_send_error(s, m, "Could not start monitoring channel");
ast_mutex_unlock(&c->lock);
return 0;
}
memset(fname, 0, FILENAME_MAX);
ast_copy_string(fname, c->name, FILENAME_MAX);
/* Channels have the format technology/channel_name - have to replace that / */
if ((d=strchr(fname, '/'))) *d='-';
}
if (ast_monitor_start(c, format, fname, 1)) {
if (ast_monitor_change_fname(c, fname, 1)) {
astman_send_error(s, m, "Could not start monitoring channel");
ast_mutex_unlock(&c->lock);
return 0;
}
}
if (ast_true(mix)) {
ast_monitor_setjoinfiles(c, 1);
}
ast_mutex_unlock(&c->lock);
astman_send_ack(s, m, "Started monitoring channel");
return 0;
}
/*!
* \internal
* \brief Update the specified mailbox.
* \since 12.1.0
*
* \param s AMI session.
* \param m AMI message.
*
* \retval 0 to keep AMI connection.
* \retval -1 to disconnect AMI connection.
*/
static int mwi_mailbox_update(struct mansession *s, const struct message *m)
{
const char *mailbox_id = astman_get_header(m, "Mailbox");
const char *msgs_old = astman_get_header(m, "OldMessages");
const char *msgs_new = astman_get_header(m, "NewMessages");
struct ast_mwi_mailbox_object *mailbox;
unsigned int num_old;
unsigned int num_new;
if (ast_strlen_zero(mailbox_id)) {
astman_send_error(s, m, "Missing mailbox parameter in request");
return 0;
}
num_old = 0;
if (!ast_strlen_zero(msgs_old)) {
if (sscanf(msgs_old, "%u", &num_old) != 1) {
astman_send_error_va(s, m, "Invalid OldMessages: %s", msgs_old);
return 0;
}
}
num_new = 0;
if (!ast_strlen_zero(msgs_new)) {
if (sscanf(msgs_new, "%u", &num_new) != 1) {
astman_send_error_va(s, m, "Invalid NewMessages: %s", msgs_new);
return 0;
}
}
mailbox = ast_mwi_mailbox_alloc(mailbox_id);
if (!mailbox) {
astman_send_error(s, m, "Mailbox object creation failure");
return 0;
}
/* Update external mailbox. */
ast_mwi_mailbox_set_msgs_old(mailbox, num_old);
ast_mwi_mailbox_set_msgs_new(mailbox, num_new);
if (ast_mwi_mailbox_update(mailbox)) {
astman_send_error(s, m, "Update attempt failed");
} else {
astman_send_ack(s, m, NULL);
}
ast_mwi_mailbox_unref(mailbox);
return 0;
}
static int ami_sip_qualify(struct mansession *s, const struct message *m)
{
const char *endpoint_name = astman_get_header(m, "Endpoint");
RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
char *aors;
char *aor_name;
if (ast_strlen_zero(endpoint_name)) {
astman_send_error(s, m, "Endpoint parameter missing.");
return 0;
}
endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
endpoint_name);
if (!endpoint) {
astman_send_error(s, m, "Unable to retrieve endpoint\n");
return 0;
}
/* send a qualify for all contacts registered with the endpoint */
if (ast_strlen_zero(endpoint->aors)) {
astman_send_error(s, m, "No AoRs configured for endpoint\n");
return 0;
}
aors = ast_strdupa(endpoint->aors);
while ((aor_name = strsep(&aors, ","))) {
struct ast_sip_aor *aor;
struct ao2_container *contacts;
aor = ast_sip_location_retrieve_aor(aor_name);
if (!aor) {
continue;
}
contacts = ast_sip_location_retrieve_aor_contacts(aor);
if (contacts) {
ao2_callback(contacts, OBJ_NODATA, ami_contact_cb, NULL);
ao2_ref(contacts, -1);
}
ao2_ref(aor, -1);
}
astman_send_ack(s, m, "Endpoint found, will qualify");
return 0;
}
static int manager_bridge_info(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m, "ActionID");
const char *bridge_uniqueid = astman_get_header(m, "BridgeUniqueid");
RAII_VAR(struct ast_str *, id_text, ast_str_create(128), ast_free);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct ast_str *, bridge_info, NULL, ast_free);
struct ast_bridge_snapshot *snapshot;
if (!id_text) {
astman_send_error(s, m, "Internal error");
return -1;
}
if (ast_strlen_zero(bridge_uniqueid)) {
astman_send_error(s, m, "BridgeUniqueid must be provided");
return 0;
}
if (!ast_strlen_zero(id)) {
ast_str_set(&id_text, 0, "ActionID: %s\r\n", id);
}
msg = stasis_cache_get(ast_bridge_cache(), ast_bridge_snapshot_type(), bridge_uniqueid);
if (!msg) {
astman_send_error(s, m, "Specified BridgeUniqueid not found");
return 0;
}
astman_send_ack(s, m, "Bridge channel listing will follow");
snapshot = stasis_message_data(msg);
bridge_info = ast_manager_build_bridge_state_string(snapshot);
ao2_callback_data(snapshot->channels, OBJ_NODATA, send_bridge_info_item_cb, s, ast_str_buffer(id_text));
astman_append(s,
"Event: BridgeInfoComplete\r\n"
"%s"
"%s"
"\r\n",
S_COR(bridge_info, ast_str_buffer(bridge_info), ""),
ast_str_buffer(id_text));
return 0;
}
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)
{
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);
}
static int manager_bridge_kick(struct mansession *s, const struct message *m)
{
const char *bridge_uniqueid = astman_get_header(m, "BridgeUniqueid");
const char *channel_name = astman_get_header(m, "Channel");
RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel *, channel, NULL, ao2_cleanup);
if (ast_strlen_zero(channel_name)) {
astman_send_error(s, m, "Channel must be provided");
return 0;
}
channel = ast_channel_get_by_name(channel_name);
if (!channel) {
astman_send_error(s, m, "Channel does not exist");
return 0;
}
if (ast_strlen_zero(bridge_uniqueid)) {
/* get the bridge from the channel */
ast_channel_lock(channel);
bridge = ast_channel_get_bridge(channel);
ast_channel_unlock(channel);
if (!bridge) {
astman_send_error(s, m, "Channel is not in a bridge");
return 0;
}
} else {
bridge = ast_bridge_find_by_id(bridge_uniqueid);
if (!bridge) {
astman_send_error(s, m, "Bridge not found");
return 0;
}
}
if (ast_bridge_kick(bridge, channel)) {
astman_send_error(s, m, "Channel kick from bridge failed");
return 0;
}
astman_send_ack(s, m, "Channel has been kicked");
return 0;
}
static void manager_park_unbridged(struct mansession *s, const struct message *m,
struct ast_channel *chan, const char *parkinglot, int timeout_override)
{
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);
}
static int manager_bridge_destroy(struct mansession *s, const struct message *m)
{
const char *bridge_uniqueid = astman_get_header(m, "BridgeUniqueid");
struct ast_bridge *bridge;
if (ast_strlen_zero(bridge_uniqueid)) {
astman_send_error(s, m, "BridgeUniqueid must be provided");
return 0;
}
bridge = ast_bridge_find_by_id(bridge_uniqueid);
if (!bridge) {
astman_send_error(s, m, "Specified BridgeUniqueid not found");
return 0;
}
ast_bridge_destroy(bridge, 0);
astman_send_ack(s, m, "Bridge has been destroyed");
return 0;
}
static int manager_dbget(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m,"ActionID");
char idText[256] = "";
const char *family = astman_get_header(m, "Family");
const char *key = astman_get_header(m, "Key");
char tmp[MAX_DB_FIELD];
int res;
if (ast_strlen_zero(family)) {
astman_send_error(s, m, "No family specified.");
return 0;
}
if (ast_strlen_zero(key)) {
astman_send_error(s, m, "No key specified.");
return 0;
}
if (!ast_strlen_zero(id))
snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
res = ast_db_get(family, key, tmp, sizeof(tmp));
if (res) {
astman_send_error(s, m, "Database entry not found");
} else {
astman_send_ack(s, m, "Result will follow");
astman_append(s, "Event: DBGetResponse\r\n"
"Family: %s\r\n"
"Key: %s\r\n"
"Val: %s\r\n"
"%s"
"\r\n",
family, key, tmp, idText);
astman_append(s, "Event: DBGetComplete\r\n"
"%s"
"\r\n",
idText);
}
return 0;
}
static int manager_bridges_list(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m, "ActionID");
const char *type_filter = astman_get_header(m, "BridgeType");
RAII_VAR(struct ast_str *, id_text, ast_str_create(128), ast_free);
RAII_VAR(struct ao2_container *, bridges, NULL, ao2_cleanup);
if (!id_text) {
astman_send_error(s, m, "Internal error");
return -1;
}
if (!ast_strlen_zero(id)) {
ast_str_set(&id_text, 0, "ActionID: %s\r\n", id);
}
bridges = stasis_cache_dump(ast_bridge_cache(), ast_bridge_snapshot_type());
if (!bridges) {
astman_send_error(s, m, "Internal error");
return -1;
}
astman_send_ack(s, m, "Bridge listing will follow");
if (!ast_strlen_zero(type_filter)) {
char *type_filter_dup = ast_strdupa(type_filter);
ao2_callback(bridges, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK, filter_bridge_type_cb, type_filter_dup);
}
ao2_callback_data(bridges, OBJ_NODATA, send_bridge_list_item_cb, s, ast_str_buffer(id_text));
astman_append(s,
"Event: BridgeListComplete\r\n"
"%s"
"\r\n",
ast_str_buffer(id_text));
return 0;
}
static int manager_play_dtmf(struct mansession *s, const struct message *m)
{
const char *channel = astman_get_header(m, "Channel");
const char *digit = astman_get_header(m, "Digit");
struct ast_channel *chan = ast_get_channel_by_name_locked(channel);
if (!chan) {
astman_send_error(s, m, "Channel not specified");
return 0;
}
if (ast_strlen_zero(digit)) {
astman_send_error(s, m, "No digit specified");
ast_mutex_unlock(&chan->lock);
return 0;
}
ast_senddigit(chan, *digit);
ast_mutex_unlock(&chan->lock);
astman_send_ack(s, m, "DTMF successfully queued");
return 0;
}
static int stop_monitor_action(struct mansession *s, struct message *m)
{
struct ast_channel *c = NULL;
char *name = astman_get_header(m, "Channel");
int res;
if (ast_strlen_zero(name)) {
astman_send_error(s, m, "No channel specified");
return 0;
}
c = ast_get_channel_by_name_locked(name);
if (!c) {
astman_send_error(s, m, "No such channel");
return 0;
}
res = ast_monitor_stop(c, 1);
ast_channel_unlock(c);
if (res) {
astman_send_error(s, m, "Could not stop monitoring channel");
return 0;
}
astman_send_ack(s, m, "Stopped monitoring channel");
return 0;
}
/*!
* \internal
* \brief Completes SIPNotify AMI command in URI mode.
*/
static void manager_notify_uri(struct mansession *s,
const struct message *m, const char *uri)
{
struct ast_variable *vars = astman_get_variables_order(m, ORDER_NATURAL);
switch (push_notify_uri(uri, vars, notify_ami_uri_data_create)) {
case INVALID_ENDPOINT:
/* Shouldn't be possible. */
ast_assert(0);
break;
case ALLOC_ERROR:
ast_variables_destroy(vars);
astman_send_error(s, m, "Unable to allocate NOTIFY task data");
break;
case TASK_PUSH_ERROR:
/* Don't need to destroy vars since it is handled by cleanup in push_notify_uri */
astman_send_error(s, m, "Unable to push Notify task");
break;
case SUCCESS:
astman_send_ack(s, m, "NOTIFY sent");
break;
}
}
static int manager_dbdel(struct mansession *s, const struct message *m)
{
const char *family = astman_get_header(m, "Family");
const char *key = astman_get_header(m, "Key");
int res;
if (ast_strlen_zero(family)) {
astman_send_error(s, m, "No family specified.");
return 0;
}
if (ast_strlen_zero(key)) {
astman_send_error(s, m, "No key specified.");
return 0;
}
res = ast_db_del(family, key);
if (res)
astman_send_error(s, m, "Database entry not found");
else
astman_send_ack(s, m, "Key deleted successfully");
return 0;
}
/*!
* \brief Bridge channels together
* \param s
* \param m
*
* Make sure valid channels were specified,
* send errors if any of the channels could not be found/locked, answer channels if needed,
* create the placeholder channels and grab the other channels
* make the channels compatible, send error if we fail doing so
* setup the bridge thread object and start the bridge.
*
* \retval 0
*/
static int action_bridge(struct mansession *s, const struct message *m)
{
const char *channela = astman_get_header(m, "Channel1");
const char *channelb = astman_get_header(m, "Channel2");
enum play_tone_action playtone = parse_playtone(astman_get_header(m, "Tone"));
RAII_VAR(struct ast_channel *, chana, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel *, chanb, NULL, ao2_cleanup);
const char *chana_exten;
const char *chana_context;
int chana_priority;
const char *chanb_exten;
const char *chanb_context;
int chanb_priority;
struct ast_bridge *bridge;
char buf[256];
RAII_VAR(struct ast_features_xfer_config *, xfer_cfg_a, NULL, ao2_cleanup);
RAII_VAR(struct ast_features_xfer_config *, xfer_cfg_b, NULL, ao2_cleanup);
/* make sure valid channels were specified */
if (ast_strlen_zero(channela) || ast_strlen_zero(channelb)) {
astman_send_error(s, m, "Missing channel parameter in request");
return 0;
}
ast_debug(1, "Performing Bridge action on %s and %s\n", channela, channelb);
/* Start with chana */
chana = ast_channel_get_by_name_prefix(channela, strlen(channela));
if (!chana) {
snprintf(buf, sizeof(buf), "Channel1 does not exist: %s", channela);
astman_send_error(s, m, buf);
return 0;
}
ast_channel_lock(chana);
xfer_cfg_a = ast_get_chan_features_xfer_config(chana);
chana_exten = ast_strdupa(ast_channel_exten(chana));
chana_context = ast_strdupa(ast_channel_context(chana));
chana_priority = ast_channel_priority(chana);
if (!ast_test_flag(ast_channel_flags(chana), AST_FLAG_IN_AUTOLOOP)) {
chana_priority++;
}
ast_channel_unlock(chana);
chanb = ast_channel_get_by_name_prefix(channelb, strlen(channelb));
if (!chanb) {
snprintf(buf, sizeof(buf), "Channel2 does not exist: %s", channelb);
astman_send_error(s, m, buf);
return 0;
}
ast_channel_lock(chanb);
xfer_cfg_b = ast_get_chan_features_xfer_config(chanb);
chanb_exten = ast_strdupa(ast_channel_exten(chanb));
chanb_context = ast_strdupa(ast_channel_context(chanb));
chanb_priority = ast_channel_priority(chanb);
if (!ast_test_flag(ast_channel_flags(chanb), AST_FLAG_IN_AUTOLOOP)) {
chanb_priority++;
}
ast_channel_unlock(chanb);
bridge = ast_bridge_basic_new();
if (!bridge) {
astman_send_error(s, m, "Unable to create bridge\n");
return 0;
}
ast_bridge_set_after_go_on(chana, chana_context, chana_exten, chana_priority, NULL);
if (ast_bridge_add_channel(bridge, chana, NULL, playtone & PLAYTONE_CHANNEL1, xfer_cfg_a ? xfer_cfg_a->xfersound : NULL)) {
snprintf(buf, sizeof(buf), "Unable to add Channel1 to bridge: %s", ast_channel_name(chana));
astman_send_error(s, m, buf);
ast_bridge_destroy(bridge, 0);
return 0;
}
ast_bridge_set_after_go_on(chanb, chanb_context, chanb_exten, chanb_priority, NULL);
if (ast_bridge_add_channel(bridge, chanb, NULL, playtone & PLAYTONE_CHANNEL2, xfer_cfg_b ? xfer_cfg_b->xfersound : NULL)) {
snprintf(buf, sizeof(buf), "Unable to add Channel2 to bridge: %s", ast_channel_name(chanb));
astman_send_error(s, m, buf);
ast_bridge_destroy(bridge, 0);
return 0;
}
astman_send_ack(s, m, "Channels have been bridged");
ao2_cleanup(bridge);
return 0;
}
static int manager_parking_status_all_lots(struct mansession *s, const struct message *m, const char *id_text)
{
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 RESULT_SUCCESS;
}
iter_lots = ao2_iterator_init(lot_container, 0);
astman_send_ack(s, m, "Parked calls will follow");
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) {
return RESULT_FAILURE;
}
parked_call_string = manager_build_parked_call_string(payload);
if (!payload) {
return RESULT_FAILURE;
}
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);
}
ao2_iterator_destroy(&iter_lots);
astman_append(s,
"Event: ParkedCallsComplete\r\n"
"Total: %d\r\n"
"%s"
"\r\n",
total, id_text);
return RESULT_SUCCESS;
}
