Asterisk - The Open Source Telephony Project  21.4.1
bridge_basic.c
Go to the documentation of this file.
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"
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 
57 
59  /*! Index for "normal" basic bridge personality */
61  /*! Index for attended transfer basic bridge personality */
63  /*! Indicates end of enum. Must always remain the last element */
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  * \param 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 
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,
305  }
306  ast_bridge_unlock(bridge_channel->bridge);
307  return 0;
308 }
309 
310 /*!
311  * \brief Details for specific basic bridge personalities
312  */
314  /*! The v_table to use for this personality */
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  */
328  /*! The current bridge personality in use */
330  /*! Array of details for the types of bridge personalities supported */
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,
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_AUTOMIXMON, "automixmon", AST_BRIDGE_BUILTIN_AUTOMIXMON);
418 
419  return res ? -1 : 0;
420 }
421 
423  /*! Offset into app_name[] where the channel name that activated the hook starts. */
425  /*! Offset into app_name[] where the dynamic feature name starts. */
427  /*! Offset into app_name[] where the MOH class name starts. (zero if no MOH) */
429  /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
431  /*! Application name to run. */
432  char app_name[0];
433 };
434 
435 static void dynamic_dtmf_hook_callback(struct ast_bridge_channel *bridge_channel,
436  const void *payload, size_t payload_size)
437 {
438  struct ast_channel *chan = bridge_channel->chan;
439  const struct dynamic_dtmf_hook_run *run_data = payload;
440 
441  pbx_builtin_setvar_helper(chan, "DYNAMIC_FEATURENAME",
442  &run_data->app_name[run_data->feature_offset]);
443  pbx_builtin_setvar_helper(chan, "DYNAMIC_WHO_ACTIVATED",
444  &run_data->app_name[run_data->activated_offset]);
445 
446  ast_bridge_channel_run_app(bridge_channel, run_data->app_name,
447  run_data->app_args_offset ? &run_data->app_name[run_data->app_args_offset] : NULL,
448  run_data->moh_offset ? &run_data->app_name[run_data->moh_offset] : NULL);
449 }
450 
452  /*! Which side of bridge to run app (AST_FEATURE_FLAG_ONSELF/AST_FEATURE_FLAG_ONPEER) */
453  unsigned int flags;
454  /*! Offset into app_name[] where the dynamic feature name starts. */
456  /*! Offset into app_name[] where the MOH class name starts. (zero if no MOH) */
458  /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
460  /*! Application name to run. */
461  char app_name[0];
462 };
463 
464 /*!
465  * \internal
466  * \brief Activated dynamic DTMF feature hook.
467  * \since 12.0.0
468  *
469  * \param bridge_channel Channel executing the feature
470  * \param hook_pvt Private data passed in when the hook was created
471  *
472  * \retval 0 Keep the callback hook.
473  * \retval -1 Remove the callback hook.
474  */
475 static int dynamic_dtmf_hook_trip(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
476 {
477  struct dynamic_dtmf_hook_data *pvt = hook_pvt;
478  struct dynamic_dtmf_hook_run *run_data;
479  const char *activated_name;
480  size_t len_name;
481  size_t len_args;
482  size_t len_moh;
483  size_t len_feature;
484  size_t len_activated;
485  size_t len_data;
486 
487  /* Determine lengths of things. */
488  len_name = strlen(pvt->app_name) + 1;
489  len_args = pvt->app_args_offset ? strlen(&pvt->app_name[pvt->app_args_offset]) + 1 : 0;
490  len_moh = pvt->moh_offset ? strlen(&pvt->app_name[pvt->moh_offset]) + 1 : 0;
491  len_feature = strlen(&pvt->app_name[pvt->feature_offset]) + 1;
492  ast_channel_lock(bridge_channel->chan);
493  activated_name = ast_strdupa(ast_channel_name(bridge_channel->chan));
494  ast_channel_unlock(bridge_channel->chan);
495  len_activated = strlen(activated_name) + 1;
496  len_data = sizeof(*run_data) + len_name + len_args + len_moh + len_feature + len_activated;
497 
498  /* Fill in dynamic feature run hook data. */
499  run_data = ast_alloca(len_data);
500  run_data->app_args_offset = len_args ? len_name : 0;
501  run_data->moh_offset = len_moh ? len_name + len_args : 0;
502  run_data->feature_offset = len_name + len_args + len_moh;
503  run_data->activated_offset = len_name + len_args + len_moh + len_feature;
504  strcpy(run_data->app_name, pvt->app_name);/* Safe */
505  if (len_args) {
506  strcpy(&run_data->app_name[run_data->app_args_offset],
507  &pvt->app_name[pvt->app_args_offset]);/* Safe */
508  }
509  if (len_moh) {
510  strcpy(&run_data->app_name[run_data->moh_offset],
511  &pvt->app_name[pvt->moh_offset]);/* Safe */
512  }
513  strcpy(&run_data->app_name[run_data->feature_offset],
514  &pvt->app_name[pvt->feature_offset]);/* Safe */
515  strcpy(&run_data->app_name[run_data->activated_offset], activated_name);/* Safe */
516 
517  if (ast_test_flag(pvt, AST_FEATURE_FLAG_ONPEER)) {
518  ast_bridge_channel_write_callback(bridge_channel,
520  dynamic_dtmf_hook_callback, run_data, len_data);
521  } else {
522  dynamic_dtmf_hook_callback(bridge_channel, run_data, len_data);
523  }
524  return 0;
525 }
526 
527 /*!
528  * \internal
529  * \brief Add a dynamic DTMF feature hook to the bridge features.
530  * \since 12.0.0
531  *
532  * \param features Bridge features to setup.
533  * \param flags Which side of bridge to run app (AST_FEATURE_FLAG_ONSELF/AST_FEATURE_FLAG_ONPEER).
534  * \param dtmf DTMF trigger sequence.
535  * \param feature_name Name of the dynamic feature.
536  * \param app_name Dialplan application name to run.
537  * \param app_args Dialplan application arguments. (Empty or NULL if no arguments)
538  * \param moh_class MOH class to play to peer. (Empty or NULL if no MOH played)
539  *
540  * \retval 0 on success.
541  * \retval -1 on error.
542  */
543 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)
544 {
545  struct dynamic_dtmf_hook_data *hook_data;
546  size_t len_name = strlen(app_name) + 1;
547  size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
548  size_t len_moh = ast_strlen_zero(moh_class) ? 0 : strlen(moh_class) + 1;
549  size_t len_feature = strlen(feature_name) + 1;
550  size_t len_data = sizeof(*hook_data) + len_name + len_args + len_moh + len_feature;
551  int res;
552 
553  /* Fill in application run hook data. */
554  hook_data = ast_malloc(len_data);
555  if (!hook_data) {
556  return -1;
557  }
558  hook_data->flags = flags;
559  hook_data->app_args_offset = len_args ? len_name : 0;
560  hook_data->moh_offset = len_moh ? len_name + len_args : 0;
561  hook_data->feature_offset = len_name + len_args + len_moh;
562  strcpy(hook_data->app_name, app_name);/* Safe */
563  if (len_args) {
564  strcpy(&hook_data->app_name[hook_data->app_args_offset], app_args);/* Safe */
565  }
566  if (len_moh) {
567  strcpy(&hook_data->app_name[hook_data->moh_offset], moh_class);/* Safe */
568  }
569  strcpy(&hook_data->app_name[hook_data->feature_offset], feature_name);/* Safe */
570 
571  res = ast_bridge_dtmf_hook(features, dtmf, dynamic_dtmf_hook_trip, hook_data,
572  ast_free_ptr,
574  if (res) {
575  ast_free(hook_data);
576  }
577  return res;
578 }
579 
580 static int setup_dynamic_feature(void *obj, void *arg, void *data, int flags)
581 {
582  struct ast_applicationmap_item *item = obj;
583  struct ast_bridge_features *features = arg;
584  int *res = data;
585 
586  *res |= dynamic_dtmf_hook_add(features,
587  item->activate_on_self ? AST_FEATURE_FLAG_ONSELF : AST_FEATURE_FLAG_ONPEER,
588  item->dtmf, item->name, item->app, item->app_data, item->moh_class);
589 
590  return 0;
591 }
592 
593 /*!
594  * \internal
595  * \brief Setup bridge dynamic features.
596  * \since 12.0.0
597  *
598  * \param features Bridge features to setup.
599  * \param chan Get features from this channel.
600  *
601  * \retval 0 on success.
602  * \retval -1 on error.
603  */
604 static int setup_bridge_features_dynamic(struct ast_bridge_features *features, struct ast_channel *chan)
605 {
606  struct ao2_container *applicationmap;
607  int res = 0;
608 
609  ast_channel_lock(chan);
610  applicationmap = ast_get_chan_applicationmap(chan);
611  ast_channel_unlock(chan);
612  if (applicationmap) {
613  ao2_callback_data(applicationmap, 0, setup_dynamic_feature, features, &res);
614  ao2_ref(applicationmap, -1);
615  }
616 
617  return res;
618 }
619 
620 /*!
621  * \internal
622  * \brief Setup DTMF feature hooks using the channel features datastore property.
623  * \since 12.0.0
624  *
625  * \param bridge_channel What to setup DTMF features on.
626  *
627  * \retval 0 on success.
628  * \retval -1 on error.
629  */
630 static int bridge_basic_setup_features(struct ast_bridge_channel *bridge_channel)
631 {
632  int res = 0;
633 
634  res |= setup_bridge_features_builtin(bridge_channel->features, bridge_channel->chan);
635  res |= setup_bridge_features_dynamic(bridge_channel->features, bridge_channel->chan);
636 
637  return res;
638 }
639 
640 static int add_normal_hooks(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
641 {
642  return ast_bridge_hangup_hook(bridge_channel->features, basic_hangup_hook,
643  NULL, NULL, AST_BRIDGE_HOOK_REMOVE_ON_PULL)
644  || bridge_basic_setup_features(bridge_channel);
645 }
646 
647 /*!
648  * \internal
649  * \brief ast_bridge basic push method.
650  * \since 12.0.0
651  *
652  * \param self Bridge to operate upon.
653  * \param bridge_channel Bridge channel to push.
654  * \param swap Bridge channel to swap places with if not NULL.
655  *
656  * \note On entry, self is already locked.
657  *
658  * \retval 0 on success
659  * \retval -1 on failure
660  */
661 static int bridge_personality_normal_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
662 {
663  if (add_normal_hooks(self, bridge_channel)) {
664  return -1;
665  }
666 
667  return 0;
668 }
669 
670 static int bridge_basic_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
671 {
672  struct bridge_basic_personality *personality = self->personality;
673 
674  ast_assert(personality != NULL);
675 
676  if (personality->details[personality->current].v_table->push
677  && personality->details[personality->current].v_table->push(self, bridge_channel, swap)) {
678  return -1;
679  }
680 
681  ast_bridge_channel_update_linkedids(bridge_channel, swap);
682  ast_bridge_channel_update_accountcodes(bridge_channel, swap);
683 
684  return ast_bridge_base_v_table.push(self, bridge_channel, swap);
685 }
686 
687 static void bridge_basic_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
688 {
689  struct bridge_basic_personality *personality = self->personality;
690 
691  ast_assert(personality != NULL);
692 
693  if (personality->details[personality->current].v_table->pull) {
694  personality->details[personality->current].v_table->pull(self, bridge_channel);
695  }
696 
697  ast_bridge_channel_update_accountcodes(NULL, bridge_channel);
698 
699  ast_bridge_base_v_table.pull(self, bridge_channel);
700 }
701 
702 static void bridge_basic_destroy(struct ast_bridge *self)
703 {
704  struct bridge_basic_personality *personality = self->personality;
705 
706  ao2_cleanup(personality);
707 
709 }
710 
711 /*!
712  * \brief Remove appropriate hooks when basic bridge personality changes
713  *
714  * Hooks that have the AST_BRIDGE_HOOK_REMOVE_ON_PERSONALITY_CHANGE flag
715  * set will be removed from all bridge channels in the bridge.
716  *
717  * \param bridge Basic bridge undergoing personality change
718  */
720 {
721  struct ast_bridge_channel *iter;
722 
723  AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
726  }
727 }
728 
729 /*!
730  * \brief Attended transfer superstates.
731  *
732  * An attended transfer's progress is facilitated by a state machine.
733  * The individual states of the state machine fall into the realm of
734  * one of two superstates.
735  */
737  /*!
738  * \brief Transfer superstate
739  *
740  * The attended transfer state machine begins in this superstate. The
741  * goal of this state is for a transferer channel to facilitate a
742  * transfer from a transferee to a transfer target.
743  *
744  * There are two bridges used in this superstate. The transferee bridge is
745  * the bridge that the transferer and transferee channels originally
746  * communicate in, and the target bridge is the bridge where the transfer
747  * target is being dialed.
748  *
749  * The transferer channel is capable of moving between the bridges using
750  * the DTMF swap sequence.
751  */
753  /*!
754  * \brief Recall superstate
755  *
756  * The attended transfer state machine moves to this superstate if
757  * atxferdropcall is set to "no" and the transferer channel hangs up
758  * during a transfer. The goal in this superstate is to call back either
759  * the transfer target or transferer and rebridge with the transferee
760  * channel(s).
761  *
762  * In this superstate, there is only a single bridge used, the original
763  * transferee bridge. Rather than distinguishing between a transferer
764  * and transfer target, all outbound calls are toward a "recall_target"
765  * channel.
766  */
768 };
769 
770 /*!
771  * The states in the attended transfer state machine.
772  */
774  /*!
775  * \brief Calling Target state
776  *
777  * This state describes the initial state of a transfer. The transferer
778  * waits in the transfer target's bridge for the transfer target to answer.
779  *
780  * Superstate: Transfer
781  *
782  * Preconditions:
783  * 1) Transfer target is RINGING
784  * 2) Transferer is in transferee bridge
785  * 3) Transferee is on hold
786  *
787  * Transitions to TRANSFER_CALLING_TARGET:
788  * 1) This is the initial state for an attended transfer.
789  * 2) TRANSFER_HESITANT: Transferer presses DTMF swap sequence
790  *
791  * State operation:
792  * The transferer is moved from the transferee bridge into the transfer
793  * target bridge.
794  *
795  * Transitions from TRANSFER_CALLING_TARGET:
796  * 1) TRANSFER_FAIL: Transferee hangs up.
797  * 2) TRANSFER_BLOND: Transferer hangs up or presses DTMF swap sequence
798  * and configured atxferdropcall setting is yes.
799  * 3) TRANSFER_BLOND_NONFINAL: Transferer hangs up or presses DTMF swap
800  * sequence and configured atxferdropcall setting is no.
801  * 4) TRANSFER_CONSULTING: Transfer target answers the call.
802  * 5) TRANSFER_REBRIDGE: Transfer target hangs up, call to transfer target
803  * times out, or transferer presses DTMF abort sequence.
804  * 6) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
805  * 7) TRANSFER_HESITANT: Transferer presses DTMF swap sequence.
806  */
808  /*!
809  * \brief Hesitant state
810  *
811  * This state only arises if when waiting for the transfer target to
812  * answer, the transferer presses the DTMF swap sequence. This will
813  * cause the transferer to be rebridged with the transferee temporarily.
814  *
815  * Superstate: Transfer
816  *
817  * Preconditions:
818  * 1) Transfer target is in ringing state
819  * 2) Transferer is in transfer target bridge
820  * 3) Transferee is on hold
821  *
822  * Transitions to TRANSFER_HESITANT:
823  * 1) TRANSFER_CALLING_TARGET: Transferer presses DTMF swap sequence.
824  *
825  * State operation:
826  * The transferer is moved from the transfer target bridge into the
827  * transferee bridge, and the transferee is taken off hold.
828  *
829  * Transitions from TRANSFER_HESITANT:
830  * 1) TRANSFER_FAIL: Transferee hangs up
831  * 2) TRANSFER_BLOND: Transferer hangs up or presses DTMF swap sequence
832  * and configured atxferdropcall setting is yes.
833  * 3) TRANSFER_BLOND_NONFINAL: Transferer hangs up or presses DTMF swap
834  * sequence and configured atxferdropcall setting is no.
835  * 4) TRANSFER_DOUBLECHECKING: Transfer target answers the call
836  * 5) TRANSFER_RESUME: Transfer target hangs up, call to transfer target
837  * times out, or transferer presses DTMF abort sequence.
838  * 6) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
839  * 7) TRANSFER_CALLING_TARGET: Transferer presses DTMF swap sequence.
840  */
842  /*!
843  * \brief Rebridge state
844  *
845  * This is a terminal state that indicates that the transferer needs
846  * to move back to the transferee's bridge. This is a failed attended
847  * transfer result.
848  *
849  * Superstate: Transfer
850  *
851  * Preconditions:
852  * 1) Transferer is in transfer target bridge
853  * 2) Transferee is on hold
854  *
855  * Transitions to TRANSFER_REBRIDGE:
856  * 1) TRANSFER_CALLING_TARGET: Transfer target hangs up, call to transfer target
857  * times out, or transferer presses DTMF abort sequence.
858  * 2) TRANSFER_STATE_CONSULTING: Transfer target hangs up, or transferer presses
859  * DTMF abort sequence.
860  *
861  * State operation:
862  * The transferer channel is moved from the transfer target bridge to the
863  * transferee bridge. The transferee is taken off hold. A stasis transfer
864  * message is published indicating a failed attended transfer.
865  *
866  * Transitions from TRANSFER_REBRIDGE:
867  * None
868  */
870  /*!
871  * \brief Resume state
872  *
873  * This is a terminal state that indicates that the party bridged with the
874  * transferee is the final party to be bridged with that transferee. This state
875  * may come about due to a successful recall or due to a failed transfer.
876  *
877  * Superstate: Transfer or Recall
878  *
879  * Preconditions:
880  * In Transfer Superstate:
881  * 1) Transferer is in transferee bridge
882  * 2) Transferee is not on hold
883  * In Recall Superstate:
884  * 1) The recall target is in the transferee bridge
885  * 2) Transferee is not on hold
886  *
887  * Transitions to TRANSFER_RESUME:
888  * TRANSFER_HESITANT: Transfer target hangs up, call to transfer target times out,
889  * or transferer presses DTMF abort sequence.
890  * TRANSFER_DOUBLECHECKING: Transfer target hangs up or transferer presses DTMF
891  * abort sequence.
892  * TRANSFER_BLOND_NONFINAL: Recall target answers
893  * TRANSFER_RECALLING: Recall target answers
894  * TRANSFER_RETRANSFER: Recall target answers
895  *
896  * State operations:
897  * None
898  *
899  * Transitions from TRANSFER_RESUME:
900  * None
901  */
903  /*!
904  * \brief Threeway state
905  *
906  * This state results when the transferer wishes to have all parties involved
907  * in a transfer to be in the same bridge together.
908  *
909  * Superstate: Transfer
910  *
911  * Preconditions:
912  * 1) Transfer target state is either RINGING or UP
913  * 2) Transferer is in either bridge
914  * 3) Transferee is not on hold
915  *
916  * Transitions to TRANSFER_THREEWAY:
917  * 1) TRANSFER_CALLING_TARGET: Transferer presses DTMF threeway sequence.
918  * 2) TRANSFER_HESITANT: Transferer presses DTMF threeway sequence.
919  * 3) TRANSFER_CONSULTING: Transferer presses DTMF threeway sequence.
920  * 4) TRANSFER_DOUBLECHECKING: Transferer presses DTMF threeway sequence.
921  *
922  * State operation:
923  * The transfer target bridge is merged into the transferee bridge.
924  *
925  * Transitions from TRANSFER_THREEWAY:
926  * None.
927  */
929  /*!
930  * \brief Consulting state
931  *
932  * This state describes the case where the transferer and transfer target
933  * are able to converse in the transfer target's bridge prior to completing
934  * the transfer.
935  *
936  * Superstate: Transfer
937  *
938  * Preconditions:
939  * 1) Transfer target is UP
940  * 2) Transferer is in target bridge
941  * 3) Transferee is on hold
942  *
943  * Transitions to TRANSFER_CONSULTING:
944  * 1) TRANSFER_CALLING_TARGET: Transfer target answers.
945  * 2) TRANSFER_DOUBLECHECKING: Transferer presses DTMF swap sequence.
946  *
947  * State operations:
948  * None.
949  *
950  * Transitions from TRANSFER_CONSULTING:
951  * TRANSFER_COMPLETE: Transferer hangs up or transferer presses DTMF complete sequence.
952  * TRANSFER_REBRIDGE: Transfer target hangs up or transferer presses DTMF abort sequence.
953  * TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
954  * TRANSFER_DOUBLECHECKING: Transferer presses DTMF swap sequence.
955  */
957  /*!
958  * \brief Double-checking state
959  *
960  * This state describes the case where the transferer and transferee are
961  * able to converse in the transferee's bridge prior to completing the transfer. The
962  * difference between this and TRANSFER_HESITANT is that the transfer target is
963  * UP in this case.
964  *
965  * Superstate: Transfer
966  *
967  * Preconditions:
968  * 1) Transfer target is UP and on hold
969  * 2) Transferer is in transferee bridge
970  * 3) Transferee is off hold
971  *
972  * Transitions to TRANSFER_DOUBLECHECKING:
973  * 1) TRANSFER_HESITANT: Transfer target answers.
974  * 2) TRANSFER_CONSULTING: Transferer presses DTMF swap sequence.
975  *
976  * State operations:
977  * None.
978  *
979  * Transitions from TRANSFER_DOUBLECHECKING:
980  * 1) TRANSFER_FAIL: Transferee hangs up.
981  * 2) TRANSFER_COMPLETE: Transferer hangs up or presses DTMF complete sequence.
982  * 3) TRANSFER_RESUME: Transfer target hangs up or transferer presses DTMF abort sequence.
983  * 4) TRANSFER_THREEWAY: Transferer presses DTMF threeway sequence.
984  * 5) TRANSFER_CONSULTING: Transferer presses the DTMF swap sequence.
985  */
987  /*!
988  * \brief Complete state
989  *
990  * This is a terminal state where a transferer has successfully completed an attended
991  * transfer. This state's goal is to get the transfer target and transferee into
992  * the same bridge and the transferer off the call.
993  *
994  * Superstate: Transfer
995  *
996  * Preconditions:
997  * 1) Transfer target is UP and off hold.
998  * 2) Transferer is in either bridge.
999  * 3) Transferee is off hold.
1000  *
1001  * Transitions to TRANSFER_COMPLETE:
1002  * 1) TRANSFER_CONSULTING: transferer hangs up or presses the DTMF complete sequence.
1003  * 2) TRANSFER_DOUBLECHECKING: transferer hangs up or presses the DTMF complete sequence.
1004  *
1005  * State operation:
1006  * The transfer target bridge is merged into the transferee bridge. The transferer
1007  * channel is kicked out of the bridges as part of the merge.
1008  *
1009  * State operations:
1010  * 1) Merge the transfer target bridge into the transferee bridge,
1011  * excluding the transferer channel from the merge.
1012  * 2) Publish a stasis transfer message.
1013  *
1014  * Exit operations:
1015  * This is a terminal state, so there are no exit operations.
1016  */
1018  /*!
1019  * \brief Blond state
1020  *
1021  * This is a terminal state where a transferer has completed an attended transfer prior
1022  * to the transfer target answering. This state is only entered if atxferdropcall
1023  * is set to 'yes'. This is considered to be a successful attended transfer.
1024  *
1025  * Superstate: Transfer
1026  *
1027  * Preconditions:
1028  * 1) Transfer target is RINGING.
1029  * 2) Transferer is in either bridge.
1030  * 3) Transferee is off hold.
1031  *
1032  * Transitions to TRANSFER_BLOND:
1033  * 1) TRANSFER_CALLING_TARGET: Transferer hangs up or presses the DTMF complete sequence.
1034  * atxferdropcall is set to 'yes'.
1035  * 2) TRANSFER_HESITANT: Transferer hangs up or presses the DTMF complete sequence.
1036  * atxferdropcall is set to 'yes'.
1037  *
1038  * State operations:
1039  * The transfer target bridge is merged into the transferee bridge. The transferer
1040  * channel is kicked out of the bridges as part of the merge. A stasis transfer
1041  * publication is sent indicating a successful transfer.
1042  *
1043  * Transitions from TRANSFER_BLOND:
1044  * None
1045  */
1047  /*!
1048  * \brief Blond non-final state
1049  *
1050  * This state is very similar to the TRANSFER_BLOND state, except that
1051  * this state is entered when atxferdropcall is set to 'no'. This is the
1052  * initial state of the Recall superstate, so state operations mainly involve
1053  * moving to the Recall superstate. This means that the transfer target, that
1054  * is currently ringing is now known as the recall target.
1055  *
1056  * Superstate: Recall
1057  *
1058  * Preconditions:
1059  * 1) Recall target is RINGING.
1060  * 2) Transferee is off hold.
1061  *
1062  * Transitions to TRANSFER_BLOND_NONFINAL:
1063  * 1) TRANSFER_CALLING_TARGET: Transferer hangs up or presses the DTMF complete sequence.
1064  * atxferdropcall is set to 'no'.
1065  * 2) TRANSFER_HESITANT: Transferer hangs up or presses the DTMF complete sequence.
1066  * atxferdropcall is set to 'no'.
1067  *
1068  * State operation:
1069  * The superstate of the attended transfer is changed from Transfer to Recall.
1070  * The transfer target bridge is merged into the transferee bridge. The transferer
1071  * channel is kicked out of the bridges as part of the merge.
1072  *
1073  * Transitions from TRANSFER_BLOND_NONFINAL:
1074  * 1) TRANSFER_FAIL: Transferee hangs up
1075  * 2) TRANSFER_RESUME: Recall target answers
1076  * 3) TRANSFER_RECALLING: Recall target hangs up or time expires.
1077  */
1079  /*!
1080  * \brief Recalling state
1081  *
1082  * This state is entered if the recall target from the TRANSFER_BLOND_NONFINAL
1083  * or TRANSFER_RETRANSFER states hangs up or does not answer. The goal of this
1084  * state is to call back the original transferer in an attempt to recover the
1085  * original call.
1086  *
1087  * Superstate: Recall
1088  *
1089  * Preconditions:
1090  * 1) Recall target is down.
1091  * 2) Transferee is off hold.
1092  *
1093  * Transitions to TRANSFER_RECALLING:
1094  * 1) TRANSFER_BLOND_NONFINAL: Recall target hangs up or time expires.
1095  * 2) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1096  * atxferloopdelay is non-zero.
1097  * 3) TRANSFER_WAIT_TO_RECALL: Time expires.
1098  *
1099  * State operation:
1100  * The original transferer becomes the recall target and is called using the Dialing API.
1101  * Ringing is indicated to the transferee.
1102  *
1103  * Transitions from TRANSFER_RECALLING:
1104  * 1) TRANSFER_FAIL:
1105  * a) Transferee hangs up.
1106  * b) Recall target hangs up or time expires, and number of recall attempts exceeds atxfercallbackretries
1107  * 2) TRANSFER_WAIT_TO_RETRANSFER: Recall target hangs up or time expires.
1108  * atxferloopdelay is non-zero.
1109  * 3) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1110  * atxferloopdelay is zero.
1111  * 4) TRANSFER_RESUME: Recall target answers.
1112  */
1114  /*!
1115  * \brief Wait to Retransfer state
1116  *
1117  * This state is used simply to give a bit of breathing room between attempting
1118  * to call back the original transferer and attempting to call back the original
1119  * transfer target. The transferee hears music on hold during this state as an
1120  * auditory clue that no one is currently being dialed.
1121  *
1122  * Superstate: Recall
1123  *
1124  * Preconditions:
1125  * 1) Recall target is down.
1126  * 2) Transferee is off hold.
1127  *
1128  * Transitions to TRANSFER_WAIT_TO_RETRANSFER:
1129  * 1) TRANSFER_RECALLING: Recall target hangs up or time expires.
1130  * atxferloopdelay is non-zero.
1131  *
1132  * State operation:
1133  * The transferee is placed on hold.
1134  *
1135  * Transitions from TRANSFER_WAIT_TO_RETRANSFER:
1136  * 1) TRANSFER_FAIL: Transferee hangs up.
1137  * 2) TRANSFER_RETRANSFER: Time expires.
1138  */
1140  /*!
1141  * \brief Retransfer state
1142  *
1143  * This state is used in order to attempt to call back the original
1144  * transfer target channel from the transfer. The transferee hears
1145  * ringing during this state as an auditory cue that a party is being
1146  * dialed.
1147  *
1148  * Superstate: Recall
1149  *
1150  * Preconditions:
1151  * 1) Recall target is down.
1152  * 2) Transferee is off hold.
1153  *
1154  * Transitions to TRANSFER_RETRANSFER:
1155  * 1) TRANSFER_RECALLING: Recall target hangs up or time expires.
1156  * atxferloopdelay is zero.
1157  * 2) TRANSFER_WAIT_TO_RETRANSFER: Time expires.
1158  *
1159  * State operation:
1160  * The original transfer target is requested and is set as the recall target.
1161  * The recall target is called and placed into the transferee bridge.
1162  *
1163  * Transitions from TRANSFER_RETRANSFER:
1164  * 1) TRANSFER_FAIL: Transferee hangs up.
1165  * 2) TRANSFER_WAIT_TO_RECALL: Recall target hangs up or time expires.
1166  * atxferloopdelay is non-zero.
1167  * 3) TRANSFER_RECALLING: Recall target hangs up or time expires.
1168  * atxferloopdelay is zero.
1169  */
1171  /*!
1172  * \brief Wait to recall state
1173  *
1174  * This state is used simply to give a bit of breathing room between attempting
1175  * to call back the original transfer target and attempting to call back the
1176  * original transferer. The transferee hears music on hold during this state as an
1177  * auditory clue that no one is currently being dialed.
1178  *
1179  * Superstate: Recall
1180  *
1181  * Preconditions:
1182  * 1) Recall target is down.
1183  * 2) Transferee is off hold.
1184  *
1185  * Transitions to TRANSFER_WAIT_TO_RECALL:
1186  * 1) TRANSFER_RETRANSFER: Recall target hangs up or time expires.
1187  * atxferloopdelay is non-zero.
1188  *
1189  * State operation:
1190  * Transferee is placed on hold.
1191  *
1192  * Transitions from TRANSFER_WAIT_TO_RECALL:
1193  * 1) TRANSFER_FAIL: Transferee hangs up
1194  * 2) TRANSFER_RECALLING: Time expires
1195  */
1197  /*!
1198  * \brief Fail state
1199  *
1200  * This state indicates that something occurred during the transfer that
1201  * makes a graceful completion impossible. The most common stimulus for this
1202  * state is when the transferee hangs up.
1203  *
1204  * Superstate: Transfer and Recall
1205  *
1206  * Preconditions:
1207  * None
1208  *
1209  * Transitions to TRANSFER_FAIL:
1210  * 1) TRANSFER_CALLING_TARGET: Transferee hangs up.
1211  * 2) TRANSFER_HESITANT: Transferee hangs up.
1212  * 3) TRANSFER_DOUBLECHECKING: Transferee hangs up.
1213  * 4) TRANSFER_BLOND_NONFINAL: Transferee hangs up.
1214  * 5) TRANSFER_RECALLING:
1215  * a) Transferee hangs up.
1216  * b) Recall target hangs up or time expires, and number of
1217  * recall attempts exceeds atxfercallbackretries.
1218  * 6) TRANSFER_WAIT_TO_RETRANSFER: Transferee hangs up.
1219  * 7) TRANSFER_RETRANSFER: Transferee hangs up.
1220  * 8) TRANSFER_WAIT_TO_RECALL: Transferee hangs up.
1221  *
1222  * State operation:
1223  * A transfer stasis publication is made indicating a failed transfer.
1224  * The transferee bridge is destroyed.
1225  *
1226  * Transitions from TRANSFER_FAIL:
1227  * None.
1228  */
1230 };
1231 
1232 /*!
1233  * \brief Stimuli that can cause transfer state changes
1234  */
1236  /*! No stimulus. This literally can never happen. */
1238  /*! All of the transferee channels have been hung up. */
1240  /*! The transferer has hung up. */
1242  /*! The transfer target channel has hung up. */
1244  /*! The transfer target channel has answered. */
1246  /*! The recall target channel has hung up. */
1248  /*! The recall target channel has answered. */
1250  /*! The current state's timer has expired. */
1252  /*! The transferer pressed the abort DTMF sequence. */
1254  /*! The transferer pressed the complete DTMF sequence. */
1256  /*! The transferer pressed the three-way DTMF sequence. */
1258  /*! The transferer pressed the swap DTMF sequence. */
1260 };
1261 
1262 /*!
1263  * \brief String representations of the various stimuli
1264  *
1265  * Used for debugging purposes
1266  */
1267 const char *stimulus_strs[] = {
1268  [STIMULUS_NONE] = "None",
1269  [STIMULUS_TRANSFEREE_HANGUP] = "Transferee Hangup",
1270  [STIMULUS_TRANSFERER_HANGUP] = "Transferer Hangup",
1271  [STIMULUS_TRANSFER_TARGET_HANGUP] = "Transfer Target Hangup",
1272  [STIMULUS_TRANSFER_TARGET_ANSWER] = "Transfer Target Answer",
1273  [STIMULUS_RECALL_TARGET_HANGUP] = "Recall Target Hangup",
1274  [STIMULUS_RECALL_TARGET_ANSWER] = "Recall Target Answer",
1275  [STIMULUS_TIMEOUT] = "Timeout",
1276  [STIMULUS_DTMF_ATXFER_ABORT] = "DTMF Abort",
1277  [STIMULUS_DTMF_ATXFER_COMPLETE] = "DTMF Complete",
1278  [STIMULUS_DTMF_ATXFER_THREEWAY] = "DTMF Threeway",
1279  [STIMULUS_DTMF_ATXFER_SWAP] = "DTMF Swap",
1280 };
1281 
1283  enum attended_transfer_stimulus stimulus;
1285 };
1286 
1287 /*!
1288  * \brief Collection of data related to an attended transfer attempt
1289  */
1292  /*! Extension of transfer target */
1294  /*! Context of transfer target */
1296  /*! Sound to play when transfer completes */
1298  /*! The channel technology of the transferer channel */
1300  /*! The transferer channel address */
1302  );
1303  /*! Condition used to synchronize when stimuli are reported to the monitor thread */
1304  ast_cond_t cond;
1305  /*! The bridge where the transferee resides. This bridge is also the bridge that
1306  * survives a successful attended transfer.
1307  */
1309  /*! The bridge used to place an outbound call to the transfer target. This
1310  * bridge is merged with the transferee_bridge on a successful transfer.
1311  */
1313  /*! The party that performs the attended transfer. */
1315  /*! The local channel dialed to reach the transfer target. */
1317  /*! The party that is currently being recalled. Depending on
1318  * the current state, this may be either the party that originally
1319  * was the transferer or the original transfer target. This is
1320  * set with reference when entering the BLOND_NONFINAL, RECALLING,
1321  * and RETRANSFER states, and the reference released on state exit
1322  * if continuing with recall or retransfer to avoid leak.
1323  */
1325  /*! The absolute starting time for running timers */
1326  struct timeval start;
1327  AST_LIST_HEAD_NOLOCK(,stimulus_list) stimulus_queue;
1328  /*! The current state of the attended transfer */
1330  /*! The current superstate of the attended transfer */
1332  /*! Configured atxferdropcall from features.conf */
1334  /*! Configured atxfercallbackretries from features.conf */
1336  /*! Configured atxferloopdelay from features.conf */
1338  /*! Configured atxfernoanswertimeout from features.conf */
1340  /*! Count of the number of times that recalls have been attempted */
1342  /*! Framehook ID for outbounc call to transfer target or recall target */
1344  /*! Dial structure used when recalling transferer channel */
1345  struct ast_dial *dial;
1346  /*! The bridging features the transferer has available */
1348  /*! Saved transferer connected line data for recalling the transferer. */
1350 };
1351 
1352 static void attended_transfer_properties_destructor(void *obj)
1353 {
1354  struct attended_transfer_properties *props = obj;
1355 
1356  ast_debug(1, "Destroy attended transfer properties %p\n", props);
1357 
1358  ao2_cleanup(props->target_bridge);
1359  ao2_cleanup(props->transferee_bridge);
1360  /* Use ast_channel_cleanup() instead of ast_channel_unref() for channels since they may be NULL */
1366  ast_cond_destroy(&props->cond);
1367 }
1368 
1369 /*!
1370  * \internal
1371  * \brief Determine the transfer context to use.
1372  * \since 12.0.0
1373  *
1374  * \param transferer Channel initiating the transfer.
1375  * \param context User supplied context if available. May be NULL.
1376  *
1377  * \return The context to use for the transfer.
1378  */
1379 static const char *get_transfer_context(struct ast_channel *transferer, const char *context)
1380 {
1381  if (!ast_strlen_zero(context)) {
1382  return context;
1383  }
1384  context = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
1385  if (!ast_strlen_zero(context)) {
1386  return context;
1387  }
1388  context = ast_channel_context(transferer);
1389  if (!ast_strlen_zero(context)) {
1390  return context;
1391  }
1392  return "default";
1393 }
1394 
1395 /*!
1396  * \internal
1397  * \brief Determine the transfer extension to use.
1398  *
1399  * \param transferer Channel initiating the transfer.
1400  * \param exten User supplied extension if available. May be NULL.
1401  *
1402  * \return The extension to use for the transfer.
1403  */
1404 static const char *get_transfer_exten(struct ast_channel *transferer, const char *exten)
1405 {
1406  if (!ast_strlen_zero(exten)) {
1407  return exten;
1408  }
1409  exten = pbx_builtin_getvar_helper(transferer, "TRANSFER_EXTEN");
1410  if (!ast_strlen_zero(exten)) {
1411  return exten;
1412  }
1413  return ""; /* empty default, to get transfer extension from user now */
1414 }
1415 
1416 /*!
1417  * \brief Allocate and initialize attended transfer properties
1418  *
1419  * \param transferer The channel performing the attended transfer
1420  * \param context Suggestion for what context the transfer target extension can be found in
1421  *
1422  * \retval NULL Failure to allocate or initialize
1423  * \retval non-NULL Newly allocated properties
1424  */
1426  struct ast_channel *transferer, const char *context)
1427 {
1428  struct attended_transfer_properties *props;
1429  char *tech;
1430  char *addr;
1431  char *serial;
1432  struct ast_features_xfer_config *xfer_cfg;
1434 
1435  props = ao2_alloc(sizeof(*props), attended_transfer_properties_destructor);
1436  if (!props) {
1437  ast_log(LOG_ERROR, "Unable to create props - channel %s, context %s\n",
1438  ast_channel_name(transferer), context);
1439  return NULL;
1440  }
1441 
1442  ast_cond_init(&props->cond, NULL);
1443 
1444  if (ast_string_field_init(props, 64)) {
1445  ast_log(LOG_ERROR, "Unable to initialize prop fields - channel %s, context %s\n",
1446  ast_channel_name(transferer), context);
1447  ao2_ref(props, -1);
1448  return NULL;
1449  }
1450 
1451  props->target_framehook_id = -1;
1452  props->transferer = ast_channel_ref(transferer);
1453 
1454  ast_channel_lock(props->transferer);
1455  xfer_cfg = ast_get_chan_features_xfer_config(props->transferer);
1456  if (!xfer_cfg) {
1457  ast_log(LOG_ERROR, "Unable to get transfer configuration from channel %s\n", ast_channel_name(props->transferer));
1458  ast_channel_unlock(props->transferer);
1459  ao2_ref(props, -1);
1460  return NULL;
1461  }
1462  transferer_features = ast_bridge_features_ds_get(props->transferer);
1463  if (transferer_features) {
1465  }
1466  props->atxferdropcall = xfer_cfg->atxferdropcall;
1467  props->atxfercallbackretries = xfer_cfg->atxfercallbackretries;
1468  props->atxfernoanswertimeout = xfer_cfg->atxfernoanswertimeout;
1469  props->atxferloopdelay = xfer_cfg->atxferloopdelay;
1470  ast_string_field_set(props, context, get_transfer_context(transferer, context));
1471  ast_string_field_set(props, xfersound, xfer_cfg->xfersound);
1472  ao2_ref(xfer_cfg, -1);
1473 
1474  /*
1475  * Save the transferee's party information for any recall calls.
1476  * This is the only piece of information needed that gets overwritten
1477  * on the transferer channel by the inital call to the transfer target.
1478  */
1480  ast_channel_connected(props->transferer));
1481 
1482  tech = ast_strdupa(ast_channel_name(props->transferer));
1483  addr = strchr(tech, '/');
1484  if (!addr) {
1485  ast_log(LOG_ERROR, "Transferer channel name does not follow typical channel naming format (tech/address)\n");
1486  ast_channel_unlock(props->transferer);
1487  ao2_ref(props, -1);
1488  return NULL;
1489  }
1490  *addr++ = '\0';
1491  serial = strrchr(addr, '-');
1492  if (serial) {
1493  *serial = '\0';
1494  }
1495  ast_string_field_set(props, transferer_type, tech);
1496  ast_string_field_set(props, transferer_addr, addr);
1497 
1498  ast_channel_unlock(props->transferer);
1499 
1500  ast_debug(1, "Allocated attended transfer properties %p for transfer from %s\n",
1501  props, ast_channel_name(props->transferer));
1502  return props;
1503 }
1504 
1505 /*!
1506  * \brief Free backlog of stimuli in the queue
1507  */
1509 {
1510  struct stimulus_list *list;
1511  SCOPED_AO2LOCK(lock, props);
1512 
1513  while ((list = AST_LIST_REMOVE_HEAD(&props->stimulus_queue, next))) {
1514  ast_free(list);
1515  }
1516 }
1517 
1518 /*!
1519  * \brief Initiate shutdown of attended transfer properties
1520  *
1521  * Calling this indicates that the attended transfer properties are no longer needed
1522  * because the transfer operation has concluded.
1523  */
1525 {
1526  ast_debug(1, "Shutting down attended transfer %p\n", props);
1527 
1528  if (props->transferee_bridge) {
1532  }
1533 
1534  if (props->target_bridge) {
1535  ast_bridge_destroy(props->target_bridge, 0);
1536  props->target_bridge = NULL;
1537  }
1538 
1539  if (props->transferer) {
1540  ast_channel_remove_bridge_role(props->transferer, AST_TRANSFERER_ROLE_NAME);
1541  }
1542 
1543  clear_stimulus_queue(props);
1544 
1545  ao2_cleanup(props);
1546 }
1547 
1548 static void stimulate_attended_transfer(struct attended_transfer_properties *props,
1549  enum attended_transfer_stimulus stimulus)
1550 {
1551  struct stimulus_list *list;
1552 
1553  list = ast_calloc(1, sizeof(*list));
1554  if (!list) {
1555  ast_log(LOG_ERROR, "Unable to push event to attended transfer queue. Expect transfer to fail\n");
1556  return;
1557  }
1558 
1559  list->stimulus = stimulus;
1560  ao2_lock(props);
1561  AST_LIST_INSERT_TAIL(&props->stimulus_queue, list, next);
1562  ast_cond_signal(&props->cond);
1563  ao2_unlock(props);
1564 }
1565 
1566 static void remove_attended_transfer_stimulus(struct attended_transfer_properties *props,
1567  enum attended_transfer_stimulus stimulus)
1568 {
1569  struct stimulus_list *list;
1570 
1571  ao2_lock(props);
1572  AST_LIST_TRAVERSE_SAFE_BEGIN(&props->stimulus_queue, list, next) {
1573  if (list->stimulus == stimulus) {
1575  ast_free(list);
1576  break;
1577  }
1578  }
1580  ao2_unlock(props);
1581 }
1582 
1583 /*!
1584  * \brief Get a desired transfer party for a bridge the transferer is not in.
1585  *
1586  * \param bridge The bridge to get the party from. May be NULL.
1587  * \param[out] party The lone channel in the bridge. Will be set NULL if bridge is NULL or multiple parties are present.
1588  */
1590  struct ast_channel **party)
1591 {
1592  if (bridge && bridge->num_channels == 1) {
1593  *party = ast_channel_ref(AST_LIST_FIRST(&bridge->channels)->chan);
1594  } else {
1595  *party = NULL;
1596  }
1597 }
1598 
1599 /*!
1600  * \brief Get the transferee and transfer target when the transferer is in a bridge with
1601  * one of the desired parties.
1602  *
1603  * \param transferer_bridge The bridge the transferer is in
1604  * \param other_bridge The bridge the transferer is not in. May be NULL.
1605  * \param transferer The transferer party
1606  * \param[out] transferer_peer The party that is in the bridge with the transferer
1607  * \param[out] other_party The party that is in the other_bridge
1608  */
1609 static void get_transfer_parties_transferer_bridge(struct ast_bridge *transferer_bridge,
1610  struct ast_bridge *other_bridge, struct ast_channel *transferer,
1611  struct ast_channel **transferer_peer, struct ast_channel **other_party)
1612 {
1613  *transferer_peer = ast_bridge_peer(transferer_bridge, transferer);
1614  get_transfer_party_non_transferer_bridge(other_bridge, other_party);
1615 }
1616 
1617 /*!
1618  * \brief determine transferee and transfer target for an attended transfer
1619  *
1620  * In builtin attended transfers, there is a single transferer channel that jumps between
1621  * the two bridges involved. At the time the attended transfer occurs, the transferer could
1622  * be in either bridge, so determining the parties is a bit more complex than normal.
1623  *
1624  * The method used here is to determine which of the two bridges the transferer is in, and
1625  * grabbing the peer from that bridge. The other bridge, if it only has a single channel in it,
1626  * has the other desired channel.
1627  *
1628  * \param transferer The channel performing the transfer
1629  * \param transferee_bridge The bridge that the transferee is in
1630  * \param target_bridge The bridge that the transfer target is in
1631  * \param[out] transferee The transferee channel
1632  * \param[out] transfer_target The transfer target channel
1633  */
1634 static void get_transfer_parties(struct ast_channel *transferer, struct ast_bridge *transferee_bridge,
1635  struct ast_bridge *target_bridge, struct ast_channel **transferee,
1636  struct ast_channel **transfer_target)
1637 {
1638  struct ast_bridge *transferer_bridge;
1639 
1640  ast_channel_lock(transferer);
1641  transferer_bridge = ast_channel_get_bridge(transferer);
1642  ast_channel_unlock(transferer);
1643 
1644  if (transferer_bridge == transferee_bridge) {
1645  get_transfer_parties_transferer_bridge(transferee_bridge, target_bridge,
1646  transferer, transferee, transfer_target);
1647  } else if (transferer_bridge == target_bridge) {
1648  get_transfer_parties_transferer_bridge(target_bridge, transferee_bridge,
1649  transferer, transfer_target, transferee);
1650  } else {
1651  get_transfer_party_non_transferer_bridge(transferee_bridge, transferee);
1652  get_transfer_party_non_transferer_bridge(target_bridge, transfer_target);
1653  }
1654 
1655  ao2_cleanup(transferer_bridge);
1656 }
1657 
1658 /*!
1659  * \brief Send a stasis publication for a successful attended transfer
1660  */
1662  struct ast_channel *transferee_channel, struct ast_channel *target_channel)
1663 {
1664  struct ast_attended_transfer_message *transfer_msg;
1665 
1666  transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1667  props->transferee_bridge, props->transferer, props->target_bridge,
1668  transferee_channel, target_channel);
1669 
1670  if (!transfer_msg) {
1671  ast_log(LOG_ERROR, "Unable to publish successful attended transfer from %s\n",
1672  ast_channel_name(props->transferer));
1673  return;
1674  }
1675 
1678  ao2_cleanup(transfer_msg);
1679 }
1680 
1681 /*!
1682  * \brief Send a stasis publication for an attended transfer that ends in a threeway call
1683  */
1685  struct ast_channel *transferee_channel, struct ast_channel *target_channel)
1686 {
1687  struct ast_attended_transfer_message *transfer_msg;
1688 
1689  transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1690  props->transferee_bridge, props->transferer, props->target_bridge,
1691  transferee_channel, target_channel);
1692 
1693  if (!transfer_msg) {
1694  ast_log(LOG_ERROR, "Unable to publish successful three-way transfer from %s\n",
1695  ast_channel_name(props->transferer));
1696  return;
1697  }
1698 
1700  props->transferee_bridge);
1702  ao2_cleanup(transfer_msg);
1703 }
1704 
1705 /*!
1706  * \brief Send a stasis publication for a failed attended transfer
1707  */
1709 {
1710  struct ast_attended_transfer_message *transfer_msg;
1711 
1712  transfer_msg = ast_attended_transfer_message_create(0, props->transferer,
1713  props->transferee_bridge, props->transferer, props->target_bridge,
1714  NULL, NULL);
1715 
1716  if (!transfer_msg) {
1717  ast_log(LOG_ERROR, "Unable to publish failed transfer from %s\n",
1718  ast_channel_name(props->transferer));
1719  return;
1720  }
1721 
1722  transfer_msg->result = AST_BRIDGE_TRANSFER_FAIL;
1724  ao2_cleanup(transfer_msg);
1725 }
1726 
1727 /*!
1728  * \brief Helper method to play a sound on a channel in a bridge
1729  *
1730  * \param chan The channel to play the sound to
1731  * \param sound The sound to play
1732  */
1733 static void play_sound(struct ast_channel *chan, const char *sound)
1734 {
1735  struct ast_bridge_channel *bridge_channel;
1736 
1737  ast_channel_lock(chan);
1738  bridge_channel = ast_channel_get_bridge_channel(chan);
1739  ast_channel_unlock(chan);
1740 
1741  if (bridge_channel) {
1742  ast_bridge_channel_queue_playfile(bridge_channel, NULL, sound, NULL);
1743  ao2_ref(bridge_channel, -1);
1744  }
1745 }
1746 
1747 /*!
1748  * \brief Helper method to play a fail sound on a channel in a bridge
1749  *
1750  * \param chan The channel to play the fail sound to
1751  */
1752 static void play_failsound(struct ast_channel *chan)
1753 {
1754  char *sound;
1755 
1756  ast_channel_lock(chan);
1757  sound = ast_get_chan_features_xferfailsound(chan);
1758  ast_channel_unlock(chan);
1759 
1760  if (sound) {
1761  play_sound(chan, sound);
1762  ast_free(sound);
1763  }
1764 }
1765 
1766 /*!
1767  * \brief Helper method to stream a fail sound on a channel
1768  *
1769  * \param chan The channel to stream the fail sound to
1770  */
1771 static void stream_failsound(struct ast_channel *chan)
1772 {
1773  char *sound;
1774 
1775  ast_channel_lock(chan);
1776  sound = ast_get_chan_features_xferfailsound(chan);
1777  ast_channel_unlock(chan);
1778 
1779  if (sound) {
1780  ast_stream_and_wait(chan, sound, AST_DIGIT_NONE);
1781  ast_free(sound);
1782  }
1783 }
1784 
1785 /*!
1786  * \brief Helper method to place a channel in a bridge on hold
1787  */
1788 static void hold(struct ast_channel *chan)
1789 {
1790  struct ast_bridge_channel *bridge_channel;
1791 
1792  if (!chan) {
1793  return;
1794  }
1795 
1796  ast_channel_lock(chan);
1797  bridge_channel = ast_channel_get_bridge_channel(chan);
1798  ast_channel_unlock(chan);
1799 
1800  if (bridge_channel) {
1801  ast_bridge_channel_write_hold(bridge_channel, NULL);
1802  ao2_ref(bridge_channel, -1);
1803  }
1804 }
1805 
1806 /*!
1807  * \brief Helper method to take a channel in a bridge off hold
1808  */
1809 static void unhold(struct ast_channel *chan)
1810 {
1811  struct ast_bridge_channel *bridge_channel;
1812 
1813  if (!chan) {
1814  return;
1815  }
1816 
1817  ast_channel_lock(chan);
1818  bridge_channel = ast_channel_get_bridge_channel(chan);
1819  ast_channel_unlock(chan);
1820 
1821  if (bridge_channel) {
1822  ast_bridge_channel_write_unhold(bridge_channel);
1823  ao2_ref(bridge_channel, -1);
1824  }
1825 }
1826 
1827 /*!
1828  * \brief Helper method to send a ringing indication to a channel in a bridge
1829  */
1830 static void ringing(struct ast_channel *chan)
1831 {
1832  struct ast_bridge_channel *bridge_channel;
1833 
1834  ast_channel_lock(chan);
1835  bridge_channel = ast_channel_get_bridge_channel(chan);
1836  ast_channel_unlock(chan);
1837 
1838  if (bridge_channel) {
1840  ao2_ref(bridge_channel, -1);
1841  }
1842 }
1843 
1844 /*!
1845  * \brief Helper method to send a ringing indication to all channels in a bridge
1846  */
1847 static void bridge_ringing(struct ast_bridge *bridge)
1848 {
1849  struct ast_frame ringing = {
1851  .subclass.integer = AST_CONTROL_RINGING,
1852  };
1853 
1854  ast_bridge_lock(bridge);
1855  ast_bridge_queue_everyone_else(bridge, NULL, &ringing);
1856  ast_bridge_unlock(bridge);
1857 }
1858 
1859 /*!
1860  * \brief Helper method to send a hold frame to all channels in a bridge
1861  */
1862 static void bridge_hold(struct ast_bridge *bridge)
1863 {
1864  struct ast_frame hold = {
1866  .subclass.integer = AST_CONTROL_HOLD,
1867  };
1868 
1869  ast_bridge_lock(bridge);
1870  ast_bridge_queue_everyone_else(bridge, NULL, &hold);
1871  ast_bridge_unlock(bridge);
1872 }
1873 
1874 /*!
1875  * \brief Helper method to send an unhold frame to all channels in a bridge
1876  */
1877 static void bridge_unhold(struct ast_bridge *bridge)
1878 {
1879  struct ast_frame unhold = {
1881  .subclass.integer = AST_CONTROL_UNHOLD,
1882  };
1883 
1884  ast_bridge_lock(bridge);
1885  ast_bridge_queue_everyone_else(bridge, NULL, &unhold);
1886  ast_bridge_unlock(bridge);
1887 }
1888 
1889 /*!
1890  * \brief Wrapper for \ref bridge_do_move
1891  */
1892 static void bridge_move(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel *channel, struct ast_channel *swap)
1893 {
1894  struct ast_bridge_channel *bridge_channel;
1895 
1896  ast_bridge_lock_both(src, dest);
1897 
1898  ast_channel_lock(channel);
1899  bridge_channel = ast_channel_get_bridge_channel(channel);
1900  ast_channel_unlock(channel);
1901 
1902  if (bridge_channel) {
1903  ao2_lock(bridge_channel);
1904  bridge_channel->swap = swap;
1905  ao2_unlock(bridge_channel);
1906 
1907  bridge_do_move(dest, bridge_channel, 1, 0);
1908  }
1909 
1910  ast_bridge_unlock(dest);
1911  ast_bridge_unlock(src);
1912 
1913  ao2_cleanup(bridge_channel);
1914 }
1915 
1916 /*!
1917  * \brief Wrapper for \ref bridge_do_merge
1918  */
1919 static void bridge_merge(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel **kick_channels, unsigned int num_channels)
1920 {
1921  struct ast_bridge_channel **kick_bridge_channels = num_channels ?
1922  ast_alloca(num_channels * sizeof(*kick_bridge_channels)) : NULL;
1923  int i;
1924  int num_bridge_channels = 0;
1925 
1926  ast_bridge_lock_both(dest, src);
1927 
1928  for (i = 0; i < num_channels; ++i) {
1929  struct ast_bridge_channel *kick_bridge_channel;
1930 
1931  kick_bridge_channel = bridge_find_channel(src, kick_channels[i]);
1932  if (!kick_bridge_channel) {
1933  kick_bridge_channel = bridge_find_channel(dest, kick_channels[i]);
1934  }
1935 
1936  /* It's possible (and fine) for the bridge channel to be NULL at this point if the
1937  * channel has hung up already. If that happens, we can just remove it from the list
1938  * of bridge channels to kick from the bridge
1939  */
1940  if (!kick_bridge_channel) {
1941  continue;
1942  }
1943 
1944  kick_bridge_channels[num_bridge_channels++] = kick_bridge_channel;
1945  }
1946 
1947  bridge_do_merge(dest, src, kick_bridge_channels, num_bridge_channels, 0);
1948  ast_bridge_unlock(dest);
1949  ast_bridge_unlock(src);
1950 }
1951 
1952 /*!
1953  * \brief Flags that indicate properties of attended transfer states
1954  */
1956  /*! This state requires that the timer be reset when entering the state */
1958  /*! This state's timer uses atxferloopdelay */
1960  /*! This state's timer uses atxfernoanswertimeout */
1962  /*! This state has a time limit associated with it */
1965  /*! This state does not transition to any other states */
1967 };
1968 
1969 static int calling_target_enter(struct attended_transfer_properties *props);
1970 static enum attended_transfer_state calling_target_exit(struct attended_transfer_properties *props,
1971  enum attended_transfer_stimulus stimulus);
1972 
1973 static int hesitant_enter(struct attended_transfer_properties *props);
1974 static enum attended_transfer_state hesitant_exit(struct attended_transfer_properties *props,
1975  enum attended_transfer_stimulus stimulus);
1976 
1977 static int rebridge_enter(struct attended_transfer_properties *props);
1978 
1979 static int resume_enter(struct attended_transfer_properties *props);
1980 
1981 static int threeway_enter(struct attended_transfer_properties *props);
1982 
1983 static int consulting_enter(struct attended_transfer_properties *props);
1984 static enum attended_transfer_state consulting_exit(struct attended_transfer_properties *props,
1985  enum attended_transfer_stimulus stimulus);
1986 
1987 static int double_checking_enter(struct attended_transfer_properties *props);
1988 static enum attended_transfer_state double_checking_exit(struct attended_transfer_properties *props,
1989  enum attended_transfer_stimulus stimulus);
1990 
1991 static int complete_enter(struct attended_transfer_properties *props);
1992 
1993 static int blond_enter(struct attended_transfer_properties *props);
1994 
1995 static int blond_nonfinal_enter(struct attended_transfer_properties *props);
1996 static enum attended_transfer_state blond_nonfinal_exit(struct attended_transfer_properties *props,
1997  enum attended_transfer_stimulus stimulus);
1998 
1999 static int recalling_enter(struct attended_transfer_properties *props);
2000 static enum attended_transfer_state recalling_exit(struct attended_transfer_properties *props,
2001  enum attended_transfer_stimulus stimulus);
2002 
2003 static int wait_to_retransfer_enter(struct attended_transfer_properties *props);
2004 static enum attended_transfer_state wait_to_retransfer_exit(struct attended_transfer_properties *props,
2005  enum attended_transfer_stimulus stimulus);
2006 
2007 static int retransfer_enter(struct attended_transfer_properties *props);
2008 static enum attended_transfer_state retransfer_exit(struct attended_transfer_properties *props,
2009  enum attended_transfer_stimulus stimulus);
2010 
2011 static int wait_to_recall_enter(struct attended_transfer_properties *props);
2012 static enum attended_transfer_state wait_to_recall_exit(struct attended_transfer_properties *props,
2013  enum attended_transfer_stimulus stimulus);
2014 
2015 static int fail_enter(struct attended_transfer_properties *props);
2016 
2017 /*!
2018  * \brief Properties of an attended transfer state
2019  */
2021  /*! The name of the state. Used for debugging */
2022  const char *state_name;
2023  /*! Function used to enter a state */
2024  int (*enter)(struct attended_transfer_properties *props);
2025  /*!
2026  * Function used to exit a state
2027  * This is used both to determine what the next state
2028  * to transition to will be and to perform any cleanup
2029  * necessary before exiting the current state.
2030  */
2032  enum attended_transfer_stimulus stimulus);
2033  /*! Flags associated with this state */
2035 };
2036 
2037 static const struct attended_transfer_state_properties state_properties[] = {
2039  .state_name = "Calling Target",
2040  .enter = calling_target_enter,
2041  .exit = calling_target_exit,
2043  },
2044  [TRANSFER_HESITANT] = {
2045  .state_name = "Hesitant",
2046  .enter = hesitant_enter,
2047  .exit = hesitant_exit,
2049  },
2050  [TRANSFER_REBRIDGE] = {
2051  .state_name = "Rebridge",
2052  .enter = rebridge_enter,
2054  },
2055  [TRANSFER_RESUME] = {
2056  .state_name = "Resume",
2057  .enter = resume_enter,
2059  },
2060  [TRANSFER_THREEWAY] = {
2061  .state_name = "Threeway",
2062  .enter = threeway_enter,
2064  },
2065  [TRANSFER_CONSULTING] = {
2066  .state_name = "Consulting",
2067  .enter = consulting_enter,
2068  .exit = consulting_exit,
2069  },
2071  .state_name = "Double Checking",
2072  .enter = double_checking_enter,
2073  .exit = double_checking_exit,
2074  },
2075  [TRANSFER_COMPLETE] = {
2076  .state_name = "Complete",
2077  .enter = complete_enter,
2079  },
2080  [TRANSFER_BLOND] = {
2081  .state_name = "Blond",
2082  .enter = blond_enter,
2084  },
2086  .state_name = "Blond Non-Final",
2087  .enter = blond_nonfinal_enter,
2088  .exit = blond_nonfinal_exit,
2090  },
2091  [TRANSFER_RECALLING] = {
2092  .state_name = "Recalling",
2093  .enter = recalling_enter,
2094  .exit = recalling_exit,
2096  },
2098  .state_name = "Wait to Retransfer",
2099  .enter = wait_to_retransfer_enter,
2100  .exit = wait_to_retransfer_exit,
2102  },
2103  [TRANSFER_RETRANSFER] = {
2104  .state_name = "Retransfer",
2105  .enter = retransfer_enter,
2106  .exit = retransfer_exit,
2108  },
2110  .state_name = "Wait to Recall",
2111  .enter = wait_to_recall_enter,
2112  .exit = wait_to_recall_exit,
2114  },
2115  [TRANSFER_FAIL] = {
2116  .state_name = "Fail",
2117  .enter = fail_enter,
2119  },
2120 };
2121 
2122 static int calling_target_enter(struct attended_transfer_properties *props)
2123 {
2124  bridge_move(props->target_bridge, props->transferee_bridge, props->transferer, NULL);
2125  return 0;
2126 }
2127 
2128 static enum attended_transfer_state calling_target_exit(struct attended_transfer_properties *props,
2129  enum attended_transfer_stimulus stimulus)
2130 {
2131  switch (stimulus) {
2133  play_failsound(props->transferer);
2134  publish_transfer_fail(props);
2135  return TRANSFER_FAIL;
2141  return TRANSFER_CONSULTING;
2143  case STIMULUS_TIMEOUT:
2145  play_failsound(props->transferer);
2146  return TRANSFER_REBRIDGE;
2149  return TRANSFER_THREEWAY;
2151  return TRANSFER_HESITANT;
2152  case STIMULUS_NONE:
2155  default:
2156  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2157  stimulus_strs[stimulus], state_properties[props->state].state_name);
2158  return props->state;
2159  }
2160 }
2161 
2162 static int hesitant_enter(struct attended_transfer_properties *props)
2163 {
2164  bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2165  unhold(props->transferer);
2166  return 0;
2167 }
2168 
2169 static enum attended_transfer_state hesitant_exit(struct attended_transfer_properties *props,
2170  enum attended_transfer_stimulus stimulus)
2171 {
2172  switch (stimulus) {
2174  play_failsound(props->transferer);
2175  publish_transfer_fail(props);
2176  return TRANSFER_FAIL;
2181  return TRANSFER_DOUBLECHECKING;
2183  case STIMULUS_TIMEOUT:
2185  play_failsound(props->transferer);
2186  return TRANSFER_RESUME;
2188  return TRANSFER_THREEWAY;
2190  hold(props->transferer);
2191  return TRANSFER_CALLING_TARGET;
2192  case STIMULUS_NONE:
2195  default:
2196  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2197  stimulus_strs[stimulus], state_properties[props->state].state_name);
2198  return props->state;
2199  }
2200 }
2201 
2202 static int rebridge_enter(struct attended_transfer_properties *props)
2203 {
2204  bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2205  unhold(props->transferer);
2206  return 0;
2207 }
2208 
2209 static int resume_enter(struct attended_transfer_properties *props)
2210 {
2211  return 0;
2212 }
2213 
2214 static int threeway_enter(struct attended_transfer_properties *props)
2215 {
2216  struct ast_channel *transferee_channel;
2217  struct ast_channel *target_channel;
2218 
2220  &transferee_channel, &target_channel);
2221  bridge_merge(props->transferee_bridge, props->target_bridge, NULL, 0);
2222  play_sound(props->transfer_target, props->xfersound);
2223  play_sound(props->transferer, props->xfersound);
2224  publish_transfer_threeway(props, transferee_channel, target_channel);
2225 
2226  ast_channel_cleanup(transferee_channel);
2227  ast_channel_cleanup(target_channel);
2228  return 0;
2229 }
2230 
2231 static int consulting_enter(struct attended_transfer_properties *props)
2232 {
2233  return 0;
2234 }
2235 
2236 static enum attended_transfer_state consulting_exit(struct attended_transfer_properties *props,
2237  enum attended_transfer_stimulus stimulus)
2238 {
2239  switch (stimulus) {
2241  /* This is a one-of-a-kind event. The transferer and transfer target are talking in
2242  * one bridge, and the transferee has hung up in a separate bridge. In this case, we
2243  * will change the personality of the transfer target bridge back to normal, and play
2244  * a sound to the transferer to indicate the transferee is gone.
2245  */
2247  play_failsound(props->transferer);
2249  /* These next two lines are here to ensure that our reference to the target bridge
2250  * is cleaned up properly and that the target bridge is not destroyed when the
2251  * monitor thread exits
2252  */
2253  ao2_ref(props->target_bridge, -1);
2254  props->target_bridge = NULL;
2255  return TRANSFER_FAIL;
2258  /* We know the transferer is in the target_bridge, so take the other bridge off hold */
2260  return TRANSFER_COMPLETE;
2262  return TRANSFER_REBRIDGE;
2264  play_failsound(props->transferer);
2265  return TRANSFER_REBRIDGE;
2268  return TRANSFER_THREEWAY;
2270  hold(props->transferer);
2271  bridge_move(props->transferee_bridge, props->target_bridge, props->transferer, NULL);
2272  unhold(props->transferer);
2273  return TRANSFER_DOUBLECHECKING;
2274  case STIMULUS_NONE:
2275  case STIMULUS_TIMEOUT:
2279  default:
2280  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2281  stimulus_strs[stimulus], state_properties[props->state].state_name);
2282  return props->state;
2283  }
2284 }
2285 
2286 static int double_checking_enter(struct attended_transfer_properties *props)
2287 {
2288  return 0;
2289 }
2290 
2291 static enum attended_transfer_state double_checking_exit(struct attended_transfer_properties *props,
2292  enum attended_transfer_stimulus stimulus)
2293 {
2294  switch (stimulus) {
2296  play_failsound(props->transferer);
2297  publish_transfer_fail(props);
2298  return TRANSFER_FAIL;
2301  /* We know the transferer is in the transferee, so take the other bridge off hold */
2302  bridge_unhold(props->target_bridge);
2303  return TRANSFER_COMPLETE;
2306  play_failsound(props->transferer);
2307  return TRANSFER_RESUME;
2309  bridge_unhold(props->target_bridge);
2310  return TRANSFER_THREEWAY;
2312  hold(props->transferer);
2313  bridge_move(props->target_bridge, props->transferee_bridge, props->transferer, NULL);
2314  unhold(props->transferer);
2315  return TRANSFER_CONSULTING;
2316  case STIMULUS_NONE:
2317  case STIMULUS_TIMEOUT:
2321  default:
2322  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2323  stimulus_strs[stimulus], state_properties[props->state].state_name);
2324  return props->state;
2325  }
2326 }
2327 
2328 static int complete_enter(struct attended_transfer_properties *props)
2329 {
2330  struct ast_channel *transferee_channel;
2331  struct ast_channel *target_channel;
2332 
2334  &transferee_channel, &target_channel);
2335  bridge_merge(props->transferee_bridge, props->target_bridge, &props->transferer, 1);
2336  play_sound(props->transfer_target, props->xfersound);
2337  publish_transfer_success(props, transferee_channel, target_channel);
2338 
2339  ast_channel_cleanup(transferee_channel);
2340  ast_channel_cleanup(target_channel);
2341  return 0;
2342 }
2343 
2344 static int blond_enter(struct attended_transfer_properties *props)
2345 {
2346  struct ast_channel *transferee_channel;
2347  struct ast_channel *target_channel;
2348 
2350  &transferee_channel, &target_channel);
2351  bridge_merge(props->transferee_bridge, props->target_bridge, &props->transferer, 1);
2352  ringing(props->transfer_target);
2353  publish_transfer_success(props, transferee_channel, target_channel);
2354 
2355  ast_channel_cleanup(transferee_channel);
2356  ast_channel_cleanup(target_channel);
2357  return 0;
2358 }
2359 
2360 static int blond_nonfinal_enter(struct attended_transfer_properties *props)
2361 {
2362  int res;
2363  props->superstate = SUPERSTATE_RECALL;
2364  /* move the transfer target to the recall target along with its reference */
2366  res = blond_enter(props);
2368  return res;
2369 }
2370 
2371 static enum attended_transfer_state blond_nonfinal_exit(struct attended_transfer_properties *props,
2372  enum attended_transfer_stimulus stimulus)
2373 {
2374  switch (stimulus) {
2376  return TRANSFER_FAIL;
2378  return TRANSFER_RESUME;
2379  case STIMULUS_TIMEOUT:
2381  /* It is possible before we hung them up that they queued up a recall target answer
2382  * so we remove it if present as it should not exist.
2383  */
2384  remove_attended_transfer_stimulus(props, STIMULUS_RECALL_TARGET_ANSWER);
2387  return TRANSFER_RECALLING;
2388  case STIMULUS_NONE:
2396  default:
2397  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2398  stimulus_strs[stimulus], state_properties[props->state].state_name);
2399  return props->state;
2400  }
2401 }
2402 
2403 /*!
2404  * \brief Dial callback when attempting to recall the original transferer channel
2405  *
2406  * This is how we can monitor if the recall target has answered or has hung up.
2407  * If one of the two is detected, then an appropriate stimulus is sent to the
2408  * attended transfer monitor thread.
2409  */
2410 static void recall_callback(struct ast_dial *dial)
2411 {
2413 
2414  switch (ast_dial_state(dial)) {
2415  default:
2421  /* Failure cases */
2422  stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_HANGUP);
2423  break;
2428  /* Don't care about these cases */
2429  break;
2431  /* We struck gold! */
2432  props->recall_target = ast_dial_answered_steal(dial);
2433  stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_ANSWER);
2434  break;
2435  }
2436 }
2437 
2438 /*!
2439  * \internal
2440  * \brief Setup common things to transferrer and transfer_target recall channels.
2441  *
2442  * \param recall Channel for recalling a party.
2443  * \param transferer Channel supplying recall information.
2444  *
2445  * \details
2446  * Setup callid, variables, datastores, accountcode, and peeraccount.
2447  *
2448  * \pre Both channels are locked on entry.
2449  *
2450  * \pre COLP and CLID on the recall channel are setup by the caller but not
2451  * explicitly published yet.
2452  */
2453 static void common_recall_channel_setup(struct ast_channel *recall, struct ast_channel *transferer)
2454 {
2455  ast_callid callid;
2456 
2457  callid = ast_read_threadstorage_callid();
2458  if (callid) {
2459  ast_channel_callid_set(recall, callid);
2460  }
2461 
2462  ast_channel_inherit_variables(transferer, recall);
2463  ast_channel_datastore_inherit(transferer, recall);
2464 
2465  /*
2466  * Stage a snapshot to ensure that a snapshot is always done
2467  * on the recall channel so earlier COLP and CLID setup will
2468  * get published.
2469  */
2473 }
2474 
2475 static int recalling_enter(struct attended_transfer_properties *props)
2476 {
2478  struct ast_channel *recall;
2479 
2480  if (!cap) {
2481  return -1;
2482  }
2483 
2485 
2486  /* When we dial the transfer target, since we are communicating
2487  * with a local channel, we can place the local channel in a bridge
2488  * and then call out to it. When recalling the transferer, though, we
2489  * have to use the dialing API because the channel is not local.
2490  */
2491  props->dial = ast_dial_create();
2492  if (!props->dial) {
2493  return -1;
2494  }
2495 
2496  if (ast_dial_append(props->dial, props->transferer_type, props->transferer_addr, NULL)) {
2497  return -1;
2498  }
2499 
2500  if (ast_dial_prerun(props->dial, NULL, cap)) {
2501  return -1;
2502  }
2503 
2504  /*
2505  * Setup callid, variables, datastores, accountcode, peeraccount,
2506  * COLP, and CLID on the recalled transferrer.
2507  */
2508  recall = ast_dial_get_channel(props->dial, 0);
2509  if (!recall) {
2510  return -1;
2511  }
2512  ast_channel_lock_both(recall, props->transferer);
2513 
2514  ast_party_caller_copy(ast_channel_caller(recall),
2515  ast_channel_caller(props->transferer));
2516  ast_party_connected_line_copy(ast_channel_connected(recall),
2517  &props->original_transferer_colp);
2518 
2519  common_recall_channel_setup(recall, props->transferer);
2520  ast_channel_unlock(recall);
2521  ast_channel_unlock(props->transferer);
2522 
2524 
2525  ao2_ref(props, +1);
2526  ast_dial_set_user_data(props->dial, props);
2527 
2528  if (ast_dial_run(props->dial, NULL, 1) == AST_DIAL_RESULT_FAILED) {
2529  ao2_ref(props, -1);
2530  return -1;
2531  }
2532 
2534  return 0;
2535 }
2536 
2537 static enum attended_transfer_state recalling_exit(struct attended_transfer_properties *props,
2538  enum attended_transfer_stimulus stimulus)
2539 {
2540  /* No matter what the outcome was, we need to kill off the dial */
2541  ast_dial_join(props->dial);
2542  ast_dial_destroy(props->dial);
2543  props->dial = NULL;
2544  /* This reference is the one we incremented for the dial state callback (recall_callback) to use */
2545  ao2_ref(props, -1);
2546 
2547  switch (stimulus) {
2549  return TRANSFER_FAIL;
2550  case STIMULUS_TIMEOUT:
2552  ++props->retry_attempts;
2553  if (props->retry_attempts >= props->atxfercallbackretries) {
2554  return TRANSFER_FAIL;
2555  }
2556  if (props->atxferloopdelay) {
2558  }
2559  return TRANSFER_RETRANSFER;
2561  /* Setting this datastore up will allow the transferer to have all of his
2562  * call features set up automatically when the bridge changes back to a
2563  * normal personality
2564  */
2567  if (ast_bridge_impart(props->transferee_bridge, props->recall_target, NULL, NULL,
2569  ast_hangup(props->recall_target);
2571  return TRANSFER_FAIL;
2572  }
2573  return TRANSFER_RESUME;
2574  case STIMULUS_NONE:
2582  default:
2583  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2584  stimulus_strs[stimulus], state_properties[props->state].state_name);
2585  return props->state;
2586  }
2587 }
2588 
2589 static int wait_to_retransfer_enter(struct attended_transfer_properties *props)
2590 {
2592  return 0;
2593 }
2594 
2595 static enum attended_transfer_state wait_to_retransfer_exit(struct attended_transfer_properties *props,
2596  enum attended_transfer_stimulus stimulus)
2597 {
2599  switch (stimulus) {
2601  return TRANSFER_FAIL;
2602  case STIMULUS_TIMEOUT:
2603  return TRANSFER_RETRANSFER;
2604  case STIMULUS_NONE:
2614  default:
2615  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2616  stimulus_strs[stimulus], state_properties[props->state].state_name);
2617  return props->state;
2618  }
2619 }
2620 
2621 static int attach_framehook(struct attended_transfer_properties *props, struct ast_channel *channel);
2622 
2623 static int retransfer_enter(struct attended_transfer_properties *props)
2624 {
2626  char destination[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
2627  int cause;
2628 
2629  if (!cap) {
2630  return -1;
2631  }
2632 
2633  snprintf(destination, sizeof(destination), "%s@%s", props->exten, props->context);
2634 
2636 
2637  /* Get a channel that is the destination we wish to call */
2638  props->recall_target = ast_request("Local", cap, NULL, NULL, destination, &cause);
2639  if (!props->recall_target) {
2640  ast_log(LOG_ERROR, "Unable to request outbound channel for recall target\n");
2641  return -1;
2642  }
2643 
2644  if (attach_framehook(props, props->recall_target)) {
2645  ast_log(LOG_ERROR, "Unable to attach framehook to recall target\n");
2646  ast_hangup(props->recall_target);
2647  props->recall_target = NULL;
2648  return -1;
2649  }
2650 
2651  /*
2652  * Setup callid, variables, datastores, accountcode, peeraccount,
2653  * and COLP on the recalled transfer target.
2654  */
2656 
2657  ast_party_connected_line_copy(ast_channel_connected(props->recall_target),
2658  &props->original_transferer_colp);
2659  ast_party_id_reset(&ast_channel_connected(props->recall_target)->priv);
2660 
2661  common_recall_channel_setup(props->recall_target, props->transferer);
2662  ast_channel_unlock(props->recall_target);
2663  ast_channel_unlock(props->transferer);
2664 
2665  if (ast_call(props->recall_target, destination, 0)) {
2666  ast_log(LOG_ERROR, "Unable to place outbound call to recall target\n");
2667  ast_hangup(props->recall_target);
2668  props->recall_target = NULL;
2669  return -1;
2670  }
2671 
2673  if (ast_bridge_impart(props->transferee_bridge, props->recall_target, NULL, NULL,
2675  ast_log(LOG_ERROR, "Unable to place recall target into bridge\n");
2676  ast_hangup(props->recall_target);
2678  return -1;
2679  }
2680 
2681  return 0;
2682 }
2683 
2684 static enum attended_transfer_state retransfer_exit(struct attended_transfer_properties *props,
2685  enum attended_transfer_stimulus stimulus)
2686 {
2687  switch (stimulus) {
2689  return TRANSFER_FAIL;
2690  case STIMULUS_TIMEOUT:
2694  if (props->atxferloopdelay) {
2695  return TRANSFER_WAIT_TO_RECALL;
2696  }
2697  return TRANSFER_RECALLING;
2699  return TRANSFER_RESUME;
2700  case STIMULUS_NONE:
2708  default:
2709  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2710  stimulus_strs[stimulus], state_properties[props->state].state_name);
2711  return props->state;
2712  }
2713 }
2714 
2715 static int wait_to_recall_enter(struct attended_transfer_properties *props)
2716 {
2718  return 0;
2719 }
2720 
2721 static enum attended_transfer_state wait_to_recall_exit(struct attended_transfer_properties *props,
2722  enum attended_transfer_stimulus stimulus)
2723 {
2725  switch (stimulus) {
2727  return TRANSFER_FAIL;
2728  case STIMULUS_TIMEOUT:
2729  return TRANSFER_RECALLING;
2730  case STIMULUS_NONE:
2740  default:
2741  ast_log(LOG_WARNING, "Unexpected stimulus '%s' received in attended transfer state '%s'\n",
2742  stimulus_strs[stimulus], state_properties[props->state].state_name);
2743  return props->state;
2744  }
2745 }
2746 
2747 static int fail_enter(struct attended_transfer_properties *props)
2748 {
2749  if (props->transferee_bridge) {
2751  props->transferee_bridge = NULL;
2752  }
2753  return 0;
2754 }
2755 
2756 /*!
2757  * \brief DTMF hook when transferer presses abort sequence.
2758  *
2759  * Sends a stimulus to the attended transfer monitor thread that the abort sequence has been pressed
2760  */
2761 static int atxfer_abort(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2762 {
2763  struct attended_transfer_properties *props = hook_pvt;
2764 
2765  ast_debug(1, "Transferer on attended transfer %p pressed abort sequence\n", props);
2766  stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_ABORT);
2767  return 0;
2768 }
2769 
2770 /*!
2771  * \brief DTMF hook when transferer presses complete sequence.
2772  *
2773  * Sends a stimulus to the attended transfer monitor thread that the complete sequence has been pressed
2774  */
2775 static int atxfer_complete(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2776 {
2777  struct attended_transfer_properties *props = hook_pvt;
2778 
2779  ast_debug(1, "Transferer on attended transfer %p pressed complete sequence\n", props);
2780  stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_COMPLETE);
2781  return 0;
2782 }
2783 
2784 /*!
2785  * \brief DTMF hook when transferer presses threeway sequence.
2786  *
2787  * Sends a stimulus to the attended transfer monitor thread that the threeway sequence has been pressed
2788  */
2789 static int atxfer_threeway(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2790 {
2791  struct attended_transfer_properties *props = hook_pvt;
2792 
2793  ast_debug(1, "Transferer on attended transfer %p pressed threeway sequence\n", props);
2794  stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_THREEWAY);
2795  return 0;
2796 }
2797 
2798 /*!
2799  * \brief DTMF hook when transferer presses swap sequence.
2800  *
2801  * Sends a stimulus to the attended transfer monitor thread that the swap sequence has been pressed
2802  */
2803 static int atxfer_swap(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2804 {
2805  struct attended_transfer_properties *props = hook_pvt;
2806 
2807  ast_debug(1, "Transferer on attended transfer %p pressed swap sequence\n", props);
2808  stimulate_attended_transfer(props, STIMULUS_DTMF_ATXFER_SWAP);
2809  return 0;
2810 }
2811 
2812 /*!
2813  * \brief Hangup hook for transferer channel.
2814  *
2815  * Sends a stimulus to the attended transfer monitor thread that the transferer has hung up.
2816  */
2817 static int atxfer_transferer_hangup(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2818 {
2819  struct attended_transfer_properties *props = hook_pvt;
2820 
2821  ast_debug(1, "Transferer on attended transfer %p hung up\n", props);
2822  stimulate_attended_transfer(props, STIMULUS_TRANSFERER_HANGUP);
2823  return 0;
2824 }
2825 
2826 /*!
2827  * \brief Frame hook for transfer target channel
2828  *
2829  * This is used to determine if the transfer target or recall target has answered
2830  * the outgoing call.
2831  *
2832  * When an answer is detected, a stimulus is sent to the attended transfer monitor
2833  * thread to indicate that the transfer target or recall target has answered.
2834  *
2835  * \param chan The channel the framehook is attached to.
2836  * \param frame The frame being read or written.
2837  * \param event What is being done with the frame.
2838  * \param data The attended transfer properties.
2839  */
2841  struct ast_frame *frame, enum ast_framehook_event event, void *data)
2842 {
2843  struct attended_transfer_properties *props = data;
2844 
2845  if (event == AST_FRAMEHOOK_EVENT_READ &&
2846  frame && frame->frametype == AST_FRAME_CONTROL &&
2847  frame->subclass.integer == AST_CONTROL_ANSWER &&
2848  !ast_check_hangup(chan)) {
2849 
2850  ast_debug(1, "Detected an answer for recall attempt on attended transfer %p\n", props);
2851  if (props->superstate == SUPERSTATE_TRANSFER) {
2852  stimulate_attended_transfer(props, STIMULUS_TRANSFER_TARGET_ANSWER);
2853  } else {
2854  stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_ANSWER);
2855  }
2857  props->target_framehook_id = -1;
2858  }
2859 
2860  return frame;
2861 }
2862 
2863 /*! \brief Callback function which informs upstream if we are consuming a frame of a specific type */
2864 static int transfer_target_framehook_consume(void *data, enum ast_frame_type type)
2865 {
2866  return (type == AST_FRAME_CONTROL ? 1 : 0);
2867 }
2868 
2869 static void transfer_target_framehook_destroy_cb(void *data)
2870 {
2871  struct attended_transfer_properties *props = data;
2872  ao2_cleanup(props);
2873 }
2874 
2875 static int bridge_personality_atxfer_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
2876 {
2877  const char *abort_dtmf;
2878  const char *complete_dtmf;
2879  const char *threeway_dtmf;
2880  const char *swap_dtmf;
2881  struct bridge_basic_personality *personality = self->personality;
2882 
2883  if (!ast_channel_has_role(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME)) {
2884  return 0;
2885  }
2886 
2887  abort_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "abort");
2888  complete_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "complete");
2889  threeway_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "threeway");
2890  swap_dtmf = ast_channel_get_role_option(bridge_channel->chan, AST_TRANSFERER_ROLE_NAME, "swap");
2891 
2892  if (!ast_strlen_zero(abort_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2893  abort_dtmf, atxfer_abort, personality->details[personality->current].pvt, NULL,
2895  return -1;
2896  }
2897  if (!ast_strlen_zero(complete_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2898  complete_dtmf, atxfer_complete, personality->details[personality->current].pvt, NULL,
2900  return -1;
2901  }
2902  if (!ast_strlen_zero(threeway_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2903  threeway_dtmf, atxfer_threeway, personality->details[personality->current].pvt, NULL,
2905  return -1;
2906  }
2907  if (!ast_strlen_zero(swap_dtmf) && ast_bridge_dtmf_hook(bridge_channel->features,
2908  swap_dtmf, atxfer_swap, personality->details[personality->current].pvt, NULL,
2910  return -1;
2911  }
2913  personality->details[personality->current].pvt, NULL,
2915  return -1;
2916  }
2917 
2918  return 0;
2919 }
2920 
2921 static void transfer_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct attended_transfer_properties *props)
2922 {
2923  if (self->num_channels > 1 || bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
2924  return;
2925  }
2926 
2927  if (self->num_channels == 1) {
2928  struct ast_bridge_channel *transferer_bridge_channel;
2929  int not_transferer;
2930 
2931  ast_channel_lock(props->transferer);
2932  transferer_bridge_channel = ast_channel_get_bridge_channel(props->transferer);
2933  ast_channel_unlock(props->transferer);
2934 
2935  if (!transferer_bridge_channel) {
2936  return;
2937  }
2938 
2939  not_transferer = AST_LIST_FIRST(&self->channels) != transferer_bridge_channel;
2940  ao2_ref(transferer_bridge_channel, -1);
2941  if (not_transferer) {
2942  return;
2943  }
2944  }
2945 
2946  /* Reaching this point means that either
2947  * 1) The bridge has no channels in it
2948  * 2) The bridge has one channel, and it's the transferer
2949  * In either case, it indicates that the non-transferer parties
2950  * are no longer in the bridge.
2951  */
2952  if (self == props->transferee_bridge) {
2953  stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2954  } else {
2955  stimulate_attended_transfer(props, STIMULUS_TRANSFER_TARGET_HANGUP);
2956  }
2957 }
2958 
2959 static void recall_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct attended_transfer_properties *props)
2960 {
2961  if (self == props->target_bridge) {
2962  /* Once we're in the recall superstate, we no longer care about this bridge */
2963  return;
2964  }
2965 
2966  if (bridge_channel->chan == props->recall_target) {
2967  stimulate_attended_transfer(props, STIMULUS_RECALL_TARGET_HANGUP);
2968  return;
2969  }
2970 
2971  if (self->num_channels == 0) {
2972  /* Empty bridge means all transferees are gone for sure */
2973  stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2974  return;
2975  }
2976 
2977  if (self->num_channels == 1) {
2978  struct ast_bridge_channel *target_bridge_channel;
2979 
2980  if (!props->recall_target) {
2981  /* No recall target means that the pull happened on a transferee. If there's still
2982  * a channel left in the bridge, we don't need to send a stimulus
2983  */
2984  return;
2985  }
2986 
2987  ast_channel_lock(props->recall_target);
2988  target_bridge_channel = ast_channel_get_bridge_channel(props->recall_target);
2989  ast_channel_unlock(props->recall_target);
2990 
2991  if (target_bridge_channel) {
2992  if (AST_LIST_FIRST(&self->channels) == target_bridge_channel) {
2993  stimulate_attended_transfer(props, STIMULUS_TRANSFEREE_HANGUP);
2994  }
2995  ao2_ref(target_bridge_channel, -1);
2996  }
2997  }
2998 }
2999 
3000 static void bridge_personality_atxfer_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
3001 {
3002  struct bridge_basic_personality *personality = self->personality;
3003  struct attended_transfer_properties *props = personality->details[personality->current].pvt;
3004 
3005  switch (props->superstate) {
3006  case SUPERSTATE_TRANSFER:
3007  transfer_pull(self, bridge_channel, props);
3008  break;
3009  case SUPERSTATE_RECALL:
3010  recall_pull(self, bridge_channel, props);
3011  break;
3012  }
3013 }
3014 
3015 static enum attended_transfer_stimulus wait_for_stimulus(struct attended_transfer_properties *props)
3016 {
3017  enum attended_transfer_stimulus stimulus;
3018  struct stimulus_list *list;
3020 
3021  while (!(list = AST_LIST_REMOVE_HEAD(&props->stimulus_queue, next))) {
3022  if (!(state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMED)) {
3023  ast_cond_wait(&props->cond, lock);
3024  } else {
3025  struct timeval relative_timeout = { 0, };
3026  struct timeval absolute_timeout;
3027  struct timespec timeout_arg;
3028 
3029  if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMER_RESET) {
3030  props->start = ast_tvnow();
3031  }
3032 
3033  if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TIMER_LOOP_DELAY) {
3034  relative_timeout.tv_sec = props->atxferloopdelay;
3035  } else {
3036  /* Implied TRANSFER_STATE_FLAG_TIMER_ATXFER_NO_ANSWER */
3037  relative_timeout.tv_sec = props->atxfernoanswertimeout;
3038  }
3039 
3040  absolute_timeout = ast_tvadd(props->start, relative_timeout);
3041  timeout_arg.tv_sec = absolute_timeout.tv_sec;
3042  timeout_arg.tv_nsec = absolute_timeout.tv_usec * 1000;
3043 
3044  if (ast_cond_timedwait(&props->cond, lock, &timeout_arg) == ETIMEDOUT) {
3045  return STIMULUS_TIMEOUT;
3046  }
3047  }
3048  }
3049  stimulus = list->stimulus;
3050  ast_free(list);
3051  return stimulus;
3052 }
3053 
3054 /*!
3055  * \brief The main loop for the attended transfer monitor thread.
3056  *
3057  * This loop runs continuously until the attended transfer reaches
3058  * a terminal state. Stimuli for changes in the attended transfer
3059  * state are handled in this thread so that all factors in an
3060  * attended transfer can be handled in an orderly fashion.
3061  *
3062  * \param data The attended transfer properties
3063  */
3064 static void *attended_transfer_monitor_thread(void *data)
3065 {
3066  struct attended_transfer_properties *props = data;
3067  ast_callid callid;
3068 
3069  /*
3070  * Set thread callid to the transferer's callid because we
3071  * are doing all this on that channel's behalf.
3072  */
3073  ast_channel_lock(props->transferer);
3074  callid = ast_channel_callid(props->transferer);
3075  ast_channel_unlock(props->transferer);
3076  if (callid) {
3078  }
3079 
3080  for (;;) {
3081  enum attended_transfer_stimulus stimulus;
3082 
3083  ast_debug(1, "About to enter state %s for attended transfer %p\n", state_properties[props->state].state_name, props);
3084 
3085  if (state_properties[props->state].enter &&
3086  state_properties[props->state].enter(props)) {
3087  ast_log(LOG_ERROR, "State %s enter function returned an error for attended transfer %p\n",
3088  state_properties[props->state].state_name, props);
3089  break;
3090  }
3091 
3092  if (state_properties[props->state].flags & TRANSFER_STATE_FLAG_TERMINAL) {
3093  ast_debug(1, "State %s is a terminal state. Ending attended transfer %p\n",
3094  state_properties[props->state].state_name, props);
3095  break;
3096  }
3097 
3098  stimulus = wait_for_stimulus(props);
3099 
3100  ast_debug(1, "Received stimulus %s on attended transfer %p\n", stimulus_strs[stimulus], props);
3101 
3102  ast_assert(state_properties[props->state].exit != NULL);
3103 
3104  props->state = state_properties[props->state].exit(props, stimulus);
3105 
3106  ast_debug(1, "Told to enter state %s exit on attended transfer %p\n", state_properties[props->state].state_name, props);
3107  }
3108 
3110 
3111  if (callid) {
3113  }
3114 
3115  return NULL;
3116 }
3117 
3118 static int attach_framehook(struct attended_transfer_properties *props, struct ast_channel *channel)
3119 {
3120  struct ast_framehook_interface target_interface = {
3121  .version = AST_FRAMEHOOK_INTERFACE_VERSION,
3122  .event_cb = transfer_target_framehook_cb,
3123  .destroy_cb = transfer_target_framehook_destroy_cb,
3124  .consume_cb = transfer_target_framehook_consume,
3125  .disable_inheritance = 1,
3126  };
3127 
3128  ao2_ref(props, +1);
3129  target_interface.data = props;
3130 
3131  ast_channel_lock(channel);
3132  props->target_framehook_id = ast_framehook_attach(channel, &target_interface);
3133  ast_channel_unlock(channel);
3134  if (props->target_framehook_id == -1) {
3135  ao2_ref(props, -1);
3136  return -1;
3137  }
3138  return 0;
3139 }
3140 
3141 static int add_transferer_role(struct ast_channel *chan, struct ast_bridge_features_attended_transfer *attended_transfer)
3142 {
3143  const char *atxfer_abort;
3144  const char *atxfer_threeway;
3145  const char *atxfer_complete;
3146  const char *atxfer_swap;
3147  struct ast_features_xfer_config *xfer_cfg;
3148  SCOPED_CHANNELLOCK(lock, chan);
3149 
3150  xfer_cfg = ast_get_chan_features_xfer_config(chan);
3151  if (!xfer_cfg) {
3152  return -1;
3153  }
3154  if (attended_transfer) {
3155  atxfer_abort = ast_strdupa(S_OR(attended_transfer->abort, xfer_cfg->atxferabort));
3156  atxfer_threeway = ast_strdupa(S_OR(attended_transfer->threeway, xfer_cfg->atxferthreeway));
3157  atxfer_complete = ast_strdupa(S_OR(attended_transfer->complete, xfer_cfg->atxfercomplete));
3158  atxfer_swap = ast_strdupa(S_OR(attended_transfer->swap, xfer_cfg->atxferswap));
3159  } else {
3160  atxfer_abort = ast_strdupa(xfer_cfg->atxferabort);
3161  atxfer_threeway = ast_strdupa(xfer_cfg->atxferthreeway);
3162  atxfer_complete = ast_strdupa(xfer_cfg->atxfercomplete);
3163  atxfer_swap = ast_strdupa(xfer_cfg->atxferswap);
3164  }
3165  ao2_ref(xfer_cfg, -1);
3166 
3167  return ast_channel_add_bridge_role(chan, AST_TRANSFERER_ROLE_NAME) ||
3168  ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "abort", atxfer_abort) ||
3169  ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "complete", atxfer_complete) ||
3170  ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "threeway", atxfer_threeway) ||
3171  ast_channel_set_bridge_role_option(chan, AST_TRANSFERER_ROLE_NAME, "swap", atxfer_swap);
3172 }
3173 
3174 /*!
3175  * \brief Helper function that presents dialtone and grabs extension
3176  *
3177  * \retval 0 on success
3178  * \retval -1 on failure
3179  */
3180 static int grab_transfer(struct ast_channel *chan, char *exten, size_t exten_len, const char *context)
3181 {
3182  int res;
3183  int digit_timeout;
3184  int attempts = 0;
3185  int max_attempts;
3186  struct ast_features_xfer_config *xfer_cfg;
3187  char *announce_sound, *retry_sound, *invalid_sound;
3188  const char *extenoverride;
3189 
3190  ast_channel_lock(chan);
3191  extenoverride = get_transfer_exten(chan, NULL);
3192 
3193  if (!ast_strlen_zero(extenoverride)) {
3194  int extenres = ast_exists_extension(chan, context, extenoverride, 1,
3195  S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL)) ? 1 : 0;
3196  if (extenres) {
3197  ast_copy_string(exten, extenoverride, exten_len);
3198  ast_channel_unlock(chan);
3199  ast_verb(3, "Transfering call to '%s@%s'", exten, context);
3200  return 0;
3201  }
3202  ast_log(LOG_WARNING, "Override extension '%s' does not exist in context '%s'\n", extenoverride, context);
3203  /* since we didn't get a valid extension from the channel, fall back and grab it from the user as usual now */
3204  }
3205 
3206  xfer_cfg = ast_get_chan_features_xfer_config(chan);
3207  if (!xfer_cfg) {
3208  ast_log(LOG_ERROR, "Channel %s: Unable to get transfer configuration\n",
3209  ast_channel_name(chan));
3210  ast_channel_unlock(chan);
3211  return -1;
3212  }
3213  digit_timeout = xfer_cfg->transferdigittimeout * 1000;
3214  max_attempts = xfer_cfg->transferdialattempts;
3215  announce_sound = ast_strdupa(xfer_cfg->transferannouncesound);
3216  retry_sound = ast_strdupa(xfer_cfg->transferretrysound);
3217  invalid_sound = ast_strdupa(xfer_cfg->transferinvalidsound);
3218  ao2_ref(xfer_cfg, -1);
3219  ast_channel_unlock(chan);
3220 
3221  /* Play the simple "transfer" prompt out and wait */
3222  if (!ast_strlen_zero(announce_sound)) {
3223  res = ast_stream_and_wait(chan, announce_sound, AST_DIGIT_ANY);
3224  ast_stopstream(chan);
3225  if (res < 0) {
3226  /* Hangup or error */
3227  return -1;
3228  }
3229  if (res) {
3230  /* Store the DTMF digit that interrupted playback of the file. */
3231  exten[0] = res;
3232  }
3233  }
3234 
3235  /* Drop to dialtone so they can enter the extension they want to transfer to */
3236  do {
3237  ++attempts;
3238 
3239  ast_test_suite_event_notify("TRANSFER_BEGIN_DIAL",
3240  "Channel: %s\r\n"
3241  "Attempt: %d",
3242  ast_channel_name(chan), attempts);
3243  res = ast_app_dtget(chan, context, exten, exten_len, exten_len - 1, digit_timeout);
3244  ast_test_suite_event_notify("TRANSFER_DIALLED",
3245  "Channel: %s\r\n"
3246  "Attempt: %d\r\n"
3247  "Dialled: %s\r\n"
3248  "Result: %s",
3249  ast_channel_name(chan), attempts, exten, res > 0 ? "Success" : "Failure");
3250  if (res < 0) {
3251  /* Hangup or error */
3252  res = -1;
3253  } else if (!res) {
3254  /* 0 for invalid extension dialed. */
3255  if (ast_strlen_zero(exten)) {
3256  ast_verb(3, "Channel %s: Dialed no digits.\n", ast_channel_name(chan));
3257  } else {
3258  ast_verb(3, "Channel %s: Dialed '%s@%s' does not exist.\n",
3259  ast_channel_name(chan), exten, context);
3260  }
3261  if (attempts < max_attempts) {
3262  ast_stream_and_wait(chan, retry_sound, AST_DIGIT_NONE);
3263  } else {
3264  ast_stream_and_wait(chan, invalid_sound, AST_DIGIT_NONE);
3265  }
3266  memset(exten, 0, exten_len);
3267  res = 1;
3268  } else {
3269  /* Dialed extension is valid. */
3270  res = 0;
3271  }
3272  } while (res > 0 && attempts < max_attempts);
3273 
3274  ast_test_suite_event_notify("TRANSFER_DIAL_FINAL",
3275  "Channel: %s\r\n"
3276  "Result: %s",
3277  ast_channel_name(chan), res == 0 ? "Success" : "Failure");
3278 
3279  return res ? -1 : 0;
3280 }
3281 
3282 static void copy_caller_data(struct ast_channel *dest, struct ast_channel *caller)
3283 {
3284  ast_channel_lock_both(caller, dest);
3285  ast_connected_line_copy_from_caller(ast_channel_connected(dest), ast_channel_caller(caller));
3286  ast_channel_inherit_variables(caller, dest);
3287  ast_channel_datastore_inherit(caller, dest);
3288  ast_channel_unlock(dest);
3289  ast_channel_unlock(caller);
3290 }
3291 
3292 /*! \brief Helper function that creates an outgoing channel and returns it immediately */
3293 static struct ast_channel *dial_transfer(struct ast_channel *caller, const char *destination)
3294 {
3295  struct ast_channel *chan;
3296  int cause;
3297  struct ast_format_cap *caps;
3298 
3299  ast_channel_lock(caller);
3300  caps = ao2_bump(ast_channel_nativeformats(caller));
3301  ast_channel_unlock(caller);
3302 
3303  /* Now we request a local channel to prepare to call the destination */
3304  chan = ast_request("Local", caps, NULL, caller, destination, &cause);
3305 
3306  ao2_cleanup(caps);
3307 
3308  if (!chan) {
3309  return NULL;
3310  }
3311 
3312  ast_channel_lock_both(chan, caller);
3313 
3315 
3316  /* Who is transferring the call. */
3317  pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", ast_channel_name(caller));
3318 
3319  ast_bridge_set_transfer_variables(chan, ast_channel_name(caller), 1);
3320 
3321  ast_channel_unlock(chan);
3322  ast_channel_unlock(caller);
3323 
3324  /* Before we actually dial out let's inherit appropriate information. */
3325  copy_caller_data(chan, caller);
3326 
3327  return chan;
3328 }
3329 
3330 /*!
3331  * \brief Internal built in feature for attended transfers
3332  *
3333  * This hook will set up a thread for monitoring the progress of
3334  * an attended transfer. For more information about attended transfer
3335  * progress, see documentation on the transfer state machine.
3336  *
3337  * \param bridge_channel The channel that pressed the attended transfer DTMF sequence
3338  * \param hook_pvt Structure with further information about the attended transfer
3339  */
3340 static int feature_attended_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
3341 {
3342  struct ast_bridge_features_attended_transfer *attended_transfer = hook_pvt;
3343  struct attended_transfer_properties *props;
3344  struct ast_bridge *bridge;
3345  char destination[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 1];
3346  char exten[AST_MAX_EXTENSION] = "";
3347  pthread_t thread;
3348 
3349  /* Inhibit the bridge before we do anything else. */
3350  bridge = ast_bridge_channel_merge_inhibit(bridge_channel, +1);
3351 
3352  ast_verb(3, "Channel %s: Started DTMF attended transfer.\n",
3353  ast_channel_name(bridge_channel->chan));
3354 
3355  if (strcmp(bridge->v_table->name, "basic")) {
3356  ast_log(LOG_ERROR, "Channel %s: Attended transfer attempted on unsupported bridge type '%s'.\n",
3357  ast_channel_name(bridge_channel->chan), bridge->v_table->name);
3358  ast_bridge_merge_inhibit(bridge, -1);
3359  ao2_ref(bridge, -1);
3360  return 0;
3361  }
3362 
3363  /* Was the bridge inhibited before we inhibited it? */
3364  if (1 < bridge->inhibit_merge) {
3365  /*
3366  * The peer likely initiated attended transfer at the same time
3367  * and we lost the race.
3368  */
3369  ast_verb(3, "Channel %s: Bridge '%s' does not permit merging at this time.\n",
3370  ast_channel_name(bridge_channel->chan), bridge->uniqueid);
3371  ast_bridge_merge_inhibit(bridge, -1);
3372  ao2_ref(bridge, -1);
3373  return 0;
3374  }
3375 
3376  props = attended_transfer_properties_alloc(bridge_channel->chan,
3377  attended_transfer ? attended_transfer->context : NULL);
3378  if (!props) {
3379  ast_log(LOG_ERROR, "Channel %s: Unable to allocate control structure for performing attended transfer.\n",
3380  ast_channel_name(bridge_channel->chan));
3381  ast_bridge_merge_inhibit(bridge, -1);
3382  ao2_ref(bridge, -1);
3383  return 0;
3384  }
3385 
3386  props->transferee_bridge = bridge;
3387 
3388  if (add_transferer_role(props->transferer, attended_transfer)) {
3389  ast_log(LOG_ERROR, "Channel %s: Unable to set transferrer bridge role.\n",
3390  ast_channel_name(bridge_channel->chan));
3392  return 0;
3393  }
3394 
3395  ast_bridge_channel_write_hold(bridge_channel, NULL);
3396 
3397  /* Grab the extension to transfer to */
3398  if (grab_transfer(bridge_channel->chan, exten, sizeof(exten), props->context)) {
3399  /*
3400  * This is a normal exit for when the user fails
3401  * to specify a valid transfer target. e.g., The user
3402  * hungup, didn't dial any digits, or dialed an invalid
3403  * extension.
3404  */
3405  ast_verb(3, "Channel %s: Unable to acquire target extension for attended transfer.\n",
3406  ast_channel_name(bridge_channel->chan));
3407  ast_bridge_channel_write_unhold(bridge_channel);
3409  return 0;
3410  }
3411 
3412  ast_string_field_set(props, exten, exten);
3413 
3414  /* Fill the variable with the extension and context we want to call */
3415  snprintf(destination, sizeof(destination), "%s@%s", props->exten, props->context);
3416 
3417  ast_debug(1, "Channel %s: Attended transfer target '%s'\n",
3418  ast_channel_name(bridge_channel->chan), destination);
3419 
3420  /* Get a channel that is the destination we wish to call */
3421  props->transfer_target = dial_transfer(bridge_channel->chan, destination);
3422  if (!props->transfer_target) {
3423  ast_log(LOG_ERROR, "Channel %s: Unable to request outbound channel for attended transfer target.\n",
3424  ast_channel_name(bridge_channel->chan));
3425  stream_failsound(props->transferer);
3426  ast_bridge_channel_write_unhold(bridge_channel);
3428  return 0;
3429  }
3430 
3431 
3432  /* Create a bridge to use to talk to the person we are calling */
3434  if (!props->target_bridge) {
3435  ast_log(LOG_ERROR, "Channel %s: Unable to create bridge for attended transfer target.\n",
3436  ast_channel_name(bridge_channel->chan));
3437  stream_failsound(props->transferer);
3438  ast_bridge_channel_write_unhold(bridge_channel);
3439  ast_hangup(props->transfer_target);
3440  props->transfer_target = NULL;
3442  return 0;
3443  }
3445 
3446  if (attach_framehook(props, props->transfer_target)) {
3447  ast_log(LOG_ERROR, "Channel %s: Unable to attach framehook to transfer target.\n",
3448  ast_channel_name(bridge_channel->chan));
3449  stream_failsound(props->transferer);
3450  ast_bridge_channel_write_unhold(bridge_channel);
3451  ast_hangup(props->transfer_target);
3452  props->transfer_target = NULL;
3454  return 0;
3455  }
3456 
3461 
3462  if (ast_call(props->transfer_target, destination, 0)) {
3463  ast_log(LOG_ERROR, "Channel %s: Unable to place outbound call to transfer target.\n",
3464  ast_channel_name(bridge_channel->chan));
3465  stream_failsound(props->transferer);
3466  ast_bridge_channel_write_unhold(bridge_channel);
3467  ast_hangup(props->transfer_target);
3468  props->transfer_target = NULL;
3470  return 0;
3471  }
3472 
3473  /* We increase the refcount of the transfer target because ast_bridge_impart() will
3474  * steal the reference we already have. We need to keep a reference, so the only
3475  * choice is to give it a bump
3476  */
3478  if (ast_bridge_impart(props->target_bridge, props->transfer_target, NULL, NULL,
3480  ast_log(LOG_ERROR, "Channel %s: Unable to place transfer target into bridge.\n",
3481  ast_channel_name(bridge_channel->chan));
3482  stream_failsound(props->transferer);
3483  ast_bridge_channel_write_unhold(bridge_channel);
3484  ast_hangup(props->transfer_target);
3485  props->transfer_target = NULL;
3487  return 0;
3488  }
3489 
3490  if (ast_pthread_create_detached(&thread, NULL, attended_transfer_monitor_thread, props)) {
3491  ast_log(LOG_ERROR, "Channel %s: Unable to create monitoring thread for attended transfer.\n",
3492  ast_channel_name(bridge_channel->chan));
3493  stream_failsound(props->transferer);
3494  ast_bridge_channel_write_unhold(bridge_channel);
3496  return 0;
3497  }
3498 
3499  /* Once the monitoring thread has been created, it is responsible for destroying all
3500  * of the necessary components.
3501  */
3502  return 0;
3503 }
3504 
3505 static void blind_transfer_cb(struct ast_channel *new_channel, struct transfer_channel_data *user_data_wrapper,
3506  enum ast_transfer_type transfer_type)
3507 {
3508  struct ast_channel *transferer_channel = user_data_wrapper->data;
3509 
3510  if (transfer_type == AST_BRIDGE_TRANSFER_MULTI_PARTY) {
3511  copy_caller_data(new_channel, transferer_channel);
3512  }
3513 }
3514 
3515 /*! \brief Internal built in feature for blind transfers */
3516 static int feature_blind_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
3517 {
3518  char xfer_exten[AST_MAX_EXTENSION] = "";
3519  struct ast_bridge_features_blind_transfer *blind_transfer = hook_pvt;
3520  const char *xfer_context;
3521  char *goto_on_blindxfer;
3522 
3523  ast_verb(3, "Channel %s: Started DTMF blind transfer.\n",
3524  ast_channel_name(bridge_channel->chan));
3525 
3526  ast_bridge_channel_write_hold(bridge_channel, NULL);
3527 
3528  ast_channel_lock(bridge_channel->chan);
3529  xfer_context = ast_strdupa(get_transfer_context(bridge_channel->chan,
3530  blind_transfer ? blind_transfer->context : NULL));
3531  goto_on_blindxfer = ast_strdupa(S_OR(pbx_builtin_getvar_helper(bridge_channel->chan,
3532  "GOTO_ON_BLINDXFR"), ""));
3533  ast_channel_unlock(bridge_channel->chan);
3534 
3535  /* Grab the extension to transfer to */
3536  if (grab_transfer(bridge_channel->chan, xfer_exten, sizeof(xfer_exten), xfer_context)) {
3537  ast_bridge_channel_write_unhold(bridge_channel);
3538  return 0;
3539  }
3540 
3541  ast_debug(1, "Channel %s: Blind transfer target '%s@%s'\n",
3542  ast_channel_name(bridge_channel->chan), xfer_exten, xfer_context);
3543 
3544  if (!ast_strlen_zero(goto_on_blindxfer)) {
3545  const char *chan_context;
3546  const char *chan_exten;
3547  int chan_priority;
3548 
3549  ast_debug(1, "Channel %s: After transfer, transferrer goes to %s\n",
3550  ast_channel_name(bridge_channel->chan), goto_on_blindxfer);
3551 
3552  ast_channel_lock(bridge_channel->chan);
3553  chan_context = ast_strdupa(ast_channel_context(bridge_channel->chan));
3554  chan_exten = ast_strdupa(ast_channel_exten(bridge_channel->chan));
3555  chan_priority = ast_channel_priority(bridge_channel->chan);
3556  ast_channel_unlock(bridge_channel->chan);
3557  ast_bridge_set_after_go_on(bridge_channel->chan,
3558  chan_context, chan_exten, chan_priority, goto_on_blindxfer);
3559  }
3560 
3561  if (ast_bridge_transfer_blind(0, bridge_channel->chan, xfer_exten, xfer_context,
3562  blind_transfer_cb, bridge_channel->chan) != AST_BRIDGE_TRANSFER_SUCCESS
3563  && !ast_strlen_zero(goto_on_blindxfer)) {
3564  ast_bridge_discard_after_goto(bridge_channel->chan);
3565  }
3566 
3567  return 0;
3568 }
3569 
3571 struct ast_bridge_methods personality_normal_v_table;
3572 struct ast_bridge_methods personality_atxfer_v_table;
3573 
3574 static void bridge_basic_change_personality(struct ast_bridge *bridge,
3575  enum bridge_basic_personality_type type, void *user_data)
3576 {
3577  struct bridge_basic_personality *personality = bridge->personality;
3579 
3581 
3582  ao2_cleanup(personality->details[personality->current].pvt);
3583  personality->details[personality->current].pvt = NULL;
3584  ast_clear_flag(&bridge->feature_flags, AST_FLAGS_ALL);
3585 
3586  personality->current = type;
3587  if (user_data) {
3588  ao2_ref(user_data, +1);
3589  }
3590  personality->details[personality->current].pvt = user_data;
3591  ast_set_flag(&bridge->feature_flags, personality->details[personality->current].bridge_flags);
3592  if (personality->details[personality->current].on_personality_change) {
3593  personality->details[personality->current].on_personality_change(bridge);
3594  }
3595 }
3596 
3597 static void personality_destructor(void *obj)
3598 {
3599  struct bridge_basic_personality *personality = obj;
3600  int i;
3601 
3602  for (i = 0; i < BRIDGE_BASIC_PERSONALITY_END; ++i) {
3603  ao2_cleanup(personality->details[i].pvt);
3604  }
3605 }
3606 
3607 static void on_personality_change_normal(struct ast_bridge *bridge)
3608 {
3609  struct ast_bridge_channel *iter;
3610 
3611  AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
3612  if (add_normal_hooks(bridge, iter)) {
3613  ast_log(LOG_WARNING, "Unable to set up bridge hooks for channel %s. Features may not work properly\n",
3614  ast_channel_name(iter->chan));
3615  }
3616  }
3617 }
3618 
3619 static void init_details(struct personality_details *details,
3621 {
3622  switch (type) {
3624  details->v_table = &personality_normal_v_table;
3625  details->bridge_flags = NORMAL_FLAGS;
3626  details->on_personality_change = on_personality_change_normal;
3627  break;
3629  details->v_table = &personality_atxfer_v_table;
3630  details->bridge_flags = TRANSFER_FLAGS;
3631  break;
3632  default:
3633  ast_log(LOG_WARNING, "Asked to initialize unexpected basic bridge personality type.\n");
3634  break;
3635  }
3636 }
3637 
3638 static struct ast_bridge *bridge_basic_personality_alloc(struct ast_bridge *bridge)
3639 {
3640  struct bridge_basic_personality *personality;
3641  int i;
3642 
3643  if (!bridge) {
3644  return NULL;
3645  }
3646 
3647  personality = ao2_alloc(sizeof(*personality), personality_destructor);
3648  if (!personality) {
3649  ao2_ref(bridge, -1);
3650  return NULL;
3651  }
3652  for (i = 0; i < BRIDGE_BASIC_PERSONALITY_END; ++i) {
3653  init_details(&personality->details[i], i);
3654  }
3656  bridge->personality = personality;
3657 
3658  return bridge;
3659 }
3660 
3662 {
3663  struct ast_bridge *bridge;
3664 
3665  bridge = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_basic_v_table);
3666  bridge = bridge_base_init(bridge,
3668  | AST_BRIDGE_CAPABILITY_MULTIMIX, NORMAL_FLAGS, NULL, NULL, NULL);
3669  bridge = bridge_basic_personality_alloc(bridge);
3670  bridge = bridge_register(bridge);
3671  return bridge;
3672 }
3673 
3674 void ast_bridge_basic_set_flags(struct ast_bridge *bridge, unsigned int flags)
3675 {
3677  struct bridge_basic_personality *personality = bridge->personality;
3678 
3679  personality->details[personality->current].bridge_flags |= flags;
3680  ast_set_flag(&bridge->feature_flags, flags);
3681 }
3682 
3684 {
3685  /* Setup bridge basic subclass v_table. */
3687  ast_bridge_basic_v_table.name = "basic";
3688  ast_bridge_basic_v_table.push = bridge_basic_push;
3689  ast_bridge_basic_v_table.pull = bridge_basic_pull;
3690  ast_bridge_basic_v_table.destroy = bridge_basic_destroy;
3691 
3692  /*
3693  * Personality vtables don't have the same rules as
3694  * normal bridge vtables. These vtable functions are
3695  * used as alterations to the ast_bridge_basic_v_table
3696  * method functionality and are checked for NULL before
3697  * calling.
3698  */
3699  personality_normal_v_table.name = "normal";
3700  personality_normal_v_table.push = bridge_personality_normal_push;
3701 
3702  personality_atxfer_v_table.name = "attended transfer";
3703  personality_atxfer_v_table.push = bridge_personality_atxfer_push;
3704  personality_atxfer_v_table.pull = bridge_personality_atxfer_pull;
3705 
3708 }
enum attended_transfer_state(* exit)(struct attended_transfer_properties *props, enum attended_transfer_stimulus stimulus)
const char * type
Definition: datastore.h:32
static int transfer_target_framehook_consume(void *data, enum ast_frame_type type)
Callback function which informs upstream if we are consuming a frame of a specific type...
static void clear_stimulus_queue(struct attended_transfer_properties *props)
Free backlog of stimuli in the queue.
static void attended_transfer_properties_shutdown(struct attended_transfer_properties *props)
Initiate shutdown of attended transfer properties.
Main Channel structure associated with a channel.
static void bridge_basic_change_personality(struct ast_bridge *bridge, enum bridge_basic_personality_type type, void *user_data)
Change basic bridge personality.
static void play_failsound(struct ast_channel *chan)
Helper method to play a fail sound on a channel in a bridge.
int ast_dial_destroy(struct ast_dial *dial)
Destroys a dialing structure.
Definition: dial.c:1091
Feature configuration relating to transfers.
struct ast_bridge * ast_bridge_channel_merge_inhibit(struct ast_bridge_channel *bridge_channel, int request)
Adjust the bridge_channel's bridge merge inhibit request count.
#define ast_bridge_lock_both(bridge1, bridge2)
Lock two bridges.
Definition: bridge.h:488
Asterisk main include file. File version handling, generic pbx functions.
struct ast_flags feature_flags
Definition: bridge.h:369
#define AST_LIST_FIRST(head)
Returns the first entry contained in a list.
Definition: linkedlists.h:421
static void publish_transfer_success(struct attended_transfer_properties *props, struct ast_channel *transferee_channel, struct ast_channel *target_channel)
Send a stasis publication for a successful attended transfer.
const ast_string_field uniqueid
Definition: bridge.h:401
struct ast_bridge_features * features
Rebridge state.
Definition: bridge_basic.c:869
void * ast_dial_get_user_data(struct ast_dial *dial)
Return the user data on a dial structure.
Definition: dial.c:1279
char complete[MAXIMUM_DTMF_FEATURE_STRING]
struct ast_bridge * bridge_register(struct ast_bridge *bridge)
Register the new bridge with the system.
Definition: bridge.c:691
Main dialing structure. Contains global options, channels being dialed, and more! ...
Definition: dial.c:48
const ast_string_field xfersound
Message representing attended transfer.
unsigned int bridge_flags
Definition: bridge_basic.c:317
void ast_party_id_reset(struct ast_party_id *id)
Destroy and initialize the given party id structure.
Definition: channel.c:1896
Structure that contains features information.
static void publish_transfer_threeway(struct attended_transfer_properties *props, struct ast_channel *transferee_channel, struct ast_channel *target_channel)
Send a stasis publication for an attended transfer that ends in a threeway call.
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
Resume state.
Definition: bridge_basic.c:902
static void bridge_merge(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel **kick_channels, unsigned int num_channels)
Wrapper for bridge_do_merge.
static void recall_callback(struct ast_dial *dial)
Dial callback when attempting to recall the original transferer channel.
attended_transfer_state
Definition: bridge_basic.c:773
const char * name
Definition: bridge.h:259
void ast_channel_remove_bridge_role(struct ast_channel *chan, const char *role_name)
Removes a bridge role from a channel.
Definition: bridge_roles.c:332
attended_transfer_state_flags
Flags that indicate properties of attended transfer states.
int ast_bridge_features_enable(struct ast_bridge_features *features, enum ast_bridge_builtin_feature feature, const char *dtmf, void *config, ast_bridge_hook_pvt_destructor destructor, enum ast_bridge_hook_remove_flags remove_flags)
Enable a built in feature on a bridge features structure.
Definition: bridge.c:3365
static void hold(struct ast_channel *chan)
Helper method to place a channel in a bridge on hold.
Complete state.
Wait to Retransfer state.
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
Definition: channel.c:2471
An applicationmap configuration item.
void(* on_personality_change)(struct ast_bridge *bridge)
Definition: bridge_basic.c:321
void ast_bridge_publish_attended_transfer(struct ast_attended_transfer_message *transfer_msg)
Publish an attended transfer.
ast_framehook_event
These are the types of events that the framehook's event callback can receive.
Definition: framehook.h:151
struct ast_bridge * transferee_bridge
int ast_bridge_channel_write_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
Write a control frame into the bridge with data.
const ast_string_field transferer_addr
void ast_bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
Run an application on the bridge channel.
struct ast_flags * ast_bridge_features_ds_get(struct ast_channel *chan)
Get DTMF feature flags from the channel.
Definition: bridge_basic.c:268
static void get_transfer_party_non_transferer_bridge(struct ast_bridge *bridge, struct ast_channel **party)
Get a desired transfer party for a bridge the transferer is not in.
int ast_call(struct ast_channel *chan, const char *addr, int timeout)
Make a call.
Definition: channel.c:6461
pthread_t thread
Definition: app_sla.c:329
enum bridge_basic_personality_type current
Definition: bridge_basic.c:329
int ast_framehook_detach(struct ast_channel *chan, int framehook_id)
Detach an framehook from a channel.
Definition: framehook.c:177
enum bridge_channel_state state
Test Framework API.
void * personality
Definition: bridge.h:353
Structure for a data store type.
Definition: datastore.h:31
int ast_bridge_destroy(struct ast_bridge *bridge, int cause)
Destroy a bridge.
Definition: bridge.c:944
Fail state.
Definition: astman.c:222
Dialing API.
int ast_callid_threadassoc_add(ast_callid callid)
Adds a known callid to thread storage of the calling thread.
Definition: logger.c:2320
static void get_transfer_parties_transferer_bridge(struct ast_bridge *transferer_bridge, struct ast_bridge *other_bridge, struct ast_channel *transferer, struct ast_channel **transferer_peer, struct ast_channel **other_party)
Get the transferee and transfer target when the transferer is in a bridge with one of the desired par...
const char * stimulus_strs[]
String representations of the various stimuli.
const ast_string_field transferannouncesound
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
#define AST_DECLARE_STRING_FIELDS(field_list)
Declare the fields needed in a structure.
Definition: stringfields.h:341
bridge_basic_personality_type
Definition: bridge_basic.c:58
unsigned int inhibit_merge
Count of the active temporary requests to inhibit bridge merges. Zero if merges are allowed...
Definition: bridge.h:384
ast_callid ast_read_threadstorage_callid(void)
extracts the callerid from the thread
Definition: logger.c:2298
int ast_bridge_channel_write_callback(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
Write a bridge action custom callback frame into the bridge.
Consulting state.
Definition: bridge_basic.c:956
Structure for a data store object.
Definition: datastore.h:64
void ast_party_connected_line_free(struct ast_party_connected_line *doomed)
Destroy the connected line information contents.
Definition: channel.c:2072
struct ast_datastore * ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
Find a datastore on a channel.
Definition: channel.c:2399
Generic File Format Support. Should be included by clients of the file handling routines. File service providers should instead include mod_format.h.
static void stream_failsound(struct ast_channel *chan)
Helper method to stream a fail sound on a channel.
int ast_channel_add_bridge_role(struct ast_channel *chan, const char *role_name)
Adds a bridge role to a channel.
Definition: bridge_roles.c:313
const ast_string_field exten
static int atxfer_complete(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
DTMF hook when transferer presses complete sequence.
const ast_string_field transferer_type
Properties of an attended transfer state.
int ast_bridge_queue_everyone_else(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
Queue the given frame to everyone else.
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615
void ast_free_ptr(void *ptr)
free() wrapper
Definition: main/astmm.c:1739
struct ast_channel * transfer_target
int ast_attended_transfer_message_add_merge(struct ast_attended_transfer_message *transfer_msg, struct ast_bridge *final_bridge)
Add details for a bridge merge to an attended transfer message.
struct ast_channel * ast_bridge_peer(struct ast_bridge *bridge, struct ast_channel *chan)
Get the channel's bridge peer only if the bridge is two-party.
Definition: bridge.c:4075
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition: datastore.c:68
static struct ast_channel * dial_transfer(struct ast_channel *caller, const char *destination)
Helper function that creates an outgoing channel and returns it immediately.
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
struct ast_bridge * bridge
Bridge this channel is participating in.
struct ast_frame_subclass subclass
Utility functions.
struct ast_channel * recall_target
void ast_party_caller_copy(struct ast_party_caller *dest, const struct ast_party_caller *src)
Copy the source caller information to the destination caller.
Definition: channel.c:1986
struct ast_bridge_methods ast_bridge_base_v_table
Bridge base class virtual method table.
Definition: bridge.c:923
struct ast_channel * ast_request(const char *type, struct ast_format_cap *request_cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
Requests a channel.
Definition: channel.c:6354
static void play_sound(struct ast_channel *chan, const char *sound)
Helper method to play a sound on a channel in a bridge.
void ast_dial_set_user_data(struct ast_dial *dial, void *user_data)
Set user data on a dial structure.
Definition: dial.c:1274
Number structure.
Definition: app_followme.c:154
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
int ast_channel_set_bridge_role_option(struct ast_channel *channel, const char *role_name, const char *option, const char *value)
Set a role option on a channel.
Definition: bridge_roles.c:375
int ast_framehook_attach(struct ast_channel *chan, struct ast_framehook_interface *i)
Attach an framehook onto a channel for frame interception.
Definition: framehook.c:132
void ast_dial_set_state_callback(struct ast_dial *dial, ast_dial_state_callback callback)
Set a callback for state changes.
Definition: dial.c:1269
void * ao2_object_get_lockaddr(void *obj)
Return the mutex lock address of an object.
Definition: astobj2.c:476
int ast_channel_datastore_inherit(struct ast_channel *from, struct ast_channel *to)
Inherit datastores from a parent to a child.
Definition: channel.c:2368
struct ast_attended_transfer_message * ast_attended_transfer_message_create(int is_external, struct ast_channel *to_transferee, struct ast_bridge *transferee_bridge, struct ast_channel *to_transfer_target, struct ast_bridge *target_bridge, struct ast_channel *transferee, struct ast_channel *transfer_target)
Create an Attended transfer message to be published.
enum ast_transfer_result result
int ast_callid_threadassoc_remove(void)
Removes callid from thread storage of the calling thread.
Definition: logger.c:2339
struct ast_bridge * ast_channel_get_bridge(const struct ast_channel *chan)
Get the bridge associated with a channel.
Definition: channel.c:10534
#define ast_bridge_channel_lock(bridge_channel)
Lock the bridge_channel.
ast_mutex_t lock
enum ast_transfer_result ast_bridge_transfer_blind(int is_external, struct ast_channel *transferer, const char *exten, const char *context, transfer_channel_cb new_channel_cb, void *user_data)
Blind transfer target to the extension and context provided.
Definition: bridge.c:4425
int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, enum ast_bridge_impart_flags flags) attribute_warn_unused_result
Impart a channel to a bridge (non-blocking)
Definition: bridge.c:1878
#define SCOPED_CHANNELLOCK(varname, chan)
scoped lock specialization for channels.
Definition: lock.h:619
General Asterisk PBX channel definitions.
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
ast_transfer_type
Definition: bridge.h:1109
const char * src
Retransfer state.
enum ast_dial_result ast_dial_join(struct ast_dial *dial)
Cancel async thread.
Definition: dial.c:1017
int ast_bridge_features_ds_append(struct ast_channel *chan, struct ast_flags *flags)
Append basic bridge DTMF feature flags on the channel.
Definition: bridge_basic.c:263
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
void ast_channel_stage_snapshot_done(struct ast_channel *chan)
Clear flag to indicate channel snapshot is being staged, and publish snapshot.
enum attended_transfer_state state
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
void ast_bridging_init_basic(void)
int ast_bridge_features_ds_set(struct ast_channel *chan, struct ast_flags *flags)
Set basic bridge DTMF feature flags datastore on the channel.
Definition: bridge_basic.c:258
static void ringing(struct ast_channel *chan)
Helper method to send a ringing indication to a channel in a bridge.
void ast_bridge_merge_inhibit(struct ast_bridge *bridge, int request)
Adjust the bridge merge inhibit request count.
Definition: bridge.c:3000
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
Double-checking state.
Definition: bridge_basic.c:986
#define AST_MAX_EXTENSION
Definition: channel.h:134
#define AST_STRING_FIELD(name)
Declare a string field.
Definition: stringfields.h:303
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition: linkedlists.h:557
Calling Target state.
Definition: bridge_basic.c:807
#define ast_channel_cleanup(c)
Cleanup a channel reference.
Definition: channel.h:2969
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:87
int ast_bridge_features_ds_get_string(struct ast_channel *chan, char *buffer, size_t buf_size)
writes a channel's DTMF features to a buffer string
Definition: bridge_basic.c:208
static void bridge_ringing(struct ast_bridge *bridge)
Helper method to send a ringing indication to all channels in a bridge.
Wait to recall state.
Blond non-final state.
struct ast_flags transferer_features
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition: format_cap.h:99
static int grab_transfer(struct ast_channel *chan, char *exten, size_t exten_len, const char *context)
Helper function that presents dialtone and grabs extension.
Recall superstate.
Definition: bridge_basic.c:767
#define SCOPED_LOCK(varname, lock, lockfunc, unlockfunc)
Scoped Locks.
Definition: lock.h:583
A set of macros to manage forward-linked lists.
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
static void bridge_hold(struct ast_bridge *bridge)
Helper method to send a hold frame to all channels in a bridge.
#define ast_debug(level,...)
Log a DEBUG message.
void ast_bridge_discard_after_goto(struct ast_channel *chan)
Discard channel after bridge goto location.
Definition: bridge_after.c:384
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
Details for specific basic bridge personalities.
Definition: bridge_basic.c:313
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
Definition: pbx.c:4175
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition: format_cap.h:49
void ast_bridge_basic_set_flags(struct ast_bridge *bridge, unsigned int flags)
Set feature flags on a basic bridge.
void ast_channel_req_accountcodes(struct ast_channel *chan, const struct ast_channel *requestor, enum ast_channel_requestor_relationship relationship)
Setup new channel accountcodes from the requestor channel after ast_request().
Definition: channel.c:6434
enum ast_dial_result ast_dial_state(struct ast_dial *dial)
Return state of dial.
Definition: dial.c:1008
Core PBX routines and definitions.
enum ast_dial_result ast_dial_run(struct ast_dial *dial, struct ast_channel *chan, int async)
Execute dialing synchronously or asynchronously.
Definition: dial.c:935
int ast_check_hangup(struct ast_channel *chan)
Check to see if a channel is needing hang up.
Definition: channel.c:445
attended_transfer_superstate
Attended transfer superstates.
Definition: bridge_basic.c:736
struct ast_bridge * bridge_base_init(struct ast_bridge *self, uint32_t capabilities, unsigned int flags, const char *creator, const char *name, const char *id)
Initialize the base class of the bridge.
Definition: bridge.c:742
#define ast_test_suite_event_notify(s, f,...)
Definition: test.h:189
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
ast_frame_type
Frame types.
#define ast_bridge_channel_unlock(bridge_channel)
Unlock the bridge_channel.
const struct ast_bridge_methods * v_table
Definition: bridge.h:351
static int atxfer_threeway(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
DTMF hook when transferer presses threeway sequence.
int ast_channel_has_role(struct ast_channel *channel, const char *role_name)
Check if a role exists on a channel.
Definition: bridge_roles.c:394
struct ast_bridge * target_bridge
#define AST_LIST_HEAD_NOLOCK(name, type)
Defines a structure to be used to hold a list of specified type (with no lock).
Definition: linkedlists.h:225
void ast_channel_stage_snapshot(struct ast_channel *chan)
Set flag to indicate channel snapshot is being staged.
Structure that contains information about a bridge.
Definition: bridge.h:349
static struct ast_frame * transfer_target_framehook_cb(struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
Frame hook for transfer target channel.
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
static int atxfer_abort(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
DTMF hook when transferer presses abort sequence.
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54
static void * attended_transfer_monitor_thread(void *data)
The main loop for the attended transfer monitor thread.
#define AST_DIGIT_NONE
Definition: file.h:47
int ast_bridge_hangup_hook(struct ast_bridge_features *features, ast_bridge_hook_callback callback, void *hook_pvt, ast_bridge_hook_pvt_destructor destructor, enum ast_bridge_hook_remove_flags remove_flags)
Attach a hangup hook to a bridge features structure.
Definition: bridge.c:3265
static void remove_hooks_on_personality_change(struct ast_bridge *bridge)
Remove appropriate hooks when basic bridge personality changes.
Definition: bridge_basic.c:719
int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf)
Register a handler for a built in feature.
Definition: bridge.c:3062
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: extconf.c:2282
Connected Line/Party information.
Definition: channel.h:456
int ast_dial_append(struct ast_dial *dial, const char *tech, const char *device, const struct ast_assigned_ids *assignedids)
Append a channel.
Definition: dial.c:280
struct ast_bridge_methods ast_bridge_basic_v_table
Bridge basic class virtual method table.
const char * app_name(struct ast_app *app)
Definition: pbx_app.c:463
void ast_bridge_channel_leave_bridge(struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
Set bridge channel state to leave bridge (if not leaving already).
static void publish_transfer_fail(struct attended_transfer_properties *props)
Send a stasis publication for a failed attended transfer.
int(* enter)(struct attended_transfer_properties *props)
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410
char threeway[MAXIMUM_DTMF_FEATURE_STRING]
structure that organizes different personalities for basic bridges.
Definition: bridge_basic.c:327
attended_transfer_stimulus
Stimuli that can cause transfer state changes.
ast_bridge_builtin_feature
Built in DTMF features.
Bridge virtual methods table definition.
Definition: bridge.h:257
#define ast_bridge_unlock(bridge)
Unlock the bridge.
Definition: bridge.h:481
#define AST_MAX_CONTEXT
Definition: channel.h:135
#define SCOPED_AO2LOCK(varname, obj)
scoped lock specialization for ao2 mutexes.
Definition: lock.h:604
union ast_frame::@224 data
void ast_channel_inherit_variables(const struct ast_channel *parent, struct ast_channel *child)
Inherits channel variable from parent to child channel.
Definition: channel.c:6771
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
struct ast_dial * ast_dial_create(void)
New dialing structure.
Definition: dial.c:223
static int atxfer_transferer_hangup(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
Hangup hook for transferer channel.
struct ast_channel * ast_dial_get_channel(struct ast_dial *dial, int num)
Get the dialing channel, if prerun has been executed.
Definition: dial.c:1258
static struct attended_transfer_properties * attended_transfer_properties_alloc(struct ast_channel *transferer, const char *context)
Allocate and initialize attended transfer properties.
static int atxfer_swap(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
DTMF hook when transferer presses swap sequence.
int ast_stream_and_wait(struct ast_channel *chan, const char *file, const char *digits)
stream file until digit If the file name is non-empty, try to play it.
Definition: file.c:1878
Transfer superstate.
Definition: bridge_basic.c:752
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition: channel.c:2541
static int feature_blind_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
Internal built in feature for blind transfers.
void ast_bridge_set_transfer_variables(struct ast_channel *chan, const char *value, int is_attended)
Set the relevant transfer variables for a single channel.
Definition: bridge.c:4352
int ast_attended_transfer_message_add_threeway(struct ast_attended_transfer_message *transfer_msg, struct ast_channel *survivor_channel, struct ast_bridge *survivor_bridge)
Add details for an attended transfer that was resolved as a three-way call.
struct ast_channel * swap
struct ast_bridge_methods * v_table
Definition: bridge_basic.c:315
Basic bridge subclass API.
void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags flags)
Remove marked bridge channel feature hooks.
Definition: bridge.c:3501
Structure used to handle boolean flags.
Definition: utils.h:199
int ast_bridge_dtmf_hook(struct ast_bridge_features *features, const char *dtmf, ast_bridge_hook_callback callback, void *hook_pvt, ast_bridge_hook_pvt_destructor destructor, enum ast_bridge_hook_remove_flags remove_flags)
Attach a DTMF hook to a bridge features structure.
Definition: bridge.c:3182
Recalling state.
int ast_bridge_features_ds_set_string(struct ast_channel *chan, const char *features)
Sets the features a channel will use upon being bridged.
Definition: bridge_basic.c:189
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
Definition: channel.c:10582
void ast_channel_callid_set(struct ast_channel *chan, ast_callid value)
struct ast_channel * ast_dial_answered_steal(struct ast_dial *dial)
Steal the channel that answered.
Definition: dial.c:989
Structure that contains configuration information for the attended transfer built in feature...
Hesitant state.
Definition: bridge_basic.c:841
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name...
#define ast_bridge_lock(bridge)
Lock the bridge.
Definition: bridge.h:470
int ast_bridge_channel_write_hold(struct ast_bridge_channel *bridge_channel, const char *moh_class)
Write a hold frame into the bridge.
#define ast_channel_lock_both(chan1, chan2)
Lock two channels.
Definition: channel.h:2929
struct ast_bridge_channels_list channels
Definition: bridge.h:363
void * data
Definition: datastore.h:66
struct ast_party_connected_line original_transferer_colp
static void get_transfer_parties(struct ast_channel *transferer, struct ast_bridge *transferee_bridge, struct ast_bridge *target_bridge, struct ast_channel **transferee, struct ast_channel **transfer_target)
determine transferee and transfer target for an attended transfer
struct ast_channel * chan
Structure that contains information regarding a channel in a bridge.
void ast_party_connected_line_copy(struct ast_party_connected_line *dest, const struct ast_party_connected_line *src)
Copy the source connected line information to the destination connected line.
Definition: channel.c:2031
After Bridge Execution API.
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2947
Blond state.
void ast_bridge_channel_lock_bridge(struct ast_bridge_channel *bridge_channel)
Lock the bridge associated with the bridge channel.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
void ast_connected_line_copy_from_caller(struct ast_party_connected_line *dest, const struct ast_party_caller *src)
Copy the caller information to the connected line information.
Definition: channel.c:8293
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one...
Definition: strings.h:80
char abort[MAXIMUM_DTMF_FEATURE_STRING]
int ast_bridge_channel_queue_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
Queue a bridge action play file frame onto the bridge channel.
int ast_app_dtget(struct ast_channel *chan, const char *context, char *collect, size_t size, int maxlen, int timeout)
Present a dialtone and collect a certain length extension.
Definition: main/app.c:138
static void unhold(struct ast_channel *chan)
Helper method to take a channel in a bridge off hold.
enum attended_transfer_state_flags flags
AO2 object that wraps data for transfer_channel_cb.
Definition: bridge.h:1119
Data structure associated with a single frame of data.
const ast_string_field context
const char * ast_channel_get_role_option(struct ast_channel *channel, const char *role_name, const char *option)
Retrieve the value of a requested role option from a channel.
Definition: bridge_roles.c:399
static void bridge_move(struct ast_bridge *dest, struct ast_bridge *src, struct ast_channel *channel, struct ast_channel *swap)
Wrapper for bridge_do_move.
Definition: search.h:40
ast_bridge_pull_channel_fn pull
Definition: bridge.h:267
void ast_bridge_set_after_go_on(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *parseable_goto)
Set channel to go on in the dialplan after the bridge.
Definition: bridge_after.c:622
ast_bridge_destructor_fn destroy
Definition: bridge.h:261
ast_bridge_push_channel_fn push
Definition: bridge.h:265
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition: linkedlists.h:529
enum ast_frame_type frametype
Private Bridging API.
static int feature_attended_transfer(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
Internal built in feature for attended transfers.
Generic container type.
Call Parking and Pickup API Includes code and algorithms from the Zapata library. ...
struct personality_details details[BRIDGE_BASIC_PERSONALITY_END]
Definition: bridge_basic.c:331
Structure that contains configuration information for the blind transfer built in feature...
int ast_bridge_channel_write_unhold(struct ast_bridge_channel *bridge_channel)
Write an unhold frame into the bridge.
Bridging API.
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
Definition: format_cache.c:41
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
static void bridge_unhold(struct ast_bridge *bridge)
Helper method to send an unhold frame to all channels in a bridge.
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition: channel.c:2385
struct ast_channel * transferer
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374
Application convenience functions, designed to give consistent look and feel to Asterisk apps...
struct ast_party_id priv
Private connected party ID.
Definition: channel.h:468
unsigned int num_channels
Definition: bridge.h:373
int ast_stopstream(struct ast_channel *c)
Stops a stream.
Definition: file.c:222
char swap[MAXIMUM_DTMF_FEATURE_STRING]
Media Format Cache API.
enum attended_transfer_superstate superstate
Threeway state.
Definition: bridge_basic.c:928
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
struct ast_bridge * ast_bridge_basic_new(void)
Create a new basic class bridge.
Collection of data related to an attended transfer attempt.
int ast_dial_prerun(struct ast_dial *dial, struct ast_channel *chan, struct ast_format_cap *cap)
Request all appended channels, but do not dial.
Definition: dial.c:431