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