res_pjsip_caller_id: Anonymize 'From' when caller id presentation is prohibited
[asterisk/asterisk.git] / 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 && !pj_stricmp2(&privacy->hvalue, "id")) {
135                 id->number.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
136                 id->name.presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
137         } else {
138                 id->number.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
139                 id->name.presentation = AST_PRES_ALLOWED_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         } else {
182                 id->number.presentation = AST_PRES_ALLOWED;
183                 id->name.presentation = AST_PRES_ALLOWED;
184         }
185         if (screen && !pj_stricmp2(&screen->value, "yes")) {
186                 id->number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
187                 id->name.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
188         } else {
189                 id->number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
190                 id->name.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
191         }
192
193         return 0;
194 }
195
196 /*!
197  * \internal
198  * \brief Set an ast_party_id structure based on data in a From
199  *
200  * This makes use of \ref set_id_from_hdr for setting name and number. It uses
201  * no information from the message in order to set privacy. It relies on endpoint
202  * configuration for privacy information.
203  *
204  * \param rdata The incoming message
205  * \param[out] id The ID to set
206  * \retval 0 Succesfully set the party ID
207  * \retval non-zero Could not set the party ID
208  */
209 static int set_id_from_from(struct pjsip_rx_data *rdata, struct ast_party_id *id)
210 {
211         pjsip_fromto_hdr *from = pjsip_msg_find_hdr(rdata->msg_info.msg,
212                         PJSIP_H_FROM, rdata->msg_info.msg->hdr.next);
213
214         if (!from) {
215                 /* This had better not happen */
216                 return -1;
217         }
218
219         set_id_from_hdr(from, id);
220
221         if (!id->number.valid) {
222                 return -1;
223         }
224
225         return 0;
226 }
227
228 /*!
229  * \internal
230  * \brief Determine if a connected line update should be queued
231  *
232  * This uses information about the session and the ID that would be queued
233  * in the connected line update in order to determine if we should queue
234  * a connected line update.
235  *
236  * \param session The session whose channel we wish to queue the connected line update on
237  * \param id The identification information that would be queued on the connected line update
238  * \retval 0 We should not queue a connected line update
239  * \retval non-zero We should queue a connected line update
240  */
241 static int should_queue_connected_line_update(const struct ast_sip_session *session, const struct ast_party_id *id)
242 {
243         /* Invalid number means no update */
244         if (!id->number.valid) {
245                 return 0;
246         }
247
248         /* If the session has never communicated an update or if the
249          * new ID has a different number than the session, then we
250          * should queue an update
251          */
252         if (ast_strlen_zero(session->id.number.str) ||
253                         strcmp(session->id.number.str, id->number.str)) {
254                 return 1;
255         }
256
257         /* By making it to this point, it means the number is not enough
258          * to determine if an update should be sent. Now we look at
259          * the name
260          */
261
262         /* If the number couldn't warrant an update and the name is
263          * invalid, then no update
264          */
265         if (!id->name.valid) {
266                 return 0;
267         }
268
269         /* If the name has changed or we don't have a name set for the
270          * session, then we should send an update
271          */
272         if (ast_strlen_zero(session->id.name.str) ||
273                         strcmp(session->id.name.str, id->name.str)) {
274                 return 1;
275         }
276
277         /* Neither the name nor the number have changed. No update */
278         return 0;
279 }
280
281 /*!
282  * \internal
283  * \brief Queue a connected line update on a session's channel.
284  * \param session The session whose channel should have the connected line update queued upon.
285  * \param id The identification information to place in the connected line update
286  */
287 static void queue_connected_line_update(struct ast_sip_session *session, const struct ast_party_id *id)
288 {
289         struct ast_party_connected_line connected;
290         struct ast_party_caller caller;
291
292         /* Fill connected line information */
293         ast_party_connected_line_init(&connected);
294         connected.id = *id;
295         connected.id.tag = session->endpoint->id.self.tag;
296         connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
297
298         /* Save to channel driver copy */
299         ast_party_id_copy(&session->id, &connected.id);
300
301         /* Update our channel CALLERID() */
302         ast_party_caller_init(&caller);
303         caller.id = connected.id;
304         caller.ani = connected.id;
305         caller.ani2 = ast_channel_caller(session->channel)->ani2;
306         ast_channel_set_caller_event(session->channel, &caller, NULL);
307
308         /* Tell peer about the new connected line information. */
309         ast_channel_queue_connected_line_update(session->channel, &connected, NULL);
310 }
311
312 /*!
313  * \internal
314  * \brief Make updates to connected line information based on an incoming request.
315  *
316  * This will get identity information from an incoming request. Once the identification is
317  * retrieved, we will check if the new information warrants a connected line update and queue
318  * a connected line update if so.
319  *
320  * \param session The session on which we received an incoming request
321  * \param rdata The incoming request
322  */
323 static void update_incoming_connected_line(struct ast_sip_session *session, pjsip_rx_data *rdata)
324 {
325         struct ast_party_id id;
326
327         if (!session->endpoint->id.trust_inbound) {
328                 return;
329         }
330
331         ast_party_id_init(&id);
332         if (!set_id_from_pai(rdata, &id) || !set_id_from_rpid(rdata, &id)) {
333                 if (should_queue_connected_line_update(session, &id)) {
334                         queue_connected_line_update(session, &id);
335                 }
336         }
337         ast_party_id_free(&id);
338 }
339
340 /*!
341  * \internal
342  * \brief Session supplement callback on an incoming INVITE request
343  *
344  * If we are receiving an initial INVITE, then we will set the session's identity
345  * based on the INVITE or configured endpoint values. If we are receiving a reinvite,
346  * then we will potentially queue a connected line update via the \ref update_incoming_connected_line
347  * function
348  *
349  * \param session The session that has received an INVITE
350  * \param rdata The incoming INVITE
351  */
352 static int caller_id_incoming_request(struct ast_sip_session *session, pjsip_rx_data *rdata)
353 {
354         if (!session->channel) {
355                 /*
356                  * Since we have no channel this must be the initial inbound
357                  * INVITE.  Set the session ID directly because the channel
358                  * has not been created yet.
359                  */
360                 if (session->endpoint->id.trust_inbound
361                         && (!set_id_from_pai(rdata, &session->id)
362                                 || !set_id_from_rpid(rdata, &session->id))) {
363                         ast_free(session->id.tag);
364                         session->id.tag = ast_strdup(session->endpoint->id.self.tag);
365                         return 0;
366                 }
367                 ast_party_id_copy(&session->id, &session->endpoint->id.self);
368                 if (!session->endpoint->id.self.number.valid) {
369                         set_id_from_from(rdata, &session->id);
370                 }
371         } else {
372                 /*
373                  * ReINVITE or UPDATE.  Check for changes to the ID and queue
374                  * a connected line update if necessary.
375                  */
376                 update_incoming_connected_line(session, rdata);
377         }
378         return 0;
379 }
380
381 /*!
382  * \internal
383  * \brief Session supplement callback on INVITE response
384  *
385  * INVITE responses could result in queuing connected line updates.
386  *
387  * \param session The session on which communication is happening
388  * \param rdata The incoming INVITE response
389  */
390 static void caller_id_incoming_response(struct ast_sip_session *session, pjsip_rx_data *rdata)
391 {
392         if (!session->channel) {
393                 return;
394         }
395
396         update_incoming_connected_line(session, rdata);
397 }
398
399 /*!
400  * \internal
401  * \brief Create an identity header for an outgoing message
402  * \param hdr_name The name of the header to create
403  * \param tdata The message to place the header on
404  * \param id The identification information for the new header
405  * \return newly-created header
406  */
407 static pjsip_fromto_hdr *create_new_id_hdr(const pj_str_t *hdr_name, pjsip_fromto_hdr *base, pjsip_tx_data *tdata, const struct ast_party_id *id)
408 {
409         pjsip_fromto_hdr *id_hdr;
410         pjsip_name_addr *id_name_addr;
411         pjsip_sip_uri *id_uri;
412
413         id_hdr = pjsip_from_hdr_create(tdata->pool);
414         id_hdr->type = PJSIP_H_OTHER;
415         pj_strdup(tdata->pool, &id_hdr->name, hdr_name);
416         id_hdr->sname.slen = 0;
417
418         id_name_addr = pjsip_uri_clone(tdata->pool, base->uri);
419         id_uri = pjsip_uri_get_uri(id_name_addr->uri);
420
421         if (id->name.valid) {
422                 int name_buf_len = strlen(id->name.str) * 2 + 1;
423                 char *name_buf = ast_alloca(name_buf_len);
424
425                 ast_escape_quoted(id->name.str, name_buf, name_buf_len);
426                 pj_strdup2(tdata->pool, &id_name_addr->display, name_buf);
427         }
428
429         pj_strdup2(tdata->pool, &id_uri->user, id->number.str);
430
431         id_hdr->uri = (pjsip_uri *) id_name_addr;
432         return id_hdr;
433 }
434
435 /*!
436  * \internal
437  * \brief Add a Privacy header to an outbound message
438  *
439  * When sending a P-Asserted-Identity header, if privacy is requested, then we
440  * will need to indicate such by adding a Privacy header. Similarly, if no
441  * privacy is requested, and a Privacy header already exists on the message,
442  * then the old Privacy header should be removed.
443  *
444  * \param tdata The outbound message to add the Privacy header to
445  * \param id The id information used to determine privacy
446  */
447 static void add_privacy_header(pjsip_tx_data *tdata, const struct ast_party_id *id)
448 {
449         static const pj_str_t pj_privacy_name = { "Privacy", 7 };
450         static const pj_str_t pj_privacy_value = { "id", 2 };
451         pjsip_hdr *old_privacy;
452
453         old_privacy = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_privacy_name, NULL);
454
455         if ((ast_party_id_presentation(id) & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
456                 if (old_privacy) {
457                         pj_list_erase(old_privacy);
458                 }
459         } else if (!old_privacy) {
460                 pjsip_generic_string_hdr *privacy_hdr = pjsip_generic_string_hdr_create(
461                                 tdata->pool, &pj_privacy_name, &pj_privacy_value);
462                 pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)privacy_hdr);
463         }
464 }
465
466 /*!
467  * \internal
468  * \brief Add a P-Asserted-Identity header to an outbound message
469  * \param tdata The message to add the header to
470  * \param id The identification information used to populate the header
471  */
472 static void add_pai_header(const struct ast_sip_session *session, pjsip_tx_data *tdata, const struct ast_party_id *id)
473 {
474         static const pj_str_t pj_pai_name = { "P-Asserted-Identity", 19 };
475         pjsip_fromto_hdr *base;
476         pjsip_fromto_hdr *pai_hdr;
477         pjsip_fromto_hdr *old_pai;
478
479         /* Since inv_session reuses responses, we have to make sure there's not already
480          * a P-Asserted-Identity present. If there is, we just modify the old one.
481          */
482         old_pai = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_pai_name, NULL);
483         if (old_pai) {
484                 /* If type is OTHER, then the existing header was most likely
485                  * added by the PJSIP_HEADER dial plan function as a simple
486                  * name/value pair.  We can't pass this to modify_id_header because
487                  * there are no virtual functions to get the uri.  We could parse
488                  * it into a pjsip_fromto_hdr but it isn't worth it since
489                  * modify_id_header is just going to overwrite the name and number
490                  * anyway.  We'll just remove it from the header list instead
491                  * and create a new one.
492                  */
493                 if (old_pai->type == PJSIP_H_OTHER) {
494                         pj_list_erase(old_pai);
495                 } else {
496                         ast_sip_modify_id_header(tdata->pool, old_pai, id);
497                         add_privacy_header(tdata, id);
498                         return;
499                 }
500         }
501
502         base = tdata->msg->type == PJSIP_REQUEST_MSG ? session->saved_from_hdr :
503                 PJSIP_MSG_TO_HDR(tdata->msg);
504
505         pai_hdr = create_new_id_hdr(&pj_pai_name, base, tdata, id);
506         if (!pai_hdr) {
507                 return;
508         }
509         add_privacy_header(tdata, id);
510
511         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)pai_hdr);
512 }
513
514 /*!
515  * \internal
516  * \brief Add privacy and screen parameters to a Remote-Party-ID header.
517  *
518  * If privacy is requested, then the privacy and screen parameters need to
519  * reflect this. Similarly, if no privacy or screening is to be communicated,
520  * we need to make sure that any previously set values are updated.
521  *
522  * \param tdata The message where the Remote-Party-ID header is
523  * \param hdr The header on which the parameters are being added
524  * \param id The identification information used to determine privacy
525  */
526 static void add_privacy_params(pjsip_tx_data *tdata, pjsip_fromto_hdr *hdr, const struct ast_party_id *id)
527 {
528         static const pj_str_t privacy_str = { "privacy", 7 };
529         static const pj_str_t screen_str = { "screen", 6 };
530         static const pj_str_t privacy_full_str = { "full", 4 };
531         static const pj_str_t privacy_off_str = { "off", 3 };
532         static const pj_str_t screen_yes_str = { "yes", 3 };
533         static const pj_str_t screen_no_str = { "no", 2 };
534         pjsip_param *old_privacy;
535         pjsip_param *old_screen;
536         pjsip_param *privacy;
537         pjsip_param *screen;
538         int presentation;
539
540         old_privacy = pjsip_param_find(&hdr->other_param, &privacy_str);
541         old_screen = pjsip_param_find(&hdr->other_param, &screen_str);
542
543         if (!old_privacy) {
544                 privacy = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
545                 privacy->name = privacy_str;
546                 pj_list_insert_before(&hdr->other_param, privacy);
547         } else {
548                 privacy = old_privacy;
549         }
550
551         if (!old_screen) {
552                 screen = PJ_POOL_ALLOC_T(tdata->pool, pjsip_param);
553                 screen->name = screen_str;
554                 pj_list_insert_before(&hdr->other_param, screen);
555         } else {
556                 screen = old_screen;
557         }
558
559         presentation = ast_party_id_presentation(id);
560         if ((presentation & AST_PRES_RESTRICTION) == AST_PRES_ALLOWED) {
561                 privacy->value = privacy_off_str;
562         } else {
563                 privacy->value = privacy_full_str;
564         }
565         if ((presentation & AST_PRES_NUMBER_TYPE) == AST_PRES_USER_NUMBER_PASSED_SCREEN) {
566                 screen->value = screen_yes_str;
567         } else {
568                 screen->value = screen_no_str;
569         }
570 }
571
572 /*!
573  * \internal
574  * \brief Add a Remote-Party-ID header to an outbound message
575  * \param tdata The message to add the header to
576  * \param id The identification information used to populate the header
577  */
578 static void add_rpid_header(const struct ast_sip_session *session, pjsip_tx_data *tdata, const struct ast_party_id *id)
579 {
580         static const pj_str_t pj_rpid_name = { "Remote-Party-ID", 15 };
581         pjsip_fromto_hdr *base;
582         pjsip_fromto_hdr *rpid_hdr;
583         pjsip_fromto_hdr *old_rpid;
584
585         /* Since inv_session reuses responses, we have to make sure there's not already
586          * a P-Asserted-Identity present. If there is, we just modify the old one.
587          */
588         old_rpid = pjsip_msg_find_hdr_by_name(tdata->msg, &pj_rpid_name, NULL);
589         if (old_rpid) {
590                 /* If type is OTHER, then the existing header was most likely
591                  * added by the PJSIP_HEADER dial plan function as a simple
592                  * name/value pair.  We can't pass this to modify_id_header because
593                  * there are no virtual functions to get the uri.  We could parse
594                  * it into a pjsip_fromto_hdr but it isn't worth it since
595                  * modify_id_header is just going to overwrite the name and number
596                  * anyway.  We'll just remove it from the header list instead
597                  * and create a new one.
598                  */
599                 if (old_rpid->type == PJSIP_H_OTHER) {
600                         pj_list_erase(old_rpid);
601                 } else {
602                         ast_sip_modify_id_header(tdata->pool, old_rpid, id);
603                         add_privacy_params(tdata, old_rpid, id);
604                         return;
605                 }
606         }
607
608         base = tdata->msg->type == PJSIP_REQUEST_MSG ? session->saved_from_hdr :
609                 PJSIP_MSG_TO_HDR(tdata->msg);
610
611         rpid_hdr = create_new_id_hdr(&pj_rpid_name, base, tdata, id);
612         if (!rpid_hdr) {
613                 return;
614         }
615         add_privacy_params(tdata, rpid_hdr, id);
616         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)rpid_hdr);
617 }
618
619 /*!
620  * \internal
621  * \brief Add any appropriate identification headers to an outbound SIP message
622  *
623  * This will determine if an outbound message should have identification headers and
624  * will add the appropriately configured headers
625  *
626  * \param session The session on which we will be sending the message
627  * \param tdata The outbound message
628  * \param The identity information to place on the message
629  */
630 static void add_id_headers(const struct ast_sip_session *session, pjsip_tx_data *tdata, const struct ast_party_id *id)
631 {
632         if (!id->number.valid
633                 || (!session->endpoint->id.trust_outbound
634                         && (ast_party_id_presentation(id) & AST_PRES_RESTRICTION) != AST_PRES_ALLOWED)) {
635                 return;
636         }
637         if (session->endpoint->id.send_pai) {
638                 add_pai_header(session, tdata, id);
639         }
640         if (session->endpoint->id.send_rpid) {
641                 add_rpid_header(session, tdata, id);
642         }
643 }
644
645 /*!
646  * \internal
647  * \brief Session supplement callback for outgoing INVITE requests
648  *
649  * On all INVITEs (initial and reinvite) we may add other identity headers
650  * such as P-Asserted-Identity and Remote-Party-ID based on configuration
651  * and privacy settings
652  *
653  * \param session The session on which the INVITE will be sent
654  * \param tdata The outbound INVITE request
655  */
656 static void caller_id_outgoing_request(struct ast_sip_session *session, pjsip_tx_data *tdata)
657 {
658         struct ast_party_id effective_id;
659         struct ast_party_id connected_id;
660
661         if (!session->channel) {
662                 return;
663         }
664
665         ast_party_id_init(&connected_id);
666         ast_channel_lock(session->channel);
667         effective_id = ast_channel_connected_effective_id(session->channel);
668         ast_party_id_copy(&connected_id, &effective_id);
669         ast_channel_unlock(session->channel);
670
671         add_id_headers(session, tdata, &connected_id);
672         ast_party_id_free(&connected_id);
673 }
674
675 /*!
676  * \internal
677  * \brief Session supplement for outgoing INVITE response
678  *
679  * This will add P-Asserted-Identity and Remote-Party-ID headers if necessary
680  *
681  * \param session The session on which the INVITE response is to be sent
682  * \param tdata The outbound INVITE response
683  */
684 static void caller_id_outgoing_response(struct ast_sip_session *session, pjsip_tx_data *tdata)
685 {
686         struct ast_party_id effective_id;
687         struct ast_party_id connected_id;
688
689         if (!session->channel) {
690                 return;
691         }
692
693         /* Must do a deep copy unless we hold the channel lock the entire time. */
694         ast_party_id_init(&connected_id);
695         ast_channel_lock(session->channel);
696         effective_id = ast_channel_connected_effective_id(session->channel);
697         ast_party_id_copy(&connected_id, &effective_id);
698         ast_channel_unlock(session->channel);
699
700         add_id_headers(session, tdata, &connected_id);
701         ast_party_id_free(&connected_id);
702 }
703
704 static struct ast_sip_session_supplement caller_id_supplement = {
705         .method = "INVITE,UPDATE",
706         .priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL - 1000,
707         .incoming_request = caller_id_incoming_request,
708         .incoming_response = caller_id_incoming_response,
709         .outgoing_request = caller_id_outgoing_request,
710         .outgoing_response = caller_id_outgoing_response,
711 };
712
713 static int load_module(void)
714 {
715         CHECK_PJSIP_SESSION_MODULE_LOADED();
716
717         ast_sip_session_register_supplement(&caller_id_supplement);
718         return AST_MODULE_LOAD_SUCCESS;
719 }
720
721 static int unload_module(void)
722 {
723         ast_sip_session_unregister_supplement(&caller_id_supplement);
724         return 0;
725 }
726
727 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Caller ID Support",
728         .support_level = AST_MODULE_SUPPORT_CORE,
729         .load = load_module,
730         .unload = unload_module,
731         .load_pri = AST_MODPRI_APP_DEPEND,
732 );