a8a11bc7fb2cafbe370474307cfb80a28977e7f0
[asterisk/asterisk.git] / res / res_pjsip_exten_state.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Kevin Harwell <kharwell@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/app.h"
40 #include "asterisk/taskprocessor.h"
41
42 #define BODY_SIZE 1024
43 #define EVENT_TYPE_SIZE 50
44
45 /*!
46  * \brief A subscription for extension state
47  *
48  * This structure acts as the owner for the underlying SIP subscription. It
49  * also keeps a pointer to an associated "provider" so when a state changes
50  * a notify data creator is quickly accessible.
51  */
52 struct exten_state_subscription {
53         /*! Watcher id when registering for extension state changes */
54         int id;
55         /*! The SIP subscription */
56         struct ast_sip_subscription *sip_sub;
57         /*! The serializer to use for notifications */
58         struct ast_taskprocessor *serializer;
59         /*! Context in which subscription looks for updates */
60         char context[AST_MAX_CONTEXT];
61         /*! Extension within the context to receive updates from */
62         char exten[AST_MAX_EXTENSION];
63         /*! The subscription's user agent */
64         char *user_agent;
65         /*! The last known extension state */
66         enum ast_extension_states last_exten_state;
67         /*! The last known presence state */
68         enum ast_presence_state last_presence_state;
69 };
70
71 #define DEFAULT_PRESENCE_BODY "application/pidf+xml"
72 #define DEFAULT_DIALOG_BODY "application/dialog-info+xml"
73
74 static void subscription_shutdown(struct ast_sip_subscription *sub);
75 static int new_subscribe(struct ast_sip_endpoint *endpoint, const char *resource);
76 static int subscription_established(struct ast_sip_subscription *sub);
77 static void *get_notify_data(struct ast_sip_subscription *sub);
78 static void to_ami(struct ast_sip_subscription *sub,
79                    struct ast_str **buf);
80
81 struct ast_sip_notifier presence_notifier = {
82         .default_accept = DEFAULT_PRESENCE_BODY,
83         .new_subscribe = new_subscribe,
84         .subscription_established = subscription_established,
85         .get_notify_data = get_notify_data,
86 };
87
88 struct ast_sip_notifier dialog_notifier = {
89         .default_accept = DEFAULT_DIALOG_BODY,
90         .new_subscribe = new_subscribe,
91         .subscription_established = subscription_established,
92         .get_notify_data = get_notify_data,
93 };
94
95 struct ast_sip_subscription_handler presence_handler = {
96         .event_name = "presence",
97         .body_type = AST_SIP_EXTEN_STATE_DATA,
98         .accept = { DEFAULT_PRESENCE_BODY, },
99         .subscription_shutdown = subscription_shutdown,
100         .to_ami = to_ami,
101         .notifier = &presence_notifier,
102 };
103
104 struct ast_sip_subscription_handler dialog_handler = {
105         .event_name = "dialog",
106         .body_type = AST_SIP_EXTEN_STATE_DATA,
107         .accept = { DEFAULT_DIALOG_BODY, },
108         .subscription_shutdown = subscription_shutdown,
109         .to_ami = to_ami,
110         .notifier = &dialog_notifier,
111 };
112
113 static void exten_state_subscription_destructor(void *obj)
114 {
115         struct exten_state_subscription *sub = obj;
116
117         ast_free(sub->user_agent);
118         ao2_cleanup(sub->sip_sub);
119         ast_taskprocessor_unreference(sub->serializer);
120 }
121
122 static char *get_user_agent(const struct ast_sip_subscription *sip_sub)
123 {
124         size_t size;
125         char *user_agent = NULL;
126         pjsip_user_agent_hdr *user_agent_hdr = ast_sip_subscription_get_header(
127                         sip_sub, "User-Agent");
128
129         if (!user_agent_hdr) {
130                 return NULL;
131         }
132
133         size = pj_strlen(&user_agent_hdr->hvalue) + 1;
134         user_agent = ast_malloc(size);
135         ast_copy_pj_str(user_agent, &user_agent_hdr->hvalue, size);
136         return ast_str_to_lower(user_agent);
137 }
138
139 /*!
140  * \internal
141  * \brief Initialize the last extension state to something outside
142  * its usual states.
143  */
144 #define INITIAL_LAST_EXTEN_STATE -3
145
146 /*!
147  * \internal
148  * \brief Allocates an exten_state_subscription object.
149  *
150  * Creates the underlying SIP subscription for the given request. First makes
151  * sure that there are registered handler and provider objects available.
152  */
153 static struct exten_state_subscription *exten_state_subscription_alloc(
154                 struct ast_sip_subscription *sip_sub, struct ast_sip_endpoint *endpoint)
155 {
156         struct exten_state_subscription * exten_state_sub;
157
158         exten_state_sub = ao2_alloc(sizeof(*exten_state_sub), exten_state_subscription_destructor);
159         if (!exten_state_sub) {
160                 return NULL;
161         }
162
163         exten_state_sub->sip_sub = ao2_bump(sip_sub);
164
165         /* We keep our own reference to the serializer as there is no guarantee in state_changed
166          * that the subscription tree is still valid when it is called. This can occur when
167          * the subscription is terminated at around the same time as the state_changed
168          * callback is invoked.
169          */
170         exten_state_sub->serializer = ao2_bump(ast_sip_subscription_get_serializer(sip_sub));
171         exten_state_sub->last_exten_state = INITIAL_LAST_EXTEN_STATE;
172         exten_state_sub->last_presence_state = AST_PRESENCE_NOT_SET;
173         exten_state_sub->user_agent = get_user_agent(sip_sub);
174         return exten_state_sub;
175 }
176
177 struct notify_task_data {
178         struct ast_sip_exten_state_data exten_state_data;
179         struct exten_state_subscription *exten_state_sub;
180         int terminate;
181 };
182
183 static void notify_task_data_destructor(void *obj)
184 {
185         struct notify_task_data *task_data = obj;
186
187         ao2_ref(task_data->exten_state_sub, -1);
188         ao2_cleanup(task_data->exten_state_data.device_state_info);
189         ast_free(task_data->exten_state_data.presence_subtype);
190         ast_free(task_data->exten_state_data.presence_message);
191         ast_free(task_data->exten_state_data.user_agent);
192 }
193
194 static struct notify_task_data *alloc_notify_task_data(char *exten, struct exten_state_subscription *exten_state_sub,
195                                                        struct ast_state_cb_info *info)
196 {
197         struct notify_task_data *task_data =
198                 ao2_alloc(sizeof(*task_data), notify_task_data_destructor);
199
200         if (!task_data) {
201                 ast_log(LOG_WARNING, "Unable to create notify task data\n");
202                 return NULL;
203         }
204
205         task_data->exten_state_sub = exten_state_sub;
206         task_data->exten_state_sub->last_exten_state = info->exten_state;
207         task_data->exten_state_sub->last_presence_state = info->presence_state;
208         ao2_ref(task_data->exten_state_sub, +1);
209
210         task_data->exten_state_data.exten = exten_state_sub->exten;
211         task_data->exten_state_data.exten_state = info->exten_state;
212         task_data->exten_state_data.presence_state = info->presence_state;
213         task_data->exten_state_data.presence_subtype = ast_strdup(info->presence_subtype);
214         task_data->exten_state_data.presence_message = ast_strdup(info->presence_message);
215         task_data->exten_state_data.user_agent = ast_strdup(exten_state_sub->user_agent);
216         task_data->exten_state_data.device_state_info = ao2_bump(info->device_state_info);
217         task_data->exten_state_data.sub = exten_state_sub->sip_sub;
218
219         if ((info->exten_state == AST_EXTENSION_DEACTIVATED) ||
220             (info->exten_state == AST_EXTENSION_REMOVED)) {
221                 ast_verb(2, "Watcher for hint %s %s\n", exten, info->exten_state
222                          == AST_EXTENSION_REMOVED ? "removed" : "deactivated");
223                 task_data->terminate = 1;
224         }
225
226         return task_data;
227 }
228
229 static int notify_task(void *obj)
230 {
231         RAII_VAR(struct notify_task_data *, task_data, obj, ao2_cleanup);
232         struct ast_sip_body_data data = {
233                 .body_type = AST_SIP_EXTEN_STATE_DATA,
234                 .body_data = &task_data->exten_state_data,
235         };
236
237         /* Terminated subscriptions are no longer associated with a valid tree, and sending
238          * NOTIFY messages on a subscription which has already been terminated won't work.
239          */
240         if (ast_sip_subscription_is_terminated(task_data->exten_state_sub->sip_sub)) {
241                 return 0;
242         }
243
244         /* All access to the subscription must occur within a task executed within its serializer */
245         ast_sip_subscription_get_local_uri(task_data->exten_state_sub->sip_sub,
246                         task_data->exten_state_data.local, sizeof(task_data->exten_state_data.local));
247         ast_sip_subscription_get_remote_uri(task_data->exten_state_sub->sip_sub,
248                         task_data->exten_state_data.remote, sizeof(task_data->exten_state_data.remote));
249
250         /* Pool allocation has to happen here so that we allocate within a PJLIB thread */
251         task_data->exten_state_data.pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(),
252                         "exten_state", 1024, 1024);
253         if (!task_data->exten_state_data.pool) {
254                 return -1;
255         }
256
257         task_data->exten_state_data.sub = task_data->exten_state_sub->sip_sub;
258
259         ast_sip_subscription_notify(task_data->exten_state_sub->sip_sub, &data,
260                         task_data->terminate);
261
262         pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(),
263                         task_data->exten_state_data.pool);
264         return 0;
265 }
266
267 /*!
268  * \internal
269  * \brief Callback for exten/device state changes.
270  *
271  * Upon state change, send the appropriate notification to the subscriber.
272  */
273 static int state_changed(char *context, char *exten,
274                          struct ast_state_cb_info *info, void *data)
275 {
276         struct notify_task_data *task_data;
277         struct exten_state_subscription *exten_state_sub = data;
278
279         if (!(task_data = alloc_notify_task_data(exten, exten_state_sub, info))) {
280                 return -1;
281         }
282
283         /* safe to push this async since we copy the data from info and
284            add a ref for the device state info */
285         if (ast_sip_push_task(task_data->exten_state_sub->serializer, notify_task,
286                 task_data)) {
287                 ao2_cleanup(task_data);
288                 return -1;
289         }
290         return 0;
291 }
292
293 static void state_changed_destroy(int id, void *data)
294 {
295         struct exten_state_subscription *exten_state_sub = data;
296         ao2_cleanup(exten_state_sub);
297 }
298
299 static struct ast_datastore_info ds_info = { };
300 static const char ds_name[] = "exten state datastore";
301
302 /*!
303  * \internal
304  * \brief Add a datastore for exten exten_state_subscription.
305  *
306  * Adds the exten_state_subscription wrapper object to a datastore so it can be retrieved
307  * later based upon its association with the ast_sip_subscription.
308  */
309 static int add_datastore(struct exten_state_subscription *exten_state_sub)
310 {
311         RAII_VAR(struct ast_datastore *, datastore,
312                  ast_sip_subscription_alloc_datastore(&ds_info, ds_name), ao2_cleanup);
313
314         if (!datastore) {
315                 return -1;
316         }
317
318         datastore->data = exten_state_sub;
319         ast_sip_subscription_add_datastore(exten_state_sub->sip_sub, datastore);
320         ao2_ref(exten_state_sub, +1);
321         return 0;
322 }
323
324 /*!
325  * \internal
326  * \brief Get the exten_state_subscription object associated with the given
327  * ast_sip_subscription in the datastore.
328  */
329 static struct exten_state_subscription *get_exten_state_sub(
330         struct ast_sip_subscription *sub)
331 {
332         RAII_VAR(struct ast_datastore *, datastore,
333                  ast_sip_subscription_get_datastore(sub, ds_name), ao2_cleanup);
334
335         return datastore ? datastore->data : NULL;
336 }
337
338 static void subscription_shutdown(struct ast_sip_subscription *sub)
339 {
340         struct exten_state_subscription *exten_state_sub = get_exten_state_sub(sub);
341
342         if (!exten_state_sub) {
343                 return;
344         }
345
346         ast_extension_state_del(exten_state_sub->id, state_changed);
347         ast_sip_subscription_remove_datastore(exten_state_sub->sip_sub, ds_name);
348         /* remove data store reference */
349         ao2_cleanup(exten_state_sub);
350 }
351
352 static int new_subscribe(struct ast_sip_endpoint *endpoint,
353                 const char *resource)
354 {
355         if (!ast_exists_extension(NULL, endpoint->context, resource, PRIORITY_HINT, NULL)) {
356                 ast_log(LOG_NOTICE, "Extension state subscription failed: Extension %s does not exist in context '%s' or has no associated hint\n",
357                         resource, endpoint->context);
358                 return 404;
359         }
360
361         return 200;
362 }
363
364 static int subscription_established(struct ast_sip_subscription *sip_sub)
365 {
366         struct ast_sip_endpoint *endpoint = ast_sip_subscription_get_endpoint(sip_sub);
367         const char *resource = ast_sip_subscription_get_resource_name(sip_sub);
368         struct exten_state_subscription *exten_state_sub;
369
370         if (!(exten_state_sub = exten_state_subscription_alloc(sip_sub, endpoint))) {
371                 ao2_cleanup(endpoint);
372                 return -1;
373         }
374
375         ast_copy_string(exten_state_sub->context, endpoint->context, sizeof(exten_state_sub->context));
376         ast_copy_string(exten_state_sub->exten, resource, sizeof(exten_state_sub->exten));
377
378         if ((exten_state_sub->id = ast_extension_state_add_destroy_extended(
379                      exten_state_sub->context, exten_state_sub->exten,
380                      state_changed, state_changed_destroy, exten_state_sub)) < 0) {
381                 ast_log(LOG_WARNING, "Unable to subscribe endpoint '%s' to extension '%s@%s'\n",
382                         ast_sorcery_object_get_id(endpoint), exten_state_sub->exten,
383                         exten_state_sub->context);
384                 ao2_cleanup(endpoint);
385                 ao2_cleanup(exten_state_sub);
386                 return -1;
387         }
388
389         /* Go ahead and cleanup the endpoint since we don't need it anymore */
390         ao2_cleanup(endpoint);
391
392         /* bump the ref since ast_extension_state_add holds a reference */
393         ao2_ref(exten_state_sub, +1);
394
395         if (add_datastore(exten_state_sub)) {
396                 ast_log(LOG_WARNING, "Unable to add to subscription datastore.\n");
397                 ao2_cleanup(exten_state_sub);
398                 return -1;
399         }
400
401         ao2_cleanup(exten_state_sub);
402         return 0;
403 }
404
405 static void exten_state_data_destructor(void *obj)
406 {
407         struct ast_sip_exten_state_data *exten_state_data = obj;
408
409         ao2_cleanup(exten_state_data->device_state_info);
410         ast_free(exten_state_data->presence_subtype);
411         ast_free(exten_state_data->presence_message);
412         if (exten_state_data->pool) {
413                 pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), exten_state_data->pool);
414         }
415 }
416
417 static struct ast_sip_exten_state_data *exten_state_data_alloc(struct ast_sip_subscription *sip_sub,
418                 struct exten_state_subscription *exten_state_sub)
419 {
420         struct ast_sip_exten_state_data *exten_state_data;
421         char *subtype = NULL;
422         char *message = NULL;
423         int presence_state;
424
425         exten_state_data = ao2_alloc(sizeof(*exten_state_data), exten_state_data_destructor);
426         if (!exten_state_data) {
427                 return NULL;
428         }
429
430         exten_state_data->exten = exten_state_sub->exten;
431         presence_state = ast_hint_presence_state(NULL, exten_state_sub->context, exten_state_sub->exten, &subtype, &message);
432         if (presence_state  == -1 || presence_state == AST_PRESENCE_INVALID) {
433                 ao2_cleanup(exten_state_data);
434                 return NULL;
435         }
436         exten_state_data->presence_state = presence_state;
437         exten_state_data->presence_subtype = subtype;
438         exten_state_data->presence_message = message;
439         exten_state_data->user_agent = exten_state_sub->user_agent;
440         ast_sip_subscription_get_local_uri(sip_sub, exten_state_data->local,
441                         sizeof(exten_state_data->local));
442         ast_sip_subscription_get_remote_uri(sip_sub, exten_state_data->remote,
443                         sizeof(exten_state_data->remote));
444         exten_state_data->sub = sip_sub;
445
446         exten_state_data->exten_state = ast_extension_state_extended(
447                         NULL, exten_state_sub->context, exten_state_sub->exten,
448                         &exten_state_data->device_state_info);
449         if (exten_state_data->exten_state < 0) {
450                 ao2_cleanup(exten_state_data);
451                 return NULL;
452         }
453
454         exten_state_data->pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(),
455                         "exten_state", 1024, 1024);
456         if (!exten_state_data->pool) {
457                 ao2_cleanup(exten_state_data);
458                 return NULL;
459         }
460
461         return exten_state_data;
462 }
463
464 static void *get_notify_data(struct ast_sip_subscription *sub)
465 {
466         struct exten_state_subscription *exten_state_sub;
467
468         exten_state_sub = get_exten_state_sub(sub);
469         if (!exten_state_sub) {
470                 return NULL;
471         }
472
473         return exten_state_data_alloc(sub, exten_state_sub);
474 }
475
476 static void to_ami(struct ast_sip_subscription *sub,
477                    struct ast_str **buf)
478 {
479         struct exten_state_subscription *exten_state_sub =
480                 get_exten_state_sub(sub);
481
482         if (!exten_state_sub) {
483                 return;
484         }
485
486         ast_str_append(buf, 0, "SubscriptionType: extension_state\r\n"
487                        "Extension: %s\r\nExtensionStates: %s\r\n",
488                        exten_state_sub->exten, ast_extension_state2str(
489                                exten_state_sub->last_exten_state));
490 }
491
492 static int load_module(void)
493 {
494         CHECK_PJSIP_MODULE_LOADED();
495
496         if (ast_sip_register_subscription_handler(&presence_handler)) {
497                 ast_log(LOG_WARNING, "Unable to register subscription handler %s\n",
498                         presence_handler.event_name);
499                 return AST_MODULE_LOAD_DECLINE;
500         }
501
502         if (ast_sip_register_subscription_handler(&dialog_handler)) {
503                 ast_log(LOG_WARNING, "Unable to register subscription handler %s\n",
504                         dialog_handler.event_name);
505                 ast_sip_unregister_subscription_handler(&presence_handler);
506                 return AST_MODULE_LOAD_DECLINE;
507         }
508
509         return AST_MODULE_LOAD_SUCCESS;
510 }
511
512 static int unload_module(void)
513 {
514         ast_sip_unregister_subscription_handler(&dialog_handler);
515         ast_sip_unregister_subscription_handler(&presence_handler);
516         return 0;
517 }
518
519 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Extension State Notifications",
520         .support_level = AST_MODULE_SUPPORT_CORE,
521         .load = load_module,
522         .unload = unload_module,
523         .load_pri = AST_MODPRI_CHANNEL_DEPEND,
524 );