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