apr_hash_this(hi, key, klen, val);
}
-
SWITCH_DECLARE(switch_memory_pool_t *) switch_hash_pool_get(switch_hash_t * ht)
{
return apr_hash_pool_get(ht);
return apr_hashfunc_default(key, klen);
}
-
/* DSO functions */
SWITCH_DECLARE(switch_status_t) switch_dso_load(switch_dso_handle_t ** res_handle, const char *path, switch_memory_pool_t *ctx)
return apr_dso_error(dso, buf, bufsize);
}
-
/* string functions */
SWITCH_DECLARE(switch_status_t) switch_strftime(char *s, switch_size_t *retsize, switch_size_t max, const char *format, switch_time_exp_t * tm)
return ((switch_time_t) (sec) * APR_USEC_PER_SEC + (switch_time_t) (usec));
}
-
/* Thread condition locks */
SWITCH_DECLARE(switch_status_t) switch_thread_cond_create(switch_thread_cond_t ** cond, switch_memory_pool_t *pool)
/* #define SWITCH_FPROT_OS_DEFAULT 0x0FFF /\**< use OS's default permissions *\/ */
-
/**
* Create a new directory on the file system.
* @param path the path for the directory to be created. (use / on all systems)
return apr_dir_make_recursive(path, perm, pool);
}
-
struct switch_dir {
apr_dir_t *dir_handle;
apr_finfo_t finfo;
return fname;
}
-
/* thread stubs */
-
SWITCH_DECLARE(switch_status_t) switch_threadattr_create(switch_threadattr_t ** new_attr, switch_memory_pool_t *pool)
{
return apr_threadattr_create(new_attr, pool);
return apr_socket_connect(sock, sa);
}
-
SWITCH_DECLARE(switch_status_t) switch_socket_send(switch_socket_t * sock, const char *buf, switch_size_t *len)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
return SWITCH_STATUS_SUCCESS;
}
-
-
-
-
/* apr-util stubs */
/* UUID Handling (apr-util) */
-
SWITCH_DECLARE(void) switch_uuid_format(char *buffer, const switch_uuid_t * uuid)
{
apr_uuid_format(buffer, (const apr_uuid_t *) uuid);
return apr_uuid_parse((apr_uuid_t *) uuid, uuid_str);
}
-
/* FIFO queues (apr-util) */
SWITCH_DECLARE(switch_status_t) switch_queue_create(switch_queue_t ** queue, unsigned int queue_capacity, switch_memory_pool_t *pool)
{
return apr_match_glob(pattern, (apr_array_header_t **)result, p);
}
-
/* For Emacs:
* Local Variables:
* switch_buffer.c -- Data Buffering Code
*
*/
+
#include <switch.h>
#include <switch_buffer.h>
}
-
SWITCH_DECLARE(switch_size_t) switch_buffer_freespace(switch_buffer_t *buffer)
{
switch_assert(buffer != NULL);
* switch_caller.c -- Caller Identification
*
*/
+
#include <switch.h>
#include <switch_caller.h>
-
#define profile_dup(a,b,p) if (!switch_strlen_zero(a)) { b = switch_core_strdup(p, a); } else { b = SWITCH_BLANK_STRING; }
#define profile_dup_clean(a,b,p) if (!switch_strlen_zero(a)) { b = switch_clean_string(switch_core_strdup(p, a)); } else { b = SWITCH_BLANK_STRING; }
const char *context,
const char *destination_number)
{
-
-
switch_caller_profile_t *profile = NULL;
profile = switch_core_alloc(pool, sizeof(*profile));
return profile;
}
-
SWITCH_DECLARE(switch_caller_profile_t *) switch_caller_profile_dup(switch_memory_pool_t *pool, switch_caller_profile_t *tocopy)
{
switch_caller_profile_t *profile = NULL;
return profile;
}
-
SWITCH_DECLARE(switch_caller_profile_t *) switch_caller_profile_clone(switch_core_session_t *session, switch_caller_profile_t *tocopy)
{
switch_memory_pool_t *pool;
return switch_caller_profile_dup(pool, tocopy);
}
-
SWITCH_DECLARE(const char *) switch_caller_get_field_by_name(switch_caller_profile_t *caller_profile, const char *name)
{
if (!strcasecmp(name, "dialplan")) {
{
char header_name[1024];
-
if (!switch_strlen_zero(caller_profile->username)) {
switch_snprintf(header_name, sizeof(header_name), "%s-Username", prefix);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, "%s", caller_profile->username);
switch_snprintf(header_name, sizeof(header_name), "%s-Privacy-Hide-Number", prefix);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, header_name, switch_test_flag(caller_profile, SWITCH_CPF_HIDE_NUMBER) ? "yes" : "no");
-
-
-
}
SWITCH_DECLARE(switch_caller_extension_t *) switch_caller_extension_new(switch_core_session_t *session, const char *extension_name, const char *extension_number)
return caller_extension;
}
-
SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session_t *session,
switch_caller_extension_t *caller_extension, const char *application_name, const char *application_data)
{
* switch_channel.c -- Media Channel Interface
*
*/
+
#include <switch.h>
#include <switch_channel.h>
int event_count;
};
-
SWITCH_DECLARE(const char *) switch_channel_cause2str(switch_call_cause_t cause)
{
uint8_t x;
}
}
-
status = SWITCH_STATUS_SUCCESS;
done:
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf_string(switch_channel_t *channel, const char *dtmf_string)
{
char *p;
}
return status;
-
}
SWITCH_DECLARE(switch_size_t) switch_channel_dequeue_dtmf_string(switch_channel_t *channel, char *dtmf_str, switch_size_t len)
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", channel->event_count++);
switch_event_fire(&event);
}
-
}
-
SWITCH_DECLARE(const char *) switch_channel_get_variable(switch_channel_t *channel, const char *varname)
{
const char *v = NULL;
}
return hi;
-
}
SWITCH_DECLARE(switch_status_t) switch_channel_set_private(switch_channel_t *channel, const char *key, const void *private_info)
return SWITCH_STATUS_SUCCESS;
}
-
SWITCH_DECLARE(char *) switch_channel_get_name(switch_channel_t *channel)
{
switch_assert(channel != NULL);
}
}
-
switch_mutex_unlock(channel->flag_mutex);
return SWITCH_STATUS_SUCCESS;
switch_channel_state_t last_state;
int ok = 0;
-
switch_assert(channel != NULL);
switch_assert(state <= CS_DONE);
switch_mutex_lock(channel->flag_mutex);
}
-
if (ok) {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_DEBUG, "%s State Change %s -> %s\n",
channel->name, state_names[last_state], state_names[state]);
if (state < CS_DONE) {
switch_core_session_signal_state_change(channel->session);
}
-
} else {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_WARNING,
"%s Invalid State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]);
if (caller_profile) {
switch_caller_profile_event_set_data(caller_profile, "Caller", event);
}
-
if (originator_caller_profile && originatee_caller_profile) {
/* Index Originator's Profile */
}
switch_mutex_unlock(channel->profile_mutex);
-
}
SWITCH_DECLARE(void) switch_channel_set_caller_profile(switch_channel_t *channel, switch_caller_profile_t *caller_profile)
channel->caller_profile->originatee_caller_profile = caller_profile;
}
switch_assert(channel->caller_profile->originatee_caller_profile->next != channel->caller_profile->originatee_caller_profile);
- switch_mutex_unlock(channel->profile_mutex);
-
+ switch_mutex_unlock(channel->profile_mutex);
}
SWITCH_DECLARE(switch_caller_profile_t *) switch_channel_get_originator_caller_profile(switch_channel_t *channel)
}
switch_mutex_unlock(channel->flag_mutex);
-
}
SWITCH_DECLARE(void) switch_channel_set_caller_extension(switch_channel_t *channel, switch_caller_extension_t *caller_extension)
return channel->state;
}
-
SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_ring_ready(switch_channel_t *channel, const char *file, const char *func, int line)
{
if (!switch_channel_test_flag(channel, CF_RING_READY)) {
return SWITCH_STATUS_FALSE;
}
-
-
SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_pre_answered(switch_channel_t *channel, const char *file, const char *func, int line)
{
switch_event_t *event;
legbillusec = caller_profile->times->hungup - caller_profile->times->profile_created;
}
}
-
-
+
switch_channel_set_variable(channel, "last_app", last_app);
switch_channel_set_variable(channel, "last_arg", last_arg);
switch_channel_set_variable(channel, "caller_id", cid_buf);
* switch_config.c -- Configuration File Parser
*
*/
+
#include <switch.h>
#include <switch_config.h>
}
}
-
SWITCH_DECLARE(void) switch_config_close_file(switch_config_t * cfg)
{
memset(cfg, 0, sizeof(*cfg));
}
-
-
SWITCH_DECLARE(int) switch_config_next_pair(switch_config_t * cfg, char **var, char **val)
{
int ret = 0;
continue;
}
-
-
if (**var == '#' || **var == ';' || **var == '\n' || **var == '\r') {
continue;
}
break;
}
-
if ((end = strchr(*var, '#')) != 0 || (end = strchr(*var, ';')) != 0) {
*end = '\0';
end--;
}
*var = p;
-
if ((*val = strchr(*var, '=')) == 0) {
ret = -1;
/* log_printf(0, server.log, "Invalid syntax on %s: line %d\n", cfg->path, cfg->lineno); */
}
}
-
return ret;
-
}
/* For Emacs:
* switch_console.c -- Simple Console
*
*/
+
#include <switch.h>
#include <switch_console.h>
#include <switch_version.h>
switch_size_t remaining = handle->data_size - handle->data_len;
switch_size_t need = strlen(data) + 1;
-
if ((remaining < need) && handle->alloc_len) {
switch_size_t new_len;
void *new_data;
return ret ? SWITCH_STATUS_FALSE : SWITCH_STATUS_SUCCESS;
}
-
static int switch_console_process(char *cmd)
{
char *arg = NULL;
switch_event_fire(&event);
}
-
done:
if (data) {
free(data);
}
return prompt_str;
-
}
static EditLine *el;
el_set(el, EL_HIST, history, myhistory);
history(myhistory, &ev, H_LOAD, hfile);
-
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
/* Clean up our memory */
history_end(myhistory);
el_end(el);
-
-
}
#else
continue;
}
#endif
-
-
memset(&cmd, 0, sizeof(cmd));
for (x = 0; x < (sizeof(cmd) - 1); x++) {
int c = getchar();
running = switch_console_process(cmd);
}
}
-
-
}
#endif
return runtime.state_handlers[index];
}
-
SWITCH_DECLARE(char *) switch_core_get_variable(const char *varname)
{
char *val;
switch_core_session_launch_thread(session, switch_core_service_thread, thread_session);
}
-
/* This function abstracts the thread creation for modules by allowing you to pass a function ptr and
a void object and trust that that the function will be run in a thread with arg This lets
you request and activate a thread without giving up any knowledge about what is in the thread
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&thread, thd_attr, func, ts, pool);
}
-
}
SWITCH_DECLARE(void) switch_core_set_globals(void)
#endif
#endif
}
-
dir_path = switch_mprintf("%s%ssounds", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR);
switch_dir_make_recursive(dir_path,
runtime.memory_pool);
switch_safe_free(dir_path);
-
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.base_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.mod_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.conf_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.htdocs_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.grammar_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
switch_dir_make_recursive(SWITCH_GLOBAL_dirs.temp_dir, SWITCH_DEFAULT_DIR_PERMS, runtime.memory_pool);
-
-
-
}
-
SWITCH_DECLARE(int32_t) set_high_priority(void)
{
#ifdef WIN32
close(fd);
fd = -1;
}
-
}
-
SWITCH_DECLARE(void) switch_core_setrlimits(void)
{
#ifdef HAVE_SETRLIMIT
return;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_init(switch_core_flag_t flags, switch_bool_t console, const char **err)
{
switch_xml_t xml = NULL, cfg = NULL;
switch_find_local_ip(guess_ip, sizeof(guess_ip), AF_INET6);
switch_core_set_variable("local_ip_v6", guess_ip);
switch_core_set_variable("base_dir", SWITCH_GLOBAL_dirs.base_dir);
-
-
if (switch_xml_init(runtime.memory_pool, err) != SWITCH_STATUS_SUCCESS) {
apr_terminate();
rlp.rlim_max = RLIM_INFINITY;
setrlimit(RLIMIT_CORE, &rlp);
#endif
-
} else if (!strcasecmp(var, "mailer-app")) {
runtime.mailer_app = switch_core_strdup(runtime.memory_pool, val);
} else if (!strcasecmp(var, "mailer-app-args")) {
switch_scheduler_add_task(switch_timestamp(NULL), heartbeat_callback, "heartbeat", "core", 0, NULL, SSHF_NONE | SSHF_NO_DEL);
-
switch_uuid_get(&uuid);
switch_uuid_format(runtime.uuid_str, &uuid);
return 0;
}
-
SWITCH_DECLARE(switch_core_flag_t) switch_core_flags(void)
{
return runtime.flags;
return (switch_test_flag((&runtime), SCF_SHUTTING_DOWN) || switch_test_flag((&runtime), SCF_NO_NEW_SESSIONS)) ? SWITCH_FALSE : SWITCH_TRUE;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_destroy(void)
{
switch_event_t *event;
switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
switch_set_flag((&runtime), SCF_SHUTTING_DOWN);
-
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "End existing sessions\n");
switch_core_session_hupall(SWITCH_CAUSE_SYSTEM_SHUTDOWN);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Clean up modules.\n");
switch_safe_free(SWITCH_GLOBAL_dirs.grammar_dir);
switch_safe_free(SWITCH_GLOBAL_dirs.temp_dir);
-
switch_core_hash_destroy(&runtime.global_vars);
switch_core_hash_destroy(&runtime.mime_types);
* switch_core_asr.c -- Main Core Library (Speech Detection Interface)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
* switch_core_codec.c -- Main Core Library (codec functions)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
switch_assert(session != NULL);
channel = switch_core_session_get_channel(session);
-
if (switch_event_create(&event, SWITCH_EVENT_CODEC) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(session->channel, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "channel-write-codec-name", "%s", codec->implementation->iananame);
memset(codec, 0, sizeof(*codec));
-
if (channels == 2) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Stereo is currently unsupported. please downsample audio source to mono.\n");
return SWITCH_STATUS_GENERR;
}
return SWITCH_STATUS_NOTIMPL;
-
}
SWITCH_DECLARE(switch_status_t) switch_core_codec_encode(switch_codec_t *codec,
return SWITCH_STATUS_GENERR;
}
-
return codec->implementation->encode(codec, other_codec, decoded_data, decoded_data_len, decoded_rate, encoded_data, encoded_data_len, encoded_rate,
flag);
-
}
SWITCH_DECLARE(switch_status_t) switch_core_codec_decode(switch_codec_t *codec,
uint32_t encoded_rate,
void *decoded_data, uint32_t * decoded_data_len, uint32_t * decoded_rate, unsigned int *flag)
{
-
switch_assert(codec != NULL);
switch_assert(encoded_data != NULL);
switch_assert(decoded_data != NULL);
-
-
if (!codec->implementation) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Codec is not initialized!\n");
return SWITCH_STATUS_GENERR;
return SWITCH_STATUS_GENERR;
}
-
return codec->implementation->decode(codec, other_codec, encoded_data, encoded_data_len, encoded_rate, decoded_data, decoded_data_len, decoded_rate,
flag);
-
}
SWITCH_DECLARE(switch_status_t) switch_core_codec_destroy(switch_codec_t *codec)
return SWITCH_STATUS_SUCCESS;
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
}
}
-
SWITCH_DECLARE(int) switch_core_db_open(const char *filename, switch_core_db_t **ppDb)
{
return sqlite3_open(filename, ppDb);
return db;
}
-
SWITCH_DECLARE(void) switch_core_db_test_reactive(switch_core_db_t *db, char *test_sql, char *drop_sql, char *reactive_sql)
{
char *errmsg;
}
-
/* For Emacs:
* Local Variables:
* mode:c
* switch_core_directory.c -- Main Core Library (Directory Interface)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
#include "switch.h"
#include "private/switch_core_pvt.h"
-
-
NEW_HOOK_DECL(outgoing_channel)
NEW_HOOK_DECL(receive_message)
NEW_HOOK_DECL(receive_event)
NEW_HOOK_DECL(waitfor_write)
NEW_HOOK_DECL(send_dtmf)
NEW_HOOK_DECL(recv_dtmf)
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_file.c -- Main Core Library (File I/O Functions)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
}
return fh->file_interface->file_get_string(fh, col, string);
-
}
-
SWITCH_DECLARE(switch_status_t) switch_core_file_close(switch_file_handle_t *fh)
{
switch_status_t status;
switch_resample_destroy(&fh->resampler);
-
if (switch_test_flag(fh, SWITCH_FILE_FLAG_FREE_POOL)) {
switch_core_destroy_memory_pool(&fh->memory_pool);
}
* switch_core_hash.c -- Main Core Library (hash functions)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
#include <sqlite3.h>
#include "../../../libs/sqlite/src/hash.h"
-
struct switch_hash {
Hash table;
};
-
SWITCH_DECLARE(switch_status_t) switch_core_hash_init(switch_hash_t ** hash, switch_memory_pool_t *pool)
{
switch_hash_t *newhash;
*hash = newhash;
return SWITCH_STATUS_SUCCESS;
-
}
SWITCH_DECLARE(switch_status_t) switch_core_hash_destroy(switch_hash_t **hash)
return SWITCH_STATUS_SUCCESS;
}
-
SWITCH_DECLARE(void *) switch_core_hash_find(switch_hash_t * hash, const char *key)
{
return sqlite3HashFind(&hash->table, key, (int)strlen(key)+1);
return val;
}
-
SWITCH_DECLARE(switch_hash_index_t *) switch_hash_first(char *depricate_me, switch_hash_t *hash)
{
return (switch_hash_index_t *) sqliteHashFirst(&hash->table);
}
-
SWITCH_DECLARE(switch_hash_index_t *) switch_hash_next(switch_hash_index_t *hi)
{
return (switch_hash_index_t *) sqliteHashNext((HashElem *) hi);
* switch_core_io.c -- Main Core Library (Media I/O)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
-
SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, int stream_id)
{
switch_io_event_hook_video_write_frame_t *ptr;
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, int stream_id)
{
switch_io_event_hook_read_frame_t *ptr;
goto done;
}
is_cng = 1;
-
}
switch_assert((*frame)->codec != NULL);
session->read_codec->implementation->actual_samples_per_second,
session->enc_read_frame.data, &session->enc_read_frame.datalen, &session->enc_read_frame.rate, &flag);
-
switch (status) {
case SWITCH_STATUS_RESAMPLE:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "fixme 1\n");
switch_thread_rwlock_unlock(session->bug_rwlock);
}
}
-
return status;
}
}
if (switch_test_flag(frame, SFF_CNG)) {
-
if (switch_channel_test_flag(session->channel, CF_ACCEPT_CNG)) {
return perform_write(session, frame, timeout, flag, stream_id);
}
-
return SWITCH_STATUS_SUCCESS;
}
session->write_resampler->from_len = write_frame->datalen / 2;
switch_short_to_float(data, session->write_resampler->from, session->write_resampler->from_len);
-
-
session->write_resampler->to_len = (uint32_t)
switch_resample_process(session->write_resampler, session->write_resampler->from,
session->write_resampler->from_len, session->write_resampler->to, session->write_resampler->to_size, 0);
-
switch_float_to_short(session->write_resampler->to, data, session->write_resampler->to_len);
write_frame->samples = session->write_resampler->to_len;
session->enc_write_frame.data,
&session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);
-
switch (status) {
case SWITCH_STATUS_RESAMPLE:
session->enc_write_frame.codec = session->write_codec;
if (do_write) {
return perform_write(session, frame, timeout, io_flag, stream_id);
}
-
return status;
}
}
}
}
-
return status;
-
}
SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_read(switch_core_session_t *session, int timeout, int stream_id)
}
}
}
-
return status;
-
}
SWITCH_DECLARE(switch_status_t) switch_core_session_waitfor_write(switch_core_session_t *session, int timeout, int stream_id)
}
}
}
-
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_session_recv_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
switch_io_event_hook_recv_dtmf_t *ptr;
status = session->endpoint_interface->io_routines->send_dtmf(session, dtmf);
}
}
-
return status;
}
-
-
SWITCH_DECLARE(switch_status_t) switch_core_session_send_dtmf_string(switch_core_session_t *session, const char *dtmf_string)
{
char *p;
}
}
-
return sent ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}
* switch_core_media_bug.c -- Main Core Library (Media Bugs)
*
*/
+
#include "switch.h"
#include "private/switch_core_pvt.h"
if ((bug->raw_read_buffer && bug->raw_write_buffer) && (!rlen && !wlen)) {
return SWITCH_STATUS_FALSE;
}
-
-
+
maxlen = sizeof(data) > frame->buflen ? frame->buflen : sizeof(data);
-
if ((rdlen = rlen > wlen ? wlen : rlen) > maxlen) {
rdlen = maxlen;
}
return SWITCH_STATUS_SUCCESS;
}
-
+
return SWITCH_STATUS_FALSE;
}
bug->thread_id = switch_thread_self();
}
-
bug->ready = 1;
switch_thread_rwlock_wrlock(session->bug_rwlock);
bug->next = session->bugs;
session->bugs = NULL;
return SWITCH_STATUS_SUCCESS;
}
-
+
return SWITCH_STATUS_FALSE;
}
*bug = NULL;
return SWITCH_STATUS_SUCCESS;
}
-
+
return SWITCH_STATUS_FALSE;
}
switch_thread_rwlock_unlock(session->bug_rwlock);
status = switch_core_media_bug_close(&bp);
}
-
+
return status;
}
* switch_core_memory.c -- Main Core Library (memory management)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
/*#define LOCK_MORE*/
switch_assert(result != NULL);
va_end(ap);
-
#ifdef LOCK_MORE
switch_mutex_unlock(memory_manager.mem_lock);
#endif
return result;
}
-
SWITCH_DECLARE(char *) switch_core_session_strdup(switch_core_session_t *session, const char *todup)
{
char *duped = NULL;
return duped;
}
-
SWITCH_DECLARE(char *) switch_core_strdup(switch_memory_pool_t *pool, const char *todup)
{
char *duped = NULL;
tmp = switch_core_sprintf(*pool, "%s:%d", func, line);
apr_pool_tag(*pool, tmp);
switch_mutex_unlock(memory_manager.mem_lock);
+
return SWITCH_STATUS_SUCCESS;
}
apr_pool_destroy(*pool);
}
*pool = NULL;
-
-
+
return SWITCH_STATUS_SUCCESS;
}
-
SWITCH_DECLARE(void *) switch_core_alloc(switch_memory_pool_t *pool, switch_size_t memory)
{
void *ptr = NULL;
ptr = apr_palloc(pool, memory);
switch_assert(ptr != NULL);
memset(ptr, 0, memory);
-
#ifdef LOCK_MORE
switch_mutex_unlock(memory_manager.mem_lock);
return ptr;
}
-
SWITCH_DECLARE(void) switch_core_memory_reclaim(void)
{
switch_memory_pool_t *pool;
}
memory_manager.pool_thread_running = 0;
+
return NULL;
}
-
void switch_core_memory_stop(void)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Stopping memory pool queue.\n");
return memory_manager.memory_pool;
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_port_allocator.c -- Main Core Library (port allocator)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
return SWITCH_STATUS_SUCCESS;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_port_allocator_request_port(switch_core_port_allocator_t *alloc, switch_port_t *port_ptr)
{
switch_port_t port = 0;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_port_allocator_free_port(switch_core_port_allocator_t *alloc, switch_port_t port)
{
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
-
SWITCH_DECLARE(void) switch_core_port_allocator_destroy(switch_core_port_allocator_t **alloc)
{
switch_memory_pool_t *pool = (*alloc)->pool;
switch_core_destroy_memory_pool(&pool);
*alloc = NULL;
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_rwlock.c -- Main Core Library (read / write locks)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
* switch_core_session.c -- Main Core Library (session routines)
*
*/
+
#include "switch.h"
#include "switch_core.h"
#include "private/switch_core_pvt.h"
switch_size_t session_id;
} session_manager;
-
#ifdef SWITCH_DEBUG_RWLOCKS
SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_locate(const char *uuid_str, const char *file, const char *func, int line)
#else
if (session->endpoint_interface->io_routines->receive_message) {
status = session->endpoint_interface->io_routines->receive_message(session, message);
-
}
if (status == SWITCH_STATUS_SUCCESS) {
} else {
status = SWITCH_STATUS_FALSE;
}
-
+
return status;
}
switch_core_session_queue_message(session, msg);
return SWITCH_STATUS_SUCCESS;
}
-
+
return SWITCH_STATUS_FALSE;
}
status = SWITCH_STATUS_SUCCESS;
}
}
-
+
return status;
}
return status;
}
-
SWITCH_DECLARE(void) switch_core_session_reset(switch_core_session_t *session, switch_bool_t flush_dtmf)
{
switch_channel_t *channel;
}
switch_ivr_deactivate_unicast(session);
-
switch_channel_clear_flag(channel, CF_BREAK);
-
}
return session->channel;
}
-
-
SWITCH_DECLARE(void) switch_core_session_signal_state_change(switch_core_session_t *session)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
return NULL;
}
-
SWITCH_DECLARE(switch_status_t) switch_core_session_thread_launch(switch_core_session_t *session)
{
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
-
SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session_t *session, switch_thread_start_t func, void *obj)
{
switch_thread_t *thread;
}
-
SWITCH_DECLARE(switch_core_session_t *) switch_core_session_request(const switch_endpoint_interface_t
*endpoint_interface, switch_memory_pool_t **pool)
{
switch_core_new_memory_pool(&usepool);
}
-
session = switch_core_alloc(usepool, sizeof(*session));
session->pool = usepool;
switch_channel_init(session->channel, session, CS_NEW, 0);
-
/* The session *IS* the pool you may not alter it because you have no idea how
its all private it will be passed to the thread run function */
return switch_core_session_request(endpoint_interface, pool);
}
-
#ifndef SWITCH_PREFIX_DIR
#define SWITCH_PREFIX_DIR "."
#endif
-
SWITCH_DECLARE(uint8_t) switch_core_session_compare(switch_core_session_t *a, switch_core_session_t *b)
{
switch_assert(a != NULL);
return runtime.sps_total;
}
-
void switch_core_session_init(switch_memory_pool_t *pool)
{
memset(&session_manager, 0, sizeof(session_manager));
session->stack_count--;
- return status;
-
+ return status;
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_speech.c -- Main Core Library (speech functions)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
}
}
-
if ((sh->speech_interface = switch_loadable_module_get_speech_interface(module_name)) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "invalid speech module [%s]!\n", module_name);
return SWITCH_STATUS_GENERR;
sh->param = switch_core_strdup(sh->memory_pool, param);
}
-
sh->rate = rate;
sh->name = switch_core_strdup(pool, module_name);
sh->samples = switch_bytes_per_frame(rate, interval);
return sh->speech_interface->speech_open(sh, voice_name, rate, flags);
}
-
SWITCH_DECLARE(switch_status_t) switch_core_speech_feed_tts(switch_speech_handle_t *sh, char *text, switch_speech_flag_t *flags)
{
switch_assert(sh != NULL);
* switch_core_sqldb.c -- Main Core Library (statistics tracker)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
}
while (retries > 0) {
-
-
-
switch_core_db_exec(db, sql, NULL, NULL, &errmsg);
if (errmsg) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SQL ERR [%s]\n", errmsg);
}
}
-
done:
switch_core_db_exec(db, "end transaction", NULL, NULL, &errmsg);
}
}
-
void switch_core_sqldb_start(switch_memory_pool_t *pool)
{
switch_thread_t *thread;
switch_core_db_close(sql_manager.event_db);
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_state_maching.c -- Main Core Library (state machine)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Standard HANGUP %s, cause: %s\n",
switch_channel_get_name(session->channel), switch_channel_cause2str(switch_channel_get_cause(session->channel)));
-
}
static void switch_core_standard_on_reset(switch_core_session_t *session)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Standard RESET %s\n",
- switch_channel_get_name(session->channel));
-
+ switch_channel_get_name(session->channel));
}
static void switch_core_standard_on_ring(switch_core_session_t *session)
if (expanded && dpstr && expanded != dpstr) {
free(expanded);
}
-
}
static void switch_core_standard_on_execute(switch_core_session_t *session)
switch_channel_expand_variables(session->channel,
extension->current_application->application_data)) != extension->current_application->application_data) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Expanded String %s(%s)\n", switch_channel_get_name(session->channel),
- extension->current_application->application_name, expanded);
-
+ extension->current_application->application_name, expanded);
}
if (switch_channel_get_variable(session->channel, "presence_id")) {
}
#endif
-
static void handle_fatality(int sig)
{
switch_thread_id_t thread_id;
}
}
-
void switch_core_state_machine_init(switch_memory_pool_t *pool)
{
}
}
-
-
#define STATE_MACRO(__STATE, __STATE_STR) do { \
midstate = state; \
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "(%s) State %s\n", switch_channel_get_name(session->channel), __STATE_STR); \
}
}
-
/*
Life of the channel. you have channel and pool in your session
everywhere you go you use the session to malloc with
}
-
endstate = switch_channel_get_state(session->channel);
-
if (endstate == switch_channel_get_running_state(session->channel)) {
if (endstate == CS_NEW) {
switch_thread_cond_wait(session->cond, session->mutex);
}
}
-
}
done:
switch_mutex_unlock(session->mutex);
//apr_hash_set(stack_table, &thread_id, sizeof(thread_id), NULL);
}
session->thread_running = 0;
-
}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ */
* switch_core_timer.c -- Main Core Library (timer interface)
*
*/
+
#include <switch.h>
#include "private/switch_core_pvt.h"
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "no match, return false\n");
- return SWITCH_STATUS_FALSE;
-
+ return SWITCH_STATUS_FALSE;
}
-
/* For Emacs:
* Local Variables:
* mode:c
* switch_event.c -- Event System
*
*/
+
#include <switch.h>
#include <switch_event.h>
switch_core_hash_insert(CUSTOM_HASH, subclass->name, subclass);
return SWITCH_STATUS_SUCCESS;
-
}
SWITCH_DECLARE(void) switch_core_memory_reclaim_events(void)
switch_core_hash_destroy(&CUSTOM_HASH);
switch_core_memory_reclaim_events();
-
return SWITCH_STATUS_SUCCESS;
}
switch_queue_create(&EVENT_QUEUE[2], POOL_COUNT_MAX + 10, THRUNTIME_POOL);
switch_queue_create(&EVENT_RECYCLE_QUEUE, SWITCH_CORE_QUEUE_LEN, THRUNTIME_POOL);
switch_queue_create(&EVENT_HEADER_RECYCLE_QUEUE, SWITCH_CORE_QUEUE_LEN, THRUNTIME_POOL);
-
-
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Activate Eventing Engine.\n");
switch_mutex_init(&BLOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL);
switch_yield(1000);
}
return SWITCH_STATUS_SUCCESS;
-
}
SWITCH_DECLARE(switch_status_t) switch_event_create_subclass(switch_event_t **event, switch_event_types_t event_id, const char *subclass_name)
return SWITCH_STATUS_SUCCESS;
}
-
static switch_xml_t add_xml_header(switch_xml_t xml, char *name, char *value, int offset)
{
switch_xml_t header = NULL;
return SWITCH_STATUS_MEMERR;
}
-
#define resize(l) {\
char *dp;\
olen += (len + l + block);\
return data;
}
-
SWITCH_DECLARE(char *) switch_event_build_param_string(switch_event_t *event, const char *prefix)
{
switch_stream_handle_t stream = { 0 };
* switch_ivr.c -- IVR Library
*
*/
+
#include <switch.h>
#include <switch_ivr.h>
#include "stfu.h"
return status;
}
-
static void *SWITCH_THREAD_FUNC unicast_thread_run(switch_thread_t *thread, void *obj)
{
switch_unicast_conninfo_t *conninfo = (switch_unicast_conninfo_t *) obj;
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_count(switch_core_session_t *session,
char *buf,
switch_size_t buflen,
digit_started = switch_timestamp_now();
}
-
-
while (switch_channel_ready(channel)) {
switch_frame_t *read_frame;
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_hold(switch_core_session_t *session)
{
switch_core_session_message_t msg = { 0 };
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_nomedia(const char *uuid, switch_media_flag_t flags)
{
const char *other_uuid;
* switch_ivr_async.c -- IVR Library (async operations)
*
*/
+
#include <switch.h>
struct echo_helper {
}
}
-
typedef struct {
switch_file_handle_t fh;
int mux;
return SWITCH_TRUE;
}
-
-
static switch_bool_t read_displace_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
{
displace_helper_t *dh = (displace_helper_t *) user_data;
}
return SWITCH_STATUS_FALSE;
-
}
SWITCH_DECLARE(switch_status_t) switch_ivr_displace_session(switch_core_session_t *session, const char *file, uint32_t limit, const char *flags)
time_t to = 0;
displace_helper_t *dh;
-
channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL);
return SWITCH_STATUS_SUCCESS;
}
-
static switch_bool_t record_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
{
switch_file_handle_t *fh = (switch_file_handle_t *) user_data;
}
return SWITCH_STATUS_FALSE;
-
}
-
struct eavesdrop_pvt {
switch_buffer_t *buffer;
switch_mutex_t *mutex;
return SWITCH_TRUE;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_eavesdrop_session(switch_core_session_t *session, const char *uuid, switch_eavesdrop_flag_t flags)
{
switch_core_session_t *tsession;
}
-
end:
switch_core_codec_destroy(&codec);
return SWITCH_STATUS_SUCCESS;
}
-
typedef struct {
switch_core_session_t *session;
teletone_generation_session_t ts;
return 0;
}
-
static switch_status_t generate_on_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
return SWITCH_STATUS_SUCCESS;
}
-
#define MAX_TONES 16
typedef struct {
teletone_multi_tone_t mt;
int up;
} switch_tone_detect_t;
-
typedef struct {
switch_tone_detect_t list[MAX_TONES+1];
int index;
return SWITCH_STATUS_SUCCESS;
}
-
struct speech_thread_handle {
switch_core_session_t *session;
switch_asr_handle_t *ah;
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&thread, thd_attr, speech_thread, sth, sth->pool);
-
}
break;
case SWITCH_ABC_TYPE_CLOSE:{
}
return SWITCH_STATUS_FALSE;
-
}
-
-
SWITCH_DECLARE(switch_status_t) switch_ivr_pause_detect_speech(switch_core_session_t *session)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
}
return SWITCH_STATUS_FALSE;
-
}
SWITCH_DECLARE(switch_status_t) switch_ivr_resume_detect_speech(switch_core_session_t *session)
}
return SWITCH_STATUS_FALSE;
-
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech_load_grammar(switch_core_session_t *session, char *grammar, char *path)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
return SWITCH_STATUS_FALSE;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech_unload_grammar(switch_core_session_t *session, const char *grammar)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
return SWITCH_STATUS_SUCCESS;
}
-
struct hangup_helper {
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
switch_bool_t bleg;
return switch_scheduler_add_task(runtime, sch_transfer_callback, (char *) __SWITCH_FUNC__, uuid, 0, helper, SSHF_FREE_ARG);
}
-
struct broadcast_helper {
char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
char *path;
switch_core_session_rwunlock(session);
switch_safe_free(mypath);
-
-
return SWITCH_STATUS_SUCCESS;
-
}
+
/* For Emacs:
* Local Variables:
* mode:c
* switch_ivr_bridge.c -- IVR Library
*
*/
+
#include <switch.h>
static const switch_state_handler_table_t audio_bridge_peer_state_handlers;
};
typedef struct switch_ivr_bridge_data switch_ivr_bridge_data_t;
-
-
static void *audio_bridge_thread(switch_thread_t * thread, void *obj)
{
switch_ivr_bridge_data_t *data = obj;
return SWITCH_STATUS_FALSE;
}
-
static switch_status_t audio_bridge_on_ring(switch_core_session_t *session)
{
switch_channel_t *channel = NULL;
/*.on_hold */ audio_bridge_on_hold,
};
-
static switch_status_t uuid_bridge_on_reset(switch_core_session_t *session)
{
switch_channel_t *channel = NULL;
}
}
-
if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
&& (other_session = switch_core_session_locate(uuid))) {
switch_channel_t *other_channel = NULL;
switch_core_session_rwunlock(other_session);
}
-
return SWITCH_STATUS_SUCCESS;
}
switch_channel_add_state_handler(caller_channel, &signal_bridge_state_handlers);
switch_channel_add_state_handler(peer_channel, &signal_bridge_state_handlers);
-
/* fire events that will change the data table from "show channels" */
if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
switch_channel_event_set_data(caller_channel, event);
}
}
-
msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE;
msg.from = __FILE__;
msg.string_arg = switch_core_session_strdup(peer_session, switch_core_session_get_uuid(session));
goto done;
}
-
switch_channel_set_variable(caller_channel, SWITCH_BRIDGE_CHANNEL_VARIABLE, switch_channel_get_name(peer_channel));
switch_channel_set_variable(caller_channel, SWITCH_BRIDGE_UUID_VARIABLE, switch_core_session_get_uuid(peer_session));
switch_channel_set_variable(caller_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(peer_session));
return status;
}
-
SWITCH_DECLARE(switch_status_t) switch_ivr_uuid_bridge(const char *originator_uuid, const char *originatee_uuid)
{
switch_core_session_t *originator_session, *originatee_session, *swap_session;
}
}
-
/* override transmit state for originator_channel to bridge to originatee_channel
* install pointer to originatee_session into originator_channel
* set CF_TRANSFER on both channels and change state to CS_TRANSMIT to
switch_channel_add_state_handler(originator_channel, &uuid_bridge_state_handlers);
switch_channel_add_state_handler(originatee_channel, &uuid_bridge_state_handlers);
switch_channel_set_variable(originator_channel, SWITCH_UUID_BRIDGE, switch_core_session_get_uuid(originatee_session));
-
-
-
+
switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_CHANNEL_VARIABLE, switch_channel_get_name(originatee_channel));
switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_UUID_VARIABLE, switch_core_session_get_uuid(originatee_session));
switch_channel_set_variable(originator_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(originatee_session));
switch_channel_set_variable(originator_channel, "original_destination_number", originator_cp->destination_number);
switch_channel_set_variable(originator_channel, "original_caller_id_name", originator_cp->caller_id_name);
switch_channel_set_variable(originator_channel, "original_caller_id_number", originator_cp->caller_id_number);
-
cp = switch_caller_profile_clone(originatee_session, originatee_cp);
cp->destination_number = switch_core_strdup(cp->pool, originator_cp->caller_id_number);
}
return status;
-
}
SWITCH_DECLARE(void) switch_ivr_intercept_session(switch_core_session_t *session, const char *uuid)
switch_channel_set_state_flag(rchannel, CF_TRANSFER);
switch_channel_set_state(rchannel, CS_RESET);
-
if (bsession) {
bchannel = switch_core_session_get_channel(bsession);
switch_channel_hangup(bchannel, SWITCH_CAUSE_PICKED_OFF);
switch_core_session_rwunlock(bsession);
}
-
-
-
switch_core_session_rwunlock(rsession);
switch_ivr_uuid_bridge(switch_core_session_get_uuid(session), uuid);
* switch_ivr_menu.c -- IVR Library (menu code)
*
*/
+
#include <switch.h>
struct switch_ivr_menu_action;
* switch_ivr_originate.c -- IVR Library (originate)
*
*/
+
#include <switch.h>
static const switch_state_handler_table_t originate_state_handlers;
/*.on_hold */ NULL
};
-
typedef enum {
IDX_CANCEL = -2,
IDX_NADA = -1
} else {
return 1;
}
-
}
struct ringback {
}
}
-
if (caller_channel) { /* ringback is only useful when there is an originator */
ringback_data = NULL;
cid_num_override = switch_event_get_header(var_event, "origination_caller_id_number");
}
-
-
for (try = 0; try < retries; try++) {
switch_safe_free(loop_data);
loop_data = strdup(data);
peer_sessions[i] = NULL;
new_session = NULL;
-
-
-
if (and_argc > 1 || or_argc > 1) {
myflags |= SOF_FORKED_DIAL;
} else if (var_event) {
switch_channel_add_state_handler(peer_channels[i], table);
}
-
if ((flags & SOF_NOBLOCK) && peer_sessions[i]) {
status = SWITCH_STATUS_SUCCESS;
*bleg = peer_sessions[i];
*cause = SWITCH_CAUSE_SUCCESS;
goto outer_for;
}
-
if (switch_core_session_running(peer_sessions[i])) {
if (!(flags & SOF_NOBLOCK)) {
} else {
switch_core_session_thread_launch(peer_sessions[i]);
}
-
-
}
switch_timestamp(&start);
projects / thirdparty / freeswitch.git / commitdiff
