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