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