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