}
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_SENSITIVE_DTMF_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "sensitive_dtmf";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "record_post_process_exec_app";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "record_post_process_exec_api";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get() {
char * jresult ;
char *result = 0 ;
}
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "execute_on_pre_bridge";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "execute_on_post_bridge";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get() {
char * jresult ;
char *result = 0 ;
}
+SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_BRIDGE_START_VARIABLE_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "api_before_bridge";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_HANGUP_HOOK_VARIABLE_get() {
char * jresult ;
char *result = 0 ;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_directories_certs_dir_set(void * jarg1, char * jarg2) {
+ switch_directories *arg1 = (switch_directories *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (switch_directories *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->certs_dir) delete [] arg1->certs_dir;
+ if (arg2) {
+ arg1->certs_dir = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->certs_dir, (const char *)arg2);
+ } else {
+ arg1->certs_dir = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_directories_certs_dir_get(void * jarg1) {
+ char * jresult ;
+ switch_directories *arg1 = (switch_directories *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (switch_directories *)jarg1;
+ result = (char *) ((arg1)->certs_dir);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_directories() {
void * jresult ;
switch_directories *result = 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_MEDIA_TYPE_TOTAL_get() {
+ int jresult ;
+ int result;
+
+ result = (int) 2;
+
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_console_callback_match_node_val_set(void * jarg1, char * jarg2) {
switch_console_callback_match_node *arg1 = (switch_console_callback_match_node *) 0 ;
char *arg2 = (char *) 0 ;
}
+SWIGEXPORT char * SWIGSTDCALL CSharp_DTLS_SRTP_FNAME_get() {
+ char * jresult ;
+ char *result = 0 ;
+
+ result = (char *) "dtls-srtp";
+
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_FPLEN_get() {
+ int jresult ;
+ int result;
+
+ result = (int) 64;
+
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_FPSTRLEN_get() {
+ int jresult ;
+ int result;
+
+ result = (int) 192;
+
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_len_set(void * jarg1, unsigned long jarg2) {
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ uint32_t arg2 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ arg2 = (uint32_t)jarg2;
+ if (arg1) (arg1)->len = arg2;
+
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_dtls_fingerprint_t_len_get(void * jarg1) {
+ unsigned long jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ uint32_t result;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ result = (uint32_t) ((arg1)->len);
+ jresult = (unsigned long)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_data_set(void * jarg1, void * jarg2) {
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ uint8_t *arg2 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ arg2 = (uint8_t *)jarg2;
+ {
+ size_t ii;
+ uint8_t *b = (uint8_t *) arg1->data;
+ for (ii = 0; ii < (size_t)64+1; ii++) b[ii] = *((uint8_t *) arg2 + ii);
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_dtls_fingerprint_t_data_get(void * jarg1) {
+ void * jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ uint8_t *result = 0 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ result = (uint8_t *)(uint8_t *) ((arg1)->data);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_type_set(void * jarg1, char * jarg2) {
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->type) delete [] arg1->type;
+ if (arg2) {
+ arg1->type = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->type, (const char *)arg2);
+ } else {
+ arg1->type = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_dtls_fingerprint_t_type_get(void * jarg1) {
+ char * jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ result = (char *) ((arg1)->type);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_dtls_fingerprint_t_str_set(void * jarg1, char * jarg2) {
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ char *arg2 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg2) strncpy((char *)arg1->str, (const char *)arg2, 192);
+ else arg1->str[0] = 0;
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_dtls_fingerprint_t_str_get(void * jarg1) {
+ char * jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ result = (char *)(char *) ((arg1)->str);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_dtls_fingerprint_t() {
+ void * jresult ;
+ dtls_fingerprint_t *result = 0 ;
+
+ result = (dtls_fingerprint_t *)new dtls_fingerprint_t();
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_dtls_fingerprint_t(void * jarg1) {
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ delete arg1;
+
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_MESSAGE_STRING_ARG_MAX_get() {
int jresult ;
int result;
}
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_native_read_frame(void * jarg1) {
+ void * jresult ;
+ switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
+ switch_frame_t *result = 0 ;
+
+ arg1 = (switch_media_bug_t *)jarg1;
+ result = (switch_frame_t *)switch_core_media_bug_get_native_read_frame(arg1);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_native_write_frame(void * jarg1) {
+ void * jresult ;
+ switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
+ switch_frame_t *result = 0 ;
+
+ arg1 = (switch_media_bug_t *)jarg1;
+ result = (switch_frame_t *)switch_core_media_bug_get_native_write_frame(arg1);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_media_bug_set_write_replace_frame(void * jarg1, void * jarg2) {
switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
switch_frame_t *arg2 = (switch_frame_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_transfer_callback(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
+ int jresult ;
+ switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+ switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
+ switch_media_bug_callback_t arg3 = (switch_media_bug_callback_t) 0 ;
+ void *(*arg4)(switch_core_session_t *,void *) = (void *(*)(switch_core_session_t *,void *)) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_core_session_t *)jarg1;
+ arg2 = (switch_core_session_t *)jarg2;
+ arg3 = (switch_media_bug_callback_t)jarg3;
+ arg4 = (void *(*)(switch_core_session_t *,void *))jarg4;
+ result = (switch_status_t)switch_core_media_bug_transfer_callback(arg1,arg2,arg3,arg4);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_read(void * jarg1, void * jarg2, int jarg3) {
int jresult ;
switch_media_bug_t *arg1 = (switch_media_bug_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_get_variables(void * jarg1) {
+ int jresult ;
+ switch_event_t **arg1 = (switch_event_t **) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_event_t **)jarg1;
+ result = (switch_status_t)switch_core_get_variables(arg1);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_set_var_conditional(char * jarg1, char * jarg2, char * jarg3) {
int jresult ;
char *arg1 = (char *) 0 ;
}
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_findall() {
+ void * jresult ;
+ switch_console_callback_match_t *result = 0 ;
+
+ result = (switch_console_callback_match_t *)switch_core_session_findall();
+ jresult = (void *)result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_session_hupall_endpoint(void * jarg1, int jarg2) {
switch_endpoint_interface_t *arg1 = (switch_endpoint_interface_t *) 0 ;
switch_call_cause_t arg2 ;
}
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_default_rate(char * jarg1, unsigned long jarg2) {
+ unsigned long jresult ;
+ char *arg1 = (char *) 0 ;
+ uint32_t arg2 ;
+ uint32_t result;
+
+ arg1 = (char *)jarg1;
+ arg2 = (uint32_t)jarg2;
+ result = (uint32_t)switch_default_rate((char const *)arg1,arg2);
+ jresult = (unsigned long)result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_add_registration(char * jarg1, char * jarg2, char * jarg3, char * jarg4, unsigned long jarg5, char * jarg6, char * jarg7, char * jarg8, char * jarg9) {
int jresult ;
char *arg1 = (char *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_gen_certs(char * jarg1) {
+ int jresult ;
+ char *arg1 = (char *) 0 ;
+ int result;
+
+ arg1 = (char *)jarg1;
+ result = (int)switch_core_gen_certs((char const *)arg1);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_gen_fingerprint(char * jarg1, void * jarg2) {
+ int jresult ;
+ char *arg1 = (char *) 0 ;
+ dtls_fingerprint_t *arg2 = (dtls_fingerprint_t *) 0 ;
+ int result;
+
+ arg1 = (char *)jarg1;
+ arg2 = (dtls_fingerprint_t *)jarg2;
+ result = (int)switch_core_cert_gen_fingerprint((char const *)arg1,arg2);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_expand_fingerprint(void * jarg1, char * jarg2) {
+ int jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+ int result;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ arg2 = (char *)jarg2;
+ result = (int)switch_core_cert_expand_fingerprint(arg1,(char const *)arg2);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_cert_verify(void * jarg1) {
+ int jresult ;
+ dtls_fingerprint_t *arg1 = (dtls_fingerprint_t *) 0 ;
+ int result;
+
+ arg1 = (dtls_fingerprint_t *)jarg1;
+ result = (int)switch_core_cert_verify(arg1);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_loadable_module_interface_module_name_set(void * jarg1, char * jarg2) {
switch_loadable_module_interface *arg1 = (switch_loadable_module_interface *) 0 ;
char *arg2 = (char *) 0 ;
}
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_print_host(void * jarg1, char * jarg2, void * jarg3) {
+ char * jresult ;
+ switch_sockaddr_t *arg1 = (switch_sockaddr_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+ switch_size_t arg3 ;
+ char *result = 0 ;
+ switch_size_t *argp3 ;
+
+ arg1 = (switch_sockaddr_t *)jarg1;
+ arg2 = (char *)jarg2;
+ argp3 = (switch_size_t *)jarg3;
+ if (!argp3) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0);
+ return 0;
+ }
+ arg3 = *argp3;
+ result = (char *)switch_print_host(arg1,arg2,arg3);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_SMAX_get() {
int jresult ;
int result;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_strcasecmp_any(char * jarg1) {
+ int jresult ;
+ char *arg1 = (char *) 0 ;
+ void *arg2 = 0 ;
+ int result;
+
+ arg1 = (char *)jarg1;
+ result = (int)switch_strcasecmp_any((char const *)arg1,arg2);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg(char * jarg1) {
char * jresult ;
char *arg1 = (char *) 0 ;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_name_set(void * jarg1, char * jarg2) {
+ switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (switch_caller_profile *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg2) {
+ arg1->orig_caller_id_name = (char const *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->orig_caller_id_name, (const char *)arg2);
+ } else {
+ arg1->orig_caller_id_name = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_name_get(void * jarg1) {
+ char * jresult ;
+ switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (switch_caller_profile *)jarg1;
+ result = (char *) ((arg1)->orig_caller_id_name);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_number_set(void * jarg1, char * jarg2) {
+ switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (switch_caller_profile *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg2) {
+ arg1->orig_caller_id_number = (char const *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->orig_caller_id_number, (const char *)arg2);
+ } else {
+ arg1->orig_caller_id_number = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_orig_caller_id_number_get(void * jarg1) {
+ char * jresult ;
+ switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (switch_caller_profile *)jarg1;
+ result = (char *) ((arg1)->orig_caller_id_number);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_caller_profile_callee_id_name_set(void * jarg1, char * jarg2) {
switch_caller_profile *arg1 = (switch_caller_profile *) 0 ;
char *arg2 = (char *) 0 ;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_max_samples_set(void * jarg1, int jarg2) {
+ switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+ int arg2 ;
+
+ arg1 = (switch_file_handle *)jarg1;
+ arg2 = (int)jarg2;
+ if (arg1) (arg1)->max_samples = arg2;
+
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_file_handle_max_samples_get(void * jarg1) {
+ int jresult ;
+ switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+ int result;
+
+ arg1 = (switch_file_handle *)jarg1;
+ result = (int) ((arg1)->max_samples);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_file_handle_params_set(void * jarg1, void * jarg2) {
+ switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+ switch_event_t *arg2 = (switch_event_t *) 0 ;
+
+ arg1 = (switch_file_handle *)jarg1;
+ arg2 = (switch_event_t *)jarg2;
+ if (arg1) (arg1)->params = arg2;
+
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_file_handle_params_get(void * jarg1) {
+ void * jresult ;
+ switch_file_handle *arg1 = (switch_file_handle *) 0 ;
+ switch_event_t *result = 0 ;
+
+ arg1 = (switch_file_handle *)jarg1;
+ result = (switch_event_t *) ((arg1)->params);
+ jresult = (void *)result;
+ return jresult;
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_file_handle() {
void * jresult ;
switch_file_handle *result = 0 ;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_step_caller_profile(void * jarg1) {
+ switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+
+ arg1 = (switch_channel_t *)jarg1;
+ switch_channel_step_caller_profile(arg1);
+}
+
+
SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_caller_profile(void * jarg1) {
void * jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_transfer_variable_prefix(void * jarg1, void * jarg2, char * jarg3) {
+ int jresult ;
+ switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+ switch_channel_t *arg2 = (switch_channel_t *) 0 ;
+ char *arg3 = (char *) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_channel_t *)jarg1;
+ arg2 = (switch_channel_t *)jarg2;
+ arg3 = (char *)jarg3;
+ result = (switch_status_t)switch_channel_transfer_variable_prefix(arg1,arg2,(char const *)arg3);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_export_variable_var_check(void * jarg1, char * jarg2, char * jarg3, char * jarg4, int jarg5) {
int jresult ;
switch_channel_t *arg1 = (switch_channel_t *) 0 ;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_invert_cid(void * jarg1) {
+ switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+
+ arg1 = (switch_channel_t *)jarg1;
+ switch_channel_invert_cid(arg1);
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_flip_cid(void * jarg1) {
switch_channel_t *arg1 = (switch_channel_t *) 0 ;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_sort_cid(void * jarg1, int jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_sort_cid(void * jarg1) {
switch_channel_t *arg1 = (switch_channel_t *) 0 ;
- switch_bool_t arg2 ;
arg1 = (switch_channel_t *)jarg1;
- arg2 = (switch_bool_t)jarg2;
- switch_channel_sort_cid(arg1,arg2);
+ switch_channel_sort_cid(arg1);
}
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_state_thread_trylock(void * jarg1) {
+ int jresult ;
+ switch_channel_t *arg1 = (switch_channel_t *) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_channel_t *)jarg1;
+ result = (switch_status_t)switch_channel_state_thread_trylock(arg1);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_buffer_create(void * jarg1, void * jarg2, void * jarg3) {
int jresult ;
switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_transfer_recordings(void * jarg1, void * jarg2) {
+ int jresult ;
+ switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+ switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
+ switch_status_t result;
+
+ arg1 = (switch_core_session_t *)jarg1;
+ arg2 = (switch_core_session_t *)jarg2;
+ result = (switch_status_t)switch_ivr_transfer_recordings(arg1,arg2);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_eavesdrop_pop_eavesdropper(void * jarg1, void * jarg2) {
int jresult ;
switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_hold_toggle_uuid(char * jarg1, char * jarg2, int jarg3) {
+ int jresult ;
+ char *arg1 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
+ switch_bool_t arg3 ;
+ switch_status_t result;
+
+ arg1 = (char *)jarg1;
+ arg2 = (char *)jarg2;
+ arg3 = (switch_bool_t)jarg3;
+ result = (switch_status_t)switch_ivr_hold_toggle_uuid((char const *)arg1,(char const *)arg2,arg3);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_unhold_uuid(char * jarg1) {
int jresult ;
char *arg1 = (char *) 0 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_record_session_mask(void * jarg1, char * jarg2, int jarg3) {
+ int jresult ;
+ switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+ switch_bool_t arg3 ;
+ switch_status_t result;
+
+ arg1 = (switch_core_session_t *)jarg1;
+ arg2 = (char *)jarg2;
+ arg3 = (switch_bool_t)jarg3;
+ result = (switch_status_t)switch_ivr_record_session_mask(arg1,(char const *)arg2,arg3);
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_RTP_MAX_BUF_LEN_get() {
int jresult ;
int result;
}
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_foundation_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->foundation) delete [] arg1->foundation;
+ if (arg2) {
+ arg1->foundation = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->foundation, (const char *)arg2);
+ } else {
+ arg1->foundation = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_foundation_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->foundation);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_component_id_set(void * jarg1, int jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ int arg2 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (int)jarg2;
+ if (arg1) (arg1)->component_id = arg2;
+
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_icand_t_component_id_get(void * jarg1) {
+ int jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ int result;
+
+ arg1 = (icand_t *)jarg1;
+ result = (int) ((arg1)->component_id);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_transport_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->transport) delete [] arg1->transport;
+ if (arg2) {
+ arg1->transport = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->transport, (const char *)arg2);
+ } else {
+ arg1->transport = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_transport_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->transport);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_priority_set(void * jarg1, unsigned long jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ uint32_t arg2 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (uint32_t)jarg2;
+ if (arg1) (arg1)->priority = arg2;
+
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_icand_t_priority_get(void * jarg1) {
+ unsigned long jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ uint32_t result;
+
+ arg1 = (icand_t *)jarg1;
+ result = (uint32_t) ((arg1)->priority);
+ jresult = (unsigned long)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_con_addr_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->con_addr) delete [] arg1->con_addr;
+ if (arg2) {
+ arg1->con_addr = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->con_addr, (const char *)arg2);
+ } else {
+ arg1->con_addr = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_con_addr_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->con_addr);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_con_port_set(void * jarg1, unsigned short jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ switch_port_t arg2 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (switch_port_t)jarg2;
+ if (arg1) (arg1)->con_port = arg2;
+
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_icand_t_con_port_get(void * jarg1) {
+ unsigned short jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ switch_port_t result;
+
+ arg1 = (icand_t *)jarg1;
+ result = (switch_port_t) ((arg1)->con_port);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_cand_type_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->cand_type) delete [] arg1->cand_type;
+ if (arg2) {
+ arg1->cand_type = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->cand_type, (const char *)arg2);
+ } else {
+ arg1->cand_type = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_cand_type_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->cand_type);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_raddr_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->raddr) delete [] arg1->raddr;
+ if (arg2) {
+ arg1->raddr = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->raddr, (const char *)arg2);
+ } else {
+ arg1->raddr = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_raddr_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->raddr);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_rport_set(void * jarg1, unsigned short jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ switch_port_t arg2 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (switch_port_t)jarg2;
+ if (arg1) (arg1)->rport = arg2;
+
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_icand_t_rport_get(void * jarg1) {
+ unsigned short jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ switch_port_t result;
+
+ arg1 = (icand_t *)jarg1;
+ result = (switch_port_t) ((arg1)->rport);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_generation_set(void * jarg1, char * jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->generation) delete [] arg1->generation;
+ if (arg2) {
+ arg1->generation = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->generation, (const char *)arg2);
+ } else {
+ arg1->generation = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_icand_t_generation_get(void * jarg1) {
+ char * jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ result = (char *) ((arg1)->generation);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_icand_t_ready_set(void * jarg1, unsigned char jarg2) {
+ icand_t *arg1 = (icand_t *) 0 ;
+ uint8_t arg2 ;
+
+ arg1 = (icand_t *)jarg1;
+ arg2 = (uint8_t)jarg2;
+ if (arg1) (arg1)->ready = arg2;
+
+}
+
+
+SWIGEXPORT unsigned char SWIGSTDCALL CSharp_icand_t_ready_get(void * jarg1) {
+ unsigned char jresult ;
+ icand_t *arg1 = (icand_t *) 0 ;
+ uint8_t result;
+
+ arg1 = (icand_t *)jarg1;
+ result = (uint8_t) ((arg1)->ready);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_icand_t() {
+ void * jresult ;
+ icand_t *result = 0 ;
+
+ result = (icand_t *)new icand_t();
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_icand_t(void * jarg1) {
+ icand_t *arg1 = (icand_t *) 0 ;
+
+ arg1 = (icand_t *)jarg1;
+ delete arg1;
+
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_MAX_CAND_get() {
+ int jresult ;
+ int result;
+
+ result = (int) 25;
+
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_cands_set(void * jarg1, void * jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ icand_t (*arg2)[2] ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (icand_t (*)[2])jarg2;
+ {
+ icand_t (*inp)[2] = (icand_t (*)[2])(arg2);
+ icand_t (*dest)[2] = (icand_t (*)[2])(arg1->cands);
+ size_t ii = 0;
+ for (; ii < 25; ++ii) {
+ icand_t *ip = inp[ii];
+ icand_t *dp = dest[ii];
+ size_t jj = 0;
+ for (; jj < 2; ++jj) dp[jj] = ip[jj];
+ }
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ice_t_cands_get(void * jarg1) {
+ void * jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ icand_t (*result)[2] = 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ result = (icand_t (*)[2])(icand_t (*)[2]) ((arg1)->cands);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_cand_idx_set(void * jarg1, int jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ int arg2 ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (int)jarg2;
+ if (arg1) (arg1)->cand_idx = arg2;
+
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_ice_t_cand_idx_get(void * jarg1) {
+ int jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ int result;
+
+ arg1 = (ice_t *)jarg1;
+ result = (int) ((arg1)->cand_idx);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_chosen_set(void * jarg1, void * jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ int *arg2 ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (int *)jarg2;
+ {
+ size_t ii;
+ int *b = (int *) arg1->chosen;
+ for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((int *) arg2 + ii);
+ }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ice_t_chosen_get(void * jarg1) {
+ void * jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ int *result = 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ result = (int *)(int *) ((arg1)->chosen);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_ufrag_set(void * jarg1, char * jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->ufrag) delete [] arg1->ufrag;
+ if (arg2) {
+ arg1->ufrag = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->ufrag, (const char *)arg2);
+ } else {
+ arg1->ufrag = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_ufrag_get(void * jarg1) {
+ char * jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ result = (char *) ((arg1)->ufrag);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_pwd_set(void * jarg1, char * jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->pwd) delete [] arg1->pwd;
+ if (arg2) {
+ arg1->pwd = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->pwd, (const char *)arg2);
+ } else {
+ arg1->pwd = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_pwd_get(void * jarg1) {
+ char * jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ result = (char *) ((arg1)->pwd);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_ice_t_options_set(void * jarg1, char * jarg2) {
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *arg2 = (char *) 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ arg2 = (char *)jarg2;
+ {
+ if (arg1->options) delete [] arg1->options;
+ if (arg2) {
+ arg1->options = (char *) (new char[strlen((const char *)arg2)+1]);
+ strcpy((char *)arg1->options, (const char *)arg2);
+ } else {
+ arg1->options = 0;
+ }
+ }
+}
+
+
+SWIGEXPORT char * SWIGSTDCALL CSharp_ice_t_options_get(void * jarg1) {
+ char * jresult ;
+ ice_t *arg1 = (ice_t *) 0 ;
+ char *result = 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ result = (char *) ((arg1)->options);
+ jresult = SWIG_csharp_string_callback((const char *)result);
+ return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_ice_t() {
+ void * jresult ;
+ ice_t *result = 0 ;
+
+ result = (ice_t *)new ice_t();
+ jresult = (void *)result;
+ return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_delete_ice_t(void * jarg1) {
+ ice_t *arg1 = (ice_t *) 0 ;
+
+ arg1 = (ice_t *)jarg1;
+ delete arg1;
+
+}
+
+
SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_add_crypto_key(void * jarg1, int jarg2, unsigned long jarg3, int jarg4, void * jarg5, void * jarg6) {
int jresult ;
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char jarg2, unsigned long jarg3, unsigned long jarg4, unsigned long jarg5, char * jarg6, void * jarg7, void * jarg8) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char jarg2, unsigned long jarg3, unsigned long jarg4, void * jarg5, char * jarg6, void * jarg7, void * jarg8) {
int jresult ;
switch_rtp_t **arg1 = (switch_rtp_t **) 0 ;
switch_payload_t arg2 ;
uint32_t arg3 ;
uint32_t arg4 ;
- switch_rtp_flag_t arg5 ;
+ switch_rtp_flag_t *arg5 ;
char *arg6 = (char *) 0 ;
char **arg7 = (char **) 0 ;
switch_memory_pool_t *arg8 = (switch_memory_pool_t *) 0 ;
arg2 = (switch_payload_t)jarg2;
arg3 = (uint32_t)jarg3;
arg4 = (uint32_t)jarg4;
- arg5 = (switch_rtp_flag_t)jarg5;
+ arg5 = (switch_rtp_flag_t *)jarg5;
arg6 = (char *)jarg6;
arg7 = (char **)jarg7;
arg8 = (switch_memory_pool_t *)jarg8;
}
-SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short jarg2, char * jarg3, unsigned short jarg4, unsigned char jarg5, unsigned long jarg6, unsigned long jarg7, unsigned long jarg8, char * jarg9, void * jarg10, void * jarg11) {
+SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short jarg2, char * jarg3, unsigned short jarg4, unsigned char jarg5, unsigned long jarg6, unsigned long jarg7, void * jarg8, char * jarg9, void * jarg10, void * jarg11) {
void * jresult ;
char *arg1 = (char *) 0 ;
switch_port_t arg2 ;
switch_payload_t arg5 ;
uint32_t arg6 ;
uint32_t arg7 ;
- switch_rtp_flag_t arg8 ;
+ switch_rtp_flag_t *arg8 ;
char *arg9 = (char *) 0 ;
char **arg10 = (char **) 0 ;
switch_memory_pool_t *arg11 = (switch_memory_pool_t *) 0 ;
arg5 = (switch_payload_t)jarg5;
arg6 = (uint32_t)jarg6;
arg7 = (uint32_t)jarg7;
- arg8 = (switch_rtp_flag_t)jarg8;
+ arg8 = (switch_rtp_flag_t *)jarg8;
arg9 = (char *)jarg9;
arg10 = (char **)jarg10;
arg11 = (switch_memory_pool_t *)jarg11;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
- int jresult ;
- switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
- char *arg2 = (char *) 0 ;
- char *arg3 = (char *) 0 ;
- char *arg4 = (char *) 0 ;
- switch_status_t result;
-
- arg1 = (switch_rtp_t *)jarg1;
- arg2 = (char *)jarg2;
- arg3 = (char *)jarg3;
- arg4 = (char *)jarg4;
- result = (switch_status_t)switch_rtp_activate_ice(arg1,arg2,arg3,(char const *)arg4);
- jresult = result;
- return jresult;
-}
-
-
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_ice(void * jarg1, char * jarg2, char * jarg3, char * jarg4, char * jarg5, int jarg6, void * jarg7, void * jarg8) {
int jresult ;
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
char *arg4 = (char *) 0 ;
+ char *arg5 = (char *) 0 ;
+ ice_proto_t arg6 ;
+ switch_core_media_ice_type_t arg7 ;
+ ice_t *arg8 = (ice_t *) 0 ;
switch_status_t result;
+ switch_core_media_ice_type_t *argp7 ;
arg1 = (switch_rtp_t *)jarg1;
arg2 = (char *)jarg2;
arg3 = (char *)jarg3;
arg4 = (char *)jarg4;
- result = (switch_status_t)switch_rtp_activate_rtcp_ice(arg1,arg2,arg3,(char const *)arg4);
+ arg5 = (char *)jarg5;
+ arg6 = (ice_proto_t)jarg6;
+ argp7 = (switch_core_media_ice_type_t *)jarg7;
+ if (!argp7) {
+ SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_core_media_ice_type_t", 0);
+ return 0;
+ }
+ arg7 = *argp7;
+ arg8 = (ice_t *)jarg8;
+ result = (switch_status_t)switch_rtp_activate_ice(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6,arg7,arg8);
jresult = result;
return jresult;
}
-SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp(void * jarg1, int jarg2, unsigned short jarg3) {
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_rtcp(void * jarg1, int jarg2, unsigned short jarg3, int jarg4) {
int jresult ;
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
int arg2 ;
switch_port_t arg3 ;
+ switch_bool_t arg4 ;
switch_status_t result;
arg1 = (switch_rtp_t *)jarg1;
arg2 = (int)jarg2;
arg3 = (switch_port_t)jarg3;
- result = (switch_status_t)switch_rtp_activate_rtcp(arg1,arg2,arg3);
+ arg4 = (switch_bool_t)jarg4;
+ result = (switch_status_t)switch_rtp_activate_rtcp(arg1,arg2,arg3,arg4);
jresult = result;
return jresult;
}
}
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, int jarg2) {
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
switch_rtp_flag_t arg2 ;
}
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flags(void * jarg1, void * jarg2) {
+ switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+ switch_rtp_flag_t *arg2 ;
+
+ arg1 = (switch_rtp_t *)jarg1;
+ arg2 = (switch_rtp_flag_t *)jarg2;
+ switch_rtp_set_flags(arg1,arg2);
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flags(void * jarg1, void * jarg2) {
+ switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+ switch_rtp_flag_t *arg2 ;
+
+ arg1 = (switch_rtp_t *)jarg1;
+ arg2 = (switch_rtp_flag_t *)jarg2;
+ switch_rtp_clear_flags(arg1,arg2);
+}
+
+
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, int jarg2) {
unsigned long jresult ;
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
switch_rtp_flag_t arg2 ;
}
-SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flag(void * jarg1, unsigned long jarg2) {
+SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_clear_flag(void * jarg1, int jarg2) {
switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
switch_rtp_flag_t arg2 ;
}
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_add_dtls(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
+ int jresult ;
+ switch_rtp_t *arg1 = (switch_rtp_t *) 0 ;
+ dtls_fingerprint_t *arg2 = (dtls_fingerprint_t *) 0 ;
+ dtls_fingerprint_t *arg3 = (dtls_fingerprint_t *) 0 ;
+ dtls_type_t arg4 ;
+ switch_status_t result;
+
+ arg1 = (switch_rtp_t *)jarg1;
+ arg2 = (dtls_fingerprint_t *)jarg2;
+ arg3 = (dtls_fingerprint_t *)jarg3;
+ arg4 = (dtls_type_t)jarg4;
+ result = (switch_status_t)switch_rtp_add_dtls(arg1,arg2,arg3,arg4);
+ jresult = result;
+ return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_has_dtls() {
+ int jresult ;
+ int result;
+
+ result = (int)switch_rtp_has_dtls();
+ jresult = result;
+ return jresult;
+}
+
+
SWIGEXPORT void SWIGSTDCALL CSharp_switch_log_node_t_data_set(void * jarg1, char * jarg2) {
switch_log_node_t *arg1 = (switch_log_node_t *) 0 ;
char *arg2 = (char *) 0 ;
using System;
using System.Runtime.InteropServices;
+public class dtls_fingerprint_t : IDisposable {
+ private HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal dtls_fingerprint_t(IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ internal static HandleRef getCPtr(dtls_fingerprint_t obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~dtls_fingerprint_t() {
+ Dispose();
+ }
+
+ public virtual void Dispose() {
+ lock(this) {
+ if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+ swigCMemOwn = false;
+ freeswitchPINVOKE.delete_dtls_fingerprint_t(swigCPtr);
+ }
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ GC.SuppressFinalize(this);
+ }
+ }
+
+ public uint len {
+ set {
+ freeswitchPINVOKE.dtls_fingerprint_t_len_set(swigCPtr, value);
+ }
+ get {
+ uint ret = freeswitchPINVOKE.dtls_fingerprint_t_len_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public SWIGTYPE_p_unsigned_char data {
+ set {
+ freeswitchPINVOKE.dtls_fingerprint_t_data_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
+ }
+ get {
+ IntPtr cPtr = freeswitchPINVOKE.dtls_fingerprint_t_data_get(swigCPtr);
+ SWIGTYPE_p_unsigned_char ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
+ return ret;
+ }
+ }
+
+ public string type {
+ set {
+ freeswitchPINVOKE.dtls_fingerprint_t_type_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.dtls_fingerprint_t_type_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string str {
+ set {
+ freeswitchPINVOKE.dtls_fingerprint_t_str_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.dtls_fingerprint_t_str_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public dtls_fingerprint_t() : this(freeswitchPINVOKE.new_dtls_fingerprint_t(), true) {
+ }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+public enum dtls_state_t {
+ DS_HANDSHAKE,
+ DS_SETUP,
+ DS_READY,
+ DS_FAIL,
+ DS_INVALID
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+public enum dtls_type_t {
+ DTLS_TYPE_CLIENT = (1 << 0),
+ DTLS_TYPE_SERVER = (1 << 1),
+ DTLS_TYPE_RTP = (1 << 2),
+ DTLS_TYPE_RTCP = (1 << 3)
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class DTMF : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
namespace FreeSWITCH.Native {
public enum dtmf_flag_t {
- DTMF_FLAG_SKIP_PROCESS = (1 << 0)
+ DTMF_FLAG_SKIP_PROCESS = (1 << 0),
+ DTMF_FLAG_SENSITIVE = (1 << 1)
}
}
return ret;
}
+ public static switch_frame switch_core_media_bug_get_native_read_frame(SWIGTYPE_p_switch_media_bug bug) {
+ IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_native_read_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
+ switch_frame ret = (cPtr == IntPtr.Zero) ? null : new switch_frame(cPtr, false);
+ return ret;
+ }
+
+ public static switch_frame switch_core_media_bug_get_native_write_frame(SWIGTYPE_p_switch_media_bug bug) {
+ IntPtr cPtr = freeswitchPINVOKE.switch_core_media_bug_get_native_write_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug));
+ switch_frame ret = (cPtr == IntPtr.Zero) ? null : new switch_frame(cPtr, false);
+ return ret;
+ }
+
public static void switch_core_media_bug_set_write_replace_frame(SWIGTYPE_p_switch_media_bug bug, switch_frame frame) {
freeswitchPINVOKE.switch_core_media_bug_set_write_replace_frame(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame));
}
return ret;
}
+ public static switch_status_t switch_core_media_bug_transfer_callback(SWIGTYPE_p_switch_core_session orig_session, SWIGTYPE_p_switch_core_session new_session, SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t callback, SWIGTYPE_p_f_p_switch_core_session_p_void__p_void user_data_dup_func) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_transfer_callback(SWIGTYPE_p_switch_core_session.getCPtr(orig_session), SWIGTYPE_p_switch_core_session.getCPtr(new_session), SWIGTYPE_p_f_p_switch_media_bug_p_void_enum_switch_abc_type_t__switch_bool_t.getCPtr(callback), SWIGTYPE_p_f_p_switch_core_session_p_void__p_void.getCPtr(user_data_dup_func));
+ return ret;
+ }
+
public static switch_status_t switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug bug, switch_frame frame, switch_bool_t fill) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_media_bug_read(SWIGTYPE_p_switch_media_bug.getCPtr(bug), switch_frame.getCPtr(frame), (int)fill);
return ret;
freeswitchPINVOKE.switch_core_set_variable(varname, value);
}
+ public static switch_status_t switch_core_get_variables(SWIGTYPE_p_p_switch_event arg0) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_get_variables(SWIGTYPE_p_p_switch_event.getCPtr(arg0));
+ return ret;
+ }
+
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;
return ret;
}
+ public static switch_console_callback_match switch_core_session_findall() {
+ IntPtr cPtr = freeswitchPINVOKE.switch_core_session_findall();
+ switch_console_callback_match ret = (cPtr == IntPtr.Zero) ? null : new switch_console_callback_match(cPtr, false);
+ return ret;
+ }
+
public static void switch_core_session_hupall_endpoint(switch_endpoint_interface endpoint_interface, switch_call_cause_t cause) {
freeswitchPINVOKE.switch_core_session_hupall_endpoint(switch_endpoint_interface.getCPtr(endpoint_interface), (int)cause);
}
return ret;
}
+ public static uint switch_default_rate(string name, uint number) {
+ uint ret = freeswitchPINVOKE.switch_default_rate(name, number);
+ return ret;
+ }
+
public static switch_status_t switch_core_add_registration(string user, string realm, string token, string url, uint expires, string network_ip, string network_port, string network_proto, string metadata) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_core_add_registration(user, realm, token, url, expires, network_ip, network_port, network_proto, metadata);
return ret;
return ret;
}
+ public static int switch_core_gen_certs(string prefix) {
+ int ret = freeswitchPINVOKE.switch_core_gen_certs(prefix);
+ return ret;
+ }
+
+ public static int switch_core_cert_gen_fingerprint(string prefix, dtls_fingerprint_t fp) {
+ int ret = freeswitchPINVOKE.switch_core_cert_gen_fingerprint(prefix, dtls_fingerprint_t.getCPtr(fp));
+ return ret;
+ }
+
+ public static int switch_core_cert_expand_fingerprint(dtls_fingerprint_t fp, string str) {
+ int ret = freeswitchPINVOKE.switch_core_cert_expand_fingerprint(dtls_fingerprint_t.getCPtr(fp), str);
+ return ret;
+ }
+
+ public static int switch_core_cert_verify(dtls_fingerprint_t fp) {
+ int ret = freeswitchPINVOKE.switch_core_cert_verify(dtls_fingerprint_t.getCPtr(fp));
+ return ret;
+ }
+
public static switch_status_t switch_loadable_module_init(switch_bool_t autoload) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_loadable_module_init((int)autoload);
return ret;
return ret;
}
+ public static string switch_print_host(SWIGTYPE_p_switch_sockaddr_t addr, string buf, SWIGTYPE_p_switch_size_t len) {
+ string ret = freeswitchPINVOKE.switch_print_host(SWIGTYPE_p_switch_sockaddr_t.getCPtr(addr), buf, SWIGTYPE_p_switch_size_t.getCPtr(len));
+ if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
public static int _zstr(string s) {
int ret = freeswitchPINVOKE._zstr(s);
return ret;
return ret;
}
+ public static int switch_strcasecmp_any(string str) {
+ int ret = freeswitchPINVOKE.switch_strcasecmp_any(str);
+ return ret;
+ }
+
public static string switch_util_quote_shell_arg(string arg0) {
string ret = freeswitchPINVOKE.switch_util_quote_shell_arg(arg0);
return ret;
freeswitchPINVOKE.switch_channel_set_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_profile.getCPtr(caller_profile));
}
+ public static void switch_channel_step_caller_profile(SWIGTYPE_p_switch_channel channel) {
+ freeswitchPINVOKE.switch_channel_step_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
+ }
+
public static switch_caller_profile switch_channel_get_caller_profile(SWIGTYPE_p_switch_channel channel) {
IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_caller_profile(SWIGTYPE_p_switch_channel.getCPtr(channel));
switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false);
return ret;
}
+ public static switch_status_t switch_channel_transfer_variable_prefix(SWIGTYPE_p_switch_channel orig_channel, SWIGTYPE_p_switch_channel new_channel, string prefix) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_transfer_variable_prefix(SWIGTYPE_p_switch_channel.getCPtr(orig_channel), SWIGTYPE_p_switch_channel.getCPtr(new_channel), prefix);
+ return ret;
+ }
+
public static switch_status_t switch_channel_export_variable_var_check(SWIGTYPE_p_switch_channel channel, string varname, string val, string export_varname, switch_bool_t var_check) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_export_variable_var_check(SWIGTYPE_p_switch_channel.getCPtr(channel), varname, val, export_varname, (int)var_check);
return ret;
freeswitchPINVOKE.switch_channel_set_caller_extension(SWIGTYPE_p_switch_channel.getCPtr(channel), switch_caller_extension.getCPtr(caller_extension));
}
+ public static void switch_channel_invert_cid(SWIGTYPE_p_switch_channel channel) {
+ freeswitchPINVOKE.switch_channel_invert_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
+ }
+
public static void switch_channel_flip_cid(SWIGTYPE_p_switch_channel channel) {
freeswitchPINVOKE.switch_channel_flip_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
}
- public static void switch_channel_sort_cid(SWIGTYPE_p_switch_channel channel, switch_bool_t arg1) {
- freeswitchPINVOKE.switch_channel_sort_cid(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)arg1);
+ public static void switch_channel_sort_cid(SWIGTYPE_p_switch_channel channel) {
+ freeswitchPINVOKE.switch_channel_sort_cid(SWIGTYPE_p_switch_channel.getCPtr(channel));
}
public static switch_caller_extension switch_channel_get_caller_extension(SWIGTYPE_p_switch_channel channel) {
freeswitchPINVOKE.switch_channel_state_thread_unlock(SWIGTYPE_p_switch_channel.getCPtr(channel));
}
+ public static switch_status_t switch_channel_state_thread_trylock(SWIGTYPE_p_switch_channel channel) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_state_thread_trylock(SWIGTYPE_p_switch_channel.getCPtr(channel));
+ return ret;
+ }
+
public static switch_status_t switch_buffer_create(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t max_len) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_create(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(max_len));
if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ public static switch_status_t switch_ivr_transfer_recordings(SWIGTYPE_p_switch_core_session orig_session, SWIGTYPE_p_switch_core_session new_session) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_transfer_recordings(SWIGTYPE_p_switch_core_session.getCPtr(orig_session), SWIGTYPE_p_switch_core_session.getCPtr(new_session));
+ return ret;
+ }
+
public static switch_status_t switch_ivr_eavesdrop_pop_eavesdropper(SWIGTYPE_p_switch_core_session session, SWIGTYPE_p_p_switch_core_session sessionp) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_eavesdrop_pop_eavesdropper(SWIGTYPE_p_switch_core_session.getCPtr(session), SWIGTYPE_p_p_switch_core_session.getCPtr(sessionp));
return ret;
return ret;
}
+ public static switch_status_t switch_ivr_hold_toggle_uuid(string uuid, string message, switch_bool_t moh) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_hold_toggle_uuid(uuid, message, (int)moh);
+ return ret;
+ }
+
public static switch_status_t switch_ivr_unhold_uuid(string uuid) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_unhold_uuid(uuid);
return ret;
return ret;
}
+ public static switch_status_t switch_ivr_record_session_mask(SWIGTYPE_p_switch_core_session session, string file, switch_bool_t on) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_ivr_record_session_mask(SWIGTYPE_p_switch_core_session.getCPtr(session), file, (int)on);
+ return ret;
+ }
+
public static switch_status_t switch_rtp_add_crypto_key(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_crypto_direction_t direction, uint index, switch_rtp_crypto_key_type_t type, SWIGTYPE_p_unsigned_char key, SWIGTYPE_p_switch_size_t keylen) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_add_crypto_key(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)direction, index, (int)type, SWIGTYPE_p_unsigned_char.getCPtr(key), SWIGTYPE_p_switch_size_t.getCPtr(keylen));
if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public static switch_status_t switch_rtp_create(SWIGTYPE_p_p_switch_rtp new_rtp_session, byte payload, uint samples_per_interval, uint ms_per_packet, uint flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
- switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_create(SWIGTYPE_p_p_switch_rtp.getCPtr(new_rtp_session), payload, samples_per_interval, ms_per_packet, flags, timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+ public static switch_status_t switch_rtp_create(SWIGTYPE_p_p_switch_rtp new_rtp_session, byte payload, uint samples_per_interval, uint ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_create(SWIGTYPE_p_p_switch_rtp.getCPtr(new_rtp_session), payload, samples_per_interval, ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags), timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
return ret;
}
- public static SWIGTYPE_p_switch_rtp switch_rtp_new(string rx_host, ushort rx_port, string tx_host, ushort tx_port, byte payload, uint samples_per_interval, uint ms_per_packet, uint flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
- IntPtr cPtr = freeswitchPINVOKE.switch_rtp_new(rx_host, rx_port, tx_host, tx_port, payload, samples_per_interval, ms_per_packet, flags, timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
+ public static SWIGTYPE_p_switch_rtp switch_rtp_new(string rx_host, ushort rx_port, string tx_host, ushort tx_port, byte payload, uint samples_per_interval, uint ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t flags, string timer_name, ref string err, SWIGTYPE_p_apr_pool_t pool) {
+ IntPtr cPtr = freeswitchPINVOKE.switch_rtp_new(rx_host, rx_port, tx_host, tx_port, payload, samples_per_interval, ms_per_packet, SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags), timer_name, ref err, SWIGTYPE_p_apr_pool_t.getCPtr(pool));
SWIGTYPE_p_switch_rtp ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_rtp(cPtr, false);
return ret;
}
freeswitchPINVOKE.switch_rtp_destroy(SWIGTYPE_p_p_switch_rtp.getCPtr(rtp_session));
}
- public static switch_status_t switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password) {
- switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password);
- return ret;
- }
-
- public static switch_status_t switch_rtp_activate_rtcp_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password) {
- switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password);
+ public static switch_status_t switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp rtp_session, string login, string rlogin, string password, string rpassword, ice_proto_t proto, SWIGTYPE_p_switch_core_media_ice_type_t type, ice_t ice_params) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_ice(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), login, rlogin, password, rpassword, (int)proto, SWIGTYPE_p_switch_core_media_ice_type_t.getCPtr(type), ice_t.getCPtr(ice_params));
+ if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public static switch_status_t switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp rtp_session, int send_rate, ushort remote_port) {
- switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), send_rate, remote_port);
+ public static switch_status_t switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp rtp_session, int send_rate, ushort remote_port, switch_bool_t mux) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_activate_rtcp(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), send_rate, remote_port, (int)mux);
return ret;
}
return ret;
}
- public static void switch_rtp_set_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
- freeswitchPINVOKE.switch_rtp_set_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+ public static void switch_rtp_set_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flag) {
+ freeswitchPINVOKE.switch_rtp_set_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flag);
}
- public static uint switch_rtp_test_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
- uint ret = freeswitchPINVOKE.switch_rtp_test_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+ public static void switch_rtp_set_flags(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_switch_rtp_flag_t flags) {
+ freeswitchPINVOKE.switch_rtp_set_flags(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags));
+ }
+
+ public static void switch_rtp_clear_flags(SWIGTYPE_p_switch_rtp rtp_session, SWIGTYPE_p_switch_rtp_flag_t flags) {
+ freeswitchPINVOKE.switch_rtp_clear_flags(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), SWIGTYPE_p_switch_rtp_flag_t.getCPtr(flags));
+ }
+
+ public static uint switch_rtp_test_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flags) {
+ uint ret = freeswitchPINVOKE.switch_rtp_test_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flags);
return ret;
}
- public static void switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp rtp_session, uint flags) {
- freeswitchPINVOKE.switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), flags);
+ public static void switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp rtp_session, switch_rtp_flag_t flag) {
+ freeswitchPINVOKE.switch_rtp_clear_flag(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), (int)flag);
}
public static SWIGTYPE_p_switch_socket_t switch_rtp_get_rtp_socket(SWIGTYPE_p_switch_rtp rtp_session) {
freeswitchPINVOKE.switch_rtp_set_interdigit_delay(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), delay);
}
+ public static switch_status_t switch_rtp_add_dtls(SWIGTYPE_p_switch_rtp rtp_session, dtls_fingerprint_t local_fp, dtls_fingerprint_t remote_fp, dtls_type_t type) {
+ switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_rtp_add_dtls(SWIGTYPE_p_switch_rtp.getCPtr(rtp_session), dtls_fingerprint_t.getCPtr(local_fp), dtls_fingerprint_t.getCPtr(remote_fp), (int)type);
+ return ret;
+ }
+
+ public static int switch_rtp_has_dtls() {
+ int ret = freeswitchPINVOKE.switch_rtp_has_dtls();
+ return ret;
+ }
+
public static switch_status_t switch_log_init(SWIGTYPE_p_apr_pool_t pool, switch_bool_t colorize) {
switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_log_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool), (int)colorize);
return ret;
public static readonly string SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE = freeswitchPINVOKE.SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE_get();
public static readonly string SWITCH_TRANSFER_HISTORY_VARIABLE = freeswitchPINVOKE.SWITCH_TRANSFER_HISTORY_VARIABLE_get();
public static readonly string SWITCH_TRANSFER_SOURCE_VARIABLE = freeswitchPINVOKE.SWITCH_TRANSFER_SOURCE_VARIABLE_get();
+ public static readonly string SWITCH_SENSITIVE_DTMF_VARIABLE = freeswitchPINVOKE.SWITCH_SENSITIVE_DTMF_VARIABLE_get();
+ public static readonly string SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE = freeswitchPINVOKE.SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get();
+ public static readonly string SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE = freeswitchPINVOKE.SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get();
+ public static readonly string SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get();
+ public static readonly string SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE_get();
public static readonly string SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE = freeswitchPINVOKE.SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE_get();
public static readonly string SWITCH_HOLDING_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_HOLDING_UUID_VARIABLE_get();
public static readonly string SWITCH_SOFT_HOLDING_UUID_VARIABLE = freeswitchPINVOKE.SWITCH_SOFT_HOLDING_UUID_VARIABLE_get();
public static readonly string SWITCH_API_BRIDGE_END_VARIABLE = freeswitchPINVOKE.SWITCH_API_BRIDGE_END_VARIABLE_get();
+ public static readonly string SWITCH_API_BRIDGE_START_VARIABLE = freeswitchPINVOKE.SWITCH_API_BRIDGE_START_VARIABLE_get();
public static readonly string SWITCH_API_HANGUP_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_API_HANGUP_HOOK_VARIABLE_get();
public static readonly string SWITCH_API_REPORTING_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_API_REPORTING_HOOK_VARIABLE_get();
public static readonly string SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE = freeswitchPINVOKE.SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE_get();
public static readonly int SWITCH_CORE_QUEUE_LEN = freeswitchPINVOKE.SWITCH_CORE_QUEUE_LEN_get();
public static readonly int SWITCH_MAX_MANAGEMENT_BUFFER_LEN = freeswitchPINVOKE.SWITCH_MAX_MANAGEMENT_BUFFER_LEN_get();
public static readonly int SWITCH_RTP_CNG_PAYLOAD = freeswitchPINVOKE.SWITCH_RTP_CNG_PAYLOAD_get();
+ public static readonly int SWITCH_MEDIA_TYPE_TOTAL = freeswitchPINVOKE.SWITCH_MEDIA_TYPE_TOTAL_get();
public static readonly int DMACHINE_MAX_DIGIT_LEN = freeswitchPINVOKE.DMACHINE_MAX_DIGIT_LEN_get();
public static readonly int MAX_ARG_RECURSION = freeswitchPINVOKE.MAX_ARG_RECURSION_get();
public static readonly int SWITCH_API_VERSION = freeswitchPINVOKE.SWITCH_API_VERSION_get();
public static readonly int SWITCH_CORE_DB_DONE = freeswitchPINVOKE.SWITCH_CORE_DB_DONE_get();
public static readonly int SWITCH_MAX_CORE_THREAD_SESSION_OBJS = freeswitchPINVOKE.SWITCH_MAX_CORE_THREAD_SESSION_OBJS_get();
public static readonly int SWITCH_MAX_STREAMS = freeswitchPINVOKE.SWITCH_MAX_STREAMS_get();
+ public static readonly string DTLS_SRTP_FNAME = freeswitchPINVOKE.DTLS_SRTP_FNAME_get();
+ public static readonly int MAX_FPLEN = freeswitchPINVOKE.MAX_FPLEN_get();
+ public static readonly int MAX_FPSTRLEN = freeswitchPINVOKE.MAX_FPSTRLEN_get();
public static readonly int MESSAGE_STRING_ARG_MAX = freeswitchPINVOKE.MESSAGE_STRING_ARG_MAX_get();
public static readonly int CACHE_DB_LEN = freeswitchPINVOKE.CACHE_DB_LEN_get();
public static readonly int SWITCH_CMD_CHUNK_LEN = freeswitchPINVOKE.SWITCH_CMD_CHUNK_LEN_get();
public static readonly int SWITCH_RTP_KEY_LEN = freeswitchPINVOKE.SWITCH_RTP_KEY_LEN_get();
public static readonly string SWITCH_RTP_CRYPTO_KEY_32 = freeswitchPINVOKE.SWITCH_RTP_CRYPTO_KEY_32_get();
public static readonly string SWITCH_RTP_CRYPTO_KEY_80 = freeswitchPINVOKE.SWITCH_RTP_CRYPTO_KEY_80_get();
+ public static readonly int MAX_CAND = freeswitchPINVOKE.MAX_CAND_get();
public static readonly int SWITCH_XML_BUFSIZE = freeswitchPINVOKE.SWITCH_XML_BUFSIZE_get();
}
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_TRANSFER_SOURCE_VARIABLE_get")]
public static extern string SWITCH_TRANSFER_SOURCE_VARIABLE_get();
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_SENSITIVE_DTMF_VARIABLE_get")]
+ public static extern string SWITCH_SENSITIVE_DTMF_VARIABLE_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get")]
+ public static extern string SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get")]
+ public static extern string SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE_get();
+
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get")]
public static extern string SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE_get();
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get")]
public static extern string SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE_get();
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get")]
+ public static extern string SWITCH_CHANNEL_EXECUTE_ON_PRE_BRIDGE_VARIABLE_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get")]
+ public static extern string SWITCH_CHANNEL_EXECUTE_ON_POST_BRIDGE_VARIABLE_get();
+
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get")]
public static extern string SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE_get();
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_BRIDGE_END_VARIABLE_get")]
public static extern string SWITCH_API_BRIDGE_END_VARIABLE_get();
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_BRIDGE_START_VARIABLE_get")]
+ public static extern string SWITCH_API_BRIDGE_START_VARIABLE_get();
+
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_API_HANGUP_HOOK_VARIABLE_get")]
public static extern string SWITCH_API_HANGUP_HOOK_VARIABLE_get();
[DllImport("mod_managed", EntryPoint="CSharp_switch_directories_lib_dir_get")]
public static extern string switch_directories_lib_dir_get(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_directories_certs_dir_set")]
+ public static extern void switch_directories_certs_dir_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_directories_certs_dir_get")]
+ public static extern string switch_directories_certs_dir_get(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_new_switch_directories")]
public static extern IntPtr new_switch_directories();
[DllImport("mod_managed", EntryPoint="CSharp_delete_switch_t38_options_t")]
public static extern void delete_switch_t38_options_t(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_MEDIA_TYPE_TOTAL_get")]
+ public static extern int SWITCH_MEDIA_TYPE_TOTAL_get();
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_console_callback_match_node_val_set")]
public static extern void switch_console_callback_match_node_val_set(HandleRef jarg1, string jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_delete_switch_thread_data_t")]
public static extern void delete_switch_thread_data_t(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_DTLS_SRTP_FNAME_get")]
+ public static extern string DTLS_SRTP_FNAME_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_MAX_FPLEN_get")]
+ public static extern int MAX_FPLEN_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_MAX_FPSTRLEN_get")]
+ public static extern int MAX_FPSTRLEN_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_len_set")]
+ public static extern void dtls_fingerprint_t_len_set(HandleRef jarg1, uint jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_len_get")]
+ public static extern uint dtls_fingerprint_t_len_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_data_set")]
+ public static extern void dtls_fingerprint_t_data_set(HandleRef jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_data_get")]
+ public static extern IntPtr dtls_fingerprint_t_data_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_type_set")]
+ public static extern void dtls_fingerprint_t_type_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_type_get")]
+ public static extern string dtls_fingerprint_t_type_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_str_set")]
+ public static extern void dtls_fingerprint_t_str_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_dtls_fingerprint_t_str_get")]
+ public static extern string dtls_fingerprint_t_str_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_new_dtls_fingerprint_t")]
+ public static extern IntPtr new_dtls_fingerprint_t();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_delete_dtls_fingerprint_t")]
+ public static extern void delete_dtls_fingerprint_t(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_MESSAGE_STRING_ARG_MAX_get")]
public static extern int MESSAGE_STRING_ARG_MAX_get();
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_write_replace_frame")]
public static extern IntPtr switch_core_media_bug_get_write_replace_frame(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_native_read_frame")]
+ public static extern IntPtr switch_core_media_bug_get_native_read_frame(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_get_native_write_frame")]
+ public static extern IntPtr switch_core_media_bug_get_native_write_frame(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_set_write_replace_frame")]
public static extern void switch_core_media_bug_set_write_replace_frame(HandleRef jarg1, HandleRef jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_transfer_recordings")]
public static extern int switch_core_media_bug_transfer_recordings(HandleRef jarg1, HandleRef jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_transfer_callback")]
+ public static extern int switch_core_media_bug_transfer_callback(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, HandleRef jarg4);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_media_bug_read")]
public static extern int switch_core_media_bug_read(HandleRef jarg1, HandleRef jarg2, int jarg3);
[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_get_variables")]
+ public static extern int switch_core_get_variables(HandleRef jarg1);
+
[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_session_findall_matching_var")]
public static extern IntPtr switch_core_session_findall_matching_var(string jarg1, string jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_findall")]
+ public static extern IntPtr switch_core_session_findall();
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_session_hupall_endpoint")]
public static extern void switch_core_session_hupall_endpoint(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_default_ptime")]
public static extern uint switch_default_ptime(string jarg1, uint jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_default_rate")]
+ public static extern uint switch_default_rate(string jarg1, uint jarg2);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_core_add_registration")]
public static extern int switch_core_add_registration(string jarg1, string jarg2, string jarg3, string jarg4, uint jarg5, string jarg6, string jarg7, string jarg8, string jarg9);
[DllImport("mod_managed", EntryPoint="CSharp_switch_fork")]
public static extern IntPtr switch_fork();
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_gen_certs")]
+ public static extern int switch_core_gen_certs(string jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_gen_fingerprint")]
+ public static extern int switch_core_cert_gen_fingerprint(string jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_expand_fingerprint")]
+ public static extern int switch_core_cert_expand_fingerprint(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_core_cert_verify")]
+ public static extern int switch_core_cert_verify(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_loadable_module_interface_module_name_set")]
public static extern void switch_loadable_module_interface_module_name_set(HandleRef jarg1, string jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_testv6_subnet")]
public static extern int switch_testv6_subnet(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_print_host")]
+ public static extern string switch_print_host(HandleRef jarg1, string jarg2, HandleRef jarg3);
+
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_SMAX_get")]
public static extern int SWITCH_SMAX_get();
[DllImport("mod_managed", EntryPoint="CSharp_switch_string_match")]
public static extern int switch_string_match(string jarg1, uint jarg2, string jarg3, uint jarg4);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_strcasecmp_any")]
+ public static extern int switch_strcasecmp_any(string jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg")]
public static extern string switch_util_quote_shell_arg(string jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_caller_id_number_get")]
public static extern string switch_caller_profile_caller_id_number_get(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_name_set")]
+ public static extern void switch_caller_profile_orig_caller_id_name_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_name_get")]
+ public static extern string switch_caller_profile_orig_caller_id_name_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_number_set")]
+ public static extern void switch_caller_profile_orig_caller_id_number_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_orig_caller_id_number_get")]
+ public static extern string switch_caller_profile_orig_caller_id_number_get(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_caller_profile_callee_id_name_set")]
public static extern void switch_caller_profile_callee_id_name_set(HandleRef jarg1, string jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_prefix_get")]
public static extern string switch_file_handle_prefix_get(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_max_samples_set")]
+ public static extern void switch_file_handle_max_samples_set(HandleRef jarg1, int jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_max_samples_get")]
+ public static extern int switch_file_handle_max_samples_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_params_set")]
+ public static extern void switch_file_handle_params_set(HandleRef jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_file_handle_params_get")]
+ public static extern IntPtr switch_file_handle_params_get(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_new_switch_file_handle")]
public static extern IntPtr new_switch_file_handle();
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_caller_profile")]
public static extern void switch_channel_set_caller_profile(HandleRef jarg1, HandleRef jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_step_caller_profile")]
+ public static extern void switch_channel_step_caller_profile(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_caller_profile")]
public static extern IntPtr switch_channel_get_caller_profile(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_del_variable_prefix")]
public static extern uint switch_channel_del_variable_prefix(HandleRef jarg1, string jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_transfer_variable_prefix")]
+ public static extern int switch_channel_transfer_variable_prefix(HandleRef jarg1, HandleRef jarg2, string jarg3);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_export_variable_var_check")]
public static extern int switch_channel_export_variable_var_check(HandleRef jarg1, string jarg2, string jarg3, string jarg4, int jarg5);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_caller_extension")]
public static extern void switch_channel_set_caller_extension(HandleRef jarg1, HandleRef jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_invert_cid")]
+ public static extern void switch_channel_invert_cid(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_flip_cid")]
public static extern void switch_channel_flip_cid(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_sort_cid")]
- public static extern void switch_channel_sort_cid(HandleRef jarg1, int jarg2);
+ public static extern void switch_channel_sort_cid(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_caller_extension")]
public static extern IntPtr switch_channel_get_caller_extension(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_channel_state_thread_unlock")]
public static extern void switch_channel_state_thread_unlock(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_state_thread_trylock")]
+ public static extern int switch_channel_state_thread_trylock(HandleRef jarg1);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")]
public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3);
[DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_record_session")]
public static extern int switch_ivr_record_session(HandleRef jarg1, string jarg2, uint jarg3, HandleRef jarg4);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_transfer_recordings")]
+ public static extern int switch_ivr_transfer_recordings(HandleRef jarg1, HandleRef jarg2);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_eavesdrop_pop_eavesdropper")]
public static extern int switch_ivr_eavesdrop_pop_eavesdropper(HandleRef jarg1, HandleRef jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_hold_uuid")]
public static extern int switch_ivr_hold_uuid(string jarg1, string jarg2, int jarg3);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_hold_toggle_uuid")]
+ public static extern int switch_ivr_hold_toggle_uuid(string jarg1, string jarg2, int jarg3);
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_unhold_uuid")]
public static extern int switch_ivr_unhold_uuid(string jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_blind_transfer_ack")]
public static extern int switch_ivr_blind_transfer_ack(HandleRef jarg1, int jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_ivr_record_session_mask")]
+ public static extern int switch_ivr_record_session_mask(HandleRef jarg1, string jarg2, int jarg3);
+
[DllImport("mod_managed", EntryPoint="CSharp_SWITCH_RTP_MAX_BUF_LEN_get")]
public static extern int SWITCH_RTP_MAX_BUF_LEN_get();
[DllImport("mod_managed", EntryPoint="CSharp_delete_switch_rtp_crypto_key")]
public static extern void delete_switch_rtp_crypto_key(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_crypto_key")]
- public static extern int switch_rtp_add_crypto_key(HandleRef jarg1, int jarg2, uint jarg3, int jarg4, HandleRef jarg5, HandleRef jarg6);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_foundation_set")]
+ public static extern void icand_t_foundation_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_random")]
- public static extern void switch_rtp_get_random(HandleRef jarg1, uint jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_foundation_get")]
+ public static extern string icand_t_foundation_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_init")]
- public static extern void switch_rtp_init(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_component_id_set")]
+ public static extern void icand_t_component_id_set(HandleRef jarg1, int jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_shutdown")]
- public static extern void switch_rtp_shutdown();
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_component_id_get")]
+ public static extern int icand_t_component_id_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_start_port")]
- public static extern ushort switch_rtp_set_start_port(ushort jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_transport_set")]
+ public static extern void icand_t_transport_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_ssrc")]
- public static extern int switch_rtp_set_ssrc(HandleRef jarg1, uint jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_transport_get")]
+ public static extern string icand_t_transport_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_end_port")]
- public static extern ushort switch_rtp_set_end_port(ushort jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_priority_set")]
+ public static extern void icand_t_priority_set(HandleRef jarg1, uint jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_request_port")]
- public static extern ushort switch_rtp_request_port(string jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_priority_get")]
+ public static extern uint icand_t_priority_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_release_port")]
- public static extern void switch_rtp_release_port(string jarg1, ushort jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_addr_set")]
+ public static extern void icand_t_con_addr_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_interval")]
- public static extern int switch_rtp_set_interval(HandleRef jarg1, uint jarg2, uint jarg3);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_addr_get")]
+ public static extern string icand_t_con_addr_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_change_interval")]
- public static extern int switch_rtp_change_interval(HandleRef jarg1, uint jarg2, uint jarg3);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_port_set")]
+ public static extern void icand_t_con_port_set(HandleRef jarg1, ushort jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_create")]
- public static extern int switch_rtp_create(HandleRef jarg1, byte jarg2, uint jarg3, uint jarg4, uint jarg5, string jarg6, ref string jarg7, HandleRef jarg8);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_con_port_get")]
+ public static extern ushort icand_t_con_port_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_new")]
- public static extern IntPtr switch_rtp_new(string jarg1, ushort jarg2, string jarg3, ushort jarg4, byte jarg5, uint jarg6, uint jarg7, uint jarg8, string jarg9, ref string jarg10, HandleRef jarg11);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_cand_type_set")]
+ public static extern void icand_t_cand_type_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_remote_address")]
- public static extern int switch_rtp_set_remote_address(HandleRef jarg1, string jarg2, ushort jarg3, ushort jarg4, int jarg5, ref string jarg6);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_cand_type_get")]
+ public static extern string icand_t_cand_type_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_remote_host")]
- public static extern string switch_rtp_get_remote_host(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_raddr_set")]
+ public static extern void icand_t_raddr_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_remote_port")]
- public static extern ushort switch_rtp_get_remote_port(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_raddr_get")]
+ public static extern string icand_t_raddr_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_reset_media_timer")]
- public static extern void switch_rtp_reset_media_timer(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_rport_set")]
+ public static extern void icand_t_rport_set(HandleRef jarg1, ushort jarg2);
- [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_icand_t_rport_get")]
+ public static extern ushort icand_t_rport_get(HandleRef jarg1);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_udptl_mode")]
- public static extern int switch_rtp_udptl_mode(HandleRef jarg1);
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_generation_set")]
+ public static extern void icand_t_generation_set(HandleRef jarg1, string jarg2);
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_local_address")]
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_generation_get")]
+ public static extern string icand_t_generation_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_ready_set")]
+ public static extern void icand_t_ready_set(HandleRef jarg1, byte jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_icand_t_ready_get")]
+ public static extern byte icand_t_ready_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_new_icand_t")]
+ public static extern IntPtr new_icand_t();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_delete_icand_t")]
+ public static extern void delete_icand_t(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_MAX_CAND_get")]
+ public static extern int MAX_CAND_get();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cands_set")]
+ public static extern void ice_t_cands_set(HandleRef jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cands_get")]
+ public static extern IntPtr ice_t_cands_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cand_idx_set")]
+ public static extern void ice_t_cand_idx_set(HandleRef jarg1, int jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_cand_idx_get")]
+ public static extern int ice_t_cand_idx_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_chosen_set")]
+ public static extern void ice_t_chosen_set(HandleRef jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_chosen_get")]
+ public static extern IntPtr ice_t_chosen_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_ufrag_set")]
+ public static extern void ice_t_ufrag_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_ufrag_get")]
+ public static extern string ice_t_ufrag_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_pwd_set")]
+ public static extern void ice_t_pwd_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_pwd_get")]
+ public static extern string ice_t_pwd_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_options_set")]
+ public static extern void ice_t_options_set(HandleRef jarg1, string jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_ice_t_options_get")]
+ public static extern string ice_t_options_get(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_new_ice_t")]
+ public static extern IntPtr new_ice_t();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_delete_ice_t")]
+ public static extern void delete_ice_t(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_crypto_key")]
+ public static extern int switch_rtp_add_crypto_key(HandleRef jarg1, int jarg2, uint jarg3, int jarg4, HandleRef jarg5, HandleRef jarg6);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_random")]
+ public static extern void switch_rtp_get_random(HandleRef jarg1, uint jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_init")]
+ public static extern void switch_rtp_init(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_shutdown")]
+ public static extern void switch_rtp_shutdown();
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_start_port")]
+ public static extern ushort switch_rtp_set_start_port(ushort jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_ssrc")]
+ public static extern int switch_rtp_set_ssrc(HandleRef jarg1, uint jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_end_port")]
+ public static extern ushort switch_rtp_set_end_port(ushort jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_request_port")]
+ public static extern ushort switch_rtp_request_port(string jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_release_port")]
+ public static extern void switch_rtp_release_port(string jarg1, ushort jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_interval")]
+ public static extern int switch_rtp_set_interval(HandleRef jarg1, uint jarg2, uint jarg3);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_change_interval")]
+ public static extern int switch_rtp_change_interval(HandleRef jarg1, uint jarg2, uint jarg3);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_create")]
+ public static extern int switch_rtp_create(HandleRef jarg1, byte jarg2, uint jarg3, uint jarg4, HandleRef jarg5, string jarg6, ref string jarg7, HandleRef jarg8);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_new")]
+ public static extern IntPtr switch_rtp_new(string jarg1, ushort jarg2, string jarg3, ushort jarg4, byte jarg5, uint jarg6, uint jarg7, HandleRef jarg8, string jarg9, ref string jarg10, HandleRef jarg11);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_remote_address")]
+ public static extern int switch_rtp_set_remote_address(HandleRef jarg1, string jarg2, ushort jarg3, ushort jarg4, int jarg5, ref string jarg6);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_remote_host")]
+ public static extern string switch_rtp_get_remote_host(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_remote_port")]
+ public static extern ushort switch_rtp_get_remote_port(HandleRef jarg1);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_reset_media_timer")]
+ public static extern void switch_rtp_reset_media_timer(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);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_kill_socket")]
public static extern void switch_rtp_destroy(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_ice")]
- public static extern int switch_rtp_activate_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
-
- [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_rtcp_ice")]
- public static extern int switch_rtp_activate_rtcp_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
+ public static extern int switch_rtp_activate_ice(HandleRef jarg1, string jarg2, string jarg3, string jarg4, string jarg5, int jarg6, HandleRef jarg7, HandleRef jarg8);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_rtcp")]
- public static extern int switch_rtp_activate_rtcp(HandleRef jarg1, int jarg2, ushort jarg3);
+ public static extern int switch_rtp_activate_rtcp(HandleRef jarg1, int jarg2, ushort jarg3, int jarg4);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_activate_jitter_buffer")]
public static extern int switch_rtp_activate_jitter_buffer(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6);
public static extern IntPtr switch_rtp_get_jitter_buffer(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_flag")]
- public static extern void switch_rtp_set_flag(HandleRef jarg1, uint jarg2);
+ public static extern void switch_rtp_set_flag(HandleRef jarg1, int jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_flags")]
+ public static extern void switch_rtp_set_flags(HandleRef jarg1, HandleRef jarg2);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_clear_flags")]
+ public static extern void switch_rtp_clear_flags(HandleRef jarg1, HandleRef jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_test_flag")]
- public static extern uint switch_rtp_test_flag(HandleRef jarg1, uint jarg2);
+ public static extern uint switch_rtp_test_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_clear_flag")]
- public static extern void switch_rtp_clear_flag(HandleRef jarg1, uint jarg2);
+ public static extern void switch_rtp_clear_flag(HandleRef jarg1, int jarg2);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_get_rtp_socket")]
public static extern IntPtr switch_rtp_get_rtp_socket(HandleRef jarg1);
[DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_set_interdigit_delay")]
public static extern void switch_rtp_set_interdigit_delay(HandleRef jarg1, uint jarg2);
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_add_dtls")]
+ public static extern int switch_rtp_add_dtls(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, int jarg4);
+
+ [DllImport("mod_managed", EntryPoint="CSharp_switch_rtp_has_dtls")]
+ public static extern int switch_rtp_has_dtls();
+
[DllImport("mod_managed", EntryPoint="CSharp_switch_log_node_t_data_set")]
public static extern void switch_log_node_t_data_set(HandleRef jarg1, string jarg2);
using System;
using System.Runtime.InteropServices;
+public class icand_t : IDisposable {
+ private HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal icand_t(IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ internal static HandleRef getCPtr(icand_t obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~icand_t() {
+ Dispose();
+ }
+
+ public virtual void Dispose() {
+ lock(this) {
+ if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+ swigCMemOwn = false;
+ freeswitchPINVOKE.delete_icand_t(swigCPtr);
+ }
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ GC.SuppressFinalize(this);
+ }
+ }
+
+ public string foundation {
+ set {
+ freeswitchPINVOKE.icand_t_foundation_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_foundation_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public int component_id {
+ set {
+ freeswitchPINVOKE.icand_t_component_id_set(swigCPtr, value);
+ }
+ get {
+ int ret = freeswitchPINVOKE.icand_t_component_id_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string transport {
+ set {
+ freeswitchPINVOKE.icand_t_transport_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_transport_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public uint priority {
+ set {
+ freeswitchPINVOKE.icand_t_priority_set(swigCPtr, value);
+ }
+ get {
+ uint ret = freeswitchPINVOKE.icand_t_priority_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string con_addr {
+ set {
+ freeswitchPINVOKE.icand_t_con_addr_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_con_addr_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public ushort con_port {
+ set {
+ freeswitchPINVOKE.icand_t_con_port_set(swigCPtr, value);
+ }
+ get {
+ ushort ret = freeswitchPINVOKE.icand_t_con_port_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string cand_type {
+ set {
+ freeswitchPINVOKE.icand_t_cand_type_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_cand_type_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string raddr {
+ set {
+ freeswitchPINVOKE.icand_t_raddr_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_raddr_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public ushort rport {
+ set {
+ freeswitchPINVOKE.icand_t_rport_set(swigCPtr, value);
+ }
+ get {
+ ushort ret = freeswitchPINVOKE.icand_t_rport_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string generation {
+ set {
+ freeswitchPINVOKE.icand_t_generation_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.icand_t_generation_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public byte ready {
+ set {
+ freeswitchPINVOKE.icand_t_ready_set(swigCPtr, value);
+ }
+ get {
+ byte ret = freeswitchPINVOKE.icand_t_ready_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public icand_t() : this(freeswitchPINVOKE.new_icand_t(), true) {
+ }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+public enum ice_proto_t {
+ IPR_RTP,
+ IPR_RTCP
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
+public class ice_t : IDisposable {
+ private HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal ice_t(IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ internal static HandleRef getCPtr(ice_t obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~ice_t() {
+ Dispose();
+ }
+
+ public virtual void Dispose() {
+ lock(this) {
+ if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
+ swigCMemOwn = false;
+ freeswitchPINVOKE.delete_ice_t(swigCPtr);
+ }
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ GC.SuppressFinalize(this);
+ }
+ }
+
+ public SWIGTYPE_p_a_2__icand_s cands {
+ set {
+ freeswitchPINVOKE.ice_t_cands_set(swigCPtr, SWIGTYPE_p_a_2__icand_s.getCPtr(value));
+ }
+ get {
+ IntPtr cPtr = freeswitchPINVOKE.ice_t_cands_get(swigCPtr);
+ SWIGTYPE_p_a_2__icand_s ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_a_2__icand_s(cPtr, false);
+ return ret;
+ }
+ }
+
+ public int cand_idx {
+ set {
+ freeswitchPINVOKE.ice_t_cand_idx_set(swigCPtr, value);
+ }
+ get {
+ int ret = freeswitchPINVOKE.ice_t_cand_idx_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public SWIGTYPE_p_int chosen {
+ set {
+ freeswitchPINVOKE.ice_t_chosen_set(swigCPtr, SWIGTYPE_p_int.getCPtr(value));
+ }
+ get {
+ IntPtr cPtr = freeswitchPINVOKE.ice_t_chosen_get(swigCPtr);
+ SWIGTYPE_p_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_int(cPtr, false);
+ return ret;
+ }
+ }
+
+ public string ufrag {
+ set {
+ freeswitchPINVOKE.ice_t_ufrag_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.ice_t_ufrag_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string pwd {
+ set {
+ freeswitchPINVOKE.ice_t_pwd_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.ice_t_pwd_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string options {
+ set {
+ freeswitchPINVOKE.ice_t_options_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.ice_t_options_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public ice_t() : this(freeswitchPINVOKE.new_ice_t(), true) {
+ }
+
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class input_callback_state_t : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
using System;
using System.Runtime.InteropServices;
+public class SWIGTYPE_p_a_2__icand_s {
+ private HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_a_2__icand_s(IntPtr cPtr, bool futureUse) {
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_a_2__icand_s() {
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ }
+
+ internal static HandleRef getCPtr(SWIGTYPE_p_a_2__icand_s obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class SWIGTYPE_p_apr_pool_t {
private HandleRef swigCPtr;
using System;
using System.Runtime.InteropServices;
+public class SWIGTYPE_p_f_p_switch_core_session_p_void__p_void {
+ private HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_f_p_switch_core_session_p_void__p_void(IntPtr cPtr, bool futureUse) {
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_f_p_switch_core_session_p_void__p_void() {
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ }
+
+ internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_p_void__p_void obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class SWIGTYPE_p_f_p_switch_core_session__switch_status_t {
private HandleRef swigCPtr;
using System;
using System.Runtime.InteropServices;
+public class SWIGTYPE_p_switch_core_media_ice_type_t {
+ private HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_switch_core_media_ice_type_t(IntPtr cPtr, bool futureUse) {
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_switch_core_media_ice_type_t() {
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ }
+
+ internal static HandleRef getCPtr(SWIGTYPE_p_switch_core_media_ice_type_t obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class SWIGTYPE_p_switch_core_port_allocator {
private HandleRef swigCPtr;
using System;
using System.Runtime.InteropServices;
+public class SWIGTYPE_p_switch_rtp_flag_t {
+ private HandleRef swigCPtr;
+
+ internal SWIGTYPE_p_switch_rtp_flag_t(IntPtr cPtr, bool futureUse) {
+ swigCPtr = new HandleRef(this, cPtr);
+ }
+
+ protected SWIGTYPE_p_switch_rtp_flag_t() {
+ swigCPtr = new HandleRef(null, IntPtr.Zero);
+ }
+
+ internal static HandleRef getCPtr(SWIGTYPE_p_switch_rtp_flag_t obj) {
+ return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
+ }
+}
+
+}
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.35
+ *
+ * Do not make changes to this file unless you know what you are doing--modify
+ * the SWIG interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+namespace FreeSWITCH.Native {
+
+using System;
+using System.Runtime.InteropServices;
+
public class SWIGTYPE_p_switch_say_file_handle {
private HandleRef swigCPtr;
SWITCH_ABC_TYPE_WRITE_REPLACE,
SWITCH_ABC_TYPE_READ_REPLACE,
SWITCH_ABC_TYPE_READ_PING,
+ SWITCH_ABC_TYPE_TAP_NATIVE_READ,
+ SWITCH_ABC_TYPE_TAP_NATIVE_WRITE,
SWITCH_ABC_TYPE_CLOSE
}
}
}
+ public string orig_caller_id_name {
+ set {
+ freeswitchPINVOKE.switch_caller_profile_orig_caller_id_name_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.switch_caller_profile_orig_caller_id_name_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public string orig_caller_id_number {
+ set {
+ freeswitchPINVOKE.switch_caller_profile_orig_caller_id_number_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.switch_caller_profile_orig_caller_id_number_get(swigCPtr);
+ return ret;
+ }
+ }
+
public string callee_id_name {
set {
freeswitchPINVOKE.switch_caller_profile_callee_id_name_set(swigCPtr, value);
CF_JITTERBUFFER,
CF_JITTERBUFFER_PLC,
CF_DIALPLAN,
+ CF_BLEG,
CF_BLOCK_BROADCAST_UNTIL_MEDIA,
CF_CNG_PLC,
CF_ATTENDED_TRANSFER,
CF_EARLY_OK,
CF_MEDIA_TRANS,
CF_HOLD_ON_BRIDGE,
+ CF_SECURE,
+ CF_CRYPTO_RECOVER,
+ CF_LIBERAL_DTMF,
+ CF_SLA_BARGE,
+ CF_SLA_BARGING,
+ CF_PROTO_HOLD,
+ CF_HOLD_LOCK,
+ CF_VIDEO_POSSIBLE,
+ CF_NOTIMER_DURING_BRIDGE,
+ CF_PASS_RFC2833,
+ CF_T38_PASSTHRU,
+ CF_DROP_DTMF,
+ CF_REINVITE,
+ CF_AUTOFLUSH_DURING_BRIDGE,
+ CF_RTP_NOTIMER_DURING_BRIDGE,
+ CF_WEBRTC,
+ CF_WEBRTC_MOZ,
+ CF_ICE,
+ CF_DTLS,
+ CF_VERBOSE_SDP,
+ CF_DTLS_OK,
CF_FLAG_MAX
}
}
}
+ public string certs_dir {
+ set {
+ freeswitchPINVOKE.switch_directories_certs_dir_set(swigCPtr, value);
+ }
+ get {
+ string ret = freeswitchPINVOKE.switch_directories_certs_dir_get(swigCPtr);
+ return ret;
+ }
+ }
+
public switch_directories() : this(freeswitchPINVOKE.new_switch_directories(), true) {
}
}
}
+ public int max_samples {
+ set {
+ freeswitchPINVOKE.switch_file_handle_max_samples_set(swigCPtr, value);
+ }
+ get {
+ int ret = freeswitchPINVOKE.switch_file_handle_max_samples_get(swigCPtr);
+ return ret;
+ }
+ }
+
+ public switch_event params {
+ set {
+ freeswitchPINVOKE.switch_file_handle_params_set(swigCPtr, switch_event.getCPtr(value));
+ }
+ get {
+ IntPtr cPtr = freeswitchPINVOKE.switch_file_handle_params_get(swigCPtr);
+ switch_event ret = (cPtr == IntPtr.Zero) ? null : new switch_event(cPtr, false);
+ return ret;
+ }
+ }
+
public switch_file_handle() : this(freeswitchPINVOKE.new_switch_file_handle(), true) {
}
SFF_DYNAMIC = (1 << 6),
SFF_ZRTP = (1 << 7),
SFF_UDPTL_PACKET = (1 << 8),
- SFF_NOT_AUDIO = (1 << 9)
+ SFF_NOT_AUDIO = (1 << 9),
+ SFF_RTCP = (1 << 10)
}
}
SMBF_READ_PING = (1 << 4),
SMBF_STEREO = (1 << 5),
SMBF_ANSWER_REQ = (1 << 6),
- SMBF_THREAD_LOCK = (1 << 7),
- SMBF_PRUNE = (1 << 8),
- SMBF_NO_PAUSE = (1 << 9),
- SMBF_STEREO_SWAP = (1 << 10),
- SMBF_LOCK = (1 << 11)
+ SMBF_BRIDGE_REQ = (1 << 7),
+ SMBF_THREAD_LOCK = (1 << 8),
+ SMBF_PRUNE = (1 << 9),
+ SMBF_NO_PAUSE = (1 << 10),
+ SMBF_STEREO_SWAP = (1 << 11),
+ SMBF_LOCK = (1 << 12),
+ SMBF_TAP_NATIVE_READ = (1 << 13),
+ SMBF_TAP_NATIVE_WRITE = (1 << 14),
+ SMBF_ONE_ONLY = (1 << 15),
+ SMBF_MASK = (1 << 16)
}
}
public enum switch_rtp_crypto_direction_t {
SWITCH_RTP_CRYPTO_SEND,
SWITCH_RTP_CRYPTO_RECV,
+ SWITCH_RTP_CRYPTO_SEND_RTCP,
+ SWITCH_RTP_CRYPTO_RECV_RTCP,
SWITCH_RTP_CRYPTO_MAX
}
NO_CRYPTO,
AES_CM_128_HMAC_SHA1_80,
AES_CM_128_HMAC_SHA1_32,
+ AES_CM_256_HMAC_SHA1_80,
AES_CM_128_NULL_AUTH
}
namespace FreeSWITCH.Native {
-[System.Flags] public enum switch_rtp_flag_enum_t {
- SWITCH_RTP_FLAG_NOBLOCK = (1 << 0),
- SWITCH_RTP_FLAG_IO = (1 << 1),
- SWITCH_RTP_FLAG_USE_TIMER = (1 << 2),
- SWITCH_RTP_FLAG_RTCP_PASSTHRU = (1 << 3),
- SWITCH_RTP_FLAG_SECURE_SEND = (1 << 4),
- SWITCH_RTP_FLAG_SECURE_RECV = (1 << 5),
- SWITCH_RTP_FLAG_AUTOADJ = (1 << 6),
- SWITCH_RTP_FLAG_RAW_WRITE = (1 << 7),
- SWITCH_RTP_FLAG_GOOGLEHACK = (1 << 8),
- SWITCH_RTP_FLAG_VAD = (1 << 9),
- SWITCH_RTP_FLAG_BREAK = (1 << 10),
- SWITCH_RTP_FLAG_UDPTL = (1 << 11),
- SWITCH_RTP_FLAG_DATAWAIT = (1 << 12),
- SWITCH_RTP_FLAG_BYTESWAP = (1 << 13),
- SWITCH_RTP_FLAG_PASS_RFC2833 = (1 << 14),
- SWITCH_RTP_FLAG_AUTO_CNG = (1 << 15),
- SWITCH_RTP_FLAG_SECURE_SEND_RESET = (1 << 16),
- SWITCH_RTP_FLAG_SECURE_RECV_RESET = (1 << 17),
- SWITCH_RTP_FLAG_PROXY_MEDIA = (1 << 18),
- SWITCH_RTP_FLAG_SHUTDOWN = (1 << 19),
- SWITCH_RTP_FLAG_FLUSH = (1 << 20),
- SWITCH_RTP_FLAG_AUTOFLUSH = (1 << 21),
- SWITCH_RTP_FLAG_STICKY_FLUSH = (1 << 22),
- SWITCH_ZRTP_FLAG_SECURE_SEND = (1 << 23),
- SWITCH_ZRTP_FLAG_SECURE_RECV = (1 << 24),
- SWITCH_ZRTP_FLAG_SECURE_MITM_SEND = (1 << 25),
- SWITCH_ZRTP_FLAG_SECURE_MITM_RECV = (1 << 26),
- SWITCH_RTP_FLAG_DEBUG_RTP_READ = (1 << 27),
- SWITCH_RTP_FLAG_DEBUG_RTP_WRITE = (1 << 28),
- SWITCH_RTP_FLAG_VIDEO = (1 << 29),
- SWITCH_RTP_FLAG_ENABLE_RTCP = (1 << 30)
+public enum switch_rtp_flag_t {
+ SWITCH_RTP_FLAG_NOBLOCK = 0,
+ SWITCH_RTP_FLAG_IO,
+ SWITCH_RTP_FLAG_USE_TIMER,
+ SWITCH_RTP_FLAG_RTCP_PASSTHRU,
+ SWITCH_RTP_FLAG_SECURE_SEND,
+ SWITCH_RTP_FLAG_SECURE_RECV,
+ SWITCH_RTP_FLAG_AUTOADJ,
+ SWITCH_RTP_FLAG_RAW_WRITE,
+ SWITCH_RTP_FLAG_GOOGLEHACK,
+ SWITCH_RTP_FLAG_VAD,
+ SWITCH_RTP_FLAG_BREAK,
+ SWITCH_RTP_FLAG_UDPTL,
+ SWITCH_RTP_FLAG_DATAWAIT,
+ SWITCH_RTP_FLAG_BYTESWAP,
+ SWITCH_RTP_FLAG_PASS_RFC2833,
+ SWITCH_RTP_FLAG_AUTO_CNG,
+ SWITCH_RTP_FLAG_SECURE_SEND_RESET,
+ SWITCH_RTP_FLAG_SECURE_RECV_RESET,
+ SWITCH_RTP_FLAG_PROXY_MEDIA,
+ SWITCH_RTP_FLAG_SHUTDOWN,
+ SWITCH_RTP_FLAG_FLUSH,
+ SWITCH_RTP_FLAG_AUTOFLUSH,
+ SWITCH_RTP_FLAG_STICKY_FLUSH,
+ SWITCH_ZRTP_FLAG_SECURE_SEND,
+ SWITCH_ZRTP_FLAG_SECURE_RECV,
+ SWITCH_ZRTP_FLAG_SECURE_MITM_SEND,
+ SWITCH_ZRTP_FLAG_SECURE_MITM_RECV,
+ SWITCH_RTP_FLAG_DEBUG_RTP_READ,
+ SWITCH_RTP_FLAG_DEBUG_RTP_WRITE,
+ SWITCH_RTP_FLAG_VIDEO,
+ SWITCH_RTP_FLAG_ENABLE_RTCP,
+ SWITCH_RTP_FLAG_RTCP_MUX,
+ SWITCH_RTP_FLAG_INVALID
}
}
projects / thirdparty / freeswitch.git / commitdiff
