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