Asterisk - The Open Source Telephony Project  18.5.0
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 <[email protected]>
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  */
35 /* @} */
36 
37 /*! \brief Convert a MWI \ref stasis_message to a \ref ast_event */
39 {
40  struct ast_event *event;
41  struct ast_mwi_state *mwi_state;
42  char *mailbox;
43  char *context;
44 
45  if (!message) {
46  return NULL;
47  }
48 
49  mwi_state = stasis_message_data(message);
50 
51  /* Strip off @context */
52  context = mailbox = ast_strdupa(mwi_state->uniqueid);
53  strsep(&context, "@");
54  if (ast_strlen_zero(context)) {
55  context = "default";
56  }
57 
63  AST_EVENT_IE_EID, AST_EVENT_IE_PLTYPE_RAW, &mwi_state->eid, sizeof(mwi_state->eid),
65 
66  return event;
67 }
68 
69 /*
70  * @{ \brief Define \ref stasis message types for MWI
71  */
73  .to_event = mwi_to_event, );
75 /* @} */
76 
77 static void mwi_state_dtor(void *obj)
78 {
79  struct ast_mwi_state *mwi_state = obj;
81  ao2_cleanup(mwi_state->snapshot);
82  mwi_state->snapshot = NULL;
83 }
84 
86 {
87  return stasis_state_all_topic(mwi_state_manager);
88 }
89 
91 {
92  return mwi_state_cache;
93 }
94 
96 {
97  return stasis_caching_get_topic(mwi_topic_cached);
98 }
99 
100 struct stasis_topic *ast_mwi_topic(const char *uniqueid)
101 {
102  return stasis_state_topic(mwi_state_manager, uniqueid);
103 }
104 
105 static struct ast_mwi_state *mwi_create_state(const char *mailbox, const char *context,
106  int urgent_msgs, int new_msgs, int old_msgs)
107 {
108  struct ast_mwi_state *mwi_state;
109 
110  ast_assert(!ast_strlen_zero(mailbox));
111 
112  mwi_state = ao2_alloc(sizeof(*mwi_state), mwi_state_dtor);
113  if (!mwi_state) {
114  ast_log(LOG_ERROR, "Unable to create MWI state for mailbox '%[email protected]%s'\n",
115  mailbox, ast_strlen_zero(context) ? "" : context);
116  return NULL;
117  }
118 
119  if (ast_string_field_init(mwi_state, 256)) {
120  ast_log(LOG_ERROR, "Unable to initialize MWI state for mailbox '%[email protected]%s'\n",
121  mailbox, ast_strlen_zero(context) ? "" : context);
122  ao2_ref(mwi_state, -1);
123  return NULL;
124  }
125  if (!ast_strlen_zero(context)) {
126  ast_string_field_build(mwi_state, uniqueid, "%[email protected]%s", mailbox, context);
127  } else {
128  ast_string_field_set(mwi_state, uniqueid, mailbox);
129  }
130 
131  mwi_state->urgent_msgs = urgent_msgs;
132  mwi_state->new_msgs = new_msgs;
133  mwi_state->old_msgs = old_msgs;
134 
135  return mwi_state;
136 }
137 
139 {
140  int urgent_msgs;
141  int new_msgs;
142  int old_msgs;
143 
144  ast_app_inboxcount2(mailbox, &urgent_msgs, &new_msgs, &old_msgs);
145  return mwi_create_state(mailbox, NULL, urgent_msgs, new_msgs, old_msgs);
146 }
147 
148 struct ast_mwi_state *ast_mwi_create(const char *mailbox, const char *context)
149 {
150  return mwi_create_state(mailbox, context, 0, 0, 0);
151 }
152 
153 /*!
154  * \internal
155  * \brief Create a MWI state snapshot message.
156  * \since 12.2.0
157  *
158  * \param[in] mailbox The mailbox identifier string.
159  * \param[in] context The context this mailbox resides in (NULL or "" if only using mailbox)
160  * \param[in] new_msgs The number of new messages in this mailbox
161  * \param[in] old_msgs The number of old messages in this mailbox
162  * \param[in] channel_id A unique identifier for a channel associated with this
163  * change in mailbox state
164  * \param[in] eid The EID of the server that originally published the message
165  *
166  * \retval message on success. Use ao2_cleanup() when done with it.
167  * \retval NULL on error.
168  */
170  const char *mailbox,
171  const char *context,
172  int urgent_msgs,
173  int new_msgs,
174  int old_msgs,
175  const char *channel_id,
176  struct ast_eid *eid)
177 {
178  struct ast_mwi_state *mwi_state;
179  struct stasis_message *message;
180 
181  if (!ast_mwi_state_type()) {
182  return NULL;
183  }
184 
185  mwi_state = mwi_create_state(mailbox, context, urgent_msgs, new_msgs, old_msgs);
186  if (!mwi_state) {
187  return NULL;
188  }
189 
190  if (!ast_strlen_zero(channel_id)) {
191  mwi_state->snapshot = ast_channel_snapshot_get_latest(channel_id);
192  }
193 
194  if (eid) {
195  mwi_state->eid = *eid;
196  } else {
197  mwi_state->eid = ast_eid_default;
198  }
199 
200  /*
201  * XXX As far as stasis is concerned, all MWI events are local.
202  *
203  * We may in the future want to make MWI aggregate local/remote
204  * message counts similar to how device state aggregates state.
205  */
207  ao2_cleanup(mwi_state);
208  return message;
209 }
210 
211 /*!
212  * \internal
213  *
214  * This object currently acts as a typedef, but can also be thought of as a "child" object
215  * of the stasis_state_subscriber type. As such the "base" pointer should always be the
216  * first object attribute. Doing so allows this object to be easily type cast and used by
217  * the stasis_state code.
218  */
220  /*! The "base" state subscriber. (Must be first object attribute) */
222 };
223 
225 {
227  mwi_state_manager, mailbox);
228 }
229 
231  stasis_subscription_cb callback, void *data)
232 {
233  struct stasis_subscription *stasis_sub;
235  mwi_state_manager, mailbox, callback, data);
236 
237  if (!sub) {
238  return NULL;
239  }
240 
241  stasis_sub = ast_mwi_subscriber_subscription(sub);
242 
245 
246  return sub;
247 }
248 
250 {
252 }
253 
255 {
257 }
258 
260 {
262 }
263 
265 {
266  struct stasis_state_subscriber *s = (struct stasis_state_subscriber *)sub;
267  struct ast_mwi_state *mwi_state = stasis_state_subscriber_data(s);
268 
270 }
271 
273 {
275 }
276 
277 /*!
278  * \internal
279  *
280  * This object currently acts as a typedef, but can also be thought of as a "child" object
281  * of the stasis_state_publisher type. As such the "base" pointer should always be the
282  * first object attribute. Doing so allows this object to be easily type cast and used by
283  * the stasis_state code.
284  */
286  /*! The "base" state publisher. (Must be first object attribute) */
288 };
289 
291 {
293  mwi_state_manager, mailbox);
294 }
295 
297 {
298  return stasis_state_add_observer(mwi_state_manager,
299  (struct stasis_state_observer *)observer);
300 }
301 
303 {
304  stasis_state_remove_observer(mwi_state_manager,
305  (struct stasis_state_observer *)observer);
306 }
307 
310  void *data;
311 };
312 
313 static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
314 {
315  struct mwi_handler_data *d = user_data;
316  struct ast_mwi_state *mwi_state = stasis_message_data(msg);
317  int res;
318 
319  if (mwi_state) {
320  return d->handler(mwi_state, d->data);
321  }
322 
323  mwi_state = mwi_create_state(id, NULL, 0, 0, 0);
324  if (!mwi_state) {
325  return 0;
326  }
327 
328  res = d->handler(mwi_state, d->data);
329  ao2_ref(mwi_state, -1);
330  return res;
331 }
332 
334 {
335  struct mwi_handler_data d = {
336  .handler = handler,
337  .data = data
338  };
339 
340  stasis_state_callback_all(mwi_state_manager, handle_mwi_state, &d);
341 }
342 
344 {
345  struct mwi_handler_data d = {
346  .handler = handler,
347  .data = data
348  };
349 
350  stasis_state_callback_subscribed(mwi_state_manager, handle_mwi_state, &d);
351 }
352 
353 int ast_mwi_publish(struct ast_mwi_publisher *pub, int urgent_msgs,
354  int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
355 {
356  struct stasis_state_publisher *p = (struct stasis_state_publisher *)pub;
358  NULL, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
359 
360  if (!msg) {
361  return -1;
362  }
363 
364  stasis_state_publish(p, msg);
365  ao2_ref(msg, -1);
366 
367  return 0;
368 }
369 
370 int ast_mwi_publish_by_mailbox(const char *mailbox, const char *context, int urgent_msgs,
371  int new_msgs, int old_msgs, const char *channel_id, struct ast_eid *eid)
372 {
373  struct ast_mwi_state *mwi_state;
375  mailbox, context, urgent_msgs, new_msgs, old_msgs, channel_id, eid);
376 
377  if (!msg) {
378  return -1;
379  }
380 
381  mwi_state = stasis_message_data(msg);
382  stasis_state_publish_by_id(mwi_state_manager, mwi_state->uniqueid, NULL, msg);
383  ao2_ref(msg, -1);
384 
385  return 0;
386 }
387 
389  const char *mailbox,
390  const char *context,
391  int new_msgs,
392  int old_msgs,
393  const char *channel_id,
394  struct ast_eid *eid)
395 {
396  return ast_mwi_publish_by_mailbox(mailbox, context, 0, new_msgs, old_msgs, channel_id, eid);
397 }
398 
399 int ast_delete_mwi_state_full(const char *mailbox, const char *context, struct ast_eid *eid)
400 {
401  RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
402  struct stasis_message *cached_msg;
403  struct stasis_message *clear_msg;
404  struct ast_mwi_state *mwi_state;
405 
406  msg = mwi_state_create_message(mailbox, context, 0, 0, 0, NULL, eid);
407  if (!msg) {
408  return -1;
409  }
410 
411  mwi_state = stasis_message_data(msg);
412 
413  /*
414  * XXX As far as stasis is concerned, all MWI events are local.
415  *
416  * For now, it is assumed that there is only one entity
417  * maintaining the state of a particular mailbox.
418  *
419  * If we ever have multiple MWI event entities maintaining
420  * the same mailbox that wish to delete their cached entry
421  * we will need to do something about the race condition
422  * potential between checking the cache and removing the
423  * cache entry.
424  */
427  if (!cached_msg) {
428  /* Nothing to clear from the cache, but still need to remove state */
429  stasis_state_remove_publish_by_id(mwi_state_manager, mwi_state->uniqueid, eid, NULL);
430  return -1;
431  }
432  ao2_cleanup(cached_msg);
433 
434  clear_msg = stasis_cache_clear_create(msg);
435  stasis_state_remove_publish_by_id(mwi_state_manager, mwi_state->uniqueid, eid, clear_msg);
436  ao2_cleanup(clear_msg);
437 
438  return 0;
439 }
440 
441 static const char *mwi_state_get_id(struct stasis_message *message)
442 {
443  if (ast_mwi_state_type() == stasis_message_type(message)) {
444  struct ast_mwi_state *mwi_state = stasis_message_data(message);
445  return mwi_state->uniqueid;
446  } else if (stasis_subscription_change_type() == stasis_message_type(message)) {
447  struct stasis_subscription_change *change = stasis_message_data(message);
448  return change->uniqueid;
449  }
450 
451  return NULL;
452 }
453 
454 static void mwi_blob_dtor(void *obj)
455 {
456  struct ast_mwi_blob *mwi_blob = obj;
457 
458  ao2_cleanup(mwi_blob->mwi_state);
459  ast_json_unref(mwi_blob->blob);
460 }
461 
463  struct stasis_message_type *message_type,
464  struct ast_json *blob)
465 {
466  struct ast_mwi_blob *obj;
467  struct stasis_message *msg;
468 
469  ast_assert(blob != NULL);
470 
471  if (!message_type) {
472  return NULL;
473  }
474 
475  obj = ao2_alloc(sizeof(*obj), mwi_blob_dtor);
476  if (!obj) {
477  return NULL;
478  }
479 
480  obj->mwi_state = mwi_state;
481  ao2_ref(obj->mwi_state, +1);
482  obj->blob = ast_json_ref(blob);
483 
484  /* This is not a normal MWI event. Only used by the MinivmNotify app. */
485  msg = stasis_message_create(message_type, obj);
486  ao2_ref(obj, -1);
487 
488  return msg;
489 }
490 
491 static void mwi_cleanup(void)
492 {
493  ao2_cleanup(mwi_state_cache);
494  mwi_state_cache = NULL;
495  mwi_topic_cached = stasis_caching_unsubscribe_and_join(mwi_topic_cached);
496  ao2_cleanup(mwi_state_manager);
497  mwi_state_manager = NULL;
500 }
501 
502 int mwi_init(void)
503 {
505 
507  return -1;
508  }
509 
511  return -1;
512  }
513 
514  mwi_state_manager = stasis_state_manager_create("mwi:all");
515  if (!mwi_state_manager) {
516  return -1;
517  }
518 
519  mwi_state_cache = stasis_cache_create(mwi_state_get_id);
520  if (!mwi_state_cache) {
521  return -1;
522  }
523 
524  mwi_topic_cached = stasis_caching_topic_create(ast_mwi_topic_all(), mwi_state_cache);
525  if (!mwi_topic_cached) {
526  return -1;
527  }
528 
529  return 0;
530 }
Managed stasis state event interface.
Definition: stasis_state.h:463
struct ast_mwi_state * mwi_state
Definition: mwi.h:474
An event.
Definition: event.c:81
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition: json.c:67
Asterisk main include file. File version handling, generic pbx functions.
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:446
static void mwi_state_dtor(void *obj)
Definition: mwi.c:77
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:412
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:399
void * stasis_state_unsubscribe(struct stasis_state_subscriber *sub)
Unsubscribe from the stasis topic and stasis state.
Definition: stasis_state.c:470
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:658
struct ast_eid eid
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:700
struct stasis_topic * stasis_state_subscriber_topic(struct stasis_state_subscriber *sub)
Retrieve the subscriber&#39;s topic.
Definition: stasis_state.c:492
static struct ast_mwi_state * mwi_retrieve_then_create_state(const char *mailbox)
Definition: mwi.c:138
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:388
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct stasis_cache * ast_mwi_state_cache(void)
Backend cache for ast_mwi_topic_cached().
Definition: mwi.c:90
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1501
struct ast_mwi_state * ast_mwi_create(const char *mailbox, const char *context)
Create a ast_mwi_state object.
Definition: mwi.c:148
int mwi_init(void)
Initialize the mwi core.
Definition: mwi.c:502
struct stasis_state_subscriber * base
Definition: mwi.c:221
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
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:462
const char * stasis_state_publisher_id(const struct stasis_state_publisher *pub)
Retrieve the publisher&#39;s underlying state&#39;s unique id.
Definition: stasis_state.c:552
static struct test_val d
static struct stasis_cache * mwi_state_cache
Definition: mwi.c:33
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:497
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1523
struct stasis_message_type * stasis_message_type(const struct stasis_message *msg)
Get the message type for a stasis_message.
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:1079
static int handle_mwi_state(const char *id, struct stasis_message *msg, void *user_data)
Definition: mwi.c:313
Definition: astman.c:222
on_mwi_state handler
Definition: mwi.c:309
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
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:105
Number of new messages Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:77
Number of Used by: AST_EVENT_MWI Payload type: UINT.
Definition: event_defs.h:83
const char * stasis_state_subscriber_id(const struct stasis_state_subscriber *sub)
Retrieve the underlying subscribed to state&#39;s unique id.
Definition: stasis_state.c:487
void ast_mwi_remove_observer(struct ast_mwi_observer *observer)
Remove an MWI state observer.
Definition: mwi.c:302
#define ast_assert(a)
Definition: utils.h:695
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
struct stasis_topic * ast_mwi_topic_all(void)
Get the Stasis Message Bus API topic for MWI messages.
Definition: mwi.c:85
#define NULL
Definition: resample.c:96
struct ast_json * blob
Definition: mwi.h:475
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:477
struct stasis_state_manager * stasis_state_manager_create(const char *topic_name)
Create a stasis state manager.
Definition: stasis_state.c:324
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:688
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:230
An Entity ID is essentially a MAC address, brief and unique.
Definition: utils.h:786
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
Entity ID Used by All events Payload type: RAW This IE indicates which server the event originated fr...
Definition: event_defs.h:272
#define ast_strlen_zero(foo)
Definition: strings.h:52
STASIS_MESSAGE_TYPE_DEFN(ast_mwi_state_type,.to_event=mwi_to_event,)
static struct stasis_state_manager * mwi_state_manager
Definition: mwi.c:32
static char mailbox[AST_MAX_MAILBOX_UNIQUEID]
Definition: chan_mgcp.c:204
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:692
#define ast_log
Definition: astobj2.c:42
Context IE Used by AST_EVENT_MWI Payload type: str.
Definition: event_defs.h:127
struct ast_mwi_subscriber * ast_mwi_add_subscriber(const char *mailbox)
Add an MWI state subscriber to the mailbox.
Definition: mwi.c:224
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
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:740
#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:911
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:353
#define ao2_ref(o, delta)
Definition: astobj2.h:464
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:531
int old_msgs
Definition: mwi.h:462
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:300
void * ast_mwi_unsubscribe(struct ast_mwi_subscriber *sub)
Unsubscribe from the stasis topic and MWI.
Definition: mwi.c:249
int(* on_mwi_state)(struct ast_mwi_state *mwi_state, void *data)
The delegate called for each managed mailbox state.
Definition: mwi.h:303
static void mwi_blob_dtor(void *obj)
Definition: mwi.c:454
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:370
struct stasis_subscription * ast_mwi_subscriber_subscription(struct ast_mwi_subscriber *sub)
Retrieve the stasis MWI topic subscription if available.
Definition: mwi.c:272
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:254
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:763
static const char * mwi_state_get_id(struct stasis_message *message)
Definition: mwi.c:441
#define LOG_ERROR
Definition: logger.h:285
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
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:638
struct stasis_topic * ast_mwi_subscriber_topic(struct ast_mwi_subscriber *sub)
Retrieves the MWI subscriber&#39;s topic.
Definition: mwi.c:259
struct stasis_subscription * stasis_state_subscriber_subscription(struct stasis_state_subscriber *sub)
Retrieve the stasis topic subscription if available.
Definition: stasis_state.c:513
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:411
void(* stasis_subscription_cb)(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Callback function type for Stasis subscriptions.
Definition: stasis.h:615
static void mwi_cleanup(void)
Definition: mwi.c:491
struct ast_channel_snapshot * snapshot
Definition: mwi.h:464
static struct stasis_caching_topic * mwi_topic_cached
Definition: mwi.c:34
int urgent_msgs
Definition: mwi.h:466
Holds details about changes to subscriptions for the specified topic.
Definition: stasis.h:892
struct stasis_message_type * ast_mwi_state_type(void)
Get the Stasis Message Bus API message type for MWI messages.
struct stasis_topic * stasis_state_all_topic(struct stasis_state_manager *manager)
Retrieve the manager&#39;s topic (the topic that all state topics get forwarded to)
Definition: stasis_state.c:364
Object that represents an MWI update with some additional application defined data.
Definition: mwi.h:473
#define ast_string_field_build(x, field, fmt, args...)
Set a field to a complex (built) value.
Definition: stringfields.h:550
struct ast_eid ast_eid_default
Global EID.
Definition: options.c:93
char * strsep(char **str, const char *delims)
struct stasis_cache * stasis_cache_create(snapshot_get_id id_fn)
Create a cache.
Definition: stasis_cache.c:360
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...
#define ao2_cleanup(obj)
Definition: astobj2.h:1958
struct ast_event * ast_event_new(enum ast_event_type event_type,...)
Create a new event.
Definition: event.c:402
struct stasis_topic * ast_mwi_topic_cached(void)
Get the Stasis Message Bus API caching topic for MWI messages.
Definition: mwi.c:95
MWI state event interface.
Definition: mwi.h:252
int new_msgs
Definition: mwi.h:461
const ast_string_field uniqueid
Definition: mwi.h:460
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
Asterisk MWI API.
void ast_mwi_state_callback_all(on_mwi_state handler, void *data)
For each managed mailbox call the given handler.
Definition: mwi.c:333
struct ast_sorcery_instance_observer observer
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:1025
struct stasis_forward * sub
Definition: res_corosync.c:240
Abstract JSON element (object, array, string, int, ...).
struct stasis_message_type * stasis_subscription_change_type(void)
Gets the message type for subscription change notices.
struct stasis_state_publisher * base
Definition: mwi.c:287
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:353
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:116
The structure that contains MWI state.
Definition: mwi.h:457
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:100
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_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
struct ast_mwi_publisher * ast_mwi_add_publisher(const char *mailbox)
Add an MWI state publisher to the mailbox.
Definition: mwi.c:290
int ast_mwi_add_observer(struct ast_mwi_observer *observer)
Add an observer to receive MWI state related events.
Definition: mwi.c:296
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:368
Application convenience functions, designed to give consistent look and feel to Asterisk apps...
struct ast_eid eid
Definition: mwi.h:465
static struct ast_event * mwi_to_event(struct stasis_message *message)
Convert a MWI stasis_message to a ast_event.
Definition: mwi.c:38
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:562
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:369
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:264
void * data
Definition: mwi.c:310
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:343
Mailbox name.
Definition: event_defs.h:89
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:169
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:514
struct stasis_message_type * ast_mwi_vm_app_type(void)
Get the Stasis Message Bus API message type for voicemail application specific messages.