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