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