res/res_pjsip/pjsip_options.c

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