From 42383b1f1565dfd12fe347d81ca8f168d58f48eb Mon Sep 17 00:00:00 2001 From: Anthony Minessale <anthony.minessale@gmail.com> Date: Fri, 20 Jan 2006 00:40:29 +0000 Subject: [PATCH] indent git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@416 d0543943-73ff-0310-b7d9-9358b9ac24b2 --- src/switch.c | 7 +- src/switch_buffer.c | 16 +- src/switch_caller.c | 20 +- src/switch_channel.c | 219 ++++++++++--------- src/switch_config.c | 5 +- src/switch_console.c | 37 ++-- src/switch_core.c | 410 ++++++++++++++++++----------------- src/switch_event.c | 66 +++--- src/switch_loadable_module.c | 71 +++--- src/switch_mutex.c | 6 +- src/switch_resample.c | 71 +++--- src/switch_utils.c | 11 +- 12 files changed, 468 insertions(+), 471 deletions(-) diff --git a/src/switch.c b/src/switch.c index 36aee26d65..9e4755a150 100644 --- a/src/switch.c +++ b/src/switch.c @@ -31,7 +31,8 @@ */ #include <switch.h> -int main(int argc, char *argv[]) { +int main(int argc, char *argv[]) +{ char *err = NULL; switch_event *event; @@ -47,7 +48,7 @@ int main(int argc, char *argv[]) { } } - if(err) { + if (err) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Error: %s", err); exit(-1); } @@ -75,5 +76,3 @@ int main(int argc, char *argv[]) { return 0; } - - diff --git a/src/switch_buffer.c b/src/switch_buffer.c index 2008839e7a..98aba36055 100644 --- a/src/switch_buffer.c +++ b/src/switch_buffer.c @@ -41,7 +41,8 @@ SWITCH_DECLARE(switch_status) switch_buffer_create(switch_memory_pool *pool, swi { switch_buffer *new_buffer; - if ((new_buffer = switch_core_alloc(pool, sizeof(switch_buffer))) && (new_buffer->data = switch_core_alloc(pool, max_len))) { + if ((new_buffer = switch_core_alloc(pool, sizeof(switch_buffer))) + && (new_buffer->data = switch_core_alloc(pool, max_len))) { new_buffer->datalen = max_len; *buffer = new_buffer; return SWITCH_STATUS_SUCCESS; @@ -54,7 +55,7 @@ SWITCH_DECLARE(int) switch_buffer_len(switch_buffer *buffer) assert(buffer != NULL); - return (int)buffer->datalen; + return (int) buffer->datalen; } @@ -63,14 +64,14 @@ SWITCH_DECLARE(int) switch_buffer_freespace(switch_buffer *buffer) { assert(buffer != NULL); - return (int)(buffer->datalen - buffer->used); + return (int) (buffer->datalen - buffer->used); } SWITCH_DECLARE(int) switch_buffer_inuse(switch_buffer *buffer) { assert(buffer != NULL); - return (int)buffer->used; + return (int) buffer->used; } SWITCH_DECLARE(int) switch_buffer_toss(switch_buffer *buffer, size_t datalen) @@ -91,7 +92,7 @@ SWITCH_DECLARE(int) switch_buffer_toss(switch_buffer *buffer, size_t datalen) memmove(buffer->data, buffer->data + reading, buffer->datalen - reading); buffer->used -= datalen; - return (int)buffer->datalen; + return (int) buffer->datalen; } SWITCH_DECLARE(int) switch_buffer_read(switch_buffer *buffer, void *data, size_t datalen) @@ -115,7 +116,7 @@ SWITCH_DECLARE(int) switch_buffer_read(switch_buffer *buffer, void *data, size_t memmove(buffer->data, buffer->data + reading, buffer->datalen - reading); buffer->used -= reading; //printf("o %d = %d\n", reading, buffer->used); - return (int)reading; + return (int) reading; } SWITCH_DECLARE(int) switch_buffer_write(switch_buffer *buffer, void *data, size_t datalen) @@ -135,6 +136,5 @@ SWITCH_DECLARE(int) switch_buffer_write(switch_buffer *buffer, void *data, size_ buffer->used += datalen; } //printf("i %d = %d\n", datalen, buffer->used); - return (int)buffer->used; + return (int) buffer->used; } - diff --git a/src/switch_caller.c b/src/switch_caller.c index 338b6f3f22..a49eba3f72 100644 --- a/src/switch_caller.c +++ b/src/switch_caller.c @@ -36,9 +36,7 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_new(switch_core_se char *caller_id_name, char *caller_id_number, char *network_addr, - char *ani, - char *ani2, - char *destination_number) + char *ani, char *ani2, char *destination_number) { @@ -75,8 +73,8 @@ SWITCH_DECLARE(switch_caller_profile *) switch_caller_profile_clone(switch_core_ return profile; } -SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile *caller_profile, char *prefix, switch_event *event) - +SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile *caller_profile, char *prefix, + switch_event *event) { char header_name[1024]; @@ -112,9 +110,7 @@ SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile } SWITCH_DECLARE(switch_caller_extension *) switch_caller_extension_new(switch_core_session *session, - char *extension_name, - char *extension_number - ) + char *extension_name, char *extension_number) { switch_caller_extension *caller_extension = NULL; @@ -130,8 +126,7 @@ SWITCH_DECLARE(switch_caller_extension *) switch_caller_extension_new(switch_cor SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session *session, switch_caller_extension *caller_extension, - char *application_name, - char *application_data) + char *application_name, char *application_data) { switch_caller_application *caller_application = NULL; @@ -142,7 +137,7 @@ SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session caller_application->application_data = switch_core_session_strdup(session, application_data); if (!caller_extension->applications) { caller_extension->applications = caller_application; - } else if(caller_extension->last_application) { + } else if (caller_extension->last_application) { caller_extension->last_application->next = caller_application; } @@ -151,6 +146,3 @@ SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session } } - - - diff --git a/src/switch_channel.c b/src/switch_channel.c index 5564f3b769..d60dca668d 100644 --- a/src/switch_channel.c +++ b/src/switch_channel.c @@ -71,7 +71,8 @@ SWITCH_DECLARE(switch_status) switch_channel_alloc(switch_channel **channel, swi return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_channel_set_raw_mode (switch_channel *channel, int freq, int bits, int channels, int ms, int kbps) +SWITCH_DECLARE(switch_status) switch_channel_set_raw_mode(switch_channel *channel, int freq, int bits, int channels, + int ms, int kbps) { assert(channel != NULL); @@ -86,7 +87,8 @@ SWITCH_DECLARE(switch_status) switch_channel_set_raw_mode (switch_channel *chann return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_channel_get_raw_mode (switch_channel *channel, int *freq, int *bits, int *channels, int *ms, int *kbps) +SWITCH_DECLARE(switch_status) switch_channel_get_raw_mode(switch_channel *channel, int *freq, int *bits, int *channels, + int *ms, int *kbps) { if (freq) { *freq = channel->freq; @@ -128,7 +130,7 @@ SWITCH_DECLARE(switch_status) switch_channel_queue_dtmf(switch_channel *channel, assert(channel != NULL); switch_mutex_lock(channel->dtmf_mutex); - if (switch_buffer_inuse(channel->dtmf_buffer) + strlen(dtmf) > (size_t)switch_buffer_len(channel->dtmf_buffer)) { + if (switch_buffer_inuse(channel->dtmf_buffer) + strlen(dtmf) > (size_t) switch_buffer_len(channel->dtmf_buffer)) { switch_buffer_toss(channel->dtmf_buffer, strlen(dtmf)); } @@ -164,8 +166,7 @@ SWITCH_DECLARE(int) switch_channel_dequeue_dtmf(switch_channel *channel, char *d SWITCH_DECLARE(switch_status) switch_channel_init(switch_channel *channel, switch_core_session *session, - switch_channel_state state, - switch_channel_flag flags) + switch_channel_state state, switch_channel_flag flags) { assert(channel != NULL); channel->state = state; @@ -277,115 +278,117 @@ SWITCH_DECLARE(switch_channel_state) switch_channel_set_state(switch_channel *ch } /* STUB for more dev - case CS_INIT: - switch(state) { + case CS_INIT: + switch(state) { + case CS_NEW: + case CS_INIT: + case CS_LOOPBACK: + case CS_TRANSMIT: + case CS_RING: + case CS_EXECUTE: + case CS_HANGUP: + case CS_DONE: + + default: + break; + } + break; + */ + + switch (last_state) { case CS_NEW: + switch (state) { + default: + ok++; + break; + } + break; + case CS_INIT: + switch (state) { + case CS_LOOPBACK: + case CS_TRANSMIT: + case CS_RING: + case CS_EXECUTE: + case CS_HANGUP: + ok++; + default: + break; + } + break; + case CS_LOOPBACK: + switch (state) { + case CS_TRANSMIT: + case CS_RING: + case CS_EXECUTE: + case CS_HANGUP: + ok++; + default: + break; + } + break; + case CS_TRANSMIT: + switch (state) { + case CS_LOOPBACK: + case CS_RING: + case CS_EXECUTE: + case CS_HANGUP: + ok++; + default: + break; + } + break; + case CS_RING: + switch (state) { + case CS_LOOPBACK: + case CS_EXECUTE: + case CS_HANGUP: + case CS_TRANSMIT: + ok++; + default: + break; + } + break; + case CS_EXECUTE: + switch (state) { + case CS_LOOPBACK: + case CS_TRANSMIT: + case CS_RING: + case CS_HANGUP: + ok++; + default: + break; + } + break; + case CS_HANGUP: - case CS_DONE: + switch (state) { + case CS_DONE: + ok++; + default: + break; + } + break; default: - break; - } - break; - */ - - switch(last_state) { -case CS_NEW: - switch(state) { -default: - ok++; - break; - } - break; - -case CS_INIT: - switch(state) { -case CS_LOOPBACK: -case CS_TRANSMIT: -case CS_RING: -case CS_EXECUTE: -case CS_HANGUP: - ok++; -default: - break; - } - break; - -case CS_LOOPBACK: - switch(state) { -case CS_TRANSMIT: -case CS_RING: -case CS_EXECUTE: -case CS_HANGUP: - ok++; -default: - break; - } - break; - -case CS_TRANSMIT: - switch(state) { -case CS_LOOPBACK: -case CS_RING: -case CS_EXECUTE: -case CS_HANGUP: - ok++; -default: - break; - } - break; - -case CS_RING: - switch(state) { -case CS_LOOPBACK: -case CS_EXECUTE: -case CS_HANGUP: -case CS_TRANSMIT: - ok++; -default: - break; - } - break; - -case CS_EXECUTE: - switch(state) { -case CS_LOOPBACK: -case CS_TRANSMIT: -case CS_RING: -case CS_HANGUP: - ok++; -default: - break; - } - break; - -case CS_HANGUP: - switch(state) { -case CS_DONE: - ok++; -default: - break; - } - break; - -default: - break; + break; } if (ok) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s State Change %s -> %s\n", channel->name, + state_names[last_state], state_names[state]); channel->state = state; switch_core_session_signal_state_change(channel->session); } else { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s Invalid State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s Invalid State Change %s -> %s\n", channel->name, + state_names[last_state], state_names[state]); //we won't tolerate an invalid state change so we can make sure we are as robust as a nice cup of dark coffee! if (channel->state < CS_HANGUP) { @@ -399,7 +402,7 @@ default: SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel *channel, switch_event *event) { switch_caller_profile *caller_profile, *originator_caller_profile, *originatee_caller_profile; - switch_hash_index_t* hi; + switch_hash_index_t *hi; void *val; const void *var; @@ -407,12 +410,13 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel *channel, swit originator_caller_profile = switch_channel_get_originator_caller_profile(channel); originatee_caller_profile = switch_channel_get_originatee_caller_profile(channel); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-State", (char *) switch_channel_state_name(channel->state)); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-State", + (char *) switch_channel_state_name(channel->state)); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Name", switch_channel_get_name(channel)); switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(channel->session)); - /* Index Caller's Profile */ + /* Index Caller's Profile */ if (caller_profile) { switch_caller_profile_event_set_data(caller_profile, "Caller", event); } @@ -428,7 +432,8 @@ SWITCH_DECLARE(void) switch_channel_event_set_data(switch_channel *channel, swit } /* Index Variables */ - for (hi = switch_hash_first(switch_core_session_get_pool(channel->session), channel->variables); hi; hi = switch_hash_next(hi)) { + for (hi = switch_hash_first(switch_core_session_get_pool(channel->session), channel->variables); hi; + hi = switch_hash_next(hi)) { char buf[1024]; switch_event_subclass *subclass; switch_hash_this(hi, &var, NULL, &val); @@ -453,13 +458,15 @@ SWITCH_DECLARE(switch_caller_profile *) switch_channel_get_caller_profile(switch return channel->caller_profile; } -SWITCH_DECLARE(void) switch_channel_set_originator_caller_profile(switch_channel *channel, switch_caller_profile *caller_profile) +SWITCH_DECLARE(void) switch_channel_set_originator_caller_profile(switch_channel *channel, + switch_caller_profile *caller_profile) { assert(channel != NULL); channel->originator_caller_profile = caller_profile; } -SWITCH_DECLARE(void) switch_channel_set_originatee_caller_profile(switch_channel *channel, switch_caller_profile *caller_profile) +SWITCH_DECLARE(void) switch_channel_set_originatee_caller_profile(switch_channel *channel, + switch_caller_profile *caller_profile) { assert(channel != NULL); channel->originatee_caller_profile = caller_profile; @@ -477,7 +484,8 @@ SWITCH_DECLARE(switch_caller_profile *) switch_channel_get_originatee_caller_pro return channel->originatee_caller_profile; } -SWITCH_DECLARE(void) switch_channel_set_event_handlers(switch_channel *channel, const struct switch_event_handler_table *event_handlers) +SWITCH_DECLARE(void) switch_channel_set_event_handlers(switch_channel *channel, + const struct switch_event_handler_table *event_handlers) { assert(channel != NULL); channel->event_handlers = event_handlers; @@ -489,7 +497,8 @@ SWITCH_DECLARE(const struct switch_event_handler_table *) switch_channel_get_eve return channel->event_handlers; } -SWITCH_DECLARE(void) switch_channel_set_caller_extension(switch_channel *channel, switch_caller_extension *caller_extension) +SWITCH_DECLARE(void) switch_channel_set_caller_extension(switch_channel *channel, + switch_caller_extension *caller_extension) { assert(channel != NULL); channel->caller_extension = caller_extension; @@ -509,7 +518,7 @@ SWITCH_DECLARE(switch_status) switch_channel_hangup(switch_channel *channel) assert(channel != NULL); if (channel->state < CS_HANGUP) { channel->state = CS_HANGUP; - switch_core_session_signal_state_change(channel->session); + switch_core_session_signal_state_change(channel->session); } return channel->state; } diff --git a/src/switch_config.c b/src/switch_config.c index 78b70f9fb5..fa05107e25 100644 --- a/src/switch_config.c +++ b/src/switch_config.c @@ -83,7 +83,7 @@ SWITCH_DECLARE(int) switch_config_next_pair(switch_config *cfg, char **var, char *var = *val = NULL; - for(;;) { + for (;;) { cfg->lineno++; if (!fgets(cfg->buf, sizeof(cfg->buf), cfg->file)) { @@ -154,6 +154,3 @@ SWITCH_DECLARE(int) switch_config_next_pair(switch_config *cfg, char **var, char return ret; } - - - diff --git a/src/switch_console.c b/src/switch_console.c index b5c381b1ab..1a2240e058 100644 --- a/src/switch_console.c +++ b/src/switch_console.c @@ -54,15 +54,10 @@ static int switch_console_process(char *cmd) switch_console_printf(SWITCH_CHANNEL_CONSOLE, "\n" "Valid Commands:\n\n" - "version\n" - "help - umm yeah..\n" - "%sshutdown - stop the program\n\n", - perlhelp - ); + "version\n" "help - umm yeah..\n" "%sshutdown - stop the program\n\n", perlhelp); return 1; } - #ifdef EMBED_PERL if (!strncmp(cmd, "perl ", 5)) { cmd += 5; @@ -71,7 +66,7 @@ static int switch_console_process(char *cmd) return 1; } #endif - if ((arg = strchr(cmd, '\r')) || (arg=strchr(cmd, '\n'))) { + if ((arg = strchr(cmd, '\r')) || (arg = strchr(cmd, '\n'))) { *arg = '\0'; arg = NULL; } @@ -79,14 +74,16 @@ static int switch_console_process(char *cmd) *arg++ = '\0'; } if (switch_api_execute(cmd, arg, retbuf, sizeof(retbuf)) == SWITCH_STATUS_SUCCESS) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "API CALL [%s(%s)] output:\n%s\n", cmd, arg ? arg : "", retbuf); + switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "API CALL [%s(%s)] output:\n%s\n", cmd, arg ? arg : "", + retbuf); } else { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Unknown Command: %s\n", cmd); } return 1; } -SWITCH_DECLARE(void) switch_console_printf(switch_text_channel channel, char *file, const char *func, int line, char *fmt, ...) +SWITCH_DECLARE(void) switch_console_printf(switch_text_channel channel, char *file, const char *func, int line, + char *fmt, ...) { char *data; int ret = 0; @@ -120,18 +117,18 @@ SWITCH_DECLARE(void) switch_console_printf(switch_text_channel channel, char *fi switch_strftime(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm); if (channel == SWITCH_CHANNEL_ID_CONSOLE) { - fprintf(handle, "[%d] %s %s:%d %s() %s", (int)getpid(), date, filep, line, func, data); + fprintf(handle, "[%d] %s %s:%d %s() %s", (int) getpid(), date, filep, line, func, data); } - else if (channel == SWITCH_CHANNEL_ID_EVENT && - switch_event_running() == SWITCH_STATUS_SUCCESS && - switch_event_create(&event, SWITCH_EVENT_LOG) == SWITCH_STATUS_SUCCESS) { + else if (channel == SWITCH_CHANNEL_ID_EVENT && + switch_event_running() == SWITCH_STATUS_SUCCESS && + switch_event_create(&event, SWITCH_EVENT_LOG) == SWITCH_STATUS_SUCCESS) { - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Data", "%s", data); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-File", "%s", filep); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Function", "%s", func); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Line", "%d", line); - switch_event_fire(&event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Data", "%s", data); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-File", "%s", filep); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Function", "%s", func); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Line", "%d", line); + switch_event_fire(&event); } free(data); } @@ -161,14 +158,14 @@ SWITCH_DECLARE(void) switch_console_loop(void) } memset(&cmd, 0, sizeof(cmd)); - for (x=0; sizeof(cmd) ;x++) { + for (x = 0; sizeof(cmd); x++) { cmd[x] = getchar(); if (cmd[x] == '\n') { cmd[x] = '\0'; break; } } - if(cmd[0]) { + if (cmd[0]) { running = switch_console_process(cmd); } } diff --git a/src/switch_core.c b/src/switch_core.c index dbb55986d5..9e4479ef73 100644 --- a/src/switch_core.c +++ b/src/switch_core.c @@ -35,8 +35,8 @@ #include <EXTERN.h> #include <perl.h> -static char *embedding[] = { "", "-e", ""}; -EXTERN_C void xs_init (pTHX); +static char *embedding[] = { "", "-e", "" }; +EXTERN_C void xs_init(pTHX); #endif @@ -81,7 +81,7 @@ struct switch_core_session { void *streams[SWITCH_MAX_STREAMS]; int stream_count; - char uuid_str[SWITCH_UUID_FORMATTED_LENGTH+1]; + char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1]; void *private; }; @@ -100,7 +100,7 @@ struct switch_core_runtime { /* Prototypes */ static int handle_SIGINT(int sig); static int handle_SIGPIPE(int sig); -static void * SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *thread, void *obj); +static void *SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *thread, void *obj); static void switch_core_standard_on_init(switch_core_session *session); static void switch_core_standard_on_hangup(switch_core_session *session); static void switch_core_standard_on_ring(switch_core_session *session); @@ -134,7 +134,7 @@ static int handle_SIGINT(int sig) } -static void db_pick_path(char *dbname, char *buf, size_t size) +static void db_pick_path(char *dbname, char *buf, size_t size) { memset(buf, 0, size); @@ -145,7 +145,7 @@ static void db_pick_path(char *dbname, char *buf, size_t size) } } -SWITCH_DECLARE(switch_core_db *) switch_core_db_open_file(char *filename) +SWITCH_DECLARE(switch_core_db *) switch_core_db_open_file(char *filename) { switch_core_db *db; char path[1024]; @@ -154,7 +154,7 @@ SWITCH_DECLARE(switch_core_db *) switch_core_db_open_file(char *filename) if (switch_core_db_open(path, &db)) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "SQL ERR [%s]\n", switch_core_db_errmsg(db)); switch_core_db_close(db); - db=NULL; + db = NULL; } return db; } @@ -186,7 +186,7 @@ SWITCH_DECLARE(switch_status) switch_core_do_perl(char *txt) } #endif -SWITCH_DECLARE (switch_status) switch_core_session_message_send(char *uuid_str, switch_core_session_message *message) +SWITCH_DECLARE(switch_status) switch_core_session_message_send(char *uuid_str, switch_core_session_message *message) { switch_core_session *session = NULL; @@ -221,7 +221,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_set_write_codec(switch_core_se return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char *codec_name, int rate, int ms, int channels, switch_codec_flag flags, const switch_codec_settings *codec_settings, switch_memory_pool *pool) +SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char *codec_name, int rate, int ms, + int channels, switch_codec_flag flags, + const switch_codec_settings *codec_settings, + switch_memory_pool *pool) { const switch_codec_interface *codec_interface; const switch_codec_implementation *iptr, *implementation = NULL; @@ -236,9 +239,9 @@ SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char * return SWITCH_STATUS_GENERR; } - for(iptr = codec_interface->implementations; iptr; iptr = iptr->next) { - if ((!rate || rate == iptr->samples_per_second) && - (!ms || ms == (iptr->microseconds_per_frame / 1000)) && + for (iptr = codec_interface->implementations; iptr; iptr = iptr->next) { + if ((!rate || rate == iptr->samples_per_second) && + (!ms || ms == (iptr->microseconds_per_frame / 1000)) && (!channels || channels == iptr->number_of_channels)) { implementation = iptr; break; @@ -263,7 +266,8 @@ SWITCH_DECLARE(switch_status) switch_core_codec_init(switch_codec *codec, char * return SWITCH_STATUS_SUCCESS; } else { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s Exists but not then desired implementation.\n", codec_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s Exists but not then desired implementation.\n", + codec_name); } return SWITCH_STATUS_NOTIMPL; @@ -276,9 +280,7 @@ SWITCH_DECLARE(switch_status) switch_core_codec_encode(switch_codec *codec, size_t decoded_data_len, int decoded_rate, void *encoded_data, - size_t *encoded_data_len, - int *encoded_rate, - unsigned int *flag) + size_t *encoded_data_len, int *encoded_rate, unsigned int *flag) { assert(codec != NULL); assert(encoded_data != NULL); @@ -299,11 +301,7 @@ SWITCH_DECLARE(switch_status) switch_core_codec_encode(switch_codec *codec, other_codec, decoded_data, decoded_data_len, - decoded_rate, - encoded_data, - encoded_data_len, - encoded_rate, - flag); + decoded_rate, encoded_data, encoded_data_len, encoded_rate, flag); } @@ -313,9 +311,7 @@ SWITCH_DECLARE(switch_status) switch_core_codec_decode(switch_codec *codec, size_t encoded_data_len, int encoded_rate, void *decoded_data, - size_t *decoded_data_len, - int *decoded_rate, - unsigned int *flag) + size_t *decoded_data_len, int *decoded_rate, unsigned int *flag) { assert(codec != NULL); @@ -337,11 +333,7 @@ SWITCH_DECLARE(switch_status) switch_core_codec_decode(switch_codec *codec, other_codec, encoded_data, encoded_data_len, - encoded_rate, - decoded_data, - decoded_data_len, - decoded_rate, - flag); + encoded_rate, decoded_data, decoded_data_len, decoded_rate, flag); } @@ -363,7 +355,8 @@ SWITCH_DECLARE(switch_status) switch_core_codec_destroy(switch_codec *codec) return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_core_file_open(switch_file_handle *fh, char *file_path, unsigned int flags, switch_memory_pool *pool) +SWITCH_DECLARE(switch_status) switch_core_file_open(switch_file_handle *fh, char *file_path, unsigned int flags, + switch_memory_pool *pool) { char *ext; switch_status status; @@ -398,17 +391,18 @@ SWITCH_DECLARE(switch_status) switch_core_file_read(switch_file_handle *fh, void { assert(fh != NULL); - return fh->file_interface->file_read(fh, data, (unsigned int *)len); + return fh->file_interface->file_read(fh, data, (unsigned int *) len); } SWITCH_DECLARE(switch_status) switch_core_file_write(switch_file_handle *fh, void *data, size_t *len) { assert(fh != NULL); - return fh->file_interface->file_write(fh, data, (unsigned int *)len); + return fh->file_interface->file_write(fh, data, (unsigned int *) len); } -SWITCH_DECLARE(switch_status) switch_core_file_seek(switch_file_handle *fh, unsigned int *cur_pos, unsigned int samples, int whence) +SWITCH_DECLARE(switch_status) switch_core_file_seek(switch_file_handle *fh, unsigned int *cur_pos, unsigned int samples, + int whence) { return fh->file_interface->file_seek(fh, cur_pos, samples, whence); } @@ -419,7 +413,8 @@ SWITCH_DECLARE(switch_status) switch_core_file_close(switch_file_handle *fh) } -SWITCH_DECLARE(switch_status) switch_core_timer_init(switch_timer *timer, char *timer_name, int interval, int samples, switch_memory_pool *pool) +SWITCH_DECLARE(switch_status) switch_core_timer_init(switch_timer *timer, char *timer_name, int interval, int samples, + switch_memory_pool *pool) { switch_timer_interface *timer_interface; switch_status status; @@ -498,8 +493,8 @@ static void *switch_core_service_thread(switch_thread *thread, void *obj) return NULL; #endif - while(data->running > 0) { - switch(switch_core_session_read_frame(session, &read_frame, -1, stream_id)) { + while (data->running > 0) { + switch (switch_core_session_read_frame(session, &read_frame, -1, stream_id)) { case SWITCH_STATUS_SUCCESS: break; case SWITCH_STATUS_TIMEOUT: @@ -527,13 +522,14 @@ SWITCH_DECLARE(void) switch_core_thread_session_end(switch_core_thread_session * if (thread_session->running > 0) { thread_session->running = -1; - while(thread_session->running) { + while (thread_session->running) { switch_yield(1000); } } } -SWITCH_DECLARE(void) switch_core_service_session(switch_core_session *session, switch_core_thread_session *thread_session, int stream_id) +SWITCH_DECLARE(void) switch_core_service_session(switch_core_session *session, + switch_core_thread_session *thread_session, int stream_id) { thread_session->running = 1; thread_session->objs[0] = session; @@ -548,7 +544,7 @@ SWITCH_DECLARE(switch_memory_pool *) switch_core_session_get_pool(switch_core_se /* **ONLY** alloc things with this function that **WILL NOT** outlive the session itself or expect an earth shattering KABOOM!*/ -SWITCH_DECLARE(void *)switch_core_session_alloc(switch_core_session *session, size_t memory) +SWITCH_DECLARE(void *) switch_core_session_alloc(switch_core_session *session, size_t memory) { void *ptr = NULL; assert(session != NULL); @@ -581,7 +577,8 @@ SWITCH_DECLARE(char *) switch_core_permenant_strdup(char *todup) assert(runtime.memory_pool != NULL); - if (!todup) return NULL; + if (!todup) + return NULL; len = strlen(todup) + 1; if (todup && (duped = apr_palloc(runtime.memory_pool, len))) { @@ -598,7 +595,8 @@ SWITCH_DECLARE(char *) switch_core_session_strdup(switch_core_session *session, assert(session != NULL); assert(session->pool != NULL); - if (!todup) return NULL; + if (!todup) + return NULL; len = strlen(todup) + 1; @@ -616,7 +614,8 @@ SWITCH_DECLARE(char *) switch_core_strdup(switch_memory_pool *pool, char *todup) assert(pool != NULL); assert(todup != NULL); - if (!todup) return NULL; + if (!todup) + return NULL; len = strlen(todup) + 1; if (todup && (duped = apr_palloc(pool, len))) { @@ -671,8 +670,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_outgoing_channel(switch_core_s } if (endpoint_interface->io_routines->outgoing_channel) { - if ((status = endpoint_interface->io_routines->outgoing_channel(session, caller_profile, new_session)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.outgoing_channel; ptr ; ptr = ptr->next) { + if ((status = + endpoint_interface->io_routines->outgoing_channel(session, caller_profile, + new_session)) == SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.outgoing_channel; ptr; ptr = ptr->next) { if ((status = ptr->outgoing_channel(session, caller_profile, *new_session)) != SWITCH_STATUS_SUCCESS) { break; } @@ -716,7 +717,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_answer_channel(switch_core_ses assert(session != NULL); if (session->endpoint_interface->io_routines->answer_channel) { if ((status = session->endpoint_interface->io_routines->answer_channel(session)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.answer_channel; ptr ; ptr = ptr->next) { + for (ptr = session->event_hooks.answer_channel; ptr; ptr = ptr->next) { if ((status = ptr->answer_channel(session)) != SWITCH_STATUS_SUCCESS) { break; } @@ -729,15 +730,17 @@ SWITCH_DECLARE(switch_status) switch_core_session_answer_channel(switch_core_ses return status; } -SWITCH_DECLARE(switch_status) switch_core_session_receive_message(switch_core_session *session, switch_core_session_message *message) +SWITCH_DECLARE(switch_status) switch_core_session_receive_message(switch_core_session *session, + switch_core_session_message *message) { struct switch_io_event_hook_receive_message *ptr; switch_status status = SWITCH_STATUS_FALSE; assert(session != NULL); if (session->endpoint_interface->io_routines->receive_message) { - if ((status = session->endpoint_interface->io_routines->receive_message(session, message)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.receive_message; ptr ; ptr = ptr->next) { + if ((status = + session->endpoint_interface->io_routines->receive_message(session, message)) == SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.receive_message; ptr; ptr = ptr->next) { if ((status = ptr->receive_message(session, message)) != SWITCH_STATUS_SUCCESS) { break; } @@ -750,7 +753,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_receive_message(switch_core_se return status; } -SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session *session, switch_frame **frame, int timeout, int stream_id) +SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session *session, switch_frame **frame, + int timeout, int stream_id) { struct switch_io_event_hook_read_frame *ptr; switch_status status = SWITCH_STATUS_FALSE; @@ -763,8 +767,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session timeout, SWITCH_IO_FLAG_NOOP, stream_id)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.read_frame; ptr ; ptr = ptr->next) { - if ((status = ptr->read_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, stream_id)) != SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.read_frame; ptr; ptr = ptr->next) { + if ((status = + ptr->read_frame(session, frame, timeout, SWITCH_IO_FLAG_NOOP, + stream_id)) != SWITCH_STATUS_SUCCESS) { break; } } @@ -776,7 +782,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session } /* if you think this code is redundant.... too bad! I like to understand what I'm doing */ - if ((session->read_codec && (*frame)->codec && session->read_codec->implementation != (*frame)->codec->implementation)) { + if ((session->read_codec && (*frame)->codec + && session->read_codec->implementation != (*frame)->codec->implementation)) { need_codec = TRUE; } @@ -800,9 +807,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session read_frame->datalen, session->read_codec->implementation->samples_per_second, session->raw_read_frame.data, - &session->raw_read_frame.datalen, - &session->raw_read_frame.rate, - &flag); + &session->raw_read_frame.datalen, &session->raw_read_frame.rate, &flag); switch (status) { case SWITCH_STATUS_RESAMPLE: @@ -811,8 +816,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session read_frame->codec->implementation->samples_per_second, read_frame->codec->implementation->bytes_per_frame * 20, session->read_codec->implementation->samples_per_second, - session->read_codec->implementation->bytes_per_frame * 20, - session->pool); + session->read_codec->implementation->bytes_per_frame * 20, session->pool); } case SWITCH_STATUS_SUCCESS: read_frame = &session->raw_read_frame; @@ -821,7 +825,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session status = SWITCH_STATUS_SUCCESS; break; default: - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s decoder error!\n", session->read_codec->codec_interface->interface_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s decoder error!\n", + session->read_codec->codec_interface->interface_name); return status; break; } @@ -829,13 +834,12 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session if (session->read_resampler) { short *data = read_frame->data; - session->read_resampler->from_len = switch_short_to_float(data, session->read_resampler->from, (int)read_frame->datalen / 2 ); - session->read_resampler->to_len = switch_resample_process(session->read_resampler, - session->read_resampler->from, - session->read_resampler->from_len, - session->read_resampler->to, - (int)session->read_resampler->to_size, - 0); + session->read_resampler->from_len = + switch_short_to_float(data, session->read_resampler->from, (int) read_frame->datalen / 2); + session->read_resampler->to_len = + switch_resample_process(session->read_resampler, session->read_resampler->from, + session->read_resampler->from_len, session->read_resampler->to, + (int) session->read_resampler->to_size, 0); switch_float_to_short(session->read_resampler->to, data, read_frame->datalen); read_frame->samples = session->read_resampler->to_len; read_frame->datalen = session->read_resampler->to_len * 2; @@ -846,7 +850,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session if ((*frame)->datalen == session->read_codec->implementation->bytes_per_frame) { perfect = TRUE; } else { - if (! session->raw_read_buffer) { + if (!session->raw_read_buffer) { int bytes = session->read_codec->implementation->bytes_per_frame * 10; switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Engaging Read Buffer at %d bytes\n", bytes); switch_buffer_create(session->pool, &session->raw_read_buffer, bytes); @@ -865,7 +869,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session } else { session->raw_read_frame.datalen = switch_buffer_read(session->raw_read_buffer, session->raw_read_frame.data, - session->read_codec->implementation->bytes_per_frame); + session->read_codec->implementation-> + bytes_per_frame); session->raw_read_frame.rate = session->read_codec->implementation->samples_per_second; enc_frame = &session->raw_read_frame; } @@ -877,8 +882,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session (*frame)->codec->implementation->samples_per_second, session->enc_read_frame.data, &session->enc_read_frame.datalen, - &session->enc_read_frame.rate, - &flag); + &session->enc_read_frame.rate, &flag); switch (status) { @@ -892,7 +896,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session status = SWITCH_STATUS_SUCCESS; break; default: - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", session->read_codec->codec_interface->interface_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", + session->read_codec->codec_interface->interface_name); *frame = NULL; status = SWITCH_STATUS_GENERR; break; @@ -904,13 +909,17 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session return status; } -static switch_status perform_write(switch_core_session *session, switch_frame *frame, int timeout, switch_io_flag flags, int stream_id) { +static switch_status perform_write(switch_core_session *session, switch_frame *frame, int timeout, switch_io_flag flags, + int stream_id) +{ struct switch_io_event_hook_write_frame *ptr; switch_status status = SWITCH_STATUS_FALSE; if (session->endpoint_interface->io_routines->write_frame) { - if ((status = session->endpoint_interface->io_routines->write_frame(session, frame, timeout, flags, stream_id)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.write_frame; ptr ; ptr = ptr->next) { + if ((status = + session->endpoint_interface->io_routines->write_frame(session, frame, timeout, flags, + stream_id)) == SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.write_frame; ptr; ptr = ptr->next) { if ((status = ptr->write_frame(session, frame, timeout, flags, stream_id)) != SWITCH_STATUS_SUCCESS) { break; } @@ -920,7 +929,8 @@ static switch_status perform_write(switch_core_session *session, switch_frame *f return status; } -SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_session *session, switch_frame *frame, int timeout, int stream_id) +SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_session *session, switch_frame *frame, + int timeout, int stream_id) { switch_status status = SWITCH_STATUS_FALSE; @@ -950,9 +960,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio frame->datalen, session->write_codec->implementation->samples_per_second, session->raw_write_frame.data, - &session->raw_write_frame.datalen, - &session->raw_write_frame.rate, - &flag); + &session->raw_write_frame.datalen, &session->raw_write_frame.rate, &flag); switch (status) { case SWITCH_STATUS_RESAMPLE: @@ -974,21 +982,21 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio status = SWITCH_STATUS_SUCCESS; break; default: - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s decoder error!\n", frame->codec->codec_interface->interface_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s decoder error!\n", + frame->codec->codec_interface->interface_name); return status; break; } - } + } if (session->write_resampler) { short *data = write_frame->data; - session->write_resampler->from_len = switch_short_to_float(data, session->write_resampler->from, (int)write_frame->datalen / 2); - session->write_resampler->to_len = switch_resample_process(session->write_resampler, - session->write_resampler->from, - session->write_resampler->from_len, - session->write_resampler->to, - (int)session->write_resampler->to_size, - 0); + session->write_resampler->from_len = + switch_short_to_float(data, session->write_resampler->from, (int) write_frame->datalen / 2); + session->write_resampler->to_len = + switch_resample_process(session->write_resampler, session->write_resampler->from, + session->write_resampler->from_len, session->write_resampler->to, + (int) session->write_resampler->to_size, 0); switch_float_to_short(session->write_resampler->to, data, write_frame->datalen * 2); write_frame->samples = session->write_resampler->to_len; write_frame->datalen = session->write_resampler->to_len * 2; @@ -1003,9 +1011,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Engaging Write Buffer at %d bytes to accomidate %d->%d\n", bytes, - write_frame->datalen, - session->write_codec->implementation->bytes_per_frame); - if ((status = switch_buffer_create(session->pool, &session->raw_write_buffer, bytes)) != SWITCH_STATUS_SUCCESS) { + write_frame->datalen, session->write_codec->implementation->bytes_per_frame); + if ((status = + switch_buffer_create(session->pool, &session->raw_write_buffer, + bytes)) != SWITCH_STATUS_SUCCESS) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Write Buffer Failed!\n"); return status; } @@ -1026,8 +1035,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio session->write_codec->implementation->samples_per_second, session->enc_write_frame.data, &session->enc_write_frame.datalen, - &session->enc_write_frame.rate, - &flag); + &session->enc_write_frame.rate, &flag); switch (status) { case SWITCH_STATUS_RESAMPLE: @@ -1040,7 +1048,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio status = SWITCH_STATUS_SUCCESS; break; default: - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", session->read_codec->codec_interface->interface_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", + session->read_codec->codec_interface->interface_name); write_frame = NULL; return status; break; @@ -1058,9 +1067,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio int x; for (x = 0; x < frames; x++) { if ((session->raw_write_frame.datalen = - switch_buffer_read(session->raw_write_buffer, - session->raw_write_frame.data, - bytes))) { + switch_buffer_read(session->raw_write_buffer, session->raw_write_frame.data, bytes))) { enc_frame = &session->raw_write_frame; session->raw_write_frame.rate = session->write_codec->implementation->samples_per_second; @@ -1072,8 +1079,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio frame->codec->implementation->samples_per_second, session->enc_write_frame.data, &session->enc_write_frame.datalen, - &session->enc_write_frame.rate, - &flag); + &session->enc_write_frame.rate, &flag); @@ -1084,9 +1090,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio status = switch_resample_create(&session->read_resampler, frame->codec->implementation->samples_per_second, frame->codec->implementation->bytes_per_frame * 20, - session->write_codec->implementation->samples_per_second, - session->write_codec->implementation->bytes_per_frame * 20, - session->pool); + session->write_codec->implementation-> + samples_per_second, + session->write_codec->implementation-> + bytes_per_frame * 20, session->pool); } break; case SWITCH_STATUS_SUCCESS: @@ -1097,7 +1104,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio status = SWITCH_STATUS_SUCCESS; break; default: - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", session->read_codec->codec_interface->interface_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Codec %s encoder error!\n", + session->read_codec->codec_interface->interface_name); write_frame = NULL; return status; break; @@ -1105,16 +1113,16 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio if (session->read_resampler) { short *data = write_frame->data; - + session->read_resampler->from_len = switch_short_to_float(data, - session->read_resampler->from, - (int)write_frame->datalen / 2); - session->read_resampler->to_len = switch_resample_process(session->read_resampler, session->read_resampler->from, - session->read_resampler->from_len, - session->read_resampler->to, - (int)session->read_resampler->to_size, - 0); + (int) write_frame->datalen / + 2); + session->read_resampler->to_len = + switch_resample_process(session->read_resampler, session->read_resampler->from, + session->read_resampler->from_len, + session->read_resampler->to, + (int) session->read_resampler->to_size, 0); switch_float_to_short(session->read_resampler->to, data, write_frame->datalen * 2); write_frame->samples = session->read_resampler->to_len; write_frame->datalen = session->read_resampler->to_len * 2; @@ -1140,7 +1148,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_kill_channel(switch_core_sessi if (session->endpoint_interface->io_routines->kill_channel) { if ((status = session->endpoint_interface->io_routines->kill_channel(session, sig)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.kill_channel; ptr ; ptr = ptr->next) { + for (ptr = session->event_hooks.kill_channel; ptr; ptr = ptr->next) { if ((status = ptr->kill_channel(session, sig)) != SWITCH_STATUS_SUCCESS) { break; } @@ -1158,8 +1166,10 @@ SWITCH_DECLARE(switch_status) switch_core_session_waitfor_read(switch_core_sessi switch_status status = SWITCH_STATUS_FALSE; if (session->endpoint_interface->io_routines->waitfor_read) { - if ((status = session->endpoint_interface->io_routines->waitfor_read(session, timeout, stream_id)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.waitfor_read; ptr ; ptr = ptr->next) { + if ((status = + session->endpoint_interface->io_routines->waitfor_read(session, timeout, + stream_id)) == SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.waitfor_read; ptr; ptr = ptr->next) { if ((status = ptr->waitfor_read(session, timeout, stream_id)) != SWITCH_STATUS_SUCCESS) { break; } @@ -1171,14 +1181,17 @@ SWITCH_DECLARE(switch_status) switch_core_session_waitfor_read(switch_core_sessi } -SWITCH_DECLARE(switch_status) switch_core_session_waitfor_write(switch_core_session *session, int timeout, int stream_id) +SWITCH_DECLARE(switch_status) switch_core_session_waitfor_write(switch_core_session *session, int timeout, + int stream_id) { struct switch_io_event_hook_waitfor_write *ptr; switch_status status = SWITCH_STATUS_FALSE; if (session->endpoint_interface->io_routines->waitfor_write) { - if ((status = session->endpoint_interface->io_routines->waitfor_write(session, timeout, stream_id)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.waitfor_write; ptr ; ptr = ptr->next) { + if ((status = + session->endpoint_interface->io_routines->waitfor_write(session, timeout, + stream_id)) == SWITCH_STATUS_SUCCESS) { + for (ptr = session->event_hooks.waitfor_write; ptr; ptr = ptr->next) { if ((status = ptr->waitfor_write(session, timeout, stream_id)) != SWITCH_STATUS_SUCCESS) { break; } @@ -1190,14 +1203,14 @@ SWITCH_DECLARE(switch_status) switch_core_session_waitfor_write(switch_core_sess } -SWITCH_DECLARE(switch_status) switch_core_session_send_dtmf(switch_core_session *session, char *dtmf) +SWITCH_DECLARE(switch_status) switch_core_session_send_dtmf(switch_core_session *session, char *dtmf) { struct switch_io_event_hook_send_dtmf *ptr; switch_status status = SWITCH_STATUS_FALSE; if (session->endpoint_interface->io_routines->send_dtmf) { if ((status = session->endpoint_interface->io_routines->send_dtmf(session, dtmf)) == SWITCH_STATUS_SUCCESS) { - for (ptr = session->event_hooks.send_dtmf; ptr ; ptr = ptr->next) { + for (ptr = session->event_hooks.send_dtmf; ptr; ptr = ptr->next) { if ((status = ptr->send_dtmf(session, dtmf)) != SWITCH_STATUS_SUCCESS) { break; } @@ -1208,7 +1221,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_send_dtmf(switch_core_session return status; } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_outgoing(switch_core_session *session, switch_outgoing_channel_hook outgoing_channel) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_outgoing(switch_core_session *session, + switch_outgoing_channel_hook outgoing_channel) { switch_io_event_hook_outgoing_channel *hook, *ptr; @@ -1218,7 +1232,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_outgoing(switch if (!session->event_hooks.outgoing_channel) { session->event_hooks.outgoing_channel = hook; } else { - for(ptr = session->event_hooks.outgoing_channel ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.outgoing_channel; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1229,7 +1243,9 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_outgoing(switch return SWITCH_STATUS_MEMERR; } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_answer_channel(switch_core_session *session, switch_answer_channel_hook answer_channel) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_answer_channel(switch_core_session *session, + switch_answer_channel_hook + answer_channel) { switch_io_event_hook_answer_channel *hook, *ptr; @@ -1239,7 +1255,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_answer_channel( if (!session->event_hooks.answer_channel) { session->event_hooks.answer_channel = hook; } else { - for(ptr = session->event_hooks.answer_channel ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.answer_channel; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1251,7 +1267,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_answer_channel( } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_read_frame(switch_core_session *session, switch_read_frame_hook read_frame) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_read_frame(switch_core_session *session, + switch_read_frame_hook read_frame) { switch_io_event_hook_read_frame *hook, *ptr; @@ -1261,7 +1278,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_read_frame(swit if (!session->event_hooks.read_frame) { session->event_hooks.read_frame = hook; } else { - for(ptr = session->event_hooks.read_frame ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.read_frame; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1273,7 +1290,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_read_frame(swit } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_write_frame(switch_core_session *session, switch_write_frame_hook write_frame) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_write_frame(switch_core_session *session, + switch_write_frame_hook write_frame) { switch_io_event_hook_write_frame *hook, *ptr; @@ -1283,7 +1301,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_write_frame(swi if (!session->event_hooks.write_frame) { session->event_hooks.write_frame = hook; } else { - for(ptr = session->event_hooks.write_frame ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.write_frame; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1295,7 +1313,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_write_frame(swi } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_kill_channel(switch_core_session *session, switch_kill_channel_hook kill_channel) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_kill_channel(switch_core_session *session, + switch_kill_channel_hook kill_channel) { switch_io_event_hook_kill_channel *hook, *ptr; @@ -1305,7 +1324,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_kill_channel(sw if (!session->event_hooks.kill_channel) { session->event_hooks.kill_channel = hook; } else { - for(ptr = session->event_hooks.kill_channel ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.kill_channel; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1317,7 +1336,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_kill_channel(sw } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_read(switch_core_session *session, switch_waitfor_read_hook waitfor_read) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_read(switch_core_session *session, + switch_waitfor_read_hook waitfor_read) { switch_io_event_hook_waitfor_read *hook, *ptr; @@ -1327,7 +1347,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_read(sw if (!session->event_hooks.waitfor_read) { session->event_hooks.waitfor_read = hook; } else { - for(ptr = session->event_hooks.waitfor_read ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.waitfor_read; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1339,7 +1359,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_read(sw } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_write(switch_core_session *session, switch_waitfor_write_hook waitfor_write) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_write(switch_core_session *session, + switch_waitfor_write_hook waitfor_write) { switch_io_event_hook_waitfor_write *hook, *ptr; @@ -1349,7 +1370,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_write(s if (!session->event_hooks.waitfor_write) { session->event_hooks.waitfor_write = hook; } else { - for(ptr = session->event_hooks.waitfor_write ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.waitfor_write; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1362,7 +1383,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_waitfor_write(s } -SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_send_dtmf(switch_core_session *session, switch_send_dtmf_hook send_dtmf) +SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_send_dtmf(switch_core_session *session, + switch_send_dtmf_hook send_dtmf) { switch_io_event_hook_send_dtmf *hook, *ptr; @@ -1372,7 +1394,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_add_event_hook_send_dtmf(switc if (!session->event_hooks.send_dtmf) { session->event_hooks.send_dtmf = hook; } else { - for(ptr = session->event_hooks.send_dtmf ; ptr && ptr->next; ptr = ptr->next); + for (ptr = session->event_hooks.send_dtmf; ptr && ptr->next; ptr = ptr->next); ptr->next = hook; } @@ -1459,16 +1481,21 @@ static void switch_core_standard_on_execute(switch_core_session *session) } while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Execute %s(%s)\n", extension->current_application->application_name, + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Execute %s(%s)\n", + extension->current_application->application_name, extension->current_application->application_data); - if (!(application_interface = switch_loadable_module_get_application_interface(extension->current_application->application_name))) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Invalid Application %s\n", extension->current_application->application_name); + if (! + (application_interface = + switch_loadable_module_get_application_interface(extension->current_application->application_name))) { + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Invalid Application %s\n", + extension->current_application->application_name); switch_channel_set_state(session->channel, CS_HANGUP); return; } if (!application_interface->application_function) { - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "No Function for %s\n", extension->current_application->application_name); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "No Function for %s\n", + extension->current_application->application_name); switch_channel_set_state(session->channel, CS_HANGUP); return; } @@ -1489,7 +1516,7 @@ static void switch_core_standard_on_loopback(switch_core_session *session) switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Standard LOOPBACK\n"); while ((state = switch_channel_get_state(session->channel)) == CS_LOOPBACK) { - for(stream_id = 0; stream_id < session->stream_count; stream_id++) { + for (stream_id = 0; stream_id < session->stream_count; stream_id++) { if (switch_core_session_read_frame(session, &frame, -1, stream_id) == SWITCH_STATUS_SUCCESS) { switch_core_session_write_frame(session, frame, -1, stream_id); } @@ -1516,20 +1543,20 @@ SWITCH_DECLARE(void) switch_core_session_run(switch_core_session *session) const switch_event_handler_table *application_event_handlers = NULL; /* - Life of the channel. you have channel and pool in your session - everywhere you go you use the session to malloc with - switch_core_session_alloc(session, <size>) + Life of the channel. you have channel and pool in your session + everywhere you go you use the session to malloc with + switch_core_session_alloc(session, <size>) - The enpoint module gets the first crack at implementing the state - if it wants to, it can cancel the default behaviour by returning SWITCH_STATUS_FALSE + The enpoint module gets the first crack at implementing the state + if it wants to, it can cancel the default behaviour by returning SWITCH_STATUS_FALSE - Next comes the channel's event handler table that can be set by an application - which also can veto the next behaviour in line by returning SWITCH_STATUS_FALSE + Next comes the channel's event handler table that can be set by an application + which also can veto the next behaviour in line by returning SWITCH_STATUS_FALSE - Finally the default state behaviour is called. + Finally the default state behaviour is called. - */ + */ assert(session != NULL); application_event_handlers = switch_channel_get_event_handlers(session->channel); @@ -1552,93 +1579,93 @@ SWITCH_DECLARE(void) switch_core_session_run(switch_core_session *session) switch_event_fire(&event); } - switch ( state ) { - case CS_NEW: /* Just created, Waiting for first instructions */ + switch (state) { + case CS_NEW: /* Just created, Waiting for first instructions */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State NEW\n"); break; case CS_DONE: continue; break; - case CS_HANGUP: /* Deactivate and end the thread */ + case CS_HANGUP: /* Deactivate and end the thread */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State HANGUP\n"); if (!driver_event_handlers->on_hangup || (driver_event_handlers->on_hangup && - driver_event_handlers->on_hangup(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_hangup(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_hangup || (application_event_handlers->on_hangup && - application_event_handlers->on_hangup(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_hangup(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_hangup(session); } } switch_channel_set_state(session->channel, CS_DONE); break; - case CS_INIT: /* Basic setup tasks */ + case CS_INIT: /* Basic setup tasks */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State INIT\n"); if (!driver_event_handlers->on_init || (driver_event_handlers->on_init && - driver_event_handlers->on_init(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_init(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_init || (application_event_handlers->on_init && - application_event_handlers->on_init(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_init(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_init(session); } } break; - case CS_RING: /* Look for a dialplan and find something to do */ + case CS_RING: /* Look for a dialplan and find something to do */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State RING\n"); if (!driver_event_handlers->on_ring || (driver_event_handlers->on_ring && - driver_event_handlers->on_ring(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_ring(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_ring || (application_event_handlers->on_ring && - application_event_handlers->on_ring(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_ring(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_ring(session); } } break; - case CS_EXECUTE: /* Execute an Operation*/ + case CS_EXECUTE: /* Execute an Operation */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State EXECUTE\n"); if (!driver_event_handlers->on_execute || (driver_event_handlers->on_execute && - driver_event_handlers->on_execute(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_execute(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_execute || (application_event_handlers->on_execute && - application_event_handlers->on_execute(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_execute(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_execute(session); } } break; - case CS_LOOPBACK: /* loop all data back to source */ + case CS_LOOPBACK: /* loop all data back to source */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State LOOPBACK\n"); if (!driver_event_handlers->on_loopback || (driver_event_handlers->on_loopback && - driver_event_handlers->on_loopback(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_loopback(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_loopback || (application_event_handlers->on_loopback && - application_event_handlers->on_loopback(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_loopback(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_loopback(session); } } break; - case CS_TRANSMIT: /* send/recieve data to/from another channel */ + case CS_TRANSMIT: /* send/recieve data to/from another channel */ switch_console_printf(SWITCH_CHANNEL_CONSOLE, "State TRANSMIT\n"); if (!driver_event_handlers->on_transmit || (driver_event_handlers->on_transmit && - driver_event_handlers->on_transmit(session) == SWITCH_STATUS_SUCCESS && + driver_event_handlers->on_transmit(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { if (!application_event_handlers || !application_event_handlers->on_transmit || (application_event_handlers->on_transmit && - application_event_handlers->on_transmit(session) == SWITCH_STATUS_SUCCESS && + application_event_handlers->on_transmit(session) == SWITCH_STATUS_SUCCESS && midstate == switch_channel_get_state(session->channel))) { switch_core_standard_on_transmit(session); } @@ -1741,17 +1768,12 @@ SWITCH_DECLARE(void) switch_core_launch_thread(switch_thread_start_t func, void } ts->objs[0] = obj; - switch_thread_create(&thread, - thd_attr, - func, - ts, - pool - ); + switch_thread_create(&thread, thd_attr, func, ts, pool); } } -static void * SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *thread, void *obj) +static void *SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *thread, void *obj) { switch_core_session *session = obj; @@ -1759,7 +1781,7 @@ static void * SWITCH_THREAD_FUNC switch_core_session_thread(switch_thread *threa session->thread = thread; session->id = runtime.session_id++; - if(runtime.session_id >= sizeof(unsigned long)) + if (runtime.session_id >= sizeof(unsigned long)) runtime.session_id = 1; snprintf(session->name, sizeof(session->name), "%ld", session->id); @@ -1781,30 +1803,21 @@ SWITCH_DECLARE(void) switch_core_session_thread_launch(switch_core_session *sess switch_threadattr_create(&thd_attr, session->pool); switch_threadattr_detach_set(thd_attr, 1); - if (switch_thread_create(&thread, - thd_attr, - switch_core_session_thread, - session, - session->pool - ) != APR_SUCCESS) { + if (switch_thread_create(&thread, thd_attr, switch_core_session_thread, session, session->pool) != APR_SUCCESS) { switch_core_session_destroy(&session); } } -SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session *session, switch_thread_start_t func, void *obj) +SWITCH_DECLARE(void) switch_core_session_launch_thread(switch_core_session *session, switch_thread_start_t func, + void *obj) { switch_thread *thread; switch_threadattr_t *thd_attr = NULL; switch_threadattr_create(&thd_attr, session->pool); switch_threadattr_detach_set(thd_attr, 1); - switch_thread_create(&thread, - thd_attr, - func, - obj, - session->pool - ); + switch_thread_create(&thread, thd_attr, func, obj, session->pool); } @@ -1820,7 +1833,8 @@ SWITCH_DECLARE(void *) switch_core_alloc(switch_memory_pool *pool, size_t memory return ptr; } -SWITCH_DECLARE(switch_core_session *) switch_core_session_request(const switch_endpoint_interface *endpoint_interface, switch_memory_pool *pool) +SWITCH_DECLARE(switch_core_session *) switch_core_session_request(const switch_endpoint_interface *endpoint_interface, + switch_memory_pool *pool) { switch_memory_pool *usepool; switch_core_session *session; @@ -1869,7 +1883,7 @@ SWITCH_DECLARE(switch_core_session *) switch_core_session_request(const switch_e session->enc_read_frame.data = session->enc_read_buf; session->enc_read_frame.buflen = sizeof(session->enc_read_buf); - switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED ,session->pool); + switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED, session->pool); switch_thread_cond_create(&session->cond, session->pool); return session; @@ -1888,11 +1902,11 @@ SWITCH_DECLARE(switch_core_session *) switch_core_session_request_by_name(char * } -static void core_event_handler (switch_event *event) +static void core_event_handler(switch_event *event) { char buf[1024]; - switch(event->event_id) { + switch (event->event_id) { case SWITCH_EVENT_LOG: return; break; @@ -1936,13 +1950,14 @@ SWITCH_DECLARE(switch_status) switch_core_init(void) switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Error Opening DB!\n"); } else { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Opening DB\n"); - if (switch_event_bind("core_db", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL) != SWITCH_STATUS_SUCCESS) { + if (switch_event_bind("core_db", SWITCH_EVENT_ALL, SWITCH_EVENT_SUBCLASS_ANY, core_event_handler, NULL) != + SWITCH_STATUS_SUCCESS) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Couldn't bind event handler!\n"); } } #ifdef EMBED_PERL - if (! (my_perl = perl_alloc())) { + if (!(my_perl = perl_alloc())) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Could not allocate perl intrepreter\n"); switch_core_destroy(); return SWITCH_STATUS_MEMERR; @@ -1961,12 +1976,12 @@ SWITCH_DECLARE(switch_status) switch_core_init(void) switch_core_hash_init(&runtime.session_table, runtime.memory_pool); /* set signal handlers and startup time */ - (void) signal(SIGINT,(void *) handle_SIGINT); + (void) signal(SIGINT, (void *) handle_SIGINT); #ifdef SIGPIPE - (void) signal(SIGPIPE,(void *) handle_SIGPIPE); + (void) signal(SIGPIPE, (void *) handle_SIGPIPE); #endif #ifdef TRAP_BUS - (void) signal(SIGBUS,(void *) handle_SIGBUS); + (void) signal(SIGBUS, (void *) handle_SIGBUS); #endif time(&runtime.initiated); @@ -2000,4 +2015,3 @@ SWITCH_DECLARE(switch_status) switch_core_destroy(void) return SWITCH_STATUS_SUCCESS; } - diff --git a/src/switch_event.c b/src/switch_event.c index aa9e7c5fd8..96b538d10b 100644 --- a/src/switch_event.c +++ b/src/switch_event.c @@ -31,7 +31,7 @@ */ #include <switch_event.h> -static switch_event_node *EVENT_NODES[SWITCH_EVENT_ALL+1] = {NULL}; +static switch_event_node *EVENT_NODES[SWITCH_EVENT_ALL + 1] = { NULL }; static switch_mutex_t *BLOCK = NULL; static switch_mutex_t *POOL_LOCK = NULL; static switch_memory_pool *RUNTIME_POOL = NULL; @@ -59,10 +59,10 @@ static void *locked_alloc(size_t len) void *mem; switch_mutex_lock(POOL_LOCK); - /* <LOCKED> -----------------------------------------------*/ + /* <LOCKED> ----------------------------------------------- */ mem = switch_core_alloc(THRUNTIME_POOL, len); switch_mutex_unlock(POOL_LOCK); - /* </LOCKED> ----------------------------------------------*/ + /* </LOCKED> ---------------------------------------------- */ return mem; } @@ -72,13 +72,14 @@ static void *locked_dup(char *str) char *dup; switch_mutex_lock(POOL_LOCK); - /* <LOCKED> -----------------------------------------------*/ + /* <LOCKED> ----------------------------------------------- */ dup = switch_core_strdup(THRUNTIME_POOL, str); switch_mutex_unlock(POOL_LOCK); - /* </LOCKED> ----------------------------------------------*/ + /* </LOCKED> ---------------------------------------------- */ return dup; } + #define ALLOC(size) locked_alloc(size) #define DUP(str) locked_dup(str) #endif @@ -139,7 +140,7 @@ static int switch_events_match(switch_event *event, switch_event_node *node) return match; } -static void * SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void *obj) +static void *SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void *obj) { switch_event_node *node; switch_event *out_event = NULL; @@ -149,11 +150,11 @@ static void * SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void assert(POOL_LOCK != NULL); assert(RUNTIME_POOL != NULL); THREAD_RUNNING = 1; - while(THREAD_RUNNING == 1 || switch_queue_size(EVENT_QUEUE)) { + while (THREAD_RUNNING == 1 || switch_queue_size(EVENT_QUEUE)) { #ifdef MALLOC_EVENTS switch_mutex_lock(POOL_LOCK); - /* <LOCKED> -----------------------------------------------*/ + /* <LOCKED> ----------------------------------------------- */ if (POOL_COUNT >= POOL_COUNT_MAX) { if (THRUNTIME_POOL == APOOL) { THRUNTIME_POOL = BPOOL; @@ -164,14 +165,14 @@ static void * SWITCH_THREAD_FUNC switch_event_thread(switch_thread *thread, void POOL_COUNT = 0; } switch_mutex_unlock(POOL_LOCK); - /* </LOCKED> -----------------------------------------------*/ + /* </LOCKED> ----------------------------------------------- */ #endif while (switch_queue_trypop(EVENT_QUEUE, &pop) == SWITCH_STATUS_SUCCESS) { out_event = pop; - for(e = out_event->event_id;; e = SWITCH_EVENT_ALL) { - for(node = EVENT_NODES[e]; node; node = node->next) { + for (e = out_event->event_id;; e = SWITCH_EVENT_ALL) { + for (node = EVENT_NODES[e]; node; node = node->next) { if (switch_events_match(out_event, node)) { out_event->bind_user_data = node->user_data; node->callback(out_event); @@ -234,7 +235,7 @@ SWITCH_DECLARE(switch_status) switch_event_shutdown(void) { THREAD_RUNNING = -1; - while(THREAD_RUNNING) { + while (THREAD_RUNNING) { switch_yield(1000); } return SWITCH_STATUS_SUCCESS; @@ -267,31 +268,26 @@ SWITCH_DECLARE(switch_status) switch_event_init(switch_memory_pool *pool) switch_mutex_init(&BLOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL); switch_mutex_init(&POOL_LOCK, SWITCH_MUTEX_NESTED, RUNTIME_POOL); switch_core_hash_init(&CUSTOM_HASH, RUNTIME_POOL); - switch_thread_create(&thread, - thd_attr, - switch_event_thread, - NULL, - RUNTIME_POOL - ); + switch_thread_create(&thread, thd_attr, switch_event_thread, NULL, RUNTIME_POOL); - while(!THREAD_RUNNING) { + while (!THREAD_RUNNING) { switch_yield(1000); } return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_event_create_subclass(switch_event **event, switch_event_t event_id, char *subclass_name) +SWITCH_DECLARE(switch_status) switch_event_create_subclass(switch_event **event, switch_event_t event_id, + char *subclass_name) { if (event_id != SWITCH_EVENT_CUSTOM && subclass_name) { return SWITCH_STATUS_GENERR; } - if(!(*event = ALLOC(sizeof(switch_event)))) { + if (!(*event = ALLOC(sizeof(switch_event)))) { return SWITCH_STATUS_MEMERR; } - #ifdef MALLOC_EVENTS memset(*event, 0, sizeof(switch_event)); #endif @@ -309,7 +305,7 @@ SWITCH_DECLARE(char *) switch_event_get_header(switch_event *event, char *header { switch_event_header *hp; if (header_name) { - for(hp = event->headers; hp; hp = hp->next) { + for (hp = event->headers; hp; hp = hp->next) { if (!strcasecmp(hp->name, header_name)) { return hp->value; } @@ -318,7 +314,8 @@ SWITCH_DECLARE(char *) switch_event_get_header(switch_event *event, char *header return NULL; } -SWITCH_DECLARE(switch_status) switch_event_add_header(switch_event *event, switch_stack_t stack, char *header_name, char *fmt, ...) +SWITCH_DECLARE(switch_status) switch_event_add_header(switch_event *event, switch_stack_t stack, char *header_name, + char *fmt, ...) { int ret = 0; char data[2048]; @@ -459,7 +456,7 @@ SWITCH_DECLARE(switch_status) switch_event_serialize(switch_event *event, char * } for (hp = event->headers; hp; hp = hp->next) { - snprintf(buf+len, buflen-len, "%s: %s\n", hp->name, hp->value); + snprintf(buf + len, buflen - len, "%s: %s\n", hp->name, hp->value); len = strlen(buf); } @@ -471,14 +468,14 @@ SWITCH_DECLARE(switch_status) switch_event_serialize(switch_event *event, char * } if (body) { - int blen = (int)strlen(body); + int blen = (int) strlen(body); if (blen) { - snprintf(buf+len, buflen-len, "Content-Length: %d\n\n%s", blen, body); + snprintf(buf + len, buflen - len, "Content-Length: %d\n\n%s", blen, body); } else { - snprintf(buf+len, buflen-len, "\n"); + snprintf(buf + len, buflen - len, "\n"); } } else { - snprintf(buf+len, buflen-len, "\n"); + snprintf(buf + len, buflen - len, "\n"); } if (data) { @@ -489,7 +486,8 @@ SWITCH_DECLARE(switch_status) switch_event_serialize(switch_event *event, char * } -SWITCH_DECLARE(switch_status) switch_event_fire_detailed(char *file, char *func, int line, switch_event **event, void *user_data) +SWITCH_DECLARE(switch_status) switch_event_fire_detailed(char *file, char *func, int line, switch_event **event, + void *user_data) { switch_time_exp_t tm; @@ -535,7 +533,8 @@ SWITCH_DECLARE(switch_status) switch_event_fire_detailed(char *file, char *func, return SWITCH_STATUS_SUCCESS; } -SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, char *subclass_name, switch_event_callback_t callback, void *user_data) +SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, char *subclass_name, + switch_event_callback_t callback, void *user_data) { switch_event_node *event_node; switch_event_subclass *subclass = NULL; @@ -556,7 +555,7 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, if (event <= SWITCH_EVENT_ALL && (event_node = switch_core_alloc(RUNTIME_POOL, sizeof(switch_event_node)))) { switch_mutex_lock(BLOCK); - /* <LOCKED> -----------------------------------------------*/ + /* <LOCKED> ----------------------------------------------- */ event_node->id = switch_core_strdup(RUNTIME_POOL, id); event_node->event_id = event; event_node->subclass = subclass; @@ -569,10 +568,9 @@ SWITCH_DECLARE(switch_status) switch_event_bind(char *id, switch_event_t event, EVENT_NODES[event] = event_node; switch_mutex_unlock(BLOCK); - /* </LOCKED> -----------------------------------------------*/ + /* </LOCKED> ----------------------------------------------- */ return SWITCH_STATUS_SUCCESS; } return SWITCH_STATUS_MEMERR; } - diff --git a/src/switch_loadable_module.c b/src/switch_loadable_module.c index 2f0ad5d22d..8c82e9af87 100644 --- a/src/switch_loadable_module.c +++ b/src/switch_loadable_module.c @@ -91,7 +91,8 @@ static void *switch_loadable_module_exec(switch_thread *thread, void *obj) return NULL; } -static switch_status switch_loadable_module_load_file(char *filename, switch_memory_pool *pool, switch_loadable_module **new_module) +static switch_status switch_loadable_module_load_file(char *filename, switch_memory_pool *pool, + switch_loadable_module **new_module) { switch_loadable_module *module = NULL; apr_dso_handle_t *dso = NULL; @@ -129,7 +130,7 @@ static switch_status switch_loadable_module_load_file(char *filename, switch_mem break; } - if (! (module = switch_core_permenant_alloc( sizeof(switch_loadable_module) ))) { + if (!(module = switch_core_permenant_alloc(sizeof(switch_loadable_module)))) { err = "Could not allocate memory\n"; break; } @@ -192,7 +193,7 @@ SWITCH_DECLARE(switch_status) switch_loadable_module_init() char *ptr; apr_finfo_t finfo; apr_dir_t *module_dir_handle; - apr_int32_t finfo_flags = APR_FINFO_DIRENT|APR_FINFO_TYPE|APR_FINFO_NAME; + apr_int32_t finfo_flags = APR_FINFO_DIRENT | APR_FINFO_TYPE | APR_FINFO_NAME; switch_loadable_module *new_module; #ifdef WIN32 const char *ext = ".dll"; @@ -250,9 +251,7 @@ SWITCH_DECLARE(switch_status) switch_loadable_module_init() const switch_endpoint_interface *ptr; for (ptr = new_module->interface->endpoint_interface; ptr; ptr = ptr->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding Endpoint '%s'\n", ptr->interface_name); - switch_core_hash_insert(loadable_modules.endpoint_hash, - (char *) ptr->interface_name, - (void *) ptr); + switch_core_hash_insert(loadable_modules.endpoint_hash, (char *) ptr->interface_name, (void *) ptr); } } @@ -260,76 +259,64 @@ SWITCH_DECLARE(switch_status) switch_loadable_module_init() const switch_codec_implementation *impl; const switch_codec_interface *ptr; - for(ptr = new_module->interface->codec_interface; ptr; ptr = ptr->next) { - for(impl = ptr->implementations; impl ; impl = impl->next) { + for (ptr = new_module->interface->codec_interface; ptr; ptr = ptr->next) { + for (impl = ptr->implementations; impl; impl = impl->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, - "Adding Codec '%s' (%s) %dkhz %dms\n", - ptr->iananame, - ptr->interface_name, - impl->samples_per_second, - impl->microseconds_per_frame / 1000); + "Adding Codec '%s' (%s) %dkhz %dms\n", + ptr->iananame, + ptr->interface_name, + impl->samples_per_second, impl->microseconds_per_frame / 1000); } - switch_core_hash_insert(loadable_modules.codec_hash, - (char *) ptr->iananame, - (void *) ptr); + switch_core_hash_insert(loadable_modules.codec_hash, (char *) ptr->iananame, (void *) ptr); } } if (new_module->interface->dialplan_interface) { const switch_dialplan_interface *ptr; - for(ptr = new_module->interface->dialplan_interface; ptr; ptr = ptr->next) { + for (ptr = new_module->interface->dialplan_interface; ptr; ptr = ptr->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding Dialplan '%s'\n", ptr->interface_name); - switch_core_hash_insert(loadable_modules.dialplan_hash, - (char *) ptr->interface_name, - (void *) ptr); + switch_core_hash_insert(loadable_modules.dialplan_hash, (char *) ptr->interface_name, (void *) ptr); } } if (new_module->interface->timer_interface) { const switch_timer_interface *ptr; - for(ptr = new_module->interface->timer_interface; ptr; ptr = ptr->next) { + for (ptr = new_module->interface->timer_interface; ptr; ptr = ptr->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding Timer '%s'\n", ptr->interface_name); - switch_core_hash_insert(loadable_modules.timer_hash, - (char *) ptr->interface_name, - (void *) ptr); + switch_core_hash_insert(loadable_modules.timer_hash, (char *) ptr->interface_name, (void *) ptr); } } if (new_module->interface->application_interface) { const switch_application_interface *ptr; - for(ptr = new_module->interface->application_interface; ptr; ptr = ptr->next) { + for (ptr = new_module->interface->application_interface; ptr; ptr = ptr->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding Application '%s'\n", ptr->interface_name); switch_core_hash_insert(loadable_modules.application_hash, - (char *) ptr->interface_name, - (void *) ptr); + (char *) ptr->interface_name, (void *) ptr); } } if (new_module->interface->api_interface) { const switch_api_interface *ptr; - for(ptr = new_module->interface->api_interface; ptr; ptr = ptr->next) { + for (ptr = new_module->interface->api_interface; ptr; ptr = ptr->next) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding API Function '%s'\n", ptr->interface_name); - switch_core_hash_insert(loadable_modules.api_hash, - (char *) ptr->interface_name, - (void *) ptr); + switch_core_hash_insert(loadable_modules.api_hash, (char *) ptr->interface_name, (void *) ptr); } } if (new_module->interface->file_interface) { const switch_file_interface *ptr; - for(ptr = new_module->interface->file_interface; ptr; ptr = ptr->next) { + for (ptr = new_module->interface->file_interface; ptr; ptr = ptr->next) { int i; - for (i = 0 ; ptr->extens[i]; i++) { + for (i = 0; ptr->extens[i]; i++) { switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Adding File Format '%s'\n", ptr->extens[i]); - switch_core_hash_insert(loadable_modules.file_hash, - (char *) ptr->extens[i], - (void *) ptr); + switch_core_hash_insert(loadable_modules.file_hash, (char *) ptr->extens[i], (void *) ptr); } } } @@ -344,7 +331,7 @@ SWITCH_DECLARE(switch_status) switch_loadable_module_init() SWITCH_DECLARE(void) switch_loadable_module_shutdown(void) { - switch_hash_index_t* hi; + switch_hash_index_t *hi; void *val; switch_loadable_module *module; @@ -397,9 +384,10 @@ SWITCH_DECLARE(switch_file_interface *) switch_loadable_module_get_file_interfac return switch_core_hash_find(loadable_modules.file_hash, name); } -SWITCH_DECLARE(int) switch_loadable_module_get_codecs(switch_memory_pool *pool, switch_codec_interface **array, int arraylen) +SWITCH_DECLARE(int) switch_loadable_module_get_codecs(switch_memory_pool *pool, switch_codec_interface **array, + int arraylen) { - switch_hash_index_t* hi; + switch_hash_index_t *hi; void *val; int i = 0; @@ -415,12 +403,13 @@ SWITCH_DECLARE(int) switch_loadable_module_get_codecs(switch_memory_pool *pool, } -SWITCH_DECLARE(int) switch_loadable_module_get_codecs_sorted(switch_memory_pool *pool, switch_codec_interface **array, int arraylen, char **prefs, int preflen) +SWITCH_DECLARE(int) switch_loadable_module_get_codecs_sorted(switch_memory_pool *pool, switch_codec_interface **array, + int arraylen, char **prefs, int preflen) { int x, i = 0; switch_codec_interface *codec_interface; - for(x = 0; x < preflen; x++) { + for (x = 0; x < preflen; x++) { if ((codec_interface = switch_loadable_module_get_codec_interface(prefs[x]))) { array[i++] = codec_interface; } diff --git a/src/switch_mutex.c b/src/switch_mutex.c index 00a69150c7..8cb9b6c4a3 100644 --- a/src/switch_mutex.c +++ b/src/switch_mutex.c @@ -31,9 +31,7 @@ */ #include <switch_mutex.h> -SWITCH_DECLARE(switch_status) switch_mutex_init(switch_mutex_t **lock, - switch_lock_flag flags, - switch_memory_pool *pool) +SWITCH_DECLARE(switch_status) switch_mutex_init(switch_mutex_t **lock, switch_lock_flag flags, switch_memory_pool *pool) { return (apr_thread_mutex_create(lock, flags, pool) == APR_SUCCESS) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_GENERR; @@ -58,5 +56,3 @@ SWITCH_DECLARE(switch_status) switch_mutex_trylock(switch_mutex_t *lock) { return apr_thread_mutex_trylock(lock); } - - diff --git a/src/switch_resample.c b/src/switch_resample.c index 0a98df78bf..64f0285db0 100644 --- a/src/switch_resample.c +++ b/src/switch_resample.c @@ -49,9 +49,7 @@ SWITCH_DECLARE(switch_status) switch_resample_create(switch_audio_resampler **new_resampler, int from_rate, size_t from_size, - int to_rate, - size_t to_size, - switch_memory_pool *pool) + int to_rate, size_t to_size, switch_memory_pool *pool) { switch_audio_resampler *resampler; @@ -61,10 +59,11 @@ SWITCH_DECLARE(switch_status) switch_resample_create(switch_audio_resampler **ne resampler->from_rate = from_rate; resampler->to_rate = to_rate; - resampler->factor = ((double)resampler->to_rate / (double)resampler->from_rate); + resampler->factor = ((double) resampler->to_rate / (double) resampler->from_rate); resampler->resampler = resample_open(QUALITY, resampler->factor, resampler->factor); - switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Activate Resampler %d->%d %f\n", resampler->from_rate, resampler->to_rate, resampler->factor); + switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Activate Resampler %d->%d %f\n", resampler->from_rate, + resampler->to_rate, resampler->factor); resampler->from_size = from_size; resampler->from = (float *) switch_core_alloc(pool, resampler->from_size); resampler->to_size = to_size; @@ -75,14 +74,16 @@ SWITCH_DECLARE(switch_status) switch_resample_create(switch_audio_resampler **ne } -SWITCH_DECLARE(int) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst, int dstlen, int last) +SWITCH_DECLARE(int) switch_resample_process(switch_audio_resampler *resampler, float *src, int srclen, float *dst, + int dstlen, int last) { - int o=0, srcused=0, srcpos=0, out=0; + int o = 0, srcused = 0, srcpos = 0, out = 0; - for(;;) { - int srcBlock = MIN(srclen-srcpos, srclen); - int lastFlag = (last && (srcBlock == srclen-srcpos)); - o = resample_process(resampler->resampler, resampler->factor, &src[srcpos], srcBlock, lastFlag, &srcused, &dst[out], dstlen-out); + for (;;) { + int srcBlock = MIN(srclen - srcpos, srclen); + int lastFlag = (last && (srcBlock == srclen - srcpos)); + o = resample_process(resampler->resampler, resampler->factor, &src[srcpos], srcBlock, lastFlag, &srcused, + &dst[out], dstlen - out); //printf("resampling %d/%d (%d) %d %f\n", srcpos, srclen, MIN(dstlen-out, dstlen), srcused, factor); srcpos += srcused; @@ -106,15 +107,17 @@ SWITCH_DECLARE(size_t) switch_float_to_short(float *f, short *s, size_t len) { size_t i; float ft; - for(i=0;i<len;i++) { + for (i = 0; i < len; i++) { ft = f[i] * NORMFACT; - if(ft >= 0) { - s[i] = (short)(ft+0.5); + if (ft >= 0) { + s[i] = (short) (ft + 0.5); } else { - s[i] = (short)(ft-0.5); + s[i] = (short) (ft - 0.5); } - if ((float)s[i] > MAXSAMPLE) s[i] = (short)MAXSAMPLE; - if (s[i] < (short)-MAXSAMPLE) s[i] = (short)-MAXSAMPLE; + if ((float) s[i] > MAXSAMPLE) + s[i] = (short) MAXSAMPLE; + if (s[i] < (short) -MAXSAMPLE) + s[i] = (short) -MAXSAMPLE; } return len; } @@ -124,16 +127,18 @@ SWITCH_DECLARE(int) switch_char_to_float(char *c, float *f, int len) int i; if (len % 2) { - return(-1); + return (-1); } - for(i=1;i<len;i+=2) { - f[(int)(i/2)] = (float)(((c[i])*0x100) + c[i-1]); - f[(int)(i/2)] /= NORMFACT; - if (f[(int)(i/2)] > MAXSAMPLE) f[(int)(i/2)] = MAXSAMPLE; - if (f[(int)(i/2)] < -MAXSAMPLE) f[(int)(i/2)] = -MAXSAMPLE; + for (i = 1; i < len; i += 2) { + f[(int) (i / 2)] = (float) (((c[i]) * 0x100) + c[i - 1]); + f[(int) (i / 2)] /= NORMFACT; + if (f[(int) (i / 2)] > MAXSAMPLE) + f[(int) (i / 2)] = MAXSAMPLE; + if (f[(int) (i / 2)] < -MAXSAMPLE) + f[(int) (i / 2)] = -MAXSAMPLE; } - return len/2; + return len / 2; } SWITCH_DECLARE(int) switch_float_to_char(float *f, char *c, int len) @@ -141,25 +146,25 @@ SWITCH_DECLARE(int) switch_float_to_char(float *f, char *c, int len) int i; float ft; long l; - for(i=0;i<len;i++) { + for (i = 0; i < len; i++) { ft = f[i] * NORMFACT; if (ft >= 0) { - l = (long)(ft+0.5); + l = (long) (ft + 0.5); } else { - l = (long)(ft-0.5); + l = (long) (ft - 0.5); } - c[i*2] = (unsigned char)((l)&0xff); - c[i*2+1] = (unsigned char)(((l)>>8)&0xff); + c[i * 2] = (unsigned char) ((l) & 0xff); + c[i * 2 + 1] = (unsigned char) (((l) >> 8) & 0xff); } - return len*2; + return len * 2; } SWITCH_DECLARE(int) switch_short_to_float(short *s, float *f, int len) { int i; - for(i=0;i<len;i++) { - f[i] = (float)(s[i]) / NORMFACT; + for (i = 0; i < len; i++) { + f[i] = (float) (s[i]) / NORMFACT; //f[i] = (float) s[i]; } return len; @@ -170,6 +175,6 @@ SWITCH_DECLARE(void) switch_swap_linear(int16_t *buf, int len) { int i; for (i = 0; i < len; i++) { - buf[i] = ((buf[i] >> 8) & 0x00ff) | ((buf[i] << 8) & 0xff00); + buf[i] = ((buf[i] >> 8) & 0x00ff) | ((buf[i] << 8) & 0xff00); } } diff --git a/src/switch_utils.c b/src/switch_utils.c index ad9edfed08..2b07e372d7 100644 --- a/src/switch_utils.c +++ b/src/switch_utils.c @@ -73,16 +73,17 @@ SWITCH_DECLARE(char *) switch_cut_path(char *in) char delims[] = "/\\"; char *i; - for(i = delims; *i; i++) { + for (i = delims; *i; i++) { p = in; - while((p = strchr(p, *i))) { + while ((p = strchr(p, *i))) { ret = ++p; } } return ret; } -SWITCH_DECLARE(switch_status) switch_socket_create_pollfd(switch_pollfd_t *poll, switch_socket_t *sock, unsigned int flags, switch_memory_pool *pool) +SWITCH_DECLARE(switch_status) switch_socket_create_pollfd(switch_pollfd_t *poll, switch_socket_t *sock, + unsigned int flags, switch_memory_pool *pool) { switch_pollset_t *pollset; switch_status status; @@ -102,7 +103,7 @@ SWITCH_DECLARE(switch_status) switch_socket_create_pollfd(switch_pollfd_t *poll, SWITCH_DECLARE(int) switch_socket_waitfor(switch_pollfd_t *poll, int ms) { - switch_status status; + switch_status status; int nsds = 0; if ((status = switch_poll(poll, 1, &nsds, ms)) != SWITCH_STATUS_SUCCESS) { @@ -117,6 +118,6 @@ SWITCH_DECLARE(int) switch_socket_waitfor(switch_pollfd_t *poll, int ms) void include_me(void) { apr_socket_shutdown(NULL, 0); - apr_socket_recvfrom(NULL , NULL, 0, NULL, NULL); + apr_socket_recvfrom(NULL, NULL, 0, NULL, NULL); } #endif