AST-2018-005: res_pjsip_transport_management: Move to core
[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 #include "asterisk/taskprocessor.h"
35
36 #define DEFAULT_LANGUAGE "en"
37 #define DEFAULT_ENCODING "text/plain"
38 #define QUALIFIED_BUCKETS 211
39
40 static const char *status_map [] = {
41         [UNAVAILABLE] = "Unreachable",
42         [AVAILABLE] = "Reachable",
43         [UNKNOWN] = "Unknown",
44         [CREATED] = "NonQualified",
45         [REMOVED] = "Removed",
46 };
47
48 static const char *short_status_map [] = {
49         [UNAVAILABLE] = "Unavail",
50         [AVAILABLE] = "Avail",
51         [UNKNOWN] = "Unknown",
52         [CREATED] = "NonQual",
53         [REMOVED] = "Removed",
54 };
55
56 static void contact_deleted(const void *obj);
57 static void qualify_and_schedule(struct ast_sip_contact *contact);
58
59 const char *ast_sip_get_contact_status_label(const enum ast_sip_contact_status_type status)
60 {
61         return status_map[status];
62 }
63
64 const char *ast_sip_get_contact_short_status_label(const enum ast_sip_contact_status_type status)
65 {
66         return short_status_map[status];
67 }
68
69 /*!
70  * \internal
71  * \brief Destroy a ast_sip_contact_status object.
72  */
73 static void contact_status_destroy(void * obj)
74 {
75         struct ast_sip_contact_status *status = obj;
76
77         ast_string_field_free_memory(status);
78 }
79
80 /*!
81  * \internal
82  * \brief Create a ast_sip_contact_status object.
83  */
84 static void *contact_status_alloc(const char *name)
85 {
86         struct ast_sip_contact_status *status = ast_sorcery_generic_alloc(sizeof(*status), contact_status_destroy);
87         char *id = ast_strdupa(name);
88         char *aor = id;
89         char *aor_separator = NULL;
90
91         if (!status) {
92                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status\n");
93                 return NULL;
94         }
95
96         if (ast_string_field_init(status, 256)) {
97                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status stringfields\n");
98                 ao2_cleanup(status);
99                 return NULL;
100         }
101
102         /* Dynamic contacts are delimited with ";@" and static ones with "@@" */
103         if ((aor_separator = strstr(id, ";@")) || (aor_separator = strstr(id, "@@"))) {
104                 *aor_separator = '\0';
105         }
106         ast_assert(aor_separator != NULL);
107
108         ast_string_field_set(status, aor, aor);
109         status->status = CREATED;
110
111         return status;
112 }
113
114 static int qualify_and_schedule_aor_contact(void *obj)
115 {
116         struct ast_sip_contact *contact = obj;
117         struct ast_sip_aor *aor;
118
119         if (!contact || ast_strlen_zero(contact->aor) ||
120                 !(aor = ast_sip_location_retrieve_aor(contact->aor))) {
121                 ao2_ref(contact, -1);
122                 return -1;
123         }
124
125         contact->qualify_frequency = aor->qualify_frequency;
126         contact->qualify_timeout = aor->qualify_timeout;
127         contact->authenticate_qualify = aor->authenticate_qualify;
128
129         ao2_ref(aor, -1);
130
131         qualify_and_schedule(contact);
132         ao2_ref(contact, -1);
133
134         return 0;
135 }
136
137 AST_MUTEX_DEFINE_STATIC(creation_lock);
138
139 /*!
140  * \brief Retrieve a ast_sip_contact_status object from sorcery creating
141  *        one if not found.
142  */
143 struct ast_sip_contact_status *ast_res_pjsip_find_or_create_contact_status(const struct ast_sip_contact *contact)
144 {
145         struct ast_sip_contact_status *status;
146         SCOPED_MUTEX(lock, &creation_lock);
147
148         status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
149                 ast_sorcery_object_get_id(contact));
150         if (status) {
151                 return status;
152         }
153
154         status = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
155                 ast_sorcery_object_get_id(contact));
156         if (!status) {
157                 ast_log(LOG_ERROR, "Unable to create ast_sip_contact_status for contact %s/%s\n",
158                         contact->aor, contact->uri);
159                 return NULL;
160         }
161
162         ast_string_field_set(status, uri, contact->uri);
163         status->rtt_start = ast_tv(0, 0);
164         status->rtt = 0;
165
166         if (ast_sorcery_create(ast_sip_get_sorcery(), status)) {
167                 ast_log(LOG_ERROR, "Unable to persist ast_sip_contact_status for contact %s\n",
168                         contact->uri);
169                 ao2_ref(status, -1);
170                 return NULL;
171         }
172
173         /* The permanent contact added after asterisk start should be qualified. */
174         if (ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED) && ast_tvzero(contact->expiration_time)) {
175                 /*
176                  * The FULLY_BOOTED to filter out contacts that already existed when asterisk started.
177                  * The zero expiration_time to select only permanent contacts.
178                  */
179                 ao2_ref((struct ast_sip_contact *) contact, +1);
180                 if (ast_sip_push_task(NULL, qualify_and_schedule_aor_contact, (struct ast_sip_contact *) contact)) {
181                         ao2_ref((struct ast_sip_contact *) contact, -1);
182                 }
183         }
184
185         ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
186                 "+1", 1.0, ast_sip_get_contact_status_label(status->status));
187
188         return status;
189 }
190
191 /*!
192  * \internal
193  * \brief Update an ast_sip_contact_status's elements.
194  */
195 static void update_contact_status(const struct ast_sip_contact *contact,
196         enum ast_sip_contact_status_type value, int is_contact_refresh)
197 {
198         RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
199         RAII_VAR(struct ast_sip_contact_status *, update, NULL, ao2_cleanup);
200
201         status = ast_res_pjsip_find_or_create_contact_status(contact);
202         if (!status) {
203                 ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
204                         contact->uri);
205                 return;
206         }
207
208         /*
209          * If the current status is CREATED, and it's a refresh or the given value is
210          * also CREATED then there is nothing to update as nothing needs to change.
211          */
212         if (status->status == CREATED && (is_contact_refresh || status->status == value)) {
213                 return;
214         }
215
216         update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
217                 ast_sorcery_object_get_id(status));
218         if (!update) {
219                 ast_log(LOG_ERROR, "Unable to allocate ast_sip_contact_status for contact %s\n",
220                         contact->uri);
221                 return;
222         }
223
224         ast_string_field_set(update, uri, contact->uri);
225
226         if (is_contact_refresh) {
227                 /* Copy everything just to set the refresh flag. */
228                 update->status = status->status;
229                 update->last_status = status->last_status;
230                 update->rtt = status->rtt;
231                 update->rtt_start = status->rtt_start;
232                 update->refresh = 1;
233         } else {
234                 update->last_status = status->status;
235                 update->status = value;
236
237                 /*
238                  * if the contact is available calculate the rtt as
239                  * the diff between the last start time and "now"
240                  */
241                 update->rtt = update->status == AVAILABLE && status->rtt_start.tv_sec > 0
242                         ? ast_tvdiff_us(ast_tvnow(), status->rtt_start)
243                         : 0;
244                 update->rtt_start = ast_tv(0, 0);
245
246                 ast_test_suite_event_notify("AOR_CONTACT_QUALIFY_RESULT",
247                         "Contact: %s\r\n"
248                         "Status: %s\r\n"
249                         "RTT: %" PRId64,
250                         ast_sorcery_object_get_id(update),
251                         ast_sip_get_contact_status_label(update->status),
252                         update->rtt);
253         }
254
255         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
256                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
257                         contact->uri);
258         }
259 }
260
261 /*!
262  * \internal
263  * \brief Initialize the start time on a contact status so the round
264  *        trip time can be calculated upon a valid response.
265  */
266 static void init_start_time(const struct ast_sip_contact *contact)
267 {
268         RAII_VAR(struct ast_sip_contact_status *, status, NULL, ao2_cleanup);
269         RAII_VAR(struct ast_sip_contact_status *, update, NULL, ao2_cleanup);
270
271         status = ast_res_pjsip_find_or_create_contact_status(contact);
272         if (!status) {
273                 ast_log(LOG_ERROR, "Unable to find ast_sip_contact_status for contact %s\n",
274                         contact->uri);
275                 return;
276         }
277
278         update = ast_sorcery_alloc(ast_sip_get_sorcery(), CONTACT_STATUS,
279                 ast_sorcery_object_get_id(status));
280         if (!update) {
281                 ast_log(LOG_ERROR, "Unable to copy ast_sip_contact_status for contact %s\n",
282                         contact->uri);
283                 return;
284         }
285
286         ast_string_field_set(status, uri, contact->uri);
287         update->status = status->status;
288         update->last_status = status->last_status;
289         update->rtt = status->rtt;
290         update->rtt_start = ast_tvnow();
291
292         if (ast_sorcery_update(ast_sip_get_sorcery(), update)) {
293                 ast_log(LOG_ERROR, "Unable to update ast_sip_contact_status for contact %s\n",
294                         contact->uri);
295         }
296 }
297
298 /*!
299  * \internal
300  * \brief For an endpoint try to match the given contact->aor.
301  */
302 static int on_endpoint(void *obj, void *arg, int flags)
303 {
304         struct ast_sip_endpoint *endpoint = obj;
305         char *contact_aor = arg;
306         char *aor_name;
307         char *aors;
308
309         if (!arg || ast_strlen_zero(endpoint->aors)) {
310                 return 0;
311         }
312
313         aors = ast_strdupa(endpoint->aors);
314         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
315                 if (!strcmp(contact_aor, aor_name)) {
316                         return CMP_MATCH;
317                 }
318         }
319
320         return 0;
321 }
322
323 /*!
324  * \internal
325  * \brief Find an endpoint associated with the given contact.
326  */
327 static struct ast_sip_endpoint *find_an_endpoint(struct ast_sip_contact *contact)
328 {
329         struct ao2_container *endpoints;
330         struct ast_sip_endpoint *endpoint;
331         struct ast_variable *var;
332         char *aor = ast_alloca(strlen(contact->aor) + 3);
333
334         sprintf(aor, "%%%s%%", contact->aor);
335         var = ast_variable_new("aors LIKE", aor, "");
336         endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
337                 "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var);
338
339         ast_variables_destroy(var);
340
341         /*
342          * Because aors are a string list, we have to use a pattern match but since a simple
343          * pattern match could return an endpoint that has an aor of "aaabccc" when searching
344          * for "abc", we still have to iterate over them to find an exact aor match.
345          */
346         endpoint = ao2_callback(endpoints, 0, on_endpoint, (char *)contact->aor);
347         ao2_ref(endpoints, -1);
348
349         return endpoint;
350 }
351
352 /*!
353  * \internal
354  * \brief Receive a response to the qualify contact request.
355  */
356 static void qualify_contact_cb(void *token, pjsip_event *e)
357 {
358         struct ast_sip_contact *contact = token;
359
360         switch(e->body.tsx_state.type) {
361         default:
362                 ast_log(LOG_ERROR, "Unexpected PJSIP event %u\n", e->body.tsx_state.type);
363                 /* Fall through */
364         case PJSIP_EVENT_TRANSPORT_ERROR:
365         case PJSIP_EVENT_TIMER:
366                 update_contact_status(contact, UNAVAILABLE, 0);
367                 break;
368         case PJSIP_EVENT_RX_MSG:
369                 update_contact_status(contact, AVAILABLE, 0);
370                 break;
371         }
372         ao2_cleanup(contact);
373 }
374
375 /*!
376  * \internal
377  * \brief Attempt to qualify the contact
378  *
379  * \details Sends a SIP OPTIONS request to the given contact in order to make
380  *         sure that contact is available.
381  */
382 static int qualify_contact(struct ast_sip_endpoint *endpoint, struct ast_sip_contact *contact)
383 {
384         pjsip_tx_data *tdata;
385         RAII_VAR(struct ast_sip_endpoint *, endpoint_local, NULL, ao2_cleanup);
386
387         if (endpoint) {
388                 endpoint_local = ao2_bump(endpoint);
389         } else {
390                 if (!ast_strlen_zero(contact->endpoint_name)) {
391                         endpoint_local = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", contact->endpoint_name);
392                 }
393                 if (!endpoint_local) {
394                         endpoint_local = find_an_endpoint(contact);
395                 }
396                 if (!endpoint_local) {
397                         ast_log(LOG_WARNING, "Unable to find an endpoint to qualify contact %s. Deleting this contact\n",
398                                 contact->uri);
399                         contact_deleted(contact);
400                         return -1;
401                 }
402         }
403
404         if (ast_sip_create_request("OPTIONS", NULL, endpoint_local, NULL, contact, &tdata)) {
405                 ast_log(LOG_ERROR, "Unable to create request to qualify contact %s\n",
406                         contact->uri);
407                 return -1;
408         }
409
410         /* If an outbound proxy is specified set it on this request */
411         if (!ast_strlen_zero(contact->outbound_proxy) &&
412                 ast_sip_set_outbound_proxy(tdata, contact->outbound_proxy)) {
413                 pjsip_tx_data_dec_ref(tdata);
414                 ast_log(LOG_ERROR, "Unable to apply outbound proxy on request to qualify contact %s\n",
415                         contact->uri);
416                 return -1;
417         }
418
419         init_start_time(contact);
420
421         ao2_ref(contact, +1);
422         if (ast_sip_send_out_of_dialog_request(tdata, endpoint_local, (int)(contact->qualify_timeout * 1000), contact, qualify_contact_cb)
423                 != PJ_SUCCESS) {
424                 ast_log(LOG_ERROR, "Unable to send request to qualify contact %s\n",
425                         contact->uri);
426                 update_contact_status(contact, UNAVAILABLE, 0);
427                 ao2_ref(contact, -1);
428                 return -1;
429         }
430
431         return 0;
432 }
433
434 /*!
435  * \internal
436  * \brief Scheduling context for sending QUALIFY request at specified intervals.
437  */
438 static struct ast_sched_context *sched;
439
440 /*!
441  * \internal
442  * \brief Container to hold all actively scheduled qualifies.
443  */
444 static struct ao2_container *sched_qualifies;
445
446 /*!
447  * \internal
448  * \brief Structure to hold qualify contact scheduling information.
449  */
450 struct sched_data {
451         /*! The scheduling id */
452         int id;
453         /*! The the contact being checked */
454         struct ast_sip_contact *contact;
455 };
456
457 /*!
458  * \internal
459  * \brief Destroy the scheduled data and remove from scheduler.
460  */
461 static void sched_data_destructor(void *obj)
462 {
463         struct sched_data *data = obj;
464
465         ao2_cleanup(data->contact);
466 }
467 /*!
468  * \internal
469  * \brief Create the scheduling data object.
470  */
471 static struct sched_data *sched_data_create(struct ast_sip_contact *contact)
472 {
473         struct sched_data *data;
474
475         data = ao2_t_alloc(sizeof(*data), sched_data_destructor, contact->uri);
476         if (!data) {
477                 ast_log(LOG_ERROR, "Unable to create schedule qualify data for contact %s\n",
478                         contact->uri);
479                 return NULL;
480         }
481
482         data->contact = contact;
483         ao2_ref(data->contact, +1);
484
485         return data;
486 }
487
488 /*!
489  * \internal
490  * \brief Send a qualify contact request within a threaded task.
491  */
492 static int qualify_contact_task(void *obj)
493 {
494         struct ast_sip_contact *contact = obj;
495         int res;
496
497         res = qualify_contact(NULL, contact);
498         ao2_ref(contact, -1);
499         return res;
500 }
501
502 /*!
503  * \internal
504  * \brief Send a scheduled qualify contact request.
505  */
506 static int qualify_contact_sched(const void *obj)
507 {
508         struct sched_data *data = (struct sched_data *) obj;
509
510         ao2_ref(data->contact, +1);
511         if (ast_sip_push_task(NULL, qualify_contact_task, data->contact)) {
512                 ao2_ref(data->contact, -1);
513         }
514
515         /*
516          * Always reschedule rather than have a potential race cleaning
517          * up the data object ref between self deletion and an external
518          * deletion.
519          */
520         return data->contact->qualify_frequency * 1000;
521 }
522
523 /*!
524  * \internal
525  * \brief Set up a scheduled qualify contact check.
526  */
527 static void schedule_qualify(struct ast_sip_contact *contact, int initial_interval)
528 {
529         struct sched_data *data;
530
531         data = sched_data_create(contact);
532         if (!data) {
533                 return;
534         }
535
536         ast_assert(contact->qualify_frequency != 0);
537
538         ao2_t_ref(data, +1, "Ref for qualify_contact_sched() scheduler entry");
539         data->id = ast_sched_add_variable(sched, initial_interval,
540                 qualify_contact_sched, data, 1);
541         if (data->id < 0) {
542                 ao2_t_ref(data, -1, "Cleanup failed scheduler add");
543                 ast_log(LOG_ERROR, "Unable to schedule qualify for contact %s\n",
544                         contact->uri);
545         } else if (!ao2_link(sched_qualifies, data)) {
546                 AST_SCHED_DEL_UNREF(sched, data->id,
547                         ao2_t_ref(data, -1, "Cleanup scheduler for failed ao2_link"));
548         }
549         ao2_t_ref(data, -1, "Done setting up scheduler entry");
550 }
551
552 /*!
553  * \internal
554  * \brief Remove the contact from the scheduler.
555  */
556 static void unschedule_qualify(struct ast_sip_contact *contact)
557 {
558         struct sched_data *data;
559
560         data = ao2_find(sched_qualifies, contact, OBJ_UNLINK | OBJ_SEARCH_KEY);
561         if (!data) {
562                 return;
563         }
564
565         AST_SCHED_DEL_UNREF(sched, data->id,
566                 ao2_t_ref(data, -1, "Delete scheduler entry ref"));
567         ao2_t_ref(data, -1, "Done with ao2_find ref");
568 }
569
570 /*!
571  * \internal
572  * \brief Qualify the given contact and set up scheduling if configured.
573  */
574 static void qualify_and_schedule(struct ast_sip_contact *contact)
575 {
576         unschedule_qualify(contact);
577
578         if (contact->qualify_frequency) {
579                 ao2_ref(contact, +1);
580                 if (ast_sip_push_task(NULL, qualify_contact_task, contact)) {
581                         ao2_ref(contact, -1);
582                 }
583
584                 schedule_qualify(contact, contact->qualify_frequency * 1000);
585         } else {
586                 update_contact_status(contact, CREATED, 0);
587         }
588 }
589
590 /*!
591  * \internal
592  * \brief A new contact has been created make sure it is available.
593  */
594 static void contact_created(const void *obj)
595 {
596         qualify_and_schedule((struct ast_sip_contact *) obj);
597 }
598
599 /*!
600  * \internal
601  * \brief A contact has been updated.
602  */
603 static void contact_updated(const void *obj)
604 {
605         update_contact_status(obj, AVAILABLE, 1);
606 }
607
608 /*!
609  * \internal
610  * \brief A contact has been deleted remove status tracking.
611  */
612 static void contact_deleted(const void *obj)
613 {
614         struct ast_sip_contact *contact = (struct ast_sip_contact *) obj;
615         struct ast_sip_contact_status *status;
616
617         unschedule_qualify(contact);
618
619         status = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), CONTACT_STATUS,
620                 ast_sorcery_object_get_id(contact));
621         if (!status) {
622                 return;
623         }
624
625         if (ast_sorcery_delete(ast_sip_get_sorcery(), status)) {
626                 ast_log(LOG_ERROR, "Unable to delete ast_sip_contact_status for contact %s\n",
627                         contact->uri);
628         }
629         ao2_ref(status, -1);
630 }
631
632 static const struct ast_sorcery_observer contact_observer = {
633         .created = contact_created,
634         .updated = contact_updated,
635         .deleted = contact_deleted,
636 };
637
638 static pj_bool_t options_start(void)
639 {
640         sched = ast_sched_context_create();
641         if (!sched) {
642                 return -1;
643         }
644         if (ast_sched_start_thread(sched)) {
645                 ast_sched_context_destroy(sched);
646                 sched = NULL;
647                 return -1;
648         }
649
650         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "contact", &contact_observer)) {
651                 ast_log(LOG_WARNING, "Unable to add contact observer\n");
652                 ast_sched_context_destroy(sched);
653                 sched = NULL;
654                 return -1;
655         }
656
657         return PJ_SUCCESS;
658 }
659
660 static int sched_qualifies_empty(void *obj, void *arg, int flags)
661 {
662         ao2_t_ref(obj, -1, "Release ref held by destroyed scheduler context.");
663         return CMP_MATCH;
664 }
665
666 static pj_bool_t options_stop(void)
667 {
668         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "contact", &contact_observer);
669
670         if (sched) {
671                 ast_sched_context_destroy(sched);
672                 sched = NULL;
673         }
674
675         /* Empty the container of scheduling data refs. */
676         ao2_callback(sched_qualifies, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
677                 sched_qualifies_empty, NULL);
678
679         return PJ_SUCCESS;
680 }
681
682 static pj_status_t send_options_response(pjsip_rx_data *rdata, int code)
683 {
684         pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
685         pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
686         pjsip_transaction *trans = pjsip_rdata_get_tsx(rdata);
687         pjsip_tx_data *tdata;
688         const pjsip_hdr *hdr;
689         pj_status_t status;
690
691         /* Make the response object */
692         status = ast_sip_create_response(rdata, code, NULL, &tdata);
693         if (status != PJ_SUCCESS) {
694                 ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
695                 return status;
696         }
697
698         /* Add appropriate headers */
699         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ACCEPT, NULL))) {
700                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
701         }
702         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ALLOW, NULL))) {
703                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
704         }
705         if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_SUPPORTED, NULL))) {
706                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
707         }
708
709         /*
710          * XXX TODO: pjsip doesn't care a lot about either of these headers -
711          * while it provides specific methods to create them, they are defined
712          * to be the standard string header creation. We never did add them
713          * in chan_sip, although RFC 3261 says they SHOULD. Hard coded here.
714          */
715         ast_sip_add_header(tdata, "Accept-Encoding", DEFAULT_ENCODING);
716         ast_sip_add_header(tdata, "Accept-Language", DEFAULT_LANGUAGE);
717
718         if (dlg && trans) {
719                 status = pjsip_dlg_send_response(dlg, trans, tdata);
720         } else {
721                 struct ast_sip_endpoint *endpoint;
722
723                 endpoint = ast_pjsip_rdata_get_endpoint(rdata);
724                 status = ast_sip_send_stateful_response(rdata, tdata, endpoint);
725                 ao2_cleanup(endpoint);
726         }
727
728         if (status != PJ_SUCCESS) {
729                 ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
730         }
731
732         return status;
733 }
734
735 static pj_bool_t options_on_rx_request(pjsip_rx_data *rdata)
736 {
737         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
738         pjsip_uri *ruri;
739         pjsip_sip_uri *sip_ruri;
740         char exten[AST_MAX_EXTENSION];
741
742         if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_options_method)) {
743                 return PJ_FALSE;
744         }
745
746         if (!(endpoint = ast_pjsip_rdata_get_endpoint(rdata))) {
747                 return PJ_FALSE;
748         }
749
750         ruri = rdata->msg_info.msg->line.req.uri;
751         if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
752                 send_options_response(rdata, 416);
753                 return PJ_TRUE;
754         }
755
756         sip_ruri = pjsip_uri_get_uri(ruri);
757         ast_copy_pj_str(exten, &sip_ruri->user, sizeof(exten));
758
759         /*
760          * We may want to match in the dialplan without any user
761          * options getting in the way.
762          */
763         AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(exten);
764
765         if (ast_shutting_down()) {
766                 /*
767                  * Not taking any new calls at this time.
768                  * Likely a server availability OPTIONS poll.
769                  */
770                 send_options_response(rdata, 503);
771         } else if (!ast_strlen_zero(exten)
772                 && !ast_exists_extension(NULL, endpoint->context, exten, 1, NULL)) {
773                 send_options_response(rdata, 404);
774         } else {
775                 send_options_response(rdata, 200);
776         }
777         return PJ_TRUE;
778 }
779
780 static pjsip_module options_module = {
781         .name = {"Options Module", 14},
782         .id = -1,
783         .priority = PJSIP_MOD_PRIORITY_APPLICATION,
784         .start = options_start,
785         .stop = options_stop,
786         .on_rx_request = options_on_rx_request,
787 };
788
789 /*!
790  * \internal
791  * \brief Send qualify request to the given contact.
792  */
793 static int cli_on_contact(void *obj, void *arg, void *data, int flags)
794 {
795         struct ast_sip_contact *contact = obj;
796         struct ast_sip_endpoint *endpoint = data;
797         int *cli_fd = arg;
798
799         ast_cli(*cli_fd, " contact %s\n", contact->uri);
800         qualify_contact(endpoint, contact);
801         return 0;
802 }
803
804 /*!
805  * \brief Data pushed to threadpool to qualify endpoints from the CLI
806  */
807 struct qualify_data {
808         /*! Endpoint that is being qualified */
809         struct ast_sip_endpoint *endpoint;
810         /*! CLI File descriptor for printing messages */
811         int cli_fd;
812 };
813
814 static struct qualify_data *qualify_data_alloc(struct ast_sip_endpoint *endpoint, int cli_fd)
815 {
816         struct qualify_data *qual_data;
817
818         qual_data = ast_malloc(sizeof(*qual_data));
819         if (!qual_data) {
820                 return NULL;
821         }
822
823         qual_data->endpoint = ao2_bump(endpoint);
824         qual_data->cli_fd = cli_fd;
825         return qual_data;
826 }
827
828 static void qualify_data_destroy(struct qualify_data *qual_data)
829 {
830         ao2_cleanup(qual_data->endpoint);
831         ast_free(qual_data);
832 }
833
834 /*!
835  * \internal
836  * \brief For an endpoint iterate over and qualify all aors/contacts
837  */
838 static int cli_qualify_contacts(void *data)
839 {
840         char *aors;
841         char *aor_name;
842         RAII_VAR(struct qualify_data *, qual_data, data, qualify_data_destroy);
843         struct ast_sip_endpoint *endpoint = qual_data->endpoint;
844         int cli_fd = qual_data->cli_fd;
845         const char *endpoint_name = ast_sorcery_object_get_id(endpoint);
846
847         if (ast_strlen_zero(endpoint->aors)) {
848                 ast_cli(cli_fd, "Endpoint %s has no AoR's configured\n",
849                         endpoint_name);
850                 return 0;
851         }
852
853         aors = ast_strdupa(endpoint->aors);
854         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
855                 struct ast_sip_aor *aor;
856                 struct ao2_container *contacts;
857
858                 aor = ast_sip_location_retrieve_aor(aor_name);
859                 if (!aor) {
860                         continue;
861                 }
862
863                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
864                 if (contacts) {
865                         ast_cli(cli_fd, "Sending qualify to endpoint %s\n", endpoint_name);
866                         ao2_callback_data(contacts, OBJ_NODATA, cli_on_contact, &cli_fd, endpoint);
867                         ao2_ref(contacts, -1);
868                 }
869
870                 ao2_ref(aor, -1);
871         }
872         return 0;
873 }
874
875 static char *cli_qualify(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
876 {
877         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
878         const char *endpoint_name;
879         struct qualify_data *qual_data;
880
881         switch (cmd) {
882         case CLI_INIT:
883                 e->command = "pjsip qualify";
884                 e->usage =
885                         "Usage: pjsip qualify <endpoint>\n"
886                         "       Send a SIP OPTIONS request to all contacts on the endpoint.\n";
887                 return NULL;
888         case CLI_GENERATE:
889                 return NULL;
890         }
891
892         if (a->argc != 3) {
893                 return CLI_SHOWUSAGE;
894         }
895
896         endpoint_name = a->argv[2];
897
898         if (!(endpoint = ast_sorcery_retrieve_by_id(
899                       ast_sip_get_sorcery(), "endpoint", endpoint_name))) {
900                 ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
901                 return CLI_FAILURE;
902         }
903
904         qual_data = qualify_data_alloc(endpoint, a->fd);
905         if (!qual_data) {
906                 return CLI_FAILURE;
907         }
908
909         if (ast_sip_push_task(NULL, cli_qualify_contacts, qual_data)) {
910                 qualify_data_destroy(qual_data);
911                 return CLI_FAILURE;
912         }
913
914         return CLI_SUCCESS;
915 }
916
917 /*!
918  * \internal
919  * \brief Send qualify request to the given contact.
920  */
921 static int ami_contact_cb(void *obj, void *arg, int flags)
922 {
923         struct ast_sip_contact *contact = obj;
924
925         ao2_ref(contact, +1);
926         if (ast_sip_push_task(NULL, qualify_contact_task, contact)) {
927                 ao2_ref(contact, -1);
928         }
929         return 0;
930 }
931
932 static struct ao2_container *get_all_contacts(void)
933 {
934         struct ao2_container *contacts;
935
936         contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact",
937                         AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
938
939         return contacts;
940 }
941
942 static int sip_contact_to_ami(const struct ast_sip_contact *contact,
943                            struct ast_str **buf)
944 {
945         return ast_sip_sorcery_object_to_ami(contact, buf);
946 }
947
948 static int format_ami_contactlist_handler(void *obj, void *arg, int flags)
949 {
950         struct ast_sip_contact *contact = obj;
951         struct ast_sip_ami *ami = arg;
952         struct ast_str *buf;
953         struct ast_sip_contact_status *status;
954
955         buf = ast_sip_create_ami_event("ContactList", ami);
956
957         if (!buf) {
958                 return CMP_STOP;
959         }
960
961         if (sip_contact_to_ami(contact, &buf)) {
962                 ast_free(buf);
963                 return CMP_STOP;
964         }
965
966         /* Add extra info */
967         status = ast_sorcery_retrieve_by_id(
968                 ast_sip_get_sorcery(), CONTACT_STATUS,
969                 ast_sorcery_object_get_id(contact));
970         ast_str_append(&buf, 0, "Status: %s\r\n",
971                         ast_sip_get_contact_status_label(status ? status->status : UNKNOWN));
972         if (!status || status->status == UNKNOWN) {
973                 ast_str_append(&buf, 0, "RoundtripUsec: N/A\r\n");
974         } else {
975                 ast_str_append(&buf, 0, "RoundtripUsec: %" PRId64 "\r\n", status->rtt);
976         }
977
978         astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
979
980         ami->count++;
981
982         ast_free(buf);
983
984         return 0;
985 }
986
987 static int ami_show_contacts(struct mansession *s, const struct message *m)
988 {
989         struct ast_sip_ami ami = { .s = s, .m = m, .action_id = astman_get_header(m, "ActionID"), };
990         struct ao2_container *contacts;
991
992         contacts = get_all_contacts();
993         if (!contacts) {
994                 astman_send_error(s, m, "Could not get Contacts\n");
995                 return 0;
996         }
997
998         if (!ao2_container_count(contacts)) {
999                 astman_send_error(s, m, "No Contacts found\n");
1000                 ao2_ref(contacts, -1);
1001                 return 0;
1002         }
1003
1004         astman_send_listack(s, m, "A listing of Contacts follows, presented as ContactList events",
1005                         "start");
1006
1007         ao2_callback(contacts, OBJ_NODATA, format_ami_contactlist_handler, &ami);
1008
1009         astman_send_list_complete_start(s, m, "ContactListComplete", ami.count);
1010         astman_send_list_complete_end(s);
1011
1012         ao2_ref(contacts, -1);
1013
1014         return 0;
1015 }
1016
1017 static int ami_sip_qualify(struct mansession *s, const struct message *m)
1018 {
1019         const char *endpoint_name = astman_get_header(m, "Endpoint");
1020         RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
1021         char *aors;
1022         char *aor_name;
1023
1024         if (ast_strlen_zero(endpoint_name)) {
1025                 astman_send_error(s, m, "Endpoint parameter missing.");
1026                 return 0;
1027         }
1028
1029         endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
1030                 endpoint_name);
1031         if (!endpoint) {
1032                 astman_send_error(s, m, "Unable to retrieve endpoint\n");
1033                 return 0;
1034         }
1035
1036         /* send a qualify for all contacts registered with the endpoint */
1037         if (ast_strlen_zero(endpoint->aors)) {
1038                 astman_send_error(s, m, "No AoRs configured for endpoint\n");
1039                 return 0;
1040         }
1041
1042         aors = ast_strdupa(endpoint->aors);
1043         while ((aor_name = ast_strip(strsep(&aors, ",")))) {
1044                 struct ast_sip_aor *aor;
1045                 struct ao2_container *contacts;
1046
1047                 aor = ast_sip_location_retrieve_aor(aor_name);
1048                 if (!aor) {
1049                         continue;
1050                 }
1051
1052                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
1053                 if (contacts) {
1054                         ao2_callback(contacts, OBJ_NODATA, ami_contact_cb, NULL);
1055                         ao2_ref(contacts, -1);
1056                 }
1057
1058                 ao2_ref(aor, -1);
1059         }
1060
1061         astman_send_ack(s, m, "Endpoint found, will qualify");
1062         return 0;
1063 }
1064
1065 static struct ast_cli_entry cli_options[] = {
1066         AST_CLI_DEFINE(cli_qualify, "Send an OPTIONS request to a PJSIP endpoint")
1067 };
1068
1069 static int sched_qualifies_hash_fn(const void *obj, int flags)
1070 {
1071         const struct sched_data *object;
1072         const struct ast_sip_contact *key;
1073
1074         switch (flags & OBJ_SEARCH_MASK) {
1075         case OBJ_SEARCH_KEY:
1076                 key = obj;
1077                 break;
1078         case OBJ_SEARCH_OBJECT:
1079                 object = obj;
1080                 key = object->contact;
1081                 break;
1082         default:
1083                 /* Hash can only work on something with a full key. */
1084                 ast_assert(0);
1085                 return 0;
1086         }
1087         return ast_str_hash(ast_sorcery_object_get_id(key));
1088 }
1089
1090 static int sched_qualifies_cmp_fn(void *obj, void *arg, int flags)
1091 {
1092         const struct sched_data *object_left = obj;
1093         const struct sched_data *object_right = arg;
1094         struct ast_sip_contact *right_key = arg;
1095         int cmp;
1096
1097         switch (flags & OBJ_SEARCH_MASK) {
1098         case OBJ_SEARCH_OBJECT:
1099                 right_key = object_right->contact;
1100                 /* Fall through */
1101         case OBJ_SEARCH_KEY:
1102                 cmp = strcmp(ast_sorcery_object_get_id(object_left->contact),
1103                         ast_sorcery_object_get_id(right_key));
1104                 break;
1105         case OBJ_SEARCH_PARTIAL_KEY:
1106                 /* Not supported by container. */
1107                 ast_assert(0);
1108                 return 0;
1109         default:
1110                 /*
1111                  * What arg points to is specific to this traversal callback
1112                  * and has no special meaning to astobj2.
1113                  */
1114                 cmp = 0;
1115                 break;
1116         }
1117         if (cmp) {
1118                 return 0;
1119         }
1120         /*
1121          * At this point the traversal callback is identical to a sorted
1122          * container.
1123          */
1124         return CMP_MATCH;
1125 }
1126
1127 static int rtt_start_handler(const struct aco_option *opt,
1128         struct ast_variable *var, void *obj)
1129 {
1130         struct ast_sip_contact_status *status = obj;
1131         long int sec, usec;
1132
1133         if (sscanf(var->value, "%ld.%06ld", &sec, &usec) != 2) {
1134                 return -1;
1135         }
1136
1137         status->rtt_start = ast_tv(sec, usec);
1138
1139         return 0;
1140 }
1141
1142 static int rtt_start_to_str(const void *obj, const intptr_t *args, char **buf)
1143 {
1144         const struct ast_sip_contact_status *status = obj;
1145
1146         if (ast_asprintf(buf, "%ld.%06ld", (long)status->rtt_start.tv_sec, (long)status->rtt_start.tv_usec) == -1) {
1147                 return -1;
1148         }
1149
1150         return 0;
1151 }
1152
1153 static char status_value_unknown[2];
1154 static char status_value_created[2];
1155
1156 int ast_sip_initialize_sorcery_qualify(void)
1157 {
1158         struct ast_sorcery *sorcery = ast_sip_get_sorcery();
1159
1160         /* initialize sorcery ast_sip_contact_status resource */
1161         ast_sorcery_apply_default(sorcery, CONTACT_STATUS, "memory", NULL);
1162         ast_sorcery_object_set_congestion_levels(sorcery, CONTACT_STATUS, -1,
1163                 3 * AST_TASKPROCESSOR_HIGH_WATER_LEVEL);
1164
1165         if (ast_sorcery_internal_object_register(sorcery, CONTACT_STATUS,
1166                                         contact_status_alloc, NULL, NULL)) {
1167                 ast_log(LOG_ERROR, "Unable to register ast_sip_contact_status in sorcery\n");
1168                 return -1;
1169         }
1170
1171         snprintf(status_value_unknown, sizeof(status_value_unknown), "%u", UNKNOWN);
1172         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "last_status",
1173                 status_value_unknown, OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, last_status));
1174         snprintf(status_value_created, sizeof(status_value_created), "%u", CREATED);
1175         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "status",
1176                 status_value_created, OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, status));
1177         ast_sorcery_object_field_register_custom_nodoc(sorcery, CONTACT_STATUS, "rtt_start",
1178                 "0.0", rtt_start_handler, rtt_start_to_str, NULL, 0, 0);
1179         ast_sorcery_object_field_register_nodoc(sorcery, CONTACT_STATUS, "rtt",
1180                 "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_contact_status, rtt));
1181
1182         return 0;
1183 }
1184
1185 static void qualify_and_schedule_contact(struct ast_sip_contact *contact)
1186 {
1187         int initial_interval;
1188         int max_time = ast_sip_get_max_initial_qualify_time();
1189
1190         /* Delay initial qualification by a random fraction of the specified interval */
1191         if (max_time && max_time < contact->qualify_frequency) {
1192                 initial_interval = max_time;
1193         } else {
1194                 initial_interval = contact->qualify_frequency;
1195         }
1196
1197         initial_interval = (int)((initial_interval * 1000) * ast_random_double());
1198
1199         unschedule_qualify(contact);
1200         if (contact->qualify_frequency) {
1201                 schedule_qualify(contact, initial_interval);
1202         } else {
1203                 update_contact_status(contact, CREATED, 0);
1204         }
1205 }
1206
1207 static int qualify_and_schedule_cb_with_aor(void *obj, void *arg, int flags)
1208 {
1209         struct ast_sip_contact *contact = obj;
1210         struct ast_sip_aor *aor = arg;
1211
1212         contact->qualify_frequency = aor->qualify_frequency;
1213         contact->qualify_timeout = aor->qualify_timeout;
1214         contact->authenticate_qualify = aor->authenticate_qualify;
1215
1216         qualify_and_schedule_contact(contact);
1217
1218         return 0;
1219 }
1220
1221 static int qualify_and_schedule_cb_without_aor(void *obj, void *arg, int flags)
1222 {
1223         /*
1224          * These are really dynamic contacts. We need to retrieve the aor associated
1225          * with the contact since it's possible some of the aor's fields were updated
1226          * since last load.
1227          */
1228         struct ast_sip_contact *contact = obj;
1229         struct ast_sip_aor *aor = ast_sip_location_retrieve_aor(contact->aor);
1230
1231         if (aor) {
1232                 qualify_and_schedule_cb_with_aor(obj, aor, flags);
1233                 ao2_ref(aor, -1);
1234         } else {
1235                 ast_log(LOG_WARNING, "Unable to locate AOR for contact '%s'. Keeping old "
1236                         "associated settings: frequency=%d, timeout=%f, authenticate=%s\n",
1237                         contact->uri, contact->qualify_frequency, contact->qualify_timeout,
1238                         contact->authenticate_qualify ? "yes" : "no");
1239                 qualify_and_schedule_contact(contact);
1240         }
1241
1242         return 0;
1243 }
1244
1245 /*!
1246  * \internal
1247  * \brief Qualify and schedule an aor's contacts
1248  *
1249  * \details For the given aor check if it has permanent contacts,
1250  *         qualify all contacts and schedule for checks if configured.
1251  */
1252 static int qualify_and_schedule_all_cb(void *obj, void *arg, int flags)
1253 {
1254         struct ast_sip_aor *aor = obj;
1255         struct ao2_container *contacts;
1256
1257         if (aor->permanent_contacts) {
1258                 contacts = ast_sip_location_retrieve_aor_contacts(aor);
1259                 if (contacts) {
1260                         ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb_with_aor, aor);
1261                         ao2_ref(contacts, -1);
1262                 }
1263         }
1264
1265         return 0;
1266 }
1267
1268 static void qualify_and_schedule_all(void)
1269 {
1270         struct ao2_container *aors;
1271         struct ao2_container *contacts;
1272
1273         /*
1274          * It's possible that the AOR had some of it's fields updated prior to a
1275          * reload. For instance qualifying could have been turned on or off by
1276          * setting the qualify_frequency. Due to this we have to iterate through
1277          * all contacts (static and dynamic), and not just ones where the frequency
1278          * is greater than zero, updating any contact fields with the AOR's values.
1279          */
1280
1281         aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1282                 "aor", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
1283
1284         if (aors) {
1285                 ao2_callback(aors, OBJ_NODATA, qualify_and_schedule_all_cb, NULL);
1286                 ao2_ref(aors, -1);
1287         }
1288
1289         contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1290                 "contact", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
1291         if (contacts) {
1292                 ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb_without_aor, NULL);
1293                 ao2_ref(contacts, -1);
1294         }
1295 }
1296
1297 int ast_sip_format_contact_ami(void *obj, void *arg, int flags)
1298 {
1299         struct ast_sip_contact_wrapper *wrapper = obj;
1300         struct ast_sip_contact *contact = wrapper->contact;
1301         struct ast_sip_ami *ami = arg;
1302         struct ast_sip_contact_status *status;
1303         struct ast_str *buf;
1304         const struct ast_sip_endpoint *endpoint = ami->arg;
1305
1306         buf = ast_sip_create_ami_event("ContactStatusDetail", ami);
1307         if (!buf) {
1308                 return -1;
1309         }
1310
1311         status = ast_sorcery_retrieve_by_id(
1312                 ast_sip_get_sorcery(), CONTACT_STATUS,
1313                 ast_sorcery_object_get_id(contact));
1314
1315         ast_str_append(&buf, 0, "AOR: %s\r\n", wrapper->aor_id);
1316         ast_str_append(&buf, 0, "URI: %s\r\n", contact->uri);
1317         ast_str_append(&buf, 0, "UserAgent: %s\r\n", contact->user_agent);
1318         ast_str_append(&buf, 0, "RegExpire: %ld\r\n", contact->expiration_time.tv_sec);
1319         if (!ast_strlen_zero(contact->via_addr)) {
1320                 ast_str_append(&buf, 0, "ViaAddress: %s", contact->via_addr);
1321                 if (contact->via_port) {
1322                         ast_str_append(&buf, 0, ":%d", contact->via_port);
1323                 }
1324                 ast_str_append(&buf, 0, "\r\n");
1325         }
1326         if (!ast_strlen_zero(contact->call_id)) {
1327                 ast_str_append(&buf, 0, "CallID: %s\r\n", contact->call_id);
1328         }
1329         ast_str_append(&buf, 0, "Status: %s\r\n", ast_sip_get_contact_status_label(status ? status->status : UNKNOWN));
1330         if (!status || status->status == UNKNOWN) {
1331                 ast_str_append(&buf, 0, "RoundtripUsec: N/A\r\n");
1332         } else {
1333                 ast_str_append(&buf, 0, "RoundtripUsec: %" PRId64 "\r\n", status->rtt);
1334         }
1335         ast_str_append(&buf, 0, "EndpointName: %s\r\n",
1336                         endpoint ? ast_sorcery_object_get_id(endpoint) : S_OR(contact->endpoint_name, ""));
1337
1338         ast_str_append(&buf, 0, "ID: %s\r\n", ast_sorcery_object_get_id(contact));
1339         ast_str_append(&buf, 0, "AuthenticateQualify: %d\r\n", contact->authenticate_qualify);
1340         ast_str_append(&buf, 0, "OutboundProxy: %s\r\n", contact->outbound_proxy);
1341         ast_str_append(&buf, 0, "Path: %s\r\n", contact->path);
1342         ast_str_append(&buf, 0, "QualifyFrequency: %u\r\n", contact->qualify_frequency);
1343         ast_str_append(&buf, 0, "QualifyTimeout: %.3f\r\n", contact->qualify_timeout);
1344
1345         astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
1346         ami->count++;
1347
1348         ast_free(buf);
1349         ao2_cleanup(status);
1350         return 0;
1351 }
1352
1353 static int format_contact_status_for_aor(void *obj, void *arg, int flags)
1354 {
1355         struct ast_sip_aor *aor = obj;
1356
1357         return ast_sip_for_each_contact(aor, ast_sip_format_contact_ami, arg);
1358 }
1359
1360 static int format_ami_contact_status(const struct ast_sip_endpoint *endpoint,
1361                 struct ast_sip_ami *ami)
1362 {
1363         ami->arg = (void *)endpoint;
1364         return ast_sip_for_each_aor(endpoint->aors, format_contact_status_for_aor, ami);
1365 }
1366
1367 static struct ast_sip_endpoint_formatter contact_status_formatter = {
1368         .format_ami = format_ami_contact_status
1369 };
1370
1371 static void aor_observer_modified(const void *obj)
1372 {
1373         struct ast_sip_aor *aor = (void *)obj;
1374         struct ao2_container *contacts;
1375
1376         contacts = ast_sip_location_retrieve_aor_contacts(aor);
1377         if (contacts) {
1378                 ao2_callback(contacts, OBJ_NODATA, qualify_and_schedule_cb_with_aor, aor);
1379                 ao2_ref(contacts, -1);
1380         }
1381 }
1382
1383 static int unschedule_contact_cb(void *obj, void *arg, int flags)
1384 {
1385         unschedule_qualify(obj);
1386
1387         return CMP_MATCH;
1388 }
1389
1390 static void aor_observer_deleted(const void *obj)
1391 {
1392         const struct ast_sip_aor *aor = obj;
1393         struct ao2_container *contacts;
1394
1395         contacts = ast_sip_location_retrieve_aor_contacts(aor);
1396         if (contacts) {
1397                 ao2_callback(contacts, OBJ_NODATA | OBJ_MULTIPLE, unschedule_contact_cb, NULL);
1398                 ao2_ref(contacts, -1);
1399         }
1400 }
1401
1402 static const struct ast_sorcery_observer observer_callbacks_options = {
1403         .created = aor_observer_modified,
1404         .updated = aor_observer_modified,
1405         .deleted = aor_observer_deleted
1406 };
1407
1408 static int aor_update_endpoint_state(void *obj, void *arg, int flags)
1409 {
1410         struct ast_sip_endpoint *endpoint = obj;
1411         const char *endpoint_name = ast_sorcery_object_get_id(endpoint);
1412         char *aor = arg;
1413         char *endpoint_aor;
1414         char *endpoint_aors;
1415
1416         if (ast_strlen_zero(aor) || ast_strlen_zero(endpoint->aors)) {
1417                 return 0;
1418         }
1419
1420         endpoint_aors = ast_strdupa(endpoint->aors);
1421         while ((endpoint_aor = ast_strip(strsep(&endpoint_aors, ",")))) {
1422                 if (!strcmp(aor, endpoint_aor)) {
1423                         if (ast_sip_persistent_endpoint_update_state(endpoint_name, AST_ENDPOINT_ONLINE) == -1) {
1424                                 ast_log(LOG_WARNING, "Unable to find persistent endpoint '%s' for aor '%s'\n",
1425                                         endpoint_name, aor);
1426                         }
1427                 }
1428         }
1429
1430         return 0;
1431 }
1432
1433 static int on_aor_update_endpoint_state(void *obj, void *arg, int flags)
1434 {
1435         struct ast_sip_aor *aor = obj;
1436         struct ao2_container *endpoints;
1437         RAII_VAR(struct ast_variable *, var, NULL, ast_variables_destroy);
1438         const char *aor_name = ast_sorcery_object_get_id(aor);
1439         char *aor_like;
1440
1441         if (ast_strlen_zero(aor_name)) {
1442                 return -1;
1443         }
1444
1445         if (aor->permanent_contacts && ((int)(aor->qualify_frequency * 1000)) <= 0) {
1446                 aor_like = ast_alloca(strlen(aor_name) + 3);
1447                 sprintf(aor_like, "%%%s%%", aor_name);
1448                 var = ast_variable_new("aors LIKE", aor_like, "");
1449                 if (!var) {
1450                         return -1;
1451                 }
1452                 endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1453                         "endpoint", AST_RETRIEVE_FLAG_MULTIPLE, var);
1454
1455                 if (endpoints) {
1456                     /*
1457                      * Because aors are a string list, we have to use a pattern match but since a simple
1458                      * pattern match could return an endpoint that has an aor of "aaabccc" when searching
1459                      * for "abc", we still have to iterate over them to find an exact aor match.
1460                      */
1461                     ao2_callback(endpoints, 0, aor_update_endpoint_state, (char *)aor_name);
1462                     ao2_ref(endpoints, -1);
1463                 }
1464         }
1465
1466         return 0;
1467 }
1468
1469 static int contact_update_endpoint_state(void *obj, void *arg, int flags)
1470 {
1471         const struct ast_sip_contact *contact = obj;
1472         struct timeval tv = ast_tvnow();
1473
1474         if (!ast_strlen_zero(contact->endpoint_name) && ((int)(contact->qualify_frequency * 1000)) <= 0 &&
1475                 contact->expiration_time.tv_sec > tv.tv_sec) {
1476
1477                 if (ast_sip_persistent_endpoint_update_state(contact->endpoint_name, AST_ENDPOINT_ONLINE) == -1) {
1478                         ast_log(LOG_WARNING, "Unable to find persistent endpoint '%s' for contact '%s/%s'\n",
1479                                 contact->endpoint_name, contact->aor, contact->uri);
1480                         return -1;
1481                 }
1482         }
1483
1484         return 0;
1485 }
1486
1487 static void update_all_unqualified_endpoints(void)
1488 {
1489         struct ao2_container *aors;
1490         struct ao2_container *contacts;
1491         RAII_VAR(struct ast_variable *, var_aor, NULL, ast_variables_destroy);
1492         RAII_VAR(struct ast_variable *, var_contact, NULL, ast_variables_destroy);
1493         RAII_VAR(char *, time_now, NULL, ast_free);
1494         struct timeval tv = ast_tvnow();
1495
1496         if (!(var_aor = ast_variable_new("contact !=", "", ""))) {
1497                 return;
1498         }
1499         if (!(var_aor->next = ast_variable_new("qualify_frequency <=", "0", ""))) {
1500                 return;
1501         }
1502
1503         if (ast_asprintf(&time_now, "%ld", tv.tv_sec) == -1) {
1504                 return;
1505         }
1506         if (!(var_contact = ast_variable_new("expiration_time >", time_now, ""))) {
1507                 return;
1508         }
1509         if (!(var_contact->next = ast_variable_new("qualify_frequency <=", "0", ""))) {
1510                 return;
1511         }
1512
1513         aors = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1514                 "aor", AST_RETRIEVE_FLAG_MULTIPLE, var_aor);
1515         if (aors) {
1516                 ao2_callback(aors, OBJ_NODATA, on_aor_update_endpoint_state, NULL);
1517                 ao2_ref(aors, -1);
1518         }
1519
1520         contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
1521                 "contact", AST_RETRIEVE_FLAG_MULTIPLE, var_contact);
1522         if (contacts) {
1523                 ao2_callback(contacts, OBJ_NODATA, contact_update_endpoint_state, NULL);
1524                 ao2_ref(contacts, -1);
1525         }
1526 }
1527
1528 int ast_res_pjsip_init_options_handling(int reload)
1529 {
1530         static const pj_str_t STR_OPTIONS = { "OPTIONS", 7 };
1531
1532         if (reload) {
1533                 qualify_and_schedule_all();
1534                 return 0;
1535         }
1536
1537         sched_qualifies = ao2_t_container_alloc(QUALIFIED_BUCKETS,
1538                 sched_qualifies_hash_fn, sched_qualifies_cmp_fn,
1539                 "Create container for scheduled qualifies");
1540         if (!sched_qualifies) {
1541                 return -1;
1542         }
1543
1544         if (pjsip_endpt_register_module(ast_sip_get_pjsip_endpoint(), &options_module) != PJ_SUCCESS) {
1545                 ao2_cleanup(sched_qualifies);
1546                 sched_qualifies = NULL;
1547                 return -1;
1548         }
1549
1550         if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW,
1551                 NULL, 1, &STR_OPTIONS) != PJ_SUCCESS) {
1552                 pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1553                 ao2_cleanup(sched_qualifies);
1554                 sched_qualifies = NULL;
1555                 return -1;
1556         }
1557
1558         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "aor", &observer_callbacks_options)) {
1559                 pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1560                 ao2_cleanup(sched_qualifies);
1561                 sched_qualifies = NULL;
1562                 return -1;
1563         }
1564
1565         ast_sip_register_endpoint_formatter(&contact_status_formatter);
1566         ast_manager_register_xml("PJSIPQualify", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_sip_qualify);
1567         ast_manager_register_xml("PJSIPShowContacts", EVENT_FLAG_SYSTEM, ami_show_contacts);
1568         ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
1569
1570         update_all_unqualified_endpoints();
1571         qualify_and_schedule_all();
1572
1573         return 0;
1574 }
1575
1576 void ast_res_pjsip_cleanup_options_handling(void)
1577 {
1578         ast_cli_unregister_multiple(cli_options, ARRAY_LEN(cli_options));
1579         ast_manager_unregister("PJSIPQualify");
1580         ast_manager_unregister("PJSIPShowContacts");
1581         ast_sip_unregister_endpoint_formatter(&contact_status_formatter);
1582
1583         ast_sorcery_observer_remove(ast_sip_get_sorcery(), "aor", &observer_callbacks_options);
1584         pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
1585         ao2_cleanup(sched_qualifies);
1586         sched_qualifies = NULL;
1587 }