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