--- Functionality changes from Asterisk 13.1.0 to Asterisk 13.2.0 ------------
------------------------------------------------------------------------------
-=======
* New 'PJSIP_AOR' and 'PJSIP_CONTACT' dialplan functions have been added which
allow examining PJSIP AORs or contacts from the dialplan.
* "Language" (the default spoken language for the channel) is now included in
the standard channel state output for suitable events.
+ * AMI actions that return a list of events have been made to return consistent
+ headers for the action response event starting the list and the list complete
+ event. The AMI version has been bumped to 2.7.0 as a result.
+
------------------------------------------------------------------------------
--- Functionality changes from Asterisk 13.0.0 to Asterisk 13.1.0 ------------
------------------------------------------------------------------------------
struct ao2_iterator iter;
struct agent_pvt *agent;
struct ast_str *out = ast_str_alloca(4096);
+ int num_agents = 0;
if (!ast_strlen_zero(id)) {
snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
} else {
id_text[0] = '\0';
}
- astman_send_ack(s, m, "Agents will follow");
+ astman_send_listack(s, m, "Agents will follow", "start");
iter = ao2_iterator_init(agents, 0);
for (; (agent = ao2_iterator_next(&iter)); ao2_ref(agent, -1)) {
astman_append(s, "Event: Agents\r\n"
"%s%s\r\n",
ast_str_buffer(out), id_text);
+ ++num_agents;
}
ao2_iterator_destroy(&iter);
- astman_append(s, "Event: AgentsComplete\r\n"
- "%s"
- "\r\n", id_text);
+ astman_send_list_complete_start(s, m, "AgentsComplete", num_agents);
+ astman_send_list_complete_end(s);
return 0;
}
ao2_unlock(conference);
ao2_ref(conference, -1);
- astman_append(s,
- "Event: ConfbridgeListComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, id_text);
+ astman_send_list_complete_start(s, m, "ConfbridgeListComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
ao2_iterator_destroy(&iter);
/* Send final confirmation */
- astman_append(s,
- "Event: ConfbridgeListRoomsComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", totalitems, id_text);
+ astman_send_list_complete_start(s, m, "ConfbridgeListRoomsComplete", totalitems);
+ astman_send_list_complete_end(s);
return 0;
}
ao2_iterator_destroy(&user_iter);
}
AST_LIST_UNLOCK(&confs);
+
/* Send final confirmation */
- astman_append(s,
- "Event: MeetmeListComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idText);
+ astman_send_list_complete_start(s, m, "MeetmeListComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
AST_LIST_UNLOCK(&confs);
/* Send final confirmation */
- astman_append(s,
- "Event: MeetmeListRoomsComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", totalitems, idText);
+ astman_send_list_complete_start(s, m, "MeetmeListRoomsComplete", totalitems);
+ astman_send_list_complete_end(s);
return 0;
}
int qmemavail = 0;
int qchancount = 0;
int qlongestholdtime = 0;
+ int qsummaries = 0;
const char *id = astman_get_header(m, "ActionID");
const char *queuefilter = astman_get_header(m, "Queue");
- char idText[256] = "";
+ char idText[256];
struct call_queue *q;
struct queue_ent *qe;
struct member *mem;
struct ao2_iterator queue_iter;
struct ao2_iterator mem_iter;
- astman_send_ack(s, m, "Queue summary will follow");
+ astman_send_listack(s, m, "Queue summary will follow", "start");
time(&now);
+ idText[0] = '\0';
if (!ast_strlen_zero(id)) {
- snprintf(idText, 256, "ActionID: %s\r\n", id);
+ snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
}
queue_iter = ao2_iterator_init(queues, 0);
while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
"%s"
"\r\n",
q->name, qmemcount, qmemavail, qchancount, q->holdtime, q->talktime, qlongestholdtime, idText);
+ ++qsummaries;
}
ao2_unlock(q);
queue_t_unref(q, "Done with iterator");
}
ao2_iterator_destroy(&queue_iter);
- astman_append(s,
- "Event: QueueSummaryComplete\r\n"
- "%s"
- "\r\n", idText);
+
+ astman_send_list_complete_start(s, m, "QueueSummaryComplete", qsummaries);
+ astman_send_list_complete_end(s);
return RESULT_SUCCESS;
}
{
time_t now;
int pos;
+ int q_items = 0;
const char *id = astman_get_header(m,"ActionID");
const char *queuefilter = astman_get_header(m,"Queue");
const char *memberfilter = astman_get_header(m,"Member");
- char idText[256] = "";
+ char idText[256];
struct call_queue *q;
struct queue_ent *qe;
float sl = 0;
struct ao2_iterator queue_iter;
struct ao2_iterator mem_iter;
- astman_send_ack(s, m, "Queue status will follow");
+ astman_send_listack(s, m, "Queue status will follow", "start");
time(&now);
+ idText[0] = '\0';
if (!ast_strlen_zero(id)) {
snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
}
"\r\n",
q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted,
q->callsabandoned, q->servicelevel, sl, q->weight, idText);
+ ++q_items;
+
/* List Queue Members */
mem_iter = ao2_iterator_init(q->members, 0);
while ((mem = ao2_iterator_next(&mem_iter))) {
"\r\n",
q->name, mem->membername, mem->interface, mem->state_interface, mem->dynamic ? "dynamic" : "static",
mem->penalty, mem->calls, (int)mem->lastcall, mem->status, mem->paused, idText);
+ ++q_items;
}
ao2_ref(mem, -1);
}
ao2_iterator_destroy(&mem_iter);
+
/* List Queue Entries */
pos = 1;
for (qe = q->head; qe; qe = qe->next) {
S_COR(ast_channel_connected(qe->chan)->id.number.valid, ast_channel_connected(qe->chan)->id.number.str, "unknown"),
S_COR(ast_channel_connected(qe->chan)->id.name.valid, ast_channel_connected(qe->chan)->id.name.str, "unknown"),
(long) (now - qe->start), idText);
+ ++q_items;
}
}
ao2_unlock(q);
}
ao2_iterator_destroy(&queue_iter);
- astman_append(s,
- "Event: QueueStatusComplete\r\n"
- "%s"
- "\r\n",idText);
+ astman_send_list_complete_start(s, m, "QueueStatusComplete", q_items);
+ astman_send_list_complete_end(s);
return RESULT_SUCCESS;
}
{
struct ast_vm_user *vmu = NULL;
const char *id = astman_get_header(m, "ActionID");
- char actionid[128] = "";
+ char actionid[128];
+ int num_users = 0;
- if (!ast_strlen_zero(id))
+ actionid[0] = '\0';
+ if (!ast_strlen_zero(id)) {
snprintf(actionid, sizeof(actionid), "ActionID: %s\r\n", id);
+ }
AST_LIST_LOCK(&users);
return RESULT_SUCCESS;
}
- astman_send_ack(s, m, "Voicemail user list will follow");
+ astman_send_listack(s, m, "Voicemail user list will follow", "start");
AST_LIST_TRAVERSE(&users, vmu, list) {
char dirname[256];
-
#ifdef IMAP_STORAGE
int new, old;
+
inboxcount(vmu->mailbox, &new, &old);
#endif
make_dir(dirname, sizeof(dirname), vmu->context, vmu->mailbox, "INBOX");
astman_append(s,
- "%s"
"Event: VoicemailUserEntry\r\n"
+ "%s"
"VMContext: %s\r\n"
"VoiceMailbox: %s\r\n"
"Fullname: %s\r\n"
count_messages(vmu, dirname)
#endif
);
+ ++num_users;
}
- astman_append(s, "Event: VoicemailUserEntryComplete\r\n%s\r\n", actionid);
+
+ astman_send_list_complete_start(s, m, "VoicemailUserEntryComplete", num_users);
+ astman_send_list_complete_end(s);
AST_LIST_UNLOCK(&users);
struct dahdi_pvt *tmp = NULL;
const char *id = astman_get_header(m, "ActionID");
const char *dahdichannel = astman_get_header(m, "DAHDIChannel");
- char idText[256] = "";
+ char idText[256];
int channels = 0;
int dahdichanquery;
dahdichanquery = -1;
}
- astman_send_ack(s, m, "DAHDI channel status will follow");
- if (!ast_strlen_zero(id))
+ idText[0] = '\0';
+ if (!ast_strlen_zero(id)) {
snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
+ }
+
+ astman_send_listack(s, m, "DAHDI channel status will follow", "start");
ast_mutex_lock(&iflock);
ast_mutex_unlock(&iflock);
- astman_append(s,
- "Event: DAHDIShowChannelsComplete\r\n"
- "%s"
- "Items: %d\r\n"
- "\r\n",
- idText,
- channels);
+ astman_send_list_complete_start(s, m, "DAHDIShowChannelsComplete", channels);
+ astman_append(s, "Items: %d\r\n", channels);
+ astman_send_list_complete_end(s);
return 0;
}
action_id[0] = '\0';
}
- astman_send_ack(s, m, "Span status will follow");
+ astman_send_listack(s, m, "Span status will follow", "start");
count = 0;
for (idx = 0; idx < ARRAY_LEN(pris); ++idx) {
}
}
- astman_append(s,
- "Event: %sComplete\r\n"
- "Items: %d\r\n"
- "%s"
- "\r\n",
- show_cmd,
- count,
- action_id);
+ astman_send_list_complete_start(s, m, "PRIShowSpansComplete", count);
+ astman_append(s, "Items: %d\r\n", count);
+ astman_send_list_complete_end(s);
return 0;
}
#endif /* defined(HAVE_PRI) */
}
if (s) {
-
if (cont->peerlist) { /* IAXpeerlist */
-
astman_append(s,
"Event: PeerEntry\r\n%s"
"Channeltype: IAX\r\n",
cont->idtext);
-
if (!ast_strlen_zero(peer->username)) {
-
astman_append(s,
"ObjectName: %s\r\n"
"ObjectUsername: %s\r\n",
peer->name,
peer->username);
-
} else {
-
astman_append(s,
"ObjectName: %s\r\n",
name);
}
-
} else { /* IAXpeers */
-
astman_append(s,
"Event: PeerEntry\r\n%s"
"Channeltype: IAX2\r\n"
cont->idtext,
name);
}
-
astman_append(s,
"ChanObjectType: peer\r\n"
"IPaddress: %s\r\n",
tmp_host);
-
if (cont->peerlist) { /* IAXpeerlist */
-
astman_append(s,
"Mask: %s\r\n"
"Port: %s\r\n",
tmp_mask,
tmp_port);
-
} else { /* IAXpeers */
-
astman_append(s,
"IPport: %s\r\n",
tmp_port);
-
}
-
astman_append(s,
"Dynamic: %s\r\n"
"Trunk: %s\r\n"
ast_test_flag64(peer, IAX_TRUNK) ? "yes" : "no",
peer->encmethods ? ast_str_buffer(encmethods) : "no",
status);
-
if (cont->peerlist) { /* IAXpeerlist */
-
astman_append(s, "\r\n");
-
} else { /* IAXpeers */
-
astman_append(s,
"Description: %s\r\n\r\n",
peer->description);
-
}
-
} else {
ast_cli(fd, PEERS_FORMAT,
name,
}
cont->total_peers++;
-
}
static int __iax2_show_peers(int fd, int *total, struct mansession *s, const int argc, const char * const argv[])
snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
astman_send_listack(s, m, "Peer status list will follow", "start");
- /* List the peers in separate manager events */
+
+ /* List the peers in separate manager events */
__iax2_show_peers(-1, &total, s, 3, a);
- /* Send final confirmation */
- astman_append(s,
- "Event: PeerlistComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
- return 0;
+
+ /* Send final confirmation */
+ astman_send_list_complete_start(s, m, "PeerlistComplete", total);
+ astman_send_list_complete_end(s);
+ return 0;
}
/*! \brief callback to display iax peers in manager format */
snprintf(cont.idtext, sizeof(cont.idtext), "ActionID: %s\r\n", id);
}
- astman_append(s,
- "Response: Success\r\n"
- "%sMessage: IAX Peer status list will follow\r\n\r\n",
- cont.idtext);
-
+ astman_send_listack(s, m, "IAX Peer status list will follow", "start");
i = ao2_iterator_init(peers, 0);
for (; (peer = ao2_iterator_next(&i)); peer_unref(peer)) {
-
_iax2_show_peers_one(-1, s, &cont, peer);
-
}
ao2_iterator_destroy(&i);
- astman_append(s,
- "Event: PeerlistComplete\r\n"
- "%sListItems: %d\r\n\r\n",
- cont.idtext,
- cont.total_peers);
+ astman_send_list_complete_start(s, m, "PeerlistComplete", cont.total_peers);
+ astman_send_list_complete_end(s);
return RESULT_SUCCESS;
}
}
AST_LIST_UNLOCK(®istrations);
- astman_append(s,
- "Event: RegistrationsComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
+ astman_send_list_complete_start(s, m, "RegistrationsComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
}
ao2_iterator_destroy(&iter);
- astman_append(s,
- "Event: RegistrationsComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
+ astman_send_list_complete_start(s, m, "RegistrationsComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
astman_send_listack(s, m, "Peer status list will follow", "start");
+
/* List the peers in separate manager events */
_sip_show_peers(-1, &total, s, m, 3, a);
+
/* Send final confirmation */
- astman_append(s,
- "Event: PeerlistComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
+ astman_send_list_complete_start(s, m, "PeerlistComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
{
const char *id = astman_get_header(m,"ActionID");
const char *peer_name = astman_get_header(m,"Peer");
- char idText[256] = "";
+ char idText[256];
struct sip_peer *peer = NULL;
+ int num_peers = 0;
+ idText[0] = '\0';
if (!ast_strlen_zero(id)) {
snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
}
}
}
- astman_send_ack(s, m, "Peer status will follow");
+ astman_send_listack(s, m, "Peer status will follow", "start");
if (!peer) {
struct ao2_iterator i = ao2_iterator_init(peers, 0);
+
while ((peer = ao2_t_iterator_next(&i, "iterate thru peers table for SIPpeerstatus"))) {
ao2_lock(peer);
send_manager_peer_status(s, peer, idText);
ao2_unlock(peer);
sip_unref_peer(peer, "unref peer for SIPpeerstatus");
+ ++num_peers;
}
ao2_iterator_destroy(&i);
} else {
send_manager_peer_status(s, peer, idText);
ao2_unlock(peer);
sip_unref_peer(peer, "unref peer for SIPpeerstatus");
+ ++num_peers;
}
-
- astman_append(s,
- "Event: SIPpeerstatusComplete\r\n"
- "%s"
- "\r\n",
- idText);
+ astman_send_list_complete_start(s, m, "SIPpeerstatusComplete", num_peers);
+ astman_send_list_complete_end(s);
return 0;
}
/* Inspired from chan_sip */
static int manager_skinny_show_devices(struct mansession *s, const struct message *m)
{
- const char *id = astman_get_header(m, "ActionID");
const char *a[] = {"skinny", "show", "devices"};
- char idtext[256] = "";
int total = 0;
- if (!ast_strlen_zero(id))
- snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
-
astman_send_listack(s, m, "Device status list will follow", "start");
+
/* List the devices in separate manager events */
_skinny_show_devices(-1, &total, s, m, 3, a);
+
/* Send final confirmation */
- astman_append(s,
- "Event: DevicelistComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
+ astman_send_list_complete_start(s, m, "DevicelistComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
/* Inspired from chan_sip */
static int manager_skinny_show_lines(struct mansession *s, const struct message *m)
{
- const char *id = astman_get_header(m, "ActionID");
const char *a[] = {"skinny", "show", "lines"};
- char idtext[256] = "";
int total = 0;
- if (!ast_strlen_zero(id))
- snprintf(idtext, sizeof(idtext), "ActionID: %s\r\n", id);
-
astman_send_listack(s, m, "Line status list will follow", "start");
+
/* List the lines in separate manager events */
_skinny_show_lines(-1, &total, s, m, 3, a);
+
/* Send final confirmation */
- astman_append(s,
- "Event: LinelistComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", total, idtext);
+ astman_send_list_complete_start(s, m, "LinelistComplete", total);
+ astman_send_list_complete_end(s);
return 0;
}
- \ref manager.c Main manager code file
*/
-#define AMI_VERSION "2.6.0"
+#define AMI_VERSION "2.7.0"
#define DEFAULT_MANAGER_PORT 5038 /* Default port for Asterisk management via TCP */
#define DEFAULT_MANAGER_TLS_PORT 5039 /* Default port for Asterisk management via TCP */
/*! \brief Send ack in manager transaction */
void astman_send_ack(struct mansession *s, const struct message *m, char *msg);
-/*! \brief Send ack in manager list transaction */
+/*!
+ * \brief Send ack in manager transaction to begin a list.
+ *
+ * \param s - AMI session control struct.
+ * \param m - AMI action request that started the list.
+ * \param msg - Message contents describing the list to follow.
+ * \param listflag - Not used. Historically always set to "start".
+ *
+ * \note You need to call astman_send_list_complete_start() and
+ * astman_send_list_complete_end() to send the AMI list completion event.
+ *
+ * \return Nothing
+ */
void astman_send_listack(struct mansession *s, const struct message *m, char *msg, char *listflag);
+/*!
+ * \brief Start the list complete event.
+ * \since 13.2.0
+ *
+ * \param s - AMI session control struct.
+ * \param m - AMI action request that started the list.
+ * \param event_name - AMI list complete event name.
+ * \param count - Number of items in the list.
+ *
+ * \note You need to call astman_send_list_complete_end() to end
+ * the AMI list completion event.
+ *
+ * \note Between calling astman_send_list_complete_start() and
+ * astman_send_list_complete_end() you can add additonal headers
+ * using astman_append().
+ *
+ * \return Nothing
+ */
+void astman_send_list_complete_start(struct mansession *s, const struct message *m, const char *event_name, int count);
+
+/*!
+ * \brief End the list complete event.
+ * \since 13.2.0
+ *
+ * \param s - AMI session control struct.
+ *
+ * \note You need to call astman_send_list_complete_start() to start
+ * the AMI list completion event.
+ *
+ * \note Between calling astman_send_list_complete_start() and
+ * astman_send_list_complete_end() you can add additonal headers
+ * using astman_append().
+ *
+ * \return Nothing
+ */
+void astman_send_list_complete_end(struct mansession *s);
+
void __attribute__((format(printf, 2, 3))) astman_append(struct mansession *s, const char *fmt, ...);
/*! \brief Determinie if a manager session ident is authenticated */
const char *id = astman_get_header(m, "ActionID");
RAII_VAR(struct ast_str *, id_text, ast_str_create(128), ast_free);
struct ast_bridge_technology *cur;
+ int num_items = 0;
if (!id_text) {
astman_send_error(s, m, "Internal error");
ast_str_set(&id_text, 0, "ActionID: %s\r\n", id);
}
- astman_send_ack(s, m, "Bridge technology listing will follow");
+ astman_send_listack(s, m, "Bridge technology listing will follow", "start");
AST_RWLIST_RDLOCK(&bridge_technologies);
AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
"\r\n",
cur->name, type, cur->preference, AST_YESNO(cur->suspended),
ast_str_buffer(id_text));
+ ++num_items;
}
AST_RWLIST_UNLOCK(&bridge_technologies);
- astman_append(s,
- "Event: BridgeTechnologyListComplete\r\n"
- "%s"
- "\r\n",
- ast_str_buffer(id_text));
+ astman_send_list_complete_start(s, m, "BridgeTechnologyListComplete", num_items);
+ astman_send_list_complete_end(s);
return 0;
}
static int manager_dbget(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m,"ActionID");
- char idText[256] = "";
+ char idText[256];
const char *family = astman_get_header(m, "Family");
const char *key = astman_get_header(m, "Key");
char tmp[MAX_DB_FIELD];
return 0;
}
+ idText[0] = '\0';
if (!ast_strlen_zero(id))
snprintf(idText, sizeof(idText) ,"ActionID: %s\r\n", id);
if (res) {
astman_send_error(s, m, "Database entry not found");
} else {
- astman_send_ack(s, m, "Result will follow");
+ astman_send_listack(s, m, "Result will follow", "start");
+
astman_append(s, "Event: DBGetResponse\r\n"
"Family: %s\r\n"
"Key: %s\r\n"
"%s"
"\r\n",
family, key, tmp, idText);
- astman_append(s, "Event: DBGetComplete\r\n"
- "%s"
- "\r\n",
- idText);
+
+ astman_send_list_complete_start(s, m, "DBGetComplete", 1);
+ astman_send_list_complete_end(s);
}
return 0;
}
void astman_send_listack(struct mansession *s, const struct message *m, char *msg, char *listflag)
{
- astman_send_response_full(s, m, "Success", msg, listflag);
+ astman_send_response_full(s, m, "Success", msg, "Start");
+}
+
+void astman_send_list_complete_start(struct mansession *s, const struct message *m, const char *event_name, int count)
+{
+ const char *id = astman_get_header(m, "ActionID");
+
+ astman_append(s, "Event: %s\r\n", event_name);
+ if (!ast_strlen_zero(id)) {
+ astman_append(s, "ActionID: %s\r\n", id);
+ }
+ astman_append(s,
+ "EventList: Complete\r\n"
+ "ListItems: %d\r\n",
+ count);
+}
+
+void astman_send_list_complete_end(struct mansession *s)
+{
+ astman_append(s, "\r\n");
}
/*! \brief Lock the 'mansession' structure. */
}
if (!ast_strlen_zero(category) && catcount == 0) { /* TODO: actually, a config with no categories doesn't even get loaded */
- astman_append(s, "No categories found\r\n");
+ astman_append(s, "Error: No categories found\r\n");
}
ast_config_destroy(cfg);
}
if (catcount == 0) { /* TODO: actually, a config with no categories doesn't even get loaded */
- astman_append(s, "Error: no categories found\r\n");
+ astman_append(s, "Error: No categories found\r\n");
}
ast_config_destroy(cfg);
regfree(®exbuf);
ast_free(regex_string);
- astman_append(s,
- "Event: ChannelsHungupListComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", channels_matched, idText);
+ astman_send_list_complete_start(s, m, "ChannelsHungupListComplete", channels_matched);
+ astman_send_list_complete_end(s);
return 0;
}
return 0;
}
-static void generate_status(struct mansession *s, struct ast_channel *chan, char **vars, int varc, int all_variables, char *id_text)
+static void generate_status(struct mansession *s, struct ast_channel *chan, char **vars, int varc, int all_variables, char *id_text, int *count)
{
struct timeval now;
long elapsed_seconds;
} else {
variable_str = ast_str_create(1024);
}
-
if (!variable_str) {
return;
}
(long)elapsed_seconds,
ast_str_buffer(variable_str),
id_text);
+ ++*count;
ao2_cleanup(bridge);
}
}
}
- astman_send_ack(s, m, "Channel status will follow");
+ astman_send_listack(s, m, "Channel status will follow", "start");
if (!ast_strlen_zero(id)) {
snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
for (; chan; all ? chan = ast_channel_iterator_next(it_chans) : 0) {
ast_channel_lock(chan);
- generate_status(s, chan, vars.name, vars.argc, all_variables, id_text);
- channels++;
+ generate_status(s, chan, vars.name, vars.argc, all_variables, id_text, &channels);
ast_channel_unlock(chan);
chan = ast_channel_unref(chan);
ast_channel_iterator_destroy(it_chans);
}
- astman_append(s,
- "Event: StatusComplete\r\n"
- "%s"
- "Items: %d\r\n"
- "\r\n", id_text, channels);
+ astman_send_list_complete_start(s, m, "StatusComplete", channels);
+ astman_append(s, "Items: %d\r\n", channels);
+ astman_send_list_complete_end(s);
return 0;
}
}
ao2_iterator_destroy(&it_chans);
- astman_append(s,
- "Event: CoreShowChannelsComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
- "%s"
- "\r\n", numchans, idText);
+ astman_send_list_complete_start(s, m, "CoreShowChannelsComplete", numchans);
+ astman_send_list_complete_end(s);
return 0;
}
return strcmp(bridge_type, snapshot->technology) ? CMP_MATCH : 0;
}
+struct bridge_list_data {
+ const char *id_text;
+ int count;
+};
+
static int send_bridge_list_item_cb(void *obj, void *arg, void *data, int flags)
{
struct ast_bridge_snapshot *snapshot = stasis_message_data(obj);
struct mansession *s = arg;
- char *id_text = data;
- RAII_VAR(struct ast_str *, bridge_info, ast_manager_build_bridge_state_string(snapshot), ast_free_ptr);
+ struct bridge_list_data *list_data = data;
+ RAII_VAR(struct ast_str *, bridge_info, ast_manager_build_bridge_state_string(snapshot), ast_free);
if (!bridge_info) {
return 0;
"%s"
"%s"
"\r\n",
- ast_str_buffer(bridge_info),
- id_text);
+ list_data->id_text,
+ ast_str_buffer(bridge_info));
+ ++list_data->count;
return 0;
}
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;
}
- astman_send_ack(s, m, "Bridge listing will follow");
+ 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);
+
+ 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));
+ 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_append(s,
- "Event: BridgeListComplete\r\n"
- "%s"
- "\r\n",
- ast_str_buffer(id_text));
+ astman_send_list_complete_start(s, m, "BridgeListComplete", list_data.count);
+ astman_send_list_complete_end(s);
return 0;
}
{
char *uniqueid = obj;
struct mansession *s = arg;
- char *id_text = data;
+ struct bridge_list_data *list_data = data;
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct ast_channel_snapshot *snapshot;
RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
+
msg = stasis_cache_get(ast_channel_cache(),
ast_channel_snapshot_type(), uniqueid);
-
if (!msg) {
return 0;
}
"%s"
"%s"
"\r\n",
- ast_str_buffer(channel_text),
- id_text);
+ list_data->id_text,
+ ast_str_buffer(channel_text));
+ ++list_data->count;
return 0;
}
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 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);
+ if (!bridge_info) {
+ astman_send_error(s, m, "Internal error");
+ return -1;
+ }
- ao2_callback_data(snapshot->channels, OBJ_NODATA, send_bridge_info_item_cb, s, ast_str_buffer(id_text));
+ astman_send_listack(s, m, "Bridge channel listing will follow", "start");
- 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));
+ 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;
}
manager_dpsendack(s, m);
}
- astman_append(s, "Event: ShowDialPlanComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n"
+ astman_send_list_complete_start(s, m, "ShowDialPlanComplete", counters.total_items);
+ astman_append(s,
"ListExtensions: %d\r\n"
"ListPriorities: %d\r\n"
- "ListContexts: %d\r\n"
- "%s"
- "\r\n", counters.total_items, counters.total_exten, counters.total_prio, counters.total_context, idtext);
+ "ListContexts: %d\r\n",
+ counters.total_exten, counters.total_prio, counters.total_context);
+ astman_send_list_complete_end(s);
/* everything ok */
return 0;
ast_extension_state2str(hint->laststate));
ao2_unlock(hint);
}
- astman_append(s, "Event: ExtensionStateListComplete\r\n");
- if (!ast_strlen_zero(action_id)) {
- astman_append(s, "ActionID: %s\r\n", action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", hint_count);
ao2_iterator_destroy(&it_hints);
ao2_unlock(hints);
+ astman_send_list_complete_start(s, m, "ExtensionStateListComplete", hint_count);
+ astman_send_list_complete_end(s);
+
return 0;
}
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,
return;
}
- astman_send_ack(s, m, "Parked calls will follow");
+ 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))) {
payload = parked_call_payload_from_parked_user(curuser, PARKED_CALL);
if (!payload) {
ao2_ref(curuser, -1);
- ao2_iterator_destroy(&iter_users);
- astman_send_error(s, m, "Failed to retrieve parking data about a parked user.");
- return;
+ break;
}
parked_call_string = manager_build_parked_call_string(payload);
if (!parked_call_string) {
ao2_ref(curuser, -1);
- ao2_iterator_destroy(&iter_users);
- astman_send_error(s, m, "Failed to retrieve parking data about a parked user.");
- return;
+ break;
}
total++;
}
ao2_iterator_destroy(&iter_users);
- astman_append(s,
- "Event: ParkedCallsComplete\r\n"
- "Total: %d\r\n"
- "%s"
- "\r\n",
- total, id_text);
+ astman_send_list_complete_start(s, m, "ParkedCallsComplete", total);
+ astman_append(s, "Total: %d\r\n", total);
+ astman_send_list_complete_end(s);
}
static void manager_parking_status_all_lots(struct mansession *s, const struct message *m, const char *id_text)
return;
}
- astman_send_ack(s, m, "Parked calls will follow");
+ 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))) {
ao2_ref(curuser, -1);
ao2_iterator_destroy(&iter_users);
ao2_ref(curlot, -1);
- ao2_iterator_destroy(&iter_lots);
- return;
+ goto abort_list;
}
parked_call_string = manager_build_parked_call_string(payload);
ao2_ref(curuser, -1);
ao2_iterator_destroy(&iter_users);
ao2_ref(curlot, -1);
- ao2_iterator_destroy(&iter_lots);
- return;
+ goto abort_list;
}
total++;
ao2_iterator_destroy(&iter_users);
ao2_ref(curlot, -1);
}
+abort_list:
ao2_iterator_destroy(&iter_lots);
- astman_append(s,
- "Event: ParkedCallsComplete\r\n"
- "Total: %d\r\n"
- "%s"
- "\r\n",
- total, id_text);
+ astman_send_list_complete_start(s, m, "ParkedCallsComplete", total);
+ astman_append(s, "Total: %d\r\n", total);
+ astman_send_list_complete_end(s);
}
static int manager_parking_status(struct mansession *s, const struct message *m)
{
const char *id = astman_get_header(m, "ActionID");
const char *lot_name = astman_get_header(m, "ParkingLot");
- char id_text[256] = "";
+ char id_text[256];
+ id_text[0] = '\0';
if (!ast_strlen_zero(id)) {
snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
}
return 0;
}
+struct park_list_data {
+ const char *id_text;
+ int count;
+};
+
static int manager_append_event_parking_lot_data_cb(void *obj, void *arg, void *data, int flags)
{
struct parking_lot *curlot = obj;
struct mansession *s = arg;
- char *id_text = data;
+ 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"
- "%s" /* The Action ID */
"\r\n",
+ list_data->id_text,
curlot->name,
curlot->cfg->parking_start,
curlot->cfg->parking_stop,
- curlot->cfg->parkingtime,
- id_text);
+ curlot->cfg->parkingtime);
+ ++list_data->count;
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;
+ 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);
}
return 0;
}
- astman_send_ack(s, m, "Parking lots will follow");
+ astman_send_listack(s, m, "Parking lots will follow", "start");
- ao2_callback_data(lot_container, OBJ_MULTIPLE | OBJ_NODATA, manager_append_event_parking_lot_data_cb, s, id_text);
+ 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_append(s,
- "Event: ParkinglotsComplete\r\n"
- "%s"
- "\r\n",id_text);
+ astman_send_list_complete_start(s, m, "ParkinglotsComplete", list_data.count);
+ astman_send_list_complete_end(s);
return 0;
}
static int manager_fax_sessions(struct mansession *s, const struct message *m)
{
const char *action_id = astman_get_header(m, "ActionID");
- char id_text[256] = "";
+ char id_text[256];
struct ast_fax_session *session;
struct ao2_iterator iter;
int session_count = 0;
- astman_send_listack(s, m, "FAXSessionsEntry event list will follow", "Start");
-
+ id_text[0] = '\0';
if (!ast_strlen_zero(action_id)) {
snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", action_id);
}
+ astman_send_listack(s, m, "FAXSessionsEntry event list will follow", "Start");
+
iter = ao2_iterator_init(faxregistry.container, 0);
while ((session = ao2_iterator_next(&iter))) {
if (!manager_fax_sessions_entry(s, session, id_text)) {
}
ao2_iterator_destroy(&iter);
- astman_append(s, "Event: FAXSessionsComplete\r\n"
- "%s"
- "EventList: Complete\r\n"
- "Total: %d\r\n"
- "\r\n",
- id_text,
- session_count);
+ astman_send_list_complete_start(s, m, "FAXSessionsComplete", session_count);
+ astman_append(s, "Total: %d\r\n", session_count);
+ astman_send_list_complete_end(s);
return 0;
}
}
ao2_iterator_destroy(&it_states);
- astman_append(s, "Event: DeviceStateListComplete\r\n");
- if (!ast_strlen_zero(action_id)) {
- astman_append(s, "ActionID: %s\r\n", action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", count);
+ astman_send_list_complete_start(s, m, "DeviceStateListComplete", count);
+ astman_send_list_complete_end(s);
return 0;
}
}
ao2_iterator_destroy(&it_states);
- astman_append(s, "Event: PresenceStateListComplete\r\n");
- if (!ast_strlen_zero(action_id)) {
- astman_append(s, "ActionID: %s\r\n", action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", count);
+ astman_send_list_complete_start(s, m, "PresenceStateListComplete", count);
+ astman_send_list_complete_end(s);
return 0;
}
ao2_iterator_destroy(&iter);
ao2_ref(mailboxes, -1);
- astman_append(s,
- "Event: MWIGetComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %u\r\n"
- "%s"
- "\r\n", count, id_text);
+ astman_send_list_complete_start(s, m, "MWIGetComplete", count);
+ astman_send_list_complete_end(s);
return 0;
}
endpoint_name);
}
- astman_append(s, "Event: EndpointDetailComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", ami.count + 1);
+ astman_send_list_complete_start(s, m, "EndpointDetailComplete", ami.count + 1);
+ astman_send_list_complete_end(s);
return 0;
}
ao2_callback(endpoints, OBJ_NODATA, format_ami_endpoints, &ami);
- astman_append(s, "Event: EndpointListComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", num);
+ astman_send_list_complete_start(s, m, "EndpointListComplete", num);
+ astman_send_list_complete_end(s);
return 0;
}
static int ami_outbound_registration_task(void *obj)
{
struct sip_ami_outbound *ami = obj;
- RAII_VAR(struct ast_str *, buf,
- ast_sip_create_ami_event("OutboundRegistrationDetail", ami->ami), ast_free);
+ RAII_VAR(struct ast_str *, buf, NULL, ast_free);
struct sip_outbound_registration_state *state;
+ buf = ast_sip_create_ami_event("OutboundRegistrationDetail", ami->ami);
if (!buf) {
return -1;
}
if ((state = get_state(ast_sorcery_object_get_id(ami->registration)))) {
pjsip_regc_info info;
+
if (state->client_state->status == SIP_REGISTRATION_REGISTERED) {
++ami->registered;
} else {
++ami->not_registered;
}
- ast_str_append(&buf, 0, "Status: %s%s",
- sip_outbound_registration_status_str[
- state->client_state->status], "\r\n");
+ ast_str_append(&buf, 0, "Status: %s\r\n",
+ sip_outbound_registration_status_str[state->client_state->status]);
pjsip_regc_get_info(state->client_state->client, &info);
- ast_str_append(&buf, 0, "NextReg: %d%s", info.next_reg, "\r\n");
+ ast_str_append(&buf, 0, "NextReg: %d\r\n", info.next_reg);
ao2_ref(state, -1);
}
return -1;
}
- astman_send_listack(s, m, "Following are Events for each Outbound "
- "registration", "start");
+ astman_send_listack(s, m, "Following are Events for each Outbound registration",
+ "start");
ao2_callback(regs, OBJ_NODATA, ami_outbound_registration_detail, &ami_outbound);
- astman_append(s, "Event: OutboundRegistrationDetailComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "Registered: %d\r\n"
- "NotRegistered: %d\r\n\r\n",
- ami_outbound.registered,
- ami_outbound.not_registered);
+ astman_send_list_complete_start(s, m, "OutboundRegistrationDetailComplete",
+ ami_outbound.registered + ami_outbound.not_registered);
+ astman_append(s,
+ "Registered: %d\r\n"
+ "NotRegistered: %d\r\n",
+ ami_outbound.registered,
+ ami_outbound.not_registered);
+ astman_send_list_complete_end(s);
return 0;
}
struct ast_sip_ami *ami,
const char *event)
{
- RAII_VAR(struct ast_str *, buf,
- ast_sip_create_ami_event(event, ami), ast_free);
+ struct ast_str *buf;
+ buf = ast_sip_create_ami_event(event, ami);
if (!buf) {
return -1;
}
sip_subscription_to_ami(sub_tree, &buf);
astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
+ ast_free(buf);
return 0;
}
num = for_each_subscription(ami_subscription_detail_inbound, &ami);
- astman_append(s, "Event: InboundSubscriptionDetailComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", num);
+ astman_send_list_complete_start(s, m, "InboundSubscriptionDetailComplete", num);
+ astman_send_list_complete_end(s);
return 0;
}
num = for_each_subscription(ami_subscription_detail_outbound, &ami);
- astman_append(s, "Event: OutboundSubscriptionDetailComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", num);
+ astman_send_list_complete_start(s, m, "OutboundSubscriptionDetailComplete", num);
+ astman_send_list_complete_end(s);
return 0;
}
static int ami_show_resource_lists(struct mansession *s, const struct message *m)
{
- struct ast_sip_ami ami = { .s = s, .m = m };
+ struct ast_sip_ami ami = { .s = s, .m = m, .action_id = astman_get_header(m, "ActionID"), };
int num;
struct ao2_container *lists;
ao2_callback(lists, OBJ_NODATA, format_ami_resource_lists, &ami);
- astman_append(s,
- "Event: ResourceListDetailComplete\r\n"
- "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", num);
+ astman_send_list_complete_start(s, m, "ResourceListDetailComplete", num);
+ astman_send_list_complete_end(s);
return 0;
}
{
int count = 0;
struct ast_sip_ami ami = { .s = s, .m = m, .arg = &count, .action_id = astman_get_header(m, "ActionID"), };
+
astman_send_listack(s, m, "Following are Events for each Inbound "
"registration", "start");
ami_registrations_endpoints(&ami);
- astman_append(s, "Event: InboundRegistrationDetailComplete\r\n");
- if (!ast_strlen_zero(ami.action_id)) {
- astman_append(s, "ActionID: %s\r\n", ami.action_id);
- }
- astman_append(s, "EventList: Complete\r\n"
- "ListItems: %d\r\n\r\n", count);
+ astman_send_list_complete_start(s, m, "InboundRegistrationDetailComplete", count);
+ astman_send_list_complete_end(s);
return 0;
}
projects / thirdparty / asterisk.git / commitdiff
