res_pjsip_keepalive: Add runtime configurable keepalive module for connection-oriente...
[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         <depend>res_pjsip_pubsub</depend>
23         <support_level>core</support_level>
24  ***/
25
26 #include "asterisk.h"
27
28 #include <pjsip.h>
29 #include <pjsip_simple.h>
30 #include <pjlib.h>
31
32 #include "asterisk/res_pjsip.h"
33 #include "asterisk/res_pjsip_pubsub.h"
34 #include "asterisk/res_pjsip_body_generator_types.h"
35 #include "asterisk/module.h"
36 #include "asterisk/logger.h"
37 #include "asterisk/astobj2.h"
38 #include "asterisk/sorcery.h"
39 #include "asterisk/stasis.h"
40 #include "asterisk/app.h"
41
42 struct mwi_subscription;
43 AO2_GLOBAL_OBJ_STATIC(unsolicited_mwi);
44
45 #define STASIS_BUCKETS 13
46 #define MWI_BUCKETS 53
47
48 #define MWI_TYPE "application"
49 #define MWI_SUBTYPE "simple-message-summary"
50
51 #define MWI_DATASTORE "MWI datastore"
52
53 static void mwi_subscription_shutdown(struct ast_sip_subscription *sub);
54 static void mwi_to_ami(struct ast_sip_subscription *sub, struct ast_str **buf);
55 static int mwi_new_subscribe(struct ast_sip_endpoint *endpoint,
56                 const char *resource);
57 static int mwi_subscription_established(struct ast_sip_subscription *sub);
58 static void *mwi_get_notify_data(struct ast_sip_subscription *sub);
59
60 static struct ast_sip_notifier mwi_notifier = {
61         .default_accept = MWI_TYPE"/"MWI_SUBTYPE,
62         .new_subscribe = mwi_new_subscribe,
63         .subscription_established = mwi_subscription_established,
64         .get_notify_data = mwi_get_notify_data,
65 };
66
67 static struct ast_sip_subscription_handler mwi_handler = {
68         .event_name = "message-summary",
69         .body_type = AST_SIP_MESSAGE_ACCUMULATOR,
70         .accept = { MWI_TYPE"/"MWI_SUBTYPE, },
71         .subscription_shutdown = mwi_subscription_shutdown,
72         .to_ami = mwi_to_ami,
73         .notifier = &mwi_notifier,
74 };
75
76 /*!
77  * \brief Wrapper for stasis subscription
78  *
79  * An MWI subscription has a container of these. This
80  * represents a stasis subscription for MWI state.
81  */
82 struct mwi_stasis_subscription {
83         /*! The MWI stasis subscription */
84         struct stasis_subscription *stasis_sub;
85         /*! The mailbox corresponding with the MWI subscription. Used as a hash key */
86         char mailbox[1];
87 };
88
89 /*!
90  * \brief A subscription for MWI
91  *
92  * This subscription is the basis for MWI for an endpoint. Each
93  * endpoint that uses MWI will have a corresponding mwi_subscription.
94  *
95  * This structure acts as the owner for the underlying SIP subscription.
96  * When the mwi_subscription is destroyed, the SIP subscription dies, too.
97  * The mwi_subscription's lifetime is governed by its underlying stasis
98  * subscriptions. When all stasis subscriptions are destroyed, the
99  * mwi_subscription is destroyed as well.
100  */
101 struct mwi_subscription {
102         /*! Container of \ref mwi_stasis_subscription structures.
103          * A single MWI subscription may be fore multiple mailboxes, thus
104          * requiring multiple stasis subscriptions
105          */
106         struct ao2_container *stasis_subs;
107         /*! The SIP subscription. Unsolicited MWI does not use this */
108         struct ast_sip_subscription *sip_sub;
109         /*! Is the MWI solicited (i.e. Initiated with an external SUBSCRIBE) ? */
110         unsigned int is_solicited;
111         /*! Identifier for the subscription.
112          * The identifier is the same as the corresponding endpoint's stasis ID.
113          * Used as a hash key
114          */
115         char id[1];
116 };
117
118 static void mwi_stasis_cb(void *userdata, struct stasis_subscription *sub,
119                 struct stasis_message *msg);
120
121 static struct mwi_stasis_subscription *mwi_stasis_subscription_alloc(const char *mailbox, struct mwi_subscription *mwi_sub)
122 {
123         struct mwi_stasis_subscription *mwi_stasis_sub;
124         struct stasis_topic *topic;
125
126         if (!mwi_sub) {
127                 return NULL;
128         }
129
130         mwi_stasis_sub = ao2_alloc(sizeof(*mwi_stasis_sub) + strlen(mailbox), NULL);
131         if (!mwi_stasis_sub) {
132                 return NULL;
133         }
134
135         topic = ast_mwi_topic(mailbox);
136
137         /* Safe strcpy */
138         strcpy(mwi_stasis_sub->mailbox, mailbox);
139         ao2_ref(mwi_sub, +1);
140         ast_debug(3, "Creating stasis MWI subscription to mailbox %s for endpoint %s\n", mailbox, mwi_sub->id);
141         mwi_stasis_sub->stasis_sub = stasis_subscribe(topic, mwi_stasis_cb, mwi_sub);
142         return mwi_stasis_sub;
143 }
144
145 static int stasis_sub_hash(const void *obj, const int flags)
146 {
147         const struct mwi_stasis_subscription *object;
148         const char *key;
149
150         switch (flags & OBJ_SEARCH_MASK) {
151         case OBJ_SEARCH_KEY:
152                 key = obj;
153                 break;
154         case OBJ_SEARCH_OBJECT:
155                 object = obj;
156                 key = object->mailbox;
157                 break;
158         default:
159                 ast_assert(0);
160                 return 0;
161         }
162         return ast_str_hash(key);
163 }
164
165 static int stasis_sub_cmp(void *obj, void *arg, int flags)
166 {
167         const struct mwi_stasis_subscription *sub_left = obj;
168         const struct mwi_stasis_subscription *sub_right = arg;
169         const char *right_key = arg;
170         int cmp;
171
172         switch (flags & OBJ_SEARCH_MASK) {
173         case OBJ_SEARCH_OBJECT:
174                 right_key = sub_right->mailbox;
175                 /* Fall through */
176         case OBJ_SEARCH_KEY:
177                 cmp = strcmp(sub_left->mailbox, right_key);
178                 break;
179         case OBJ_SEARCH_PARTIAL_KEY:
180                 cmp = strncmp(sub_left->mailbox, right_key, strlen(right_key));
181                 break;
182         default:
183                 cmp = 0;
184                 break;
185         }
186         if (cmp) {
187                 return 0;
188         }
189         return CMP_MATCH;
190 }
191
192 static void mwi_subscription_destructor(void *obj)
193 {
194         struct mwi_subscription *sub = obj;
195
196         ast_debug(3, "Destroying MWI subscription for endpoint %s\n", sub->id);
197         ao2_cleanup(sub->sip_sub);
198         ao2_cleanup(sub->stasis_subs);
199 }
200
201 static struct mwi_subscription *mwi_subscription_alloc(struct ast_sip_endpoint *endpoint,
202                 unsigned int is_solicited, struct ast_sip_subscription *sip_sub)
203 {
204         struct mwi_subscription *sub;
205         const char *endpoint_id = ast_sorcery_object_get_id(endpoint);
206
207         sub = ao2_alloc(sizeof(*sub) + strlen(endpoint_id),
208                         mwi_subscription_destructor);
209
210         if (!sub) {
211                 return NULL;
212         }
213
214         /* Safe strcpy */
215         strcpy(sub->id, endpoint_id);
216
217         /* Unsolicited MWI doesn't actually result in a SIP subscription being
218          * created. This is because a SIP subscription associates with a dialog.
219          * Most devices expect unsolicited MWI NOTIFYs to appear out of dialog. If
220          * they receive an in-dialog MWI NOTIFY (i.e. with a to-tag), then they
221          * will reject the NOTIFY with a 481, thus resulting in message-waiting
222          * state not being updated on the device
223          */
224         if (is_solicited) {
225                 sub->sip_sub = ao2_bump(sip_sub);
226         }
227
228         sub->stasis_subs = ao2_container_alloc(STASIS_BUCKETS, stasis_sub_hash, stasis_sub_cmp);
229         if (!sub->stasis_subs) {
230                 ao2_cleanup(sub);
231                 return NULL;
232         }
233         sub->is_solicited = is_solicited;
234
235         ast_debug(3, "Created %s MWI subscription for endpoint %s\n", is_solicited ? "solicited" : "unsolicited", sub->id);
236
237         return sub;
238 }
239
240 static int mwi_sub_hash(const void *obj, const int flags)
241 {
242         const struct mwi_subscription *object;
243         const char *key;
244
245         switch (flags & OBJ_SEARCH_MASK) {
246         case OBJ_SEARCH_KEY:
247                 key = obj;
248                 break;
249         case OBJ_SEARCH_OBJECT:
250                 object = obj;
251                 key = object->id;
252                 break;
253         default:
254                 ast_assert(0);
255                 return 0;
256         }
257         return ast_str_hash(key);
258 }
259
260 static int mwi_sub_cmp(void *obj, void *arg, int flags)
261 {
262         const struct mwi_subscription *sub_left = obj;
263         const struct mwi_subscription *sub_right = arg;
264         const char *right_key = arg;
265         int cmp;
266
267         switch (flags & OBJ_SEARCH_MASK) {
268         case OBJ_SEARCH_OBJECT:
269                 right_key = sub_right->id;
270                 /* Fall through */
271         case OBJ_SEARCH_KEY:
272                 cmp = strcmp(sub_left->id, right_key);
273                 break;
274         case OBJ_SEARCH_PARTIAL_KEY:
275                 cmp = strncmp(sub_left->id, right_key, strlen(right_key));
276                 break;
277         default:
278                 cmp = 0;
279                 break;
280         }
281         if (cmp) {
282                 return 0;
283         }
284         return CMP_MATCH;
285 }
286
287 static int get_message_count(void *obj, void *arg, int flags)
288 {
289         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
290         struct mwi_stasis_subscription *mwi_stasis = obj;
291         struct ast_sip_message_accumulator *counter = arg;
292         struct ast_mwi_state *mwi_state;
293
294         msg = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), mwi_stasis->mailbox);
295         if (!msg) {
296                 return 0;
297         }
298
299         mwi_state = stasis_message_data(msg);
300         counter->old_msgs += mwi_state->old_msgs;
301         counter->new_msgs += mwi_state->new_msgs;
302         return 0;
303 }
304
305 struct unsolicited_mwi_data {
306         struct mwi_subscription *sub;
307         struct ast_sip_endpoint *endpoint;
308         pjsip_evsub_state state;
309         const struct ast_sip_body *body;
310 };
311
312 static int send_unsolicited_mwi_notify_to_contact(void *obj, void *arg, int flags)
313 {
314         struct unsolicited_mwi_data *mwi_data = arg;
315         struct mwi_subscription *sub = mwi_data->sub;
316         struct ast_sip_endpoint *endpoint = mwi_data->endpoint;
317         pjsip_evsub_state state = mwi_data->state;
318         const struct ast_sip_body *body = mwi_data->body;
319         struct ast_sip_contact *contact = obj;
320         const char *state_name;
321         pjsip_tx_data *tdata;
322         pjsip_sub_state_hdr *sub_state;
323         pjsip_event_hdr *event;
324         const pjsip_hdr *allow_events = pjsip_evsub_get_allow_events_hdr(NULL);
325
326         if (ast_sip_create_request("NOTIFY", NULL, endpoint, NULL, contact, &tdata)) {
327                 ast_log(LOG_WARNING, "Unable to create unsolicited NOTIFY request to endpoint %s URI %s\n", sub->id, contact->uri);
328                 return 0;
329         }
330
331         if (!ast_strlen_zero(endpoint->subscription.mwi.fromuser)) {
332                 pjsip_fromto_hdr *from = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_FROM, NULL);
333                 pjsip_name_addr *from_name_addr = (pjsip_name_addr *) from->uri;
334                 pjsip_sip_uri *from_uri = pjsip_uri_get_uri(from_name_addr->uri);
335
336                 pj_strdup2(tdata->pool, &from_uri->user, endpoint->subscription.mwi.fromuser);
337         }
338
339         switch (state) {
340         case PJSIP_EVSUB_STATE_ACTIVE:
341                 state_name = "active";
342                 break;
343         case PJSIP_EVSUB_STATE_TERMINATED:
344         default:
345                 state_name = "terminated";
346                 break;
347         }
348
349         sub_state = pjsip_sub_state_hdr_create(tdata->pool);
350         pj_cstr(&sub_state->sub_state, state_name);
351         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) sub_state);
352
353         event = pjsip_event_hdr_create(tdata->pool);
354         pj_cstr(&event->event_type, "message-summary");
355         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) event);
356
357         pjsip_msg_add_hdr(tdata->msg, pjsip_hdr_shallow_clone(tdata->pool, allow_events));
358         ast_sip_add_body(tdata, body);
359         ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL);
360
361         return 0;
362 }
363
364 static void send_unsolicited_mwi_notify(struct mwi_subscription *sub,
365                 struct ast_sip_message_accumulator *counter)
366 {
367         RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(),
368                                 "endpoint", sub->id), ao2_cleanup);
369         char *endpoint_aors;
370         char *aor_name;
371         struct ast_sip_body body;
372         struct ast_str *body_text;
373         struct ast_sip_body_data body_data = {
374                 .body_type = AST_SIP_MESSAGE_ACCUMULATOR,
375                 .body_data = counter,
376         };
377
378         if (!endpoint) {
379                 ast_log(LOG_WARNING, "Unable to send unsolicited MWI to %s because endpoint does not exist\n",
380                                 sub->id);
381                 return;
382         }
383         if (ast_strlen_zero(endpoint->aors)) {
384                 ast_log(LOG_WARNING, "Unable to send unsolicited MWI to %s because the endpoint has no"
385                                 " configured AORs\n", sub->id);
386                 return;
387         }
388
389         body.type = MWI_TYPE;
390         body.subtype = MWI_SUBTYPE;
391
392         body_text = ast_str_create(64);
393
394         if (!body_text) {
395                 return;
396         }
397
398         if (ast_sip_pubsub_generate_body_content(body.type, body.subtype, &body_data, &body_text)) {
399                 ast_log(LOG_WARNING, "Unable to generate SIP MWI NOTIFY body.\n");
400                 ast_free(body_text);
401                 return;
402         }
403
404         body.body_text = ast_str_buffer(body_text);
405
406         endpoint_aors = ast_strdupa(endpoint->aors);
407
408         ast_debug(5, "Sending unsolicited MWI NOTIFY to endpoint %s, new messages: %d, old messages: %d\n",
409                         sub->id, counter->new_msgs, counter->old_msgs);
410
411         while ((aor_name = strsep(&endpoint_aors, ","))) {
412                 RAII_VAR(struct ast_sip_aor *, aor, ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
413                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
414                 struct unsolicited_mwi_data mwi_data = {
415                         .sub = sub,
416                         .endpoint = endpoint,
417                         .body = &body,
418                 };
419
420                 if (!aor) {
421                         ast_log(LOG_WARNING, "Unable to locate AOR %s for unsolicited MWI\n", aor_name);
422                         continue;
423                 }
424
425                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
426                 if (!contacts || (ao2_container_count(contacts) == 0)) {
427                         ast_log(LOG_WARNING, "No contacts bound to AOR %s. Cannot send unsolicited MWI.\n", aor_name);
428                         continue;
429                 }
430
431                 ao2_callback(contacts, OBJ_NODATA, send_unsolicited_mwi_notify_to_contact, &mwi_data);
432         }
433
434         ast_free(body_text);
435 }
436
437 static void send_mwi_notify(struct mwi_subscription *sub)
438 {
439         struct ast_sip_message_accumulator counter = {
440                 .old_msgs = 0,
441                 .new_msgs = 0,
442         };
443         struct ast_sip_body_data data = {
444                 .body_type = AST_SIP_MESSAGE_ACCUMULATOR,
445                 .body_data = &counter,
446         };
447
448         ao2_callback(sub->stasis_subs, OBJ_NODATA, get_message_count, &counter);
449
450         if (sub->is_solicited) {
451                 ast_sip_subscription_notify(sub->sip_sub, &data, 0);
452                 return;
453         }
454
455         send_unsolicited_mwi_notify(sub, &counter);
456 }
457
458 static int unsubscribe_stasis(void *obj, void *arg, int flags)
459 {
460         struct mwi_stasis_subscription *mwi_stasis = obj;
461         if (mwi_stasis->stasis_sub) {
462                 ast_debug(3, "Removing stasis subscription to mailbox %s\n", mwi_stasis->mailbox);
463                 mwi_stasis->stasis_sub = stasis_unsubscribe(mwi_stasis->stasis_sub);
464         }
465         return CMP_MATCH;
466 }
467
468 static void mwi_subscription_shutdown(struct ast_sip_subscription *sub)
469 {
470         struct mwi_subscription *mwi_sub;
471         RAII_VAR(struct ast_datastore *, mwi_datastore,
472                         ast_sip_subscription_get_datastore(sub, MWI_DATASTORE), ao2_cleanup);
473
474         if (!mwi_datastore) {
475                 return;
476         }
477
478         mwi_sub = mwi_datastore->data;
479         ao2_callback(mwi_sub->stasis_subs, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe_stasis, NULL);
480 }
481
482 static struct ast_datastore_info mwi_ds_info = { };
483
484 static int add_mwi_datastore(struct mwi_subscription *sub)
485 {
486         RAII_VAR(struct ast_datastore *, mwi_datastore, NULL, ao2_cleanup);
487
488         mwi_datastore = ast_sip_subscription_alloc_datastore(&mwi_ds_info, MWI_DATASTORE);
489         if (!mwi_datastore) {
490                 return -1;
491         }
492         mwi_datastore->data = sub;
493
494         ast_sip_subscription_add_datastore(sub->sip_sub, mwi_datastore);
495         return 0;
496 }
497
498 /*!
499  * \brief Determines if an endpoint is receiving unsolicited MWI for a particular mailbox.
500  *
501  * \param endpoint The endpoint to check
502  * \param mailbox The candidate mailbox
503  * \retval 0 The endpoint does not receive unsolicited MWI for this mailbox
504  * \retval 1 The endpoint receives unsolicited MWI for this mailbox
505  */
506 static int endpoint_receives_unsolicited_mwi_for_mailbox(struct ast_sip_endpoint *endpoint,
507                 const char *mailbox)
508 {
509         struct ao2_container *unsolicited = ao2_global_obj_ref(unsolicited_mwi);
510         struct ao2_iterator *mwi_subs;
511         struct mwi_subscription *mwi_sub;
512         const char *endpoint_id = ast_sorcery_object_get_id(endpoint);
513         int ret = 0;
514
515         if (!unsolicited) {
516                 return 0;
517         }
518
519         mwi_subs = ao2_find(unsolicited, endpoint_id, OBJ_SEARCH_KEY | OBJ_MULTIPLE);
520         ao2_cleanup(unsolicited);
521
522         if (!mwi_subs) {
523                 return 0;
524         }
525
526         for (; (mwi_sub = ao2_iterator_next(mwi_subs)) && !ret; ao2_cleanup(mwi_sub)) {
527                 struct mwi_stasis_subscription *mwi_stasis;
528
529                 mwi_stasis = ao2_find(mwi_sub->stasis_subs, mailbox, OBJ_SEARCH_KEY);
530                 if (mwi_stasis) {
531                         ret = 1;
532                         ao2_cleanup(mwi_stasis);
533                 }
534         }
535
536         ao2_iterator_destroy(mwi_subs);
537         return ret;
538 }
539
540 /*!
541  * \brief Determine if an endpoint is a candidate to be able to subscribe for MWI
542  *
543  * Currently, this just makes sure that the endpoint is not already receiving unsolicted
544  * MWI for any of an AOR's configured mailboxes.
545  *
546  * \param obj The AOR to which the endpoint is subscribing.
547  * \param arg The endpoint that is attempting to subscribe.
548  * \param flags Unused.
549  * \retval 0 Endpoint is a candidate to subscribe to MWI on the AOR.
550  * \retval -1 The endpoint cannot subscribe to MWI on the AOR.
551  */
552 static int mwi_validate_for_aor(void *obj, void *arg, int flags)
553 {
554         struct ast_sip_aor *aor = obj;
555         struct ast_sip_endpoint *endpoint = arg;
556         char *mailboxes;
557         char *mailbox;
558
559         if (ast_strlen_zero(aor->mailboxes)) {
560                 return 0;
561         }
562
563         mailboxes = ast_strdupa(aor->mailboxes);
564         while ((mailbox = strsep(&mailboxes, ","))) {
565                 if (endpoint_receives_unsolicited_mwi_for_mailbox(endpoint, mailbox)) {
566                         ast_log(LOG_NOTICE, "Endpoint '%s' already configured for unsolicited MWI for mailbox '%s'. "
567                                         "Denying MWI subscription to %s\n", ast_sorcery_object_get_id(endpoint), mailbox,
568                                         ast_sorcery_object_get_id(aor));
569                         return -1;
570                 }
571         }
572
573         return 0;
574 }
575
576 static int mwi_on_aor(void *obj, void *arg, int flags)
577 {
578         struct ast_sip_aor *aor = obj;
579         struct mwi_subscription *sub = arg;
580         char *mailboxes;
581         char *mailbox;
582
583         if (ast_strlen_zero(aor->mailboxes)) {
584                 return 0;
585         }
586
587         mailboxes = ast_strdupa(aor->mailboxes);
588         while ((mailbox = strsep(&mailboxes, ","))) {
589                 RAII_VAR(struct mwi_stasis_subscription *, mwi_stasis_sub,
590                                 mwi_stasis_subscription_alloc(mailbox, sub), ao2_cleanup);
591                 if (mwi_stasis_sub) {
592                         ao2_link(sub->stasis_subs, mwi_stasis_sub);
593                 }
594         }
595
596         return 0;
597 }
598
599 static struct mwi_subscription *mwi_create_subscription(
600         struct ast_sip_endpoint *endpoint, struct ast_sip_subscription *sip_sub)
601 {
602         struct mwi_subscription *sub = mwi_subscription_alloc(endpoint, 1, sip_sub);
603
604         if (!sub) {
605                 return NULL;
606         }
607
608         if (add_mwi_datastore(sub)) {
609                 ast_log(LOG_WARNING, "Unable to allocate datastore on MWI "
610                         "subscription from %s\n", sub->id);
611                 ao2_ref(sub, -1);
612                 return NULL;
613         }
614
615         return sub;
616 }
617
618 static struct mwi_subscription *mwi_subscribe_single(
619         struct ast_sip_endpoint *endpoint, struct ast_sip_subscription *sip_sub, const char *name)
620 {
621         RAII_VAR(struct ast_sip_aor *, aor,
622                  ast_sip_location_retrieve_aor(name), ao2_cleanup);
623         struct mwi_subscription *sub;
624
625         if (!aor) {
626                 /*! I suppose it's possible for the AOR to disappear on us
627                  * between accepting the subscription and sending the first
628                  * NOTIFY...
629                  */
630                 ast_log(LOG_WARNING, "Unable to locate aor %s. MWI "
631                         "subscription failed.\n", name);
632                 return NULL;
633         }
634
635         if (!(sub = mwi_create_subscription(endpoint, sip_sub))) {
636                 return NULL;
637         }
638
639         mwi_on_aor(aor, sub, 0);
640         return sub;
641 }
642
643 static struct mwi_subscription *mwi_subscribe_all(
644         struct ast_sip_endpoint *endpoint, struct ast_sip_subscription *sip_sub)
645 {
646         struct mwi_subscription *sub;
647
648         sub = mwi_create_subscription(endpoint, sip_sub);
649
650         if (!sub) {
651                 return NULL;
652         }
653
654         ast_sip_for_each_aor(endpoint->aors, mwi_on_aor, sub);
655         return sub;
656 }
657
658 static int mwi_new_subscribe(struct ast_sip_endpoint *endpoint,
659                 const char *resource)
660 {
661         struct ast_sip_aor *aor;
662
663         if (ast_strlen_zero(resource)) {
664                 if (ast_sip_for_each_aor(endpoint->aors, mwi_validate_for_aor, endpoint)) {
665                         return 500;
666                 }
667                 return 200;
668         }
669
670         aor = ast_sip_location_retrieve_aor(resource);
671
672         if (!aor) {
673                 ast_log(LOG_WARNING, "Unable to locate aor %s. MWI "
674                         "subscription failed.\n", resource);
675                 return 404;
676         }
677
678         if (ast_strlen_zero(aor->mailboxes)) {
679                 ast_log(LOG_WARNING, "AOR %s has no configured mailboxes. "
680                         "MWI subscription failed\n", resource);
681                 return 404;
682         }
683
684         if (mwi_validate_for_aor(aor, endpoint, 0)) {
685                 return 500;
686         }
687
688         return 200;
689 }
690
691 static int mwi_subscription_established(struct ast_sip_subscription *sip_sub)
692 {
693         const char *resource = ast_sip_subscription_get_resource_name(sip_sub);
694         struct mwi_subscription *sub;
695         struct ast_sip_endpoint *endpoint = ast_sip_subscription_get_endpoint(sip_sub);
696
697         /* no aor in uri? subscribe to all on endpoint */
698         if (ast_strlen_zero(resource)) {
699                 sub = mwi_subscribe_all(endpoint, sip_sub);
700         } else {
701                 sub = mwi_subscribe_single(endpoint, sip_sub, resource);
702         }
703
704         if (!sub) {
705                 ao2_cleanup(endpoint);
706                 return -1;
707         }
708
709         ao2_cleanup(sub);
710         ao2_cleanup(endpoint);
711         return 0;
712 }
713
714 static void *mwi_get_notify_data(struct ast_sip_subscription *sub)
715 {
716         struct ast_sip_message_accumulator *counter;
717         struct mwi_subscription *mwi_sub;
718         struct ast_datastore *mwi_datastore;
719
720         mwi_datastore = ast_sip_subscription_get_datastore(sub, MWI_DATASTORE);
721         if (!mwi_datastore) {
722                 return NULL;
723         }
724         mwi_sub = mwi_datastore->data;
725
726         counter = ao2_alloc(sizeof(*counter), NULL);
727         if (!counter) {
728                 ao2_cleanup(mwi_datastore);
729                 return NULL;
730         }
731
732         ao2_callback(mwi_sub->stasis_subs, OBJ_NODATA, get_message_count, counter);
733         ao2_cleanup(mwi_datastore);
734         return counter;
735 }
736
737 static void mwi_subscription_mailboxes_str(struct ao2_container *stasis_subs,
738                                            struct ast_str **str)
739 {
740         int num = ao2_container_count(stasis_subs);
741
742         struct mwi_stasis_subscription *node;
743         struct ao2_iterator i = ao2_iterator_init(stasis_subs, 0);
744
745         while ((node = ao2_iterator_next(&i))) {
746                 if (--num) {
747                         ast_str_append(str, 0, "%s,", node->mailbox);
748                 } else {
749                         ast_str_append(str, 0, "%s", node->mailbox);
750                 }
751                 ao2_ref(node, -1);
752         }
753         ao2_iterator_destroy(&i);
754 }
755
756 static void mwi_to_ami(struct ast_sip_subscription *sub,
757                        struct ast_str **buf)
758 {
759         struct mwi_subscription *mwi_sub;
760         RAII_VAR(struct ast_datastore *, mwi_datastore,
761                         ast_sip_subscription_get_datastore(sub, MWI_DATASTORE), ao2_cleanup);
762
763         if (!mwi_datastore) {
764                 return;
765         }
766
767         mwi_sub = mwi_datastore->data;
768
769         ast_str_append(buf, 0, "SubscriptionType: mwi\r\n");
770         ast_str_append(buf, 0, "Mailboxes: ");
771         mwi_subscription_mailboxes_str(mwi_sub->stasis_subs, buf);
772         ast_str_append(buf, 0, "\r\n");
773 }
774
775 static int serialized_notify(void *userdata)
776 {
777         struct mwi_subscription *mwi_sub = userdata;
778
779         send_mwi_notify(mwi_sub);
780         ao2_ref(mwi_sub, -1);
781         return 0;
782 }
783
784 static int serialized_cleanup(void *userdata)
785 {
786         struct mwi_subscription *mwi_sub = userdata;
787
788         /* This is getting rid of the reference that was added
789          * just before this serialized task was pushed.
790          */
791         ao2_cleanup(mwi_sub);
792         /* This is getting rid of the reference held by the
793          * stasis subscription
794          */
795         ao2_cleanup(mwi_sub);
796         return 0;
797 }
798
799 static void mwi_stasis_cb(void *userdata, struct stasis_subscription *sub,
800                 struct stasis_message *msg)
801 {
802         struct mwi_subscription *mwi_sub = userdata;
803
804         if (stasis_subscription_final_message(sub, msg)) {
805                 ao2_ref(mwi_sub, +1);
806                 ast_sip_push_task(NULL, serialized_cleanup, mwi_sub);
807                 return;
808         }
809
810         if (ast_mwi_state_type() == stasis_message_type(msg)) {
811                 struct ast_taskprocessor *serializer = mwi_sub->is_solicited ? ast_sip_subscription_get_serializer(mwi_sub->sip_sub) : NULL;
812                 ao2_ref(mwi_sub, +1);
813                 ast_sip_push_task(serializer, serialized_notify, mwi_sub);
814         }
815 }
816
817 static int create_mwi_subscriptions_for_endpoint(void *obj, void *arg, int flags)
818 {
819         RAII_VAR(struct mwi_subscription *, aggregate_sub, NULL, ao2_cleanup);
820         struct ast_sip_endpoint *endpoint = obj;
821         struct ao2_container *mwi_subscriptions = arg;
822         char *mailboxes;
823         char *mailbox;
824
825         if (ast_strlen_zero(endpoint->subscription.mwi.mailboxes)) {
826                 return 0;
827         }
828
829         if (endpoint->subscription.mwi.aggregate) {
830                 aggregate_sub = mwi_subscription_alloc(endpoint, 0, NULL);
831                 if (!aggregate_sub) {
832                         return 0;
833                 }
834         }
835
836         mailboxes = ast_strdupa(endpoint->subscription.mwi.mailboxes);
837         while ((mailbox = strsep(&mailboxes, ","))) {
838                 struct mwi_subscription *sub = aggregate_sub ?:
839                         mwi_subscription_alloc(endpoint, 0, NULL);
840                 RAII_VAR(struct mwi_stasis_subscription *, mwi_stasis_sub,
841                                 mwi_stasis_subscription_alloc(mailbox, sub), ao2_cleanup);
842                 if (mwi_stasis_sub) {
843                         ao2_link(sub->stasis_subs, mwi_stasis_sub);
844                 }
845                 if (!aggregate_sub) {
846                         ao2_link(mwi_subscriptions, sub);
847                         ao2_cleanup(sub);
848                 }
849         }
850         if (aggregate_sub) {
851                 ao2_link(mwi_subscriptions, aggregate_sub);
852         }
853         return 0;
854 }
855
856 static int unsubscribe(void *obj, void *arg, int flags)
857 {
858         struct mwi_subscription *mwi_sub = obj;
859
860         ao2_callback(mwi_sub->stasis_subs, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe_stasis, NULL);
861         return CMP_MATCH;
862 }
863
864 static void create_mwi_subscriptions(void)
865 {
866         struct ao2_container *mwi_subscriptions = ao2_container_alloc(MWI_BUCKETS, mwi_sub_hash, mwi_sub_cmp);
867         RAII_VAR(struct ao2_container *, old_mwi_subscriptions, ao2_global_obj_ref(unsolicited_mwi), ao2_cleanup);
868         RAII_VAR(struct ao2_container *, endpoints, ast_sorcery_retrieve_by_fields(
869                                 ast_sip_get_sorcery(), "endpoint", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL),
870                         ao2_cleanup);
871
872         if (!mwi_subscriptions) {
873                 return;
874         }
875
876         /* We remove all the old stasis subscriptions first before applying the new configuration. This
877          * prevents a situation where there might be multiple overlapping stasis subscriptions for an
878          * endpoint for mailboxes. Though there may be mailbox changes during the gap between unsubscribing
879          * and resubscribing, up-to-date mailbox state will be sent out to the endpoint when the
880          * new stasis subscription is established
881          */
882         if (old_mwi_subscriptions) {
883                 ao2_callback(old_mwi_subscriptions, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe, NULL);
884         }
885         ao2_callback(endpoints, OBJ_NODATA, create_mwi_subscriptions_for_endpoint, mwi_subscriptions);
886         ao2_global_obj_replace_unref(unsolicited_mwi, mwi_subscriptions);
887         ao2_ref(mwi_subscriptions, -1);
888 }
889
890 static int reload(void)
891 {
892         create_mwi_subscriptions();
893         return 0;
894 }
895
896 static int load_module(void)
897 {
898         CHECK_PJSIP_MODULE_LOADED();
899
900         if (ast_sip_register_subscription_handler(&mwi_handler)) {
901                 return AST_MODULE_LOAD_DECLINE;
902         }
903         create_mwi_subscriptions();
904         return AST_MODULE_LOAD_SUCCESS;
905 }
906
907 static int unload_module(void)
908 {
909         RAII_VAR(struct ao2_container *, mwi_subscriptions, ao2_global_obj_ref(unsolicited_mwi), ao2_cleanup);
910         if (mwi_subscriptions) {
911                 ao2_callback(mwi_subscriptions, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, unsubscribe, NULL);
912                 ao2_global_obj_release(unsolicited_mwi);
913         }
914         ast_sip_unregister_subscription_handler(&mwi_handler);
915         return 0;
916 }
917
918 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP MWI resource",
919                 .support_level = AST_MODULE_SUPPORT_CORE,
920                 .load = load_module,
921                 .unload = unload_module,
922                 .reload = reload,
923                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
924 );