diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.cxx index a0dd415580..dd81abf181 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.cxx @@ -1190,6 +1190,39 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_TRANSFER_SOURCE_VARIABLE_get() { } +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 ; @@ -1278,6 +1311,28 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VAR } +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 ; @@ -1410,6 +1465,17 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_SWITCH_API_BRIDGE_END_VARIABLE_get() { } +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 ; @@ -2864,6 +2930,36 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_directories_lib_dir_get(void * jarg1 } +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 ; @@ -4472,6 +4568,17 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_t38_options_t(void * jarg1) { } +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 ; @@ -6613,6 +6720,162 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) { } +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; @@ -7437,6 +7700,30 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_media_bug_get_write_replace_fra } +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 ; @@ -7637,6 +7924,24 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_media_bug_transfer_recordings(void } +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 ; @@ -8705,6 +9010,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_set_variable(char * jarg1, char * } +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 ; @@ -8769,6 +9086,16 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_core_session_findall_matching_var(ch } +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 ; @@ -12316,6 +12643,20 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_default_ptime(char * jarg1, u } +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 ; @@ -12728,6 +13069,58 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_fork() { } +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 ; @@ -14149,6 +14542,28 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_testv6_subnet(void * jarg1, void * jarg } +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; @@ -15135,6 +15550,19 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_string_match(char * jarg1, unsigned lon } +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 ; @@ -15757,6 +16185,64 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_caller_profile_caller_id_number_get( } +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 ; @@ -20844,6 +21330,52 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_file_handle_prefix_get(void * jarg1) } +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 ; @@ -26663,6 +27195,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_caller_profile(void * jarg } +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 ; @@ -26921,6 +27461,22 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_channel_del_variable_prefix(v } +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 ; @@ -27098,6 +27654,14 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_set_caller_extension(void * ja } +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 ; @@ -27106,13 +27670,11 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_flip_cid(void * jarg1) { } -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); } @@ -28082,6 +28644,18 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_state_thread_unlock(void * jar } +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 ; @@ -31114,6 +31688,20 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_record_session(void * jarg1, char * } +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 ; @@ -31768,6 +32356,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_hold_uuid(char * jarg1, char * jarg } +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 ; @@ -32902,6 +33506,22 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_ivr_blind_transfer_ack(void * jarg1, in } +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; @@ -33122,6 +33742,521 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_rtp_crypto_key(void * jarg1) { } +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 ; @@ -33265,13 +34400,13 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_change_interval(void * jarg1, unsig } -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 ; @@ -33281,7 +34416,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char 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; @@ -33291,7 +34426,7 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_create(void * jarg1, unsigned char } -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 ; @@ -33300,7 +34435,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short 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 ; @@ -33313,7 +34448,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_new(char * jarg1, unsigned short 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; @@ -33461,53 +34596,51 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_destroy(void * jarg1) { } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_rtp_activate_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_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_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_rtcp_ice(arg1,arg2,arg3,(char const *)arg4); - 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; } @@ -33587,7 +34720,7 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_switch_rtp_get_jitter_buffer(void * jarg1) } -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 ; @@ -33597,7 +34730,27 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_flag(void * jarg1, unsigned lo } -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 ; @@ -33611,7 +34764,7 @@ SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_rtp_test_flag(void * jarg1, u } -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 ; @@ -34031,6 +35184,34 @@ SWIGEXPORT void SWIGSTDCALL CSharp_switch_rtp_set_interdigit_delay(void * jarg1, } +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 ; diff --git a/src/mod/languages/mod_managed/managed/swig.cs b/src/mod/languages/mod_managed/managed/swig.cs index 4aba6331e2..81a9e258fc 100644 --- a/src/mod/languages/mod_managed/managed/swig.cs +++ b/src/mod/languages/mod_managed/managed/swig.cs @@ -531,6 +531,131 @@ namespace FreeSWITCH.Native { 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; @@ -596,7 +721,8 @@ public class DTMF : IDisposable { 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) } } @@ -1116,6 +1242,18 @@ public class freeswitch { 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)); } @@ -1195,6 +1333,11 @@ public class freeswitch { 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; @@ -1605,6 +1748,11 @@ public class freeswitch { 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; @@ -1629,6 +1777,12 @@ public class freeswitch { 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); } @@ -2773,6 +2927,11 @@ public class freeswitch { 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; @@ -2918,6 +3077,26 @@ public class freeswitch { 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; @@ -3251,6 +3430,12 @@ public class freeswitch { 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; @@ -3572,6 +3757,11 @@ public class freeswitch { 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; @@ -3851,6 +4041,10 @@ public class freeswitch { 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); @@ -3946,6 +4140,11 @@ public class freeswitch { 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; @@ -4007,12 +4206,16 @@ public class freeswitch { 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) { @@ -4372,6 +4575,11 @@ public class freeswitch { 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(); @@ -4898,6 +5106,11 @@ public class freeswitch { 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; @@ -5079,6 +5292,11 @@ public class freeswitch { 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; @@ -5440,6 +5658,11 @@ public class freeswitch { 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(); @@ -5492,13 +5715,13 @@ public class freeswitch { 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; } @@ -5557,18 +5780,14 @@ public class freeswitch { 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); + 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_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); - 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; } @@ -5598,17 +5817,25 @@ public class freeswitch { 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) { @@ -5758,6 +5985,16 @@ public class freeswitch { 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; @@ -6382,6 +6619,9 @@ public class freeswitch { 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(); @@ -6390,6 +6630,8 @@ public class freeswitch { 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(); @@ -6402,6 +6644,7 @@ public class freeswitch { 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(); @@ -6470,6 +6713,7 @@ public class freeswitch { 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(); @@ -6504,6 +6748,9 @@ public class freeswitch { 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(); @@ -6517,6 +6764,7 @@ public class freeswitch { 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(); } @@ -6952,6 +7200,15 @@ class freeswitchPINVOKE { [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(); @@ -6976,6 +7233,12 @@ class freeswitchPINVOKE { [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(); @@ -7012,6 +7275,9 @@ class freeswitchPINVOKE { [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(); @@ -7375,6 +7641,12 @@ class freeswitchPINVOKE { [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(); @@ -7780,6 +8052,9 @@ class freeswitchPINVOKE { [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); @@ -8308,6 +8583,45 @@ class freeswitchPINVOKE { [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(); @@ -8503,6 +8817,12 @@ class freeswitchPINVOKE { [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); @@ -8551,6 +8871,9 @@ class freeswitchPINVOKE { [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); @@ -8797,6 +9120,9 @@ class freeswitchPINVOKE { [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); @@ -8812,6 +9138,9 @@ class freeswitchPINVOKE { [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); @@ -9610,6 +9939,9 @@ class freeswitchPINVOKE { [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); @@ -9703,6 +10035,18 @@ class freeswitchPINVOKE { [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); @@ -10039,6 +10383,9 @@ class freeswitchPINVOKE { [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(); @@ -10231,6 +10578,9 @@ class freeswitchPINVOKE { [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); @@ -10357,6 +10707,18 @@ class freeswitchPINVOKE { [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); @@ -11614,6 +11976,18 @@ class freeswitchPINVOKE { [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(); @@ -13069,6 +13443,9 @@ class freeswitchPINVOKE { [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); @@ -13126,6 +13503,9 @@ class freeswitchPINVOKE { [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); @@ -13165,11 +13545,14 @@ class freeswitchPINVOKE { [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); @@ -13396,6 +13779,9 @@ class freeswitchPINVOKE { [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); @@ -14053,6 +14439,9 @@ class freeswitchPINVOKE { [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); @@ -14161,6 +14550,9 @@ class freeswitchPINVOKE { [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); @@ -14380,6 +14772,9 @@ class freeswitchPINVOKE { [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(); @@ -14437,6 +14832,123 @@ class freeswitchPINVOKE { [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_icand_t_foundation_set")] + public static extern void icand_t_foundation_set(HandleRef jarg1, string 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_icand_t_component_id_set")] + public static extern void icand_t_component_id_set(HandleRef jarg1, int jarg2); + + [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_icand_t_transport_set")] + public static extern void icand_t_transport_set(HandleRef jarg1, string 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_icand_t_priority_set")] + public static extern void icand_t_priority_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_icand_t_priority_get")] + public static extern uint icand_t_priority_get(HandleRef jarg1); + + [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_icand_t_con_addr_get")] + public static extern string icand_t_con_addr_get(HandleRef jarg1); + + [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_icand_t_con_port_get")] + public static extern ushort icand_t_con_port_get(HandleRef jarg1); + + [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_icand_t_cand_type_get")] + public static extern string icand_t_cand_type_get(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_icand_t_raddr_get")] + public static extern string icand_t_raddr_get(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_icand_t_rport_get")] + public static extern ushort icand_t_rport_get(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_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); @@ -14471,10 +14983,10 @@ class freeswitchPINVOKE { 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, uint jarg5, string jarg6, ref string jarg7, HandleRef jarg8); + 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, uint jarg8, string jarg9, ref string jarg10, HandleRef jarg11); + 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); @@ -14513,13 +15025,10 @@ class freeswitchPINVOKE { 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); @@ -14537,13 +15046,19 @@ class freeswitchPINVOKE { 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); @@ -14638,6 +15153,12 @@ class freeswitchPINVOKE { [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); @@ -15940,6 +16461,288 @@ namespace FreeSWITCH.Native { 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; @@ -16360,6 +17163,36 @@ namespace FreeSWITCH.Native { 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; @@ -17770,6 +18603,36 @@ namespace FreeSWITCH.Native { 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; @@ -20620,6 +21483,36 @@ namespace FreeSWITCH.Native { 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; @@ -21280,6 +22173,36 @@ namespace FreeSWITCH.Native { 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; @@ -21794,6 +22717,8 @@ public enum switch_abc_type_t { 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 } @@ -23876,6 +24801,26 @@ public class switch_caller_profile : IDisposable { } } + 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); @@ -24391,6 +25336,7 @@ public enum switch_channel_flag_t { CF_JITTERBUFFER, CF_JITTERBUFFER_PLC, CF_DIALPLAN, + CF_BLEG, CF_BLOCK_BROADCAST_UNTIL_MEDIA, CF_CNG_PLC, CF_ATTENDED_TRANSFER, @@ -24419,6 +25365,27 @@ public enum switch_channel_flag_t { 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 } @@ -26882,6 +27849,16 @@ public class switch_directories : IDisposable { } } + 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) { } @@ -28335,6 +29312,27 @@ public class switch_file_handle : IDisposable { } } + 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) { } @@ -28816,7 +29814,8 @@ namespace FreeSWITCH.Native { 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) } } @@ -31332,11 +32331,16 @@ namespace FreeSWITCH.Native { 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) } } @@ -31709,6 +32713,8 @@ namespace FreeSWITCH.Native { 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 } @@ -31828,6 +32834,7 @@ public enum switch_rtp_crypto_key_type_t { 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 } @@ -31842,38 +32849,40 @@ public enum switch_rtp_crypto_key_type_t { 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 } }