Fixed compile errors introduced in r395954.
[asterisk/asterisk.git] / res / res_pjsip_mwi.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@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         <depend>pjproject</depend>
21         <depend>res_pjsip</depend>
22         <support_level>core</support_level>
23  ***/
24
25 #include "asterisk.h"
26
27 #include <pjsip.h>
28 #include <pjsip_simple.h>
29 #include <pjlib.h>
30
31 #include "asterisk/res_pjsip.h"
32 #include "asterisk/res_pjsip_pubsub.h"
33 #include "asterisk/module.h"
34 #include "asterisk/logger.h"
35 #include "asterisk/astobj2.h"
36 #include "asterisk/sorcery.h"
37 #include "asterisk/stasis.h"
38 #include "asterisk/app.h"
39
40 /*** MODULEINFO
41         <depend>pjproject</depend>
42         <depend>res_pjsip</depend>
43         <depend>res_pjsip_pubsub</depend>
44         <support_level>core</support_level>
45  ***/
46
47 struct mwi_subscription;
48 AO2_GLOBAL_OBJ_STATIC(unsolicited_mwi);
49
50 #define STASIS_BUCKETS 13
51 #define MWI_BUCKETS 53
52 static void mwi_subscription_shutdown(struct ast_sip_subscription *sub);
53 static struct ast_sip_subscription *mwi_new_subscribe(struct ast_sip_endpoint *endpoint,
54                 pjsip_rx_data *rdata);
55 static void mwi_resubscribe(struct ast_sip_subscription *sub, pjsip_rx_data *rdata,
56                 struct ast_sip_subscription_response_data *response_data);
57 static void mwi_subscription_timeout(struct ast_sip_subscription *sub);
58 static void mwi_subscription_terminated(struct ast_sip_subscription *sub, pjsip_rx_data *rdata);
59 static void mwi_notify_response(struct ast_sip_subscription *sub, pjsip_rx_data *rdata);
60 static void mwi_notify_request(struct ast_sip_subscription *sub, pjsip_rx_data *rdata,
61                 struct ast_sip_subscription_response_data *response_data);
62 static int mwi_refresh_subscription(struct ast_sip_subscription *sub);
63
64 static struct ast_sip_subscription_handler mwi_handler = {
65         .event_name = "message-summary",
66         .accept = { "application/simple-message-summary", },
67         .subscription_shutdown = mwi_subscription_shutdown,
68         .new_subscribe = mwi_new_subscribe,
69         .resubscribe = mwi_resubscribe,
70         .subscription_timeout = mwi_subscription_timeout,
71         .subscription_terminated = mwi_subscription_terminated,
72         .notify_response = mwi_notify_response,
73         .notify_request = mwi_notify_request,
74         .refresh_subscription = mwi_refresh_subscription,
75 };
76
77 /*!
78  * \brief Wrapper for stasis subscription
79  *
80  * An MWI subscription has a container of these. This
81  * represents a stasis subscription for MWI state.
82  */
83 struct mwi_stasis_subscription {
84         /*! The MWI stasis subscription */
85         struct stasis_subscription *stasis_sub;
86         /*! The mailbox corresponding with the MWI subscription. Used as a hash key */
87         char mailbox[1];
88 };
89
90 /*!
91  * \brief A subscription for MWI
92  *
93  * This subscription is the basis for MWI for an endpoint. Each
94  * endpoint that uses MWI will have a corresponding mwi_subscription.
95  *
96  * This structure acts as the owner for the underlying SIP subscription.
97  * When the mwi_subscription is destroyed, the SIP subscription dies, too.
98  * The mwi_subscription's lifetime is governed by its underlying stasis
99  * subscriptions. When all stasis subscriptions are destroyed, the
100  * mwi_subscription is destroyed as well.
101  */
102 struct mwi_subscription {
103         /*! Container of \ref mwi_stasis_subscription structures.
104          * A single MWI subscription may be fore multiple mailboxes, thus
105          * requiring multiple stasis subscriptions
106          */
107         struct ao2_container *stasis_subs;
108         /*! The SIP subscription. Unsolicited MWI does not use this */
109         struct ast_sip_subscription *sip_sub;
110         /*! Is the MWI solicited (i.e. Initiated with an external SUBSCRIBE) ? */
111         unsigned int is_solicited;
112         /*! Identifier for the subscription.
113          * The identifier is the same as the corresponding endpoint's stasis ID.
114          * Used as a hash key
115          */
116         char id[1];
117 };
118
119 static void mwi_stasis_cb(void *userdata, struct stasis_subscription *sub,
120                 struct stasis_topic *topic, struct stasis_message *msg);
121
122 static struct mwi_stasis_subscription *mwi_stasis_subscription_alloc(const char *mailbox, struct mwi_subscription *mwi_sub)
123 {
124         struct mwi_stasis_subscription *mwi_stasis_sub;
125         struct stasis_topic *topic;
126         
127         if (!mwi_sub) {
128                 return NULL;
129         }
130         
131         mwi_stasis_sub = ao2_alloc(sizeof(*mwi_stasis_sub) + strlen(mailbox), NULL);
132         if (!mwi_stasis_sub) {
133                 return NULL;
134         }
135
136         topic = ast_mwi_topic(mailbox);
137
138         /* Safe strcpy */
139         strcpy(mwi_stasis_sub->mailbox, mailbox);
140         ao2_ref(mwi_sub, +1);
141         ast_debug(3, "Creating stasis MWI subscription to mailbox %s for endpoint %s\n", mailbox, mwi_sub->id);
142         mwi_stasis_sub->stasis_sub = stasis_subscribe(topic, mwi_stasis_cb, mwi_sub);
143         return mwi_stasis_sub;
144 }
145
146 static int stasis_sub_hash(const void *obj, int flags)
147 {
148         const struct mwi_stasis_subscription *mwi_stasis = obj;
149
150         return ast_str_hash(mwi_stasis->mailbox);
151 }
152
153 static int stasis_sub_cmp(void *obj, void *arg, int flags)
154 {
155         struct mwi_stasis_subscription *mwi_stasis1 = obj;
156         struct mwi_stasis_subscription *mwi_stasis2 = arg;
157
158         return strcmp(mwi_stasis1->mailbox, mwi_stasis2->mailbox) ? 0 : CMP_MATCH;
159 }
160
161 static void mwi_subscription_destructor(void *obj)
162 {
163         struct mwi_subscription *sub = obj;
164
165         ast_debug(3, "Destroying MWI subscription for endpoint %s\n", sub->id);
166         ao2_cleanup(sub->sip_sub);
167         ao2_cleanup(sub->stasis_subs);
168 }
169
170 static struct mwi_subscription *mwi_subscription_alloc(struct ast_sip_endpoint *endpoint,
171                 enum ast_sip_subscription_role role, unsigned int is_solicited, pjsip_rx_data *rdata)
172 {
173         struct mwi_subscription *sub;
174         const char *endpoint_id = ast_sorcery_object_get_id(endpoint);
175
176         sub = ao2_alloc(sizeof(*sub) + strlen(endpoint_id),
177                         mwi_subscription_destructor);
178
179         if (!sub) {
180                 return NULL;
181         }
182
183         /* Safe strcpy */
184         strcpy(sub->id, endpoint_id);
185         /* Unsolicited MWI doesn't actually result in a SIP subscription being
186          * created. This is because a SIP subscription associates with a dialog.
187          * Most devices expect unsolicited MWI NOTIFYs to appear out of dialog. If
188          * they receive an in-dialog MWI NOTIFY (i.e. with a to-tag), then they
189          * will reject the NOTIFY with a 481, thus resulting in message-waiting
190          * state not being updated on the device
191          */
192         if (is_solicited) {
193                 sub->sip_sub = ast_sip_create_subscription(&mwi_handler,
194                                 role, endpoint, rdata);
195                 if (!sub->sip_sub) {
196                         ast_log(LOG_WARNING, "Unable to create MWI SIP subscription for endpoint %s\n", sub->id);
197                         ao2_cleanup(sub);
198                         return NULL;
199                 }
200         }
201
202         sub->stasis_subs = ao2_container_alloc(STASIS_BUCKETS, stasis_sub_hash, stasis_sub_cmp);
203         if (!sub->stasis_subs) {
204                 ao2_cleanup(sub);
205                 return NULL;
206         }
207         sub->is_solicited = is_solicited;
208
209         ast_debug(3, "Created %s MWI subscription for endpoint %s\n", is_solicited ? "solicited" : "unsolicited", sub->id);
210
211         return sub;
212 }
213
214 static int mwi_sub_hash(const void *obj, int flags)
215 {
216         const struct mwi_subscription *mwi_sub = obj;
217         
218         return ast_str_hash(mwi_sub->id);
219 }
220
221 static int mwi_sub_cmp(void *obj, void *arg, int flags)
222 {
223         struct mwi_subscription *mwi_sub1 = obj;
224         struct mwi_subscription *mwi_sub2 = arg;
225
226         return strcmp(mwi_sub1->id, mwi_sub2->id) ? 0 : CMP_MATCH;
227 }
228
229 struct message_accumulator {
230         int old_msgs;
231         int new_msgs;
232         const char *reason;
233 };
234
235 static int get_message_count(void *obj, void *arg, int flags)
236 {
237         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
238         struct mwi_stasis_subscription *mwi_stasis = obj;
239         struct message_accumulator *counter = arg;
240         struct ast_mwi_state *mwi_state;
241
242         msg = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), mwi_stasis->mailbox);
243         if (!msg) {
244                 return 0;
245         }
246
247         mwi_state = stasis_message_data(msg);
248         counter->old_msgs += mwi_state->old_msgs;
249         counter->new_msgs += mwi_state->new_msgs;
250         return 0;
251 }
252
253 struct unsolicited_mwi_data {
254         struct mwi_subscription *sub;
255         struct ast_sip_endpoint *endpoint;
256         pjsip_evsub_state state;
257         const char *reason;
258         const pjsip_media_type *mwi_type;
259         const pj_str_t *body_text;
260 };
261
262 static int send_unsolicited_mwi_notify_to_contact(void *obj, void *arg, int flags)
263 {
264         struct unsolicited_mwi_data *mwi_data = arg;
265         struct mwi_subscription *sub = mwi_data->sub;
266         struct ast_sip_endpoint *endpoint = mwi_data->endpoint;
267         pjsip_evsub_state state = mwi_data->state;
268         const char *reason = mwi_data->reason;
269         const pjsip_media_type *mwi_type = mwi_data->mwi_type;
270         const pj_str_t *body_text = mwi_data->body_text;
271         struct ast_sip_contact *contact = obj;
272         const char *state_name;
273         pjsip_tx_data *tdata;
274         pjsip_msg_body *msg_body;
275         pjsip_sub_state_hdr *sub_state;
276         pjsip_event_hdr *event;
277         const pjsip_hdr *allow_events = pjsip_evsub_get_allow_events_hdr(NULL);
278
279         if (ast_sip_create_request("NOTIFY", NULL, endpoint, contact->uri, &tdata)) {
280                 ast_log(LOG_WARNING, "Unable to create unsolicited NOTIFY request to endpoint %s URI %s\n", sub->id, contact->uri);
281                 return 0;
282         }
283
284         if (!ast_strlen_zero(endpoint->subscription.mwi.fromuser)) {
285                 pjsip_fromto_hdr *from = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_FROM, NULL);
286                 pjsip_name_addr *from_name_addr = (pjsip_name_addr *) from->uri;
287                 pjsip_sip_uri *from_uri = pjsip_uri_get_uri(from_name_addr->uri);
288
289                 pj_strdup2(tdata->pool, &from_uri->user, endpoint->subscription.mwi.fromuser);
290         }
291
292         switch (state) {
293         case PJSIP_EVSUB_STATE_ACTIVE:
294                 state_name = "active";
295                 break;
296         case PJSIP_EVSUB_STATE_TERMINATED:
297         default:
298                 state_name = "terminated";
299                 break;
300         }
301
302         sub_state = pjsip_sub_state_hdr_create(tdata->pool);
303         pj_cstr(&sub_state->sub_state, state_name);
304         if (reason) {
305                 pj_cstr(&sub_state->reason_param, reason);
306         }
307         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) sub_state);
308
309         event = pjsip_event_hdr_create(tdata->pool);
310         pj_cstr(&event->event_type, "message-summary");
311         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) event);
312
313         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, allow_events));
314         msg_body = pjsip_msg_body_create(tdata->pool, &mwi_type->type, &mwi_type->subtype, body_text);
315         tdata->msg->body = msg_body;
316         ast_sip_send_request(tdata, NULL, endpoint);
317
318         return 0;
319 }
320
321 static void send_unsolicited_mwi_notify(struct mwi_subscription *sub, pjsip_evsub_state state, const char *reason,
322                 const pjsip_media_type *mwi_type, const pj_str_t *body_text)
323 {
324         RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(),
325                                 "endpoint", sub->id), ao2_cleanup);
326         char *endpoint_aors;
327         char *aor_name;
328
329         if (!endpoint) {
330                 ast_log(LOG_WARNING, "Unable to send unsolicited MWI to %s because endpoint does not exist\n",
331                                 sub->id);
332                 return;
333         }
334         if (ast_strlen_zero(endpoint->aors)) {
335                 ast_log(LOG_WARNING, "Unable to send unsolicited MWI to %s because the endpoint has no"
336                                 " configured AORs\n", sub->id);
337                 return;
338         }
339
340         endpoint_aors = ast_strdupa(endpoint->aors);
341
342         while ((aor_name = strsep(&endpoint_aors, ","))) {
343                 RAII_VAR(struct ast_sip_aor *, aor, ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
344                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
345                 struct unsolicited_mwi_data mwi_data = {
346                         .sub = sub,
347                         .endpoint = endpoint,
348                         .state = state,
349                         .reason = reason,
350                         .mwi_type = mwi_type,
351                         .body_text = body_text,
352                 };
353
354                 if (!aor) {
355                         ast_log(LOG_WARNING, "Unable to locate AOR %s for unsolicited MWI\n", aor_name);
356                         continue;
357                 }
358
359                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
360                 if (!contacts || (ao2_container_count(contacts) == 0)) {
361                         ast_log(LOG_WARNING, "No contacts bound to AOR %s. Cannot send unsolicited MWI.\n", aor_name);
362                         continue;
363                 }
364
365                 ao2_callback(contacts, OBJ_NODATA, send_unsolicited_mwi_notify_to_contact, &mwi_data);
366         }
367 }
368
369 static void send_mwi_notify(struct mwi_subscription *sub, pjsip_evsub_state state, const char *reason)
370 {
371         const pj_str_t *reason_str_ptr = NULL;
372         static pjsip_media_type mwi_type = {
373                 .type = { "application", 11 },
374                 .subtype = { "simple-message-summary", 22 },
375         };
376         struct message_accumulator counter = {
377                 .old_msgs = 0,
378                 .new_msgs = 0,
379         };
380         RAII_VAR(struct ast_str *, body, ast_str_create(64), ast_free_ptr);
381         pjsip_tx_data *tdata;
382         pj_str_t reason_str;
383         pj_str_t pj_body;
384
385         ao2_callback(sub->stasis_subs, OBJ_NODATA, get_message_count, &counter);
386
387         if (reason) {
388                 pj_cstr(&reason_str, reason);
389                 reason_str_ptr = &reason_str;
390         }
391         ast_str_append(&body, 0, "Messages-Waiting: %s\r\n", counter.new_msgs ? "yes" : "no");
392         ast_str_append(&body, 0, "Voice-Message: %d/%d (0/0)\r\n", counter.new_msgs, counter.old_msgs);
393         pj_cstr(&pj_body, ast_str_buffer(body));
394
395         ast_debug(5, "Sending  %s MWI NOTIFY to endpoint %s, new messages: %d, old messages: %d\n",
396                         sub->is_solicited ? "solicited" : "unsolicited", sub->id, counter.new_msgs,
397                         counter.old_msgs);
398
399         if (sub->is_solicited) {
400                 if (pjsip_mwi_notify(ast_sip_subscription_get_evsub(sub->sip_sub),
401                                 state,
402                                 NULL,
403                                 reason_str_ptr,
404                                 &mwi_type,
405                                 &pj_body,
406                                 &tdata) != PJ_SUCCESS) {
407                         ast_log(LOG_WARNING, "Unable to create MWI NOTIFY request to %s.\n", sub->id);
408                         return;
409                 }
410                 if (ast_sip_subscription_send_request(sub->sip_sub, tdata) != PJ_SUCCESS) {
411                         ast_log(LOG_WARNING, "Unable to send MWI NOTIFY request to %s\n", sub->id);
412                         return;
413                 }
414         } else {
415                 send_unsolicited_mwi_notify(sub, state, reason, &mwi_type, &pj_body);
416         }
417 }
418
419 static int unsubscribe_stasis(void *obj, void *arg, int flags)
420 {
421         struct mwi_stasis_subscription *mwi_stasis = obj;
422         if (mwi_stasis->stasis_sub) {
423                 ast_debug(3, "Removing stasis subscription to mailbox %s\n", mwi_stasis->mailbox);
424                 mwi_stasis->stasis_sub = stasis_unsubscribe(mwi_stasis->stasis_sub);
425         }
426         return CMP_MATCH;
427 }
428
429 static void mwi_subscription_shutdown(struct ast_sip_subscription *sub)
430 {
431         struct mwi_subscription *mwi_sub;
432         RAII_VAR(struct ast_datastore *, mwi_datastore,
433                         ast_sip_subscription_get_datastore(sub, "MWI datastore"), ao2_cleanup);
434
435         if (!mwi_datastore) {
436                 return;
437         }
438
439         mwi_sub = mwi_datastore->data;
440         ao2_callback(mwi_sub->stasis_subs, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe_stasis, NULL);
441 }
442
443 static struct ast_datastore_info mwi_ds_info = { };
444
445 static int add_mwi_datastore(struct mwi_subscription *sub)
446 {
447         RAII_VAR(struct ast_datastore *, mwi_datastore, NULL, ao2_cleanup);
448
449         mwi_datastore = ast_sip_subscription_alloc_datastore(&mwi_ds_info, "MWI datastore");
450         if (!mwi_datastore) {
451                 return -1;
452         }
453         mwi_datastore->data = sub;
454
455         ast_sip_subscription_add_datastore(sub->sip_sub, mwi_datastore);
456         return 0;
457 }
458
459 static struct ast_sip_subscription *mwi_new_subscribe(struct ast_sip_endpoint *endpoint,
460                 pjsip_rx_data *rdata)
461 {
462         RAII_VAR(struct ast_sip_aor *, aor, NULL, ao2_cleanup);
463         /* It's not obvious here, but the reference(s) to this subscription,
464          * once this function exits, is held by the stasis subscription(s)
465          * created in mwi_stasis_subscription_alloc()
466          */
467         RAII_VAR(struct mwi_subscription *, sub, NULL, ao2_cleanup);
468         pjsip_uri *ruri = rdata->msg_info.msg->line.req.uri;
469         pjsip_sip_uri *sip_ruri;
470         pjsip_evsub *evsub;
471         char aor_name[80];
472         char *mailboxes;
473         char *mailbox;
474
475         if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
476                 ast_log(LOG_WARNING, "Attempt to SUBSCRIBE to a non-SIP URI\n");
477                 return NULL;
478         }
479         sip_ruri = pjsip_uri_get_uri(ruri);
480         ast_copy_pj_str(aor_name, &sip_ruri->user, sizeof(aor_name));
481
482         aor = ast_sip_location_retrieve_aor(aor_name);
483         if (!aor) {
484                 ast_log(LOG_WARNING, "Unable to locate aor %s. MWI subscription failed.\n", aor_name);
485                 return NULL;
486         }
487
488         if (ast_strlen_zero(aor->mailboxes)) {
489                 ast_log(LOG_WARNING, "AOR %s has no configured mailboxes. MWI subscription failed\n", aor_name);
490                 return NULL;
491         }
492
493         sub = mwi_subscription_alloc(endpoint, AST_SIP_NOTIFIER, 1, rdata);
494         if (!sub) {
495                 return NULL;
496         }
497
498         if (add_mwi_datastore(sub)) {
499                 ast_log(LOG_WARNING, "Unable to allocate datastore on MWI subscription from %s\n", sub->id);
500                 return NULL;
501         }
502
503         mailboxes = ast_strdupa(aor->mailboxes);
504         while ((mailbox = strsep(&mailboxes, ","))) {
505                 RAII_VAR(struct mwi_stasis_subscription *, mwi_stasis_sub,
506                                 mwi_stasis_subscription_alloc(mailbox, sub), ao2_cleanup);
507                 if (mwi_stasis_sub) {
508                         ao2_link(sub->stasis_subs, mwi_stasis_sub);
509                 }
510         }
511
512         evsub = ast_sip_subscription_get_evsub(sub->sip_sub);
513         pjsip_evsub_accept(evsub, rdata, 200, NULL);
514         send_mwi_notify(sub, PJSIP_EVSUB_STATE_ACTIVE, NULL);
515
516         return sub->sip_sub;
517 }
518
519 static void mwi_resubscribe(struct ast_sip_subscription *sub,
520                 pjsip_rx_data *rdata, struct ast_sip_subscription_response_data *response_data)
521 {
522         pjsip_tx_data *tdata;
523
524         pjsip_mwi_current_notify(ast_sip_subscription_get_evsub(sub), &tdata);
525         ast_sip_subscription_send_request(sub, tdata);
526 }
527
528 static void mwi_subscription_timeout(struct ast_sip_subscription *sub)
529 {
530         struct mwi_subscription *mwi_sub;
531         RAII_VAR(struct ast_datastore *, mwi_datastore,
532                         ast_sip_subscription_get_datastore(sub, "MWI datastore"), ao2_cleanup);
533
534         if (!mwi_datastore) {
535                 return;
536         }
537
538
539         mwi_sub = mwi_datastore->data;
540
541         ast_log(LOG_NOTICE, "MWI subscription for %s has timed out.\n", mwi_sub->id);
542
543         send_mwi_notify(mwi_sub, PJSIP_EVSUB_STATE_TERMINATED, "timeout");
544 }
545
546 static void mwi_subscription_terminated(struct ast_sip_subscription *sub, pjsip_rx_data *rdata)
547 {
548         struct mwi_subscription *mwi_sub;
549         RAII_VAR(struct ast_datastore *, mwi_datastore,
550                         ast_sip_subscription_get_datastore(sub, "MWI datastore"), ao2_cleanup);
551
552         if (!mwi_datastore) {
553                 return;
554         }
555
556         mwi_sub = mwi_datastore->data;
557
558         ast_log(LOG_NOTICE, "MWI subscription for %s has been terminated\n", mwi_sub->id);
559
560         send_mwi_notify(mwi_sub, PJSIP_EVSUB_STATE_TERMINATED, NULL);
561 }
562
563 static void mwi_notify_response(struct ast_sip_subscription *sub, pjsip_rx_data *rdata)
564 {
565         /* We don't really care about NOTIFY responses for the moment */
566 }
567
568 static void mwi_notify_request(struct ast_sip_subscription *sub, pjsip_rx_data *rdata,
569                 struct ast_sip_subscription_response_data *response_data)
570 {
571         ast_log(LOG_WARNING, "Received an MWI NOTIFY request? This should not happen\n");
572 }
573
574 static int mwi_refresh_subscription(struct ast_sip_subscription *sub)
575 {
576         ast_log(LOG_WARNING, "Being told to refresh an MWI subscription? This should not happen\n");
577         return 0;
578 }
579
580 static int serialized_notify(void *userdata)
581 {
582         struct mwi_subscription *mwi_sub = userdata;
583
584         send_mwi_notify(mwi_sub, PJSIP_EVSUB_STATE_ACTIVE, NULL);
585         ao2_ref(mwi_sub, -1);
586         return 0;
587 }
588
589 static int serialized_cleanup(void *userdata)
590 {
591         struct mwi_subscription *mwi_sub = userdata;
592
593         /* This is getting rid of the reference that was added
594          * just before this serialized task was pushed.
595          */
596         ao2_cleanup(mwi_sub);
597         /* This is getting rid of the reference held by the
598          * stasis subscription
599          */
600         ao2_cleanup(mwi_sub);
601         return 0;
602 }
603
604 static void mwi_stasis_cb(void *userdata, struct stasis_subscription *sub,
605                 struct stasis_topic *topic, struct stasis_message *msg)
606 {
607         struct mwi_subscription *mwi_sub = userdata;
608
609         if (stasis_subscription_final_message(sub, msg)) {
610                 ao2_ref(mwi_sub, +1);
611                 ast_sip_push_task(NULL, serialized_cleanup, mwi_sub);
612                 return;
613         }
614
615         if (ast_mwi_state_type() == stasis_message_type(msg)) {
616                 struct ast_taskprocessor *serializer = mwi_sub->is_solicited ? ast_sip_subscription_get_serializer(mwi_sub->sip_sub) : NULL;
617                 ao2_ref(mwi_sub, +1);
618                 ast_sip_push_task(serializer, serialized_notify, mwi_sub);
619         }
620 }
621
622 static int create_mwi_subscriptions_for_endpoint(void *obj, void *arg, int flags)
623 {
624         RAII_VAR(struct mwi_subscription *, aggregate_sub, NULL, ao2_cleanup);
625         struct ast_sip_endpoint *endpoint = obj;
626         struct ao2_container *mwi_subscriptions = arg;
627         char *mailboxes;
628         char *mailbox;
629
630         if (ast_strlen_zero(endpoint->subscription.mwi.mailboxes)) {
631                 return 0;
632         }
633
634         if (endpoint->subscription.mwi.aggregate) {
635                 aggregate_sub = mwi_subscription_alloc(endpoint, AST_SIP_NOTIFIER, 0, NULL);
636                 if (!aggregate_sub) {
637                         return 0;
638                 }
639         }
640
641         mailboxes = ast_strdupa(endpoint->subscription.mwi.mailboxes);
642         while ((mailbox = strsep(&mailboxes, ","))) {
643                 struct mwi_subscription *sub = aggregate_sub ?:
644                         mwi_subscription_alloc(endpoint, AST_SIP_SUBSCRIBER, 0, NULL);
645                 RAII_VAR(struct mwi_stasis_subscription *, mwi_stasis_sub,
646                                 mwi_stasis_subscription_alloc(mailbox, sub), ao2_cleanup);
647                 if (mwi_stasis_sub) {
648                         ao2_link(sub->stasis_subs, mwi_stasis_sub);
649                 }
650                 if (!aggregate_sub) {
651                         ao2_link(mwi_subscriptions, sub);
652                         ao2_cleanup(sub);
653                 }
654         }
655         ao2_link(mwi_subscriptions, aggregate_sub);
656         return 0;
657 }
658
659 static int unsubscribe(void *obj, void *arg, int flags)
660 {
661         struct mwi_subscription *mwi_sub = obj;
662
663         ao2_callback(mwi_sub->stasis_subs, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe_stasis, NULL);
664         return CMP_MATCH;
665 }
666
667 static void create_mwi_subscriptions(void)
668 {
669         struct ao2_container *mwi_subscriptions = ao2_container_alloc(MWI_BUCKETS, mwi_sub_hash, mwi_sub_cmp);
670         RAII_VAR(struct ao2_container *, old_mwi_subscriptions, ao2_global_obj_ref(unsolicited_mwi), ao2_cleanup);
671         RAII_VAR(struct ao2_container *, endpoints, ast_sorcery_retrieve_by_fields(
672                                 ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL),
673                         ao2_cleanup);
674
675         if (!mwi_subscriptions) {
676                 return;
677         }
678
679         /* We remove all the old stasis subscriptions first before applying the new configuration. This
680          * prevents a situation where there might be multiple overlapping stasis subscriptions for an
681          * endpoint for mailboxes. Though there may be mailbox changes during the gap between unsubscribing
682          * and resubscribing, up-to-date mailbox state will be sent out to the endpoint when the
683          * new stasis subscription is established
684          */
685         if (old_mwi_subscriptions) {
686                 ao2_callback(old_mwi_subscriptions, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe, NULL);
687         }
688         ao2_callback(endpoints, OBJ_NODATA, create_mwi_subscriptions_for_endpoint, mwi_subscriptions);
689         ao2_global_obj_replace_unref(unsolicited_mwi, mwi_subscriptions);
690 }
691
692 static int reload(void)
693 {
694         create_mwi_subscriptions();
695         return 0;
696 }
697
698 static int load_module(void)
699 {
700         if (ast_sip_register_subscription_handler(&mwi_handler)) {
701                 return AST_MODULE_LOAD_DECLINE;
702         }
703         create_mwi_subscriptions();
704         return AST_MODULE_LOAD_SUCCESS;
705 }
706
707 static int unload_module(void)
708 {
709         RAII_VAR(struct ao2_container *, mwi_subscriptions, ao2_global_obj_ref(unsolicited_mwi), ao2_cleanup);
710         if (mwi_subscriptions) {
711                 ao2_callback(mwi_subscriptions, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe, NULL);
712                 ao2_global_obj_release(unsolicited_mwi);
713         }
714         ast_sip_unregister_subscription_handler(&mwi_handler);
715         return 0;
716 }
717
718 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP MWI resource",
719                 .load = load_module,
720                 .unload = unload_module,
721                 .reload = reload,
722                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
723 );