res/res_pjsip_caller_id.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2013, Digium, Inc.
   5  *
   6  * Mark Michelson <mmichelson@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 /*** MODULEINFO
  20         <depend>pjproject</depend>
  21         <depend>res_pjsip</depend>
  22         <depend>res_pjsip_session</depend>
  23         <support_level>core</support_level>
  24  ***/
  25
  26 #include "asterisk.h"
  27
  28 #include <pjsip.h>
  29 #include <pjsip_ua.h>
  30
  31 #include "asterisk/res_pjsip.h"
  32 #include "asterisk/res_pjsip_session.h"
  33 #include "asterisk/channel.h"
  34 #include "asterisk/module.h"
  35 #include "asterisk/callerid.h"
  36
  37 /*!
  38  * \internal
  39  * \brief Set an ast_party_id name and number based on an identity header.
  40  * \param hdr From, P-Asserted-Identity, or Remote-Party-ID header on incoming message
  41  * \param[out] id The ID to set data on
  42  */
  43 static void set_id_from_hdr(pjsip_fromto_hdr *hdr, struct ast_party_id *id)
  44 {
  45         char cid_name[AST_CHANNEL_NAME];
  46         char cid_num[AST_CHANNEL_NAME];
  47         pjsip_sip_uri *uri;
  48         pjsip_name_addr *id_name_addr = (pjsip_name_addr *) hdr->uri;
  49
  50         uri = pjsip_uri_get_uri(id_name_addr);
  51         ast_copy_pj_str(cid_name, &id_name_addr->display, sizeof(cid_name));
  52         ast_copy_pj_str(cid_num, &uri->user, sizeof(cid_num));
  53
  54         ast_free(id->name.str);
  55         id->name.str = ast_strdup(cid_name);
  56         if (!ast_strlen_zero(cid_name)) {
  57                 id->name.valid = 1;
  58         }
  59         ast_free(id->number.str);
  60         id->number.str = ast_strdup(cid_num);
  61         if (!ast_strlen_zero(cid_num)) {
  62                 id->number.valid = 1;
  63         }
  64 }
  65
  66 /*!
  67  * \internal
  68  * \brief Get a P-Asserted-Identity or Remote-Party-ID header from an incoming message
  69  *
  70  * This function will parse the header as if it were a From header. This allows for us
  71  * to easily manipulate the URI, as well as add, modify, or remove parameters from the
  72  * header
  73  *
  74  * \param rdata The incoming message
  75  * \param header_name The name of the ID header to find
  76  * \retval NULL No ID header present or unable to parse ID header
  77  * \retval non-NULL The parsed ID header
  78  */
  79 static pjsip_fromto_hdr *get_id_header(pjsip_rx_data *rdata, const pj_str_t *header_name)
  80 {
  81         static const pj_str_t from = { "From", 4 };
  82         pj_str_t header_content;
  83         pjsip_fromto_hdr *parsed_hdr;
  84         pjsip_generic_string_hdr *ident = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg,
  85                         header_name, NULL);
  86         int parsed_len;
  87
  88         if (!ident) {
  89                 return NULL;
  90         }
  91
  92         pj_strdup_with_null(rdata->tp_info.pool, &header_content, &ident->hvalue);
  93
  94         parsed_hdr = pjsip_parse_hdr(rdata->tp_info.pool, &from, header_content.ptr,
  95                         pj_strlen(&header_content), &parsed_len);
  96
  97         if (!parsed_hdr) {
  98                 return NULL;
  99         }
 100
 101         return parsed_hdr;
 102 }
 103
 104 /*!
 105  * \internal
 106  * \brief Set an ast_party_id structure based on data in a P-Asserted-Identity header
 107  *
 108  * This makes use of \ref set_id_from_hdr for setting name and number. It uses
 109  * the contents of a Privacy header in order to set presentation information.
 110  *
 111  * \param rdata The incoming message
 112  * \param[out] id The ID to set
 113  * \retval 0 Successfully set the party ID
 114  * \retval non-zero Could not set the party ID
 115  */
 116 static int set_id_from_pai(pjsip_rx_data *rdata, struct ast_party_id *id)
 117 {
 118         static const pj_str_t pai_str = { "P-Asserted-Identity", 19 };
 119         static const pj_str_t privacy_str = { "Privacy", 7 };
 120         pjsip_fromto_hdr *pai_hdr = get_id_header(rdata, &pai_str);
 121         pjsip_generic_string_hdr *privacy;
 122
 123         if (!pai_hdr) {
 124                 return -1;
 125         }
 126
 127         set_id_from_hdr(pai_hdr, id);
 128
 129         if (!id->number.valid) {
 130                 return -1;
 131         }
 132
 133         privacy = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &privacy_str, NULL);
 134         if (!privacy) {
 135                 return 0;
 136         }
 137         if (!pj_stricmp2(&privacy->hvalue, "id")) {
 138                 id->number.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 139                 id->name.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
 140         }
 141
 142         return 0;
 143 }
 144
 145 /*!
 146  * \internal
 147  * \brief Set an ast_party_id structure based on data in a Remote-Party-ID header
 148  *
 149  * This makes use of \ref set_id_from_hdr for setting name and number. It uses
 150  * the privacy and screen parameters in order to set presentation information.
 151  *
 152  * \param rdata The incoming message
 153  * \param[out] id The ID to set
 154  * \retval 0 Succesfully set the party ID
 155  * \retval non-zero Could not set the party ID
 156  */
 157 static int set_id_from_rpid(pjsip_rx_data *rdata, struct ast_party_id *id)
 158 {
 159         static const pj_str_t rpid_str = { "Remote-Party-ID", 15 };
 160         static const pj_str_t privacy_str = { "privacy", 7 };
 161         static const pj_str_t screen_str = { "screen", 6 };
 162         pjsip_fromto_hdr *rpid_hdr = get_id_header(rdata, &rpid_str);
 163         pjsip_param *screen;
 164         pjsip_param *privacy;
 165
 166         if (!rpid_hdr) {
 167                 return -1;
 168         }
 169
 170         set_id_from_hdr(rpid_hdr, id);
 171
 172         if (!id->number.valid) {
 173                 return -1;
 174         }
 175
 176         privacy = pjsip_param_find(&rpid_hdr->other_param, &privacy_str);
 177         screen = pjsip_param_find(&rpid_hdr->other_param, &screen_str);
 178         if (privacy && !pj_stricmp2(&privacy->value, "full")) {
 179                 id->number.presentation |= AST_PRES_RESTRICTED;
 180                 id->name.presentation |= AST_PRES_RESTRICTED;
 181         }
 182         if (screen && !pj_stricmp2(&screen->value, "yes")) {
 183                 id->number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
 184                 id->name.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
 185         }
 186
 187         return 0;
 188 }
 189
 190 /*!
 191  * \internal
 192  * \brief Set an ast_party_id structure based on data in a From
 193  *
 194  * This makes use of \ref set_id_from_hdr for setting name and number. It uses
 195  * no information from the message in order to set privacy. It relies on endpoint
 196  * configuration for privacy information.
 197  *
 198  * \param rdata The incoming message
 199  * \param[out] id The ID to set
 200  * \retval 0 Succesfully set the party ID
 201  * \retval non-zero Could not set the party ID
 202  */
 203 static int set_id_from_from(struct pjsip_rx_data *rdata, struct ast_party_id *id)
 204 {
 205         pjsip_fromto_hdr *from = pjsip_msg_find_hdr(rdata->msg_info.msg,
 206                         PJSIP_H_FROM, rdata->msg_info.msg->hdr.next);
 207
 208         if (!from) {
 209                 /* This had better not happen */
 210                 return -1;
 211         }
 212
 213         set_id_from_hdr(from, id);
 214
 215         if (!id->number.valid) {
 216                 return -1;
 217         }
 218
 219         return 0;
 220 }
 221
 222 /*!
 223  * \internal
 224  * \brief Determine if a connected line update should be queued
 225  *
 226  * This uses information about the session and the ID that would be queued
 227  * in the connected line update in order to determine if we should queue
 228  * a connected line update.
 229  *
 230  * \param session The session whose channel we wish to queue the connected line update on
 231  * \param id The identification information that would be queued on the connected line update
 232  * \retval 0 We should not queue a connected line update
 233  * \retval non-zero We should queue a connected line update
 234  */
 235 static int should_queue_connected_line_update(const struct ast_sip_session *session, const struct ast_party_id *id)
 236 {
 237         /* Invalid number means no update */
 238         if (!id->number.valid) {
 239                 return 0;
 240         }
 241
 242         /* If the session has never communicated an update or if the
 243          * new ID has a different number than the session, then we
 244          * should queue an update
 245          */
 246         if (ast_strlen_zero(session->id.number.str) ||
 247                         strcmp(session->id.number.str, id->number.str)) {
 248                 return 1;
 249         }
 250
 251         /* By making it to this point, it means the number is not enough
 252          * to determine if an update should be sent. Now we look at
 253          * the name
 254          */
 255
 256         /* If the number couldn't warrant an update and the name is
 257          * invalid, then no update
 258          */
 259         if (!id->name.valid) {
 260                 return 0;
 261         }
 262
 263         /* If the name has changed or we don't have a name set for the
 264          * session, then we should send an update
 265          */
 266         if (ast_strlen_zero(session->id.name.str) ||
 267                         strcmp(session->id.name.str, id->name.str)) {
 268                 return 1;
 269         }
 270
 271         /* Neither the name nor the number have changed. No update */
 272         return 0;
 273 }
 274
 275 /*!
 276  * \internal
 277  * \brief Queue a connected line update on a session's channel.
 278  * \param session The session whose channel should have the connected line update queued upon.
 279  * \param id The identification information to place in the connected line update
 280  */
 281 static void queue_connected_line_update(struct ast_sip_session *session, const struct ast_party_id *id)
 282 {
 283         struct ast_party_connected_line connected;
 284         struct ast_party_caller caller;
 285
 286         /* Fill connected line information */
 287         ast_party_connected_line_init(&connected);
 288         connected.id = *id;
 289         connected.id.tag = session->endpoint->id.self.tag;
 290         connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
 291
 292         /* Save to channel driver copy */
 293         ast_party_id_copy(&session->id, &connected.id);
 294
 295         /* Update our channel CALLERID() */
 296         ast_party_caller_init(&caller);
 297         caller.id = connected.id;
 298         caller.ani = connected.id;
 299         caller.ani2 = ast_channel_caller(session->channel)->ani2;
 300         ast_channel_set_caller_event(session->channel, &caller, NULL);
 301
 302         /* Tell peer about the new connected line information. */
 303         ast_channel_queue_connected_line_update(session->channel, &connected, NULL);
 304 }
 305
 306 /*!
 307  * \internal
 308  * \brief Make updates to connected line information based on an incoming request.
 309  *
 310  * This will get identity information from an incoming request. Once the identification is
 311  * retrieved, we will check if the new information warrants a connected line update and queue
 312  * a connected line update if so.
 313  *
 314  * \param session The session on which we received an incoming request
 315  * \param rdata The incoming request
 316  */
 317 static void update_incoming_connected_line(struct ast_sip_session *session, pjsip_rx_data *rdata)
 318 {
 319         struct ast_party_id id;
 320
 321         if (!session->endpoint->id.trust_inbound) {
 322                 return;
 323         }
 324
 325         ast_party_id_init(&id);
 326         if (!set_id_from_pai(rdata, &id) || !set_id_from_rpid(rdata, &id)) {
 327                 if (should_queue_connected_line_update(session, &id)) {
 328                         queue_connected_line_update(session, &id);
 329                 }
 330         }
 331         ast_party_id_free(&id);
 332 }
 333
 334 /*!
 335  * \internal
 336  * \brief Session supplement callback on an incoming INVITE request
 337  *
 338  * If we are receiving an initial INVITE, then we will set the session's identity
 339  * based on the INVITE or configured endpoint values. If we are receiving a reinvite,
 340  * then we will potentially queue a connected line update via the \ref update_incoming_connected_line
 341  * function
 342  *
 343  * \param session The session that has received an INVITE
 344  * \param rdata The incoming INVITE
 345  */
 346 static int caller_id_incoming_request(struct ast_sip_session *session, pjsip_rx_data *rdata)
 347 {
 348         if (session->inv_session->state < PJSIP_INV_STATE_CONFIRMED) {
 349                 /*
 350                  * Initial inbound INVITE.  Set the session ID directly
 351                  * because the channel has not been created yet.
 352                  */
 353                 if (session->endpoint->id.trust_inbound
 354                         && (!set_id_from_pai(rdata, &session->id)
 355                                 || !set_id_from_rpid(rdata, &session->id))) {
 356                         ast_free(session->id.tag);
 357                         session->id.tag = ast_strdup(session->endpoint->id.self.tag);
 358                         return 0;
 359                 }
 360                 ast_party_id_copy(&session->id, &session->endpoint->id.self);
 361                 if (!session->endpoint->id.self.number.valid) {
 362                         set_id_from_from(rdata, &session->id);
 363                 }
 364         } else {
 365                 /* Reinvite. Check for changes to the ID and queue a connected line
 366                  * update if necessary
 367                  */
 368                 update_incoming_connected_line(session, rdata);
 369         }
 370         return 0;
 371 }
 372
 373 /*!
 374  * \internal
 375  * \brief Session supplement callback on INVITE response
 376  *
 377  * INVITE responses could result in queuing connected line updates.
 378  *
 379  * \param session The session on which communication is happening
 380  * \param rdata The incoming INVITE response
 381  */
 382 static void caller_id_incoming_response(struct ast_sip_session *session, pjsip_rx_data *rdata)
 383 {
 384         if (!session->channel) {
 385                 return;
 386         }
 387
 388         update_incoming_connected_line(session, rdata);
 389 }
 390
 391 /*!
 392  * \internal
 393  * \brief Set name and number information on an identity header.
 394  * \param pool Memory pool to use for string duplication
 395  * \param id_hdr A From, P-Asserted-Identity, or Remote-Party-ID header to modify
 396  * \param id The identity information to apply to the header
 397  */
 398 static void modify_id_header(pj_pool_t *pool, pjsip_fromto_hdr *id_hdr, const struct ast_party_id *id)
 399 {
 400         pjsip_name_addr *id_name_addr;
 401         pjsip_sip_uri *id_uri;
 402
 403         id_name_addr = (pjsip_name_addr *) id_hdr->uri;
 404         id_uri = pjsip_uri_get_uri(id_name_addr->uri);
 405
 406         if (id->name.valid) {
 407                 pj_strdup2(pool, &id_name_addr->display, id->name.str);
 408         }
 409
 410         if (id->number.valid) {
 411                 pj_strdup2(pool, &id_uri->user, id->number.str);
 412         }
 413 }
 414
 415 /*!
 416  * \internal
 417  * \brief Create an identity header for an outgoing message
 418  * \param hdr_name The name of the header to create
 419  * \param tdata The message to place the header on
 420  * \param id The identification information for the new header
 421  * \return newly-created header
 422  */
 423 static pjsip_fromto_hdr *create_new_id_hdr(const pj_str_t *hdr_name, pjsip_tx_data *tdata, const struct ast_party_id *id)
 424 {
 425         pjsip_fromto_hdr *id_hdr;
 426         pjsip_fromto_hdr *base;
 427         pjsip_name_addr *id_name_addr;
 428         pjsip_sip_uri *id_uri;
 429
 430         base = tdata->msg->type == PJSIP_REQUEST_MSG ? PJSIP_MSG_FROM_HDR(tdata->msg) :
 431                 PJSIP_MSG_TO_HDR(tdata->msg);
 432         id_hdr = pjsip_from_hdr_create(tdata->pool);
 433         id_hdr->type = PJSIP_H_OTHER;
 434         pj_strdup(tdata->pool, &id_hdr->name, hdr_name);
 435         id_hdr->sname.slen = 0;
 436
 437         id_name_addr = pjsip_uri_clone(tdata->pool, base->uri);
 438         id_uri = pjsip_uri_get_uri(id_name_addr->uri);
 439
 440         if (id->name.valid) {
 441                 pj_strdup2(tdata->pool, &id_name_addr->display, id->name.str);
 442         }
 443
 444         pj_strdup2(tdata->pool, &id_uri->user, id->number.str);
 445
 446         id_hdr->uri = (pjsip_uri *) id_name_addr;
 447         return id_hdr;
 448 }
 449
 450 /*!
 451  * \internal
 452  * \brief Add a Privacy header to an outbound message
 453  *
 454  * When sending a P-Asserted-Identity header, if privacy is requested, then we
 455  * will need to indicate such by adding a Privacy header. Similarly, if no
 456  * privacy is requested, and a Privacy header already exists on the message,
 457  * then the old Privacy header should be removed.
 458  *
 459  * \param tdata The outbound message to add the Privacy header to
 460  * \param id The id information used to determine privacy
 461  */
 462 static void add_privacy_header(pjsip_tx_data *tdata, const struct ast_party_id *id)
 463 {
 464         static const pj_str_t pj_privacy_name = { "Privacy", 7 };
 465         static const pj_str_t pj_privacy_value = { "id", 2 };
 466         pjsip_hdr *old_privacy;
 467
 468         old_privacy = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_privacy_name, NULL);
 469
 470         if ((id->name.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED &&
 471                         (id->name.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
 472                 if (old_privacy) {
 473                         pj_list_erase(old_privacy);
 474                 }
 475         } else if (!old_privacy) {
 476                 pjsip_generic_string_hdr *privacy_hdr = pjsip_generic_string_hdr_create(
 477                                 tdata->pool, &pj_privacy_name, &pj_privacy_value);
 478                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)privacy_hdr);
 479         }
 480 }
 481
 482 /*!
 483  * \internal
 484  * \brief Add a P-Asserted-Identity header to an outbound message
 485  * \param tdata The message to add the header to
 486  * \param id The identification information used to populate the header
 487  */
 488 static void add_pai_header(pjsip_tx_data *tdata, const struct ast_party_id *id)
 489 {
 490         static const pj_str_t pj_pai_name = { "P-Asserted-Identity", 19 };
 491         pjsip_fromto_hdr *pai_hdr;
 492         pjsip_fromto_hdr *old_pai;
 493
 494         if (!id->number.valid) {
 495                 return;
 496         }
 497
 498         /* Since inv_session reuses responses, we have to make sure there's not already
 499          * a P-Asserted-Identity present. If there is, we just modify the old one.
 500          */
 501         old_pai = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_pai_name, NULL);
 502         if (old_pai) {
 503                 modify_id_header(tdata->pool, old_pai, id);
 504                 add_privacy_header(tdata, id);
 505                 return;
 506         }
 507
 508         pai_hdr = create_new_id_hdr(&pj_pai_name, tdata, id);
 509         if (!pai_hdr) {
 510                 return;
 511         }
 512         add_privacy_header(tdata, id);
 513
 514         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)pai_hdr);
 515 }
 516
 517 /*!
 518  * \internal
 519  * \brief Add privacy and screen parameters to a Remote-Party-ID header.
 520  *
 521  * If privacy is requested, then the privacy and screen parameters need to
 522  * reflect this. Similarly, if no privacy or screening is to be communicated,
 523  * we need to make sure that any previously set values are updated.
 524  *
 525  * \param tdata The message where the Remote-Party-ID header is
 526  * \param hdr The header on which the parameters are being added
 527  * \param id The identification information used to determine privacy
 528  */
 529 static void add_privacy_params(pjsip_tx_data *tdata, pjsip_fromto_hdr *hdr, const struct ast_party_id *id)
 530 {
 531         static const pj_str_t privacy_str = { "privacy", 7 };
 532         static const pj_str_t screen_str = { "screen", 6 };
 533         static const pj_str_t privacy_full_str = { "full", 4 };
 534         static const pj_str_t privacy_off_str = { "off", 3 };
 535         static const pj_str_t screen_yes_str = { "yes", 3 };
 536         static const pj_str_t screen_no_str = { "no", 2 };
 537         pjsip_param *old_privacy;
 538         pjsip_param *old_screen;
 539         pjsip_param *privacy;
 540         pjsip_param *screen;
 541
 542         old_privacy = pjsip_param_find(&hdr->other_param, &privacy_str);
 543         old_screen = pjsip_param_find(&hdr->other_param, &screen_str);
 544
 545         if (!old_privacy) {
 546                 privacy = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
 547                 privacy->name = privacy_str;
 548                 pj_list_insert_before(&hdr->other_param, privacy);
 549         } else {
 550                 privacy = old_privacy;
 551         }
 552
 553         if (!old_screen) {
 554                 screen = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
 555                 screen->name = screen_str;
 556                 pj_list_insert_before(&hdr->other_param, screen);
 557         } else {
 558                 screen = old_screen;
 559         }
 560
 561         if ((id->name.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED &&
 562                         (id->name.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
 563                 privacy->value = privacy_off_str;
 564         } else {
 565                 privacy->value = privacy_full_str;
 566         }
 567
 568         if ((id->name.presentation & AST_PRES_NUMBER_TYPE) == AST_PRES_USER_NUMBER_PASSED_SCREEN &&
 569                         (id->number.presentation & AST_PRES_NUMBER_TYPE) == AST_PRES_USER_NUMBER_PASSED_SCREEN) {
 570                 screen->value = screen_yes_str;
 571         } else {
 572                 screen->value = screen_no_str;
 573         }
 574 }
 575
 576 /*!
 577  * \internal
 578  * \brief Add a Remote-Party-ID header to an outbound message
 579  * \param tdata The message to add the header to
 580  * \param id The identification information used to populate the header
 581  */
 582 static void add_rpid_header(pjsip_tx_data *tdata, const struct ast_party_id *id)
 583 {
 584         static const pj_str_t pj_rpid_name = { "Remote-Party-ID", 15 };
 585         pjsip_fromto_hdr *rpid_hdr;
 586         pjsip_fromto_hdr *old_rpid;
 587
 588         if (!id->number.valid) {
 589                 return;
 590         }
 591
 592         /* Since inv_session reuses responses, we have to make sure there's not already
 593          * a P-Asserted-Identity present. If there is, we just modify the old one.
 594          */
 595         old_rpid = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_rpid_name, NULL);
 596         if (old_rpid) {
 597                 modify_id_header(tdata->pool, old_rpid, id);
 598                 add_privacy_params(tdata, old_rpid, id);
 599                 return;
 600         }
 601
 602         rpid_hdr = create_new_id_hdr(&pj_rpid_name, tdata, id);
 603         if (!rpid_hdr) {
 604                 return;
 605         }
 606         add_privacy_params(tdata, rpid_hdr, id);
 607         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)rpid_hdr);
 608 }
 609
 610 /*!
 611  * \internal
 612  * \brief Add any appropriate identification headers to an outbound SIP message
 613  *
 614  * This will determine if an outbound message should have identification headers and
 615  * will add the appropriately configured headers
 616  *
 617  * \param session The session on which we will be sending the message
 618  * \param tdata The outbound message
 619  * \param The identity information to place on the message
 620  */
 621 static void add_id_headers(const struct ast_sip_session *session, pjsip_tx_data *tdata, const struct ast_party_id *id)
 622 {
 623         if (((id->name.presentation & AST_PRES_RESTRICTION) == AST_PRES_RESTRICTED ||
 624                         (id->number.presentation & AST_PRES_RESTRICTION) == AST_PRES_RESTRICTED) &&
 625                         !session->endpoint->id.trust_outbound) {
 626                 return;
 627         }
 628         if (session->endpoint->id.send_pai) {
 629                 add_pai_header(tdata, id);
 630         }
 631         if (session->endpoint->id.send_rpid) {
 632                 add_rpid_header(tdata, id);
 633         }
 634 }
 635
 636 /*!
 637  * \internal
 638  * \brief Session supplement callback for outgoing INVITE requests
 639  *
 640  * For an initial INVITE request, we may change the From header to appropriately
 641  * reflect the identity information. On all INVITEs (initial and reinvite) we may
 642  * add other identity headers such as P-Asserted-Identity and Remote-Party-ID based
 643  * on configuration and privacy settings
 644  *
 645  * \param session The session on which the INVITE will be sent
 646  * \param tdata The outbound INVITE request
 647  */
 648 static void caller_id_outgoing_request(struct ast_sip_session *session, pjsip_tx_data *tdata)
 649 {
 650         struct ast_party_id effective_id;
 651         struct ast_party_id connected_id;
 652
 653         if (!session->channel) {
 654                 return;
 655         }
 656
 657         /* Must do a deep copy unless we hold the channel lock the entire time. */
 658         ast_party_id_init(&connected_id);
 659         ast_channel_lock(session->channel);
 660         effective_id = ast_channel_connected_effective_id(session->channel);
 661         ast_party_id_copy(&connected_id, &effective_id);
 662         ast_channel_unlock(session->channel);
 663
 664         if (session->inv_session->state < PJSIP_INV_STATE_CONFIRMED &&
 665                         ast_strlen_zero(session->endpoint->fromuser) &&
 666                         (session->endpoint->id.trust_outbound ||
 667                         ((connected_id.name.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED &&
 668                         (connected_id.number.presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED))) {
 669                 /* Only change the From header on the initial outbound INVITE. Switching it
 670                  * mid-call might confuse some UAs.
 671                  */
 672                 pjsip_fromto_hdr *from;
 673                 pjsip_dialog *dlg;
 674
 675                 from = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_FROM, tdata->msg->hdr.next);
 676                 dlg = session->inv_session->dlg;
 677
 678                 modify_id_header(tdata->pool, from, &connected_id);
 679                 modify_id_header(dlg->pool, dlg->local.info, &connected_id);
 680         }
 681         add_id_headers(session, tdata, &connected_id);
 682         ast_party_id_free(&connected_id);
 683 }
 684
 685 /*!
 686  * \internal
 687  * \brief Session supplement for outgoing INVITE response
 688  *
 689  * This will add P-Asserted-Identity and Remote-Party-ID headers if necessary
 690  *
 691  * \param session The session on which the INVITE response is to be sent
 692  * \param tdata The outbound INVITE response
 693  */
 694 static void caller_id_outgoing_response(struct ast_sip_session *session, pjsip_tx_data *tdata)
 695 {
 696         struct ast_party_id effective_id;
 697         struct ast_party_id connected_id;
 698
 699         if (!session->channel) {
 700                 return;
 701         }
 702
 703         /* Must do a deep copy unless we hold the channel lock the entire time. */
 704         ast_party_id_init(&connected_id);
 705         ast_channel_lock(session->channel);
 706         effective_id = ast_channel_connected_effective_id(session->channel);
 707         ast_party_id_copy(&connected_id, &effective_id);
 708         ast_channel_unlock(session->channel);
 709
 710         add_id_headers(session, tdata, &connected_id);
 711         ast_party_id_free(&connected_id);
 712 }
 713
 714 static struct ast_sip_session_supplement caller_id_supplement = {
 715         .method = "INVITE,UPDATE",
 716         .priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL - 1000,
 717         .incoming_request = caller_id_incoming_request,
 718         .incoming_response = caller_id_incoming_response,
 719         .outgoing_request = caller_id_outgoing_request,
 720         .outgoing_response = caller_id_outgoing_response,
 721 };
 722
 723 static int load_module(void)
 724 {
 725         ast_sip_session_register_supplement(&caller_id_supplement);
 726         return AST_MODULE_LOAD_SUCCESS;
 727 }
 728
 729 static int unload_module(void)
 730 {
 731         ast_sip_session_unregister_supplement(&caller_id_supplement);
 732         return 0;
 733 }
 734
 735 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Caller ID Support",
 736                 .support_level = AST_MODULE_SUPPORT_CORE,
 737                 .load = load_module,
 738                 .unload = unload_module,
 739                 .load_pri = AST_MODPRI_APP_DEPEND,
 740                );