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