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