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 }