* \param datalen amount of data to be written
* \return int amount of buffer used after the write, or 0 if no space available
*/
-SWITCH_DECLARE(switch_size_t) switch_buffer_write(switch_buffer_t *buffer, void *data, switch_size_t datalen);
+SWITCH_DECLARE(switch_size_t) switch_buffer_write(switch_buffer_t *buffer, const void *data, switch_size_t datalen);
/*! \brief Remove data from the buffer
* \param buffer any buffer of type switch_buffer_t
\param extension_number extension number
\return a new extension object allocated from the session's memory pool
*/
-SWITCH_DECLARE(switch_caller_extension_t *) switch_caller_extension_new(switch_core_session_t *session, char *extension_name, char *extension_number);
+SWITCH_DECLARE(switch_caller_extension_t *) switch_caller_extension_new(switch_core_session_t *session, const char *extension_name, const char *extension_number);
/*!
\brief Add an application (instruction) to the given extension
\param extra_data optional argument to the application
*/
SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session_t *session,
- switch_caller_extension_t *caller_extension, char *application_name, char *extra_data);
+ switch_caller_extension_t *caller_extension, const char *application_name, const char *extra_data);
/*!
\param name the name
\note this function is meant for situations where the name paramater is the contents of the variable
*/
-SWITCH_DECLARE(char *) switch_caller_get_field_by_name(switch_caller_profile_t *caller_profile, char *name);
+SWITCH_DECLARE(char *) switch_caller_get_field_by_name(switch_caller_profile_t *caller_profile, const char *name);
/*!
\brief Create a new caller profile object
\param event the event to add the information to
*/
-SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile_t *caller_profile, char *prefix, switch_event_t *event);
+SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile_t *caller_profile, const char *prefix, switch_event_t *event);
SWITCH_END_EXTERN_C
/** @} */
\param str the string to check
\return the code
*/
-SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(char *str);
+SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(const char *str);
/*!
\brief return the cause code for a given channel
\param cause the code to check
\return the string
*/
-SWITCH_DECLARE(char *) switch_channel_cause2str(switch_call_cause_t cause);
+SWITCH_DECLARE(const char *) switch_channel_cause2str(switch_call_cause_t cause);
/*!
\brief View the timetable of a channel
\param rpid the rpid if for the icon to use
\param status the status message
*/
-SWITCH_DECLARE(void) switch_channel_presence(switch_channel_t *channel, char *rpid, char *status);
+SWITCH_DECLARE(void) switch_channel_presence(switch_channel_t *channel, const char *rpid, const char *status);
/*!
\brief Uninitalize a channel
\param varname the name of the variable
\return the value of the requested variable
*/
-SWITCH_DECLARE(char *) switch_channel_get_variable(switch_channel_t *channel, char *varname);
+SWITCH_DECLARE(char *) switch_channel_get_variable(switch_channel_t *channel, const char *varname);
/*!
* Start iterating over the entries in the channel variable list.
\param private_info void pointer to private data
\return SWITCH_STATUS_SUCCESS if data was set
*/
-SWITCH_DECLARE(switch_status_t) switch_channel_set_private(switch_channel_t *channel, char *key, void *private_info);
+SWITCH_DECLARE(switch_status_t) switch_channel_set_private(switch_channel_t *channel, const char *key, const void *private_info);
/*!
\brief Retrieve private from a given channel
\param key unique keyname to retrieve your private data
\return void pointer to channel's private data
*/
-SWITCH_DECLARE(void *) switch_channel_get_private(switch_channel_t *channel, char *key);
+SWITCH_DECLARE(void *) switch_channel_get_private(switch_channel_t *channel, const char *key);
/*!
\brief Assign a name to a given channel
\param name name to assign
\return SWITCH_STATUS_SUCCESS if name was assigned
*/
-SWITCH_DECLARE(switch_status_t) switch_channel_set_name(switch_channel_t *channel, char *name);
+SWITCH_DECLARE(switch_status_t) switch_channel_set_name(switch_channel_t *channel, const char *name);
/*!
\brief Retrieve the name of a given channel
\param dtmf string of digits to queue
\return SWITCH_STATUS_SUCCESS if successful
*/
-SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *channel, char *dtmf);
+SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *channel, const char *dtmf);
/*!
\brief Retrieve DTMF digits from a given channel
\param name the name of the state
\return the enum value (numeric)
*/
-SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(char *name);
+SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(const char *name);
/*!
\brief Add information about a given channel to an event object
\param err a pointer to set any errors to
\note to be called at application startup
*/
-SWITCH_DECLARE(switch_status_t) switch_core_init(char *console, const char **err);
+SWITCH_DECLARE(switch_status_t) switch_core_init(const char *console, const char **err);
/*!
\brief Initilize the core and load modules
\param err a pointer to set any errors to
\note to be called at application startup instead of switch_core_init. Includes module loading.
*/
-SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(char *console, const char **err);
+SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(const char *console, const char **err);
/*!
\brief Set/Get Session Limit
#ifdef SWITCH_DEBUG_RWLOCKS
#define switch_core_session_locate(uuid_str) switch_core_session_perform_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)
#else
-SWITCH_DECLARE(switch_core_session_t *) switch_core_session_locate(char *uuid_str);
+SWITCH_DECLARE(switch_core_session_t *) switch_core_session_locate(const char *uuid_str);
#endif
/*!
\param varname the name of the variable
\return the value of the desired variable
*/
-SWITCH_DECLARE(char *) switch_core_get_variable(char *varname);
+SWITCH_DECLARE(char *) switch_core_get_variable(const char *varname);
/*!
\brief Add a global variable to the core
\param varname the name of the variable
\param value the value of the variable
*/
-SWITCH_DECLARE(void) switch_core_set_variable(char *varname, char *value);
+SWITCH_DECLARE(void) switch_core_set_variable(const char *varname, const char *value);
/*!
\brief Hangup All Sessions
\brief Set the output console to the desired file
\param console the file path
*/
-SWITCH_DECLARE(switch_status_t) switch_core_set_console(char *console);
+SWITCH_DECLARE(switch_status_t) switch_core_set_console(const char *console);
/*!
\brief Breakdown a number of milliseconds into various time spec
\param name the name of the endpoint
\return the desired endpoint interface
*/
-SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(char *name);
+SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(const char *name);
/*!
\brief Retrieve the codec interface by it's registered name
\param name the name of the codec
\return the desired codec interface
*/
-SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(char *name);
+SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(const char *name);
/*!
\brief Retrieve the dialplan interface by it's registered name
\param name the name of the dialplan
\return the desired dialplan interface
*/
-SWITCH_DECLARE(switch_dialplan_interface_t *) switch_loadable_module_get_dialplan_interface(char *name);
+SWITCH_DECLARE(switch_dialplan_interface_t *) switch_loadable_module_get_dialplan_interface(const char *name);
/*!
\brief build a dynamic module object and register it (for use in double embeded modules)
\param name the name of the timer
\return the desired timer interface
*/
-SWITCH_DECLARE(switch_timer_interface_t *) switch_loadable_module_get_timer_interface(char *name);
+SWITCH_DECLARE(switch_timer_interface_t *) switch_loadable_module_get_timer_interface(const char *name);
/*!
\brief Retrieve the application interface by it's registered name
\param name the name of the application
\return the desired application interface
*/
-SWITCH_DECLARE(switch_application_interface_t *) switch_loadable_module_get_application_interface(char *name);
+SWITCH_DECLARE(switch_application_interface_t *) switch_loadable_module_get_application_interface(const char *name);
/*!
\brief Retrieve the API interface by it's registered name
\param name the name of the API
\return the desired API interface
*/
-SWITCH_DECLARE(switch_api_interface_t *) switch_loadable_module_get_api_interface(char *name);
+SWITCH_DECLARE(switch_api_interface_t *) switch_loadable_module_get_api_interface(const char *name);
/*!
\brief Retrieve the file format interface by it's registered name
\param name the name of the file format
\return the desired file format interface
*/
-SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(char *name);
+SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(const char *name);
/*!
\brief Retrieve the speech interface by it's registered name
\param name the name of the speech interface
\return the desired speech interface
*/
-SWITCH_DECLARE(switch_speech_interface_t *) switch_loadable_module_get_speech_interface(char *name);
+SWITCH_DECLARE(switch_speech_interface_t *) switch_loadable_module_get_speech_interface(const char *name);
/*!
\brief Retrieve the asr interface by it's registered name
\param name the name of the asr interface
\return the desired asr interface
*/
-SWITCH_DECLARE(switch_asr_interface_t *) switch_loadable_module_get_asr_interface(char *name);
+SWITCH_DECLARE(switch_asr_interface_t *) switch_loadable_module_get_asr_interface(const char *name);
/*!
\brief Retrieve the directory interface by it's registered name
\param name the name of the directory interface
\return the desired directory interface
*/
-SWITCH_DECLARE(switch_directory_interface_t *) switch_loadable_module_get_directory_interface(char *name);
+SWITCH_DECLARE(switch_directory_interface_t *) switch_loadable_module_get_directory_interface(const char *name);
/*!
\brief Retrieve the chat interface by it's registered name
\param name the name of the chat interface
\return the desired chat interface
*/
-SWITCH_DECLARE(switch_chat_interface_t *) switch_loadable_module_get_chat_interface(char *name);
+SWITCH_DECLARE(switch_chat_interface_t *) switch_loadable_module_get_chat_interface(const char *name);
/*!
\brief Retrieve the say interface by it's registered name
\param name the name of the say interface
\return the desired say interface
*/
-SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(char *name);
+SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(const char *name);
/*!
\brief Retrieve the management interface by it's registered name
\param relative_oid the relative oid of the management interface
\return the desired management interface
*/
-SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(char *relative_oid);
+SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(const char *relative_oid);
/*!
\brief Retrieve the list of loaded codecs into an array
\param stream stream for output
\return the status returned by the API call
*/
-SWITCH_DECLARE(switch_status_t) switch_api_execute(char *cmd, char *arg, switch_core_session_t *session, switch_stream_handle_t *stream);
+SWITCH_DECLARE(switch_status_t) switch_api_execute(const char *cmd, const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream);
/*!
\brief Load a module
SWITCH_DECLARE(void) switch_regex_free(void *data);
-SWITCH_DECLARE(int) switch_regex_perform(char *field, char *expression, switch_regex_t **new_re, int *ovector, uint32_t olen);
-SWITCH_DECLARE(void) switch_perform_substitution(switch_regex_t *re, int match_count, char *data, char *field_data,
+SWITCH_DECLARE(int) switch_regex_perform(const char *field, const char *expression, switch_regex_t **new_re, int *ovector, uint32_t olen);
+SWITCH_DECLARE(void) switch_perform_substitution(switch_regex_t *re, int match_count, const char *data, const char *field_data,
char *substituted, uint32_t len, int *ovector);
/*!
\param expression The regular expression to run against the string
\return Boolean if a match was found or not
*/
-SWITCH_DECLARE(switch_status_t) switch_regex_match(char *target, char *expression);
+SWITCH_DECLARE(switch_status_t) switch_regex_match(const char *target, const char *expression);
#define switch_regex_safe_free(re) if (re) {\
switch_regex_free(re);\
\param pool a memory pool to use for the session
\return the new RTP session or NULL on failure
*/
-SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(char *rx_host,
+SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
switch_port_t rx_port,
- char *tx_host,
+ const char *tx_host,
switch_port_t tx_port,
switch_payload_t payload,
uint32_t samples_per_interval,
\param port the remote port
\param err pointer for error messages
*/
-SWITCH_DECLARE(switch_status_t) switch_rtp_set_remote_address(switch_rtp_t *rtp_session, char *host, switch_port_t port, const char **err);
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_remote_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err);
/*!
\brief Assign a local address to the RTP session
\param err pointer for error messages
\note this call also binds the RTP session's socket to the new address
*/
-SWITCH_DECLARE(switch_status_t) switch_rtp_set_local_address(switch_rtp_t *rtp_session, char *host, switch_port_t port, const char **err);
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_local_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err);
/*!
\brief Kill the socket on an existing RTP session
*/
SWITCH_DECLARE(uint32_t) switch_scheduler_add_task(time_t task_runtime,
switch_scheduler_func_t func,
- char *desc, char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags);
+ const char *desc, const char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags);
/*!
\brief Delete a scheduled task
\param group the group name
\return the number of jobs deleted
*/
-SWITCH_DECLARE(uint32_t) switch_scheduler_del_task_group(char *group);
+SWITCH_DECLARE(uint32_t) switch_scheduler_del_task_group(const char *group);
/*!
typedef switch_status_t (*switch_state_handler_t) (switch_core_session_t *);
typedef struct switch_stream_handle switch_stream_handle_t;
typedef switch_status_t (*switch_stream_handle_write_function_t) (switch_stream_handle_t *handle, const char *fmt, ...);
-typedef switch_status_t (*switch_api_function_t) (char *in, switch_core_session_t *session, switch_stream_handle_t *stream);
+typedef switch_status_t (*switch_api_function_t) (const char *in, switch_core_session_t *session, switch_stream_handle_t *stream);
typedef switch_status_t (*switch_input_callback_function_t) (switch_core_session_t *session, void *input,
switch_input_type_t input_type, void *buf, unsigned int buflen);
typedef struct switch_say_interface switch_say_interface_t;
#define switch_is_file_path(file) ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR))
#endif
-static inline switch_bool_t switch_is_digit_string(char *s) {
+static inline switch_bool_t switch_is_digit_string(const char *s) {
while(s && *s) {
if (*s < 48 || *s > 57) {
\param priority the priority to get the name of
\return the printable form of the priority
*/
-SWITCH_DECLARE(char *) switch_priority_name(switch_priority_t priority);
+SWITCH_DECLARE(const char *) switch_priority_name(switch_priority_t priority);
/*!
\brief Return the RFC2833 character based on an event id
\param in the string
\return the epoch time in usec
*/
-SWITCH_DECLARE(switch_time_t) switch_str_time(char *in);
+SWITCH_DECLARE(switch_time_t) switch_str_time(const char *in);
/*!
\brief Declares a function designed to set a dymaic global string
\param esc the escape character
\return the escaped string
*/
-SWITCH_DECLARE(char *) switch_escape_char(switch_memory_pool_t *pool, char *in, char *delim, char esc);
+SWITCH_DECLARE(char *) switch_escape_char(switch_memory_pool_t *pool, char *in, const char *delim, char esc);
/*!
\brief Wait for a socket
static switch_api_interface_t sched_transfer_api_interface;
static switch_api_interface_t sched_hangup_api_interface;
-static switch_status_t status_function(char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t status_function(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
{
uint8_t html = 0;
switch_core_time_duration_t duration;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t ctl_function(char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t ctl_function(const char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
{
int argc;
char *mydata, *argv[5];
}
-static switch_status_t load_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t load_function(const char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
{
const char *err;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t unload_function(char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t unload_function(const char *mod, switch_core_session_t *session, switch_stream_handle_t *stream)
{
const char *err;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t reload_function(char *args, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t reload_function(const char *args, switch_core_session_t *session, switch_stream_handle_t *stream)
{
const char *err;
switch_xml_t xml_root;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t kill_function(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t kill_function(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t transfer_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t transfer_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
if (isession) {
return SWITCH_STATUS_FALSE;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (argc >= 2 && argc <= 4) {
+ char *uuid = argv[0];
+ char *dest = argv[1];
+ char *dp = argv[2];
+ char *context = argv[3];
- if (switch_strlen_zero(cmd) || argc < 2 || argc > 4) {
- stream->write_function(stream, "USAGE: %s\n", transfer_api_interface.syntax);
- } else {
- char *uuid = argv[0];
- char *dest = argv[1];
- char *dp = argv[2];
- char *context = argv[3];
+ if ((session = switch_core_session_locate(uuid))) {
- if ((session = switch_core_session_locate(uuid))) {
+ if (switch_ivr_session_transfer(session, dest, dp, context) == SWITCH_STATUS_SUCCESS) {
+ stream->write_function(stream, "OK\n");
+ } else {
+ stream->write_function(stream, "ERROR\n");
+ }
+
+ switch_core_session_rwunlock(session);
- if (switch_ivr_session_transfer(session, dest, dp, context) == SWITCH_STATUS_SUCCESS) {
- stream->write_function(stream, "OK\n");
} else {
- stream->write_function(stream, "ERROR\n");
+ stream->write_function(stream, "No Such Channel!\n");
}
-
- switch_core_session_rwunlock(session);
-
- } else {
- stream->write_function(stream, "No Such Channel!\n");
+ goto done;
}
}
+ stream->write_function(stream, "USAGE: %s\n", transfer_api_interface.syntax);
+
+done:
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sched_transfer_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sched_transfer_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
- char *argv[6] = { 0 };
+ char *mycmd = NULL, *argv[6] = { 0 };
int argc = 0;
if (isession) {
return SWITCH_STATUS_FALSE;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 2 || argc > 5) {
stream->write_function(stream, "USAGE: %s\n", sched_transfer_api_interface.syntax);
}
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sched_hangup_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sched_hangup_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
if (isession) {
return SWITCH_STATUS_FALSE;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 1) {
stream->write_function(stream, "USAGE: %s\n", sched_hangup_api_interface.syntax);
}
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t uuid_media_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t uuid_media_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 1) {
stream->write_function(stream, "USAGE: %s\n", media_api_interface.syntax);
stream->write_function(stream, "-ERR Operation Failed\n");
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t uuid_broadcast_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t uuid_broadcast_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 2) {
stream->write_function(stream, "USAGE: %s\n", broadcast_api_interface.syntax);
stream->write_function(stream, "+OK Message Sent\n");
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sched_broadcast_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sched_broadcast_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 3) {
stream->write_function(stream, "USAGE: %s\n", sched_broadcast_api_interface.syntax);
stream->write_function(stream, "+OK Message Scheduled\n");
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t uuid_hold_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t uuid_hold_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 1) {
stream->write_function(stream, "USAGE: %s\n", hold_api_interface.syntax);
stream->write_function(stream, "-ERR Operation Failed\n");
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t uuid_bridge_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t uuid_bridge_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
if (isession) {
return SWITCH_STATUS_FALSE;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc != 2) {
stream->write_function(stream, "USAGE: %s\n", uuid_bridge_api_interface.syntax);
}
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t session_record_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t session_record_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
char *uuid = NULL, *action = NULL, *path = NULL;
int argc = 0;
goto usage;
}
- if ((argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) != 3) {
+ if (!(mycmd = strdup(cmd))) {
+ goto usage;
+ }
+
+ if ((argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])))) != 3) {
goto usage;
}
usage:
stream->write_function(stream, "USAGE: %s\n", session_record_api_interface.syntax);
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
done:
switch_core_session_rwunlock(session);
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t pause_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t pause_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_core_session_t *session = NULL;
- char *argv[4] = { 0 };
+ char *mycmd = NULL, *argv[4] = { 0 };
int argc = 0;
if (isession) {
return SWITCH_STATUS_FALSE;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 2) {
stream->write_function(stream, "USAGE: %s\n", pause_api_interface.syntax);
}
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t originate_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t originate_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
switch_channel_t *caller_channel;
switch_core_session_t *caller_session = NULL;
- char *argv[7] = { 0 };
+ char *mycmd = NULL, *argv[7] = { 0 };
int i = 0, x, argc = 0;
char *aleg, *exten, *dp, *context, *cid_name, *cid_num;
uint32_t timeout = 60;
return SWITCH_STATUS_SUCCESS;
}
- argc = switch_separate_string(cmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ if (!switch_strlen_zero(cmd) && (mycmd = strdup(cmd))) {
+ argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
+ }
if (switch_strlen_zero(cmd) || argc < 2 || argc > 7) {
stream->write_function(stream, "USAGE: %s\n", originate_api_interface.syntax);
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
} else {
stream->write_function(stream, "Cannot Create Outgoing Channel! [%s] cause: %s\n", aleg, switch_channel_cause2str(cause));
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
if ((extension = switch_caller_extension_new(caller_session, app_name, arg)) == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "memory error!\n");
switch_channel_hangup(caller_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+ switch_safe_free(mycmd);
return SWITCH_STATUS_MEMERR;
}
switch_caller_extension_add_application(caller_session, extension, app_name, arg);
switch_core_session_rwunlock(caller_session);
}
+ switch_safe_free(mycmd);
return SWITCH_STATUS_SUCCESS;
}
switch_safe_free(stream.data);
}
-static switch_status_t sched_del_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sched_del_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
uint32_t cnt = 0;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t xml_wrap_api_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t xml_wrap_api_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
char *dcommand, *edata = NULL, *send = NULL, *command, *arg = NULL;
switch_stream_handle_t mystream = { 0 };
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sched_api_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sched_api_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
char *tm = NULL, *dcmd, *group;
time_t when;
return 0;
}
-static switch_status_t show_function(char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t show_function(const char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char sql[1024];
char *errmsg;
return SWITCH_STATUS_FALSE;
}
- if (data) {
- if ((mydata = strdup(data))) {
- argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
- }
-
+ if (data && (mydata = strdup(data))) {
+ argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
cmd = argv[0];
if (argv[2] && !strcasecmp(argv[1], "as")) {
as = argv[2];
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t version_function(char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t version_function(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char version_string[1024];
snprintf(version_string, sizeof(version_string) - 1, "FreeSwitch Version %s\n", SWITCH_VERSION_FULL);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t help_function(char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t help_function(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char showcmd[1024];
int all = 0;
static switch_status_t conference_play_file(conference_obj_t * conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async);
static switch_status_t conference_say(conference_obj_t * conference, const char *text, uint32_t leadin);
static void conference_list(conference_obj_t * conference, switch_stream_handle_t *stream, char *delim);
-static switch_status_t conf_api_main(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t conf_api_main(const char *buf, switch_core_session_t *session, switch_stream_handle_t *stream);
static switch_status_t audio_bridge_on_ring(switch_core_session_t *session);
static switch_status_t conference_outcall(conference_obj_t * conference,
char *conference_name,
}
/* API Interface Function */
-static switch_status_t conf_api_main(char *buf, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t conf_api_main(const char *buf, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char *lbuf = NULL;
switch_status_t status = SWITCH_STATUS_SUCCESS;
}
-static switch_status_t strepoch_api_function(char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t strepoch_api_function(const char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
{
switch_time_t out;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t strftime_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t strftime_api_function(const char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
{
switch_size_t retsize;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t presence_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t presence_api_function(const char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
{
switch_event_t *event;
char *lbuf, *argv[4];
}
-static switch_status_t chat_api_function(char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t chat_api_function(const char *fmt, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char *lbuf, *argv[4];
int argc = 0;
}
-static switch_status_t enum_function(char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t enum_function(const char *data, switch_core_session_t *session, switch_stream_handle_t *stream)
{
int argc = 0;
dest = argv[0];
root = argv[1] ? argv[1] : globals.root;
- if (!enum_lookup(root, data, &results) == SWITCH_STATUS_SUCCESS) {
+ if (!enum_lookup(root, dest, &results) == SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "No Match!\n");
return SWITCH_STATUS_SUCCESS;
}
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t pa_cmd(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t pa_cmd(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
char *argv[1024] = { 0 };
int argc = 0;
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_codec_string, globals.codec_string)
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_codec_rates_string, globals.codec_rates_string)
-static switch_status_t dl_login(char *arg, switch_core_session_t *session, switch_stream_handle_t *stream);
-static switch_status_t dl_logout(char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
-static switch_status_t dl_pres(char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
-static switch_status_t dl_debug(char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t dl_login(const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t dl_logout(const char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t dl_pres(const char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
+static switch_status_t dl_debug(const char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream);
static switch_status_t channel_on_init(switch_core_session_t *session);
static switch_status_t channel_on_hangup(switch_core_session_t *session);
static switch_status_t channel_on_ring(switch_core_session_t *session);
}
}
-static switch_status_t dl_debug(char *tf, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t dl_debug(const char *tf, switch_core_session_t *session, switch_stream_handle_t *stream)
{
int on, cur;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t dl_pres(char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t dl_pres(const char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream)
{
mdl_profile_t *profile;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t dl_logout(char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t dl_logout(const char *profile_name, switch_core_session_t *session, switch_stream_handle_t *stream)
{
mdl_profile_t *profile;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t dl_login(char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t dl_login(const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
{
char *argv[10] = { 0 };
int argc = 0;
static switch_status_t load_config(void);
static int get_dev_by_name(char *name, int in);
static int get_dev_by_number(int number, int in);
- static switch_status_t pa_cmd(char *dest, switch_core_session_t *session, switch_stream_handle_t *stream);
- static switch_status_t padep(char *dest, switch_core_session_t *session, switch_stream_handle_t *stream);
+ static switch_status_t pa_cmd(const char *dest, switch_core_session_t *session, switch_stream_handle_t *stream);
+ static switch_status_t padep(const char *dest, switch_core_session_t *session, switch_stream_handle_t *stream);
/*
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t padep(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t padep(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
stream->write_function(stream, "This command no longer exists (try 'pa help')\n");
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t pa_cmd(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t pa_cmd(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
char *argv[1024] = { 0 };
int argc = 0;
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t sofia_function(char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
+static switch_status_t sofia_function(const char *cmd, switch_core_session_t *isession, switch_stream_handle_t *stream)
{
char *argv[1024] = { 0 };
int argc = 0;
switch_time_t callenddate;
switch_time_t calltransferdate;
switch_call_cause_t hangupcause;
- char *hangupcause_text;
+ const char *hangupcause_text;
char clid[80];
bool originated; // Did they originate this call?
char dialplan[80];
static CDRContainer *newcdrcontainer;
static switch_memory_pool_t *module_pool;
static switch_status_t my_on_hangup(switch_core_session_t *session);
-static switch_status_t modcdr_reload(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
-static switch_status_t modcdr_queue_pause(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
-static switch_status_t modcdr_queue_resume(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
-static switch_status_t modcdr_show_active(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
-static switch_status_t modcdr_show_available(char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
+static switch_status_t modcdr_reload(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
+static switch_status_t modcdr_queue_pause(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
+static switch_status_t modcdr_queue_resume(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
+static switch_status_t modcdr_show_active(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
+static switch_status_t modcdr_show_available(const char *dest, switch_core_session_t *isession, switch_stream_handle_t *stream);
static switch_thread_rwlock_t *cdr_rwlock;
/* Now begins the glue that will tie this into the system.
return RUNNING ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_TERM;
}
-static switch_status_t modcdr_reload(char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
+static switch_status_t modcdr_reload(const char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
{
#ifdef SWITCH_QUEUE_ENHANCED
switch_thread_rwlock_wrlock(cdr_rwlock);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t modcdr_queue_pause(char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
+static switch_status_t modcdr_queue_pause(const char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
{
#ifdef SWITCH_QUEUE_ENHANCED
newcdrcontainer->queue_pause(stream);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t modcdr_queue_resume(char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
+static switch_status_t modcdr_queue_resume(const char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
{
#ifdef SWITCH_QUEUE_ENHANCED
newcdrcontainer->queue_resume(stream);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t modcdr_show_active(char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
+static switch_status_t modcdr_show_active(const char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
{
newcdrcontainer->active(stream);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t modcdr_show_available(char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
+static switch_status_t modcdr_show_available(const char *dest=0, switch_core_session_t *isession=0, switch_stream_handle_t *stream=0)
{
newcdrcontainer->available(stream);
return SWITCH_STATUS_SUCCESS;
return NULL;
}
-static switch_status_t launch_python(char *text, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t launch_python(const char *text, switch_core_session_t *session, switch_stream_handle_t *stream)
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
static switch_memory_pool_t *module_pool = NULL;
-static void js_thread_launch(char *text)
+static void js_thread_launch(const char *text)
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
}
-static switch_status_t launch_async(char *text, switch_core_session_t *session, switch_stream_handle_t *stream)
+static switch_status_t launch_async(const char *text, switch_core_session_t *session, switch_stream_handle_t *stream)
{
if (switch_strlen_zero(text)) {
return reading;
}
-SWITCH_DECLARE(switch_size_t) switch_buffer_write(switch_buffer_t *buffer, void *data, switch_size_t datalen)
+SWITCH_DECLARE(switch_size_t) switch_buffer_write(switch_buffer_t *buffer, const void *data, switch_size_t datalen)
{
switch_size_t freespace, actual_freespace;
return profile;
}
-SWITCH_DECLARE(char *) switch_caller_get_field_by_name(switch_caller_profile_t *caller_profile, char *name)
+SWITCH_DECLARE(char *) switch_caller_get_field_by_name(switch_caller_profile_t *caller_profile, const char *name)
{
if (!strcasecmp(name, "dialplan")) {
return caller_profile->dialplan;
return NULL;
}
-SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile_t *caller_profile, char *prefix, switch_event_t *event)
+SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile_t *caller_profile, const char *prefix, switch_event_t *event)
{
char header_name[1024];
}
-SWITCH_DECLARE(switch_caller_extension_t *) switch_caller_extension_new(switch_core_session_t *session, char *extension_name, char *extension_number)
+SWITCH_DECLARE(switch_caller_extension_t *) switch_caller_extension_new(switch_core_session_t *session, const char *extension_name, const char *extension_number)
{
switch_caller_extension_t *caller_extension = NULL;
SWITCH_DECLARE(void) switch_caller_extension_add_application(switch_core_session_t *session,
- switch_caller_extension_t *caller_extension, char *application_name, char *application_data)
+ switch_caller_extension_t *caller_extension, const char *application_name, const char *application_data)
{
switch_caller_application_t *caller_application = NULL;
};
-SWITCH_DECLARE(char *) switch_channel_cause2str(switch_call_cause_t cause)
+SWITCH_DECLARE(const char *) switch_channel_cause2str(switch_call_cause_t cause)
{
uint8_t x;
- char *str = "UNKNOWN";
+ const char *str = "UNKNOWN";
for (x = 0; CAUSE_CHART[x].name; x++) {
if (CAUSE_CHART[x].cause == cause) {
- str = (char *) CAUSE_CHART[x].name;
+ str = CAUSE_CHART[x].name;
}
}
return str;
}
-SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(char *str)
+SWITCH_DECLARE(switch_call_cause_t) switch_channel_str2cause(const char *str)
{
uint8_t x;
switch_call_cause_t cause = SWITCH_CAUSE_UNALLOCATED;
return has;
}
-SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *channel, char *dtmf)
+SWITCH_DECLARE(switch_status_t) switch_channel_queue_dtmf(switch_channel_t *channel, const char *dtmf)
{
switch_status_t status;
register switch_size_t len, inuse;
switch_size_t wr = 0;
- char *p;
+ const char *p;
assert(channel != NULL);
return SWITCH_STATUS_SUCCESS;
}
-SWITCH_DECLARE(void) switch_channel_presence(switch_channel_t *channel, char *rpid, char *status)
+SWITCH_DECLARE(void) switch_channel_presence(switch_channel_t *channel, const char *rpid, const char *status)
{
char *id = switch_channel_get_variable(channel, "presence_id");
switch_event_t *event;
}
-SWITCH_DECLARE(char *) switch_channel_get_variable(switch_channel_t *channel, char *varname)
+SWITCH_DECLARE(char *) switch_channel_get_variable(switch_channel_t *channel, const char *varname)
{
char *v = NULL;
assert(channel != NULL);
return hi;
}
-SWITCH_DECLARE(switch_status_t) switch_channel_set_private(switch_channel_t *channel, char *key, void *private_info)
+SWITCH_DECLARE(switch_status_t) switch_channel_set_private(switch_channel_t *channel, const char *key, const void *private_info)
{
assert(channel != NULL);
switch_mutex_lock(channel->profile_mutex);
return SWITCH_STATUS_SUCCESS;
}
-SWITCH_DECLARE(void *) switch_channel_get_private(switch_channel_t *channel, char *key)
+SWITCH_DECLARE(void *) switch_channel_get_private(switch_channel_t *channel, const char *key)
{
void *val;
assert(channel != NULL);
return val;
}
-SWITCH_DECLARE(switch_status_t) switch_channel_set_name(switch_channel_t *channel, char *name)
+SWITCH_DECLARE(switch_status_t) switch_channel_set_name(switch_channel_t *channel, const char *name)
{
assert(channel != NULL);
channel->name = NULL;
}
-SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(char *name)
+SWITCH_DECLARE(switch_channel_state_t) switch_channel_name_state(const char *name)
{
uint32_t x = 0;
for (x = 0; state_names[x]; x++) {
}
-SWITCH_DECLARE(switch_status_t) switch_core_set_console(char *console)
+SWITCH_DECLARE(switch_status_t) switch_core_set_console(const char *console)
{
if ((runtime.console = fopen(console, "a")) == 0) {
fprintf(stderr, "Cannot open output file %s.\n", console);
}
-SWITCH_DECLARE(char *) switch_core_get_variable(char *varname)
+SWITCH_DECLARE(char *) switch_core_get_variable(const char *varname)
{
return (char *) switch_core_hash_find(runtime.global_vars, varname);
}
-SWITCH_DECLARE(void) switch_core_set_variable(char *varname, char *value)
+SWITCH_DECLARE(void) switch_core_set_variable(const char *varname, const char *value)
{
switch_core_hash_insert(runtime.global_vars, switch_core_strdup(runtime.memory_pool, varname), switch_core_strdup(runtime.memory_pool, value));
}
}
-SWITCH_DECLARE(switch_status_t) switch_core_init(char *console, const char **err)
+SWITCH_DECLARE(switch_status_t) switch_core_init(const char *console, const char **err)
{
switch_xml_t xml = NULL, cfg = NULL;
switch_uuid_t uuid;
if (sig);
return;
}
-SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(char *console, const char **err)
+SWITCH_DECLARE(switch_status_t) switch_core_init_and_modload(const char *console, const char **err)
{
switch_event_t *event;
if (switch_core_init(console, err) != SWITCH_STATUS_SUCCESS) {
#ifdef SWITCH_DEBUG_RWLOCKS
-SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_locate(char *uuid_str, const char *file, const char *func, int line)
+SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_locate(const char *uuid_str, const char *file, const char *func, int line)
#else
-SWITCH_DECLARE(switch_core_session_t *) switch_core_session_locate(char *uuid_str)
+SWITCH_DECLARE(switch_core_session_t *) switch_core_session_locate(const char *uuid_str)
#endif
{
switch_core_session_t *session = NULL;
}
-SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(char *name)
+SWITCH_DECLARE(switch_endpoint_interface_t *) switch_loadable_module_get_endpoint_interface(const char *name)
{
switch_endpoint_interface_t *ptr;
return ptr;
}
-SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(char *name)
+SWITCH_DECLARE(switch_codec_interface_t *) switch_loadable_module_get_codec_interface(const char *name)
{
char altname[256] = "";
switch_codec_interface_t *codec;
return codec;
}
-SWITCH_DECLARE(switch_dialplan_interface_t *) switch_loadable_module_get_dialplan_interface(char *name)
+SWITCH_DECLARE(switch_dialplan_interface_t *) switch_loadable_module_get_dialplan_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.dialplan_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_timer_interface_t *) switch_loadable_module_get_timer_interface(char *name)
+SWITCH_DECLARE(switch_timer_interface_t *) switch_loadable_module_get_timer_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.timer_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_application_interface_t *) switch_loadable_module_get_application_interface(char *name)
+SWITCH_DECLARE(switch_application_interface_t *) switch_loadable_module_get_application_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.application_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_api_interface_t *) switch_loadable_module_get_api_interface(char *name)
+SWITCH_DECLARE(switch_api_interface_t *) switch_loadable_module_get_api_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.api_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(char *name)
+SWITCH_DECLARE(switch_file_interface_t *) switch_loadable_module_get_file_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.file_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_speech_interface_t *) switch_loadable_module_get_speech_interface(char *name)
+SWITCH_DECLARE(switch_speech_interface_t *) switch_loadable_module_get_speech_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.speech_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_asr_interface_t *) switch_loadable_module_get_asr_interface(char *name)
+SWITCH_DECLARE(switch_asr_interface_t *) switch_loadable_module_get_asr_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.asr_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_directory_interface_t *) switch_loadable_module_get_directory_interface(char *name)
+SWITCH_DECLARE(switch_directory_interface_t *) switch_loadable_module_get_directory_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.directory_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_chat_interface_t *) switch_loadable_module_get_chat_interface(char *name)
+SWITCH_DECLARE(switch_chat_interface_t *) switch_loadable_module_get_chat_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.chat_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(char *name)
+SWITCH_DECLARE(switch_say_interface_t *) switch_loadable_module_get_say_interface(const char *name)
{
return switch_core_hash_find_locked(loadable_modules.say_hash, name, loadable_modules.mutex);
}
-SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(char *relative_oid)
+SWITCH_DECLARE(switch_management_interface_t *) switch_loadable_module_get_management_interface(const char *relative_oid)
{
return switch_core_hash_find_locked(loadable_modules.management_hash, relative_oid, loadable_modules.mutex);
}
return i;
}
-SWITCH_DECLARE(switch_status_t) switch_api_execute(char *cmd, char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
+SWITCH_DECLARE(switch_status_t) switch_api_execute(const char *cmd, const char *arg, switch_core_session_t *session, switch_stream_handle_t *stream)
{
switch_api_interface_t *api;
switch_status_t status;
#include <switch.h>
#include <pcre.h>
-\r \rSWITCH_DECLARE(switch_regex_t *) switch_regex_compile(const char *pattern,
- int options, const char **errorptr, int *erroroffset, \rconst unsigned char *tables) \r
+
+
+SWITCH_DECLARE(switch_regex_t *) switch_regex_compile(const char *pattern,
+ int options, const char **errorptr, int *erroroffset,
+const unsigned char *tables)
{
- \rreturn pcre_compile(pattern, options, errorptr, erroroffset, tables);
-\r}
-\r\rSWITCH_DECLARE(int) switch_regex_copy_substring(const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int size)
+
+return pcre_compile(pattern, options, errorptr, erroroffset, tables);
+
+}
+
+
+SWITCH_DECLARE(int) switch_regex_copy_substring(const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int size)
{
return pcre_copy_substring(subject, ovector, stringcount, stringnumber, buffer, size);
}
SWITCH_DECLARE(void) switch_regex_free(void *data)
{
pcre_free(data);
-\r} \r\rSWITCH_DECLARE(int) switch_regex_perform(char *field, char *expression, switch_regex_t **new_re, int *ovector, uint32_t olen)
+
+}
+
+SWITCH_DECLARE(int) switch_regex_perform(const char *field, const char *expression, switch_regex_t **new_re, int *ovector, uint32_t olen)
{
const char *error = NULL;
int erroffset = 0;
}
-SWITCH_DECLARE(void) switch_perform_substitution(switch_regex_t *re, int match_count, char *data, char *field_data,
+SWITCH_DECLARE(void) switch_perform_substitution(switch_regex_t *re, int match_count, const char *data, const char *field_data,
char *substituted, uint32_t len, int *ovector)
{
char index[10] = "";
}
substituted[y++] = '\0';
}
-\rSWITCH_DECLARE(switch_status_t) switch_regex_match(char *target, char *expression)
+
+SWITCH_DECLARE(switch_status_t) switch_regex_match(const char *target, const char *expression)
{
const char *error = NULL; //Used to hold any errors
int error_offset = 0; //Holds the offset of an error
}
-SWITCH_DECLARE(switch_status_t) switch_rtp_set_local_address(switch_rtp_t *rtp_session, char *host, switch_port_t port, const char **err)
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_local_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
{
switch_socket_t *new_sock = NULL, *old_sock = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
return status;
}
-SWITCH_DECLARE(switch_status_t) switch_rtp_set_remote_address(switch_rtp_t *rtp_session, char *host, switch_port_t port, const char **err)
+SWITCH_DECLARE(switch_status_t) switch_rtp_set_remote_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
{
*err = "Success";
return SWITCH_STATUS_SUCCESS;
}
-SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(char *rx_host,
+SWITCH_DECLARE(switch_rtp_t *) switch_rtp_new(const char *rx_host,
switch_port_t rx_port,
- char *tx_host,
+ const char *tx_host,
switch_port_t tx_port,
switch_payload_t payload,
uint32_t samples_per_interval,
SWITCH_DECLARE(uint32_t) switch_scheduler_add_task(time_t task_runtime,
switch_scheduler_func_t func,
- char *desc, char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags)
+ const char *desc, const char *group, uint32_t cmd_id, void *cmd_arg, switch_scheduler_flag_t flags)
{
switch_scheduler_task_container_t *container, *tp;
switch_event_t *event;
return delcnt;
}
-SWITCH_DECLARE(uint32_t) switch_scheduler_del_task_group(char *group)
+SWITCH_DECLARE(uint32_t) switch_scheduler_del_task_group(const char *group)
{
switch_scheduler_task_container_t *tp;
switch_event_t *event;
}
-SWITCH_DECLARE(switch_time_t) switch_str_time(char *in)
+SWITCH_DECLARE(switch_time_t) switch_str_time(const char *in)
{
switch_time_exp_t tm = { 0 };
int proceed = 0, ovector[30];
}
-SWITCH_DECLARE(char *) switch_priority_name(switch_priority_t priority)
+SWITCH_DECLARE(const char *) switch_priority_name(switch_priority_t priority)
{
switch (priority) { /*lol */
case SWITCH_PRIORITY_NORMAL:
return '\0';
}
-SWITCH_DECLARE(char *) switch_escape_char(switch_memory_pool_t *pool, char *in, char *delim, char esc)
+SWITCH_DECLARE(char *) switch_escape_char(switch_memory_pool_t *pool, char *in, const char *delim, char esc)
{
- char *data, *p, *d;
+ char *data;
+ const char *p, *d;
int count = 1, i = 0;
p = in;
projects / thirdparty / freeswitch.git / commitdiff
