diff --git a/libs/srtp/libsrtp.2010.vcxproj b/libs/srtp/libsrtp.2010.vcxproj index f16277300e..554e943fe0 100644 --- a/libs/srtp/libsrtp.2010.vcxproj +++ b/libs/srtp/libsrtp.2010.vcxproj @@ -340,6 +340,7 @@ + diff --git a/libs/srtp/libsrtp.2012.vcxproj b/libs/srtp/libsrtp.2012.vcxproj index 941780b1df..331131a10e 100644 --- a/libs/srtp/libsrtp.2012.vcxproj +++ b/libs/srtp/libsrtp.2012.vcxproj @@ -1,4 +1,4 @@ - + @@ -348,6 +348,7 @@ + @@ -417,4 +418,4 @@ - + \ No newline at end of file diff --git a/libs/srtp/srtp/ekt.c b/libs/srtp/srtp/ekt.c index 9ae7f7e5c8..03300691f8 100644 --- a/libs/srtp/srtp/ekt.c +++ b/libs/srtp/srtp/ekt.c @@ -47,6 +47,10 @@ #include "srtp_priv.h" #include "ekt.h" +#ifdef _MSC_VER +#pragma warning(disable:4100) +#endif + extern debug_module_t mod_srtp; /* diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx index bf0b7ba491..d2740f8ccd 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx @@ -1210,6 +1210,26 @@ 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 ; @@ -1330,6 +1350,16 @@ 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 ; @@ -2710,6 +2740,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 ; @@ -4250,6 +4310,16 @@ 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 ; @@ -6308,6 +6378,161 @@ 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-1); + arg1->str[192-1] = 0; + } 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; @@ -8405,6 +8630,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 ; @@ -8469,6 +8706,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 ; @@ -12004,6 +12251,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 ; @@ -12416,6 +12677,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 ; @@ -13814,6 +14127,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 ; + switch_size_t *argp3 ; + char *result = 0 ; + + 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; @@ -14798,6 +15133,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 ; @@ -26003,6 +26351,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 ; @@ -31076,6 +31432,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 ; @@ -32418,6 +32790,512 @@ 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 ; @@ -32561,13 +33439,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 ; @@ -32577,7 +33455,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; @@ -32587,7 +33465,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 ; @@ -32596,7 +33474,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 ; @@ -32609,7 +33487,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; @@ -32757,53 +33635,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_core_media_ice_type_t *argp7 ; switch_status_t result; arg1 = (switch_rtp_t *)jarg1; arg2 = (char *)jarg2; arg3 = (char *)jarg3; arg4 = (char *)jarg4; - result = (switch_status_t)switch_rtp_activate_ice(arg1,arg2,arg3,(char const *)arg4); + 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; } @@ -32883,7 +33759,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 ; @@ -32893,7 +33769,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 ; @@ -32907,7 +33803,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 ; @@ -33327,6 +34223,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.2010.cs b/src/mod/languages/mod_managed/managed/swig.2010.cs index 8b889f5777..f7b6dc1014 100644 --- a/src/mod/languages/mod_managed/managed/swig.2010.cs +++ b/src/mod/languages/mod_managed/managed/swig.2010.cs @@ -537,6 +537,133 @@ 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) { + if (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 2.0.1 + * + * 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 2.0.1 + * + * 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 2.0.1 + * + * 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; @@ -1630,6 +1757,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; @@ -1654,6 +1786,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); } @@ -2798,6 +2936,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; @@ -2943,6 +3086,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; @@ -3276,6 +3439,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; @@ -3597,6 +3766,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; @@ -3876,6 +4050,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); @@ -5109,6 +5287,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; @@ -5522,13 +5705,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; } @@ -5587,18 +5770,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; } @@ -5628,17 +5807,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) { @@ -5788,6 +5975,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; @@ -6421,6 +6618,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(); @@ -6433,6 +6632,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(); @@ -6501,6 +6701,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(); @@ -6535,6 +6736,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(); @@ -6548,6 +6752,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(); } @@ -7014,6 +7219,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(); @@ -7050,6 +7261,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(); @@ -7413,6 +7627,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(); @@ -7818,6 +8038,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); @@ -8346,6 +8569,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(); @@ -8841,6 +9103,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); @@ -8856,6 +9121,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); @@ -9654,6 +9922,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); @@ -9747,6 +10018,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); @@ -10083,6 +10366,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(); @@ -10275,6 +10561,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); @@ -13125,6 +13414,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); @@ -14220,6 +14512,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); @@ -14496,6 +14791,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); @@ -14530,10 +14942,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); @@ -14572,13 +14984,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); @@ -14596,13 +15005,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); @@ -14697,6 +15112,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); @@ -15999,6 +16420,292 @@ 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) { + if (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 2.0.1 + * + * 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 2.0.1 + * + * 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) { + if (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 2.0.1 + * + * 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; @@ -16461,6 +17168,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 2.0.1 + * + * 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_FILE { private HandleRef swigCPtr; @@ -20721,6 +21458,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 2.0.1 + * + * 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; @@ -21351,6 +22118,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 2.0.1 + * + * 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; @@ -24522,6 +25319,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 } @@ -27017,6 +27835,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) { } @@ -28990,7 +29818,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) } } @@ -31557,7 +32386,8 @@ namespace FreeSWITCH.Native { SMBF_STEREO_SWAP = (1 << 11), SMBF_LOCK = (1 << 12), SMBF_TAP_NATIVE_READ = (1 << 13), - SMBF_TAP_NATIVE_WRITE = (1 << 14) + SMBF_TAP_NATIVE_WRITE = (1 << 14), + SMBF_ONE_ONLY = (1 << 15) } } @@ -31934,6 +32764,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 } @@ -32055,6 +32887,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 } @@ -32069,38 +32902,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 } } diff --git a/src/switch_core_media.c b/src/switch_core_media.c index 79601ad982..13c09bdb22 100644 --- a/src/switch_core_media.c +++ b/src/switch_core_media.c @@ -1814,6 +1814,13 @@ static int dtls_ok(switch_core_session_t *session) return switch_channel_test_flag(session->channel, CF_DTLS_OK); } +#ifdef _MSC_VER +/* remove this if the break is removed from the following for loop which causes unreachable code loop */ +/* for (i = 0; i < engine->cand_acl_count; i++) { */ +#pragma warning(push) +#pragma warning(disable:4702) +#endif + //? static void check_ice(switch_media_handle_t *smh, switch_media_type_t type, sdp_session_t *sdp, sdp_media_t *m) { @@ -2051,6 +2058,9 @@ static void check_ice(switch_media_handle_t *smh, switch_media_type_t type, sdp_ } } +#ifdef _MSC_VER +#pragma warning(pop) +#endif SWITCH_DECLARE(void) switch_core_session_set_ice(switch_core_session_t *session) { @@ -6968,6 +6978,13 @@ SWITCH_DECLARE(void) switch_core_media_check_outgoing_proxy(switch_core_session_ } } +#ifdef _MSC_VER +/* remove this if the break is removed from the following for loop which causes unreachable code loop */ +/* for (m = sdp->sdp_media; m; m = m->m_next) { */ +#pragma warning(push) +#pragma warning(disable:4702) +#endif + //? SWITCH_DECLARE(void) switch_core_media_proxy_codec(switch_core_session_t *session, const char *r_sdp) { @@ -7038,6 +7055,9 @@ SWITCH_DECLARE(void) switch_core_media_proxy_codec(switch_core_session_t *sessio sdp_parser_free(parser); } +#ifdef _MSC_VER +#pragma warning(pop) +#endif SWITCH_DECLARE (void) switch_core_media_recover_session(switch_core_session_t *session) { diff --git a/src/switch_sdp.c b/src/switch_sdp.c index 4b1562c0dc..cbf91e1592 100644 --- a/src/switch_sdp.c +++ b/src/switch_sdp.c @@ -17,3 +17,7 @@ sdp_connection_t *sdp_media_connections(sdp_media_t const *m) #include #include #include +#ifdef _MSC_VER +#define longlong __int64 +#include +#endif \ No newline at end of file