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