c1b76ae20765bae3cac82cdee8e67688f8d2f695
[asterisk/asterisk.git] / res / res_pjsip_refer.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@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/module.h"
34 #include "asterisk/pbx.h"
35 #include "asterisk/taskprocessor.h"
36 #include "asterisk/bridge.h"
37 #include "asterisk/framehook.h"
38 #include "asterisk/stasis_bridges.h"
39 #include "asterisk/stasis_channels.h"
40 #include "asterisk/causes.h"
41
42 /*! \brief REFER Progress structure */
43 struct refer_progress {
44         /*! \brief Subscription to provide updates on */
45         pjsip_evsub *sub;
46         /*! \brief Dialog for subscription */
47         pjsip_dialog *dlg;
48         /*! \brief Received packet, used to construct final response in case no subscription exists */
49         pjsip_rx_data *rdata;
50         /*! \brief Frame hook for monitoring REFER progress */
51         int framehook;
52         /*! \brief Last received subclass in frame hook */
53         int subclass;
54         /*! \brief Serializer for notifications */
55         struct ast_taskprocessor *serializer;
56         /*! \brief Stasis subscription for bridge events */
57         struct stasis_subscription *bridge_sub;
58         /*! \brief Reference to transfer_channel_data related to the refer */
59         struct transfer_channel_data *transfer_data;
60         /*! \brief Uniqueid of transferee channel */
61         char *transferee;
62 };
63
64 /*! \brief REFER Progress notification structure */
65 struct refer_progress_notification {
66         /*! \brief Refer progress structure to send notification on */
67         struct refer_progress *progress;
68         /*! \brief SIP response code to send */
69         int response;
70         /*! \brief Subscription state */
71         pjsip_evsub_state state;
72 };
73
74 /*! \brief REFER Progress module, used to attach REFER progress structure to subscriptions */
75 static pjsip_module refer_progress_module = {
76         .name = { "REFER Progress", 14 },
77         .id = -1,
78 };
79
80 /*! \brief Destructor for REFER Progress notification structure */
81 static void refer_progress_notification_destroy(void *obj)
82 {
83         struct refer_progress_notification *notification = obj;
84
85         ao2_cleanup(notification->progress);
86 }
87
88 /*! \brief Allocator for REFER Progress notification structure */
89 static struct refer_progress_notification *refer_progress_notification_alloc(struct refer_progress *progress, int response,
90         pjsip_evsub_state state)
91 {
92         struct refer_progress_notification *notification = ao2_alloc(sizeof(*notification), refer_progress_notification_destroy);
93
94         if (!notification) {
95                 return NULL;
96         }
97
98         ao2_ref(progress, +1);
99         notification->progress = progress;
100         notification->response = response;
101         notification->state = state;
102
103         return notification;
104 }
105
106 /*! \brief Serialized callback for subscription notification */
107 static int refer_progress_notify(void *data)
108 {
109         RAII_VAR(struct refer_progress_notification *, notification, data, ao2_cleanup);
110         pjsip_evsub *sub;
111         pjsip_tx_data *tdata;
112
113         /* If the subscription has already been terminated we can't send a notification */
114         if (!(sub = notification->progress->sub)) {
115                 ast_debug(3, "Not sending NOTIFY of response '%d' and state '%u' on progress monitor '%p' as subscription has been terminated\n",
116                         notification->response, notification->state, notification->progress);
117                 return 0;
118         }
119
120         /* If the subscription is being terminated we want to actually remove the progress structure here to
121          * stop a deadlock from occurring - basically terminated changes the state which queues a synchronous task
122          * but we are already running a task... thus it would deadlock */
123         if (notification->state == PJSIP_EVSUB_STATE_TERMINATED) {
124                 ast_debug(3, "Subscription '%p' is being terminated as a result of a NOTIFY, removing REFER progress structure early on progress monitor '%p'\n",
125                         notification->progress->sub, notification->progress);
126                 pjsip_dlg_inc_lock(notification->progress->dlg);
127                 pjsip_evsub_set_mod_data(notification->progress->sub, refer_progress_module.id, NULL);
128                 pjsip_dlg_dec_lock(notification->progress->dlg);
129
130                 /* This is for dropping the reference on the subscription */
131                 ao2_cleanup(notification->progress);
132
133                 notification->progress->sub = NULL;
134         }
135
136         ast_debug(3, "Sending NOTIFY with response '%d' and state '%u' on subscription '%p' and progress monitor '%p'\n",
137                 notification->response, notification->state, sub, notification->progress);
138
139         /* Actually send the notification */
140         if (pjsip_xfer_notify(sub, notification->state, notification->response, NULL, &tdata) == PJ_SUCCESS) {
141                 pjsip_xfer_send_request(sub, tdata);
142         }
143
144         return 0;
145 }
146
147 static void refer_progress_bridge(void *data, struct stasis_subscription *sub,
148                 struct stasis_message *message)
149 {
150         struct refer_progress *progress = data;
151         struct ast_bridge_blob *enter_blob;
152         struct refer_progress_notification *notification;
153         struct ast_channel *chan;
154
155         if (stasis_subscription_final_message(sub, message)) {
156                 ao2_ref(progress, -1);
157                 return;
158         }
159
160         if (ast_channel_entered_bridge_type() != stasis_message_type(message)) {
161                 /* Don't care */
162                 return;
163         }
164
165         enter_blob = stasis_message_data(message);
166         if (strcmp(enter_blob->channel->uniqueid, progress->transferee)) {
167                 /* Don't care */
168                 return;
169         }
170
171         if (!progress->transfer_data->completed) {
172                 /* We can't act on this message because the transfer_channel_data doesn't show that
173                  * the transfer is ready to progress */
174                 return;
175         }
176
177         /* OMG the transferee is joining a bridge. His call got answered! */
178         notification = refer_progress_notification_alloc(progress, 200, PJSIP_EVSUB_STATE_TERMINATED);
179         if (notification) {
180                 if (ast_sip_push_task(progress->serializer, refer_progress_notify, notification)) {
181                         ao2_cleanup(notification);
182                 }
183                 progress->bridge_sub = stasis_unsubscribe(progress->bridge_sub);
184         }
185
186         chan = ast_channel_get_by_name(progress->transferee);
187         if (!chan) {
188                 /* The channel is already gone */
189                 return;
190         }
191
192         ast_channel_lock(chan);
193         ast_debug(3, "Detaching REFER progress monitoring hook from '%s' as it has joined a bridge\n",
194                 ast_channel_name(chan));
195         ast_framehook_detach(chan, progress->framehook);
196         ast_channel_unlock(chan);
197
198         ast_channel_unref(chan);
199 }
200
201 /*! \brief Progress monitoring frame hook - examines frames to determine state of transfer */
202 static struct ast_frame *refer_progress_framehook(struct ast_channel *chan, struct ast_frame *f, enum ast_framehook_event event, void *data)
203 {
204         struct refer_progress *progress = data;
205         struct refer_progress_notification *notification = NULL;
206
207         /* We only care about frames *to* the channel */
208         if (!f || (event != AST_FRAMEHOOK_EVENT_WRITE)) {
209                 return f;
210         }
211
212         /* If the completed flag hasn't been raised, skip this pass. */
213         if (!progress->transfer_data->completed) {
214                 return f;
215         }
216
217         /* Determine the state of the REFER based on the control frames (or voice frames) passing */
218         if (f->frametype == AST_FRAME_VOICE && !progress->subclass) {
219                 /* Media is passing without progress, this means the call has been answered */
220                 notification = refer_progress_notification_alloc(progress, 200, PJSIP_EVSUB_STATE_TERMINATED);
221         } else if (f->frametype == AST_FRAME_CONTROL) {
222                 /* Based on the control frame being written we can send a NOTIFY advising of the progress */
223                 if ((f->subclass.integer == AST_CONTROL_RING) || (f->subclass.integer == AST_CONTROL_RINGING)) {
224                         progress->subclass = f->subclass.integer;
225                         notification = refer_progress_notification_alloc(progress, 180, PJSIP_EVSUB_STATE_ACTIVE);
226                 } else if (f->subclass.integer == AST_CONTROL_BUSY) {
227                         progress->subclass = f->subclass.integer;
228                         notification = refer_progress_notification_alloc(progress, 486, PJSIP_EVSUB_STATE_TERMINATED);
229                 } else if (f->subclass.integer == AST_CONTROL_CONGESTION) {
230                         progress->subclass = f->subclass.integer;
231                         notification = refer_progress_notification_alloc(progress, 503, PJSIP_EVSUB_STATE_TERMINATED);
232                 } else if (f->subclass.integer == AST_CONTROL_PROGRESS) {
233                         progress->subclass = f->subclass.integer;
234                         notification = refer_progress_notification_alloc(progress, 183, PJSIP_EVSUB_STATE_ACTIVE);
235                 } else if (f->subclass.integer == AST_CONTROL_PROCEEDING) {
236                         progress->subclass = f->subclass.integer;
237                         notification = refer_progress_notification_alloc(progress, 100, PJSIP_EVSUB_STATE_ACTIVE);
238                 } else if (f->subclass.integer == AST_CONTROL_ANSWER) {
239                         progress->subclass = f->subclass.integer;
240                         notification = refer_progress_notification_alloc(progress, 200, PJSIP_EVSUB_STATE_TERMINATED);
241                 }
242         }
243
244         /* If a notification is due to be sent push it to the thread pool */
245         if (notification) {
246                 /* If the subscription is being terminated we don't need the frame hook any longer */
247                 if (notification->state == PJSIP_EVSUB_STATE_TERMINATED) {
248                         ast_debug(3, "Detaching REFER progress monitoring hook from '%s' as subscription is being terminated\n",
249                                 ast_channel_name(chan));
250                         ast_framehook_detach(chan, progress->framehook);
251                 }
252
253                 if (ast_sip_push_task(progress->serializer, refer_progress_notify, notification)) {
254                         ao2_cleanup(notification);
255                 }
256         }
257
258         return f;
259 }
260
261 /*! \brief Destroy callback for monitoring framehook */
262 static void refer_progress_framehook_destroy(void *data)
263 {
264         struct refer_progress *progress = data;
265         struct refer_progress_notification *notification = refer_progress_notification_alloc(progress, 503, PJSIP_EVSUB_STATE_TERMINATED);
266
267         if (notification && ast_sip_push_task(progress->serializer, refer_progress_notify, notification)) {
268                 ao2_cleanup(notification);
269         }
270
271         if (progress->bridge_sub) {
272                 progress->bridge_sub = stasis_unsubscribe(progress->bridge_sub);
273         }
274
275         ao2_cleanup(progress);
276 }
277
278 /*! \brief Serialized callback for subscription termination */
279 static int refer_progress_terminate(void *data)
280 {
281         struct refer_progress *progress = data;
282
283         /* The subscription is no longer valid */
284         progress->sub = NULL;
285
286         return 0;
287 }
288
289 /*! \brief Callback for REFER subscription state changes */
290 static void refer_progress_on_evsub_state(pjsip_evsub *sub, pjsip_event *event)
291 {
292         struct refer_progress *progress = pjsip_evsub_get_mod_data(sub, refer_progress_module.id);
293
294         /* If being destroyed queue it up to the serializer */
295         if (progress && (pjsip_evsub_get_state(sub) == PJSIP_EVSUB_STATE_TERMINATED)) {
296                 /* To prevent a deadlock race condition we unlock the dialog so other serialized tasks can execute */
297                 ast_debug(3, "Subscription '%p' has been remotely terminated, waiting for other tasks to complete on progress monitor '%p'\n",
298                         sub, progress);
299
300                 /* It's possible that a task is waiting to remove us already, so bump the refcount of progress so it doesn't get destroyed */
301                 ao2_ref(progress, +1);
302                 pjsip_dlg_dec_lock(progress->dlg);
303                 ast_sip_push_task_synchronous(progress->serializer, refer_progress_terminate, progress);
304                 pjsip_dlg_inc_lock(progress->dlg);
305                 ao2_ref(progress, -1);
306
307                 ast_debug(3, "Subscription '%p' removed from progress monitor '%p'\n", sub, progress);
308
309                 /* Since it was unlocked it is possible for this to have been removed already, so check again */
310                 if (pjsip_evsub_get_mod_data(sub, refer_progress_module.id)) {
311                         pjsip_evsub_set_mod_data(sub, refer_progress_module.id, NULL);
312                         ao2_cleanup(progress);
313                 }
314         }
315 }
316
317 /*! \brief Callback structure for subscription */
318 static pjsip_evsub_user refer_progress_evsub_cb = {
319         .on_evsub_state = refer_progress_on_evsub_state,
320 };
321
322 /*! \brief Destructor for REFER progress sutrcture */
323 static void refer_progress_destroy(void *obj)
324 {
325         struct refer_progress *progress = obj;
326
327         if (progress->bridge_sub) {
328                 progress->bridge_sub = stasis_unsubscribe(progress->bridge_sub);
329         }
330
331         ao2_cleanup(progress->transfer_data);
332
333         ast_free(progress->transferee);
334         ast_taskprocessor_unreference(progress->serializer);
335 }
336
337 /*! \brief Internal helper function which sets up a refer progress structure if needed */
338 static int refer_progress_alloc(struct ast_sip_session *session, pjsip_rx_data *rdata, struct refer_progress **progress)
339 {
340         const pj_str_t str_refer_sub = { "Refer-Sub", 9 };
341         pjsip_generic_string_hdr *refer_sub = NULL;
342         const pj_str_t str_true = { "true", 4 };
343         pjsip_tx_data *tdata;
344         pjsip_hdr hdr_list;
345
346         *progress = NULL;
347
348         /* Grab the optional Refer-Sub header, it can be used to suppress the implicit subscription */
349         refer_sub = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_refer_sub, NULL);
350         if ((refer_sub && pj_strnicmp(&refer_sub->hvalue, &str_true, 4))) {
351                 return 0;
352         }
353
354         if (!(*progress = ao2_alloc(sizeof(struct refer_progress), refer_progress_destroy))) {
355                 return -1;
356         }
357
358         ast_debug(3, "Created progress monitor '%p' for transfer occurring from channel '%s' and endpoint '%s'\n",
359                 progress, ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
360
361         (*progress)->framehook = -1;
362
363         /* To prevent a potential deadlock we need the dialog so we can lock/unlock */
364         (*progress)->dlg = session->inv_session->dlg;
365
366         if (!((*progress)->serializer = ast_sip_create_serializer())) {
367                 goto error;
368         }
369
370         /* Create the implicit subscription for monitoring of this transfer */
371         if (pjsip_xfer_create_uas(session->inv_session->dlg, &refer_progress_evsub_cb, rdata, &(*progress)->sub) != PJ_SUCCESS) {
372                 goto error;
373         }
374
375         /* Associate the REFER progress structure with the subscription */
376         ao2_ref(*progress, +1);
377         pjsip_evsub_set_mod_data((*progress)->sub, refer_progress_module.id, *progress);
378
379         pj_list_init(&hdr_list);
380         if (refer_sub) {
381                 pjsip_hdr *hdr = (pjsip_hdr*)pjsip_generic_string_hdr_create(session->inv_session->dlg->pool, &str_refer_sub, &str_true);
382
383                 pj_list_push_back(&hdr_list, hdr);
384         }
385
386         /* Accept the REFER request */
387         ast_debug(3, "Accepting REFER request for progress monitor '%p'\n", *progress);
388         pjsip_xfer_accept((*progress)->sub, rdata, 202, &hdr_list);
389
390         /* Send initial NOTIFY Request */
391         ast_debug(3, "Sending initial 100 Trying NOTIFY for progress monitor '%p'\n", *progress);
392         if (pjsip_xfer_notify((*progress)->sub, PJSIP_EVSUB_STATE_ACTIVE, 100, NULL, &tdata) == PJ_SUCCESS) {
393                 pjsip_xfer_send_request((*progress)->sub, tdata);
394         }
395
396         return 0;
397
398 error:
399         ao2_cleanup(*progress);
400         *progress = NULL;
401         return -1;
402 }
403
404 /*! \brief Structure for attended transfer task */
405 struct refer_attended {
406         /*! \brief Transferer session */
407         struct ast_sip_session *transferer;
408         /*! \brief Transferer channel */
409         struct ast_channel *transferer_chan;
410         /*! \brief Second transferer session */
411         struct ast_sip_session *transferer_second;
412         /*! \brief Optional refer progress structure */
413         struct refer_progress *progress;
414 };
415
416 /*! \brief Destructor for attended transfer task */
417 static void refer_attended_destroy(void *obj)
418 {
419         struct refer_attended *attended = obj;
420
421         ao2_cleanup(attended->transferer);
422         ast_channel_cleanup(attended->transferer_chan);
423         ao2_cleanup(attended->transferer_second);
424         ao2_cleanup(attended->progress);
425 }
426
427 /*! \brief Allocator for attended transfer task */
428 static struct refer_attended *refer_attended_alloc(struct ast_sip_session *transferer,
429         struct ast_sip_session *transferer_second,
430         struct refer_progress *progress)
431 {
432         struct refer_attended *attended;
433
434         attended = ao2_alloc_options(sizeof(*attended), refer_attended_destroy,
435                 AO2_ALLOC_OPT_LOCK_NOLOCK);
436         if (!attended) {
437                 return NULL;
438         }
439
440         ao2_ref(transferer, +1);
441         attended->transferer = transferer;
442         ast_channel_ref(transferer->channel);
443         attended->transferer_chan = transferer->channel;
444         ao2_ref(transferer_second, +1);
445         attended->transferer_second = transferer_second;
446
447         if (progress) {
448                 ao2_ref(progress, +1);
449                 attended->progress = progress;
450         }
451
452         return attended;
453 }
454
455 /*! \brief Task for attended transfer */
456 static int refer_attended(void *data)
457 {
458         RAII_VAR(struct refer_attended *, attended, data, ao2_cleanup);
459         int response = 0;
460
461         if (!attended->transferer_second->channel) {
462                 return -1;
463         }
464
465         ast_debug(3, "Performing a REFER attended transfer - Transferer #1: %s Transferer #2: %s\n",
466                 ast_channel_name(attended->transferer_chan), ast_channel_name(attended->transferer_second->channel));
467
468         switch (ast_bridge_transfer_attended(attended->transferer_chan, attended->transferer_second->channel)) {
469         case AST_BRIDGE_TRANSFER_INVALID:
470                 response = 400;
471                 break;
472         case AST_BRIDGE_TRANSFER_NOT_PERMITTED:
473                 response = 403;
474                 break;
475         case AST_BRIDGE_TRANSFER_FAIL:
476                 response = 500;
477                 break;
478         case AST_BRIDGE_TRANSFER_SUCCESS:
479                 response = 200;
480                 ast_sip_session_defer_termination(attended->transferer);
481                 break;
482         }
483
484         ast_debug(3, "Final response for REFER attended transfer - Transferer #1: %s Transferer #2: %s is '%d'\n",
485                 ast_channel_name(attended->transferer_chan), ast_channel_name(attended->transferer_second->channel), response);
486
487         if (attended->progress && response) {
488                 struct refer_progress_notification *notification = refer_progress_notification_alloc(attended->progress, response, PJSIP_EVSUB_STATE_TERMINATED);
489
490                 if (notification) {
491                         refer_progress_notify(notification);
492                 }
493         }
494
495         return 0;
496 }
497
498 /*! \brief Structure for blind transfer callback details */
499 struct refer_blind {
500         /*! \brief Context being used for transfer */
501         const char *context;
502         /*! \brief Optional progress structure */
503         struct refer_progress *progress;
504         /*! \brief REFER message */
505         pjsip_rx_data *rdata;
506         /*! \brief Optional Replaces header */
507         pjsip_replaces_hdr *replaces;
508         /*! \brief Optional Refer-To header */
509         pjsip_sip_uri *refer_to;
510 };
511
512 /*! \brief Blind transfer callback function */
513 static void refer_blind_callback(struct ast_channel *chan, struct transfer_channel_data *user_data_wrapper,
514         enum ast_transfer_type transfer_type)
515 {
516         struct refer_blind *refer = user_data_wrapper->data;
517         pjsip_generic_string_hdr *referred_by;
518
519         static const pj_str_t str_referred_by = { "Referred-By", 11 };
520
521         pbx_builtin_setvar_helper(chan, "SIPTRANSFER", "yes");
522
523         /* If progress monitoring is being done attach a frame hook so we can monitor it */
524         if (refer->progress) {
525                 struct ast_framehook_interface hook = {
526                         .version = AST_FRAMEHOOK_INTERFACE_VERSION,
527                         .event_cb = refer_progress_framehook,
528                         .destroy_cb = refer_progress_framehook_destroy,
529                         .data = refer->progress,
530                         .disable_inheritance = 1,
531                 };
532
533                 refer->progress->transferee = ast_strdup(ast_channel_uniqueid(chan));
534                 if (!refer->progress->transferee) {
535                         struct refer_progress_notification *notification = refer_progress_notification_alloc(refer->progress, 200,
536                                 PJSIP_EVSUB_STATE_TERMINATED);
537
538                         ast_log(LOG_WARNING, "Could not copy channel name '%s' during transfer - assuming success\n",
539                                 ast_channel_name(chan));
540
541                         if (notification) {
542                                 refer_progress_notify(notification);
543                         }
544                 }
545
546                 /* Progress needs a reference to the transfer_channel_data so that it can track the completed status of the transfer */
547                 ao2_ref(user_data_wrapper, +1);
548                 refer->progress->transfer_data = user_data_wrapper;
549
550                 /* We need to bump the reference count up on the progress structure since it is in the frame hook now */
551                 ao2_ref(refer->progress, +1);
552
553                 /* If we can't attach a frame hook for whatever reason send a notification of success immediately */
554                 if ((refer->progress->framehook = ast_framehook_attach(chan, &hook)) < 0) {
555                         struct refer_progress_notification *notification = refer_progress_notification_alloc(refer->progress, 200,
556                                 PJSIP_EVSUB_STATE_TERMINATED);
557
558                         ast_log(LOG_WARNING, "Could not attach REFER transfer progress monitoring hook to channel '%s' - assuming success\n",
559                                 ast_channel_name(chan));
560
561                         if (notification) {
562                                 refer_progress_notify(notification);
563                         }
564
565                         ao2_cleanup(refer->progress);
566                 }
567
568                 /* We need to bump the reference count for the stasis subscription */
569                 ao2_ref(refer->progress, +1);
570                 /* We also will need to detect if the transferee enters a bridge. This is currently the only reliable way to
571                  * detect if the transfer target has answered the call
572                  */
573                 refer->progress->bridge_sub = stasis_subscribe_pool(ast_bridge_topic_all(), refer_progress_bridge, refer->progress);
574                 if (!refer->progress->bridge_sub) {
575                         struct refer_progress_notification *notification = refer_progress_notification_alloc(refer->progress, 200,
576                                 PJSIP_EVSUB_STATE_TERMINATED);
577
578                         ast_log(LOG_WARNING, "Could not create bridge stasis subscription for monitoring progress on transfer of channel '%s' - assuming success\n",
579                                         ast_channel_name(chan));
580
581                         if (notification) {
582                                 refer_progress_notify(notification);
583                         }
584
585                         ast_framehook_detach(chan, refer->progress->framehook);
586
587                         ao2_cleanup(refer->progress);
588                 }
589         }
590
591         pbx_builtin_setvar_helper(chan, "SIPREFERRINGCONTEXT", S_OR(refer->context, NULL));
592
593         referred_by = pjsip_msg_find_hdr_by_name(refer->rdata->msg_info.msg,
594                 &str_referred_by, NULL);
595         if (referred_by) {
596                 size_t uri_size = pj_strlen(&referred_by->hvalue) + 1;
597                 char *uri = ast_alloca(uri_size);
598
599                 ast_copy_pj_str(uri, &referred_by->hvalue, uri_size);
600                 pbx_builtin_setvar_helper(chan, "__SIPREFERREDBYHDR", S_OR(uri, NULL));
601         } else {
602                 pbx_builtin_setvar_helper(chan, "SIPREFERREDBYHDR", NULL);
603         }
604
605         if (refer->replaces) {
606                 char replaces[512];
607                 char *replaces_val = NULL;
608                 int len;
609
610                 len = pjsip_hdr_print_on(refer->replaces, replaces, sizeof(replaces) - 1);
611                 if (len != -1) {
612                         /* pjsip_hdr_print_on does not NULL terminate the buffer */
613                         replaces[len] = '\0';
614                         replaces_val = replaces + sizeof("Replaces:");
615                 }
616                 pbx_builtin_setvar_helper(chan, "__SIPREPLACESHDR", replaces_val);
617         } else {
618                 pbx_builtin_setvar_helper(chan, "SIPREPLACESHDR", NULL);
619         }
620
621         if (refer->refer_to) {
622                 char refer_to[PJSIP_MAX_URL_SIZE];
623
624                 pjsip_uri_print(PJSIP_URI_IN_REQ_URI, refer->refer_to, refer_to, sizeof(refer_to));
625                 pbx_builtin_setvar_helper(chan, "SIPREFERTOHDR", S_OR(refer_to, NULL));
626         } else {
627                 pbx_builtin_setvar_helper(chan, "SIPREFERTOHDR", NULL);
628         }
629 }
630
631 /*!
632  * \internal
633  * \brief Set the passed in context variable to the determined transfer context.
634  * \since 13.3.0
635  *
636  * \param context Set to the determined transfer context.
637  * \param session INVITE dialog SIP session.
638  */
639 #define DETERMINE_TRANSFER_CONTEXT(context, session)                                                                    \
640         do {                                                                                                                                                            \
641                 ast_channel_lock((session)->channel);                                                                                   \
642                 context = pbx_builtin_getvar_helper((session)->channel, "TRANSFER_CONTEXT");    \
643                 if (ast_strlen_zero(context)) {                                                                                                 \
644                         context = (session)->endpoint->context;                                                                         \
645                 } else {                                                                                                                                                \
646                         context = ast_strdupa(context);                                                                                         \
647                 }                                                                                                                                                               \
648                 ast_channel_unlock((session)->channel);                                                                                 \
649         } while (0)                                                                                                                                                     \
650
651 static int refer_incoming_attended_request(struct ast_sip_session *session, pjsip_rx_data *rdata, pjsip_sip_uri *target_uri,
652         pjsip_param *replaces_param, struct refer_progress *progress)
653 {
654         const pj_str_t str_replaces = { "Replaces", 8 };
655         pj_str_t replaces_content;
656         pjsip_replaces_hdr *replaces;
657         int parsed_len;
658         pjsip_dialog *dlg;
659
660         pj_strdup_with_null(rdata->tp_info.pool, &replaces_content, &replaces_param->value);
661
662         /* Parsing the parameter as a Replaces header easily grabs the needed information */
663         if (!(replaces = pjsip_parse_hdr(rdata->tp_info.pool, &str_replaces, replaces_content.ptr,
664                 pj_strlen(&replaces_content), &parsed_len))) {
665                 ast_log(LOG_ERROR, "Received REFER request on channel '%s' from endpoint '%s' with invalid Replaces header, rejecting\n",
666                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
667                 return 400;
668         }
669
670         /* See if the dialog is local, or remote */
671         if ((dlg = pjsip_ua_find_dialog(&replaces->call_id, &replaces->to_tag, &replaces->from_tag, PJ_TRUE))) {
672                 RAII_VAR(struct ast_sip_session *, other_session, ast_sip_dialog_get_session(dlg), ao2_cleanup);
673                 struct refer_attended *attended;
674
675                 pjsip_dlg_dec_lock(dlg);
676
677                 if (!other_session) {
678                         ast_debug(3, "Received REFER request on channel '%s' from endpoint '%s' for local dialog but no session exists on it\n",
679                                 ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
680                         return 603;
681                 }
682
683                 /* We defer actually doing the attended transfer to the other session so no deadlock can occur */
684                 if (!(attended = refer_attended_alloc(session, other_session, progress))) {
685                         ast_log(LOG_ERROR, "Received REFER request on channel '%s' from endpoint '%s' for local dialog but could not allocate structure to complete, rejecting\n",
686                                 ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
687                         return 500;
688                 }
689
690                 /* Push it to the other session, which will have both channels with minimal locking */
691                 if (ast_sip_push_task(other_session->serializer, refer_attended, attended)) {
692                         ao2_cleanup(attended);
693                         return 500;
694                 }
695
696                 ast_debug(3, "Attended transfer from '%s' pushed to second channel serializer\n",
697                         ast_channel_name(session->channel));
698
699                 return 200;
700         } else {
701                 const char *context;
702                 struct refer_blind refer = { 0, };
703
704                 DETERMINE_TRANSFER_CONTEXT(context, session);
705
706                 if (!ast_exists_extension(NULL, context, "external_replaces", 1, NULL)) {
707                         ast_log(LOG_ERROR, "Received REFER for remote session on channel '%s' from endpoint '%s' but 'external_replaces' extension not found in context %s\n",
708                                 ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint), context);
709                         return 404;
710                 }
711
712                 refer.context = context;
713                 refer.progress = progress;
714                 refer.rdata = rdata;
715                 refer.replaces = replaces;
716                 refer.refer_to = target_uri;
717
718                 switch (ast_bridge_transfer_blind(1, session->channel, "external_replaces", context, refer_blind_callback, &refer)) {
719                 case AST_BRIDGE_TRANSFER_INVALID:
720                         return 400;
721                 case AST_BRIDGE_TRANSFER_NOT_PERMITTED:
722                         return 403;
723                 case AST_BRIDGE_TRANSFER_FAIL:
724                         return 500;
725                 case AST_BRIDGE_TRANSFER_SUCCESS:
726                         ast_sip_session_defer_termination(session);
727                         return 200;
728                 }
729
730                 return 503;
731         }
732 }
733
734 static int refer_incoming_blind_request(struct ast_sip_session *session, pjsip_rx_data *rdata, pjsip_sip_uri *target,
735         struct refer_progress *progress)
736 {
737         const char *context;
738         char exten[AST_MAX_EXTENSION];
739         struct refer_blind refer = { 0, };
740
741         /* If no explicit transfer context has been provided use their configured context */
742         DETERMINE_TRANSFER_CONTEXT(context, session);
743
744         /* Using the user portion of the target URI see if it exists as a valid extension in their context */
745         ast_copy_pj_str(exten, &target->user, sizeof(exten));
746         if (!ast_exists_extension(NULL, context, exten, 1, NULL)) {
747                 ast_log(LOG_ERROR, "Channel '%s' from endpoint '%s' attempted blind transfer to '%s@%s' but target does not exist\n",
748                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint), exten, context);
749                 return 404;
750         }
751
752         refer.context = context;
753         refer.progress = progress;
754         refer.rdata = rdata;
755         refer.refer_to = target;
756
757         switch (ast_bridge_transfer_blind(1, session->channel, exten, context, refer_blind_callback, &refer)) {
758         case AST_BRIDGE_TRANSFER_INVALID:
759                 return 400;
760         case AST_BRIDGE_TRANSFER_NOT_PERMITTED:
761                 return 403;
762         case AST_BRIDGE_TRANSFER_FAIL:
763                 return 500;
764         case AST_BRIDGE_TRANSFER_SUCCESS:
765                 ast_sip_session_defer_termination(session);
766                 return 200;
767         }
768
769         return 503;
770 }
771
772 /*! \brief Structure used to retrieve channel from another session */
773 struct invite_replaces {
774         /*! \brief Session we want the channel from */
775         struct ast_sip_session *session;
776         /*! \brief Channel from the session (with reference) */
777         struct ast_channel *channel;
778         /*! \brief Bridge the channel is in */
779         struct ast_bridge *bridge;
780 };
781
782 /*! \brief Task for invite replaces */
783 static int invite_replaces(void *data)
784 {
785         struct invite_replaces *invite = data;
786
787         if (!invite->session->channel) {
788                 return -1;
789         }
790
791         ast_channel_ref(invite->session->channel);
792         invite->channel = invite->session->channel;
793
794         ast_channel_lock(invite->channel);
795         invite->bridge = ast_channel_get_bridge(invite->channel);
796         ast_channel_unlock(invite->channel);
797
798         return 0;
799 }
800
801 static int refer_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
802 {
803         pjsip_dialog *other_dlg = NULL;
804         pjsip_tx_data *packet;
805         int response = 0;
806         RAII_VAR(struct ast_sip_session *, other_session, NULL, ao2_cleanup);
807         struct invite_replaces invite;
808
809         /* If a Replaces header is present make sure it is valid */
810         if (pjsip_replaces_verify_request(rdata, &other_dlg, PJ_TRUE, &packet) != PJ_SUCCESS) {
811                 response = packet->msg->line.status.code;
812                 ast_assert(response != 0);
813                 pjsip_tx_data_dec_ref(packet);
814                 goto inv_replace_failed;
815         }
816
817         /* If no other dialog exists then this INVITE request does not have a Replaces header */
818         if (!other_dlg) {
819                 return 0;
820         }
821
822         other_session = ast_sip_dialog_get_session(other_dlg);
823         pjsip_dlg_dec_lock(other_dlg);
824
825         /* Don't accept an in-dialog INVITE with Replaces as it does not make much sense */
826         if (session->inv_session->dlg->state == PJSIP_DIALOG_STATE_ESTABLISHED) {
827                 response = 488;
828                 goto inv_replace_failed;
829         }
830
831         if (!other_session) {
832                 ast_debug(3, "INVITE with Replaces received on channel '%s' from endpoint '%s', but requested session does not exist\n",
833                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
834                 response = 481;
835                 goto inv_replace_failed;
836         }
837
838         invite.session = other_session;
839
840         if (ast_sip_push_task_synchronous(other_session->serializer, invite_replaces, &invite)) {
841                 response = 481;
842                 goto inv_replace_failed;
843         }
844
845         ast_channel_lock(session->channel);
846         ast_setstate(session->channel, AST_STATE_RING);
847         ast_channel_unlock(session->channel);
848         ast_raw_answer(session->channel);
849
850         ast_debug(3, "INVITE with Replaces being attempted.  '%s' --> '%s'\n",
851                 ast_channel_name(session->channel), ast_channel_name(invite.channel));
852
853         if (!invite.bridge) {
854                 struct ast_channel *chan = session->channel;
855
856                 /*
857                  * This will use a synchronous task but we aren't operating in
858                  * the serializer at this point in time, so it won't deadlock.
859                  */
860                 if (!ast_channel_move(invite.channel, chan)) {
861                         /*
862                          * We can't directly use session->channel because ast_channel_move()
863                          * does a masquerade which changes session->channel to a different
864                          * channel.  To ensure we work on the right channel we store a
865                          * pointer locally before we begin so it remains valid.
866                          */
867                         ast_hangup(chan);
868                 } else {
869                         response = AST_CAUSE_FAILURE;
870                 }
871         } else {
872                 if (ast_bridge_impart(invite.bridge, session->channel, invite.channel, NULL,
873                         AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
874                         response = AST_CAUSE_FAILURE;
875                 }
876         }
877
878         ast_channel_unref(invite.channel);
879         ao2_cleanup(invite.bridge);
880
881         if (!response) {
882                 /*
883                  * On success we cannot use session->channel in the debug message.
884                  * This thread either no longer has a ref to session->channel or
885                  * session->channel is no longer the original channel.
886                  */
887                 ast_debug(3, "INVITE with Replaces successfully completed.\n");
888         } else {
889                 ast_debug(3, "INVITE with Replaces failed on channel '%s', hanging up with cause '%d'\n",
890                         ast_channel_name(session->channel), response);
891                 ast_channel_lock(session->channel);
892                 ast_channel_hangupcause_set(session->channel, response);
893                 ast_channel_unlock(session->channel);
894                 ast_hangup(session->channel);
895         }
896
897         return 1;
898
899 inv_replace_failed:
900         if (session->inv_session->dlg->state != PJSIP_DIALOG_STATE_ESTABLISHED) {
901                 ast_debug(3, "INVITE with Replaces failed on channel '%s', sending response of '%d'\n",
902                         ast_channel_name(session->channel), response);
903                 session->defer_terminate = 1;
904                 ast_hangup(session->channel);
905
906                 if (pjsip_inv_end_session(session->inv_session, response, NULL, &packet) == PJ_SUCCESS) {
907                         ast_sip_session_send_response(session, packet);
908                 }
909         } else {
910                 ast_debug(3, "INVITE with Replaces in-dialog on channel '%s', hanging up\n",
911                         ast_channel_name(session->channel));
912                 ast_queue_hangup(session->channel);
913         }
914
915         return 1;
916 }
917
918 static int refer_incoming_refer_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
919 {
920         pjsip_generic_string_hdr *refer_to;
921         char *uri;
922         pjsip_uri *target;
923         pjsip_sip_uri *target_uri;
924         RAII_VAR(struct refer_progress *, progress, NULL, ao2_cleanup);
925         pjsip_param *replaces;
926         int response;
927
928         static const pj_str_t str_refer_to = { "Refer-To", 8 };
929         static const pj_str_t str_replaces = { "Replaces", 8 };
930
931         if (!session->channel) {
932                 /* No channel to refer.  Likely because the call was just hung up. */
933                 pjsip_dlg_respond(session->inv_session->dlg, rdata, 404, NULL, NULL, NULL);
934                 ast_debug(3, "Received a REFER on a session with no channel from endpoint '%s'.\n",
935                         ast_sorcery_object_get_id(session->endpoint));
936                 return 0;
937         }
938
939         if (!session->endpoint->allowtransfer) {
940                 pjsip_dlg_respond(session->inv_session->dlg, rdata, 603, NULL, NULL, NULL);
941                 ast_log(LOG_WARNING, "Endpoint %s transfer attempt blocked due to configuration\n",
942                                 ast_sorcery_object_get_id(session->endpoint));
943                 return 0;
944         }
945
946         /* A Refer-To header is required */
947         refer_to = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &str_refer_to, NULL);
948         if (!refer_to) {
949                 pjsip_dlg_respond(session->inv_session->dlg, rdata, 400, NULL, NULL, NULL);
950                 ast_debug(3, "Received a REFER without Refer-To on channel '%s' from endpoint '%s'\n",
951                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
952                 return 0;
953         }
954
955         /* This is done on purpose (and is safe) - it's done so that the value passed to
956          * pjsip_parse_uri is NULL terminated as required
957          */
958         uri = refer_to->hvalue.ptr;
959         uri[refer_to->hvalue.slen] = '\0';
960
961         target = pjsip_parse_uri(rdata->tp_info.pool, refer_to->hvalue.ptr, refer_to->hvalue.slen, 0);
962         if (!target
963                 || (!PJSIP_URI_SCHEME_IS_SIP(target)
964                         && !PJSIP_URI_SCHEME_IS_SIPS(target))) {
965                 size_t uri_size = pj_strlen(&refer_to->hvalue) + 1;
966                 char *uri = ast_alloca(uri_size);
967
968                 ast_copy_pj_str(uri, &refer_to->hvalue, uri_size);
969
970                 pjsip_dlg_respond(session->inv_session->dlg, rdata, 400, NULL, NULL, NULL);
971                 ast_debug(3, "Received a REFER without a parseable Refer-To ('%s') on channel '%s' from endpoint '%s'\n",
972                         uri, ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
973                 return 0;
974         }
975         target_uri = pjsip_uri_get_uri(target);
976
977         /* Set up REFER progress subscription if requested/possible */
978         if (refer_progress_alloc(session, rdata, &progress)) {
979                 pjsip_dlg_respond(session->inv_session->dlg, rdata, 500, NULL, NULL, NULL);
980                 ast_debug(3, "Could not set up subscription for REFER on channel '%s' from endpoint '%s'\n",
981                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint));
982                 return 0;
983         }
984
985         /* Determine if this is an attended or blind transfer */
986         if ((replaces = pjsip_param_find(&target_uri->header_param, &str_replaces)) ||
987                 (replaces = pjsip_param_find(&target_uri->other_param, &str_replaces))) {
988                 response = refer_incoming_attended_request(session, rdata, target_uri, replaces, progress);
989         } else {
990                 response = refer_incoming_blind_request(session, rdata, target_uri, progress);
991         }
992
993         if (!progress) {
994                 /* The transferer has requested no subscription, so send a final response immediately */
995                 pjsip_tx_data *tdata;
996                 const pj_str_t str_refer_sub = { "Refer-Sub", 9 };
997                 const pj_str_t str_false = { "false", 5 };
998                 pjsip_hdr *hdr;
999
1000                 ast_debug(3, "Progress monitoring not requested for REFER on channel '%s' from endpoint '%s', sending immediate response of '%d'\n",
1001                         ast_channel_name(session->channel), ast_sorcery_object_get_id(session->endpoint), response);
1002
1003                 if (pjsip_dlg_create_response(session->inv_session->dlg, rdata, response, NULL, &tdata) != PJ_SUCCESS) {
1004                         pjsip_dlg_respond(session->inv_session->dlg, rdata, response, NULL, NULL, NULL);
1005                         return 0;
1006                 }
1007
1008                 hdr = (pjsip_hdr*)pjsip_generic_string_hdr_create(tdata->pool, &str_refer_sub, &str_false);
1009                 pjsip_msg_add_hdr(tdata->msg, hdr);
1010
1011                 pjsip_dlg_send_response(session->inv_session->dlg, pjsip_rdata_get_tsx(rdata), tdata);
1012         } else if (response != 200) {
1013                 /* Since this failed we can send a final NOTIFY now and terminate the subscription */
1014                 struct refer_progress_notification *notification = refer_progress_notification_alloc(progress, response, PJSIP_EVSUB_STATE_TERMINATED);
1015
1016                 if (notification) {
1017                         /* The refer_progress_notify function will call ao2_cleanup on this for us */
1018                         refer_progress_notify(notification);
1019                 }
1020         }
1021
1022         return 0;
1023 }
1024
1025 static int refer_incoming_request(struct ast_sip_session *session, pjsip_rx_data *rdata)
1026 {
1027         if (!pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, pjsip_get_refer_method())) {
1028                 return refer_incoming_refer_request(session, rdata);
1029         } else if (!pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_invite_method)) {
1030                 return refer_incoming_invite_request(session, rdata);
1031         } else {
1032                 return 0;
1033         }
1034 }
1035
1036 static void refer_outgoing_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
1037 {
1038         const char *hdr;
1039
1040         if (pjsip_method_cmp(&tdata->msg->line.req.method, &pjsip_invite_method)
1041                 || !session->channel
1042                 || session->inv_session->state != PJSIP_INV_STATE_NULL) {
1043                 return;
1044         }
1045
1046         ast_channel_lock(session->channel);
1047         hdr = pbx_builtin_getvar_helper(session->channel, "SIPREPLACESHDR");
1048         if (!ast_strlen_zero(hdr)) {
1049                 ast_sip_add_header(tdata, "Replaces", hdr);
1050         }
1051
1052         hdr = pbx_builtin_getvar_helper(session->channel, "SIPREFERREDBYHDR");
1053         if (!ast_strlen_zero(hdr)) {
1054                 ast_sip_add_header(tdata, "Referred-By", hdr);
1055         }
1056         ast_channel_unlock(session->channel);
1057 }
1058
1059 static struct ast_sip_session_supplement refer_supplement = {
1060         .priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL + 1,
1061         .incoming_request = refer_incoming_request,
1062         .outgoing_request = refer_outgoing_request,
1063 };
1064
1065 static int load_module(void)
1066 {
1067         const pj_str_t str_norefersub = { "norefersub", 10 };
1068
1069         CHECK_PJSIP_SESSION_MODULE_LOADED();
1070
1071         pjsip_replaces_init_module(ast_sip_get_pjsip_endpoint());
1072         pjsip_xfer_init_module(ast_sip_get_pjsip_endpoint());
1073         pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_SUPPORTED, NULL, 1, &str_norefersub);
1074
1075         ast_sip_register_service(&refer_progress_module);
1076         ast_sip_session_register_supplement(&refer_supplement);
1077
1078         return AST_MODULE_LOAD_SUCCESS;
1079 }
1080
1081 static int unload_module(void)
1082 {
1083         ast_sip_session_unregister_supplement(&refer_supplement);
1084         ast_sip_unregister_service(&refer_progress_module);
1085
1086         return 0;
1087 }
1088
1089 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Blind and Attended Transfer Support",
1090                 .support_level = AST_MODULE_SUPPORT_CORE,
1091                 .load = load_module,
1092                 .unload = unload_module,
1093                 .load_pri = AST_MODPRI_APP_DEPEND,
1094                    );