Author: anthm Date: Tue Oct 2 15:58:06 2007 New Revision: 5779 Modified: freeswitch/trunk/src/include/switch_ivr.h freeswitch/trunk/src/mod/applications/mod_fifo/mod_fifo.c freeswitch/trunk/src/switch_channel.c freeswitch/trunk/src/switch_ivr.c Log: improve mod-fifo Modified: freeswitch/trunk/src/include/switch_ivr.h ============================================================================== --- freeswitch/trunk/src/include/switch_ivr.h (original) +++ freeswitch/trunk/src/include/switch_ivr.h Tue Oct 2 15:58:06 2007 @@ -89,6 +89,8 @@ \note on success the xml object must be freed */ SWITCH_DECLARE(switch_status_t) switch_ivr_generate_xml_cdr(switch_core_session_t *session, switch_xml_t * xml_cdr); +SWITCH_DECLARE(int) switch_ivr_set_xml_profile_data(switch_xml_t xml, switch_caller_profile_t *caller_profile, int off); +SWITCH_DECLARE(int) switch_ivr_set_xml_chan_vars(switch_xml_t xml, switch_channel_t *channel, int off); /*! \brief Parse command from an event Modified: freeswitch/trunk/src/mod/applications/mod_fifo/mod_fifo.c ============================================================================== --- freeswitch/trunk/src/mod/applications/mod_fifo/mod_fifo.c (original) +++ freeswitch/trunk/src/mod/applications/mod_fifo/mod_fifo.c Tue Oct 2 15:58:06 2007 @@ -34,6 +34,8 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_fifo_load); SWITCH_MODULE_DEFINITION(mod_fifo, mod_fifo_load, mod_fifo_shutdown, NULL); +#define FIFO_EVENT "fifo::info" + static switch_status_t on_dtmf(switch_core_session_t *session, void *input, switch_input_type_t itype, void *buf, unsigned int buflen) @@ -79,20 +81,41 @@ static struct { switch_hash_t *fifo_hash; + switch_mutex_t *mutex; switch_memory_pool_t *pool; } globals; + +struct fifo_node { + char *name; + switch_mutex_t *mutex; + switch_queue_t *fifo; + switch_hash_t *caller_hash; + switch_hash_t *consumer_hash; + int caller_count; + int consumer_count; +}; + +typedef struct fifo_node fifo_node_t; + #define FIFO_DESC "Fifo for stacking parked calls." #define FIFO_USAGE "<fifo name> [in [<announce file>|undef] [<music file>|undef] | out [wait|nowait] [<announce file>|undef] [<music file>|undef]]" SWITCH_STANDARD_APP(fifo_function) { int argc; char *mydata = NULL, *argv[5] = { 0 }; - switch_queue_t *fifo; + fifo_node_t *node; switch_channel_t *channel; int nowait = 0; char *moh = NULL; char *announce = NULL; + switch_event_t *event = NULL; + char date[80] = ""; + switch_time_exp_t tm; + switch_time_t ts = switch_time_now(); + switch_size_t retsize; + + if (switch_strlen_zero(data)) { @@ -107,11 +130,19 @@ return; } - if (!(fifo = switch_core_hash_find(globals.fifo_hash, argv[0]))) { - switch_queue_create(&fifo, SWITCH_CORE_QUEUE_LEN, globals.pool); - assert(fifo); - switch_core_hash_insert(globals.fifo_hash, argv[0], fifo); + switch_mutex_lock(globals.mutex); + if (!(node = switch_core_hash_find(globals.fifo_hash, argv[0]))) { + node = switch_core_alloc(globals.pool, sizeof(*node)); + node->name = switch_core_strdup(globals.pool, argv[0]); + switch_queue_create(&node->fifo, SWITCH_CORE_QUEUE_LEN, globals.pool); + switch_core_hash_init(&node->caller_hash, globals.pool); + switch_core_hash_init(&node->consumer_hash, globals.pool); + assert(node->fifo); + switch_mutex_init(&node->mutex, SWITCH_MUTEX_NESTED, globals.pool); + switch_core_hash_insert(globals.fifo_hash, argv[0], node); } + switch_mutex_unlock(globals.mutex); + channel = switch_core_session_get_channel(session); moh = switch_channel_get_variable(channel, "fifo_music"); @@ -129,7 +160,7 @@ if (argc > 2) { announce = argv[2]; } - + if (argc > 3) { moh = argv[3]; } @@ -143,10 +174,29 @@ } switch_channel_set_flag(channel, CF_TAGGED); + + switch_mutex_lock(node->mutex); + node->caller_count++; + switch_core_hash_insert(node->caller_hash, uuid, session); + switch_queue_push(node->fifo, uuid); + switch_mutex_unlock(node->mutex); + + switch_time_exp_lt(&tm, ts); + switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); + switch_channel_set_variable(channel, "fifo_status", "WAITING"); + switch_channel_set_variable(channel, "fifo_timestamp", date); - switch_queue_push(fifo, uuid); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "push"); + switch_event_fire(&event); + } + switch_ivr_park(session, NULL); - + + + if (switch_channel_ready(channel)) { if (announce) { switch_ivr_play_file(session, NULL, announce, NULL); @@ -156,7 +206,24 @@ switch_channel_clear_flag(channel, CF_TAGGED); if (switch_channel_ready(channel)) { - switch_channel_set_state(channel, CS_HIBERNATE); + switch_channel_set_state(channel, CS_HIBERNATE); + } else { + + switch_time_exp_lt(&tm, ts); + switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); + switch_channel_set_variable(channel, "fifo_status", "ABORTED"); + switch_channel_set_variable(channel, "fifo_timestamp", date); + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "abort"); + switch_event_fire(&event); + } + switch_mutex_lock(node->mutex); + node->caller_count--; + switch_core_hash_delete(node->caller_hash, uuid); + switch_mutex_unlock(node->mutex); } return; @@ -179,31 +246,50 @@ check_string(announce); check_string(moh); - + if (!nowait) { + switch_mutex_lock(node->mutex); + node->consumer_count++; + switch_core_hash_insert(node->consumer_hash, switch_core_session_get_uuid(session), session); + switch_mutex_unlock(node->mutex); switch_channel_answer(channel); } - for (;;) { + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_start"); + switch_event_fire(&event); + } + + + switch_time_exp_lt(&tm, ts); + switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); + switch_channel_set_variable(channel, "fifo_status", "WAITING"); + switch_channel_set_variable(channel, "fifo_timestamp", date); + + + + while(switch_channel_ready(channel)) { if (moh) { args.read_frame_callback = read_frame_callback; - args.user_data = fifo; + args.user_data = node->fifo; switch_ivr_play_file(session, NULL, moh, &args); } - if (switch_queue_trypop(fifo, &pop) != SWITCH_STATUS_SUCCESS) { + if (switch_queue_trypop(node->fifo, &pop) != SWITCH_STATUS_SUCCESS) { if (nowait) { - return; + break; } status = switch_core_session_read_frame(session, &read_frame, -1, 0); if (!SWITCH_READ_ACCEPTABLE(status)) { - return; + break; } continue; } if (!pop) { - return; + break; } uuid = (char *) pop; @@ -211,20 +297,40 @@ if ((other_session = switch_core_session_locate(uuid))) { switch_channel_t *other_channel = switch_core_session_get_channel(other_session); switch_caller_profile_t *cloned_profile; + + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(other_channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "caller_pop"); + switch_event_fire(&event); + } + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_pop"); + switch_event_fire(&event); + } + + if (announce) { switch_ivr_play_file(session, NULL, announce, NULL); } else { switch_ivr_sleep(session, 500); } - switch_channel_clear_flag(other_channel, CF_CONTROLLED); - switch_channel_clear_flag(other_channel, CF_BROADCAST); - switch_channel_set_flag(other_channel, CF_BREAK); - switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK); - while (switch_channel_test_flag(other_channel, CF_TAGGED)) { - status = switch_core_session_read_frame(session, &read_frame, -1, 0); - if (!SWITCH_READ_ACCEPTABLE(status)) { - break; + + if (switch_channel_test_flag(other_channel, CF_TAGGED)) { + switch_channel_clear_flag(other_channel, CF_CONTROLLED); + switch_channel_clear_flag(other_channel, CF_BROADCAST); + switch_channel_set_flag(other_channel, CF_BREAK); + switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK); + while (switch_channel_test_flag(other_channel, CF_TAGGED)) { + status = switch_core_session_read_frame(session, &read_frame, -1, 0); + if (!SWITCH_READ_ACCEPTABLE(status)) { + break; + } } } @@ -238,7 +344,29 @@ assert(cloned_profile->next == NULL); switch_channel_set_originatee_caller_profile(channel, cloned_profile); + switch_time_exp_lt(&tm, ts); + switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); + switch_channel_set_variable(channel, "fifo_status", "TALKING"); + switch_channel_set_variable(channel, "fifo_target", uuid); + switch_channel_set_variable(channel, "fifo_timestamp", date); + + switch_channel_set_variable(other_channel, "fifo_status", "TALKING"); + switch_channel_set_variable(other_channel, "fifo_timestamp", date); + switch_channel_set_variable(other_channel, "fifo_target", switch_core_session_get_uuid(session)); switch_ivr_multi_threaded_bridge(session, other_session, on_dtmf, other_session, session); + + switch_time_exp_lt(&tm, ts); + switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); + switch_channel_set_variable(channel, "fifo_status", "WAITING"); + switch_channel_set_variable(channel, "fifo_timestamp", date); + + switch_channel_set_variable(other_channel, "fifo_status", "DONE"); + switch_channel_set_variable(other_channel, "fifo_timestamp", date); + + switch_mutex_lock(node->mutex); + node->caller_count--; + switch_core_hash_delete(node->caller_hash, uuid); + switch_mutex_unlock(node->mutex); switch_core_session_rwunlock(other_session); if (nowait) { done = 1; @@ -251,23 +379,206 @@ break; } } + + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, FIFO_EVENT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Name", "%s", argv[0]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "FIFO-Action", "consumer_stop"); + switch_event_fire(&event); + } + + if (!nowait) { + switch_mutex_lock(node->mutex); + switch_core_hash_delete(node->consumer_hash, switch_core_session_get_uuid(session)); + node->consumer_count--; + switch_mutex_unlock(node->mutex); + } + } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "USAGE %s\n", FIFO_USAGE); } } +static int xml_hash(switch_xml_t xml, switch_hash_t *hash, char *container, char *tag, int cc_off, int verbose) +{ + switch_xml_t x_tmp, x_caller, x_cp, variables; + switch_hash_index_t *hi; + switch_core_session_t *session; + switch_channel_t *channel; + void *val; + const void *var; + + x_tmp = switch_xml_add_child_d(xml, container, cc_off++); + assert(x_tmp); + + for (hi = switch_hash_first(NULL, hash); hi; hi = switch_hash_next(hi)) { + int c_off = 0, d_off = 0; + char *status; + char *ts; + + switch_hash_this(hi, &var, NULL, &val); + session = (switch_core_session_t *) val; + channel = switch_core_session_get_channel(session); + x_caller = switch_xml_add_child_d(x_tmp, tag, c_off++); + assert(x_caller); + + switch_xml_set_attr_d(x_caller, "uuid", switch_core_session_get_uuid(session)); + + if ((status = switch_channel_get_variable(channel, "fifo_status"))) { + switch_xml_set_attr_d(x_caller, "status", status); + } + + if ((ts = switch_channel_get_variable(channel, "fifo_timestamp"))) { + switch_xml_set_attr_d(x_caller, "timestamp", ts); + } + + if ((ts = switch_channel_get_variable(channel, "fifo_target"))) { + switch_xml_set_attr_d(x_caller, "target", ts); + } + + if (!(x_cp = switch_xml_add_child_d(x_caller, "caller_profile", d_off++))) { + abort(); + } + if (verbose) { + d_off += switch_ivr_set_xml_profile_data(x_cp, switch_channel_get_caller_profile(channel), d_off); + + if (!(variables = switch_xml_add_child_d(x_caller, "variables", c_off++))) { + abort(); + } + + switch_ivr_set_xml_chan_vars(variables, channel, c_off); + } + + } + + return cc_off; +} + +static void list_node(fifo_node_t *node, switch_xml_t x_report, int *off, int verbose) +{ + + switch_xml_t x_fifo; + int cc_off = 0; + char tmp[35]; + + x_fifo = switch_xml_add_child_d(x_report, "fifo", (*off)++);; + assert(x_fifo); + + switch_xml_set_attr_d(x_fifo, "name", node->name); + snprintf(tmp, sizeof(tmp), "%d", node->consumer_count); + switch_xml_set_attr_d(x_fifo, "consumer_count", tmp); + snprintf(tmp, sizeof(tmp), "%d", node->caller_count); + switch_xml_set_attr_d(x_fifo, "caller_count", tmp); + + cc_off = xml_hash(x_fifo, node->caller_hash, "callers", "caller", cc_off, verbose); + cc_off = xml_hash(x_fifo, node->consumer_hash, "consumers", "consumer", cc_off, verbose); + +} + +#define FIFO_API_SYNTAX "count <fifo name>" +SWITCH_STANDARD_API(fifo_api_function) +{ + int len = 0; + fifo_node_t *node; + char *data; + int argc = 0; + char *argv[5] = { 0 }; + switch_hash_index_t *hi; + void *val; + const void *var; + int x = 0, verbose = 0; + + if (!switch_strlen_zero(cmd)) { + data = strdup(cmd); + assert(data); + } + + if (switch_strlen_zero(cmd) || (argc = switch_separate_string(data, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) < 1) { + stream->write_function(stream, "%s\n", FIFO_API_SYNTAX); + return SWITCH_STATUS_SUCCESS; + } + + switch_mutex_lock(globals.mutex); + verbose = !strcasecmp(argv[0], "list_verbose"); + + if (!strcasecmp(argv[0], "list") || verbose) { + char *xml_text = NULL; + switch_xml_t x_report = switch_xml_new("fifo_report"); + assert(x_report); + + if (argc < 2) { + for (hi = switch_hash_first(NULL, globals.fifo_hash); hi; hi = switch_hash_next(hi)) { + switch_hash_this(hi, &var, NULL, &val); + node = (fifo_node_t *) val; + switch_mutex_lock(node->mutex); + list_node(node, x_report, &x, verbose); + switch_mutex_unlock(node->mutex); + } + } else { + if ((node = switch_core_hash_find(globals.fifo_hash, argv[1]))) { + switch_mutex_lock(node->mutex); + list_node(node, x_report, &x, verbose); + switch_mutex_unlock(node->mutex); + } + } + xml_text = switch_xml_toxml(x_report); + assert(xml_text); + stream->write_function(stream, "%s\n", xml_text); + switch_xml_free(x_report); + switch_safe_free(xml_text); + + } else if (!strcasecmp(argv[0], "count")) { + if (argc < 2) { + for (hi = switch_hash_first(NULL, globals.fifo_hash); hi; hi = switch_hash_next(hi)) { + switch_hash_this(hi, &var, NULL, &val); + node = (fifo_node_t *) val; + len = switch_queue_size(node->fifo); + switch_mutex_lock(node->mutex); + stream->write_function(stream, "%s:%d:%d:%d\n", (char *)var, node->consumer_count, node->caller_count, len); + switch_mutex_unlock(node->mutex); + x++; + } + + if (!x) { + stream->write_function(stream, "none\n"); + } + } else { + if ((node = switch_core_hash_find(globals.fifo_hash, argv[1]))) { + len = switch_queue_size(node->fifo); + } + switch_mutex_lock(node->mutex); + stream->write_function(stream, "%s:%d:%d:%d\n", argv[1], node->consumer_count, node->caller_count, len); + switch_mutex_unlock(node->mutex); + } + } + + switch_mutex_unlock(globals.mutex); + return SWITCH_STATUS_SUCCESS; +} + + SWITCH_MODULE_LOAD_FUNCTION(mod_fifo_load) { switch_application_interface_t *app_interface; + switch_api_interface_t *commands_api_interface; + + + /* create/register custom event message type */ + if (switch_event_reserve_subclass(FIFO_EVENT) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register subclass %s!", FIFO_EVENT); + return SWITCH_STATUS_TERM; + } switch_core_new_memory_pool(&globals.pool); switch_core_hash_init(&globals.fifo_hash, globals.pool); + switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, globals.pool); /* connect my internal structure to the blank pointer passed to me */ *module_interface = switch_loadable_module_create_module_interface(pool, modname); SWITCH_ADD_APP(app_interface, "fifo", "Park with FIFO", FIFO_DESC, fifo_function, FIFO_USAGE, SAF_NONE); - + SWITCH_ADD_API(commands_api_interface, "fifo", "Return data about a fifo", fifo_api_function, FIFO_API_SYNTAX); return SWITCH_STATUS_SUCCESS; } @@ -279,16 +590,19 @@ { switch_hash_index_t *hi; void *val, *pop; - switch_queue_t *fifo; - + fifo_node_t *node; + switch_mutex_lock(globals.mutex); /* Cleanup*/ for (hi = switch_hash_first(NULL, globals.fifo_hash); hi; hi = switch_hash_next(hi)) { switch_hash_this(hi, NULL, NULL, &val); - fifo = (switch_queue_t *) val; - while (switch_queue_trypop(fifo, &pop) == SWITCH_STATUS_SUCCESS) { + node = (fifo_node_t *) val; + while (switch_queue_trypop(node->fifo, &pop) == SWITCH_STATUS_SUCCESS) { free(pop); } + switch_core_hash_destroy(&node->caller_hash); + switch_core_hash_destroy(&node->consumer_hash); } + switch_mutex_unlock(globals.mutex); switch_core_hash_destroy(&globals.fifo_hash); switch_core_destroy_memory_pool(&globals.pool); return SWITCH_STATUS_SUCCESS; Modified: freeswitch/trunk/src/switch_channel.c ============================================================================== --- freeswitch/trunk/src/switch_channel.c (original) +++ freeswitch/trunk/src/switch_channel.c Tue Oct 2 15:58:06 2007 @@ -404,11 +404,10 @@ if (!switch_strlen_zero(varname)) { switch_mutex_lock(channel->profile_mutex); + switch_event_del_header(channel->variables, varname); if (value) { switch_event_add_header(channel->variables, SWITCH_STACK_BOTTOM, varname, "%s", value); - } else { - switch_event_del_header(channel->variables, varname); - } + } switch_mutex_unlock(channel->profile_mutex); return SWITCH_STATUS_SUCCESS; } Modified: freeswitch/trunk/src/switch_ivr.c ============================================================================== --- freeswitch/trunk/src/switch_ivr.c (original) +++ freeswitch/trunk/src/switch_ivr.c Tue Oct 2 15:58:06 2007 @@ -1206,7 +1206,7 @@ return status; } -static int set_profile_data(switch_xml_t xml, switch_caller_profile_t *caller_profile, int off) +SWITCH_DECLARE(int) switch_ivr_set_xml_profile_data(switch_xml_t xml, switch_caller_profile_t *caller_profile, int off) { switch_xml_t param; @@ -1278,14 +1278,43 @@ return off; } +SWITCH_DECLARE(int) switch_ivr_set_xml_chan_vars(switch_xml_t xml, switch_channel_t *channel, int off) +{ + switch_event_header_t *hi; + switch_xml_t variable; + + if ((hi = switch_channel_variable_first(channel))) { + for (; hi; hi = hi->next) { + char *vvar = hi->name; + char *vval = hi->value; + if (vvar && vval) { + if ((variable = switch_xml_add_child_d(xml, (char *) vvar, off++))) { + char *data; + char *value = (char *) vval; + switch_size_t dlen = strlen(value) * 3; + + if ((data = malloc(dlen))) { + memset(data, 0, dlen); + switch_url_encode(value, data, dlen); + switch_xml_set_txt_d(variable, data); + free(data); + } + } + } + } + switch_channel_variable_last(channel); + } + + return off; +} + SWITCH_DECLARE(switch_status_t) switch_ivr_generate_xml_cdr(switch_core_session_t *session, switch_xml_t * xml_cdr) { switch_channel_t *channel; switch_caller_profile_t *caller_profile; - switch_xml_t variable, variables, cdr, x_main_cp, x_caller_profile, x_caller_extension, x_times, time_tag, + switch_xml_t variables, cdr, x_main_cp, x_caller_profile, x_caller_extension, x_times, time_tag, x_application, x_callflow, x_inner_extension, x_apps, x_o; switch_app_log_t *app_log; - switch_event_header_t *hi; char tmp[512]; int cdr_off = 0, v_off = 0; @@ -1318,27 +1347,8 @@ } } - - if ((hi = switch_channel_variable_first(channel))) { - for (; hi; hi = hi->next) { - char *vvar = hi->name; - char *vval = hi->value; - if (vvar && vval) { - if ((variable = switch_xml_add_child_d(variables, (char *) vvar, v_off++))) { - char *data; - char *value = (char *) vval; - switch_size_t dlen = strlen(value) * 3; - - if ((data = switch_core_session_alloc(session, dlen))) { - switch_url_encode(value, data, dlen); - switch_xml_set_txt_d(variable, data); - } - } - } - } - switch_channel_variable_last(channel); - } - + switch_ivr_set_xml_chan_vars(variables, channel, v_off); + caller_profile = switch_channel_get_caller_profile(channel); while (caller_profile) { @@ -1419,7 +1429,7 @@ goto error; } - cp_off += set_profile_data(x_main_cp, caller_profile, 0); + cp_off += switch_ivr_set_xml_profile_data(x_main_cp, caller_profile, 0); if (caller_profile->originator_caller_profile) { switch_caller_profile_t *cp = NULL; @@ -1432,7 +1442,7 @@ if (!(x_caller_profile = switch_xml_add_child_d(x_o, "originator_caller_profile", off++))) { goto error; } - set_profile_data(x_caller_profile, cp, 0); + switch_ivr_set_xml_profile_data(x_caller_profile, cp, 0); } } @@ -1446,7 +1456,7 @@ if (!(x_caller_profile = switch_xml_add_child_d(x_o, "originatee_caller_profile", off++))) { goto error; } - set_profile_data(x_caller_profile, caller_profile->originatee_caller_profile, 0); + switch_ivr_set_xml_profile_data(x_caller_profile, caller_profile->originatee_caller_profile, 0); } }