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