bridge_basic.c: Update transfer diagnostic messages.
[asterisk/asterisk.git] / main / bridge_basic.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013 Digium, Inc.
5  *
6  * Richard Mudgett <rmudgett@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 /*!
20  * \file
21  * \brief Basic bridge class.  It is a subclass of struct ast_bridge.
22  *
23  * \author Richard Mudgett <rmudgett@digium.com>
24  *
25  * See Also:
26  * \arg \ref AstCREDITS
27  */
28
29
30 #include "asterisk.h"
31
32 #include "asterisk/channel.h"
33 #include "asterisk/utils.h"
34 #include "asterisk/linkedlists.h"
35 #include "asterisk/bridge.h"
36 #include "asterisk/bridge_internal.h"
37 #include "asterisk/bridge_basic.h"
38 #include "asterisk/bridge_after.h"
39 #include "asterisk/astobj2.h"
40 #include "asterisk/features_config.h"
41 #include "asterisk/pbx.h"
42 #include "asterisk/file.h"
43 #include "asterisk/app.h"
44 #include "asterisk/dial.h"
45 #include "asterisk/stasis_bridges.h"
46 #include "asterisk/stasis_channels.h"
47 #include "asterisk/features.h"
48 #include "asterisk/format_cache.h"
49 #include "asterisk/test.h"
50
51 #define NORMAL_FLAGS    (AST_BRIDGE_FLAG_DISSOLVE_HANGUP | AST_BRIDGE_FLAG_DISSOLVE_EMPTY \
52                         | AST_BRIDGE_FLAG_SMART)
53
54 #define TRANSFER_FLAGS AST_BRIDGE_FLAG_SMART
55
56 struct attended_transfer_properties;
57
58 enum bridge_basic_personality_type {
59         /*! Index for "normal" basic bridge personality */
60         BRIDGE_BASIC_PERSONALITY_NORMAL,
61         /*! Index for attended transfer basic bridge personality */
62         BRIDGE_BASIC_PERSONALITY_ATXFER,
63         /*! Indicates end of enum. Must always remain the last element */
64         BRIDGE_BASIC_PERSONALITY_END,
65 };
66
67 /*!
68  * \brief Change basic bridge personality
69  *
70  * Changing personalities allows for the bridge to remain in use but have
71  * properties such as its v_table and its flags change.
72  *
73  * \param bridge The bridge
74  * \param type The personality to change the bridge to
75  * \user_data Private data to attach to the personality.
76  */
77 static void bridge_basic_change_personality(struct ast_bridge *bridge,
78                 enum bridge_basic_personality_type type, void *user_data);
79
80 /* ------------------------------------------------------------------- */
81
82 static const struct ast_datastore_info dtmf_features_info = {
83         .type = "bridge-dtmf-features",
84         .destroy = ast_free_ptr,
85 };
86
87 /*!
88  * \internal
89  * \since 12.0.0
90  * \brief read a feature code character and set it on for the give feature_flags struct
91  *
92  * \param feature_flags flags being modifed
93  * \param feature feature code provided - should be an uppercase letter
94  *
95  * \retval 0 if the feature was set successfully
96  * \retval -1 failure because the requested feature code isn't handled by this function
97  */
98 static int set_feature_flag_from_char(struct ast_flags *feature_flags, char feature)
99 {
100         switch (feature) {
101         case 'T':
102                 ast_set_flag(feature_flags, AST_FEATURE_REDIRECT);
103                 return 0;
104         case 'K':
105                 ast_set_flag(feature_flags, AST_FEATURE_PARKCALL);
106                 return 0;
107         case 'H':
108                 ast_set_flag(feature_flags, AST_FEATURE_DISCONNECT);
109                 return 0;
110         case 'W':
111                 ast_set_flag(feature_flags, AST_FEATURE_AUTOMON);
112                 return 0;
113         case 'X':
114                 ast_set_flag(feature_flags, AST_FEATURE_AUTOMIXMON);
115                 return 0;
116         default:
117                 return -1;
118         }
119 }
120
121 /*!
122  * \internal
123  * \since 12.0.0
124  * \brief Write a features string to a string buffer based on the feature flags provided
125  *
126  * \param feature_flags pointer to the feature flags to write from.
127  * \param buffer pointer to a string buffer to write the features
128  * \param buffer_size size of the buffer provided (should be able to fit all feature codes)
129  *
130  * \retval 0 on successful write
131  * \retval -1 failure due to running out of buffer space
132  */
133 static int dtmf_features_flags_to_string(struct ast_flags *feature_flags, char *buffer, size_t buffer_size)
134 {
135         size_t buffer_expended = 0;
136         unsigned int cur_feature;
137         static const struct {
138                 char letter;
139                 unsigned int flag;
140         } associations[] = {
141                 { 'T', AST_FEATURE_REDIRECT },
142                 { 'K', AST_FEATURE_PARKCALL },
143                 { 'H', AST_FEATURE_DISCONNECT },
144                 { 'W', AST_FEATURE_AUTOMON },
145                 { 'X', AST_FEATURE_AUTOMIXMON },
146         };
147
148         for (cur_feature = 0; cur_feature < ARRAY_LEN(associations); cur_feature++) {
149                 if (ast_test_flag(feature_flags, associations[cur_feature].flag)) {
150                         if (buffer_expended == buffer_size - 1) {
151                                 buffer[buffer_expended] = '\0';
152                                 return -1;
153                         }
154                         buffer[buffer_expended++] = associations[cur_feature].letter;
155                 }
156         }
157
158         buffer[buffer_expended] = '\0';
159         return 0;
160 }
161
162 static int build_dtmf_features(struct ast_flags *flags, const char *features)
163 {
164         const char *feature;
165
166         char missing_features[strlen(features) + 1];
167         size_t number_of_missing_features = 0;
168
169         for (feature = features; *feature; feature++) {
170                 if (!isupper(*feature)) {
171                         ast_log(LOG_ERROR, "Features string '%s' rejected because it contains non-uppercase feature.\n", features);
172                         return -1;
173                 }
174
175                 if (set_feature_flag_from_char(flags, *feature)) {
176                         missing_features[number_of_missing_features++] = *feature;
177                 }
178         }
179
180         missing_features[number_of_missing_features] = '\0';
181
182         if (number_of_missing_features) {
183                 ast_log(LOG_WARNING, "Features '%s' from features string '%s' can not be applied.\n", missing_features, features);
184         }
185
186         return 0;
187 }
188
189 int ast_bridge_features_ds_set_string(struct ast_channel *chan, const char *features)
190 {
191         struct ast_flags flags = {0};
192
193         if (build_dtmf_features(&flags, features)) {
194                 return -1;
195         }
196
197         ast_channel_lock(chan);
198         if (ast_bridge_features_ds_set(chan, &flags)) {
199                 ast_channel_unlock(chan);
200                 ast_log(LOG_ERROR, "Failed to apply features datastore for '%s' to channel '%s'\n", features, ast_channel_name(chan));
201                 return -1;
202         }
203         ast_channel_unlock(chan);
204
205         return 0;
206 }
207
208 int ast_bridge_features_ds_get_string(struct ast_channel *chan, char *buffer, size_t buf_size)
209 {
210         struct ast_flags *channel_flags;
211         struct ast_flags held_copy;
212
213         ast_channel_lock(chan);
214         if (!(channel_flags = ast_bridge_features_ds_get(chan))) {
215                 ast_channel_unlock(chan);
216                 return -1;
217         }
218         held_copy = *channel_flags;
219         ast_channel_unlock(chan);
220
221         return dtmf_features_flags_to_string(&held_copy, buffer, buf_size);
222 }
223
224 static int bridge_features_ds_set_full(struct ast_channel *chan, struct ast_flags *flags, int replace)
225 {
226         struct ast_datastore *datastore;
227         struct ast_flags *ds_flags;
228
229         datastore = ast_channel_datastore_find(chan, &dtmf_features_info, NULL);
230         if (datastore) {
231                 ds_flags = datastore->data;
232                 if (replace) {
233                         *ds_flags = *flags;
234                 } else {
235                         flags->flags = flags->flags | ds_flags->flags;
236                         *ds_flags = *flags;
237                 }
238                 return 0;
239         }
240
241         datastore = ast_datastore_alloc(&dtmf_features_info, NULL);
242         if (!datastore) {
243                 return -1;
244         }
245
246         ds_flags = ast_malloc(sizeof(*ds_flags));
247         if (!ds_flags) {
248                 ast_datastore_free(datastore);
249                 return -1;
250         }
251
252         *ds_flags = *flags;
253         datastore->data = ds_flags;
254         ast_channel_datastore_add(chan, datastore);
255         return 0;
256 }
257
258 int ast_bridge_features_ds_set(struct ast_channel *chan, struct ast_flags *flags)
259 {
260         return bridge_features_ds_set_full(chan, flags, 1);
261 }
262
263 int ast_bridge_features_ds_append(struct ast_channel *chan, struct ast_flags *flags)
264 {
265         return bridge_features_ds_set_full(chan, flags, 0);
266 }
267
268 struct ast_flags *ast_bridge_features_ds_get(struct ast_channel *chan)
269 {
270         struct ast_datastore *datastore;
271
272         datastore = ast_channel_datastore_find(chan, &dtmf_features_info, NULL);
273         if (!datastore) {
274                 return NULL;
275         }
276         return datastore->data;
277 }
278
279 /*!
280  * \internal
281  * \brief Determine if we should dissolve the bridge from a hangup.
282  * \since 12.0.0
283  *
284  * \param bridge_channel Channel executing the feature
285  * \param hook_pvt Private data passed in when the hook was created
286  *
287  * \retval 0 Keep the callback hook.
288  * \retval -1 Remove the callback hook.
289  */
290 static int basic_hangup_hook(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
291 {
292         int bridge_count = 0;
293         struct ast_bridge_channel *iter;
294
295         ast_bridge_channel_lock_bridge(bridge_channel);
296         AST_LIST_TRAVERSE(&bridge_channel->bridge->channels, iter, entry) {
297                 if (iter != bridge_channel && iter->state == BRIDGE_CHANNEL_STATE_WAIT) {
298                         ++bridge_count;
299                 }
300         }
301         if (2 <= bridge_count) {
302                 /* Just allow this channel to leave the multi-party bridge. */
303                 ast_bridge_channel_leave_bridge(bridge_channel,
304                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, 0);
305         }
306         ast_bridge_unlock(bridge_channel->bridge);
307         return 0;
308 }
309
310 /*!
311  * \brief Details for specific basic bridge personalities
312  */
313 struct personality_details {
314         /*! The v_table to use for this personality */
315         struct ast_bridge_methods *v_table;
316         /*! Flags to set on this type of bridge */
317         unsigned int bridge_flags;
318         /*! User data for this personality. If used, must be an ao2 object */
319         void *pvt;
320         /*! Callback to be called when changing to the personality */
321         void (*on_personality_change)(struct ast_bridge *bridge);
322 };
323
324 /*!
325  * \brief structure that organizes different personalities for basic bridges.
326  */
327 struct bridge_basic_personality {
328         /*! The current bridge personality in use */
329         enum bridge_basic_personality_type current;
330         /*! Array of details for the types of bridge personalities supported */
331         struct personality_details details[BRIDGE_BASIC_PERSONALITY_END];
332 };
333
334 /*
335  * \internal
336  * \brief Get the extension for a given builtin feature.
337  *
338  * \param chan Get the feature extension for this channel.
339  * \param feature_name features.conf name of feature.
340  * \param buf Where to put the extension.
341  * \param len Length of the given extension buffer.
342  *
343  * \retval 0 success
344  * \retval non-zero failiure
345  */
346 static int builtin_feature_get_exten(struct ast_channel *chan, const char *feature_name, char *buf, size_t len)
347 {
348         SCOPED_CHANNELLOCK(lock, chan);
349
350         return ast_get_builtin_feature(chan, feature_name, buf, len);
351 }
352
353 /*!
354  * \internal
355  * \brief Helper to add a builtin DTMF feature hook to the features struct.
356  * \since 12.0.0
357  *
358  * \param features Bridge features to setup.
359  * \param chan Get features from this channel.
360  * \param flags Feature flags on the channel.
361  * \param feature_flag Feature flag to test.
362  * \param feature_name features.conf name of feature.
363  * \param feature_bridge Bridge feature enum to get hook callback.
364  *
365  * \retval 0 on success.
366  * \retval -1 on error.
367  */
368 static int builtin_features_helper(struct ast_bridge_features *features, struct ast_channel *chan,
369         struct ast_flags *flags, unsigned int feature_flag, const char *feature_name, enum ast_bridge_builtin_feature feature_bridge)
370 {
371         char dtmf[AST_FEATURE_MAX_LEN];
372         int res;
373
374         res = 0;
375         if (ast_test_flag(flags, feature_flag)
376                 && !builtin_feature_get_exten(chan, feature_name, dtmf, sizeof(dtmf))
377                 && !ast_strlen_zero(dtmf)) {
378                 res = ast_bridge_features_enable(features, feature_bridge, dtmf, NULL, NULL,
379                         AST_BRIDGE_HOOK_REMOVE_ON_PULL | AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE);
380                 if (res) {
381                         ast_log(LOG_ERROR, "Channel %s: Requested DTMF feature %s not available.\n",
382                                 ast_channel_name(chan), feature_name);
383                 }
384         }
385
386         return res;
387 }
388
389 /*!
390  * \internal
391  * \brief Setup bridge builtin features.
392  * \since 12.0.0
393  *
394  * \param features Bridge features to setup.
395  * \param chan Get features from this channel.
396  *
397  * \retval 0 on success.
398  * \retval -1 on error.
399  */
400 static int setup_bridge_features_builtin(struct ast_bridge_features *features, struct ast_channel *chan)
401 {
402         struct ast_flags *flags;
403         int res;
404
405         ast_channel_lock(chan);
406         flags = ast_bridge_features_ds_get(chan);
407         ast_channel_unlock(chan);
408         if (!flags) {
409                 return 0;
410         }
411
412         res = 0;
413         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_REDIRECT, "blindxfer", AST_BRIDGE_BUILTIN_BLINDTRANSFER);
414         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_REDIRECT, "atxfer", AST_BRIDGE_BUILTIN_ATTENDEDTRANSFER);
415         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_DISCONNECT, "disconnect", AST_BRIDGE_BUILTIN_HANGUP);
416         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_PARKCALL, "parkcall", AST_BRIDGE_BUILTIN_PARKCALL);
417         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_AUTOMON, "automon", AST_BRIDGE_BUILTIN_AUTOMON);
418         res |= builtin_features_helper(features, chan, flags, AST_FEATURE_AUTOMIXMON, "automixmon", AST_BRIDGE_BUILTIN_AUTOMIXMON);
419
420         return res ? -1 : 0;
421 }
422
423 struct dynamic_dtmf_hook_run {
424         /*! Offset into app_name[] where the channel name that activated the hook starts. */
425         int activated_offset;
426         /*! Offset into app_name[] where the dynamic feature name starts. */
427         int feature_offset;
428         /*! Offset into app_name[] where the MOH class name starts.  (zero if no MOH) */
429         int moh_offset;
430         /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
431         int app_args_offset;
432         /*! Application name to run. */
433         char app_name[0];
434 };
435
436 static void dynamic_dtmf_hook_callback(struct ast_bridge_channel *bridge_channel,
437         const void *payload, size_t payload_size)
438 {
439         struct ast_channel *chan = bridge_channel->chan;
440         const struct dynamic_dtmf_hook_run *run_data = payload;
441
442         pbx_builtin_setvar_helper(chan, "DYNAMIC_FEATURENAME",
443                 &run_data->app_name[run_data->feature_offset]);
444         pbx_builtin_setvar_helper(chan, "DYNAMIC_WHO_ACTIVATED",
445                 &run_data->app_name[run_data->activated_offset]);
446
447         ast_bridge_channel_run_app(bridge_channel, run_data->app_name,
448                 run_data->app_args_offset ? &run_data->app_name[run_data->app_args_offset] : NULL,
449                 run_data->moh_offset ? &run_data->app_name[run_data->moh_offset] : NULL);
450 }
451
452 struct dynamic_dtmf_hook_data {
453         /*! Which side of bridge to run app (AST_FEATURE_FLAG_ONSELF/AST_FEATURE_FLAG_ONPEER) */
454         unsigned int flags;
455         /*! Offset into app_name[] where the dynamic feature name starts. */
456         int feature_offset;
457         /*! Offset into app_name[] where the MOH class name starts.  (zero if no MOH) */
458         int moh_offset;
459         /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
460         int app_args_offset;
461         /*! Application name to run. */
462         char app_name[0];
463 };
464
465 /*!
466  * \internal
467  * \brief Activated dynamic DTMF feature hook.
468  * \since 12.0.0
469  *
470  * \param bridge_channel Channel executing the feature
471  * \param hook_pvt Private data passed in when the hook was created
472  *
473  * \retval 0 Keep the callback hook.
474  * \retval -1 Remove the callback hook.
475  */
476 static int dynamic_dtmf_hook_trip(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
477 {
478         struct dynamic_dtmf_hook_data *pvt = hook_pvt;
479         struct dynamic_dtmf_hook_run *run_data;
480         const char *activated_name;
481         size_t len_name;
482         size_t len_args;
483         size_t len_moh;
484         size_t len_feature;
485         size_t len_activated;
486         size_t len_data;
487
488         /* Determine lengths of things. */
489         len_name = strlen(pvt->app_name) + 1;
490         len_args = pvt->app_args_offset ? strlen(&pvt->app_name[pvt->app_args_offset]) + 1 : 0;
491         len_moh = pvt->moh_offset ? strlen(&pvt->app_name[pvt->moh_offset]) + 1 : 0;
492         len_feature = strlen(&pvt->app_name[pvt->feature_offset]) + 1;
493         ast_channel_lock(bridge_channel->chan);
494         activated_name = ast_strdupa(ast_channel_name(bridge_channel->chan));
495         ast_channel_unlock(bridge_channel->chan);
496         len_activated = strlen(activated_name) + 1;
497         len_data = sizeof(*run_data) + len_name + len_args + len_moh + len_feature + len_activated;
498
499         /* Fill in dynamic feature run hook data. */
500         run_data = ast_alloca(len_data);
501         run_data->app_args_offset = len_args ? len_name : 0;
502         run_data->moh_offset = len_moh ? len_name + len_args : 0;
503         run_data->feature_offset = len_name + len_args + len_moh;
504         run_data->activated_offset = len_name + len_args + len_moh + len_feature;
505         strcpy(run_data->app_name, pvt->app_name);/* Safe */
506         if (len_args) {
507                 strcpy(&run_data->app_name[run_data->app_args_offset],
508                         &pvt->app_name[pvt->app_args_offset]);/* Safe */
509         }
510         if (len_moh) {
511                 strcpy(&run_data->app_name[run_data->moh_offset],
512                         &pvt->app_name[pvt->moh_offset]);/* Safe */
513         }
514         strcpy(&run_data->app_name[run_data->feature_offset],
515                 &pvt->app_name[pvt->feature_offset]);/* Safe */
516         strcpy(&run_data->app_name[run_data->activated_offset], activated_name);/* Safe */
517
518         if (ast_test_flag(pvt, AST_FEATURE_FLAG_ONPEER)) {
519                 ast_bridge_channel_write_callback(bridge_channel,
520                         AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA,
521                         dynamic_dtmf_hook_callback, run_data, len_data);
522         } else {
523                 dynamic_dtmf_hook_callback(bridge_channel, run_data, len_data);
524         }
525         return 0;
526 }
527
528 /*!
529  * \internal
530  * \brief Add a dynamic DTMF feature hook to the bridge features.
531  * \since 12.0.0
532  *
533  * \param features Bridge features to setup.
534  * \param flags Which side of bridge to run app (AST_FEATURE_FLAG_ONSELF/AST_FEATURE_FLAG_ONPEER).
535  * \param dtmf DTMF trigger sequence.
536  * \param feature_name Name of the dynamic feature.
537  * \param app_name Dialplan application name to run.
538  * \param app_args Dialplan application arguments. (Empty or NULL if no arguments)
539  * \param moh_class MOH class to play to peer. (Empty or NULL if no MOH played)
540  *
541  * \retval 0 on success.
542  * \retval -1 on error.
543  */
544 static int dynamic_dtmf_hook_add(struct ast_bridge_features *features, unsigned int flags, const char *dtmf, const char *feature_name, const char *app_name, const char *app_args, const char *moh_class)
545 {
546         struct dynamic_dtmf_hook_data *hook_data;
547         size_t len_name = strlen(app_name) + 1;
548         size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
549         size_t len_moh = ast_strlen_zero(moh_class) ? 0 : strlen(moh_class) + 1;
550         size_t len_feature = strlen(feature_name) + 1;
551         size_t len_data = sizeof(*hook_data) + len_name + len_args + len_moh + len_feature;
552         int res;
553
554         /* Fill in application run hook data. */
555         hook_data = ast_malloc(len_data);
556         if (!hook_data) {
557                 return -1;
558         }
559         hook_data->flags = flags;
560         hook_data->app_args_offset = len_args ? len_name : 0;
561         hook_data->moh_offset = len_moh ? len_name + len_args : 0;
562         hook_data->feature_offset = len_name + len_args + len_moh;
563         strcpy(hook_data->app_name, app_name);/* Safe */
564         if (len_args) {
565                 strcpy(&hook_data->app_name[hook_data->app_args_offset], app_args);/* Safe */
566         }
567         if (len_moh) {
568                 strcpy(&hook_data->app_name[hook_data->moh_offset], moh_class);/* Safe */
569         }
570         strcpy(&hook_data->app_name[hook_data->feature_offset], feature_name);/* Safe */
571
572         res = ast_bridge_dtmf_hook(features, dtmf, dynamic_dtmf_hook_trip, hook_data,
573                 ast_free_ptr,
574                 AST_BRIDGE_HOOK_REMOVE_ON_PULL | AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE);
575         if (res) {
576                 ast_free(hook_data);
577         }
578         return res;
579 }
580
581 static int setup_dynamic_feature(void *obj, void *arg, void *data, int flags)
582 {
583         struct ast_applicationmap_item *item = obj;
584         struct ast_bridge_features *features = arg;
585         int *res = data;
586
587         *res |= dynamic_dtmf_hook_add(features,
588                 item->activate_on_self ? AST_FEATURE_FLAG_ONSELF : AST_FEATURE_FLAG_ONPEER,
589                 item->dtmf, item->name, item->app, item->app_data, item->moh_class);
590
591         return 0;
592 }
593
594 /*!
595  * \internal
596  * \brief Setup bridge dynamic features.
597  * \since 12.0.0
598  *
599  * \param features Bridge features to setup.
600  * \param chan Get features from this channel.
601  *
602  * \retval 0 on success.
603  * \retval -1 on error.
604  */
605 static int setup_bridge_features_dynamic(struct ast_bridge_features *features, struct ast_channel *chan)
606 {
607         struct ao2_container *applicationmap;
608         int res = 0;
609
610         ast_channel_lock(chan);
611         applicationmap = ast_get_chan_applicationmap(chan);
612         ast_channel_unlock(chan);
613         if (applicationmap) {
614                 ao2_callback_data(applicationmap, 0, setup_dynamic_feature, features, &res);
615                 ao2_ref(applicationmap, -1);
616         }
617
618         return res;
619 }
620
621 /*!
622  * \internal
623  * \brief Setup DTMF feature hooks using the channel features datastore property.
624  * \since 12.0.0
625  *
626  * \param bridge_channel What to setup DTMF features on.
627  *
628  * \retval 0 on success.
629  * \retval -1 on error.
630  */
631 static int bridge_basic_setup_features(struct ast_bridge_channel *bridge_channel)
632 {
633         int res = 0;
634
635         res |= setup_bridge_features_builtin(bridge_channel->features, bridge_channel->chan);
636         res |= setup_bridge_features_dynamic(bridge_channel->features, bridge_channel->chan);
637
638         return res;
639 }
640
641 static int add_normal_hooks(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
642 {
643         return ast_bridge_hangup_hook(bridge_channel->features, basic_hangup_hook,
644                         NULL, NULL, AST_BRIDGE_HOOK_REMOVE_ON_PULL)
645                 || bridge_basic_setup_features(bridge_channel);
646 }
647
648 /*!
649  * \internal
650  * \brief ast_bridge basic push method.
651  * \since 12.0.0
652  *
653  * \param self Bridge to operate upon.
654  * \param bridge_channel Bridge channel to push.
655  * \param swap Bridge channel to swap places with if not NULL.
656  *
657  * \note On entry, self is already locked.
658  *
659  * \retval 0 on success
660  * \retval -1 on failure
661  */
662 static int bridge_personality_normal_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
663 {
664         if (add_normal_hooks(self, bridge_channel)) {
665                 return -1;
666         }
667
668         return 0;
669 }
670
671 static int bridge_basic_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
672 {
673         struct bridge_basic_personality *personality = self->personality;
674
675         ast_assert(personality != NULL);
676
677         if (personality->details[personality->current].v_table->push
678                 && personality->details[personality->current].v_table->push(self, bridge_channel, swap)) {
679                 return -1;
680         }
681
682         ast_bridge_channel_update_linkedids(bridge_channel, swap);
683         ast_bridge_channel_update_accountcodes(bridge_channel, swap);
684
685         return ast_bridge_base_v_table.push(self, bridge_channel, swap);
686 }
687
688 static void bridge_basic_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
689 {
690         struct bridge_basic_personality *personality = self->personality;
691
692         ast_assert(personality != NULL);
693
694         if (personality->details[personality->current].v_table->pull) {
695                 personality->details[personality->current].v_table->pull(self, bridge_channel);
696         }
697
698         ast_bridge_channel_update_accountcodes(NULL, bridge_channel);
699
700         ast_bridge_base_v_table.pull(self, bridge_channel);
701 }
702
703 static void bridge_basic_destroy(struct ast_bridge *self)
704 {
705         struct bridge_basic_personality *personality = self->personality;
706
707         ao2_cleanup(personality);
708
709         ast_bridge_base_v_table.destroy(self);
710 }
711
712 /*!
713  * \brief Remove appropriate hooks when basic bridge personality changes
714  *
715  * Hooks that have the AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE flag
716  * set will be removed from all bridge channels in the bridge.
717  *
718  * \param bridge Basic bridge undergoing personality change
719  */
720 static void remove_hooks_on_personality_change(struct ast_bridge *bridge)
721 {
722         struct ast_bridge_channel *iter;
723
724         AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
725                 SCOPED_LOCK(lock, iter, ast_bridge_channel_lock, ast_bridge_channel_unlock);
726                 ast_bridge_features_remove(iter->features, AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE);
727         }
728 }
729
730 /*!
731  * \brief Attended transfer superstates.
732  *
733  * An attended transfer's progress is facilitated by a state machine.
734  * The individual states of the state machine fall into the realm of
735  * one of two superstates.
736  */
737 enum attended_transfer_superstate {
738         /*!
739          * \brief Transfer superstate
740          *
741          * The attended transfer state machine begins in this superstate. The
742          * goal of this state is for a transferer channel to facilitate a
743          * transfer from a transferee to a transfer target.
744          *
745          * There are two bridges used in this superstate. The transferee bridge is
746          * the bridge that the transferer and transferee channels originally
747          * communicate in, and the target bridge is the bridge where the transfer
748          * target is being dialed.
749          *
750          * The transferer channel is capable of moving between the bridges using
751          * the DTMF swap sequence.
752          */
753         SUPERSTATE_TRANSFER,
754         /*!
755          * \brief Recall superstate
756          *
757          * The attended transfer state machine moves to this superstate if
758          * atxferdropcall is set to "no" and the transferer channel hangs up
759          * during a transfer. The goal in this superstate is to call back either
760          * the transfer target or transferer and rebridge with the transferee
761          * channel(s).
762          *
763          * In this superstate, there is only a single bridge used, the original
764          * transferee bridge. Rather than distinguishing between a transferer
765          * and transfer target, all outbound calls are toward a "recall_target"
766          * channel.
767          */
768         SUPERSTATE_RECALL,
769 };
770
771 /*!
772  * The states in the attended transfer state machine.
773  */
774 enum attended_transfer_state {
775         /*!
776          * \brief Calling Target state
777          *
778          * This state describes the initial state of a transfer. The transferer
779          * waits in the transfer target's bridge for the transfer target to answer.
780          *
781          * Superstate: Transfer
782          *
783          * Preconditions:
784          * 1) Transfer target is RINGING
785          * 2) Transferer is in transferee bridge
786          * 3) Transferee is on hold
787          *
788          * Transitions to TRANSFER_CALLING_TARGET:
789          * 1) This is the initial state for an attended transfer.
790          * 2) TRANSFER_HESITANT: Transferer presses DTMF swap sequence
791          *
792          * State operation:
793          * The transferer is moved from the transferee bridge into the transfer
794          * target bridge.
795          *
796          * Transitions from TRANSFER_CALLING_TARGET:
797          * 1) TRANSFER_FAIL: Transferee hangs up.
798          * 2) TRANSFER_BLOND: Transferer hangs up or presses DTMF swap sequence
799          * and configured atxferdropcall setting is yes.
800          * 3) TRANSFER_BLOND_NONFINAL: Transferer hangs up or presses DTMF swap
801          * sequence and configured atxferdroppcall setting is no.
802          * 4) TRANSFER_CONSULTING: Transfer target answers the call.
803          * 5) TRANSFER_REBRIDGE: Transfer target hangs up, call to transfer target
804          * times out, or transferer presses DTMF abort sequence.
805          * 6) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
806          * 7) TRANSFER_HESITANT: Transferer presses DTMF swap sequence.
807          */
808         TRANSFER_CALLING_TARGET,
809         /*!
810          * \brief Hesitant state
811          *
812          * This state only arises if when waiting for the transfer target to
813          * answer, the transferer presses the DTMF swap sequence. This will
814          * cause the transferer to be rebridged with the transferee temporarily.
815          *
816          * Superstate: Transfer
817          *
818          * Preconditions:
819          * 1) Transfer target is in ringing state
820          * 2) Transferer is in transfer target bridge
821          * 3) Transferee is on hold
822          *
823          * Transitions to TRANSFER_HESITANT:
824          * 1) TRANSFER_CALLING_TARGET: Transferer presses DTMF swap sequence.
825          *
826          * State operation:
827          * The transferer is moved from the transfer target bridge into the
828          * transferee bridge, and the transferee is taken off hold.
829          *
830          * Transitions from TRANSFER_HESITANT:
831          * 1) TRANSFER_FAIL: Transferee hangs up
832          * 2) TRANSFER_BLOND: Transferer hangs up or presses DTMF swap sequence
833          * and configured atxferdropcall setting is yes.
834          * 3) TRANSFER_BLOND_NONFINAL: Transferer hangs up or presses DTMF swap
835          * sequence and configured atxferdroppcall setting is no.
836          * 4) TRANSFER_DOUBLECHECKING: Transfer target answers the call
837          * 5) TRANSFER_RESUME: Transfer target hangs up, call to transfer target
838          * times out, or transferer presses DTMF abort sequence.
839          * 6) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
840          * 7) TRANSFER_CALLING_TARGET: Transferer presses DTMF swap sequence.
841          */
842         TRANSFER_HESITANT,
843         /*!
844          * \brief Rebridge state
845          *
846          * This is a terminal state that indicates that the transferer needs
847          * to move back to the transferee's bridge. This is a failed attended
848          * transfer result.
849          *
850          * Superstate: Transfer
851          *
852          * Preconditions:
853          * 1) Transferer is in transfer target bridge
854          * 2) Transferee is on hold
855          *
856          * Transitions to TRANSFER_REBRIDGE:
857          * 1) TRANSFER_CALLING_TARGET: Transfer target hangs up, call to transfer target
858          * times out, or transferer presses DTMF abort sequence.
859          * 2) TRANSFER_STATE_CONSULTING: Transfer target hangs up, or transferer presses
860          * DTMF abort sequence.
861          *
862          * State operation:
863          * The transferer channel is moved from the transfer target bridge to the
864          * transferee bridge. The transferee is taken off hold. A stasis transfer
865          * message is published indicating a failed attended transfer.
866          *
867          * Transitions from TRANSFER_REBRIDGE:
868          * None
869          */
870         TRANSFER_REBRIDGE,
871         /*!
872          * \brief Resume state
873          *
874          * This is a terminal state that indicates that the party bridged with the
875          * transferee is the final party to be bridged with that transferee. This state
876          * may come about due to a successful recall or due to a failed transfer.
877          *
878          * Superstate: Transfer or Recall
879          *
880          * Preconditions:
881          * In Transfer Superstate:
882          * 1) Transferer is in transferee bridge
883          * 2) Transferee is not on hold
884          * In Recall Superstate:
885          * 1) The recall target is in the transferee bridge
886          * 2) Transferee is not on hold
887          *
888          * Transitions to TRANSFER_RESUME:
889          * TRANSFER_HESITANT: Transfer target hangs up, call to transfer target times out,
890          * or transferer presses DTMF abort sequence.
891          * TRANSFER_DOUBLECHECKING: Transfer target hangs up or transferer presses DTMF
892          * abort sequence.
893          * TRANSFER_BLOND_NONFINAL: Recall target answers
894          * TRANSFER_RECALLING: Recall target answers
895          * TRANSFER_RETRANSFER: Recall target answers
896          *
897          * State operations:
898          * None
899          *
900          * Transitions from TRANSFER_RESUME:
901          * None
902          */
903         TRANSFER_RESUME,
904         /*!
905          * \brief Threeway state
906          *
907          * This state results when the transferer wishes to have all parties involved
908          * in a transfer to be in the same bridge together.
909          *
910          * Superstate: Transfer
911          *
912          * Preconditions:
913          * 1) Transfer target state is either RINGING or UP
914          * 2) Transferer is in either bridge
915          * 3) Transferee is not on hold
916          *
917          * Transitions to TRANSFER_THREEWAY:
918          * 1) TRANSFER_CALLING_TARGET: Transferer presses DTMF threeway sequence.
919          * 2) TRANSFER_HESITANT: Transferer presses DTMF threeway sequence.
920          * 3) TRANSFER_CONSULTING: Transferer presses DTMF threeway sequence.
921          * 4) TRANSFER_DOUBLECHECKING: Transferer presses DTMF threeway sequence.
922          *
923          * State operation:
924          * The transfer target bridge is merged into the transferee bridge.
925          *
926          * Transitions from TRANSFER_THREEWAY:
927          * None.
928          */
929         TRANSFER_THREEWAY,
930         /*!
931          * \brief Consulting state
932          *
933          * This state describes the case where the transferer and transfer target
934          * are able to converse in the transfer target's bridge prior to completing
935          * the transfer.
936          *
937          * Superstate: Transfer
938          *
939          * Preconditions:
940          * 1) Transfer target is UP
941          * 2) Transferer is in target bridge
942          * 3) Transferee is on hold
943          *
944          * Transitions to TRANSFER_CONSULTING:
945          * 1) TRANSFER_CALLING_TARGET: Transfer target answers.
946          * 2) TRANSFER_DOUBLECHECKING: Transferer presses DTMF swap sequence.
947          *
948          * State operations:
949          * None.
950          *
951          * Transitions from TRANSFER_CONSULTING:
952          * TRANSFER_COMPLETE: Transferer hangs up or transferer presses DTMF complete sequence.
953          * TRANSFER_REBRIDGE: Transfer target hangs up or transferer presses DTMF abort sequence.
954          * TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
955          * TRANSFER_DOUBLECHECKING: Transferer presses DTMF swap sequence.
956          */
957         TRANSFER_CONSULTING,
958         /*!
959          * \brief Double-checking state
960          *
961          * This state describes the case where the transferer and transferee are
962          * able to converse in the transferee's bridge prior to completing the transfer. The
963          * difference between this and TRANSFER_HESITANT is that the transfer target is
964          * UP in this case.
965          *
966          * Superstate: Transfer
967          *
968          * Preconditions:
969          * 1) Transfer target is UP and on hold
970          * 2) Transferer is in transferee bridge
971          * 3) Transferee is off hold
972          *
973          * Transitions to TRANSFER_DOUBLECHECKING:
974          * 1) TRANSFER_HESITANT: Transfer target answers.
975          * 2) TRANSFER_CONSULTING: Transferer presses DTMF swap sequence.
976          *
977          * State operations:
978          * None.
979          *
980          * Transitions from TRANSFER_DOUBLECHECKING:
981          * 1) TRANSFER_FAIL: Transferee hangs up.
982          * 2) TRANSFER_COMPLETE: Transferer hangs up or presses DTMF complete sequence.
983          * 3) TRANSFER_RESUME: Transfer target hangs up or transferer presses DTMF abort sequence.
984          * 4) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
985          * 5) TRANSFER_CONSULTING: Transferer presses the DTMF swap sequence.
986          */
987         TRANSFER_DOUBLECHECKING,
988         /*!
989          * \brief Complete state
990          *
991          * This is a terminal state where a transferer has successfully completed an attended
992          * transfer. This state's goal is to get the transfer target and transferee into
993          * the same bridge and the transferer off the call.
994          *
995          * Superstate: Transfer
996          *
997          * Preconditions:
998          * 1) Transfer target is UP and off hold.
999          * 2) Transferer is in either bridge.
1000          * 3) Transferee is off hold.
1001          *
1002          * Transitions to TRANSFER_COMPLETE:
1003          * 1) TRANSFER_CONSULTING: transferer hangs up or presses the DTMF complete sequence.
1004          * 2) TRANSFER_DOUBLECHECKING: transferer hangs up or presses the DTMF complete sequence.
1005          *
1006          * State operation:
1007          * The transfer target bridge is merged into the transferee bridge. The transferer
1008          * channel is kicked out of the bridges as part of the merge.
1009          *
1010          * State operations:
1011          * 1) Merge the transfer target bridge into the transferee bridge,
1012          * excluding the transferer channel from the merge.
1013          * 2) Publish a stasis transfer message.
1014          *
1015          * Exit operations:
1016          * This is a terminal state, so there are no exit operations.
1017          */
1018         TRANSFER_COMPLETE,
1019         /*!
1020          * \brief Blond state
1021          *
1022          * This is a terminal state where a transferer has completed an attended transfer prior
1023          * to the transfer target answering. This state is only entered if atxferdropcall
1024          * is set to 'yes'. This is considered to be a successful attended transfer.
1025          *
1026          * Superstate: Transfer
1027          *
1028          * Preconditions:
1029          * 1) Transfer target is RINGING.
1030          * 2) Transferer is in either bridge.
1031          * 3) Transferee is off hold.
1032          *
1033          * Transitions to TRANSFER_BLOND:
1034          * 1) TRANSFER_CALLING_TARGET: Transferer hangs up or presses the DTMF complete sequence.
1035          *    atxferdropcall is set to 'yes'.
1036          * 2) TRANSFER_HESITANT: Transferer hangs up or presses the DTMF complete sequence.
1037          *    atxferdropcall is set to 'yes'.
1038          *
1039          * State operations:
1040          * The transfer target bridge is merged into the transferee bridge. The transferer
1041          * channel is kicked out of the bridges as part of the merge. A stasis transfer
1042          * publication is sent indicating a successful transfer.
1043          *
1044          * Transitions from TRANSFER_BLOND:
1045          * None
1046          */
1047         TRANSFER_BLOND,
1048         /*!
1049          * \brief Blond non-final state
1050          *
1051          * This state is very similar to the TRANSFER_BLOND state, except that
1052          * this state is entered when atxferdropcall is set to 'no'. This is the
1053          * initial state of the Recall superstate, so state operations mainly involve
1054          * moving to the Recall superstate. This means that the transfer target, that
1055          * is currently ringing is now known as the recall target.
1056          *
1057          * Superstate: Recall
1058          *
1059          * Preconditions:
1060          * 1) Recall target is RINGING.
1061          * 2) Transferee is off hold.
1062          *
1063          * Transitions to TRANSFER_BLOND_NONFINAL:
1064          * 1) TRANSFER_CALLING_TARGET: Transferer hangs up or presses the DTMF complete sequence.
1065          *    atxferdropcall is set to 'no'.
1066          * 2) TRANSFER_HESITANT: Transferer hangs up or presses the DTMF complete sequence.
1067          *    atxferdropcall is set to 'no'.
1068          *
1069          * State operation:
1070          * The superstate of the attended transfer is changed from Transfer to Recall.
1071          * The transfer target bridge is merged into the transferee bridge. The transferer
1072          * channel is kicked out of the bridges as part of the merge.
1073          *
1074          * Transitions from TRANSFER_BLOND_NONFINAL:
1075          * 1) TRANSFER_FAIL: Transferee hangs up
1076          * 2) TRANSFER_RESUME: Recall target answers
1077          * 3) TRANSFER_RECALLING: Recall target hangs up or time expires.
1078          */
1079         TRANSFER_BLOND_NONFINAL,
1080         /*!
1081          * \brief Recalling state
1082          *
1083          * This state is entered if the recall target from the TRANSFER_BLOND_NONFINAL
1084          * or TRANSFER_RETRANSFER states hangs up or does not answer. The goal of this
1085          * state is to call back the original transferer in an attempt to recover the
1086          * original call.
1087          *
1088          * Superstate: Recall
1089          *
1090          * Preconditions:
1091          * 1) Recall target is down.
1092          * 2) Transferee is off hold.
1093          *
1094          * Transitions to TRANSFER_RECALLING:
1095          * 1) TRANSFER_BLOND_NONFINAL: Recall target hangs up or time expires.
1096          * 2) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1097          *    atxferloopdelay is non-zero.
1098          * 3) TRANSFER_WAIT_TO_RECALL: Time expires.
1099          *
1100          * State operation:
1101          * The original transferer becomes the recall target and is called using the Dialing API.
1102          * Ringing is indicated to the transferee.
1103          *
1104          * Transitions from TRANSFER_RECALLING:
1105          * 1) TRANSFER_FAIL:
1106          *    a) Transferee hangs up.
1107          *    b) Recall target hangs up or time expires, and number of recall attempts exceeds atxfercallbackretries
1108          * 2) TRANSFER_WAIT_TO_RETRANSFER: Recall target hangs up or time expires.
1109          *    atxferloopdelay is non-zero.
1110          * 3) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1111          *    atxferloopdelay is zero.
1112          * 4) TRANSFER_RESUME: Recall target answers.
1113          */
1114         TRANSFER_RECALLING,
1115         /*!
1116          * \brief Wait to Retransfer state
1117          *
1118          * This state is used simply to give a bit of breathing room between attempting
1119          * to call back the original transferer and attempting to call back the original
1120          * transfer target. The transferee hears music on hold during this state as an
1121          * auditory clue that no one is currently being dialed.
1122          *
1123          * Superstate: Recall
1124          *
1125          * Preconditions:
1126          * 1) Recall target is down.
1127          * 2) Transferee is off hold.
1128          *
1129          * Transitions to TRANSFER_WAIT_TO_RETRANSFER:
1130          * 1) TRANSFER_RECALLING: Recall target hangs up or time expires.
1131          *    atxferloopdelay is non-zero.
1132          *
1133          * State operation:
1134          * The transferee is placed on hold.
1135          *
1136          * Transitions from TRANSFER_WAIT_TO_RETRANSFER:
1137          * 1) TRANSFER_FAIL: Transferee hangs up.
1138          * 2) TRANSFER_RETRANSFER: Time expires.
1139          */
1140         TRANSFER_WAIT_TO_RETRANSFER,
1141         /*!
1142          * \brief Retransfer state
1143          *
1144          * This state is used in order to attempt to call back the original
1145          * transfer target channel from the transfer. The transferee hears
1146          * ringing during this state as an auditory cue that a party is being
1147          * dialed.
1148          *
1149          * Superstate: Recall
1150          *
1151          * Preconditions:
1152          * 1) Recall target is down.
1153          * 2) Transferee is off hold.
1154          *
1155          * Transitions to TRANSFER_RETRANSFER:
1156          * 1) TRANSFER_RECALLING: Recall target hangs up or time expires.
1157          *    atxferloopdelay is zero.
1158          * 2) TRANSFER_WAIT_TO_RETRANSFER: Time expires.
1159          *
1160          * State operation:
1161          * The original transfer target is requested and is set as the recall target.
1162          * The recall target is called and placed into the transferee bridge.
1163          *
1164          * Transitions from TRANSFER_RETRANSFER:
1165          * 1) TRANSFER_FAIL: Transferee hangs up.
1166          * 2) TRANSFER_WAIT_TO_RECALL: Recall target hangs up or time expires.
1167          *    atxferloopdelay is non-zero.
1168          * 3) TRANSFER_RECALLING: Recall target hangs up or time expires.
1169          *    atxferloopdelay is zero.
1170          */
1171         TRANSFER_RETRANSFER,
1172         /*!
1173          * \brief Wait to recall state
1174          *
1175          * This state is used simply to give a bit of breathing room between attempting
1176          * to call back the original transfer target and attempting to call back the
1177          * original transferer. The transferee hears music on hold during this state as an
1178          * auditory clue that no one is currently being dialed.
1179          *
1180          * Superstate: Recall
1181          *
1182          * Preconditions:
1183          * 1) Recall target is down.
1184          * 2) Transferee is off hold.
1185          *
1186          * Transitions to TRANSFER_WAIT_TO_RECALL:
1187          * 1) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1188          *    atxferloopdelay is non-zero.
1189          *
1190          * State operation:
1191          * Transferee is placed on hold.
1192          *
1193          * Transitions from TRANSFER_WAIT_TO_RECALL:
1194          * 1) TRANSFER_FAIL: Transferee hangs up
1195          * 2) TRANSFER_RECALLING: Time expires
1196          */
1197         TRANSFER_WAIT_TO_RECALL,
1198         /*!
1199          * \brief Fail state
1200          *
1201          * This state indicates that something occurred during the transfer that
1202          * makes a graceful completion impossible. The most common stimulus for this
1203          * state is when the transferee hangs up.
1204          *
1205          * Superstate: Transfer and Recall
1206          *
1207          * Preconditions:
1208          * None
1209          *
1210          * Transitions to TRANSFER_FAIL:
1211          * 1) TRANSFER_CALLING_TARGET: Transferee hangs up.
1212          * 2) TRANSFER_HESITANT: Transferee hangs up.
1213          * 3) TRANSFER_DOUBLECHECKING: Transferee hangs up.
1214          * 4) TRANSFER_BLOND_NONFINAL: Transferee hangs up.
1215          * 5) TRANSFER_RECALLING:
1216          *    a) Transferee hangs up.
1217          *    b) Recall target hangs up or time expires, and number of
1218          *       recall attempts exceeds atxfercallbackretries.
1219          * 6) TRANSFER_WAIT_TO_RETRANSFER: Transferee hangs up.
1220          * 7) TRANSFER_RETRANSFER: Transferee hangs up.
1221          * 8) TRANSFER_WAIT_TO_RECALL: Transferee hangs up.
1222          *
1223          * State operation:
1224          * A transfer stasis publication is made indicating a failed transfer.
1225          * The transferee bridge is destroyed.
1226          *
1227          * Transitions from TRANSFER_FAIL:
1228          * None.
1229          */
1230         TRANSFER_FAIL,
1231 };
1232
1233 /*!
1234  * \brief Stimuli that can cause transfer state changes
1235  */
1236 enum attended_transfer_stimulus {
1237         /*! No stimulus. This literally can never happen. */
1238         STIMULUS_NONE,
1239         /*! All of the transferee channels have been hung up. */
1240         STIMULUS_TRANSFEREE_HANGUP,
1241         /*! The transferer has hung up. */
1242         STIMULUS_TRANSFERER_HANGUP,
1243         /*! The transfer target channel has hung up. */
1244         STIMULUS_TRANSFER_TARGET_HANGUP,
1245         /*! The transfer target channel has answered. */
1246         STIMULUS_TRANSFER_TARGET_ANSWER,
1247         /*! The recall target channel has hung up. */
1248         STIMULUS_RECALL_TARGET_HANGUP,
1249         /*! The recall target channel has answered. */
1250         STIMULUS_RECALL_TARGET_ANSWER,
1251         /*! The current state's timer has expired. */
1252         STIMULUS_TIMEOUT,
1253         /*! The transferer pressed the abort DTMF sequence. */
1254         STIMULUS_DTMF_ATXFER_ABORT,
1255         /*! The transferer pressed the complete DTMF sequence. */
1256         STIMULUS_DTMF_ATXFER_COMPLETE,
1257         /*! The transferer pressed the three-way DTMF sequence. */
1258         STIMULUS_DTMF_ATXFER_THREEWAY,
1259         /*! The transferer pressed the swap DTMF sequence. */
1260         STIMULUS_DTMF_ATXFER_SWAP,
1261 };
1262
1263 /*!
1264  * \brief String representations of the various stimuli
1265  *
1266  * Used for debugging purposes
1267  */
1268 const char *stimulus_strs[] = {
1269         [STIMULUS_NONE] = "None",
1270         [STIMULUS_TRANSFEREE_HANGUP] = "Transferee Hangup",
1271         [STIMULUS_TRANSFERER_HANGUP] = "Transferer Hangup",
1272         [STIMULUS_TRANSFER_TARGET_HANGUP] = "Transfer Target Hangup",
1273         [STIMULUS_TRANSFER_TARGET_ANSWER] = "Transfer Target Answer",
1274         [STIMULUS_RECALL_TARGET_HANGUP] = "Recall Target Hangup",
1275         [STIMULUS_RECALL_TARGET_ANSWER] = "Recall Target Answer",
1276         [STIMULUS_TIMEOUT] = "Timeout",
1277         [STIMULUS_DTMF_ATXFER_ABORT] = "DTMF Abort",
1278         [STIMULUS_DTMF_ATXFER_COMPLETE] = "DTMF Complete",
1279         [STIMULUS_DTMF_ATXFER_THREEWAY] = "DTMF Threeway",
1280         [STIMULUS_DTMF_ATXFER_SWAP] = "DTMF Swap",
1281 };
1282
1283 struct stimulus_list {
1284         enum attended_transfer_stimulus stimulus;
1285         AST_LIST_ENTRY(stimulus_list) next;
1286 };
1287
1288 /*!
1289  * \brief Collection of data related to an attended transfer attempt
1290  */
1291 struct attended_transfer_properties {
1292         AST_DECLARE_STRING_FIELDS (
1293                 /*! Extension of transfer target */
1294                 AST_STRING_FIELD(exten);
1295                 /*! Context of transfer target */
1296                 AST_STRING_FIELD(context);
1297                 /*! Sound to play when transfer completes */
1298                 AST_STRING_FIELD(xfersound);
1299                 /*! The channel technology of the transferer channel */
1300                 AST_STRING_FIELD(transferer_type);
1301                 /*! The transferer channel address */
1302                 AST_STRING_FIELD(transferer_addr);
1303         );
1304         /*! Condition used to synchronize when stimuli are reported to the monitor thread */
1305         ast_cond_t cond;
1306         /*! The bridge where the transferee resides. This bridge is also the bridge that
1307          * survives a successful attended transfer.
1308          */
1309         struct ast_bridge *transferee_bridge;
1310         /*! The bridge used to place an outbound call to the transfer target. This
1311          * bridge is merged with the transferee_bridge on a successful transfer.
1312          */
1313         struct ast_bridge *target_bridge;
1314         /*! The party that performs the attended transfer. */
1315         struct ast_channel *transferer;
1316         /*! The local channel dialed to reach the transfer target. */
1317         struct ast_channel *transfer_target;
1318         /*! The party that is currently being recalled. Depending on
1319          * the current state, this may be either the party that originally
1320          * was the transferer or the original transfer target.  This is
1321          * set with reference when entering the BLOND_NONFINAL, RECALLING,
1322          * and RETRANSFER states, and the reference released on state exit
1323          * if continuing with recall or retransfer to avoid leak.
1324          */
1325         struct ast_channel *recall_target;
1326         /*! The absolute starting time for running timers */
1327         struct timeval start;
1328         AST_LIST_HEAD_NOLOCK(,stimulus_list) stimulus_queue;
1329         /*! The current state of the attended transfer */
1330         enum attended_transfer_state state;
1331         /*! The current superstate of the attended transfer */
1332         enum attended_transfer_superstate superstate;
1333         /*! Configured atxferdropcall from features.conf */
1334         int atxferdropcall;
1335         /*! Configured atxfercallbackretries from features.conf */
1336         int atxfercallbackretries;
1337         /*! Configured atxferloopdelay from features.conf */
1338         int atxferloopdelay;
1339         /*! Configured atxfernoanswertimeout from features.conf */
1340         int atxfernoanswertimeout;
1341         /*! Count of the number of times that recalls have been attempted */
1342         int retry_attempts;
1343         /*! Framehook ID for outbounc call to transfer target or recall target */
1344         int target_framehook_id;
1345         /*! Dial structure used when recalling transferer channel */
1346         struct ast_dial *dial;
1347         /*! The bridging features the transferer has available */
1348         struct ast_flags transferer_features;
1349         /*! Saved transferer connected line data for recalling the transferer. */
1350         struct ast_party_connected_line original_transferer_colp;
1351 };
1352
1353 static void attended_transfer_properties_destructor(void *obj)
1354 {
1355         struct attended_transfer_properties *props = obj;
1356
1357         ast_debug(1, "Destroy attended transfer properties %p\n", props);
1358
1359         ao2_cleanup(props->target_bridge);
1360         ao2_cleanup(props->transferee_bridge);
1361         /* Use ast_channel_cleanup() instead of ast_channel_unref() for channels since they may be NULL */
1362         ast_channel_cleanup(props->transferer);
1363         ast_channel_cleanup(props->transfer_target);
1364         ast_channel_cleanup(props->recall_target);
1365         ast_party_connected_line_free(&props->original_transferer_colp);
1366         ast_string_field_free_memory(props);
1367         ast_cond_destroy(&props->cond);
1368 }
1369
1370 /*!
1371  * \internal
1372  * \brief Determine the transfer context to use.
1373  * \since 12.0.0
1374  *
1375  * \param transferer Channel initiating the transfer.
1376  * \param context User supplied context if available.  May be NULL.
1377  *
1378  * \return The context to use for the transfer.
1379  */
1380 static const char *get_transfer_context(struct ast_channel *transferer, const char *context)
1381 {
1382         if (!ast_strlen_zero(context)) {
1383                 return context;
1384         }
1385         context = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
1386         if (!ast_strlen_zero(context)) {
1387                 return context;
1388         }
1389         context = ast_channel_macrocontext(transferer);
1390         if (!ast_strlen_zero(context)) {
1391                 return context;
1392         }
1393         context = ast_channel_context(transferer);
1394         if (!ast_strlen_zero(context)) {
1395                 return context;
1396         }
1397         return "default";
1398 }
1399
1400 /*!
1401  * \brief Allocate and initialize attended transfer properties
1402  *
1403  * \param transferer The channel performing the attended transfer
1404  * \param context Suggestion for what context the transfer target extension can be found in
1405  *
1406  * \retval NULL Failure to allocate or initialize
1407  * \retval non-NULL Newly allocated properties
1408  */
1409 static struct attended_transfer_properties *attended_transfer_properties_alloc(
1410         struct ast_channel *transferer, const char *context)
1411 {
1412         struct attended_transfer_properties *props;
1413         char *tech;
1414         char *addr;
1415         char *serial;
1416         struct ast_features_xfer_config *xfer_cfg;
1417         struct ast_flags *transferer_features;
1418
1419         props = ao2_alloc(sizeof(*props), attended_transfer_properties_destructor);
1420         if (!props) {
1421                 ast_log(LOG_ERROR, "Unable to create props - channel %s, context %s\n",
1422                         ast_channel_name(transferer), context);
1423                 return NULL;
1424         }
1425
1426         ast_cond_init(&props->cond, NULL);
1427
1428         if (ast_string_field_init(props, 64)) {
1429                 ast_log(LOG_ERROR, "Unable to initialize prop fields - channel %s, context %s\n",
1430                         ast_channel_name(transferer), context);
1431                 ao2_ref(props, -1);
1432                 return NULL;
1433         }
1434
1435         props->target_framehook_id = -1;
1436         props->transferer = ast_channel_ref(transferer);
1437
1438         ast_channel_lock(props->transferer);
1439         xfer_cfg = ast_get_chan_features_xfer_config(props->transferer);
1440         if (!xfer_cfg) {
1441                 ast_log(LOG_ERROR, "Unable to get transfer configuration from channel %s\n", ast_channel_name(props->transferer));
1442                 ast_channel_unlock(props->transferer);
1443                 ao2_ref(props, -1);
1444                 return NULL;
1445         }
1446         transferer_features = ast_bridge_features_ds_get(props->transferer);
1447         if (transferer_features) {
1448                 props->transferer_features = *transferer_features;
1449         }
1450         props->atxferdropcall = xfer_cfg->atxferdropcall;
1451         props->atxfercallbackretries = xfer_cfg->atxfercallbackretries;
1452         props->atxfernoanswertimeout = xfer_cfg->atxfernoanswertimeout;
1453         props->atxferloopdelay = xfer_cfg->atxferloopdelay;
1454         ast_string_field_set(props, context, get_transfer_context(transferer, context));
1455         ast_string_field_set(props, xfersound, xfer_cfg->xfersound);
1456         ao2_ref(xfer_cfg, -1);
1457
1458         /*
1459          * Save the transferee's party information for any recall calls.
1460          * This is the only piece of information needed that gets overwritten
1461          * on the transferer channel by the inital call to the transfer target.
1462          */
1463         ast_party_connected_line_copy(&props->original_transferer_colp,
1464                 ast_channel_connected(props->transferer));
1465
1466         tech = ast_strdupa(ast_channel_name(props->transferer));
1467         addr = strchr(tech, '/');
1468         if (!addr) {
1469                 ast_log(LOG_ERROR, "Transferer channel name does not follow typical channel naming format (tech/address)\n");
1470                 ast_channel_unlock(props->transferer);
1471                 ao2_ref(props, -1);
1472                 return NULL;
1473         }
1474         *addr++ = '\0';
1475         serial = strrchr(addr, '-');
1476         if (serial) {
1477                 *serial = '\0';
1478         }
1479         ast_string_field_set(props, transferer_type, tech);
1480         ast_string_field_set(props, transferer_addr, addr);
1481
1482         ast_channel_unlock(props->transferer);
1483
1484         ast_debug(1, "Allocated attended transfer properties %p for transfer from %s\n",
1485                         props, ast_channel_name(props->transferer));
1486         return props;
1487 }
1488
1489 /*!
1490  * \brief Free backlog of stimuli in the queue
1491  */
1492 static void clear_stimulus_queue(struct attended_transfer_properties *props)
1493 {
1494         struct stimulus_list *list;
1495         SCOPED_AO2LOCK(lock, props);
1496
1497         while ((list = AST_LIST_REMOVE_HEAD(&props->stimulus_queue, next))) {
1498                 ast_free(list);
1499         }
1500 }
1501
1502 /*!
1503  * \brief Initiate shutdown of attended transfer properties
1504  *
1505  * Calling this indicates that the attended transfer properties are no longer needed
1506  * because the transfer operation has concluded.
1507  */
1508 static void attended_transfer_properties_shutdown(struct attended_transfer_properties *props)
1509 {
1510         ast_debug(1, "Shutting down attended transfer %p\n", props);
1511
1512         if (props->transferee_bridge) {
1513                 bridge_basic_change_personality(props->transferee_bridge,
1514                                 BRIDGE_BASIC_PERSONALITY_NORMAL, NULL);
1515                 ast_bridge_merge_inhibit(props->transferee_bridge, -1);
1516         }
1517
1518         if (props->target_bridge) {
1519                 ast_bridge_destroy(props->target_bridge, 0);
1520                 props->target_bridge = NULL;
1521         }
1522
1523         if (props->transferer) {
1524                 ast_channel_remove_bridge_role(props->transferer, AST_TRANSFERER_ROLE_NAME);
1525         }
1526
1527         clear_stimulus_queue(props);
1528
1529         ao2_cleanup(props);
1530 }
1531
1532 static void stimulate_attended_transfer(struct attended_transfer_properties *props,
1533                 enum attended_transfer_stimulus stimulus)
1534 {
1535         struct stimulus_list *list;
1536
1537         list = ast_calloc(1, sizeof(*list));
1538         if (!list) {
1539                 ast_log(LOG_ERROR, "Unable to push event to attended transfer queue. Expect transfer to fail\n");
1540                 return;
1541         }
1542
1543         list->stimulus = stimulus;
1544         ao2_lock(props);
1545         AST_LIST_INSERT_TAIL(&props->stimulus_queue, list, next);
1546         ast_cond_signal(&props->cond);
1547         ao2_unlock(props);
1548 }
1549
1550 static void remove_attended_transfer_stimulus(struct attended_transfer_properties *props,
1551                 enum attended_transfer_stimulus stimulus)
1552 {
1553         struct stimulus_list *list;
1554
1555         ao2_lock(props);
1556         AST_LIST_TRAVERSE_SAFE_BEGIN(&props->stimulus_queue, list, next) {
1557                 if (list->stimulus == stimulus) {
1558                         AST_LIST_REMOVE_CURRENT(next);
1559                         ast_free(list);
1560                         break;
1561                 }
1562         }
1563         AST_LIST_TRAVERSE_SAFE_END;
1564         ao2_unlock(props);
1565 }
1566
1567 /*!
1568  * \brief Get a desired transfer party for a bridge the transferer is not in.
1569  *
1570  * \param bridge The bridge to get the party from. May be NULL.
1571  * \param[out] party The lone channel in the bridge. Will be set NULL if bridge is NULL or multiple parties are present.
1572  */
1573 static void get_transfer_party_non_transferer_bridge(struct ast_bridge *bridge,
1574                 struct ast_channel **party)
1575 {
1576         if (bridge && bridge->num_channels == 1) {
1577                 *party = ast_channel_ref(AST_LIST_FIRST(&bridge->channels)->chan);
1578         } else {
1579                 *party = NULL;
1580         }
1581 }
1582
1583 /*!
1584  * \brief Get the transferee and transfer target when the transferer is in a bridge with
1585  * one of the desired parties.
1586  *
1587  * \param transferer_bridge The bridge the transferer is in
1588  * \param other_bridge The bridge the transferer is not in. May be NULL.
1589  * \param transferer The transferer party
1590  * \param[out] transferer_peer The party that is in the bridge with the transferer
1591  * \param[out] other_party The party that is in the other_bridge
1592  */
1593 static void get_transfer_parties_transferer_bridge(struct ast_bridge *transferer_bridge,
1594                 struct ast_bridge *other_bridge, struct ast_channel *transferer,
1595                 struct ast_channel **transferer_peer, struct ast_channel **other_party)
1596 {
1597         *transferer_peer = ast_bridge_peer(transferer_bridge, transferer);
1598         get_transfer_party_non_transferer_bridge(other_bridge, other_party);
1599 }
1600
1601 /*!
1602  * \brief determine transferee and transfer target for an attended transfer
1603  *
1604  * In builtin attended transfers, there is a single transferer channel that jumps between
1605  * the two bridges involved. At the time the attended transfer occurs, the transferer could
1606  * be in either bridge, so determining the parties is a bit more complex than normal.
1607  *
1608  * The method used here is to determine which of the two bridges the transferer is in, and
1609  * grabbing the peer from that bridge. The other bridge, if it only has a single channel in it,
1610  * has the other desired channel.
1611  *
1612  * \param transferer The channel performing the transfer
1613  * \param transferee_bridge The bridge that the transferee is in
1614  * \param target_bridge The bridge that the transfer target is in
1615  * \param[out] transferee The transferee channel
1616  * \param[out] transfer_target The transfer target channel
1617  */
1618 static void get_transfer_parties(struct ast_channel *transferer, struct ast_bridge *transferee_bridge,
1619                 struct ast_bridge *target_bridge, struct ast_channel **transferee,
1620                 struct ast_channel **transfer_target)
1621 {
1622         struct ast_bridge *transferer_bridge;
1623
1624         ast_channel_lock(transferer);
1625         transferer_bridge = ast_channel_get_bridge(transferer);
1626         ast_channel_unlock(transferer);
1627
1628         if (transferer_bridge == transferee_bridge) {
1629                 get_transfer_parties_transferer_bridge(transferee_bridge, target_bridge,
1630                                 transferer, transferee, transfer_target);
1631         } else if (transferer_bridge == target_bridge) {
1632                 get_transfer_parties_transferer_bridge(target_bridge, transferee_bridge,
1633                                 transferer, transfer_target, transferee);
1634         } else {
1635                 get_transfer_party_non_transferer_bridge(transferee_bridge, transferee);
1636                 get_transfer_party_non_transferer_bridge(target_bridge, transfer_target);
1637         }
1638
1639         ao2_cleanup(transferer_bridge);
1640 }
1641
1642 /*!
1643  * \brief Send a stasis publication for a successful attended transfer
1644  */
1645 static void publish_transfer_success(struct attended_transfer_properties *props,
1646                 struct ast_channel *transferee_channel, struct ast_channel *target_channel)
1647 {
1648         struct ast_attended_transfer_message *transfer_msg;
1649
1650         transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1651                         props->transferee_bridge, props->transferer, props->target_bridge,
1652                         transferee_channel, target_channel);
1653
1654         if (!transfer_msg) {
1655                 ast_log(LOG_ERROR, "Unable to publish successful attended transfer from %s\n",
1656                                 ast_channel_name(props->transferer));
1657                 return;
1658         }
1659
1660         ast_attended_transfer_message_add_merge(transfer_msg, props->transferee_bridge);
1661         ast_bridge_publish_attended_transfer(transfer_msg);
1662         ao2_cleanup(transfer_msg);
1663 }
1664
1665 /*!
1666  * \brief Send a stasis publication for an attended transfer that ends in a threeway call
1667  */
1668 static void publish_transfer_threeway(struct attended_transfer_properties *props,
1669                 struct ast_channel *transferee_channel, struct ast_channel *target_channel)
1670 {
1671         struct ast_attended_transfer_message *transfer_msg;
1672
1673         transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1674                         props->transferee_bridge, props->transferer, props->target_bridge,
1675                         transferee_channel, target_channel);
1676
1677         if (!transfer_msg) {
1678                 ast_log(LOG_ERROR, "Unable to publish successful three-way transfer from %s\n",
1679                                 ast_channel_name(props->transferer));
1680                 return;
1681         }
1682
1683         ast_attended_transfer_message_add_threeway(transfer_msg, props->transferer,
1684                         props->transferee_bridge);
1685         ast_bridge_publish_attended_transfer(transfer_msg);
1686         ao2_cleanup(transfer_msg);
1687 }
1688
1689 /*!
1690  * \brief Send a stasis publication for a failed attended transfer
1691  */
1692 static void publish_transfer_fail(struct attended_transfer_properties *props)
1693 {
1694         struct ast_attended_transfer_message *transfer_msg;
1695
1696         transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1697                         props->transferee_bridge, props->transferer, props->target_bridge,
1698                         NULL, NULL);
1699
1700         if (!transfer_msg) {
1701                 ast_log(LOG_ERROR, "Unable to publish failed transfer from %s\n",
1702                                 ast_channel_name(props->transferer));
1703                 return;
1704         }
1705
1706         transfer_msg->result = AST_BRIDGE_TRANSFER_FAIL;
1707         ast_bridge_publish_attended_transfer(transfer_msg);
1708         ao2_cleanup(transfer_msg);
1709 }
1710
1711 /*!
1712  * \brief Helper method to play a sound on a channel in a bridge
1713  *
1714  * \param chan The channel to play the sound to
1715  * \param sound The sound to play
1716  */
1717 static void play_sound(struct ast_channel *chan, const char *sound)
1718 {
1719         struct ast_bridge_channel *bridge_channel;
1720
1721         ast_channel_lock(chan);
1722         bridge_channel = ast_channel_get_bridge_channel(chan);
1723         ast_channel_unlock(chan);
1724
1725         if (bridge_channel) {
1726                 ast_bridge_channel_queue_playfile(bridge_channel, NULL, sound, NULL);
1727                 ao2_ref(bridge_channel, -1);
1728         }
1729 }
1730
1731 /*!
1732  * \brief Helper method to play a fail sound on a channel in a bridge
1733  *
1734  * \param chan The channel to play the fail sound to
1735  */
1736 static void play_failsound(struct ast_channel *chan)
1737 {
1738         char *sound;
1739
1740         ast_channel_lock(chan);
1741         sound = ast_get_chan_features_xferfailsound(chan);
1742         ast_channel_unlock(chan);
1743
1744         if (sound) {
1745                 play_sound(chan, sound);
1746                 ast_free(sound);
1747         }
1748 }
1749
1750 /*!
1751  * \brief Helper method to stream a fail sound on a channel
1752  *
1753  * \param chan The channel to stream the fail sound to
1754  */
1755 static void stream_failsound(struct ast_channel *chan)
1756 {
1757         char *sound;
1758
1759         ast_channel_lock(chan);
1760         sound = ast_get_chan_features_xferfailsound(chan);
1761         ast_channel_unlock(chan);
1762
1763         if (sound) {
1764                 ast_stream_and_wait(chan, sound, AST_DIGIT_NONE);
1765                 ast_free(sound);
1766         }
1767 }
1768
1769 /*!
1770  * \brief Helper method to place a channel in a bridge on hold
1771  */
1772 static void hold(struct ast_channel *chan)
1773 {
1774         struct ast_bridge_channel *bridge_channel;
1775
1776         if (!chan) {
1777                 return;
1778         }
1779
1780         ast_channel_lock(chan);
1781         bridge_channel = ast_channel_get_bridge_channel(chan);
1782         ast_channel_unlock(chan);
1783
1784         if (bridge_channel) {
1785                 ast_bridge_channel_write_hold(bridge_channel, NULL);
1786                 ao2_ref(bridge_channel, -1);
1787         }
1788 }
1789
1790 /*!
1791  * \brief Helper method to take a channel in a bridge off hold
1792  */
1793 static void unhold(struct ast_channel *chan)
1794 {
1795         struct ast_bridge_channel *bridge_channel;
1796
1797         if (!chan) {
1798                 return;
1799         }
1800
1801         ast_channel_lock(chan);
1802         bridge_channel = ast_channel_get_bridge_channel(chan);
1803         ast_channel_unlock(chan);
1804
1805         if (bridge_channel) {
1806                 ast_bridge_channel_write_unhold(bridge_channel);
1807                 ao2_ref(bridge_channel, -1);
1808         }
1809 }
1810
1811 /*!
1812  * \brief Helper method to send a ringing indication to a channel in a bridge
1813  */
1814 static void ringing(struct ast_channel *chan)
1815 {
1816         struct ast_bridge_channel *bridge_channel;
1817
1818         ast_channel_lock(chan);
1819         bridge_channel = ast_channel_get_bridge_channel(chan);
1820         ast_channel_unlock(chan);
1821
1822         if (bridge_channel) {
1823                 ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_RINGING, NULL, 0);
1824                 ao2_ref(bridge_channel, -1);
1825         }
1826 }
1827
1828 /*!
1829  * \brief Helper method to send a ringing indication to all channels in a bridge
1830  */
1831 static void bridge_ringing(struct ast_bridge *bridge)
1832 {
1833         struct ast_frame ringing = {
1834                 .frametype = AST_FRAME_CONTROL,
1835                 .subclass.integer = AST_CONTROL_RINGING,
1836         };
1837
1838         ast_bridge_queue_everyone_else(bridge, NULL, &ringing);
1839 }
1840
1841 /*!
1842  * \brief Helper method to send a hold frame to all channels in a bridge
1843  */
1844 static void bridge_hold(struct ast_bridge *bridge)
1845 {
1846         struct ast_frame hold = {
1847                 .frametype = AST_FRAME_CONTROL,
1848                 .subclass.integer = AST_CONTROL_HOLD,
1849         };
1850
1851         ast_bridge_queue_everyone_else(bridge, NULL, &hold);
1852 }
1853
1854 /*!
1855  * \brief Helper method to send an unhold frame to all channels in a bridge
1856  */
1857 static void bridge_unhold(struct ast_bridge *bridge)
1858 {
1859         struct ast_frame unhold = {
1860                 .frametype = AST_FRAME_CONTROL,
1861                 .subclass.integer = AST_CONTROL_UNHOLD,
1862         };
1863
1864         ast_bridge_queue_everyone_else(bridge, NULL, &unhold);
1865 }
1866
1867 /*!
1868  * \brief Wrapper for \ref bridge_do_move
1869  */
1870 static void bridge_move(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel *channel, struct ast_channel *swap)
1871 {
1872         struct ast_bridge_channel *bridge_channel;
1873
1874         ast_bridge_lock_both(src, dest);
1875
1876         ast_channel_lock(channel);
1877         bridge_channel = ast_channel_get_bridge_channel(channel);
1878         ast_channel_unlock(channel);
1879
1880         if (bridge_channel) {
1881                 ao2_lock(bridge_channel);
1882                 bridge_channel->swap = swap;
1883                 ao2_unlock(bridge_channel);
1884
1885                 bridge_do_move(dest, bridge_channel, 1, 0);
1886         }
1887
1888         ast_bridge_unlock(dest);
1889         ast_bridge_unlock(src);
1890
1891         ao2_cleanup(bridge_channel);
1892 }
1893
1894 /*!
1895  * \brief Wrapper for \ref bridge_do_merge
1896  */
1897 static void bridge_merge(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel **kick_channels, unsigned int num_channels)
1898 {
1899         struct ast_bridge_channel **kick_bridge_channels = num_channels ?
1900                 ast_alloca(num_channels * sizeof(*kick_bridge_channels)) : NULL;
1901         int i;
1902         int num_bridge_channels = 0;
1903
1904         ast_bridge_lock_both(dest, src);
1905
1906         for (i = 0; i < num_channels; ++i) {
1907                 struct ast_bridge_channel *kick_bridge_channel;
1908
1909                 kick_bridge_channel = bridge_find_channel(src, kick_channels[i]);
1910                 if (!kick_bridge_channel) {
1911                         kick_bridge_channel = bridge_find_channel(dest, kick_channels[i]);
1912                 }
1913
1914                 /* It's possible (and fine) for the bridge channel to be NULL at this point if the
1915                  * channel has hung up already. If that happens, we can just remove it from the list
1916                  * of bridge channels to kick from the bridge
1917                  */
1918                 if (!kick_bridge_channel) {
1919                         continue;
1920                 }
1921
1922                 kick_bridge_channels[num_bridge_channels++] = kick_bridge_channel;
1923         }
1924
1925         bridge_do_merge(dest, src, kick_bridge_channels, num_bridge_channels, 0);
1926         ast_bridge_unlock(dest);
1927         ast_bridge_unlock(src);
1928 }
1929
1930 /*!
1931  * \brief Flags that indicate properties of attended transfer states
1932  */
1933 enum attended_transfer_state_flags {
1934         /*! This state requires that the timer be reset when entering the state */
1935         TRANSFER_STATE_FLAG_TIMER_RESET = (1 << 0),
1936         /*! This state's timer uses atxferloopdelay */
1937         TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY = (1 << 1),
1938         /*! This state's timer uses atxfernoanswertimeout */
1939         TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER = (1 << 2),
1940         /*! This state has a time limit associated with it */
1941         TRANSFER_STATE_FLAG_TIMED = (TRANSFER_STATE_FLAG_TIMER_RESET |
1942                         TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY | TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER),
1943         /*! This state does not transition to any other states */
1944         TRANSFER_STATE_FLAG_TERMINAL = (1 << 3),
1945 };
1946
1947 static int calling_target_enter(struct attended_transfer_properties *props);
1948 static enum attended_transfer_state calling_target_exit(struct attended_transfer_properties *props,
1949                 enum attended_transfer_stimulus stimulus);
1950
1951 static int hesitant_enter(struct attended_transfer_properties *props);
1952 static enum attended_transfer_state hesitant_exit(struct attended_transfer_properties *props,
1953                 enum attended_transfer_stimulus stimulus);
1954
1955 static int rebridge_enter(struct attended_transfer_properties *props);
1956
1957 static int resume_enter(struct attended_transfer_properties *props);
1958
1959 static int threeway_enter(struct attended_transfer_properties *props);
1960
1961 static int consulting_enter(struct attended_transfer_properties *props);
1962 static enum attended_transfer_state consulting_exit(struct attended_transfer_properties *props,
1963                 enum attended_transfer_stimulus stimulus);
1964
1965 static int double_checking_enter(struct attended_transfer_properties *props);
1966 static enum attended_transfer_state double_checking_exit(struct attended_transfer_properties *props,
1967                 enum attended_transfer_stimulus stimulus);
1968
1969 static int complete_enter(struct attended_transfer_properties *props);
1970
1971 static int blond_enter(struct attended_transfer_properties *props);
1972
1973 static int blond_nonfinal_enter(struct attended_transfer_properties *props);
1974 static enum attended_transfer_state blond_nonfinal_exit(struct attended_transfer_properties *props,
1975                 enum attended_transfer_stimulus stimulus);
1976
1977 static int recalling_enter(struct attended_transfer_properties *props);
1978 static enum attended_transfer_state recalling_exit(struct attended_transfer_properties *props,
1979                 enum attended_transfer_stimulus stimulus);
1980
1981 static int wait_to_retransfer_enter(struct attended_transfer_properties *props);
1982 static enum attended_transfer_state wait_to_retransfer_exit(struct attended_transfer_properties *props,
1983                 enum attended_transfer_stimulus stimulus);
1984
1985 static int retransfer_enter(struct attended_transfer_properties *props);
1986 static enum attended_transfer_state retransfer_exit(struct attended_transfer_properties *props,
1987                 enum attended_transfer_stimulus stimulus);
1988
1989 static int wait_to_recall_enter(struct attended_transfer_properties *props);
1990 static enum attended_transfer_state wait_to_recall_exit(struct attended_transfer_properties *props,
1991                 enum attended_transfer_stimulus stimulus);
1992
1993 static int fail_enter(struct attended_transfer_properties *props);
1994
1995 /*!
1996  * \brief Properties of an attended transfer state
1997  */
1998 struct attended_transfer_state_properties {
1999         /*! The name of the state. Used for debugging */
2000         const char *state_name;
2001         /*! Function used to enter a state */
2002         int (*enter)(struct attended_transfer_properties *props);
2003         /*!
2004          * Function used to exit a state
2005          * This is used both to determine what the next state
2006          * to transition to will be and to perform any cleanup
2007          * necessary before exiting the current state.
2008          */
2009         enum attended_transfer_state (*exit)(struct attended_transfer_properties *props,
2010                         enum attended_transfer_stimulus stimulus);
2011         /*! Flags associated with this state */
2012         enum attended_transfer_state_flags flags;
2013 };
2014
2015 static const struct attended_transfer_state_properties state_properties[] = {
2016         [TRANSFER_CALLING_TARGET] = {
2017                 .state_name = "Calling Target",
2018                 .enter = calling_target_enter,
2019                 .exit = calling_target_exit,
2020                 .flags = TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER | TRANSFER_STATE_FLAG_TIMER_RESET,
2021         },
2022         [TRANSFER_HESITANT] = {
2023                 .state_name = "Hesitant",
2024                 .enter = hesitant_enter,
2025                 .exit = hesitant_exit,
2026                 .flags = TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER,
2027         },
2028         [TRANSFER_REBRIDGE] = {
2029                 .state_name = "Rebridge",
2030                 .enter = rebridge_enter,
2031                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2032         },
2033         [TRANSFER_RESUME] = {
2034                 .state_name = "Resume",
2035                 .enter = resume_enter,
2036                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2037         },
2038         [TRANSFER_THREEWAY] = {
2039                 .state_name = "Threeway",
2040                 .enter = threeway_enter,
2041                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2042         },
2043         [TRANSFER_CONSULTING] = {
2044                 .state_name = "Consulting",
2045                 .enter = consulting_enter,
2046                 .exit = consulting_exit,
2047         },
2048         [TRANSFER_DOUBLECHECKING] = {
2049                 .state_name = "Double Checking",
2050                 .enter = double_checking_enter,
2051                 .exit = double_checking_exit,
2052         },
2053         [TRANSFER_COMPLETE] = {
2054                 .state_name = "Complete",
2055                 .enter = complete_enter,
2056                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2057         },
2058         [TRANSFER_BLOND] = {
2059                 .state_name = "Blond",
2060                 .enter = blond_enter,
2061                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2062         },
2063         [TRANSFER_BLOND_NONFINAL] = {
2064                 .state_name = "Blond Non-Final",
2065                 .enter = blond_nonfinal_enter,
2066                 .exit = blond_nonfinal_exit,
2067                 .flags = TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER,
2068         },
2069         [TRANSFER_RECALLING] = {
2070                 .state_name = "Recalling",
2071                 .enter = recalling_enter,
2072                 .exit = recalling_exit,
2073                 .flags = TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER | TRANSFER_STATE_FLAG_TIMER_RESET,
2074         },
2075         [TRANSFER_WAIT_TO_RETRANSFER] = {
2076                 .state_name = "Wait to Retransfer",
2077                 .enter = wait_to_retransfer_enter,
2078                 .exit = wait_to_retransfer_exit,
2079                 .flags = TRANSFER_STATE_FLAG_TIMER_RESET | TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY,
2080         },
2081         [TRANSFER_RETRANSFER] = {
2082                 .state_name = "Retransfer",
2083                 .enter = retransfer_enter,
2084                 .exit = retransfer_exit,
2085                 .flags = TRANSFER_STATE_FLAG_ATXFER_NO_ANSWER | TRANSFER_STATE_FLAG_TIMER_RESET,
2086         },
2087         [TRANSFER_WAIT_TO_RECALL] = {
2088                 .state_name = "Wait to Recall",
2089                 .enter = wait_to_recall_enter,
2090                 .exit = wait_to_recall_exit,
2091                 .flags = TRANSFER_STATE_FLAG_TIMER_RESET | TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY,
2092         },
2093         [TRANSFER_FAIL] = {
2094                 .state_name = "Fail",
2095                 .enter = fail_enter,
2096                 .flags = TRANSFER_STATE_FLAG_TERMINAL,
2097         },
2098 };
2099
2100 static int calling_target_enter(struct attended_transfer_properties *props)
2101 {
2102         bridge_move(props->target_bridge, props->transferee_bridge, props->transferer, NULL);
2103         return 0;
2104 }
2105
2106 static enum attended_transfer_state calling_target_exit(struct attended_transfer_properties *props,
2107                 enum attended_transfer_stimulus stimulus)
2108 {
2109         switch (stimulus) {
2110         case STIMULUS_TRANSFEREE_HANGUP:
2111                 play_failsound(props->transferer);
2112                 publish_transfer_fail(props);
2113                 return TRANSFER_FAIL;
2114         case STIMULUS_DTMF_ATXFER_COMPLETE:
2115         case STIMULUS_TRANSFERER_HANGUP:
2116                 bridge_unhold(props->transferee_bridge);
2117                 return props->atxferdropcall ? TRANSFER_BLOND : TRANSFER_BLOND_NONFINAL;
2118         case STIMULUS_TRANSFER_TARGET_ANSWER:
2119                 return TRANSFER_CONSULTING;
2120         case STIMULUS_TRANSFER_TARGET_HANGUP:
2121         case STIMULUS_TIMEOUT:
2122         case STIMULUS_DTMF_ATXFER_ABORT:
2123                 play_failsound(props->transferer);
2124                 return TRANSFER_REBRIDGE;
2125         case STIMULUS_DTMF_ATXFER_THREEWAY:
2126                 bridge_unhold(props->transferee_bridge);
2127                 return TRANSFER_THREEWAY;
2128         case STIMULUS_DTMF_ATXFER_SWAP:
2129                 return TRANSFER_HESITANT;
2130         case STIMULUS_NONE:
2131         case STIMULUS_RECALL_TARGET_ANSWER:
2132         case STIMULUS_RECALL_TARGET_HANGUP:
2133         default:
2134                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2135                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2136                 return props->state;
2137         }
2138 }
2139
2140 static int hesitant_enter(struct attended_transfer_properties *props)
2141 {
2142         bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2143         unhold(props->transferer);
2144         return 0;
2145 }
2146
2147 static enum attended_transfer_state hesitant_exit(struct attended_transfer_properties *props,
2148                 enum attended_transfer_stimulus stimulus)
2149 {
2150         switch (stimulus) {
2151         case STIMULUS_TRANSFEREE_HANGUP:
2152                 play_failsound(props->transferer);
2153                 publish_transfer_fail(props);
2154                 return TRANSFER_FAIL;
2155         case STIMULUS_DTMF_ATXFER_COMPLETE:
2156         case STIMULUS_TRANSFERER_HANGUP:
2157                 return props->atxferdropcall ? TRANSFER_BLOND : TRANSFER_BLOND_NONFINAL;
2158         case STIMULUS_TRANSFER_TARGET_ANSWER:
2159                 return TRANSFER_DOUBLECHECKING;
2160         case STIMULUS_TRANSFER_TARGET_HANGUP:
2161         case STIMULUS_TIMEOUT:
2162         case STIMULUS_DTMF_ATXFER_ABORT:
2163                 play_failsound(props->transferer);
2164                 return TRANSFER_RESUME;
2165         case STIMULUS_DTMF_ATXFER_THREEWAY:
2166                 return TRANSFER_THREEWAY;
2167         case STIMULUS_DTMF_ATXFER_SWAP:
2168                 hold(props->transferer);
2169                 return TRANSFER_CALLING_TARGET;
2170         case STIMULUS_NONE:
2171         case STIMULUS_RECALL_TARGET_HANGUP:
2172         case STIMULUS_RECALL_TARGET_ANSWER:
2173         default:
2174                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2175                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2176                 return props->state;
2177         }
2178 }
2179
2180 static int rebridge_enter(struct attended_transfer_properties *props)
2181 {
2182         bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2183         unhold(props->transferer);
2184         return 0;
2185 }
2186
2187 static int resume_enter(struct attended_transfer_properties *props)
2188 {
2189         return 0;
2190 }
2191
2192 static int threeway_enter(struct attended_transfer_properties *props)
2193 {
2194         struct ast_channel *transferee_channel;
2195         struct ast_channel *target_channel;
2196
2197         get_transfer_parties(props->transferer, props->transferee_bridge, props->target_bridge,
2198                         &transferee_channel, &target_channel);
2199         bridge_merge(props->transferee_bridge, props->target_bridge, NULL, 0);
2200         play_sound(props->transfer_target, props->xfersound);
2201         play_sound(props->transferer, props->xfersound);
2202         publish_transfer_threeway(props, transferee_channel, target_channel);
2203
2204         ast_channel_cleanup(transferee_channel);
2205         ast_channel_cleanup(target_channel);
2206         return 0;
2207 }
2208
2209 static int consulting_enter(struct attended_transfer_properties *props)
2210 {
2211         return 0;
2212 }
2213
2214 static enum attended_transfer_state consulting_exit(struct attended_transfer_properties *props,
2215                 enum attended_transfer_stimulus stimulus)
2216 {
2217         switch (stimulus) {
2218         case STIMULUS_TRANSFEREE_HANGUP:
2219                 /* This is a one-of-a-kind event. The transferer and transfer target are talking in
2220                  * one bridge, and the transferee has hung up in a separate bridge. In this case, we
2221                  * will change the personality of the transfer target bridge back to normal, and play
2222                  * a sound to the transferer to indicate the transferee is gone.
2223                  */
2224                 bridge_basic_change_personality(props->target_bridge, BRIDGE_BASIC_PERSONALITY_NORMAL, NULL);
2225                 play_failsound(props->transferer);
2226                 ast_bridge_merge_inhibit(props->target_bridge, -1);
2227                 /* These next two lines are here to ensure that our reference to the target bridge
2228                  * is cleaned up properly and that the target bridge is not destroyed when the
2229                  * monitor thread exits
2230                  */
2231                 ao2_ref(props->target_bridge, -1);
2232                 props->target_bridge = NULL;
2233                 return TRANSFER_FAIL;
2234         case STIMULUS_TRANSFERER_HANGUP:
2235         case STIMULUS_DTMF_ATXFER_COMPLETE:
2236                 /* We know the transferer is in the target_bridge, so take the other bridge off hold */
2237                 bridge_unhold(props->transferee_bridge);
2238                 return TRANSFER_COMPLETE;
2239         case STIMULUS_TRANSFER_TARGET_HANGUP:
2240                 return TRANSFER_REBRIDGE;
2241         case STIMULUS_DTMF_ATXFER_ABORT:
2242                 play_failsound(props->transferer);
2243                 return TRANSFER_REBRIDGE;
2244         case STIMULUS_DTMF_ATXFER_THREEWAY:
2245                 bridge_unhold(props->transferee_bridge);
2246                 return TRANSFER_THREEWAY;
2247         case STIMULUS_DTMF_ATXFER_SWAP:
2248                 hold(props->transferer);
2249                 bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2250                 unhold(props->transferer);
2251                 return TRANSFER_DOUBLECHECKING;
2252         case STIMULUS_NONE:
2253         case STIMULUS_TIMEOUT:
2254         case STIMULUS_TRANSFER_TARGET_ANSWER:
2255         case STIMULUS_RECALL_TARGET_HANGUP:
2256         case STIMULUS_RECALL_TARGET_ANSWER:
2257         default:
2258                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2259                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2260                 return props->state;
2261         }
2262 }
2263
2264 static int double_checking_enter(struct attended_transfer_properties *props)
2265 {
2266         return 0;
2267 }
2268
2269 static enum attended_transfer_state double_checking_exit(struct attended_transfer_properties *props,
2270                 enum attended_transfer_stimulus stimulus)
2271 {
2272         switch (stimulus) {
2273         case STIMULUS_TRANSFEREE_HANGUP:
2274                 play_failsound(props->transferer);
2275                 publish_transfer_fail(props);
2276                 return TRANSFER_FAIL;
2277         case STIMULUS_TRANSFERER_HANGUP:
2278         case STIMULUS_DTMF_ATXFER_COMPLETE:
2279                 /* We know the transferer is in the transferee, so take the other bridge off hold */
2280                 bridge_unhold(props->target_bridge);
2281                 return TRANSFER_COMPLETE;
2282         case STIMULUS_TRANSFER_TARGET_HANGUP:
2283         case STIMULUS_DTMF_ATXFER_ABORT:
2284                 play_failsound(props->transferer);
2285                 return TRANSFER_RESUME;
2286         case STIMULUS_DTMF_ATXFER_THREEWAY:
2287                 bridge_unhold(props->target_bridge);
2288                 return TRANSFER_THREEWAY;
2289         case STIMULUS_DTMF_ATXFER_SWAP:
2290                 hold(props->transferer);
2291                 bridge_move(props->target_bridge, props->transferee_bridge, props->transferer, NULL);
2292                 unhold(props->transferer);
2293                 return TRANSFER_CONSULTING;
2294         case STIMULUS_NONE:
2295         case STIMULUS_TIMEOUT:
2296         case STIMULUS_TRANSFER_TARGET_ANSWER:
2297         case STIMULUS_RECALL_TARGET_HANGUP:
2298         case STIMULUS_RECALL_TARGET_ANSWER:
2299         default:
2300                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2301                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2302                 return props->state;
2303         }
2304 }
2305
2306 static int complete_enter(struct attended_transfer_properties *props)
2307 {
2308         struct ast_channel *transferee_channel;
2309         struct ast_channel *target_channel;
2310
2311         get_transfer_parties(props->transferer, props->transferee_bridge, props->target_bridge,
2312                         &transferee_channel, &target_channel);
2313         bridge_merge(props->transferee_bridge, props->target_bridge, &props->transferer, 1);
2314         play_sound(props->transfer_target, props->xfersound);
2315         publish_transfer_success(props, transferee_channel, target_channel);
2316
2317         ast_channel_cleanup(transferee_channel);
2318         ast_channel_cleanup(target_channel);
2319         return 0;
2320 }
2321
2322 static int blond_enter(struct attended_transfer_properties *props)
2323 {
2324         struct ast_channel *transferee_channel;
2325         struct ast_channel *target_channel;
2326
2327         get_transfer_parties(props->transferer, props->transferee_bridge, props->target_bridge,
2328                         &transferee_channel, &target_channel);
2329         bridge_merge(props->transferee_bridge, props->target_bridge, &props->transferer, 1);
2330         ringing(props->transfer_target);
2331         publish_transfer_success(props, transferee_channel, target_channel);
2332
2333         ast_channel_cleanup(transferee_channel);
2334         ast_channel_cleanup(target_channel);
2335         return 0;
2336 }
2337
2338 static int blond_nonfinal_enter(struct attended_transfer_properties *props)
2339 {
2340         int res;
2341         props->superstate = SUPERSTATE_RECALL;
2342         /* move the transfer target to the recall target along with its reference */
2343         props->recall_target = ast_channel_ref(props->transfer_target);
2344         res = blond_enter(props);
2345         props->transfer_target = ast_channel_unref(props->transfer_target);
2346         return res;
2347 }
2348
2349 static enum attended_transfer_state blond_nonfinal_exit(struct attended_transfer_properties *props,
2350                 enum attended_transfer_stimulus stimulus)
2351 {
2352         switch (stimulus) {
2353         case STIMULUS_TRANSFEREE_HANGUP:
2354                 return TRANSFER_FAIL;
2355         case STIMULUS_RECALL_TARGET_ANSWER:
2356                 return TRANSFER_RESUME;
2357         case STIMULUS_TIMEOUT:
2358                 ast_softhangup(props->recall_target, AST_SOFTHANGUP_EXPLICIT);
2359                 /* It is possible before we hung them up that they queued up a recall target answer
2360                  * so we remove it if present as it should not exist.
2361                  */
2362                 remove_attended_transfer_stimulus(props, STIMULUS_RECALL_TARGET_ANSWER);
2363         case STIMULUS_RECALL_TARGET_HANGUP:
2364                 props->recall_target = ast_channel_unref(props->recall_target);
2365                 return TRANSFER_RECALLING;
2366         case STIMULUS_NONE:
2367         case STIMULUS_DTMF_ATXFER_ABORT:
2368         case STIMULUS_DTMF_ATXFER_COMPLETE:
2369         case STIMULUS_DTMF_ATXFER_THREEWAY:
2370         case STIMULUS_DTMF_ATXFER_SWAP:
2371         case STIMULUS_TRANSFERER_HANGUP:
2372         case STIMULUS_TRANSFER_TARGET_HANGUP:
2373         case STIMULUS_TRANSFER_TARGET_ANSWER:
2374         default:
2375                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2376                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2377                 return props->state;
2378         }
2379 }
2380
2381 /*!
2382  * \brief Dial callback when attempting to recall the original transferer channel
2383  *
2384  * This is how we can monitor if the recall target has answered or has hung up.
2385  * If one of the two is detected, then an appropriate stimulus is sent to the
2386  * attended transfer monitor thread.
2387  */
2388 static void recall_callback(struct ast_dial *dial)
2389 {
2390         struct attended_transfer_properties *props = ast_dial_get_user_data(dial);
2391
2392         switch (ast_dial_state(dial)) {
2393         default:
2394         case AST_DIAL_RESULT_INVALID:
2395         case AST_DIAL_RESULT_FAILED:
2396         case AST_DIAL_RESULT_TIMEOUT:
2397         case AST_DIAL_RESULT_HANGUP:
2398         case AST_DIAL_RESULT_UNANSWERED:
2399                 /* Failure cases */
2400                 stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_HANGUP);
2401                 break;
2402         case AST_DIAL_RESULT_RINGING:
2403         case AST_DIAL_RESULT_PROGRESS:
2404         case AST_DIAL_RESULT_PROCEEDING:
2405         case AST_DIAL_RESULT_TRYING:
2406                 /* Don't care about these cases */
2407                 break;
2408         case AST_DIAL_RESULT_ANSWERED:
2409                 /* We struck gold! */
2410                 props->recall_target = ast_dial_answered_steal(dial);
2411                 stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_ANSWER);
2412                 break;
2413         }
2414 }
2415
2416 /*!
2417  * \internal
2418  * \brief Setup common things to transferrer and transfer_target recall channels.
2419  *
2420  * \param recall Channel for recalling a party.
2421  * \param transferer Channel supplying recall information.
2422  *
2423  * \details
2424  * Setup callid, variables, datastores, accountcode, and peeraccount.
2425  *
2426  * \pre Both channels are locked on entry.
2427  *
2428  * \pre COLP and CLID on the recall channel are setup by the caller but not
2429  * explicitly published yet.
2430  *
2431  * \return Nothing
2432  */
2433 static void common_recall_channel_setup(struct ast_channel *recall, struct ast_channel *transferer)
2434 {
2435         ast_callid callid;
2436
2437         callid = ast_read_threadstorage_callid();
2438         if (callid) {
2439                 ast_channel_callid_set(recall, callid);
2440         }
2441
2442         ast_channel_inherit_variables(transferer, recall);
2443         ast_channel_datastore_inherit(transferer, recall);
2444
2445         /*
2446          * Stage a snapshot to ensure that a snapshot is always done
2447          * on the recall channel so earler COLP and CLID setup will
2448          * get published.
2449          */
2450         ast_channel_stage_snapshot(recall);
2451         ast_channel_req_accountcodes(recall, transferer, AST_CHANNEL_REQUESTOR_REPLACEMENT);
2452         ast_channel_stage_snapshot_done(recall);
2453 }
2454
2455 static int recalling_enter(struct attended_transfer_properties *props)
2456 {
2457         RAII_VAR(struct ast_format_cap *, cap, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
2458         struct ast_channel *recall;
2459
2460         if (!cap) {
2461                 return -1;
2462         }
2463
2464         ast_format_cap_append(cap, ast_format_slin, 0);
2465
2466         /* When we dial the transfer target, since we are communicating
2467          * with a local channel, we can place the local channel in a bridge
2468          * and then call out to it. When recalling the transferer, though, we
2469          * have to use the dialing API because the channel is not local.
2470          */
2471         props->dial = ast_dial_create();
2472         if (!props->dial) {
2473                 return -1;
2474         }
2475
2476         if (ast_dial_append(props->dial, props->transferer_type, props->transferer_addr, NULL)) {
2477                 return -1;
2478         }
2479
2480         if (ast_dial_prerun(props->dial, NULL, cap)) {
2481                 return -1;
2482         }
2483
2484         /*
2485          * Setup callid, variables, datastores, accountcode, peeraccount,
2486          * COLP, and CLID on the recalled transferrer.
2487          */
2488         recall = ast_dial_get_channel(props->dial, 0);
2489         if (!recall) {
2490                 return -1;
2491         }
2492         ast_channel_lock_both(recall, props->transferer);
2493
2494         ast_party_caller_copy(ast_channel_caller(recall),
2495                 ast_channel_caller(props->transferer));
2496         ast_party_connected_line_copy(ast_channel_connected(recall),
2497                 &props->original_transferer_colp);
2498
2499         common_recall_channel_setup(recall, props->transferer);
2500         ast_channel_unlock(recall);
2501         ast_channel_unlock(props->transferer);
2502
2503         ast_dial_set_state_callback(props->dial, recall_callback);
2504
2505         ao2_ref(props, +1);
2506         ast_dial_set_user_data(props->dial, props);
2507
2508         if (ast_dial_run(props->dial, NULL, 1) == AST_DIAL_RESULT_FAILED) {
2509                 ao2_ref(props, -1);
2510                 return -1;
2511         }
2512
2513         bridge_ringing(props->transferee_bridge);
2514         return 0;
2515 }
2516
2517 static enum attended_transfer_state recalling_exit(struct attended_transfer_properties *props,
2518                 enum attended_transfer_stimulus stimulus)
2519 {
2520         /* No matter what the outcome was, we need to kill off the dial */
2521         ast_dial_join(props->dial);
2522         ast_dial_destroy(props->dial);
2523         props->dial = NULL;
2524         /* This reference is the one we incremented for the dial state callback (recall_callback) to use */
2525         ao2_ref(props, -1);
2526
2527         switch (stimulus) {
2528         case STIMULUS_TRANSFEREE_HANGUP:
2529                 return TRANSFER_FAIL;
2530         case STIMULUS_TIMEOUT:
2531         case STIMULUS_RECALL_TARGET_HANGUP:
2532                 ++props->retry_attempts;
2533                 if (props->retry_attempts >= props->atxfercallbackretries) {
2534                         return TRANSFER_FAIL;
2535                 }
2536                 if (props->atxferloopdelay) {
2537                         return TRANSFER_WAIT_TO_RETRANSFER;
2538                 }
2539                 return TRANSFER_RETRANSFER;
2540         case STIMULUS_RECALL_TARGET_ANSWER:
2541                 /* Setting this datastore up will allow the transferer to have all of his
2542                  * call features set up automatically when the bridge changes back to a
2543                  * normal personality
2544                  */
2545                 ast_bridge_features_ds_set(props->recall_target, &props->transferer_features);
2546                 ast_channel_ref(props->recall_target);
2547                 if (ast_bridge_impart(props->transferee_bridge, props->recall_target, NULL, NULL,
2548                         AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
2549                         ast_hangup(props->recall_target);
2550                         ast_channel_unref(props->recall_target);
2551                         return TRANSFER_FAIL;
2552                 }
2553                 return TRANSFER_RESUME;
2554         case STIMULUS_NONE:
2555         case STIMULUS_DTMF_ATXFER_ABORT:
2556         case STIMULUS_DTMF_ATXFER_COMPLETE:
2557         case STIMULUS_DTMF_ATXFER_THREEWAY:
2558         case STIMULUS_DTMF_ATXFER_SWAP:
2559         case STIMULUS_TRANSFER_TARGET_HANGUP:
2560         case STIMULUS_TRANSFER_TARGET_ANSWER:
2561         case STIMULUS_TRANSFERER_HANGUP:
2562         default:
2563                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2564                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2565                 return props->state;
2566         }
2567 }
2568
2569 static int wait_to_retransfer_enter(struct attended_transfer_properties *props)
2570 {
2571         bridge_hold(props->transferee_bridge);
2572         return 0;
2573 }
2574
2575 static enum attended_transfer_state wait_to_retransfer_exit(struct attended_transfer_properties *props,
2576                 enum attended_transfer_stimulus stimulus)
2577 {
2578         bridge_unhold(props->transferee_bridge);
2579         switch (stimulus) {
2580         case STIMULUS_TRANSFEREE_HANGUP:
2581                 return TRANSFER_FAIL;
2582         case STIMULUS_TIMEOUT:
2583                 return TRANSFER_RETRANSFER;
2584         case STIMULUS_NONE:
2585         case STIMULUS_DTMF_ATXFER_ABORT:
2586         case STIMULUS_DTMF_ATXFER_COMPLETE:
2587         case STIMULUS_DTMF_ATXFER_THREEWAY:
2588         case STIMULUS_DTMF_ATXFER_SWAP:
2589         case STIMULUS_TRANSFER_TARGET_HANGUP:
2590         case STIMULUS_TRANSFER_TARGET_ANSWER:
2591         case STIMULUS_TRANSFERER_HANGUP:
2592         case STIMULUS_RECALL_TARGET_HANGUP:
2593         case STIMULUS_RECALL_TARGET_ANSWER:
2594         default:
2595                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2596                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2597                 return props->state;
2598         }
2599 }
2600
2601 static int attach_framehook(struct attended_transfer_properties *props, struct ast_channel *channel);
2602
2603 static int retransfer_enter(struct attended_transfer_properties *props)
2604 {
2605         RAII_VAR(struct ast_format_cap *, cap, ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT), ao2_cleanup);
2606         char destination[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
2607         int cause;
2608
2609         if (!cap) {
2610                 return -1;
2611         }
2612
2613         snprintf(destination, sizeof(destination), "%s@%s", props->exten, props->context);
2614
2615         ast_format_cap_append(cap, ast_format_slin, 0);
2616
2617         /* Get a channel that is the destination we wish to call */
2618         props->recall_target = ast_request("Local", cap, NULL, NULL, destination, &cause);
2619         if (!props->recall_target) {
2620                 ast_log(LOG_ERROR, "Unable to request outbound channel for recall target\n");
2621                 return -1;
2622         }
2623
2624         if (attach_framehook(props, props->recall_target)) {
2625                 ast_log(LOG_ERROR, "Unable to attach framehook to recall target\n");
2626                 ast_hangup(props->recall_target);
2627                 props->recall_target = NULL;
2628                 return -1;
2629         }
2630
2631         /*
2632          * Setup callid, variables, datastores, accountcode, peeraccount,
2633          * and COLP on the recalled transfer target.
2634          */
2635         ast_channel_lock_both(props->recall_target, props->transferer);
2636
2637         ast_party_connected_line_copy(ast_channel_connected(props->recall_target),
2638                 &props->original_transferer_colp);
2639         ast_party_id_reset(&ast_channel_connected(props->recall_target)->priv);
2640
2641         common_recall_channel_setup(props->recall_target, props->recall_target);
2642         ast_channel_unlock(props->recall_target);
2643         ast_channel_unlock(props->transferer);
2644
2645         if (ast_call(props->recall_target, destination, 0)) {
2646                 ast_log(LOG_ERROR, "Unable to place outbound call to recall target\n");
2647                 ast_hangup(props->recall_target);
2648                 props->recall_target = NULL;
2649                 return -1;
2650         }
2651
2652         ast_channel_ref(props->recall_target);
2653         if (ast_bridge_impart(props->transferee_bridge, props->recall_target, NULL, NULL,
2654                 AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
2655                 ast_log(LOG_ERROR, "Unable to place recall target into bridge\n");
2656                 ast_hangup(props->recall_target);
2657                 ast_channel_unref(props->recall_target);
2658                 return -1;
2659         }
2660
2661         return 0;
2662 }
2663
2664 static enum attended_transfer_state retransfer_exit(struct attended_transfer_properties *props,
2665                 enum attended_transfer_stimulus stimulus)
2666 {
2667         switch (stimulus) {
2668         case STIMULUS_TRANSFEREE_HANGUP:
2669                 return TRANSFER_FAIL;
2670         case STIMULUS_TIMEOUT:
2671                 ast_softhangup(props->recall_target, AST_SOFTHANGUP_EXPLICIT);
2672         case STIMULUS_RECALL_TARGET_HANGUP:
2673                 props->recall_target = ast_channel_unref(props->recall_target);
2674                 if (props->atxferloopdelay) {
2675                         return TRANSFER_WAIT_TO_RECALL;
2676                 }
2677                 return TRANSFER_RECALLING;
2678         case STIMULUS_RECALL_TARGET_ANSWER:
2679                 return TRANSFER_RESUME;
2680         case STIMULUS_NONE:
2681         case STIMULUS_DTMF_ATXFER_ABORT:
2682         case STIMULUS_DTMF_ATXFER_COMPLETE:
2683         case STIMULUS_DTMF_ATXFER_THREEWAY:
2684         case STIMULUS_DTMF_ATXFER_SWAP:
2685         case STIMULUS_TRANSFER_TARGET_HANGUP:
2686         case STIMULUS_TRANSFER_TARGET_ANSWER:
2687         case STIMULUS_TRANSFERER_HANGUP:
2688         default:
2689                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2690                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2691                 return props->state;
2692         }
2693 }
2694
2695 static int wait_to_recall_enter(struct attended_transfer_properties *props)
2696 {
2697         bridge_hold(props->transferee_bridge);
2698         return 0;
2699 }
2700
2701 static enum attended_transfer_state wait_to_recall_exit(struct attended_transfer_properties *props,
2702                 enum attended_transfer_stimulus stimulus)
2703 {
2704         bridge_unhold(props->transferee_bridge);
2705         switch (stimulus) {
2706         case STIMULUS_TRANSFEREE_HANGUP:
2707                 return TRANSFER_FAIL;
2708         case STIMULUS_TIMEOUT:
2709                 return TRANSFER_RECALLING;
2710         case STIMULUS_NONE:
2711         case STIMULUS_DTMF_ATXFER_ABORT:
2712         case STIMULUS_DTMF_ATXFER_COMPLETE:
2713         case STIMULUS_DTMF_ATXFER_THREEWAY:
2714         case STIMULUS_DTMF_ATXFER_SWAP:
2715         case STIMULUS_TRANSFER_TARGET_HANGUP:
2716         case STIMULUS_TRANSFER_TARGET_ANSWER:
2717         case STIMULUS_TRANSFERER_HANGUP:
2718         case STIMULUS_RECALL_TARGET_HANGUP:
2719         case STIMULUS_RECALL_TARGET_ANSWER:
2720         default:
2721                 ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2722                                 stimulus_strs[stimulus], state_properties[props->state].state_name);
2723                 return props->state;
2724         }
2725 }
2726
2727 static int fail_enter(struct attended_transfer_properties *props)
2728 {
2729         if (props->transferee_bridge) {
2730                 ast_bridge_destroy(props->transferee_bridge, 0);
2731                 props->transferee_bridge = NULL;
2732         }
2733         return 0;
2734 }
2735
2736 /*!
2737  * \brief DTMF hook when transferer presses abort sequence.
2738  *
2739  * Sends a stimulus to the attended transfer monitor thread that the abort sequence has been pressed
2740  */
2741 static int atxfer_abort(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2742 {
2743         struct attended_transfer_properties *props = hook_pvt;
2744
2745         ast_debug(1, "Transferer on attended transfer %p pressed abort sequence\n", props);
2746         stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_ABORT);
2747         return 0;
2748 }
2749
2750 /*!
2751  * \brief DTMF hook when transferer presses complete sequence.
2752  *
2753  * Sends a stimulus to the attended transfer monitor thread that the complete sequence has been pressed
2754  */
2755 static int atxfer_complete(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2756 {
2757         struct attended_transfer_properties *props = hook_pvt;
2758
2759         ast_debug(1, "Transferer on attended transfer %p pressed complete sequence\n", props);
2760         stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_COMPLETE);
2761         return 0;
2762 }
2763
2764 /*!
2765  * \brief DTMF hook when transferer presses threeway sequence.
2766  *
2767  * Sends a stimulus to the attended transfer monitor thread that the threeway sequence has been pressed
2768  */
2769 static int atxfer_threeway(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2770 {
2771         struct attended_transfer_properties *props = hook_pvt;
2772
2773         ast_debug(1, "Transferer on attended transfer %p pressed threeway sequence\n", props);
2774         stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_THREEWAY);
2775         return 0;
2776 }
2777
2778 /*!
2779  * \brief DTMF hook when transferer presses swap sequence.
2780  *
2781  * Sends a stimulus to the attended transfer monitor thread that the swap sequence has been pressed
2782  */
2783 static int atxfer_swap(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2784 {
2785         struct attended_transfer_properties *props = hook_pvt;
2786
2787         ast_debug(1, "Transferer on attended transfer %p pressed swap sequence\n", props);
2788         stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_SWAP);
2789         return 0;
2790 }
2791
2792 /*!
2793  * \brief Hangup hook for transferer channel.
2794  *
2795  * Sends a stimulus to the attended transfer monitor thread that the transferer has hung up.
2796  */
2797 static int atxfer_transferer_hangup(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2798 {
2799         struct attended_transfer_properties *props = hook_pvt;
2800
2801         ast_debug(1, "Transferer on attended transfer %p hung up\n", props);
2802         stimulate_attended_transfer(props, STIMULUS_TRANSFERER_HANGUP);
2803         return 0;
2804 }
2805
2806 /*!
2807  * \brief Frame hook for transfer target channel
2808  *
2809  * This is used to determine if the transfer target or recall target has answered
2810  * the outgoing call.
2811  *
2812  * When an answer is detected, a stimulus is sent to the attended transfer monitor
2813  * thread to indicate that the transfer target or recall target has answered.
2814  *
2815  * \param chan The channel the framehook is attached to.
2816  * \param frame The frame being read or written.
2817  * \param event What is being done with the frame.
2818  * \param data The attended transfer properties.
2819  */
2820 static struct ast_frame *transfer_target_framehook_cb(struct ast_channel *chan,
2821                 struct ast_frame *frame, enum ast_framehook_event event, void *data)
2822 {
2823         struct attended_transfer_properties *props = data;
2824
2825         if (event == AST_FRAMEHOOK_EVENT_READ &&
2826                         frame && frame->frametype == AST_FRAME_CONTROL &&
2827                         frame->subclass.integer == AST_CONTROL_ANSWER &&
2828                         !ast_check_hangup(chan)) {
2829
2830                 ast_debug(1, "Detected an answer for recall attempt on attended transfer %p\n", props);
2831                 if (props->superstate == SUPERSTATE_TRANSFER) {
2832                         stimulate_attended_transfer(props, STIMULUS_TRANSFER_TARGET_ANSWER);
2833                 } else {
2834                         stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_ANSWER);
2835                 }
2836                 ast_framehook_detach(chan, props->target_framehook_id);
2837                 props->target_framehook_id = -1;
2838         }
2839
2840         return frame;
2841 }
2842
2843 /*! \brief Callback function which informs upstream if we are consuming a frame of a specific type */
2844 static int transfer_target_framehook_consume(void *data, enum ast_frame_type type)
2845 {
2846         return (type == AST_FRAME_CONTROL ? 1 : 0);
2847 }
2848
2849 static void transfer_target_framehook_destroy_cb(void *data)
2850 {
2851         struct attended_transfer_properties *props = data;
2852         ao2_cleanup(props);
2853 }
2854
2855 static int bridge_personality_atxfer_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
2856 {
2857         const char *abort_dtmf;
2858         const char *complete_dtmf;
2859         const char *threeway_dtmf;
2860         const char *swap_dtmf;
2861         struct bridge_basic_personality *personality = self->personality;
2862
2863         if (!ast_channel_has_role(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME)) {
2864                 return 0;
2865         }
2866
2867         abort_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "abort");
2868         complete_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "complete");
2869         threeway_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "threeway");
2870         swap_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "swap");
2871
2872         if (!ast_strlen_zero(abort_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2873                         abort_dtmf, atxfer_abort, personality->details[personality->current].pvt, NULL,
2874                         AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE | AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
2875                 return -1;
2876         }
2877         if (!ast_strlen_zero(complete_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2878                         complete_dtmf, atxfer_complete, personality->details[personality->current].pvt, NULL,
2879                         AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE | AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
2880                 return -1;
2881         }
2882         if (!ast_strlen_zero(threeway_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2883                         threeway_dtmf, atxfer_threeway, personality->details[personality->current].pvt, NULL,
2884                         AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE | AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
2885                 return -1;
2886         }
2887         if (!ast_strlen_zero(swap_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2888                         swap_dtmf, atxfer_swap, personality->details[personality->current].pvt, NULL,
2889                         AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE | AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
2890                 return -1;
2891         }
2892         if (ast_bridge_hangup_hook(bridge_channel->features, atxfer_transferer_hangup,
2893                         personality->details[personality->current].pvt, NULL,
2894                         AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE | AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
2895                 return -1;
2896         }
2897
2898         return 0;
2899 }
2900
2901 static void transfer_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct attended_transfer_properties *props)
2902 {
2903         if (self->num_channels > 1 || bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
2904                 return;
2905         }
2906
2907         if (self->num_channels == 1) {
2908                 struct ast_bridge_channel *transferer_bridge_channel;
2909                 int not_transferer;
2910
2911                 ast_channel_lock(props->transferer);
2912                 transferer_bridge_channel = ast_channel_get_bridge_channel(props->transferer);
2913                 ast_channel_unlock(props->transferer);
2914
2915                 if (!transferer_bridge_channel) {
2916                         return;
2917                 }
2918
2919                 not_transferer = AST_LIST_FIRST(&self->channels) != transferer_bridge_channel;
2920                 ao2_ref(transferer_bridge_channel, -1);
2921                 if (not_transferer) {
2922                         return;
2923                 }
2924         }
2925
2926         /* Reaching this point means that either
2927          * 1) The bridge has no channels in it
2928          * 2) The bridge has one channel, and it's the transferer
2929          * In either case, it indicates that the non-transferer parties
2930          * are no longer in the bridge.
2931          */
2932         if (self == props->transferee_bridge) {
2933                 stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2934         } else {
2935                 stimulate_attended_transfer(props, STIMULUS_TRANSFER_TARGET_HANGUP);
2936         }
2937 }
2938
2939 static void recall_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct attended_transfer_properties *props)
2940 {
2941         if (self == props->target_bridge) {
2942                 /* Once we're in the recall superstate, we no longer care about this bridge */
2943                 return;
2944         }
2945
2946         if (bridge_channel->chan == props->recall_target) {
2947                 stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_HANGUP);
2948                 return;
2949         }
2950
2951         if (self->num_channels == 0) {
2952                 /* Empty bridge means all transferees are gone for sure */
2953                 stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2954                 return;
2955         }
2956
2957         if (self->num_channels == 1) {
2958                 struct ast_bridge_channel *target_bridge_channel;
2959
2960                 if (!props->recall_target) {
2961                         /* No recall target means that the pull happened on a transferee. If there's still
2962                          * a channel left in the bridge, we don't need to send a stimulus
2963                          */
2964                         return;
2965                 }
2966
2967                 ast_channel_lock(props->recall_target);
2968                 target_bridge_channel = ast_channel_get_bridge_channel(props->recall_target);
2969                 ast_channel_unlock(props->recall_target);
2970
2971                 if (target_bridge_channel) {
2972                         if (AST_LIST_FIRST(&self->channels) == target_bridge_channel) {
2973                                 stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2974                         }
2975                         ao2_ref(target_bridge_channel, -1);
2976                 }
2977         }
2978 }
2979
2980 static void bridge_personality_atxfer_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
2981 {
2982         struct bridge_basic_personality *personality = self->personality;
2983         struct attended_transfer_properties *props = personality->details[personality->current].pvt;
2984
2985         switch (props->superstate) {
2986         case SUPERSTATE_TRANSFER:
2987                 transfer_pull(self, bridge_channel, props);
2988                 break;
2989         case SUPERSTATE_RECALL:
2990                 recall_pull(self, bridge_channel, props);
2991                 break;
2992         }
2993 }
2994
2995 static enum attended_transfer_stimulus wait_for_stimulus(struct attended_transfer_properties *props)
2996 {
2997         enum attended_transfer_stimulus stimulus;
2998         struct stimulus_list *list;
2999         SCOPED_MUTEX(lock, ao2_object_get_lockaddr(props));
3000
3001         while (!(list = AST_LIST_REMOVE_HEAD(&props->stimulus_queue, next))) {
3002                 if (!(state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMED)) {
3003                         ast_cond_wait(&props->cond, lock);
3004                 } else {
3005                         struct timeval relative_timeout = { 0, };
3006                         struct timeval absolute_timeout;
3007                         struct timespec timeout_arg;
3008
3009                         if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMER_RESET) {
3010                                 props->start = ast_tvnow();
3011                         }
3012
3013                         if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY) {
3014                                 relative_timeout.tv_sec = props->atxferloopdelay;
3015                         } else {
3016                                 /* Implied TRANSFER_STATE_FLAG_TIMER_ATXFER_NO_ANSWER */
3017                                 relative_timeout.tv_sec = props->atxfernoanswertimeout;
3018                         }
3019
3020                         absolute_timeout = ast_tvadd(props->start, relative_timeout);
3021                         timeout_arg.tv_sec = absolute_timeout.tv_sec;
3022                         timeout_arg.tv_nsec = absolute_timeout.tv_usec * 1000;
3023
3024                         if (ast_cond_timedwait(&props->cond, lock, &timeout_arg) == ETIMEDOUT) {
3025                                 return STIMULUS_TIMEOUT;
3026                         }
3027                 }
3028         }
3029         stimulus = list->stimulus;
3030         ast_free(list);
3031         return stimulus;
3032 }
3033
3034 /*!
3035  * \brief The main loop for the attended transfer monitor thread.
3036  *
3037  * This loop runs continuously until the attended transfer reaches
3038  * a terminal state. Stimuli for changes in the attended transfer
3039  * state are handled in this thread so that all factors in an
3040  * attended transfer can be handled in an orderly fashion.
3041  *
3042  * \param data The attended transfer properties
3043  */
3044 static void *attended_transfer_monitor_thread(void *data)
3045 {
3046         struct attended_transfer_properties *props = data;
3047         ast_callid callid;
3048
3049         /*
3050          * Set thread callid to the transferer's callid because we
3051          * are doing all this on that channel's behalf.
3052          */
3053         ast_channel_lock(props->transferer);
3054         callid = ast_channel_callid(props->transferer);
3055         ast_channel_unlock(props->transferer);
3056         if (callid) {
3057                 ast_callid_threadassoc_add(callid);
3058         }
3059
3060         for (;;) {
3061                 enum attended_transfer_stimulus stimulus;
3062
3063                 ast_debug(1, "About to enter state %s for attended transfer %p\n", state_properties[props->state].state_name, props);
3064
3065                 if (state_properties[props->state].enter &&
3066                                 state_properties[props->state].enter(props)) {
3067                         ast_log(LOG_ERROR, "State %s enter function returned an error for attended transfer %p\n",
3068                                         state_properties[props->state].state_name, props);
3069                         break;
3070                 }
3071
3072                 if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TERMINAL) {
3073                         ast_debug(1, "State %s is a terminal state. Ending attended transfer %p\n",
3074                                         state_properties[props->state].state_name, props);
3075                         break;
3076                 }
3077
3078                 stimulus = wait_for_stimulus(props);
3079
3080                 ast_debug(1, "Received stimulus %s on attended transfer %p\n", stimulus_strs[stimulus], props);
3081
3082                 ast_assert(state_properties[props->state].exit != NULL);
3083
3084                 props->state = state_properties[props->state].exit(props, stimulus);
3085
3086                 ast_debug(1, "Told to enter state %s exit on attended transfer %p\n", state_properties[props->state].state_name, props);
3087         }
3088
3089         attended_transfer_properties_shutdown(props);
3090
3091         if (callid) {
3092                 ast_callid_threadassoc_remove();
3093         }
3094
3095         return NULL;
3096 }
3097
3098 static int attach_framehook(struct attended_transfer_properties *props, struct ast_channel *channel)
3099 {
3100         struct ast_framehook_interface target_interface = {
3101                 .version = AST_FRAMEHOOK_INTERFACE_VERSION,
3102                 .event_cb = transfer_target_framehook_cb,
3103                 .destroy_cb = transfer_target_framehook_destroy_cb,
3104                 .consume_cb = transfer_target_framehook_consume,
3105                 .disable_inheritance = 1,
3106         };
3107
3108         ao2_ref(props, +1);
3109         target_interface.data = props;
3110
3111         ast_channel_lock(channel);
3112         props->target_framehook_id = ast_framehook_attach(channel, &target_interface);
3113         ast_channel_unlock(channel);
3114         if (props->target_framehook_id == -1) {
3115                 ao2_ref(props, -1);
3116                 return -1;
3117         }
3118         return 0;
3119 }
3120
3121 static int add_transferer_role(struct ast_channel *chan, struct ast_bridge_features_attended_transfer *attended_transfer)
3122 {
3123         const char *atxfer_abort;
3124         const char *atxfer_threeway;
3125         const char *atxfer_complete;
3126         const char *atxfer_swap;
3127         struct ast_features_xfer_config *xfer_cfg;
3128         SCOPED_CHANNELLOCK(lock, chan);
3129
3130         xfer_cfg = ast_get_chan_features_xfer_config(chan);
3131         if (!xfer_cfg) {
3132                 return -1;
3133         }
3134         if (attended_transfer) {
3135                 atxfer_abort = ast_strdupa(S_OR(attended_transfer->abort, xfer_cfg->atxferabort));
3136                 atxfer_threeway = ast_strdupa(S_OR(attended_transfer->threeway, xfer_cfg->atxferthreeway));
3137                 atxfer_complete = ast_strdupa(S_OR(attended_transfer->complete, xfer_cfg->atxfercomplete));
3138                 atxfer_swap = ast_strdupa(S_OR(attended_transfer->swap, xfer_cfg->atxferswap));
3139         } else {
3140                 atxfer_abort = ast_strdupa(xfer_cfg->atxferabort);
3141                 atxfer_threeway = ast_strdupa(xfer_cfg->atxferthreeway);
3142                 atxfer_complete = ast_strdupa(xfer_cfg->atxfercomplete);
3143                 atxfer_swap = ast_strdupa(xfer_cfg->atxferswap);
3144         }
3145         ao2_ref(xfer_cfg, -1);
3146
3147         return ast_channel_add_bridge_role(chan, AST_TRANSFERER_ROLE_NAME) ||
3148                 ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "abort", atxfer_abort) ||
3149                 ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "complete", atxfer_complete) ||
3150                 ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "threeway", atxfer_threeway) ||
3151                 ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "swap", atxfer_swap);
3152 }
3153
3154 /*!
3155  * \brief Helper function that presents dialtone and grabs extension
3156  *
3157  * \retval 0 on success
3158  * \retval -1 on failure
3159  */
3160 static int grab_transfer(struct ast_channel *chan, char *exten, size_t exten_len, const char *context)
3161 {
3162         int res;
3163         int digit_timeout;
3164         int attempts = 0;
3165         int max_attempts;
3166         struct ast_features_xfer_config *xfer_cfg;
3167         char *retry_sound;
3168         char *invalid_sound;
3169
3170         ast_channel_lock(chan);
3171         xfer_cfg = ast_get_chan_features_xfer_config(chan);
3172         if (!xfer_cfg) {
3173                 ast_log(LOG_ERROR, "Channel %s: Unable to get transfer configuration\n",
3174                         ast_channel_name(chan));
3175                 ast_channel_unlock(chan);
3176                 return -1;
3177         }
3178         digit_timeout = xfer_cfg->transferdigittimeout * 1000;
3179         max_attempts = xfer_cfg->transferdialattempts;
3180         retry_sound = ast_strdupa(xfer_cfg->transferretrysound);
3181         invalid_sound = ast_strdupa(xfer_cfg->transferinvalidsound);
3182         ao2_ref(xfer_cfg, -1);
3183         ast_channel_unlock(chan);
3184
3185         /* Play the simple "transfer" prompt out and wait */
3186         res = ast_stream_and_wait(chan, "pbx-transfer", AST_DIGIT_ANY);
3187         ast_stopstream(chan);
3188         if (res < 0) {
3189                 /* Hangup or error */
3190                 return -1;
3191         }
3192         if (res) {
3193                 /* Store the DTMF digit that interrupted playback of the file. */
3194                 exten[0] = res;
3195         }
3196
3197         /* Drop to dialtone so they can enter the extension they want to transfer to */
3198         do {
3199                 ++attempts;
3200
3201                 ast_test_suite_event_notify("TRANSFER_BEGIN_DIAL",
3202                                 "Channel: %s\r\n"
3203                                 "Attempt: %d",
3204                                 ast_channel_name(chan), attempts);
3205                 res = ast_app_dtget(chan, context, exten, exten_len, exten_len - 1, digit_timeout);
3206                 ast_test_suite_event_notify("TRANSFER_DIALLED",
3207                                 "Channel: %s\r\n"
3208                                 "Attempt: %d\r\n"
3209                                 "Dialled: %s\r\n"
3210                                 "Result: %s",
3211                                 ast_channel_name(chan), attempts, exten, res > 0 ? "Success" : "Failure");
3212                 if (res < 0) {
3213                         /* Hangup or error */
3214                         res = -1;
3215                 } else if (!res) {
3216                         /* 0 for invalid extension dialed. */
3217                         if (ast_strlen_zero(exten)) {
3218                                 ast_verb(4, "%s dialed no digits.\n", ast_channel_name(chan));
3219                         } else {
3220                                 ast_verb(4, "%s dialed '%s@%s' does not exist.\n",
3221                                         ast_channel_name(chan), exten, context);
3222                         }
3223                         if (attempts < max_attempts) {
3224                                 ast_stream_and_wait(chan, retry_sound, AST_DIGIT_NONE);
3225                         } else {
3226                                 ast_stream_and_wait(chan, invalid_sound, AST_DIGIT_NONE);
3227                         }
3228                         memset(exten, 0, exten_len);
3229                         res = 1;
3230                 } else {
3231                         /* Dialed extension is valid. */
3232                         res = 0;
3233                 }
3234         } while (res > 0 && attempts < max_attempts);
3235
3236         ast_test_suite_event_notify("TRANSFER_DIAL_FINAL",
3237                         "Channel: %s\r\n"
3238                         "Result: %s",
3239                         ast_channel_name(chan), res == 0 ? "Success" : "Failure");
3240
3241         return res ? -1 : 0;
3242 }
3243
3244 static void copy_caller_data(struct ast_channel *dest, struct ast_channel *caller)
3245 {
3246         ast_channel_lock_both(caller, dest);
3247         ast_connected_line_copy_from_caller(ast_channel_connected(dest), ast_channel_caller(caller));
3248         ast_channel_inherit_variables(caller, dest);
3249         ast_channel_datastore_inherit(caller, dest);
3250         ast_channel_unlock(dest);
3251         ast_channel_unlock(caller);
3252 }
3253
3254 /*! \brief Helper function that creates an outgoing channel and returns it immediately */
3255 static struct ast_channel *dial_transfer(struct ast_channel *caller, const char *destination)
3256 {
3257         struct ast_channel *chan;
3258         int cause;
3259
3260         /* Now we request a local channel to prepare to call the destination */
3261         chan = ast_request("Local", ast_channel_nativeformats(caller), NULL, caller, destination,
3262                 &cause);
3263         if (!chan) {
3264                 return NULL;
3265         }
3266
3267         ast_channel_lock_both(chan, caller);
3268
3269         ast_channel_req_accountcodes(chan, caller, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
3270
3271         /* Who is transferring the call. */
3272         pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", ast_channel_name(caller));
3273
3274         ast_bridge_set_transfer_variables(chan, ast_channel_name(caller), 1);
3275
3276         ast_channel_unlock(chan);
3277         ast_channel_unlock(caller);
3278
3279         /* Before we actually dial out let's inherit appropriate information. */
3280         copy_caller_data(chan, caller);
3281
3282         return chan;
3283 }
3284
3285 /*!
3286  * \brief Internal built in feature for attended transfers
3287  *
3288  * This hook will set up a thread for monitoring the progress of
3289  * an attended transfer. For more information about attended transfer
3290  * progress, see documentation on the transfer state machine.
3291  *
3292  * \param bridge_channel The channel that pressed the attended transfer DTMF sequence
3293  * \param hook_pvt Structure with further information about the attended transfer
3294  */
3295 static int feature_attended_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
3296 {
3297         struct ast_bridge_features_attended_transfer *attended_transfer = hook_pvt;
3298         struct attended_transfer_properties *props;
3299         struct ast_bridge *bridge;
3300         char destination[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 1];
3301         char exten[AST_MAX_EXTENSION] = "";
3302         pthread_t thread;
3303
3304         /* Inhibit the bridge before we do anything else. */
3305         bridge = ast_bridge_channel_merge_inhibit(bridge_channel, +1);
3306
3307         if (strcmp(bridge->v_table->name, "basic")) {
3308                 ast_log(LOG_ERROR, "Channel %s: Attended transfer attempted on unsupported bridge type '%s'.\n",
3309                         ast_channel_name(bridge_channel->chan), bridge->v_table->name);
3310                 ast_bridge_merge_inhibit(bridge, -1);
3311                 ao2_ref(bridge, -1);
3312                 return 0;
3313         }
3314
3315         /* Was the bridge inhibited before we inhibited it? */
3316         if (1 < bridge->inhibit_merge) {
3317                 /*
3318                  * The peer likely initiated attended transfer at the same time
3319                  * and we lost the race.
3320                  */
3321                 ast_verb(3, "Channel %s: Bridge '%s' does not permit merging at this time.\n",
3322                         ast_channel_name(bridge_channel->chan), bridge->uniqueid);
3323                 ast_bridge_merge_inhibit(bridge, -1);
3324                 ao2_ref(bridge, -1);
3325                 return 0;
3326         }
3327
3328         props = attended_transfer_properties_alloc(bridge_channel->chan,
3329                 attended_transfer ? attended_transfer->context : NULL);
3330         if (!props) {
3331                 ast_log(LOG_ERROR, "Channel %s: Unable to allocate control structure for performing attended transfer.\n",
3332                         ast_channel_name(bridge_channel->chan));
3333                 ast_bridge_merge_inhibit(bridge, -1);
3334                 ao2_ref(bridge, -1);
3335                 return 0;
3336         }
3337
3338         props->transferee_bridge = bridge;
3339
3340         if (add_transferer_role(props->transferer, attended_transfer)) {
3341                 ast_log(LOG_ERROR, "Channel %s: Unable to set transferrer bridge role.\n",
3342                         ast_channel_name(bridge_channel->chan));
3343                 attended_transfer_properties_shutdown(props);
3344                 return 0;
3345         }
3346
3347         ast_bridge_channel_write_hold(bridge_channel, NULL);
3348
3349         /* Grab the extension to transfer to */
3350         if (grab_transfer(bridge_channel->chan, exten, sizeof(exten), props->context)) {
3351                 /*
3352                  * XXX The warning here really should be removed.  While the
3353                  * message is accurate, this is a normal exit for when the user
3354                  * fails to specify a valid transfer target.  e.g., The user
3355                  * hungup, didn't dial any digits, or dialed an invalid
3356                  * extension.
3357                  */
3358                 ast_log(LOG_WARNING, "Channel %s: Unable to acquire target extension for attended transfer.\n",
3359                         ast_channel_name(bridge_channel->chan));
3360                 ast_bridge_channel_write_unhold(bridge_channel);
3361                 attended_transfer_properties_shutdown(props);
3362                 return 0;
3363         }
3364
3365         ast_string_field_set(props, exten, exten);
3366
3367         /* Fill the variable with the extension and context we want to call */
3368         snprintf(destination, sizeof(destination), "%s@%s", props->exten, props->context);
3369
3370         ast_debug(1, "Channel %s: Attended transfer target '%s'\n",
3371                 ast_channel_name(bridge_channel->chan), destination);
3372
3373         /* Get a channel that is the destination we wish to call */
3374         props->transfer_target = dial_transfer(bridge_channel->chan, destination);
3375         if (!props->transfer_target) {
3376                 ast_log(LOG_ERROR, "Channel %s: Unable to request outbound channel for attended transfer target.\n",
3377                         ast_channel_name(bridge_channel->chan));
3378                 stream_failsound(props->transferer);
3379                 ast_bridge_channel_write_unhold(bridge_channel);
3380                 attended_transfer_properties_shutdown(props);
3381                 return 0;
3382         }
3383
3384
3385         /* Create a bridge to use to talk to the person we are calling */
3386         props->target_bridge = ast_bridge_basic_new();
3387         if (!props->target_bridge) {
3388                 ast_log(LOG_ERROR, "Channel %s: Unable to create bridge for attended transfer target.\n",
3389                         ast_channel_name(bridge_channel->chan));
3390                 stream_failsound(props->transferer);
3391                 ast_bridge_channel_write_unhold(bridge_channel);
3392                 ast_hangup(props->transfer_target);
3393                 props->transfer_target = NULL;
3394                 attended_transfer_properties_shutdown(props);
3395                 return 0;
3396         }
3397         ast_bridge_merge_inhibit(props->target_bridge, +1);
3398
3399         if (attach_framehook(props, props->transfer_target)) {
3400                 ast_log(LOG_ERROR, "Channel %s: Unable to attach framehook to transfer target.\n",
3401                         ast_channel_name(bridge_channel->chan));
3402                 stream_failsound(props->transferer);
3403                 ast_bridge_channel_write_unhold(bridge_channel);
3404                 ast_hangup(props->transfer_target);
3405                 props->transfer_target = NULL;
3406                 attended_transfer_properties_shutdown(props);
3407                 return 0;
3408         }
3409
3410         bridge_basic_change_personality(props->target_bridge,
3411                         BRIDGE_BASIC_PERSONALITY_ATXFER, props);
3412         bridge_basic_change_personality(bridge,
3413                         BRIDGE_BASIC_PERSONALITY_ATXFER, props);
3414
3415         if (ast_call(props->transfer_target, destination, 0)) {
3416                 ast_log(LOG_ERROR, "Channel %s: Unable to place outbound call to transfer target.\n",
3417                         ast_channel_name(bridge_channel->chan));
3418                 stream_failsound(props->transferer);
3419                 ast_bridge_channel_write_unhold(bridge_channel);
3420                 ast_hangup(props->transfer_target);
3421                 props->transfer_target = NULL;
3422                 attended_transfer_properties_shutdown(props);
3423                 return 0;
3424         }
3425
3426         /* We increase the refcount of the transfer target because ast_bridge_impart() will
3427          * steal the reference we already have. We need to keep a reference, so the only
3428          * choice is to give it a bump
3429          */
3430         ast_channel_ref(props->transfer_target);
3431         if (ast_bridge_impart(props->target_bridge, props->transfer_target, NULL, NULL,
3432                 AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
3433                 ast_log(LOG_ERROR, "Channel %s: Unable to place transfer target into bridge.\n",
3434                         ast_channel_name(bridge_channel->chan));
3435                 stream_failsound(props->transferer);
3436                 ast_bridge_channel_write_unhold(bridge_channel);
3437                 ast_hangup(props->transfer_target);
3438                 props->transfer_target = NULL;
3439                 attended_transfer_properties_shutdown(props);
3440                 return 0;
3441         }
3442
3443         if (ast_pthread_create_detached(&thread, NULL, attended_transfer_monitor_thread, props)) {
3444                 ast_log(LOG_ERROR, "Channel %s: Unable to create monitoring thread for attended transfer.\n",
3445                         ast_channel_name(bridge_channel->chan));
3446                 stream_failsound(props->transferer);
3447                 ast_bridge_channel_write_unhold(bridge_channel);
3448                 attended_transfer_properties_shutdown(props);
3449                 return 0;
3450         }
3451
3452         /* Once the monitoring thread has been created, it is responsible for destroying all
3453          * of the necessary components.
3454          */
3455         return 0;
3456 }
3457
3458 static void blind_transfer_cb(struct ast_channel *new_channel, struct transfer_channel_data *user_data_wrapper,
3459                 enum ast_transfer_type transfer_type)
3460 {
3461         struct ast_channel *transferer_channel = user_data_wrapper->data;
3462
3463         if (transfer_type == AST_BRIDGE_TRANSFER_MULTI_PARTY) {
3464                 copy_caller_data(new_channel, transferer_channel);
3465         }
3466 }
3467
3468 /*! \brief Internal built in feature for blind transfers */
3469 static int feature_blind_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
3470 {
3471         char xfer_exten[AST_MAX_EXTENSION] = "";
3472         struct ast_bridge_features_blind_transfer *blind_transfer = hook_pvt;
3473         const char *xfer_context;
3474         char *goto_on_blindxfr;
3475
3476         ast_bridge_channel_write_hold(bridge_channel, NULL);
3477
3478         ast_channel_lock(bridge_channel->chan);
3479         xfer_context = ast_strdupa(get_transfer_context(bridge_channel->chan,
3480                 blind_transfer ? blind_transfer->context : NULL));
3481         goto_on_blindxfr = ast_strdupa(S_OR(pbx_builtin_getvar_helper(bridge_channel->chan,
3482                 "GOTO_ON_BLINDXFR"), ""));
3483         ast_channel_unlock(bridge_channel->chan);
3484
3485         /* Grab the extension to transfer to */
3486         if (grab_transfer(bridge_channel->chan, xfer_exten, sizeof(xfer_exten), xfer_context)) {
3487                 ast_bridge_channel_write_unhold(bridge_channel);
3488                 return 0;
3489         }
3490
3491         ast_debug(1, "Channel %s: Blind transfer target '%s@%s'\n",
3492                 ast_channel_name(bridge_channel->chan), xfer_exten, xfer_context);
3493
3494         if (!ast_strlen_zero(goto_on_blindxfr)) {
3495                 const char *chan_context;
3496                 const char *chan_exten;
3497                 int chan_priority;
3498
3499                 ast_debug(1, "After transfer, transferrer %s goes to %s\n",
3500                         ast_channel_name(bridge_channel->chan), goto_on_blindxfr);
3501
3502                 ast_channel_lock(bridge_channel->chan);
3503                 chan_context = ast_strdupa(ast_channel_context(bridge_channel->chan));
3504                 chan_exten = ast_strdupa(ast_channel_exten(bridge_channel->chan));
3505                 chan_priority = ast_channel_priority(bridge_channel->chan);
3506                 ast_channel_unlock(bridge_channel->chan);
3507                 ast_bridge_set_after_go_on(bridge_channel->chan,
3508                         chan_context, chan_exten, chan_priority, goto_on_blindxfr);
3509         }
3510
3511         if (ast_bridge_transfer_blind(0, bridge_channel->chan, xfer_exten, xfer_context,
3512                 blind_transfer_cb, bridge_channel->chan) != AST_BRIDGE_TRANSFER_SUCCESS
3513                 && !ast_strlen_zero(goto_on_blindxfr)) {
3514                 ast_bridge_discard_after_goto(bridge_channel->chan);
3515         }
3516
3517         return 0;
3518 }
3519
3520 struct ast_bridge_methods ast_bridge_basic_v_table;
3521 struct ast_bridge_methods personality_normal_v_table;
3522 struct ast_bridge_methods personality_atxfer_v_table;
3523
3524 static void bridge_basic_change_personality(struct ast_bridge *bridge,
3525                 enum bridge_basic_personality_type type, void *user_data)
3526 {
3527         struct bridge_basic_personality *personality = bridge->personality;
3528         SCOPED_LOCK(lock, bridge, ast_bridge_lock, ast_bridge_unlock);
3529
3530         remove_hooks_on_personality_change(bridge);
3531
3532         ao2_cleanup(personality->details[personality->current].pvt);
3533         personality->details[personality->current].pvt = NULL;
3534         ast_clear_flag(&bridge->feature_flags, AST_FLAGS_ALL);
3535
3536         personality->current = type;
3537         if (user_data) {
3538                 ao2_ref(user_data, +1);
3539         }
3540         personality->details[personality->current].pvt = user_data;
3541         ast_set_flag(&bridge->feature_flags, personality->details[personality->current].bridge_flags);
3542         if (personality->details[personality->current].on_personality_change) {
3543                 personality->details[personality->current].on_personality_change(bridge);
3544         }
3545 }
3546
3547 static void personality_destructor(void *obj)
3548 {
3549         struct bridge_basic_personality *personality = obj;
3550         int i;
3551
3552         for (i = 0; i < BRIDGE_BASIC_PERSONALITY_END; ++i) {
3553                 ao2_cleanup(personality->details[i].pvt);
3554         }
3555 }
3556
3557 static void on_personality_change_normal(struct ast_bridge *bridge)
3558 {
3559         struct ast_bridge_channel *iter;
3560
3561         AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
3562                 if (add_normal_hooks(bridge, iter)) {
3563                         ast_log(LOG_WARNING, "Unable to set up bridge hooks for channel %s. Features may not work properly\n",
3564                                         ast_channel_name(iter->chan));
3565                 }
3566         }
3567 }
3568
3569 static void init_details(struct personality_details *details,
3570                 enum bridge_basic_personality_type type)
3571 {
3572         switch (type) {
3573         case BRIDGE_BASIC_PERSONALITY_NORMAL:
3574                 details->v_table = &personality_normal_v_table;
3575                 details->bridge_flags = NORMAL_FLAGS;
3576                 details->on_personality_change = on_personality_change_normal;
3577                 break;
3578         case BRIDGE_BASIC_PERSONALITY_ATXFER:
3579                 details->v_table = &personality_atxfer_v_table;
3580                 details->bridge_flags = TRANSFER_FLAGS;
3581                 break;
3582         default:
3583                 ast_log(LOG_WARNING, "Asked to initialize unexpected basic bridge personality type.\n");
3584                 break;
3585         }
3586 }
3587
3588 static struct ast_bridge *bridge_basic_personality_alloc(struct ast_bridge *bridge)
3589 {
3590         struct bridge_basic_personality *personality;
3591         int i;
3592
3593         if (!bridge) {
3594                 return NULL;
3595         }
3596
3597         personality = ao2_alloc(sizeof(*personality), personality_destructor);
3598         if (!personality) {
3599                 ao2_ref(bridge, -1);
3600                 return NULL;
3601         }
3602         for (i = 0; i < BRIDGE_BASIC_PERSONALITY_END; ++i) {
3603                 init_details(&personality->details[i], i);
3604         }
3605         personality->current = BRIDGE_BASIC_PERSONALITY_NORMAL;
3606         bridge->personality = personality;
3607
3608         return bridge;
3609 }
3610
3611 struct ast_bridge *ast_bridge_basic_new(void)
3612 {
3613         struct ast_bridge *bridge;
3614
3615         bridge = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_basic_v_table);
3616         bridge = bridge_base_init(bridge,
3617                 AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX
3618                         | AST_BRIDGE_CAPABILITY_MULTIMIX, NORMAL_FLAGS, NULL, NULL, NULL);
3619         bridge = bridge_basic_personality_alloc(bridge);
3620         bridge = bridge_register(bridge);
3621         return bridge;
3622 }
3623
3624 void ast_bridge_basic_set_flags(struct ast_bridge *bridge, unsigned int flags)
3625 {
3626         SCOPED_LOCK(lock, bridge, ast_bridge_lock, ast_bridge_unlock);
3627         struct bridge_basic_personality *personality = bridge->personality;
3628
3629         personality->details[personality->current].bridge_flags |= flags;
3630         ast_set_flag(&bridge->feature_flags, flags);
3631 }
3632
3633 void ast_bridging_init_basic(void)
3634 {
3635         /* Setup bridge basic subclass v_table. */
3636         ast_bridge_basic_v_table = ast_bridge_base_v_table;
3637         ast_bridge_basic_v_table.name = "basic";
3638         ast_bridge_basic_v_table.push = bridge_basic_push;
3639         ast_bridge_basic_v_table.pull = bridge_basic_pull;
3640         ast_bridge_basic_v_table.destroy = bridge_basic_destroy;
3641
3642         /*
3643          * Personality vtables don't have the same rules as
3644          * normal bridge vtables.  These vtable functions are
3645          * used as alterations to the ast_bridge_basic_v_table
3646          * method functionality and are checked for NULL before
3647          * calling.
3648          */
3649         personality_normal_v_table.name = "normal";
3650         personality_normal_v_table.push = bridge_personality_normal_push;
3651
3652         personality_atxfer_v_table.name = "attended transfer";
3653         personality_atxfer_v_table.push = bridge_personality_atxfer_push;
3654         personality_atxfer_v_table.pull = bridge_personality_atxfer_pull;
3655
3656         ast_bridge_features_register(AST_BRIDGE_BUILTIN_ATTENDEDTRANSFER, feature_attended_transfer, NULL);
3657         ast_bridge_features_register(AST_BRIDGE_BUILTIN_BLINDTRANSFER, feature_blind_transfer, NULL);
3658 }
3659