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