461e5534a41bf4c8017747a8fff48fccbfbbf63e
[asterisk/asterisk.git] / res / res_pjsip / pjsip_options.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Matt Jordan <mjordan@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 #include "asterisk.h"
20
21 #include <pjsip.h>
22 #include <pjsip_ua.h>
23 #include <pjlib.h>
24
25 #include "asterisk/res_pjsip.h"
26 #include "asterisk/channel.h"
27 #include "asterisk/pbx.h"
28 #include "asterisk/astobj2.h"
29 #include "asterisk/cli.h"
30 #include "asterisk/time.h"
31 #include "include/res_pjsip_private.h"
32
33 #define DEFAULT_LANGUAGE "en"
34 #define DEFAULT_ENCODING "text/plain"
35 #define QUALIFIED_BUCKETS 211
36
37 /*!
38  * \internal
39  * \brief Create a ast_sip_contact_status object.
40  */
41 static void *contact_status_alloc(const char *name)
42 {
43         struct ast_sip_contact_status *status = ast_sorcery_generic_alloc(sizeof(*status), NULL);
44
45         if (!status) {
46                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status\n");
47                 return NULL;
48         }
49
50         status->status = UNAVAILABLE;
51
52         return status;
53 }
54
55 /*!
56  * \internal
57  * \brief Retrieve a ast_sip_contact_status object from sorcery creating
58  *        one if not found.
59  */
60 static struct ast_sip_contact_status *find_or_create_contact_status(const struct ast_sip_contact *contact)
61 {
62         struct ast_sip_contact_status *status = ast_sorcery_retrieve_by_id(
63                 ast_sip_get_sorcery(), CONTACT_STATUS,
64                 ast_sorcery_object_get_id(contact));
65
66         if (status) {
67                 return status;
68         }
69
70         if (!(status = ast_sorcery_alloc(
71                       ast_sip_get_sorcery(), CONTACT_STATUS,
72                       ast_sorcery_object_get_id(contact)))) {
73
74                 ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s\n",
75                         contact->uri);
76                 return NULL;
77         }
78
79         if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
80                 ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
81                         contact->uri);
82                 return NULL;
83         }
84
85         return status;
86 }
87
88 /*!
89  * \internal
90  * \brief Update an ast_sip_contact_status's elements.
91  */
92 static void update_contact_status(const struct ast_sip_contact *contact,
93                                   enum ast_sip_contact_status_type value)
94 {
95         RAII_VAR(struct ast_sip_contact_status *, status,
96                  find_or_create_contact_status(contact), ao2_cleanup);
97
98         RAII_VAR(struct ast_sip_contact_status *, update, ast_sorcery_alloc(
99                       ast_sip_get_sorcery(), CONTACT_STATUS,
100                       ast_sorcery_object_get_id(status)), ao2_cleanup);
101
102         if (!update) {
103                 ast_log(LOG_ERROR, "Unable to create update ast_sip_contact_status for contact %s\n",
104                         contact->uri);
105                 return;
106         }
107
108         update->status = value;
109
110         /* if the contact is available calculate the rtt as
111            the diff between the last start time and "now" */
112         update->rtt = update->status ?
113                 ast_tvdiff_us(ast_tvnow(), status->rtt_start) : 0;
114
115         update->rtt_start = ast_tv(0, 0);
116
117         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
118                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
119                         contact->uri);
120         }
121 }
122
123 /*!
124  * \internal
125  * \brief Initialize the start time on a contact status so the round
126  *        trip time can be calculated upon a valid response.
127  */
128 static void init_start_time(const struct ast_sip_contact *contact)
129 {
130         RAII_VAR(struct ast_sip_contact_status *, status,
131                  find_or_create_contact_status(contact), ao2_cleanup);
132
133         RAII_VAR(struct ast_sip_contact_status *, update, ast_sorcery_alloc(
134                       ast_sip_get_sorcery(), CONTACT_STATUS,
135                       ast_sorcery_object_get_id(status)), ao2_cleanup);
136
137         if (!update) {
138                 ast_log(LOG_ERROR, "Unable to create update ast_sip_contact_status for contact %s\n",
139                         contact->uri);
140                 return;
141         }
142
143         update->rtt_start = ast_tvnow();
144
145         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
146                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
147                         contact->uri);
148         }
149 }
150
151 /*!
152  * \internal
153  * \brief Match a container contact object with the contact sorcery id looking for.
154  *
155  * \param obj pointer to the (user-defined part) of an object.
156  * \param arg callback argument from ao2_callback()
157  * \param flags flags from ao2_callback()
158  *
159  * \return Values are a combination of enum _cb_results.
160  */
161 static int match_contact_id(void *obj, void *arg, int flags)
162 {
163         struct ast_sip_contact *contact = obj;
164         const char *looking_for = arg;
165
166         return strcmp(ast_sorcery_object_get_id(contact), looking_for) ? 0 : CMP_MATCH;
167 }
168
169 /*!
170  * \internal
171  * \brief For an endpoint try to match the given contact sorcery id.
172  */
173 static int on_endpoint(void *obj, void *arg, int flags)
174 {
175         struct ast_sip_endpoint *endpoint = obj;
176         struct ast_sip_contact *contact;
177         char *looking_for = arg;
178         char *aor_name;
179         char *aors;
180
181         if (!arg || ast_strlen_zero(endpoint->aors)) {
182                 return 0;
183         }
184
185         aors = ast_strdupa(endpoint->aors);
186
187         while ((aor_name = strsep(&aors, ","))) {
188                 RAII_VAR(struct ast_sip_aor *, aor,
189                          ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
190                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
191
192                 if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
193                         continue;
194                 }
195
196                 contact = ao2_callback(contacts, 0, match_contact_id, looking_for);
197                 if (contact) {
198                         ao2_ref(contact,  -1);
199                         return CMP_MATCH;
200                 }
201         }
202
203         return 0;
204 }
205
206 /*!
207  * \internal
208  * \brief Find an endpoint associated with the given contact.
209  */
210 static struct ast_sip_endpoint *find_an_endpoint(struct ast_sip_contact *contact)
211 {
212         RAII_VAR(struct ao2_container *, endpoints, ast_sip_get_endpoints(), ao2_cleanup);
213         char *looking_for = (char *) ast_sorcery_object_get_id(contact);
214
215         return ao2_callback(endpoints, 0, on_endpoint, looking_for);
216 }
217
218 /*!
219  * \internal
220  * \brief Receive an response to the qualify contact request.
221  */
222 static void qualify_contact_cb(void *token, pjsip_event *e)
223 {
224         struct ast_sip_contact *contact = token;
225
226         switch(e->body.tsx_state.type) {
227         case PJSIP_EVENT_TRANSPORT_ERROR:
228         case PJSIP_EVENT_TIMER:
229                 update_contact_status(contact, UNAVAILABLE);
230                 break;
231         default:
232                 update_contact_status(contact, AVAILABLE);
233                 break;
234         }
235         ao2_cleanup(contact);
236 }
237
238 /*!
239  * \internal
240  * \brief Attempt to qualify the contact
241  *
242  * \details Sends a SIP OPTIONS request to the given contact in order to make
243  *         sure that contact is available.
244  */
245 static int qualify_contact(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact)
246 {
247         pjsip_tx_data *tdata;
248         RAII_VAR(struct ast_sip_endpoint *, endpoint_local, NULL, ao2_cleanup);
249
250         if (contact->authenticate_qualify) {
251                 endpoint_local = ao2_bump(endpoint);
252                 if (!endpoint_local) {
253                         /*
254                          * Find the "first" endpoint to completely qualify the contact - any
255                          * endpoint that is associated with the contact should do.
256                          */
257                         endpoint_local = find_an_endpoint(contact);
258                         if (!endpoint_local) {
259                                 ast_log(LOG_ERROR, "Unable to find an endpoint to qualify contact %s\n",
260                                         contact->uri);
261                                 return -1;
262                         }
263                 }
264         }
265
266         if (ast_sip_create_request("OPTIONS", NULL, NULL, NULL, contact, &tdata)) {
267                 ast_log(LOG_ERROR, "Unable to create request to qualify contact %s\n",
268                         contact->uri);
269                 return -1;
270         }
271
272         /* If an outbound proxy is specified set it on this request */
273         if (!ast_strlen_zero(contact->outbound_proxy) &&
274                 ast_sip_set_outbound_proxy(tdata, contact->outbound_proxy)) {
275                 pjsip_tx_data_dec_ref(tdata);
276                 ast_log(LOG_ERROR, "Unable to apply outbound proxy on request to qualify contact %s\n",
277                         contact->uri);
278                 return -1;
279         }
280
281         init_start_time(contact);
282
283         ao2_ref(contact, +1);
284         if (ast_sip_send_request(tdata, NULL, endpoint_local, contact, qualify_contact_cb)
285                 != PJ_SUCCESS) {
286                 ast_log(LOG_ERROR, "Unable to send request to qualify contact %s\n",
287                         contact->uri);
288                 ao2_ref(contact, -1);
289                 return -1;
290         }
291
292         return 0;
293 }
294
295 /*!
296  * \internal
297  * \brief Scheduling context for sending QUALIFY request at specified intervals.
298  */
299 static struct ast_sched_context *sched;
300
301 /*!
302  * \internal
303  * \brief Container to hold all actively scheduled qualifies.
304  */
305 static struct ao2_container *sched_qualifies;
306
307 /*!
308  * \internal
309  * \brief Structure to hold qualify contact scheduling information.
310  */
311 struct sched_data {
312         /*! The scheduling id */
313         int id;
314         /*! The the contact being checked */
315         struct ast_sip_contact *contact;
316 };
317
318 /*!
319  * \internal
320  * \brief Destroy the scheduled data and remove from scheduler.
321  */
322 static void sched_data_destructor(void *obj)
323 {
324         struct sched_data *data = obj;
325         ao2_cleanup(data->contact);
326 }
327 /*!
328  * \internal
329  * \brief Create the scheduling data object.
330  */
331 static struct sched_data *sched_data_create(struct ast_sip_contact *contact)
332 {
333         struct sched_data *data = ao2_alloc(sizeof(*data), sched_data_destructor);
334
335         if (!data) {
336                 ast_log(LOG_ERROR, "Unable to create schedule qualify data\n");
337                 return NULL;
338         }
339
340         data->contact = contact;
341         ao2_ref(data->contact, +1);
342
343         return data;
344 }
345
346 /*!
347  * \internal
348  * \brief Send a qualify contact request within a threaded task.
349  */
350 static int qualify_contact_task(void *obj)
351 {
352         RAII_VAR(struct ast_sip_contact *, contact, obj, ao2_cleanup);
353         return qualify_contact(NULL, contact);
354 }
355
356 /*!
357  * \internal
358  * \brief Send a scheduled qualify contact request.
359  */
360 static int qualify_contact_sched(const void *obj)
361 {
362         struct sched_data *data = (struct sched_data *)obj;
363
364         ao2_ref(data->contact, +1);
365         if (ast_sip_push_task(NULL, qualify_contact_task, data->contact)) {
366                 ao2_ref(data->contact, -1);
367                 ao2_cleanup(data);
368                 return 0;
369         }
370
371         return data->contact->qualify_frequency * 1000;
372 }
373
374 /*!
375  * \internal
376  * \brief Set up a scheduled qualify contact check.
377  */
378 static void schedule_qualify(struct ast_sip_contact *contact)
379 {
380         RAII_VAR(struct sched_data *, data, sched_data_create(contact), ao2_cleanup);
381
382         if (!data) {
383                 return;
384         }
385
386         ao2_ref(data, +1);
387         if ((data->id = ast_sched_add_variable(
388                     sched, contact->qualify_frequency * 1000,
389                     qualify_contact_sched, data, 1)) < 0) {
390
391                 ao2_ref(data, -1);
392                 ast_log(LOG_ERROR, "Unable to schedule qualify for contact %s\n",
393                         contact->uri);
394                 return;
395         }
396
397         ao2_link(sched_qualifies, data);
398 }
399
400 /*!
401  * \internal
402  * \brief Remove the contact from the scheduler.
403  */
404 static void unschedule_qualify(struct ast_sip_contact *contact)
405 {
406         RAII_VAR(struct sched_data *, data, ao2_find(
407                          sched_qualifies, contact, OBJ_UNLINK), ao2_cleanup);
408
409         if (!data) {
410                 return;
411         }
412
413         AST_SCHED_DEL_UNREF(sched, data->id, ao2_cleanup(data));
414 }
415
416 /*!
417  * \internal
418  * \brief Qualify the given contact and set up scheduling if configured.
419  */
420 static void qualify_and_schedule(struct ast_sip_contact *contact)
421 {
422         unschedule_qualify(contact);
423
424         if (contact->qualify_frequency) {
425                 ao2_ref(contact, +1);
426                 ast_sip_push_task(NULL, qualify_contact_task, contact);
427
428                 schedule_qualify(contact);
429         }
430 }
431
432 /*!
433  * \internal
434  * \brief A new contact has been created make sure it is available.
435  */
436 static void contact_created(const void *obj)
437 {
438         qualify_and_schedule((struct ast_sip_contact *)obj);
439 }
440
441 /*!
442  * \internal
443  * \brief A contact has been deleted remove status tracking.
444  */
445 static void contact_deleted(const void *obj)
446 {
447         struct ast_sip_contact *contact = (struct ast_sip_contact *)obj;
448         RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
449
450         unschedule_qualify(contact);
451
452         if (!(status = ast_sorcery_retrieve_by_id(
453                       ast_sip_get_sorcery(), CONTACT_STATUS,
454                       ast_sorcery_object_get_id(contact)))) {
455                 return;
456         }
457
458         if (ast_sorcery_delete(ast_sip_get_sorcery(), status)) {
459                 ast_log(LOG_ERROR, "Unable to delete ast_sip_contact_status for contact %s\n",
460                         contact->uri);
461         }
462 }
463
464 static const struct ast_sorcery_observer contact_observer = {
465         .created = contact_created,
466         .deleted = contact_deleted
467 };
468
469 static pj_bool_t options_start(void)
470 {
471         if (!(sched = ast_sched_context_create()) ||
472             ast_sched_start_thread(sched)) {
473                 return -1;
474         }
475
476         return PJ_SUCCESS;
477 }
478
479 static pj_bool_t options_stop(void)
480 {
481         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "contact", &contact_observer);
482
483         ao2_t_ref(sched_qualifies, -1, "Remove scheduled qualifies on module stop");
484
485         if (sched) {
486                 ast_sched_context_destroy(sched);
487         }
488
489         return PJ_SUCCESS;
490 }
491
492 static pj_status_t send_options_response(pjsip_rx_data *rdata, int code)
493 {
494         pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
495         pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
496         pjsip_transaction *trans = pjsip_rdata_get_tsx(rdata);
497         pjsip_tx_data *tdata;
498         const pjsip_hdr *hdr;
499         pjsip_response_addr res_addr;
500         pj_status_t status;
501
502         /* Make the response object */
503         if ((status = ast_sip_create_response(rdata, code, NULL, &tdata) != PJ_SUCCESS)) {
504                 ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
505                 return status;
506         }
507
508         /* Add appropriate headers */
509         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ACCEPT, NULL))) {
510                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
511         }
512         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ALLOW, NULL))) {
513                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
514         }
515         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_SUPPORTED, NULL))) {
516                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
517         }
518
519         /*
520          * XXX TODO: pjsip doesn't care a lot about either of these headers -
521          * while it provides specific methods to create them, they are defined
522          * to be the standard string header creation. We never did add them
523          * in chan_sip, although RFC 3261 says they SHOULD. Hard coded here.
524          */
525         ast_sip_add_header(tdata, "Accept-Encoding", DEFAULT_ENCODING);
526         ast_sip_add_header(tdata, "Accept-Language", DEFAULT_LANGUAGE);
527
528         if (dlg && trans) {
529                 status = pjsip_dlg_send_response(dlg, trans, tdata);
530         } else {
531                 /* Get where to send request. */
532                 if ((status = pjsip_get_response_addr(
533                              tdata->pool, rdata, &res_addr)) != PJ_SUCCESS) {
534                         ast_log(LOG_ERROR, "Unable to get response address (%d)\n",
535                                 status);
536
537                         pjsip_tx_data_dec_ref(tdata);
538                         return status;
539                 }
540                 status = ast_sip_send_response(&res_addr, tdata,
541                                                    ast_pjsip_rdata_get_endpoint(rdata));
542         }
543
544         if (status != PJ_SUCCESS) {
545                 ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
546         }
547
548         return status;
549 }
550
551 static pj_bool_t options_on_rx_request(pjsip_rx_data *rdata)
552 {
553         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
554         pjsip_uri *ruri;
555         pjsip_sip_uri *sip_ruri;
556         char exten[AST_MAX_EXTENSION];
557
558         if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method,
559                              &pjsip_options_method)) {
560                 return PJ_FALSE;
561         }
562
563         if (!(endpoint = ast_pjsip_rdata_get_endpoint(rdata))) {
564                 return PJ_FALSE;
565         }
566
567         ruri = rdata->msg_info.msg->line.req.uri;
568         if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
569                 send_options_response(rdata, 416);
570                 return -1;
571         }
572
573         sip_ruri = pjsip_uri_get_uri(ruri);
574         ast_copy_pj_str(exten, &sip_ruri->user, sizeof(exten));
575
576         if (ast_shutting_down()) {
577                 send_options_response(rdata, 503);
578         } else if (!ast_exists_extension(NULL, endpoint->context, exten, 1, NULL)) {
579                 send_options_response(rdata, 404);
580         } else {
581                 send_options_response(rdata, 200);
582         }
583         return PJ_TRUE;
584 }
585
586 static pjsip_module options_module = {
587         .name = {"Options Module", 14},
588         .id = -1,
589         .priority = PJSIP_MOD_PRIORITY_APPLICATION,
590         .start = options_start,
591         .stop = options_stop,
592         .on_rx_request = options_on_rx_request,
593 };
594
595 /*!
596  * \internal
597  * \brief Send qualify request to the given contact.
598  */
599 static int cli_on_contact(void *obj, void *arg, void *data, int flags)
600 {
601         struct ast_sip_contact *contact = obj;
602         struct ast_sip_endpoint *endpoint = data;
603         int *cli_fd = arg;
604
605         ast_cli(*cli_fd, " contact %s\n", contact->uri);
606         qualify_contact(endpoint, contact);
607         return 0;
608 }
609
610 /*!
611  * \brief Data pushed to threadpool to qualify endpoints from the CLI
612  */
613 struct qualify_data {
614         /*! Endpoint that is being qualified */
615         struct ast_sip_endpoint *endpoint;
616         /*! CLI File descriptor for printing messages */
617         int cli_fd;
618 };
619
620 static struct qualify_data *qualify_data_alloc(struct ast_sip_endpoint *endpoint, int cli_fd)
621 {
622         struct qualify_data *qual_data;
623
624         qual_data = ast_malloc(sizeof(*qual_data));
625         if (!qual_data) {
626                 return NULL;
627         }
628
629         qual_data->endpoint = ao2_bump(endpoint);
630         qual_data->cli_fd = cli_fd;
631         return qual_data;
632 }
633
634 static void qualify_data_destroy(struct qualify_data *qual_data)
635 {
636         ao2_cleanup(qual_data->endpoint);
637         ast_free(qual_data);
638 }
639
640 /*!
641  * \internal
642  * \brief For an endpoint iterate over and qualify all aors/contacts
643  */
644 static int cli_qualify_contacts(void *data)
645 {
646         char *aor_name, *aors;
647         RAII_VAR(struct qualify_data *, qual_data, data, qualify_data_destroy);
648         struct ast_sip_endpoint *endpoint = qual_data->endpoint;
649         int cli_fd = qual_data->cli_fd;
650         const char *endpoint_name = ast_sorcery_object_get_id(endpoint);
651
652         if (ast_strlen_zero(endpoint->aors)) {
653                 ast_cli(cli_fd, "Endpoint %s has no AoR's configured\n",
654                         endpoint_name);
655                 return 0;
656         }
657
658         aors = ast_strdupa(endpoint->aors);
659
660         while ((aor_name = strsep(&aors, ","))) {
661                 RAII_VAR(struct ast_sip_aor *, aor,
662                          ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
663                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
664
665                 if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
666                         continue;
667                 }
668
669                 ast_cli(cli_fd, "Sending qualify to endpoint %s\n", endpoint_name);
670                 ao2_callback_data(contacts, OBJ_NODATA, cli_on_contact, &cli_fd, endpoint);
671         }
672         return 0;
673 }
674
675 static char *cli_qualify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
676 {
677         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
678         const char *endpoint_name;
679         struct qualify_data *qual_data;
680
681         switch (cmd) {
682         case CLI_INIT:
683                 e->command = "pjsip qualify";
684                 e->usage =
685                         "Usage: pjsip qualify <endpoint>\n"
686                         "       Send a SIP OPTIONS request to all contacts on the endpoint.\n";
687                 return NULL;
688         case CLI_GENERATE:
689                 return NULL;
690         }
691
692         if (a->argc != 3) {
693                 return CLI_SHOWUSAGE;
694         }
695
696         endpoint_name = a->argv[2];
697
698         if (!(endpoint = ast_sorcery_retrieve_by_id(
699                       ast_sip_get_sorcery(), "endpoint", endpoint_name))) {
700                 ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
701                 return CLI_FAILURE;
702         }
703
704         qual_data = qualify_data_alloc(endpoint, a->fd);
705         if (!qual_data) {
706                 return CLI_FAILURE;
707         }
708
709         if (ast_sip_push_task(NULL, cli_qualify_contacts, qual_data)) {
710                 qualify_data_destroy(qual_data);
711                 return CLI_FAILURE;
712         }
713
714         return CLI_SUCCESS;
715 }
716
717 /*!
718  * \internal
719  * \brief Send qualify request to the given contact.
720  */
721 static int ami_contact_cb(void *obj, void *arg, int flags)
722 {
723         struct ast_sip_contact *contact = obj;
724         ao2_ref(contact, +1);
725         if (ast_sip_push_task(NULL, qualify_contact_task, contact)) {
726                 ao2_cleanup(contact);
727         }
728         return 0;
729 }
730
731 static int ami_sip_qualify(struct mansession *s, const struct message *m)
732 {
733         const char *endpoint_name = astman_get_header(m, "Endpoint");
734         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
735         char *aor_name, *aors;
736
737         if (ast_strlen_zero(endpoint_name)) {
738                 astman_send_error(s, m, "Endpoint parameter missing.");
739                 return 0;
740         }
741
742         endpoint = ast_sorcery_retrieve_by_id(
743                 ast_sip_get_sorcery(),
744                 "endpoint",
745                 endpoint_name);
746         if (!endpoint) {
747                 astman_send_error(s, m, "Unable to retrieve endpoint\n");
748                 return 0;
749         }
750
751         /* send a qualify for all contacts registered with the endpoint */
752         if (ast_strlen_zero(endpoint->aors)) {
753                 astman_send_error(s, m, "No AoRs configured for endpoint\n");
754                 return 0;
755         }
756
757         aors = ast_strdupa(endpoint->aors);
758
759         while ((aor_name = strsep(&aors, ","))) {
760                 RAII_VAR(struct ast_sip_aor *, aor,
761                          ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
762                 RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
763
764                 if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
765                         continue;
766                 }
767
768                 ao2_callback(contacts, OBJ_NODATA, ami_contact_cb, NULL);
769         }
770
771         astman_send_ack(s, m, "Endpoint found, will qualify");
772         return 0;
773 }
774
775 static struct ast_cli_entry cli_options[] = {
776         AST_CLI_DEFINE(cli_qualify, "Send an OPTIONS request to a PJSIP endpoint")
777 };
778
779 static int sched_qualifies_hash_fn(const void *obj, int flags)
780 {
781         const struct sched_data *data = obj;
782
783         return ast_str_hash(ast_sorcery_object_get_id(data->contact));
784 }
785
786 static int sched_qualifies_cmp_fn(void *obj, void *arg, int flags)
787 {
788         struct sched_data *data = obj;
789
790         return !strcmp(ast_sorcery_object_get_id(data->contact),
791                        ast_sorcery_object_get_id(arg));
792 }
793
794 int ast_sip_initialize_sorcery_qualify(void)
795 {
796         struct ast_sorcery *sorcery = ast_sip_get_sorcery();
797
798         /* initialize sorcery ast_sip_contact_status resource */
799         ast_sorcery_apply_default(sorcery, CONTACT_STATUS, "memory", NULL);
800
801         if (ast_sorcery_internal_object_register(sorcery, CONTACT_STATUS,
802                                         contact_status_alloc, NULL, NULL)) {
803                 ast_log(LOG_ERROR, "Unable to register ast_sip_contact_status in sorcery\n");
804                 return -1;
805         }
806
807         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "rtt", "0", OPT_UINT_T,
808                                           1, FLDSET(struct ast_sip_contact_status, status));
809         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "rtt", "0", OPT_UINT_T,
810                                           1, FLDSET(struct ast_sip_contact_status, rtt));
811
812         return 0;
813 }
814
815 static int qualify_and_schedule_cb(void *obj, void *arg, int flags)
816 {
817         struct ast_sip_contact *contact = obj;
818         struct ast_sip_aor *aor = arg;
819
820         contact->qualify_frequency = aor->qualify_frequency;
821         contact->authenticate_qualify = aor->authenticate_qualify;
822
823         qualify_and_schedule(contact);
824
825         return 0;
826 }
827
828 /*!
829  * \internal
830  * \brief Qualify and schedule an endpoint's contacts
831  *
832  * \details For the given endpoint retrieve its list of aors, qualify all
833  *         contacts, and schedule for checks if configured.
834  */
835 static int qualify_and_schedule_all_cb(void *obj, void *arg, int flags)
836 {
837         struct ast_sip_endpoint *endpoint = obj;
838         char *aor_name, *aors;
839
840         if (ast_strlen_zero(endpoint->aors)) {
841                 return 0;
842         }
843
844         aors = ast_strdupa(endpoint->aors);
845
846         while ((aor_name = strsep(&aors, ","))) {
847                 RAII_VAR(struct ast_sip_aor *, aor,
848                          ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
849                 struct ao2_container *contacts;
850
851                 if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
852                         continue;
853                 }
854
855                 ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb, aor);
856                 ao2_ref(contacts, -1);
857         }
858
859         return 0;
860 }
861
862 static void qualify_and_schedule_all(void)
863 {
864         struct ao2_container *endpoints = ast_sip_get_endpoints();
865
866         if (!endpoints) {
867                 return;
868         }
869
870         ao2_callback(endpoints, OBJ_NODATA,
871                      qualify_and_schedule_all_cb, NULL);
872         ao2_ref(endpoints, -1);
873 }
874
875 int ast_res_pjsip_init_options_handling(int reload)
876 {
877         const pj_str_t STR_OPTIONS = { "OPTIONS", 7 };
878
879         if (reload) {
880                 qualify_and_schedule_all();
881                 return 0;
882         }
883
884         if (!(sched_qualifies = ao2_t_container_alloc(
885                 QUALIFIED_BUCKETS, sched_qualifies_hash_fn, sched_qualifies_cmp_fn,
886                 "Create container for scheduled qualifies"))) {
887
888                 return -1;
889         }
890
891         if (pjsip_endpt_register_module(ast_sip_get_pjsip_endpoint(), &options_module) != PJ_SUCCESS) {
892                 options_stop();
893                 return -1;
894         }
895
896         if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW, NULL, 1, &STR_OPTIONS) != PJ_SUCCESS) {
897                 pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
898                 return -1;
899         }
900
901         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "contact", &contact_observer)) {
902                 ast_log(LOG_WARNING, "Unable to add contact observer\n");
903                 return -1;
904         }
905
906         qualify_and_schedule_all();
907         ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
908         ast_manager_register2("PJSIPQualify", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_sip_qualify, NULL, NULL, NULL);
909
910         return 0;
911 }
912
913 void ast_res_pjsip_cleanup_options_handling(void)
914 {
915         ast_cli_unregister_multiple(cli_options, ARRAY_LEN(cli_options));
916         ast_manager_unregister("PJSIPQualify");
917 }