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