/*! * \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 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_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 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; }
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 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; }
/*! * \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 ami_show_auths(struct mansession *s, const struct message *m) { struct ast_sip_ami ami = { .s = s, .m = m, .action_id = astman_get_header(m, "ActionID"), }; struct ao2_container *auths; auths = cli_get_auths(); if (!auths) { astman_send_error(s, m, "Could not get Auths\n"); return 0; } if (!ao2_container_count(auths)) { astman_send_error(s, m, "No Auths found\n"); ao2_ref(auths, -1); return 0; } astman_send_listack(s, m, "A listing of Auths follows, presented as AuthList events", "start"); ao2_callback(auths, OBJ_NODATA, format_ami_authlist_handler, &ami); astman_send_list_complete_start(s, m, "AuthListComplete", ami.count); astman_send_list_complete_end(s); ao2_ref(auths, -1); return 0; } static struct ao2_container *cli_get_container(const char *regex) { RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup); struct ao2_container *s_container; container = ast_sorcery_retrieve_by_regex(ast_sip_get_sorcery(), "auth", regex); if (!container) { return NULL; } s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, ast_sorcery_object_id_sort, ast_sorcery_object_id_compare); if (!s_container) { return NULL; } if (ao2_container_dup(s_container, container, 0)) { ao2_ref(s_container, -1); return NULL; } return s_container; }
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; struct bridge_list_data list_data; 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; } snapshot = stasis_message_data(msg); bridge_info = ast_manager_build_bridge_state_string(snapshot); if (!bridge_info) { astman_send_error(s, m, "Internal error"); return -1; } astman_send_listack(s, m, "Bridge channel listing will follow", "start"); list_data.id_text = ast_str_buffer(id_text); list_data.count = 0; ao2_callback_data(snapshot->channels, OBJ_NODATA, send_bridge_info_item_cb, s, &list_data); astman_send_list_complete_start(s, m, "BridgeInfoComplete", list_data.count); if (!ast_strlen_zero(ast_str_buffer(bridge_info))) { astman_append(s, "%s", ast_str_buffer(bridge_info)); } astman_send_list_complete_end(s); 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 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; }
static int manager_parking_lot_list(struct mansession *s, const struct message *m) { 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; }
static int manager_mutestream(struct mansession *s, const struct message *m) { const char *channel = astman_get_header(m, "Channel"); const char *id = astman_get_header(m,"ActionID"); const char *state = astman_get_header(m,"State"); const char *direction = astman_get_header(m,"Direction"); char id_text[256]; struct ast_channel *c = NULL; if (ast_strlen_zero(channel)) { astman_send_error(s, m, "Channel not specified"); return 0; } if (ast_strlen_zero(state)) { astman_send_error(s, m, "State not specified"); return 0; } if (ast_strlen_zero(direction)) { astman_send_error(s, m, "Direction not specified"); return 0; } /* Ok, we have everything */ c = ast_channel_get_by_name(channel); if (!c) { astman_send_error(s, m, "No such channel"); return 0; } if (mute_channel(c, direction, ast_true(state))) { astman_send_error(s, m, "Failed to mute/unmute stream"); ast_channel_unref(c); return 0; } ast_channel_unref(c); if (!ast_strlen_zero(id)) { snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id); } else { id_text[0] = '\0'; } astman_append(s, "Response: Success\r\n" "%s" "\r\n", id_text); 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 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); }
/*! * \internal * \brief AMI entry point to send a SIP notify to an endpoint. */ static int manager_notify(struct mansession *s, const struct message *m) { const char *endpoint_name = astman_get_header(m, "Endpoint"); const char *uri = astman_get_header(m, "URI"); if (!ast_strlen_zero(endpoint_name) && !ast_strlen_zero(uri)) { astman_send_error(s, m, "PJSIPNotify action can not handle a request specifying " "both 'URI' and 'Endpoint'. You must use only one of the two.\n"); } else if (!ast_strlen_zero(endpoint_name)) { manager_notify_endpoint(s, m, endpoint_name); } else if (!ast_strlen_zero(uri)) { manager_notify_uri(s, m, uri); } else { astman_send_error(s, m, "PJSIPNotify requires either an endpoint name or a SIP URI."); } return 0; }
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_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); struct bridge_list_data list_data; 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_listack(s, m, "Bridge listing will follow", "start"); 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); } list_data.id_text = ast_str_buffer(id_text); list_data.count = 0; ao2_callback_data(bridges, OBJ_NODATA, send_bridge_list_item_cb, s, &list_data); astman_send_list_complete_start(s, m, "BridgeListComplete", list_data.count); astman_send_list_complete_end(s); return 0; }
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_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; }
/*! * \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 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; }
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; }
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 *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 < 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)) { 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; }