kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-04-15 08:29:45 +00:00
Code Issues Projects Releases Wiki Activity

fix obscure bs, remove CR from dptools, add info app

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@3463 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale 2006-11-28 02:23:26 +00:00
parent 44649c70b4
commit d20870e121
3 changed files with 472 additions and 428 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

884
src/mod/applications/mod_dptools/mod_dptools.c
View File

@ -1,425 +1,465 @@
/* /*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com> * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
* *
* Version: MPL 1.1 * Version: MPL 1.1
* *
* The contents of this file are subject to the Mozilla Public License Version * The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with * 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at * the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/ * http://www.mozilla.org/MPL/
* *
* Software distributed under the License is distributed on an "AS IS" basis, * Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the * for the specific language governing rights and limitations under the
* License. * License.
* *
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* *
* The Initial Developer of the Original Code is * The Initial Developer of the Original Code is
* Anthony Minessale II <anthmct@yahoo.com> * Anthony Minessale II <anthmct@yahoo.com>
* Portions created by the Initial Developer are Copyright (C) * Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved. * the Initial Developer. All Rights Reserved.
* *
* Contributor(s): * Contributor(s):
* *
* Anthony Minessale II <anthmct@yahoo.com> * Anthony Minessale II <anthmct@yahoo.com>
* Ken Rice, Asteria Solutions Group, Inc <ken@asteriasgi.com> * Ken Rice, Asteria Solutions Group, Inc <ken@asteriasgi.com>
* Michael Murdock <mike at mmurdock dot org> * Michael Murdock <mike at mmurdock dot org>
* *
* *
* mod_dptools.c -- Raw Audio File Streaming Application Module * mod_dptools.c -- Raw Audio File Streaming Application Module
* *
*/ */
#include <switch.h> #include <switch.h>
static const char modname[] = "mod_dptools"; static const char modname[] = "mod_dptools";
static const switch_application_interface_t detect_speech_application_interface; static const switch_application_interface_t detect_speech_application_interface;
static void detect_speech_function(switch_core_session_t *session, char *data) static void detect_speech_function(switch_core_session_t *session, char *data)
{ {
char *argv[4]; char *argv[4];
int argc; int argc;
char *lbuf = NULL; char *lbuf = NULL;
if ((lbuf = switch_core_session_strdup(session, data)) && (argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) { if ((lbuf = switch_core_session_strdup(session, data)) && (argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
if (!strcasecmp(argv[0], "grammar") && argc >= 1) { if (!strcasecmp(argv[0], "grammar") && argc >= 1) {
switch_ivr_detect_speech_load_grammar(session, argv[1], argv[2]); switch_ivr_detect_speech_load_grammar(session, argv[1], argv[2]);
} else if (!strcasecmp(argv[0], "nogrammar")) { } else if (!strcasecmp(argv[0], "nogrammar")) {
switch_ivr_detect_speech_unload_grammar(session, argv[1]); switch_ivr_detect_speech_unload_grammar(session, argv[1]);
} else if (!strcasecmp(argv[0], "pause")) { } else if (!strcasecmp(argv[0], "pause")) {
switch_ivr_pause_detect_speech(session); switch_ivr_pause_detect_speech(session);
} else if (!strcasecmp(argv[0], "resume")) { } else if (!strcasecmp(argv[0], "resume")) {
switch_ivr_resume_detect_speech(session); switch_ivr_resume_detect_speech(session);
} else if (!strcasecmp(argv[0], "stop")) { } else if (!strcasecmp(argv[0], "stop")) {
switch_ivr_stop_detect_speech(session); switch_ivr_stop_detect_speech(session);
} else if (argc >= 3) { } else if (argc >= 3) {
switch_ivr_detect_speech(session, argv[0], argv[1], argv[2], argv[3], NULL); switch_ivr_detect_speech(session, argv[0], argv[1], argv[2], argv[3], NULL);
} }
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Usage: %s\n", detect_speech_application_interface.syntax); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Usage: %s\n", detect_speech_application_interface.syntax);
} }
} }
static void ringback_function(switch_core_session_t *session, char *data) static void ringback_function(switch_core_session_t *session, char *data)
{ {
switch_channel_t *channel; switch_channel_t *channel;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL); assert(channel != NULL);
switch_channel_ringback(channel); switch_channel_ringback(channel);
} }
static void transfer_function(switch_core_session_t *session, char *data) static void transfer_function(switch_core_session_t *session, char *data)
{ {
int argc; int argc;
char *argv[4] = {0}; char *argv[4] = {0};
char *mydata; char *mydata;
if ((mydata = switch_core_session_strdup(session, data))) { if ((mydata = switch_core_session_strdup(session, data))) {
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) >= 1) { if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) >= 1) {
switch_ivr_session_transfer(session, argv[0], argv[1], argv[2]); switch_ivr_session_transfer(session, argv[0], argv[1], argv[2]);
} else { } else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No extension specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No extension specified.\n");
} }
} }
} }
static void sleep_function(switch_core_session_t *session, char *data) static void sleep_function(switch_core_session_t *session, char *data)
{ {
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No timeout specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No timeout specified.\n");
} else { } else {
uint32_t ms = atoi(data); uint32_t ms = atoi(data);
switch_ivr_sleep(session, ms); switch_ivr_sleep(session, ms);
} }
} }
static void eval_function(switch_core_session_t *session, char *data) static void eval_function(switch_core_session_t *session, char *data)
{ {
return; return;
} }
static void answer_function(switch_core_session_t *session, char *data) static void answer_function(switch_core_session_t *session, char *data)
{ {
switch_channel_t *channel; switch_channel_t *channel;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL); assert(channel != NULL);
switch_channel_answer(channel); switch_channel_answer(channel);
} }
static void set_function(switch_core_session_t *session, char *data) static void set_function(switch_core_session_t *session, char *data)
{ {
switch_channel_t *channel; switch_channel_t *channel;
char *var, *val = NULL; char *var, *val = NULL;
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
assert(channel != NULL); assert(channel != NULL);
if (switch_strlen_zero(data)) { if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No variable name specified.\n");
} else { } else {
var = switch_core_session_strdup(session, data); var = switch_core_session_strdup(session, data);
val = strchr(var, '='); val = strchr(var, '=');
if (val) { if (val) {
*val++ = '\0'; *val++ = '\0';
if (!strcmp(val, "_UNDEF_")) { if (!strcmp(val, "_UNDEF_")) {
val = NULL; val = NULL;
} }
} }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", var, val ? val : "UNDEF"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", var, val ? val : "UNDEF");
switch_channel_set_variable(channel, var, val); switch_channel_set_variable(channel, var, val);
} }
} }
static void log_function(switch_core_session_t *session, char *data) static void log_function(switch_core_session_t *session, char *data)
{ {
switch_channel_t *channel; switch_channel_t *channel;
channel = switch_core_session_get_channel(session); char *level, *log_str;
assert(channel != NULL);
channel = switch_core_session_get_channel(session);
if (!switch_strlen_zero(data)) { assert(channel != NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s\n", data);
} if ((level = strdup(data))) {
} switch_event_types_t etype = SWITCH_LOG_DEBUG;
static void privacy_function(switch_core_session_t *session, char *data) if ((log_str = strchr(level, ' '))) {
{ *log_str++ = '\0';
switch_channel_t *channel; switch_name_event(level, &etype);
switch_caller_profile_t *caller_profile; } else {
char *arg; log_str = level;
}
channel = switch_core_session_get_channel(session);
assert(channel != NULL); switch_log_printf(SWITCH_CHANNEL_LOG, etype, "%s\n", log_str);
switch_safe_free(level);
caller_profile = switch_channel_get_caller_profile(channel); }
}
if (switch_strlen_zero(data)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No privacy mode specified.\n");
} else { static void info_function(switch_core_session_t *session, char *data)
arg = switch_core_session_strdup(session, data); {
switch_channel_t *channel;
switch_set_flag(caller_profile, SWITCH_CPF_SCREEN); switch_event_t *event;
char *buf;
if(!strcasecmp(arg, "no")) {
switch_clear_flag(caller_profile, SWITCH_CPF_HIDE_NAME); channel = switch_core_session_get_channel(session);
switch_clear_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER); assert(channel != NULL);
} else if (!strcasecmp(arg, "yes")) {
switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER); if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
} else if (!strcasecmp(arg, "full")) { switch_channel_event_set_data(channel, event);
switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER); switch_event_serialize(event, &buf);
} else if (!strcasecmp(arg, "name")) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "CHANNEL_DATA:\n%s\n", buf);
switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME); switch_event_destroy(&event);
} else if (!strcasecmp(arg, "number")) { }
switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER);
} else { }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "INVALID privacy mode specified. Use a valid mode [no|yes|name|full|number].\n");
} static void privacy_function(switch_core_session_t *session, char *data)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Set Privacy to %s [%d]\n", arg, caller_profile->flags); {
} switch_channel_t *channel;
} switch_caller_profile_t *caller_profile;
char *arg;
static void strftime_function(switch_core_session_t *session, char *data)
{ channel = switch_core_session_get_channel(session);
char *argv[2]; assert(channel != NULL);
int argc;
char *lbuf; caller_profile = switch_channel_get_caller_profile(channel);
if ((lbuf = switch_core_session_strdup(session, data))&&(argc = switch_separate_string(lbuf, '=', argv, (sizeof(argv) / sizeof(argv[0])))) > 1) { if (switch_strlen_zero(data)) {
switch_size_t retsize; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No privacy mode specified.\n");
switch_time_exp_t tm; } else {
char date[80] = ""; arg = switch_core_session_strdup(session, data);
switch_channel_t *channel;
switch_set_flag(caller_profile, SWITCH_CPF_SCREEN);
channel = switch_core_session_get_channel(session);
assert(channel != NULL); if(!strcasecmp(arg, "no")) {
switch_clear_flag(caller_profile, SWITCH_CPF_HIDE_NAME);
switch_time_exp_lt(&tm, switch_time_now()); switch_clear_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER);
switch_strftime(date, &retsize, sizeof(date), argv[1], &tm); } else if (!strcasecmp(arg, "yes")) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", argv[0], date); switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER);
switch_channel_set_variable(channel, argv[0], date); } else if (!strcasecmp(arg, "full")) {
} switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER);
} } else if (!strcasecmp(arg, "name")) {
switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NAME);
static switch_status_t strftime_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream) } else if (!strcasecmp(arg, "number")) {
{ switch_set_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER);
switch_size_t retsize; } else {
switch_time_exp_t tm; switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "INVALID privacy mode specified. Use a valid mode [no|yes|name|full|number].\n");
char date[80] = ""; }
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Set Privacy to %s [%d]\n", arg, caller_profile->flags);
switch_time_exp_lt(&tm, switch_time_now()); }
switch_strftime(date, &retsize, sizeof(date), fmt, &tm); }
stream->write_function(stream, date);
static void strftime_function(switch_core_session_t *session, char *data)
return SWITCH_STATUS_SUCCESS; {
} char *argv[2];
int argc;
static switch_status_t presence_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream) char *lbuf;
{
switch_event_t *event; if ((lbuf = switch_core_session_strdup(session, data))&&(argc = switch_separate_string(lbuf, '=', argv, (sizeof(argv) / sizeof(argv[0])))) > 1) {
char *lbuf, *argv[4]; switch_size_t retsize;
int argc = 0; switch_time_exp_t tm;
switch_event_types_t type = SWITCH_EVENT_PRESENCE_IN; char date[80] = "";
switch_channel_t *channel;
if (fmt && (lbuf = strdup(fmt)) && (argc = switch_separate_string(lbuf, '|', argv, (sizeof(argv) / sizeof(argv[0])))) > 0) {
if (!strcasecmp(argv[0], "out")) { channel = switch_core_session_get_channel(session);
type = SWITCH_EVENT_PRESENCE_OUT; assert(channel != NULL);
} else if (argc != 4) {
stream->write_function(stream, "Invalid"); switch_time_exp_lt(&tm, switch_time_now());
return SWITCH_STATUS_SUCCESS; switch_strftime(date, &retsize, sizeof(date), argv[1], &tm);
} switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SET [%s]=[%s]\n", argv[0], date);
switch_channel_set_variable(channel, argv[0], date);
if (switch_event_create(&event, type) == SWITCH_STATUS_SUCCESS) { }
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", "dp"); }
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", __FILE__);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", argv[1]); static switch_status_t strftime_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
if (type == SWITCH_EVENT_PRESENCE_IN) { {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "%s", argv[2]); switch_size_t retsize;
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "%s", argv[3]); switch_time_exp_t tm;
} char date[80] = "";
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
switch_event_fire(&event); switch_time_exp_lt(&tm, switch_time_now());
} switch_strftime(date, &retsize, sizeof(date), fmt, &tm);
stream->write_function(stream, "Event Sent"); stream->write_function(stream, date);
switch_safe_free(lbuf);
} else { return SWITCH_STATUS_SUCCESS;
stream->write_function(stream, "Invalid"); }
}
static switch_status_t presence_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
return SWITCH_STATUS_SUCCESS; {
} switch_event_t *event;
char *lbuf, *argv[4];
int argc = 0;
static switch_status_t chat_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream) switch_event_types_t type = SWITCH_EVENT_PRESENCE_IN;
{
char *lbuf, *argv[4]; if (fmt && (lbuf = strdup(fmt)) && (argc = switch_separate_string(lbuf, '|', argv, (sizeof(argv) / sizeof(argv[0])))) > 0) {
int argc = 0; if (!strcasecmp(argv[0], "out")) {
type = SWITCH_EVENT_PRESENCE_OUT;
if ((lbuf = strdup(fmt)) && (argc = switch_separate_string(lbuf, '|', argv, (sizeof(argv) / sizeof(argv[0])))) == 4) { } else if (argc != 4) {
switch_chat_interface_t *ci; stream->write_function(stream, "Invalid");
return SWITCH_STATUS_SUCCESS;
if ((ci = switch_loadable_module_get_chat_interface(argv[0]))) { }
ci->chat_send("dp", argv[1], argv[2], "", argv[3], "");
stream->write_function(stream, "Sent"); if (switch_event_create(&event, type) == SWITCH_STATUS_SUCCESS) {
} else { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "proto", "dp");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invaid Chat Interface [%s]!\n", argv[0]); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "login", "%s", __FILE__);
} switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s", argv[1]);
} else { if (type == SWITCH_EVENT_PRESENCE_IN) {
stream->write_function(stream, "Invalid"); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "rpid", "%s", argv[2]);
} switch_event_add_header(event, SWITCH_STACK_BOTTOM, "status", "%s", argv[3]);
}
return SWITCH_STATUS_SUCCESS; switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
} switch_event_fire(&event);
}
stream->write_function(stream, "Event Sent");
static switch_api_interface_t chat_api_interface = { switch_safe_free(lbuf);
/*.interface_name */ "chat", } else {
/*.desc */ "chat", stream->write_function(stream, "Invalid");
/*.function */ chat_api_function, }
/*.syntax */ "<proto>|<from>|<to>|<message>",
/*.next */ NULL return SWITCH_STATUS_SUCCESS;
}; }
static switch_api_interface_t dptools_api_interface = {
/*.interface_name */ "strftime", static switch_status_t chat_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
/*.desc */ "strftime", {
/*.function */ strftime_api_function, char *lbuf, *argv[4];
/*.syntax */ "<format_string>", int argc = 0;
/*.next */ &chat_api_interface
}; if ((lbuf = strdup(fmt)) && (argc = switch_separate_string(lbuf, '|', argv, (sizeof(argv) / sizeof(argv[0])))) == 4) {
switch_chat_interface_t *ci;
static switch_api_interface_t presence_api_interface = {
/*.interface_name */ "presence", if ((ci = switch_loadable_module_get_chat_interface(argv[0]))) {
/*.desc */ "presence", ci->chat_send("dp", argv[1], argv[2], "", argv[3], "");
/*.function */ presence_api_function, stream->write_function(stream, "Sent");
/*.syntax */ "<user> <rpid> <message>", } else {
/*.next */ &dptools_api_interface switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invaid Chat Interface [%s]!\n", argv[0]);
}; }
} else {
static const switch_application_interface_t detect_speech_application_interface = { stream->write_function(stream, "Invalid");
/*.interface_name */ "detect_speech", }
/*.application_function */ detect_speech_function,
/* long_desc */ "Detect speech on a channel.", return SWITCH_STATUS_SUCCESS;
/* short_desc */ "Detect speech", }
/* syntax */ "<mod_name> <gram_name> <gram_path> [<addr>] OR grammar <gram_name> [<path>] OR pause OR resume",
/*.next */ NULL
}; static switch_api_interface_t chat_api_interface = {
/*.interface_name */ "chat",
static const switch_application_interface_t ringback_application_interface = { /*.desc */ "chat",
/*.interface_name */ "ringback", /*.function */ chat_api_function,
/*.application_function */ ringback_function, /*.syntax */ "<proto>|<from>|<to>|<message>",
/* long_desc */ "Indicate Ringback on a channel.", /*.next */ NULL
/* short_desc */ "Indicate Ringback", };
/* syntax */ "",
/*.next */ &detect_speech_application_interface static switch_api_interface_t dptools_api_interface = {
}; /*.interface_name */ "strftime",
/*.desc */ "strftime",
static const switch_application_interface_t set_application_interface = { /*.function */ strftime_api_function,
/*.interface_name */ "set", /*.syntax */ "<format_string>",
/*.application_function */ set_function, /*.next */ &chat_api_interface
/* long_desc */ "Set a channel varaible for the channel calling the application.", };
/* short_desc */ "Set a channel varaible",
/* syntax */ "<varname>=[<value>|_UNDEF_]", static switch_api_interface_t presence_api_interface = {
/*.next */ &ringback_application_interface /*.interface_name */ "presence",
}; /*.desc */ "presence",
/*.function */ presence_api_function,
static const switch_application_interface_t log_application_interface = { /*.syntax */ "<user> <rpid> <message>",
/*.interface_name */ "log", /*.next */ &dptools_api_interface
/*.application_function */ log_function, };
/* long_desc */ "Logs a channel varaible for the channel calling the application.",
/* short_desc */ "Logs a channel varaible", static const switch_application_interface_t detect_speech_application_interface = {
/* syntax */ "<varname>", /*.interface_name */ "detect_speech",
/*.next */ &set_application_interface /*.application_function */ detect_speech_function,
}; /* long_desc */ "Detect speech on a channel.",
/* short_desc */ "Detect speech",
static const switch_application_interface_t answer_application_interface = { /* syntax */ "<mod_name> <gram_name> <gram_path> [<addr>] OR grammar <gram_name> [<path>] OR pause OR resume",
/*.interface_name */ "answer", /*.next */ NULL
/*.application_function */ answer_function, };
/* long_desc */ "Answer the call for a channel.",
/* short_desc */ "Answer the call", static const switch_application_interface_t ringback_application_interface = {
/* syntax */ "", /*.interface_name */ "ringback",
/*.next */ &log_application_interface /*.application_function */ ringback_function,
/* long_desc */ "Indicate Ringback on a channel.",
}; /* short_desc */ "Indicate Ringback",
/* syntax */ "",
static const switch_application_interface_t eval_application_interface = { /*.next */ &detect_speech_application_interface
/*.interface_name */ "eval", };
/*.application_function */ eval_function,
/* long_desc */ "Do Nothing", static const switch_application_interface_t set_application_interface = {
/* short_desc */ "Do Nothing", /*.interface_name */ "set",
/* syntax */ "", /*.application_function */ set_function,
/*.next */ &answer_application_interface /* long_desc */ "Set a channel varaible for the channel calling the application.",
/* short_desc */ "Set a channel varaible",
}; /* syntax */ "<varname>=[<value>|_UNDEF_]",
/*.next */ &ringback_application_interface
static const switch_application_interface_t strftime_application_interface = { };
/*.interface_name */ "strftime",
/*.application_function */ strftime_function, static const switch_application_interface_t info_application_interface = {
/* long_desc */ NULL, /*.interface_name */ "info",
/* short_desc */ NULL, /*.application_function */ info_function,
/* syntax */ NULL, /* long_desc */ "Display Call Info",
/*.next */ &eval_application_interface /* short_desc */ "Display Call Info",
/* syntax */ "",
}; /*.next */ &set_application_interface
};
static const switch_application_interface_t sleep_application_interface = {
/*.interface_name */ "sleep", static const switch_application_interface_t log_application_interface = {
/*.application_function */ sleep_function, /*.interface_name */ "log",
/* long_desc */ "Pause the channel for a given number of milliseconds, consuming the audio for that period of time.", /*.application_function */ log_function,
/* short_desc */ "Pause a channel", /* long_desc */ "Logs a channel varaible for the channel calling the application.",
/* syntax */ "<pausemilliseconds>", /* short_desc */ "Logs a channel varaible",
/* next */ &strftime_application_interface /* syntax */ "<varname>",
}; /*.next */ &info_application_interface
};
static const switch_application_interface_t transfer_application_interface = {
/*.interface_name */ "transfer", static const switch_application_interface_t answer_application_interface = {
/*.application_function */ transfer_function, /*.interface_name */ "answer",
/* long_desc */ "Immediatly transfer the calling channel to a new extension", /*.application_function */ answer_function,
/* short_desc */ "Transfer a channel", /* long_desc */ "Answer the call for a channel.",
/* syntax */ "<exten> [<dialplan> <context>]", /* short_desc */ "Answer the call",
/* next */ &sleep_application_interface /* syntax */ "",
}; /*.next */ &log_application_interface
static const switch_application_interface_t privacy_application_interface = { };
/*.interface_name */ "privacy",
/*.application_function */ privacy_function, static const switch_application_interface_t eval_application_interface = {
/* long_desc */ "Set caller privacy on calls.", /*.interface_name */ "eval",
/* short_desc */ "Set privacy on calls", /*.application_function */ eval_function,
/* syntax */ "off|on|name|full|number", /* long_desc */ "Do Nothing",
/*.next */ &transfer_application_interface /* short_desc */ "Do Nothing",
}; /* syntax */ "",
/*.next */ &answer_application_interface
static const switch_loadable_module_interface_t mod_dptools_module_interface = {
/*.module_name = */ modname, };
/*.endpoint_interface = */ NULL,
/*.timer_interface = */ NULL, static const switch_application_interface_t strftime_application_interface = {
/*.dialplan_interface = */ NULL, /*.interface_name */ "strftime",
/*.codec_interface = */ NULL, /*.application_function */ strftime_function,
/*.application_interface */ &privacy_application_interface, /* long_desc */ NULL,
/*.api_interface */ &presence_api_interface /* short_desc */ NULL,
}; /* syntax */ NULL,
/*.next */ &eval_application_interface
SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename)
{ };
/* connect my internal structure to the blank pointer passed to me */ static const switch_application_interface_t sleep_application_interface = {
*module_interface = &mod_dptools_module_interface; /*.interface_name */ "sleep",
/*.application_function */ sleep_function,
/* long_desc */ "Pause the channel for a given number of milliseconds, consuming the audio for that period of time.",
/* indicate that the module should continue to be loaded */ /* short_desc */ "Pause a channel",
return SWITCH_STATUS_SUCCESS; /* syntax */ "<pausemilliseconds>",
} /* next */ &strftime_application_interface
};
/* 'switch_module_runtime' will start up in a thread by itself just by having it exist
if it returns anything but SWITCH_STATUS_TERM it will be called again automaticly static const switch_application_interface_t transfer_application_interface = {
*/ /*.interface_name */ "transfer",
/*.application_function */ transfer_function,
/* long_desc */ "Immediatly transfer the calling channel to a new extension",
//switch_status_t switch_module_runtime(void) /* short_desc */ "Transfer a channel",
/* syntax */ "<exten> [<dialplan> <context>]",
/* next */ &sleep_application_interface
};
static const switch_application_interface_t privacy_application_interface = {
/*.interface_name */ "privacy",
/*.application_function */ privacy_function,
/* long_desc */ "Set caller privacy on calls.",
/* short_desc */ "Set privacy on calls",
/* syntax */ "off|on|name|full|number",
/*.next */ &transfer_application_interface
};
static const switch_loadable_module_interface_t mod_dptools_module_interface = {
/*.module_name = */ modname,
/*.endpoint_interface = */ NULL,
/*.timer_interface = */ NULL,
/*.dialplan_interface = */ NULL,
/*.codec_interface = */ NULL,
/*.application_interface */ &privacy_application_interface,
/*.api_interface */ &presence_api_interface
};
SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename)
{
/* connect my internal structure to the blank pointer passed to me */
*module_interface = &mod_dptools_module_interface;
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
/* 'switch_module_runtime' will start up in a thread by itself just by having it exist
if it returns anything but SWITCH_STATUS_TERM it will be called again automaticly
*/
//switch_status_t switch_module_runtime(void)
/* For Emacs: /* For Emacs:
* Local Variables: * Local Variables:

11
src/switch_channel.c
View File

@ -1198,11 +1198,14 @@ SWITCH_DECLARE(char *) switch_channel_expand_variables(switch_channel_t *channel
} }
if ((nlen = sub_val ? strlen(sub_val) : 0)) { if ((nlen = sub_val ? strlen(sub_val) : 0)) {
if (len + nlen >= olen) { if (len + nlen >= olen) {
olen = (olen + len + nlen + block); char *dp;
olen += (len + nlen + block);
cpos = c - data; cpos = c - data;
data = realloc(data, olen); if ((dp = realloc(data, olen))) {
c = data + cpos; data = dp;
memset(c, 0, olen - cpos); c = data + cpos;
memset(c, 0, olen - cpos);
}
} }
len += nlen; len += nlen;

5
src/switch_core.c
View File

@ -2673,7 +2673,8 @@ static void switch_core_standard_on_execute(switch_core_session_t *session)
} }
while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) { while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) {
char *expanded; char *expanded = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Execute %s(%s)\n", switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Execute %s(%s)\n",
extension->current_application->application_name, extension->current_application->application_name,
extension->current_application->application_data); extension->current_application->application_data);
@ -2720,7 +2721,7 @@ static void switch_core_standard_on_execute(switch_core_session_t *session)
application_interface->application_function(session, expanded); application_interface->application_function(session, expanded);
if (expanded != extension->current_application->application_data) { if (expanded != extension->current_application->application_data) {
free(expanded); switch_safe_free(expanded);
} }
extension->current_application = extension->current_application->next; extension->current_application = extension->current_application->next;
} }