switch_time_t initiated;
switch_time_t reference;
int64_t offset;
- switch_hash_t *global_vars;
+ switch_event_t *global_vars;
switch_hash_t *mime_types;
switch_memory_pool_t *memory_pool;
const switch_state_handler_table_t *state_handlers[SWITCH_MAX_STATE_HANDLERS];
*/
SWITCH_DECLARE(void) switch_core_set_variable(_In_z_ const char *varname, _In_opt_z_ const char *value);
+/*!
+ \brief Conditionally add a global variable to the core
+ \param varname the name of the variable
+ \param value the value of the variable
+ \param val2 the value of the variable to verify against
+ \ If the global did not exist and val2=="", add global with value, return true
+ \ If the global exists with the value of val2, replace it, return true
+ \ If the global exists with a value other than val2, return false
+*/
+SWITCH_DECLARE(switch_bool_t) switch_core_set_var_conditional(_In_z_ const char *varname, _In_opt_z_ const char *value, _In_opt_z_ const char *val2);
+
SWITCH_DECLARE(void) switch_core_dump_variables(_In_ switch_stream_handle_t *stream);
/*!
</pre>
*/
typedef enum {
- SWITCH_STACK_BOTTOM,
- SWITCH_STACK_TOP
+ SWITCH_STACK_BOTTOM = (1 << 0),
+ SWITCH_STACK_TOP = (1 << 1),
+ SWITCH_STACK_NODUP = (1 << 2)
} switch_stack_t;
/*!
return SWITCH_STATUS_SUCCESS;
}
-#define GLOBAL_SETVAR_SYNTAX "<var> <value>"
+#define GLOBAL_SETVAR_SYNTAX "<var> <value> [<value2>]"
SWITCH_STANDARD_API(global_setvar_function)
{
- char *mycmd = NULL, *argv[2] = { 0 };
+ char *mycmd = NULL, *argv[3] = { 0 };
int argc = 0;
if (!zstr(cmd) && (mycmd = strdup(cmd))) {
if (argc > 0 && !zstr(argv[0])) {
char *var_name = argv[0];
char *var_value = argv[1];
+ char *var_value2 = argv[2];
if (zstr(var_value)) {
var_value = NULL;
}
- switch_core_set_variable(var_name, var_value);
+
+ if (zstr(var_value2)) {
+ var_value2 = NULL;
+ }
+
+ if (var_value2) {
+ switch_core_set_var_conditional(var_name, var_value, var_value2);
+ } else {
+ switch_core_set_variable(var_name, var_value);
+ }
stream->write_function(stream, "+OK");
goto done;
}
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_t38_options_t_T38FaxVersion_set(void * jarg1, unsigned short jarg2) {
+ switch_t38_options_t *arg1 = (switch_t38_options_t *) 0 ;
+ uint16_t arg2 ;
+
+ arg1 = (switch_t38_options_t *)jarg1;
+ arg2 = (uint16_t)jarg2;
+ if (arg1) (arg1)->T38FaxVersion = arg2;
+
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_switch_t38_options_t_T38FaxVersion_get(void * jarg1) {
+ unsigned short jresult ;
+ switch_t38_options_t *arg1 = (switch_t38_options_t *) 0 ;
+ uint16_t result;
+
+ arg1 = (switch_t38_options_t *)jarg1;
+ result = (uint16_t) ((arg1)->T38FaxVersion);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_t38_options_t_T38MaxBitRate_set(void * jarg1, unsigned long jarg2) {
switch_t38_options_t *arg1 = (switch_t38_options_t *) 0 ;
uint32_t arg2 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_set_var_conditional(char * jarg1, char * jarg2, char * jarg3) {
+ int jresult ;
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ switch_bool_t result;
+
+ arg1 = (char *)jarg1;
+ arg2 = (char *)jarg2;
+ arg3 = (char *)jarg3;
+ result = (switch_bool_t)switch_core_set_var_conditional((char const *)arg1,(char const *)arg2,(char const *)arg3);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_dump_variables(void * jarg1) {
switch_stream_handle_t *arg1 = (switch_stream_handle_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_udptl_mode(void * jarg1) {
+ int jresult ;
+ switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_rtp_t *)jarg1;
+ result = (switch_status_t)switch_rtp_udptl_mode(arg1);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_set_local_address(void * jarg1, char * jarg2, unsigned short jarg3, void * jarg4) {
int jresult ;
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
freeswitchPINVOKE.switch_core_set_variable(varname, value);
}
+ public static switch_bool_t switch_core_set_var_conditional(string varname, string value, string val2) {
+ switch_bool_t ret = (switch_bool_t)freeswitchPINVOKE.switch_core_set_var_conditional(varname, value, val2);
+ return ret;
+ }
+
public static void switch_core_dump_variables(switch_stream_handle stream) {
freeswitchPINVOKE.switch_core_dump_variables(switch_stream_handle.getCPtr(stream));
}
freeswitchPINVOKE.switch_rtp_set_max_missed_packets(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), max);
}
+ public static switch_status_t switch_rtp_udptl_mode(SWIGTYPE_p_switch_rtp rtp_session) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_udptl_mode(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session));
+ return ret;
+ }
+
public static switch_status_t switch_rtp_set_local_address(SWIGTYPE_p_switch_rtp rtp_session, string host, ushort port, ref string err) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_set_local_address(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), host, port, ref err);
return ret;
[DllImport("mod_managed", EntryPoint="CSharp_delete_switch_rtcp_hdr_t")]
public static extern void delete_switch_rtcp_hdr_t(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_t38_options_t_T38FaxVersion_set")]
+ public static extern void switch_t38_options_t_T38FaxVersion_set(HandleRef jarg1, ushort jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_t38_options_t_T38FaxVersion_get")]
+ public static extern ushort switch_t38_options_t_T38FaxVersion_get(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_t38_options_t_T38MaxBitRate_set")]
public static extern void switch_t38_options_t_T38MaxBitRate_set(HandleRef jarg1, uint jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_set_variable")]
public static extern void switch_core_set_variable(string jarg1, string jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_set_var_conditional")]
+ public static extern int switch_core_set_var_conditional(string jarg1, string jarg2, string jarg3);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_dump_variables")]
public static extern void switch_core_dump_variables(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_max_missed_packets")]
public static extern void switch_rtp_set_max_missed_packets(HandleRef jarg1, uint jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_udptl_mode")]
+ public static extern int switch_rtp_udptl_mode(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_local_address")]
public static extern int switch_rtp_set_local_address(HandleRef jarg1, string jarg2, ushort jarg3, ref string jarg4);
namespace FreeSWITCH.Native {
public enum switch_channel_app_flag_t {
- CF_APP_TAGGED = (1 << 0)
+ CF_APP_TAGGED = (1 << 0),
+ CF_APP_T38 = (1 << 1)
}
}
SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC,
SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE,
SWITCH_MESSAGE_INDICATE_PHONE_EVENT,
+ SWITCH_MESSAGE_INDICATE_T38_DESCRIPTION,
+ SWITCH_MESSAGE_INDICATE_UDPTL_MODE,
SWITCH_MESSAGE_INVALID
}
namespace FreeSWITCH.Native {
[System.Flags] public enum switch_eavesdrop_flag_enum_t {
+ ED_NONE = 0,
ED_MUX_READ = (1 << 0),
ED_MUX_WRITE = (1 << 1),
ED_DTMF = (1 << 2)
SFF_RFC2833 = (1 << 4),
SFF_PROXY_PACKET = (1 << 5),
SFF_DYNAMIC = (1 << 6),
- SFF_ZRTP = (1 << 7)
+ SFF_ZRTP = (1 << 7),
+ SFF_UDPTL_PACKET = (1 << 8)
}
}
SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 8),
SWITCH_RTP_FLAG_VAD = (1 << 9),
SWITCH_RTP_FLAG_BREAK = (1 << 10),
- SWITCH_RTP_FLAG_MINI = (1 << 11),
+ SWITCH_RTP_FLAG_UDPTL = (1 << 11),
SWITCH_RTP_FLAG_DATAWAIT = (1 << 12),
SWITCH_RTP_FLAG_BUGGY_2833 = (1 << 13),
SWITCH_RTP_FLAG_PASS_RFC2833 = (1 << 14),
}
}
+ public ushort T38FaxVersion {
+ set {
+ freeswitchPINVOKE.switch_t38_options_t_T38FaxVersion_set(swigCPtr, value);
+ }
+ get {
+ ushort ret = freeswitchPINVOKE.switch_t38_options_t_T38FaxVersion_get(swigCPtr);
+ return ret;
+ }
+ }
+
public uint T38MaxBitRate {
set {
freeswitchPINVOKE.switch_t38_options_t_T38MaxBitRate_set(swigCPtr, value);
static JSBool js_global_set(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{
- char *var_name = NULL, *val = NULL;
+ char *var_name = NULL, *val = NULL, *val2 = NULL;
+ JSBool tf = JS_TRUE;
if (argc > 1) {
var_name = JS_GetStringBytes(JS_ValueToString(cx, argv[0]));
val = JS_GetStringBytes(JS_ValueToString(cx, argv[1]));
- switch_core_set_variable(var_name, val);
- return JS_TRUE;
+ if (argc == 2) {
+ switch_core_set_variable(var_name, val);
+ *rval = BOOLEAN_TO_JSVAL(JS_TRUE);
+ return JS_TRUE;
+ } else {
+ val2 = JS_GetStringBytes(JS_ValueToString(cx, argv[2]));
+ if (switch_core_set_var_conditional(var_name, val, val2) != SWITCH_TRUE) {
+ tf = JS_FALSE;
+ }
+ *rval = BOOLEAN_TO_JSVAL(tf);
+ return JS_TRUE;
+ }
}
/* this is so the wrong error message to throw for this one */
eval_some_js("~throw new Error(\"var name not supplied!\");", cx, obj, rval);
SWITCH_DECLARE(void) switch_core_dump_variables(switch_stream_handle_t *stream)
{
- switch_hash_index_t *hi;
- const void *var;
- void *val;
+ switch_event_header_t *hi;
+
switch_mutex_lock(runtime.global_mutex);
- for (hi = switch_hash_first(NULL, runtime.global_vars); hi; hi = switch_hash_next(hi)) {
- char *vvar, *vval;
- switch_hash_this(hi, &var, NULL, &val);
- vvar = (char *) var;
- vval = (char *) val;
- stream->write_function(stream, "%s=%s\n", vvar, vval);
+ for (hi = runtime.global_vars->headers; hi; hi = hi->next) {
+ stream->write_function(stream, "%s=%s\n", hi->name, hi->value);
}
switch_mutex_unlock(runtime.global_mutex);
}
{
char *val;
switch_mutex_lock(runtime.global_var_mutex);
- val = (char *) switch_core_hash_find(runtime.global_vars, varname);
+ val = (char *) switch_event_get_header(runtime.global_vars, varname);
switch_mutex_unlock(runtime.global_var_mutex);
return val;
}
static void switch_core_unset_variables(void)
{
- switch_hash_index_t *hi;
- const void *var;
- void *val;
-
switch_mutex_lock(runtime.global_var_mutex);
- for (hi = switch_hash_first(NULL, runtime.global_vars); hi; hi = switch_hash_next(hi)) {
- switch_hash_this(hi, &var, NULL, &val);
- free(val);
- }
+ switch_event_destroy(&runtime.global_vars);
+ switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
switch_mutex_unlock(runtime.global_var_mutex);
}
if (varname) {
switch_mutex_lock(runtime.global_var_mutex);
- val = (char *) switch_core_hash_find(runtime.global_vars, varname);
+ val = (char *) switch_event_get_header(runtime.global_vars, varname);
+ if (val) {
+ switch_event_del_header(runtime.global_vars, varname);
+ }
+ if (value) {
+ char *v = strdup(value);
+ switch_string_var_check(v, SWITCH_TRUE);
+ switch_event_add_header_string(runtime.global_vars, SWITCH_STACK_BOTTOM | SWITCH_STACK_NODUP, varname, v);
+ } else {
+ switch_event_del_header(runtime.global_vars, varname);
+ }
+ switch_mutex_unlock(runtime.global_var_mutex);
+ }
+}
+
+SWITCH_DECLARE(switch_bool_t) switch_core_set_var_conditional(const char *varname, const char *value, const char *val2)
+{
+ char *val;
+
+ if (varname) {
+ switch_mutex_lock(runtime.global_var_mutex);
+ val = (char *) switch_event_get_header(runtime.global_vars, varname);
+
if (val) {
- free(val);
+ if (!val2 || strcmp(val, val2) != 0) {
+ switch_mutex_unlock(runtime.global_var_mutex);
+ return SWITCH_FALSE;
+ }
+ switch_event_del_header(runtime.global_vars, varname);
+ } else if (!zstr(val2)) {
+ switch_mutex_unlock(runtime.global_var_mutex);
+ return SWITCH_FALSE;
}
+
if (value) {
char *v = strdup(value);
switch_string_var_check(v, SWITCH_TRUE);
- switch_core_hash_insert(runtime.global_vars, varname, v);
+ switch_event_add_header_string(runtime.global_vars, SWITCH_STACK_BOTTOM | SWITCH_STACK_NODUP, varname, v);
} else {
- switch_core_hash_delete(runtime.global_vars, varname);
+ switch_event_del_header(runtime.global_vars, varname);
}
switch_mutex_unlock(runtime.global_var_mutex);
}
+ return SWITCH_TRUE;
}
SWITCH_DECLARE(char *) switch_core_get_uuid(void)
switch_mutex_init(&runtime.global_var_mutex, SWITCH_MUTEX_NESTED, runtime.memory_pool);
switch_core_set_globals();
switch_core_session_init(runtime.memory_pool);
- switch_core_hash_init(&runtime.global_vars, runtime.memory_pool);
+ switch_event_create_plain(&runtime.global_vars, SWITCH_EVENT_CHANNEL_DATA);
switch_core_hash_init(&runtime.mime_types, runtime.memory_pool);
load_mime_types();
runtime.flags = flags;
switch_safe_free(SWITCH_GLOBAL_dirs.run_dir);
switch_safe_free(SWITCH_GLOBAL_dirs.temp_dir);
- switch_core_hash_destroy(&runtime.global_vars);
+ switch_event_destroy(&runtime.global_vars);
switch_core_hash_destroy(&runtime.mime_types);
if (IP_LIST.hash) {
switch_mutex_lock(sql_manager.dbh_mutex);
top:
locked = 0;
-
+ printf("WTF1\n");
for (hi = switch_hash_first(NULL, sql_manager.dbh_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, &var, NULL, &val);
key = (char *) var;
-
+ printf("WTF2\n");
if ((dbh = (switch_cache_db_handle_t *) val)) {
time_t diff = 0;
-
+ printf("WTF3\n");
if (prune > 0 && prune > dbh->last_used) {
diff = (time_t) prune - dbh->last_used;
}
if (prune > 0 && diff < SQL_CACHE_TIMEOUT) {
continue;
}
-
+ printf("WTF4\n");
if (switch_mutex_trylock(dbh->mutex) == SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Dropping idle DB connection %s\n", key);
-
+ printf("WTF5\n");
switch (dbh->type) {
case SCDB_TYPE_ODBC:
{
/* ---- methods not bound to CoreSession instance ---- */
+
+SWITCH_DECLARE(int) globalSetVariable(const char *var, const char *val, const char *val2)
+{
+ if (zstr(val)) val = NULL;
+ if (zstr(val2)) val2 = NULL;
+
+ if (val2) {
+ switch_core_set_var_conditional(var, val, val2);
+ } else {
+ switch_core_set_variable(var, val);
+ }
+}
+
SWITCH_DECLARE(void) consoleLog(char *level_str, char *msg)
{
return console_log(level_str, msg);
header->value = data;
header->hash = switch_ci_hashfunc_default(header->name, &hlen);
- if (stack == SWITCH_STACK_TOP) {
+ if ((stack & SWITCH_STACK_TOP)) {
header->next = event->headers;
event->headers = header;
if (!event->last_header) {
SWITCH_DECLARE(switch_status_t) switch_event_add_header_string(switch_event_t *event, switch_stack_t stack, const char *header_name, const char *data)
{
if (data) {
- return switch_event_base_add_header(event, stack, header_name, DUP(data));
+ return switch_event_base_add_header(event, stack, header_name, (stack & SWITCH_STACK_NODUP) ? (char *)data : DUP(data));
}
return SWITCH_STATUS_GENERR;
}
projects / thirdparty / freeswitch.git / commitdiff
