Asterisk - The Open Source Telephony Project GIT-master-3dae2cf
mwi.c
Go to the documentation of this file.
1/*
2 * Asterisk -- An open source telephony toolkit.
3 *
4 * Copyright (C) 2019, Sangoma Technologies Corporation
5 *
6 * Kevin Harwell <kharwell@digium.com>
7 *
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
13 *
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
17 */
18
19/*** MODULEINFO
20 <support_level>core</support_level>
21 ***/
22
23#include "asterisk.h"
24
25#include "asterisk/app.h"
26#include "asterisk/mwi.h"
28
29/*!
30 * \brief Define \ref stasis topic objects
31 * @{
32 */
36
37/*! @} */
38
39/*! \brief Convert a MWI \ref stasis_message to a \ref ast_event */
41{
42 struct ast_event *event;
43 struct ast_mwi_state *mwi_state;
44 char *mailbox;
45 char *context;
46
47 if (!message) {
48 return NULL;
49 }
50
51 mwi_state = stasis_message_data(message);
52
53 /* Strip off @context */
54 context = mailbox = ast_strdupa(mwi_state->uniqueid);
55 strsep(&context, "@");
57 context = "default";
58 }
59
65 AST_EVENT_IE_EID, AST_EVENT_IE_PLTYPE_RAW, &mwi_state->eid, sizeof(mwi_state->eid),
67
68 return event;
69}
70
71/*!
72 * \brief Define \ref stasis message types for MWI
73 * @{
74 */
76 .to_event = mwi_to_event, );
78
79/*! @} */
80
81static void mwi_state_dtor(void *obj)
82{
83 struct ast_mwi_state *mwi_state = obj;
85 ao2_cleanup(mwi_state->snapshot);
86 mwi_state->snapshot = NULL;
87}
88
90{
92}
93
95{
96 return mwi_state_cache;
97}
98
100{
102}
103
104struct stasis_topic *ast_mwi_topic(const char *uniqueid)
105{
106 return stasis_state_topic(mwi_state_manager, uniqueid);
107}
108
109static struct ast_mwi_state *mwi_create_state(const char *mailbox, const char *context,
110 int urgent_msgs, int new_msgs, int old_msgs)
111{
112 struct ast_mwi_state *mwi_state;
113
115
116 mwi_state = ao2_alloc(sizeof(*mwi_state), mwi_state_dtor);
117 if (!mwi_state) {
118 ast_log(LOG_ERROR, "Unable to create MWI state for mailbox '%s@%s'\n",
120 return NULL;
121 }
122
123 if (ast_string_field_init(mwi_state, 256)) {
124 ast_log(LOG_ERROR, "Unable to initialize MWI state for mailbox '%s@%s'\n",
126 ao2_ref(mwi_state, -1);
127 return NULL;
128 }
129 if (!ast_strlen_zero(context)) {
130 ast_string_field_build(mwi_state, uniqueid, "%s@%s", mailbox, context);
131 } else {
133 }
134
135 mwi_state->urgent_msgs = urgent_msgs;
136 mwi_state->new_msgs = new_msgs;
137 mwi_state->old_msgs = old_msgs;
138
139 return mwi_state;
140}
141
143{
144 int urgent_msgs;
145 int new_msgs;
146 int old_msgs;
147
150}
151
152struct ast_mwi_state *ast_mwi_create(const char *mailbox, const char *context)
153{
154 return mwi_create_state(mailbox, context, 0, 0, 0);
155}
156
157/*!
158 * \internal
159 * \brief Create a MWI state snapshot message.
160 * \since 12.2.0
161 *
162 * \param[in] mailbox The mailbox identifier string.
163 * \param[in] context The context this mailbox resides in (NULL or "" if only using mailbox)
164 * \param urgent_msgs
165 * \param[in] new_msgs The number of new messages in this mailbox
166 * \param[in] old_msgs The number of old messages in this mailbox
167 * \param[in] channel_id A unique identifier for a channel associated with this
168 * change in mailbox state
169 * \param[in] eid The EID of the server that originally published the message
170 *
171 * \return message on success. Use ao2_cleanup() when done with it.
172 * \retval NULL on error.
173 */
175 const char *mailbox,
176 const char *context,
177 int urgent_msgs,
178 int new_msgs,
179 int old_msgs,
180 const char *channel_id,
181 struct ast_eid *eid)
182{
183 struct ast_mwi_state *mwi_state;
184 struct stasis_message *message;
185
186 if (!ast_mwi_state_type()) {
187 return NULL;
188 }
189
190 mwi_state = mwi_create_state(mailbox, context, urgent_msgs, new_msgs, old_msgs);
191 if (!mwi_state) {
192 return NULL;
193 }
194
195 if (!ast_strlen_zero(channel_id)) {
196 mwi_state->snapshot = ast_channel_snapshot_get_latest(channel_id);
197 }
198
199 if (eid) {
200 mwi_state->eid = *eid;
201 } else {
202 mwi_state->eid = ast_eid_default;
203 }
204
205 /*
206 * XXX As far as stasis is concerned, all MWI events are local.
207 *
208 * We may in the future want to make MWI aggregate local/remote
209 * message counts similar to how device state aggregates state.
210 */
212 ao2_cleanup(mwi_state);
213 return message;
214}
215
216/*!
217 * \internal
218 *
219 * This object currently acts as a typedef, but can also be thought of as a "child" object
220 * of the stasis_state_subscriber type. As such the "base" pointer should always be the
221 * first object attribute. Doing so allows this object to be easily type cast and used by
222 * the stasis_state code.
223 */
225 /*! The "base" state subscriber. (Must be first object attribute) */
227};
228
230{
233}
234
236 stasis_subscription_cb callback, void *data)
237{
238 struct stasis_subscription *stasis_sub;
240 mwi_state_manager, mailbox, callback, data);
241
242 if (!sub) {
243 return NULL;
244 }
245
247
250
251 return sub;
252}
253
255{
257}
258
260{
262}
263
265{
267}
268
270{
272 struct ast_mwi_state *mwi_state = stasis_state_subscriber_data(s);
273
275}
276
278{
280}
281
282/*!
283 * \internal
284 *
285 * This object currently acts as a typedef, but can also be thought of as a "child" object
286 * of the stasis_state_publisher type. As such the "base" pointer should always be the
287 * first object attribute. Doing so allows this object to be easily type cast and used by
288 * the stasis_state code.
289 */
291 /*! The "base" state publisher. (Must be first object attribute) */
293};
294
296{
299}
300
302{
305}
306
308{
311}
312
315 void *data;
316};
317
318static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
319{
320 struct mwi_handler_data *d = user_data;
321 struct ast_mwi_state *mwi_state = stasis_message_data(msg);
322 int res;
323
324 if (mwi_state) {
325 return d->handler(mwi_state, d->data);
326 }
327
328 mwi_state = mwi_create_state(id, NULL, 0, 0, 0);
329 if (!mwi_state) {
330 return 0;
331 }
332
333 res = d->handler(mwi_state, d->data);
334 ao2_ref(mwi_state, -1);
335 return res;
336}
337
339{
340 struct mwi_handler_data d = {
341 .handler = handler,
342 .data = data
343 };
344
346}
347
349{
350 struct mwi_handler_data d = {
351 .handler = handler,
352 .data = data
353 };
354
356}
357
358int ast_mwi_publish(struct ast_mwi_publisher *pub, int urgent_msgs,
359 int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
360{
361 struct stasis_state_publisher *p = (struct stasis_state_publisher *)pub;
363 NULL, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
364
365 if (!msg) {
366 return -1;
367 }
368
369 stasis_state_publish(p, msg);
370 ao2_ref(msg, -1);
371
372 return 0;
373}
374
375int ast_mwi_publish_by_mailbox(const char *mailbox, const char *context, int urgent_msgs,
376 int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
377{
378 struct ast_mwi_state *mwi_state;
380 mailbox, context, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
381
382 if (!msg) {
383 return -1;
384 }
385
386 mwi_state = stasis_message_data(msg);
388 ao2_ref(msg, -1);
389
390 return 0;
391}
392
394 const char *mailbox,
395 const char *context,
396 int new_msgs,
397 int old_msgs,
398 const char *channel_id,
399 struct ast_eid *eid)
400{
401 return ast_mwi_publish_by_mailbox(mailbox, context, 0, new_msgs, old_msgs, channel_id, eid);
402}
403
404int ast_delete_mwi_state_full(const char *mailbox, const char *context, struct ast_eid *eid)
405{
406 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
407 struct stasis_message *cached_msg;
408 struct stasis_message *clear_msg;
409 struct ast_mwi_state *mwi_state;
410
412 if (!msg) {
413 return -1;
414 }
415
416 mwi_state = stasis_message_data(msg);
417
418 /*
419 * XXX As far as stasis is concerned, all MWI events are local.
420 *
421 * For now, it is assumed that there is only one entity
422 * maintaining the state of a particular mailbox.
423 *
424 * If we ever have multiple MWI event entities maintaining
425 * the same mailbox that wish to delete their cached entry
426 * we will need to do something about the race condition
427 * potential between checking the cache and removing the
428 * cache entry.
429 */
432 if (!cached_msg) {
433 /* Nothing to clear from the cache, but still need to remove state */
435 return -1;
436 }
437 ao2_cleanup(cached_msg);
438
439 clear_msg = stasis_cache_clear_create(msg);
441 ao2_cleanup(clear_msg);
442
443 return 0;
444}
445
446static const char *mwi_state_get_id(struct stasis_message *message)
447{
449 struct ast_mwi_state *mwi_state = stasis_message_data(message);
450 return mwi_state->uniqueid;
453 return change->uniqueid;
454 }
455
456 return NULL;
457}
458
459static void mwi_blob_dtor(void *obj)
460{
461 struct ast_mwi_blob *mwi_blob = obj;
462
463 ao2_cleanup(mwi_blob->mwi_state);
464 ast_json_unref(mwi_blob->blob);
465}
466
468 struct stasis_message_type *message_type,
469 struct ast_json *blob)
470{
471 struct ast_mwi_blob *obj;
472 struct stasis_message *msg;
473
474 ast_assert(blob != NULL);
475
476 if (!message_type) {
477 return NULL;
478 }
479
480 obj = ao2_alloc(sizeof(*obj), mwi_blob_dtor);
481 if (!obj) {
482 return NULL;
483 }
484
485 obj->mwi_state = mwi_state;
486 ao2_ref(obj->mwi_state, +1);
487 obj->blob = ast_json_ref(blob);
488
489 /* This is not a normal MWI event. Only used by the MinivmNotify app. */
490 msg = stasis_message_create(message_type, obj);
491 ao2_ref(obj, -1);
492
493 return msg;
494}
495
496static void mwi_cleanup(void)
497{
505}
506
507int mwi_init(void)
508{
510
512 return -1;
513 }
514
516 return -1;
517 }
518
520 if (!mwi_state_manager) {
521 return -1;
522 }
523
525 if (!mwi_state_cache) {
526 return -1;
527 }
528
530 if (!mwi_topic_cached) {
531 return -1;
532 }
533
534 return 0;
535}
Asterisk main include file. File version handling, generic pbx functions.
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_log
Definition: astobj2.c:42
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
struct ast_event * ast_event_new(enum ast_event_type event_type,...)
Create a new event.
Definition: event.c:403
@ AST_EVENT_IE_END
Definition: event_defs.h:70
@ AST_EVENT_IE_CONTEXT
Context IE Used by AST_EVENT_MWI Payload type: str.
Definition: event_defs.h:127
@ AST_EVENT_IE_EID
Entity ID Used by All events Payload type: RAW This IE indicates which server the event originated fr...
Definition: event_defs.h:272
@ AST_EVENT_IE_MAILBOX
Mailbox name.
Definition: event_defs.h:89
@ AST_EVENT_IE_OLDMSGS
Number of Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:83
@ AST_EVENT_IE_NEWMSGS
Number of new messages Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:77
@ AST_EVENT_MWI
Definition: event_defs.h:38
@ AST_EVENT_IE_PLTYPE_RAW
Definition: event_defs.h:337
@ AST_EVENT_IE_PLTYPE_UINT
Definition: event_defs.h:333
@ AST_EVENT_IE_PLTYPE_STR
Definition: event_defs.h:335
struct stasis_message_type * stasis_subscription_change_type(void)
Gets the message type for subscription change notices.
struct ast_channel_snapshot * ast_channel_snapshot_get_latest(const char *uniqueid)
Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object,...
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
int ast_app_inboxcount2(const char *mailboxes, int *urgentmsgs, int *newmsgs, int *oldmsgs)
Determine number of urgent/new/old messages in a mailbox.
Definition: main/app.c:619
char * strsep(char **str, const char *delims)
#define LOG_ERROR
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition: json.c:67
void * ast_mwi_unsubscribe(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic and MWI.
Definition: mwi.c:254
struct ast_mwi_subscriber * ast_mwi_add_subscriber(const char *mailbox)
Add an MWI state subscriber to the mailbox.
Definition: mwi.c:229
struct stasis_subscription * ast_mwi_subscriber_subscription(struct ast_mwi_subscriber *sub)
Retrieve the stasis MWI topic subscription if available.
Definition: mwi.c:277
static struct stasis_message * mwi_state_create_message(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Definition: mwi.c:174
static void mwi_state_dtor(void *obj)
Definition: mwi.c:81
static struct ast_event * mwi_to_event(struct stasis_message *message)
Convert a MWI stasis_message to a ast_event.
Definition: mwi.c:40
static struct stasis_caching_topic * mwi_topic_cached
Definition: mwi.c:35
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
Definition: mwi.c:94
static struct stasis_state_manager * mwi_state_manager
Define Stasis Message Bus API topic objects.
Definition: mwi.c:33
struct stasis_message * ast_mwi_blob_create(struct ast_mwi_state *mwi_state, struct stasis_message_type *message_type, struct ast_json *blob)
Creates a ast_mwi_blob message.
Definition: mwi.c:467
int mwi_init(void)
Initialize the mwi core.
Definition: mwi.c:507
static struct stasis_cache * mwi_state_cache
Definition: mwi.c:34
struct stasis_topic * ast_mwi_topic(const char *uniqueid)
Get the Stasis Message Bus API topic for MWI messages on a unique ID.
Definition: mwi.c:104
static const char * mwi_state_get_id(struct stasis_message *message)
Definition: mwi.c:446
int ast_publish_mwi_state_full(const char *mailbox, const char *context, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish a MWI state update via stasis with all parameters.
Definition: mwi.c:393
static void mwi_cleanup(void)
Definition: mwi.c:496
int ast_mwi_publish(struct ast_mwi_publisher *pub, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish MWI for the given mailbox.
Definition: mwi.c:358
static struct ast_mwi_state * mwi_retrieve_then_create_state(const char *mailbox)
Definition: mwi.c:142
void ast_mwi_state_callback_all(on_mwi_state handler, void *data)
For each managed mailbox call the given handler.
Definition: mwi.c:338
void ast_mwi_state_callback_subscribed(on_mwi_state handler, void *data)
For each managed mailbox that has a subscriber call the given handler.
Definition: mwi.c:348
struct ast_mwi_publisher * ast_mwi_add_publisher(const char *mailbox)
Add an MWI state publisher to the mailbox.
Definition: mwi.c:295
static struct ast_mwi_state * mwi_create_state(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs)
Definition: mwi.c:109
int ast_mwi_add_observer(struct ast_mwi_observer *observer)
Add an observer to receive MWI state related events.
Definition: mwi.c:301
struct ast_mwi_state * ast_mwi_create(const char *mailbox, const char *context)
Create a ast_mwi_state object.
Definition: mwi.c:152
int ast_delete_mwi_state_full(const char *mailbox, const char *context, struct ast_eid *eid)
Delete MWI state cached by stasis with all parameters.
Definition: mwi.c:404
static void mwi_blob_dtor(void *obj)
Definition: mwi.c:459
static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
Definition: mwi.c:318
void ast_mwi_remove_observer(struct ast_mwi_observer *observer)
Remove an MWI state observer.
Definition: mwi.c:307
struct stasis_topic * ast_mwi_topic_cached(void)
Get the Stasis Message Bus API caching topic for MWI messages.
Definition: mwi.c:99
void * ast_mwi_unsubscribe_and_join(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic, block until the final message is received, and then unsubscribe fr...
Definition: mwi.c:259
struct stasis_topic * ast_mwi_topic_all(void)
Get the Stasis Message Bus API topic for MWI messages.
Definition: mwi.c:89
struct ast_mwi_subscriber * ast_mwi_subscribe_pool(const char *mailbox, stasis_subscription_cb callback, void *data)
Add an MWI state subscriber, and stasis subscription to the mailbox.
Definition: mwi.c:235
STASIS_MESSAGE_TYPE_DEFN(ast_mwi_state_type,.to_event=mwi_to_event,)
Define Stasis Message Bus API message types for MWI.
int ast_mwi_publish_by_mailbox(const char *mailbox, const char *context, int urgent_msgs, int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
Publish MWI for the given mailbox.
Definition: mwi.c:375
struct stasis_topic * ast_mwi_subscriber_topic(struct ast_mwi_subscriber *sub)
Retrieves the MWI subscriber's topic.
Definition: mwi.c:264
struct ast_mwi_state * ast_mwi_subscriber_data(struct ast_mwi_subscriber *sub)
Retrieves the state data object associated with the MWI subscriber.
Definition: mwi.c:269
Asterisk MWI API.
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
struct stasis_message_type * ast_mwi_vm_app_type(void)
Get the Stasis Message Bus API message type for voicemail application specific messages.
int(* on_mwi_state)(struct ast_mwi_state *mwi_state, void *data)
The delegate called for each managed mailbox state.
Definition: mwi.h:301
struct stasis_forward * sub
Definition: res_corosync.c:240
struct ast_sorcery_instance_observer observer
#define NULL
Definition: resample.c:96
struct stasis_message * stasis_cache_clear_create(struct stasis_message *message)
A message which instructs the caching topic to remove an entry from its cache.
Definition: stasis_cache.c:778
struct stasis_message_type * stasis_message_type(const struct stasis_message *msg)
Get the message type for a stasis_message.
struct stasis_topic * stasis_caching_get_topic(struct stasis_caching_topic *caching_topic)
Returns the topic of cached events from a caching topics.
Definition: stasis_cache.c:85
void(* stasis_subscription_cb)(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Callback function type for Stasis subscriptions.
Definition: stasis.h:611
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1515
@ STASIS_SUBSCRIPTION_FILTER_SELECTIVE
Definition: stasis.h:297
struct stasis_caching_topic * stasis_caching_topic_create(struct stasis_topic *original_topic, struct stasis_cache *cache)
Create a topic which monitors and caches messages from another topic.
Definition: stasis_cache.c:948
int stasis_subscription_accept_message_type(struct stasis_subscription *subscription, const struct stasis_message_type *type)
Indicate to a subscription that we are interested in a message type.
Definition: stasis.c:1024
int stasis_subscription_set_filter(struct stasis_subscription *subscription, enum stasis_subscription_message_filter filter)
Set the message type filtering level on a subscription.
Definition: stasis.c:1078
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1493
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
struct stasis_caching_topic * stasis_caching_unsubscribe_and_join(struct stasis_caching_topic *caching_topic)
Unsubscribes a caching topic from its upstream topic, blocking until all messages have been forwarded...
Definition: stasis_cache.c:146
struct stasis_cache * stasis_cache_create(snapshot_get_id id_fn)
Create a cache.
Definition: stasis_cache.c:360
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
struct stasis_message * stasis_message_create_full(struct stasis_message_type *type, void *data, const struct ast_eid *eid)
Create a new message for an entity.
struct stasis_message * stasis_cache_get_by_eid(struct stasis_cache *cache, struct stasis_message_type *type, const char *id, const struct ast_eid *eid)
Retrieve an item from the cache for a specific entity.
Definition: stasis_cache.c:659
void * stasis_state_unsubscribe(struct stasis_state_subscriber *sub)
Unsubscribe from the stasis topic and stasis state.
Definition: stasis_state.c:471
struct stasis_topic * stasis_state_all_topic(struct stasis_state_manager *manager)
Retrieve the manager's topic (the topic that all state topics get forwarded to)
Definition: stasis_state.c:365
const char * stasis_state_subscriber_id(const struct stasis_state_subscriber *sub)
Retrieve the underlying subscribed to state's unique id.
Definition: stasis_state.c:488
void stasis_state_callback_all(struct stasis_state_manager *manager, on_stasis_state handler, void *data)
For each managed state call the given handler.
Definition: stasis_state.c:741
struct stasis_state_subscriber * stasis_state_add_subscriber(struct stasis_state_manager *manager, const char *id)
Add a subscriber to the managed stasis state for the given id.
Definition: stasis_state.c:413
struct stasis_state_manager * stasis_state_manager_create(const char *topic_name)
Create a stasis state manager.
Definition: stasis_state.c:325
void stasis_state_publish_by_id(struct stasis_state_manager *manager, const char *id, const struct ast_eid *eid, struct stasis_message *msg)
Publish to a managed named by id topic, and add an implicit subscriber.
Definition: stasis_state.c:639
void stasis_state_remove_observer(struct stasis_state_manager *manager, struct stasis_state_observer *observer)
Remove an observer (will no longer receive managed state related events).
Definition: stasis_state.c:701
void * stasis_state_unsubscribe_and_join(struct stasis_state_subscriber *sub)
Unsubscribe from the stasis topic, block until the final message is received, and then unsubscribe fr...
Definition: stasis_state.c:478
int stasis_state_add_observer(struct stasis_state_manager *manager, struct stasis_state_observer *observer)
Add an observer to receive managed state related events.
Definition: stasis_state.c:689
const char * stasis_state_publisher_id(const struct stasis_state_publisher *pub)
Retrieve the publisher's underlying state's unique id.
Definition: stasis_state.c:553
struct stasis_subscription * stasis_state_subscriber_subscription(struct stasis_state_subscriber *sub)
Retrieve the stasis topic subscription if available.
Definition: stasis_state.c:514
struct stasis_state_subscriber * stasis_state_subscribe_pool(struct stasis_state_manager *manager, const char *id, stasis_subscription_cb callback, void *data)
Add a subscriber, and subscribe to its underlying stasis topic.
Definition: stasis_state.c:447
struct stasis_topic * stasis_state_subscriber_topic(struct stasis_state_subscriber *sub)
Retrieve the subscriber's topic.
Definition: stasis_state.c:493
void stasis_state_callback_subscribed(struct stasis_state_manager *manager, on_stasis_state handler, void *data)
For each managed, and explicitly subscribed state call the given handler.
Definition: stasis_state.c:764
void stasis_state_remove_publish_by_id(struct stasis_state_manager *manager, const char *id, const struct ast_eid *eid, struct stasis_message *msg)
Publish to a managed named by id topic, and remove an implicit publisher.
Definition: stasis_state.c:659
void stasis_state_publish(struct stasis_state_publisher *pub, struct stasis_message *msg)
Publish to a managed state (topic) using a publisher.
Definition: stasis_state.c:563
struct stasis_topic * stasis_state_topic(struct stasis_state_manager *manager, const char *id)
Retrieve a managed topic creating one if not currently managed.
Definition: stasis_state.c:370
struct stasis_state_publisher * stasis_state_add_publisher(struct stasis_state_manager *manager, const char *id)
Add a publisher to the managed state for the given id.
Definition: stasis_state.c:532
void * stasis_state_subscriber_data(struct stasis_state_subscriber *sub)
Retrieve the last known state stasis message payload for the subscriber.
Definition: stasis_state.c:498
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
#define ast_string_field_build(x, field, fmt, args...)
Set a field to a complex (built) value.
Definition: stringfields.h:555
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
An Entity ID is essentially a MAC address, brief and unique.
Definition: utils.h:813
An event.
Definition: event.c:81
Abstract JSON element (object, array, string, int, ...).
Object that represents an MWI update with some additional application defined data.
Definition: mwi.h:471
struct ast_mwi_state * mwi_state
Definition: mwi.h:472
struct ast_json * blob
Definition: mwi.h:473
MWI state event interface.
Definition: mwi.h:248
struct stasis_state_publisher * base
Definition: mwi.c:292
The structure that contains MWI state.
Definition: mwi.h:455
int urgent_msgs
Definition: mwi.h:464
struct ast_channel_snapshot * snapshot
Definition: mwi.h:462
int old_msgs
Definition: mwi.h:460
int new_msgs
Definition: mwi.h:459
const ast_string_field uniqueid
Definition: mwi.h:458
struct ast_eid eid
Definition: mwi.h:463
struct stasis_state_subscriber * base
Definition: mwi.c:226
Definition: astman.c:222
void * data
Definition: mwi.c:315
on_mwi_state handler
Definition: mwi.c:314
struct ast_eid eid
Managed stasis state event interface.
Definition: stasis_state.h:463
Holds details about changes to subscriptions for the specified topic.
Definition: stasis.h:890
static void handler(const char *name, int response_code, struct ast_variable *get_params, struct ast_variable *path_vars, struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
Definition: test_ari.c:59
static struct test_val d
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
#define ast_assert(a)
Definition: utils.h:739
struct ast_eid ast_eid_default
Global EID.
Definition: options.c:93