sorcery/res_pjsip: Refactor for realtime performance
[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 "asterisk/test.h"
32 #include "asterisk/statsd.h"
33 #include "include/res_pjsip_private.h"
34
35 #define DEFAULT_LANGUAGE "en"
36 #define DEFAULT_ENCODING "text/plain"
37 #define QUALIFIED_BUCKETS 211
38
39 static const char *status_map [] = {
40         [UNAVAILABLE] = "Unreachable",
41         [AVAILABLE] = "Reachable",
42         [UNKNOWN] = "Unknown",
43         [CREATED] = "Created",
44         [REMOVED] = "Removed",
45 };
46
47 static const char *short_status_map [] = {
48         [UNAVAILABLE] = "Unavail",
49         [AVAILABLE] = "Avail",
50         [UNKNOWN] = "Unknown",
51         [CREATED] = "Created",
52         [REMOVED] = "Removed",
53 };
54
55 const char *ast_sip_get_contact_status_label(const enum ast_sip_contact_status_type status)
56 {
57         return status_map[status];
58 }
59
60 const char *ast_sip_get_contact_short_status_label(const enum ast_sip_contact_status_type status)
61 {
62         return short_status_map[status];
63 }
64
65 /*!
66  * \internal
67  * \brief Destroy a ast_sip_contact_status object.
68  */
69 static void contact_status_destroy(void * obj)
70 {
71         struct ast_sip_contact_status *status = obj;
72
73         ast_string_field_free_memory(status);
74 }
75
76 /*!
77  * \internal
78  * \brief Create a ast_sip_contact_status object.
79  */
80 static void *contact_status_alloc(const char *name)
81 {
82         struct ast_sip_contact_status *status = ast_sorcery_generic_alloc(sizeof(*status), contact_status_destroy);
83         char *id = ast_strdupa(name);
84         char *aor = id;
85         char *aor_separator = NULL;
86
87         if (!status) {
88                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status\n");
89                 return NULL;
90         }
91
92         if (ast_string_field_init(status, 256)) {
93                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status stringfields\n");
94                 ao2_cleanup(status);
95                 return NULL;
96         }
97
98         /* Dynamic contacts are delimited with ";@" and static ones with "@@" */
99         if ((aor_separator = strstr(id, ";@")) || (aor_separator = strstr(id, "@@"))) {
100                 *aor_separator = '\0';
101         }
102         ast_assert(aor_separator != NULL);
103
104         ast_string_field_set(status, aor, aor);
105         status->status = CREATED;
106
107         return status;
108 }
109
110 AST_MUTEX_DEFINE_STATIC(creation_lock);
111
112 /*!
113  * \brief Retrieve a ast_sip_contact_status object from sorcery creating
114  *        one if not found.
115  */
116 struct ast_sip_contact_status *ast_res_pjsip_find_or_create_contact_status(const struct ast_sip_contact *contact)
117 {
118         struct ast_sip_contact_status *status;
119         SCOPED_MUTEX(lock, &creation_lock);
120
121         status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
122                 ast_sorcery_object_get_id(contact));
123         if (status) {
124                 return status;
125         }
126
127         status = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
128                 ast_sorcery_object_get_id(contact));
129         if (!status) {
130                 ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s/%s\n",
131                         contact->aor, contact->uri);
132                 return NULL;
133         }
134
135         ast_string_field_set(status, uri, contact->uri);
136         status->rtt_start = ast_tv(0, 0);
137         status->rtt = 0;
138
139         if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
140                 ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
141                         contact->uri);
142                 ao2_ref(status, -1);
143                 return NULL;
144         }
145
146         ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
147                 "+1", 1.0, ast_sip_get_contact_status_label(status->status));
148
149         return status;
150 }
151
152 /*!
153  * \internal
154  * \brief Update an ast_sip_contact_status's elements.
155  */
156 static void update_contact_status(const struct ast_sip_contact *contact,
157         enum ast_sip_contact_status_type value)
158 {
159         RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
160         RAII_VAR(struct ast_sip_contact_status *, update, NULL, ao2_cleanup);
161
162         status = ast_res_pjsip_find_or_create_contact_status(contact);
163         if (!status) {
164                 ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
165                         contact->uri);
166                 return;
167         }
168
169         update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
170                 ast_sorcery_object_get_id(status));
171         if (!update) {
172                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status for contact %s\n",
173                         contact->uri);
174                 return;
175         }
176
177         ast_string_field_set(update, uri, contact->uri);
178         update->last_status = status->status;
179         update->status = value;
180
181         /* if the contact is available calculate the rtt as
182            the diff between the last start time and "now" */
183         update->rtt = update->status == AVAILABLE && status->rtt_start.tv_sec > 0 ?
184                 ast_tvdiff_us(ast_tvnow(), status->rtt_start) : 0;
185         update->rtt_start = ast_tv(0, 0);
186
187         ast_test_suite_event_notify("AOR_CONTACT_QUALIFY_RESULT",
188                 "Contact: %s\r\n"
189                 "Status: %s\r\n"
190                 "RTT: %" PRId64,
191                 ast_sorcery_object_get_id(update),
192                 ast_sip_get_contact_status_label(update->status),
193                 update->rtt);
194
195         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
196                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
197                         contact->uri);
198         }
199 }
200
201 /*!
202  * \internal
203  * \brief Initialize the start time on a contact status so the round
204  *        trip time can be calculated upon a valid response.
205  */
206 static void init_start_time(const struct ast_sip_contact *contact)
207 {
208         RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
209         RAII_VAR(struct ast_sip_contact_status *, update, NULL, ao2_cleanup);
210
211         status = ast_res_pjsip_find_or_create_contact_status(contact);
212         if (!status) {
213                 ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
214                         contact->uri);
215                 return;
216         }
217
218         update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
219                 ast_sorcery_object_get_id(status));
220         if (!update) {
221                 ast_log(LOG_ERROR, "Unable to copy ast_sip_contact_status for contact %s\n",
222                         contact->uri);
223                 return;
224         }
225
226         ast_string_field_set(status, uri, contact->uri);
227         update->status = status->status;
228         update->last_status = status->last_status;
229         update->rtt = status->rtt;
230         update->rtt_start = ast_tvnow();
231
232         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
233                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
234                         contact->uri);
235         }
236 }
237
238 /*!
239  * \internal
240  * \brief Match a container contact object with the contact sorcery id looking for.
241  *
242  * \param obj pointer to the (user-defined part) of an object.
243  * \param arg callback argument from ao2_callback()
244  * \param flags flags from ao2_callback()
245  *
246  * \return Values are a combination of enum _cb_results.
247  */
248 static int match_contact_id(void *obj, void *arg, int flags)
249 {
250         struct ast_sip_contact *contact = obj;
251         const char *looking_for = arg;
252
253         return strcmp(ast_sorcery_object_get_id(contact), looking_for) ? 0 : CMP_MATCH;
254 }
255
256 /*!
257  * \internal
258  * \brief For an endpoint try to match the given contact sorcery id.
259  */
260 static int on_endpoint(void *obj, void *arg, int flags)
261 {
262         struct ast_sip_endpoint *endpoint = obj;
263         struct ast_sip_contact *contact;
264         char *looking_for = arg;
265         char *aor_name;
266         char *aors;
267
268         if (!arg || ast_strlen_zero(endpoint->aors)) {
269                 return 0;
270         }
271
272         aors = ast_strdupa(endpoint->aors);
273         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
274                 struct ast_sip_aor *aor;
275                 struct ao2_container *contacts;
276
277                 aor = ast_sip_location_retrieve_aor(aor_name);
278                 if (!aor) {
279                         continue;
280                 }
281
282                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
283                 ao2_ref(aor, -1);
284                 if (!contacts) {
285                         continue;
286                 }
287
288                 contact = ao2_callback(contacts, 0, match_contact_id, looking_for);
289                 ao2_ref(contacts, -1);
290                 if (contact) {
291                         ao2_ref(contact, -1);
292                         return CMP_MATCH;
293                 }
294         }
295
296         return 0;
297 }
298
299 /*!
300  * \internal
301  * \brief Find an endpoint associated with the given contact.
302  */
303 static struct ast_sip_endpoint *find_an_endpoint(struct ast_sip_contact *contact)
304 {
305         char *looking_for = (char *) ast_sorcery_object_get_id(contact);
306         struct ao2_container *endpoints = ast_sip_get_endpoints();
307         struct ast_sip_endpoint *endpoint;
308
309         endpoint = ao2_callback(endpoints, 0, on_endpoint, looking_for);
310         ao2_ref(endpoints, -1);
311         return endpoint;
312 }
313
314 /*!
315  * \internal
316  * \brief Receive a response to the qualify contact request.
317  */
318 static void qualify_contact_cb(void *token, pjsip_event *e)
319 {
320         struct ast_sip_contact *contact = token;
321
322         switch(e->body.tsx_state.type) {
323         default:
324                 ast_log(LOG_ERROR, "Unexpected PJSIP event %u\n", e->body.tsx_state.type);
325                 /* Fall through */
326         case PJSIP_EVENT_TRANSPORT_ERROR:
327         case PJSIP_EVENT_TIMER:
328                 update_contact_status(contact, UNAVAILABLE);
329                 break;
330         case PJSIP_EVENT_RX_MSG:
331                 update_contact_status(contact, AVAILABLE);
332                 break;
333         }
334         ao2_cleanup(contact);
335 }
336
337 /*!
338  * \internal
339  * \brief Attempt to qualify the contact
340  *
341  * \details Sends a SIP OPTIONS request to the given contact in order to make
342  *         sure that contact is available.
343  */
344 static int qualify_contact(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact)
345 {
346         pjsip_tx_data *tdata;
347         RAII_VAR(struct ast_sip_endpoint *, endpoint_local, NULL, ao2_cleanup);
348
349         if (contact->authenticate_qualify) {
350                 endpoint_local = ao2_bump(endpoint);
351                 if (!endpoint_local) {
352                         /*
353                          * Find the "first" endpoint to completely qualify the contact - any
354                          * endpoint that is associated with the contact should do.
355                          */
356                         endpoint_local = find_an_endpoint(contact);
357                         if (!endpoint_local) {
358                                 ast_log(LOG_ERROR, "Unable to find an endpoint to qualify contact %s\n",
359                                         contact->uri);
360                                 return -1;
361                         }
362                 }
363         }
364
365         if (ast_sip_create_request("OPTIONS", NULL, NULL, NULL, contact, &tdata)) {
366                 ast_log(LOG_ERROR, "Unable to create request to qualify contact %s\n",
367                         contact->uri);
368                 return -1;
369         }
370
371         /* If an outbound proxy is specified set it on this request */
372         if (!ast_strlen_zero(contact->outbound_proxy) &&
373                 ast_sip_set_outbound_proxy(tdata, contact->outbound_proxy)) {
374                 pjsip_tx_data_dec_ref(tdata);
375                 ast_log(LOG_ERROR, "Unable to apply outbound proxy on request to qualify contact %s\n",
376                         contact->uri);
377                 return -1;
378         }
379
380         init_start_time(contact);
381
382         ao2_ref(contact, +1);
383         if (ast_sip_send_out_of_dialog_request(tdata, endpoint_local, (int)(contact->qualify_timeout * 1000), contact, qualify_contact_cb)
384                 != PJ_SUCCESS) {
385                 ast_log(LOG_ERROR, "Unable to send request to qualify contact %s\n",
386                         contact->uri);
387                 update_contact_status(contact, UNAVAILABLE);
388                 ao2_ref(contact, -1);
389                 return -1;
390         }
391
392         return 0;
393 }
394
395 /*!
396  * \internal
397  * \brief Scheduling context for sending QUALIFY request at specified intervals.
398  */
399 static struct ast_sched_context *sched;
400
401 /*!
402  * \internal
403  * \brief Container to hold all actively scheduled qualifies.
404  */
405 static struct ao2_container *sched_qualifies;
406
407 /*!
408  * \internal
409  * \brief Structure to hold qualify contact scheduling information.
410  */
411 struct sched_data {
412         /*! The scheduling id */
413         int id;
414         /*! The the contact being checked */
415         struct ast_sip_contact *contact;
416 };
417
418 /*!
419  * \internal
420  * \brief Destroy the scheduled data and remove from scheduler.
421  */
422 static void sched_data_destructor(void *obj)
423 {
424         struct sched_data *data = obj;
425
426         ao2_cleanup(data->contact);
427 }
428 /*!
429  * \internal
430  * \brief Create the scheduling data object.
431  */
432 static struct sched_data *sched_data_create(struct ast_sip_contact *contact)
433 {
434         struct sched_data *data;
435
436         data = ao2_t_alloc(sizeof(*data), sched_data_destructor, contact->uri);
437         if (!data) {
438                 ast_log(LOG_ERROR, "Unable to create schedule qualify data for contact %s\n",
439                         contact->uri);
440                 return NULL;
441         }
442
443         data->contact = contact;
444         ao2_ref(data->contact, +1);
445
446         return data;
447 }
448
449 /*!
450  * \internal
451  * \brief Send a qualify contact request within a threaded task.
452  */
453 static int qualify_contact_task(void *obj)
454 {
455         struct ast_sip_contact *contact = obj;
456         int res;
457
458         res = qualify_contact(NULL, contact);
459         ao2_ref(contact, -1);
460         return res;
461 }
462
463 /*!
464  * \internal
465  * \brief Send a scheduled qualify contact request.
466  */
467 static int qualify_contact_sched(const void *obj)
468 {
469         struct sched_data *data = (struct sched_data *) obj;
470
471         ao2_ref(data->contact, +1);
472         if (ast_sip_push_task(NULL, qualify_contact_task, data->contact)) {
473                 ao2_ref(data->contact, -1);
474         }
475
476         /*
477          * Always reschedule rather than have a potential race cleaning
478          * up the data object ref between self deletion and an external
479          * deletion.
480          */
481         return data->contact->qualify_frequency * 1000;
482 }
483
484 /*!
485  * \internal
486  * \brief Set up a scheduled qualify contact check.
487  */
488 static void schedule_qualify(struct ast_sip_contact *contact, int initial_interval)
489 {
490         struct sched_data *data;
491
492         data = sched_data_create(contact);
493         if (!data) {
494                 return;
495         }
496
497         ast_assert(contact->qualify_frequency != 0);
498
499         ao2_t_ref(data, +1, "Ref for qualify_contact_sched() scheduler entry");
500         data->id = ast_sched_add_variable(sched, initial_interval,
501                 qualify_contact_sched, data, 1);
502         if (data->id < 0) {
503                 ao2_t_ref(data, -1, "Cleanup failed scheduler add");
504                 ast_log(LOG_ERROR, "Unable to schedule qualify for contact %s\n",
505                         contact->uri);
506         } else if (!ao2_link(sched_qualifies, data)) {
507                 AST_SCHED_DEL_UNREF(sched, data->id,
508                         ao2_t_ref(data, -1, "Cleanup scheduler for failed ao2_link"));
509         }
510         ao2_t_ref(data, -1, "Done setting up scheduler entry");
511 }
512
513 /*!
514  * \internal
515  * \brief Remove the contact from the scheduler.
516  */
517 static void unschedule_qualify(struct ast_sip_contact *contact)
518 {
519         struct sched_data *data;
520
521         data = ao2_find(sched_qualifies, contact, OBJ_UNLINK | OBJ_SEARCH_KEY);
522         if (!data) {
523                 return;
524         }
525
526         AST_SCHED_DEL_UNREF(sched, data->id,
527                 ao2_t_ref(data, -1, "Delete scheduler entry ref"));
528         ao2_t_ref(data, -1, "Done with ao2_find ref");
529 }
530
531 /*!
532  * \internal
533  * \brief Qualify the given contact and set up scheduling if configured.
534  */
535 static void qualify_and_schedule(struct ast_sip_contact *contact)
536 {
537         unschedule_qualify(contact);
538
539         if (contact->qualify_frequency) {
540                 ao2_ref(contact, +1);
541                 if (ast_sip_push_task(NULL, qualify_contact_task, contact)) {
542                         ao2_ref(contact, -1);
543                 }
544
545                 schedule_qualify(contact, contact->qualify_frequency * 1000);
546         } else {
547                 update_contact_status(contact, UNKNOWN);
548         }
549 }
550
551 /*!
552  * \internal
553  * \brief A new contact has been created make sure it is available.
554  */
555 static void contact_created(const void *obj)
556 {
557         qualify_and_schedule((struct ast_sip_contact *) obj);
558 }
559
560 /*!
561  * \internal
562  * \brief A contact has been deleted remove status tracking.
563  */
564 static void contact_deleted(const void *obj)
565 {
566         struct ast_sip_contact *contact = (struct ast_sip_contact *) obj;
567         struct ast_sip_contact_status *status;
568
569         unschedule_qualify(contact);
570
571         status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
572                 ast_sorcery_object_get_id(contact));
573         if (!status) {
574                 return;
575         }
576
577         if (ast_sorcery_delete(ast_sip_get_sorcery(), status)) {
578                 ast_log(LOG_ERROR, "Unable to delete ast_sip_contact_status for contact %s\n",
579                         contact->uri);
580         }
581         ao2_ref(status, -1);
582 }
583
584 static const struct ast_sorcery_observer contact_observer = {
585         .created = contact_created,
586         .deleted = contact_deleted
587 };
588
589 static pj_bool_t options_start(void)
590 {
591         sched = ast_sched_context_create();
592         if (!sched) {
593                 return -1;
594         }
595         if (ast_sched_start_thread(sched)) {
596                 ast_sched_context_destroy(sched);
597                 sched = NULL;
598                 return -1;
599         }
600
601         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "contact", &contact_observer)) {
602                 ast_log(LOG_WARNING, "Unable to add contact observer\n");
603                 ast_sched_context_destroy(sched);
604                 sched = NULL;
605                 return -1;
606         }
607
608         return PJ_SUCCESS;
609 }
610
611 static int sched_qualifies_empty(void *obj, void *arg, int flags)
612 {
613         ao2_t_ref(obj, -1, "Release ref held by destroyed scheduler context.");
614         return CMP_MATCH;
615 }
616
617 static pj_bool_t options_stop(void)
618 {
619         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "contact", &contact_observer);
620
621         if (sched) {
622                 ast_sched_context_destroy(sched);
623                 sched = NULL;
624         }
625
626         /* Empty the container of scheduling data refs. */
627         ao2_callback(sched_qualifies, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
628                 sched_qualifies_empty, NULL);
629
630         return PJ_SUCCESS;
631 }
632
633 static pj_status_t send_options_response(pjsip_rx_data *rdata, int code)
634 {
635         pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
636         pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
637         pjsip_transaction *trans = pjsip_rdata_get_tsx(rdata);
638         pjsip_tx_data *tdata;
639         const pjsip_hdr *hdr;
640         pj_status_t status;
641
642         /* Make the response object */
643         if ((status = ast_sip_create_response(rdata, code, NULL, &tdata) != PJ_SUCCESS)) {
644                 ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
645                 return status;
646         }
647
648         /* Add appropriate headers */
649         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ACCEPT, NULL))) {
650                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
651         }
652         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ALLOW, NULL))) {
653                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
654         }
655         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_SUPPORTED, NULL))) {
656                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
657         }
658
659         /*
660          * XXX TODO: pjsip doesn't care a lot about either of these headers -
661          * while it provides specific methods to create them, they are defined
662          * to be the standard string header creation. We never did add them
663          * in chan_sip, although RFC 3261 says they SHOULD. Hard coded here.
664          */
665         ast_sip_add_header(tdata, "Accept-Encoding", DEFAULT_ENCODING);
666         ast_sip_add_header(tdata, "Accept-Language", DEFAULT_LANGUAGE);
667
668         if (dlg && trans) {
669                 status = pjsip_dlg_send_response(dlg, trans, tdata);
670         } else {
671                 struct ast_sip_endpoint *endpoint;
672
673                 endpoint = ast_pjsip_rdata_get_endpoint(rdata);
674                 status = ast_sip_send_stateful_response(rdata, tdata, endpoint);
675                 ao2_cleanup(endpoint);
676         }
677
678         if (status != PJ_SUCCESS) {
679                 ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
680         }
681
682         return status;
683 }
684
685 static pj_bool_t options_on_rx_request(pjsip_rx_data *rdata)
686 {
687         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
688         pjsip_uri *ruri;
689         pjsip_sip_uri *sip_ruri;
690         char exten[AST_MAX_EXTENSION];
691
692         if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method,
693                              &pjsip_options_method)) {
694                 return PJ_FALSE;
695         }
696
697         if (!(endpoint = ast_pjsip_rdata_get_endpoint(rdata))) {
698                 return PJ_FALSE;
699         }
700
701         ruri = rdata->msg_info.msg->line.req.uri;
702         if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
703                 send_options_response(rdata, 416);
704                 return PJ_TRUE;
705         }
706
707         sip_ruri = pjsip_uri_get_uri(ruri);
708         ast_copy_pj_str(exten, &sip_ruri->user, sizeof(exten));
709
710         if (ast_shutting_down()) {
711                 /*
712                  * Not taking any new calls at this time.
713                  * Likely a server availability OPTIONS poll.
714                  */
715                 send_options_response(rdata, 503);
716         } else if (!ast_strlen_zero(exten) && !ast_exists_extension(NULL, endpoint->context, exten, 1, NULL)) {
717                 send_options_response(rdata, 404);
718         } else {
719                 send_options_response(rdata, 200);
720         }
721         return PJ_TRUE;
722 }
723
724 static pjsip_module options_module = {
725         .name = {"Options Module", 14},
726         .id = -1,
727         .priority = PJSIP_MOD_PRIORITY_APPLICATION,
728         .start = options_start,
729         .stop = options_stop,
730         .on_rx_request = options_on_rx_request,
731 };
732
733 /*!
734  * \internal
735  * \brief Send qualify request to the given contact.
736  */
737 static int cli_on_contact(void *obj, void *arg, void *data, int flags)
738 {
739         struct ast_sip_contact *contact = obj;
740         struct ast_sip_endpoint *endpoint = data;
741         int *cli_fd = arg;
742
743         ast_cli(*cli_fd, " contact %s\n", contact->uri);
744         qualify_contact(endpoint, contact);
745         return 0;
746 }
747
748 /*!
749  * \brief Data pushed to threadpool to qualify endpoints from the CLI
750  */
751 struct qualify_data {
752         /*! Endpoint that is being qualified */
753         struct ast_sip_endpoint *endpoint;
754         /*! CLI File descriptor for printing messages */
755         int cli_fd;
756 };
757
758 static struct qualify_data *qualify_data_alloc(struct ast_sip_endpoint *endpoint, int cli_fd)
759 {
760         struct qualify_data *qual_data;
761
762         qual_data = ast_malloc(sizeof(*qual_data));
763         if (!qual_data) {
764                 return NULL;
765         }
766
767         qual_data->endpoint = ao2_bump(endpoint);
768         qual_data->cli_fd = cli_fd;
769         return qual_data;
770 }
771
772 static void qualify_data_destroy(struct qualify_data *qual_data)
773 {
774         ao2_cleanup(qual_data->endpoint);
775         ast_free(qual_data);
776 }
777
778 /*!
779  * \internal
780  * \brief For an endpoint iterate over and qualify all aors/contacts
781  */
782 static int cli_qualify_contacts(void *data)
783 {
784         char *aors;
785         char *aor_name;
786         RAII_VAR(struct qualify_data *, qual_data, data, qualify_data_destroy);
787         struct ast_sip_endpoint *endpoint = qual_data->endpoint;
788         int cli_fd = qual_data->cli_fd;
789         const char *endpoint_name = ast_sorcery_object_get_id(endpoint);
790
791         if (ast_strlen_zero(endpoint->aors)) {
792                 ast_cli(cli_fd, "Endpoint %s has no AoR's configured\n",
793                         endpoint_name);
794                 return 0;
795         }
796
797         aors = ast_strdupa(endpoint->aors);
798         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
799                 struct ast_sip_aor *aor;
800                 struct ao2_container *contacts;
801
802                 aor = ast_sip_location_retrieve_aor(aor_name);
803                 if (!aor) {
804                         continue;
805                 }
806
807                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
808                 if (contacts) {
809                         ast_cli(cli_fd, "Sending qualify to endpoint %s\n", endpoint_name);
810                         ao2_callback_data(contacts, OBJ_NODATA, cli_on_contact, &cli_fd, endpoint);
811                         ao2_ref(contacts, -1);
812                 }
813
814                 ao2_ref(aor, -1);
815         }
816         return 0;
817 }
818
819 static char *cli_qualify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
820 {
821         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
822         const char *endpoint_name;
823         struct qualify_data *qual_data;
824
825         switch (cmd) {
826         case CLI_INIT:
827                 e->command = "pjsip qualify";
828                 e->usage =
829                         "Usage: pjsip qualify <endpoint>\n"
830                         "       Send a SIP OPTIONS request to all contacts on the endpoint.\n";
831                 return NULL;
832         case CLI_GENERATE:
833                 return NULL;
834         }
835
836         if (a->argc != 3) {
837                 return CLI_SHOWUSAGE;
838         }
839
840         endpoint_name = a->argv[2];
841
842         if (!(endpoint = ast_sorcery_retrieve_by_id(
843                       ast_sip_get_sorcery(), "endpoint", endpoint_name))) {
844                 ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
845                 return CLI_FAILURE;
846         }
847
848         qual_data = qualify_data_alloc(endpoint, a->fd);
849         if (!qual_data) {
850                 return CLI_FAILURE;
851         }
852
853         if (ast_sip_push_task(NULL, cli_qualify_contacts, qual_data)) {
854                 qualify_data_destroy(qual_data);
855                 return CLI_FAILURE;
856         }
857
858         return CLI_SUCCESS;
859 }
860
861 /*!
862  * \internal
863  * \brief Send qualify request to the given contact.
864  */
865 static int ami_contact_cb(void *obj, void *arg, int flags)
866 {
867         struct ast_sip_contact *contact = obj;
868
869         ao2_ref(contact, +1);
870         if (ast_sip_push_task(NULL, qualify_contact_task, contact)) {
871                 ao2_ref(contact, -1);
872         }
873         return 0;
874 }
875
876 static int ami_sip_qualify(struct mansession *s, const struct message *m)
877 {
878         const char *endpoint_name = astman_get_header(m, "Endpoint");
879         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
880         char *aors;
881         char *aor_name;
882
883         if (ast_strlen_zero(endpoint_name)) {
884                 astman_send_error(s, m, "Endpoint parameter missing.");
885                 return 0;
886         }
887
888         endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
889                 endpoint_name);
890         if (!endpoint) {
891                 astman_send_error(s, m, "Unable to retrieve endpoint\n");
892                 return 0;
893         }
894
895         /* send a qualify for all contacts registered with the endpoint */
896         if (ast_strlen_zero(endpoint->aors)) {
897                 astman_send_error(s, m, "No AoRs configured for endpoint\n");
898                 return 0;
899         }
900
901         aors = ast_strdupa(endpoint->aors);
902         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
903                 struct ast_sip_aor *aor;
904                 struct ao2_container *contacts;
905
906                 aor = ast_sip_location_retrieve_aor(aor_name);
907                 if (!aor) {
908                         continue;
909                 }
910
911                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
912                 if (contacts) {
913                         ao2_callback(contacts, OBJ_NODATA, ami_contact_cb, NULL);
914                         ao2_ref(contacts, -1);
915                 }
916
917                 ao2_ref(aor, -1);
918         }
919
920         astman_send_ack(s, m, "Endpoint found, will qualify");
921         return 0;
922 }
923
924 static struct ast_cli_entry cli_options[] = {
925         AST_CLI_DEFINE(cli_qualify, "Send an OPTIONS request to a PJSIP endpoint")
926 };
927
928 static int sched_qualifies_hash_fn(const void *obj, int flags)
929 {
930         const struct sched_data *object;
931         const struct ast_sip_contact *key;
932
933         switch (flags & OBJ_SEARCH_MASK) {
934         case OBJ_SEARCH_KEY:
935                 key = obj;
936                 break;
937         case OBJ_SEARCH_OBJECT:
938                 object = obj;
939                 key = object->contact;
940                 break;
941         default:
942                 /* Hash can only work on something with a full key. */
943                 ast_assert(0);
944                 return 0;
945         }
946         return ast_str_hash(ast_sorcery_object_get_id(key));
947 }
948
949 static int sched_qualifies_cmp_fn(void *obj, void *arg, int flags)
950 {
951         const struct sched_data *object_left = obj;
952         const struct sched_data *object_right = arg;
953         struct ast_sip_contact *right_key = arg;
954         int cmp;
955
956         switch (flags & OBJ_SEARCH_MASK) {
957         case OBJ_SEARCH_OBJECT:
958                 right_key = object_right->contact;
959                 /* Fall through */
960         case OBJ_SEARCH_KEY:
961                 cmp = strcmp(ast_sorcery_object_get_id(object_left->contact),
962                         ast_sorcery_object_get_id(right_key));
963                 break;
964         case OBJ_SEARCH_PARTIAL_KEY:
965                 /* Not supported by container. */
966                 ast_assert(0);
967                 return 0;
968         default:
969                 /*
970                  * What arg points to is specific to this traversal callback
971                  * and has no special meaning to astobj2.
972                  */
973                 cmp = 0;
974                 break;
975         }
976         if (cmp) {
977                 return 0;
978         }
979         /*
980          * At this point the traversal callback is identical to a sorted
981          * container.
982          */
983         return CMP_MATCH;
984 }
985
986 static int rtt_start_handler(const struct aco_option *opt,
987         struct ast_variable *var, void *obj)
988 {
989         struct ast_sip_contact_status *status = obj;
990         long int sec, usec;
991
992         if (sscanf(var->value, "%ld.%06ld", &sec, &usec) != 2) {
993                 return -1;
994         }
995
996         status->rtt_start = ast_tv(sec, usec);
997
998         return 0;
999 }
1000
1001 static int rtt_start_to_str(const void *obj, const intptr_t *args, char **buf)
1002 {
1003         const struct ast_sip_contact_status *status = obj;
1004
1005         if (ast_asprintf(buf, "%ld.%06ld", (long)status->rtt_start.tv_sec, (long)status->rtt_start.tv_usec) == -1) {
1006                 return -1;
1007         }
1008
1009         return 0;
1010 }
1011
1012 static char status_value_unknown[2];
1013 static char status_value_created[2];
1014
1015 int ast_sip_initialize_sorcery_qualify(void)
1016 {
1017         struct ast_sorcery *sorcery = ast_sip_get_sorcery();
1018
1019         /* initialize sorcery ast_sip_contact_status resource */
1020         ast_sorcery_apply_default(sorcery, CONTACT_STATUS, "memory", NULL);
1021
1022         if (ast_sorcery_internal_object_register(sorcery, CONTACT_STATUS,
1023                                         contact_status_alloc, NULL, NULL)) {
1024                 ast_log(LOG_ERROR, "Unable to register ast_sip_contact_status in sorcery\n");
1025                 return -1;
1026         }
1027
1028         snprintf(status_value_unknown, sizeof(status_value_unknown), "%u", UNKNOWN);
1029         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "last_status",
1030                 status_value_unknown, OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, last_status));
1031         snprintf(status_value_created, sizeof(status_value_created), "%u", CREATED);
1032         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "status",
1033                 status_value_created, OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, status));
1034         ast_sorcery_object_field_register_custom_nodoc(sorcery, CONTACT_STATUS, "rtt_start",
1035                 "0.0", rtt_start_handler, rtt_start_to_str, NULL, 0, 0);
1036         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "rtt",
1037                 "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, rtt));
1038
1039         return 0;
1040 }
1041
1042 static int qualify_and_schedule_cb(void *obj, void *arg, int flags)
1043 {
1044         struct ast_sip_contact *contact = obj;
1045         struct ast_sip_aor *aor = arg;
1046         int initial_interval;
1047         int max_time = ast_sip_get_max_initial_qualify_time();
1048
1049         contact->qualify_frequency = aor->qualify_frequency;
1050         contact->qualify_timeout = aor->qualify_timeout;
1051         contact->authenticate_qualify = aor->authenticate_qualify;
1052
1053         /* Delay initial qualification by a random fraction of the specified interval */
1054         if (max_time && max_time < contact->qualify_frequency) {
1055                 initial_interval = max_time;
1056         } else {
1057                 initial_interval = contact->qualify_frequency;
1058         }
1059
1060         initial_interval = (int)((initial_interval * 1000) * ast_random_double());
1061
1062         unschedule_qualify(contact);
1063         if (contact->qualify_frequency) {
1064                 schedule_qualify(contact, initial_interval);
1065         } else {
1066                 update_contact_status(contact, UNKNOWN);
1067         }
1068
1069         return 0;
1070 }
1071
1072 /*!
1073  * \internal
1074  * \brief Qualify and schedule an endpoint's contacts
1075  *
1076  * \details For the given endpoint retrieve its list of aors, qualify all
1077  *         contacts, and schedule for checks if configured.
1078  */
1079 static int qualify_and_schedule_all_cb(void *obj, void *arg, int flags)
1080 {
1081         struct ast_sip_aor *aor = obj;
1082         struct ao2_container *contacts;
1083
1084         contacts = ast_sip_location_retrieve_aor_contacts(aor);
1085         if (contacts) {
1086                 ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb, aor);
1087                 ao2_ref(contacts, -1);
1088         }
1089
1090         return 0;
1091 }
1092
1093 /*!
1094  * \internal
1095  * \brief Unschedule all existing contacts
1096  */
1097 static int unschedule_all_cb(void *obj, void *arg, int flags)
1098 {
1099         struct sched_data *data = obj;
1100
1101         AST_SCHED_DEL_UNREF(sched, data->id, ao2_ref(data, -1));
1102
1103         return CMP_MATCH;
1104 }
1105
1106 static void qualify_and_schedule_all(void)
1107 {
1108         struct ast_variable *var = ast_variable_new("qualify_frequency >", "0", "");
1109         struct ao2_container *aors;
1110
1111         if (!var) {
1112                 return;
1113         }
1114         aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1115                 "aor", AST_RETRIEVE_FLAG_MULTIPLE, var);
1116
1117         ast_variables_destroy(var);
1118
1119         ao2_callback(sched_qualifies, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, unschedule_all_cb, NULL);
1120
1121         if (!aors) {
1122                 return;
1123         }
1124
1125         ao2_callback(aors, OBJ_NODATA, qualify_and_schedule_all_cb, NULL);
1126         ao2_ref(aors, -1);
1127 }
1128
1129 static int format_contact_status(void *obj, void *arg, int flags)
1130 {
1131         struct ast_sip_contact_wrapper *wrapper = obj;
1132         struct ast_sip_contact *contact = wrapper->contact;
1133         struct ast_sip_ami *ami = arg;
1134         struct ast_sip_contact_status *status;
1135         struct ast_str *buf;
1136         const struct ast_sip_endpoint *endpoint = ami->arg;
1137
1138         buf = ast_sip_create_ami_event("ContactStatusDetail", ami);
1139         if (!buf) {
1140                 return -1;
1141         }
1142
1143         status = ast_sorcery_retrieve_by_id(
1144                 ast_sip_get_sorcery(), CONTACT_STATUS,
1145                 ast_sorcery_object_get_id(contact));
1146
1147         ast_str_append(&buf, 0, "AOR: %s\r\n", wrapper->aor_id);
1148         ast_str_append(&buf, 0, "URI: %s\r\n", contact->uri);
1149         ast_str_append(&buf, 0, "Status: %s\r\n", ast_sip_get_contact_status_label(status->status));
1150         if (status->status == UNKNOWN) {
1151                 ast_str_append(&buf, 0, "RoundtripUsec: N/A\r\n");
1152         } else {
1153                 ast_str_append(&buf, 0, "RoundtripUsec: %" PRId64 "\r\n", status->rtt);
1154         }
1155         ast_str_append(&buf, 0, "EndpointName: %s\r\n",
1156                         ast_sorcery_object_get_id(endpoint));
1157         astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
1158         ami->count++;
1159         
1160         ast_free(buf);
1161         ao2_cleanup(status);
1162         return 0;
1163 }
1164
1165 static int format_contact_status_for_aor(void *obj, void *arg, int flags)
1166 {
1167         struct ast_sip_aor *aor = obj;
1168
1169         return ast_sip_for_each_contact(aor, format_contact_status, arg);
1170 }
1171
1172 static int format_ami_contact_status(const struct ast_sip_endpoint *endpoint,
1173                 struct ast_sip_ami *ami)
1174 {
1175         ami->arg = (void *)endpoint;
1176         return ast_sip_for_each_aor(endpoint->aors, format_contact_status_for_aor, ami);
1177 }
1178
1179 static struct ast_sip_endpoint_formatter contact_status_formatter = {
1180         .format_ami = format_ami_contact_status
1181 };
1182
1183 static void aor_observer_modified(const void *obj)
1184 {
1185         struct ast_sip_aor *aor = (void *)obj;
1186         struct ao2_container *contacts;
1187
1188         contacts = ast_sip_location_retrieve_aor_contacts(aor);
1189         if (contacts) {
1190                 ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb, aor);
1191                 ao2_ref(contacts, -1);
1192         }
1193 }
1194
1195 static int unschedule_contact_cb(void *obj, void *arg, int flags)
1196 {
1197         unschedule_qualify(obj);
1198
1199         return CMP_MATCH;
1200 }
1201
1202 static void aor_observer_deleted(const void *obj)
1203 {
1204         const struct ast_sip_aor *aor = obj;
1205         struct ao2_container *contacts;
1206
1207         contacts = ast_sip_location_retrieve_aor_contacts(aor);
1208         if (contacts) {
1209                 ao2_callback(contacts, OBJ_NODATA, unschedule_contact_cb, NULL);
1210                 ao2_ref(contacts, -1);
1211         }
1212 }
1213
1214 static const struct ast_sorcery_observer observer_callbacks_options = {
1215         .created = aor_observer_modified,
1216         .updated = aor_observer_modified,
1217         .deleted = aor_observer_deleted
1218 };
1219
1220 int ast_res_pjsip_init_options_handling(int reload)
1221 {
1222         static const pj_str_t STR_OPTIONS = { "OPTIONS", 7 };
1223
1224         if (reload) {
1225                 qualify_and_schedule_all();
1226                 return 0;
1227         }
1228
1229         sched_qualifies = ao2_t_container_alloc(QUALIFIED_BUCKETS,
1230                 sched_qualifies_hash_fn, sched_qualifies_cmp_fn,
1231                 "Create container for scheduled qualifies");
1232         if (!sched_qualifies) {
1233                 return -1;
1234         }
1235
1236         if (pjsip_endpt_register_module(ast_sip_get_pjsip_endpoint(), &options_module) != PJ_SUCCESS) {
1237                 ao2_cleanup(sched_qualifies);
1238                 sched_qualifies = NULL;
1239                 return -1;
1240         }
1241
1242         if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW,
1243                 NULL, 1, &STR_OPTIONS) != PJ_SUCCESS) {
1244                 pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1245                 ao2_cleanup(sched_qualifies);
1246                 sched_qualifies = NULL;
1247                 return -1;
1248         }
1249
1250         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "aor", &observer_callbacks_options)) {
1251                 pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1252                 ao2_cleanup(sched_qualifies);
1253                 sched_qualifies = NULL;
1254                 return -1;
1255         }
1256
1257         internal_sip_register_endpoint_formatter(&contact_status_formatter);
1258         ast_manager_register_xml("PJSIPQualify", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_sip_qualify);
1259         ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
1260
1261         qualify_and_schedule_all();
1262
1263         return 0;
1264 }
1265
1266 void ast_res_pjsip_cleanup_options_handling(void)
1267 {
1268         ast_cli_unregister_multiple(cli_options, ARRAY_LEN(cli_options));
1269         ast_manager_unregister("PJSIPQualify");
1270         internal_sip_unregister_endpoint_formatter(&contact_status_formatter);
1271
1272         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "aor", &observer_callbacks_options);
1273         pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1274         ao2_cleanup(sched_qualifies);
1275         sched_qualifies = NULL;
1276 }