#include <switch.h>

Include dependency graph for switch_msrp.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	msrp_msg_s

struct	switch_msrp_session_s

Macros
#define	switch_msrp_send(ms, msg) switch_msrp_perform_send(ms, msg, __FILE__, __SWITCH_FUNC__, __LINE__)

Typedefs
typedef struct switch_msrp_session_s	switch_msrp_session_t

typedef struct msrp_client_socket_s	switch_msrp_client_socket_t

typedef struct msrp_socket_s	switch_msrp_socket_t

typedef struct msrp_msg_s	switch_msrp_msg_t

Functions
switch_status_t	switch_msrp_init (void)

switch_status_t	switch_msrp_destroy (void)

switch_msrp_session_t *	switch_msrp_session_new (switch_memory_pool_t pool, const char call_id, switch_bool_t secure)

switch_status_t	switch_msrp_session_destroy (switch_msrp_session_t **ms)

switch_msrp_msg_t *	switch_msrp_session_pop_msg (switch_msrp_session_t *ms)

switch_status_t	switch_msrp_perform_send (switch_msrp_session_t ms, switch_msrp_msg_t msg, const char file, const char func, int line)

switch_status_t	switch_msrp_start_client (switch_msrp_session_t *msrp_session)

const char *	switch_msrp_listen_ip (void)

switch_msrp_msg_t *	switch_msrp_msg_create (void)

void	switch_msrp_msg_destroy (switch_msrp_msg_t **msg)

void	switch_msrp_load_apis_and_applications (switch_loadable_module_interface_t **moudle_interface)

const char *	switch_msrp_msg_get_header (switch_msrp_msg_t *msrp_msg, switch_msrp_header_type_t htype)

switch_status_t	switch_msrp_msg_add_header (switch_msrp_msg_t msrp_msg, switch_msrp_header_type_t htype, char fmt,...)

void	switch_msrp_msg_set_payload (switch_msrp_msg_t msrp_msg, const char buf, switch_size_t payload_bytes)

char *	switch_msrp_header_name (switch_msrp_header_type_t htype)

switch_msrp_msg_t *	switch_msrp_msg_dup (switch_msrp_msg_t *msg)

Macro Definition Documentation

◆ switch_msrp_send

#define switch_msrp_send	(	ms,
		msg
	)	switch_msrp_perform_send(ms, msg, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 141 of file switch_msrp.h.

Referenced by msrp_worker(), SWITCH_STANDARD_API(), and SWITCH_STANDARD_APP().

Typedef Documentation

◆ switch_msrp_client_socket_t

typedef struct msrp_client_socket_s switch_msrp_client_socket_t

Definition at line 69 of file switch_msrp.h.

◆ switch_msrp_msg_t

typedef struct msrp_msg_s switch_msrp_msg_t

◆ switch_msrp_session_t

typedef struct switch_msrp_session_s switch_msrp_session_t

Definition at line 68 of file switch_msrp.h.

◆ switch_msrp_socket_t

typedef struct msrp_socket_s switch_msrp_socket_t

Definition at line 70 of file switch_msrp.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
MSRP_ST_WAIT_HEADER
MSRP_ST_PARSE_HEADER
MSRP_ST_WAIT_BODY
MSRP_ST_DONE
MSRP_ST_ERROR
MSRP_METHOD_REPLY
MSRP_METHOD_SEND
MSRP_METHOD_AUTH
MSRP_METHOD_REPORT

Definition at line 37 of file switch_msrp.h.

      {
         MSRP_ST_WAIT_HEADER,
         MSRP_ST_PARSE_HEADER,
         MSRP_ST_WAIT_BODY,
         MSRP_ST_DONE,
         MSRP_ST_ERROR,
 
         MSRP_METHOD_REPLY,
         MSRP_METHOD_SEND,
         MSRP_METHOD_AUTH,
         MSRP_METHOD_REPORT
 };

◆ switch_msrp_header_type_t

enum switch_msrp_header_type_t

Enumerator
MSRP_H_FROM_PATH
MSRP_H_TO_PATH
MSRP_H_MESSAGE_ID
MSRP_H_CONTENT_TYPE
MSRP_H_SUCCESS_REPORT
MSRP_H_FAILURE_REPORT
MSRP_H_STATUS
MSRP_H_KEEPALIVE
MSRP_H_TRASACTION_ID
MSRP_H_DELIMITER
MSRP_H_CODE_DESCRIPTION
MSRP_H_UNKNOWN

Definition at line 50 of file switch_msrp.h.

              {
         MSRP_H_FROM_PATH,
         MSRP_H_TO_PATH,
         MSRP_H_MESSAGE_ID,
         MSRP_H_CONTENT_TYPE,
         MSRP_H_SUCCESS_REPORT,
         MSRP_H_FAILURE_REPORT,
         MSRP_H_STATUS,
         MSRP_H_KEEPALIVE,
 
         /* Fake headers */
         MSRP_H_TRASACTION_ID,
         MSRP_H_DELIMITER,
         MSRP_H_CODE_DESCRIPTION,
 
         MSRP_H_UNKNOWN
 } switch_msrp_header_type_t;

Function Documentation

◆ switch_msrp_destroy()

switch_status_t switch_msrp_destroy ( void )

Definition at line 349 of file switch_msrp.c.

References close_socket(), globals, msrp_deinit_ssl(), msrp_socket_s::sock, SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, switch_log_printf(), switch_safe_free, SWITCH_STATUS_SUCCESS, and switch_thread_join().

Referenced by switch_core_destroy(), and SWITCH_STANDARD_API().

 {
         switch_status_t st = SWITCH_STATUS_SUCCESS;
         switch_socket_t *sock;
 
         globals.running = 0;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "destroying thread\n");
 
         sock = globals.msock.sock;
         close_socket(&sock);
 
         sock = globals.msock_ssl.sock;
         close_socket(&sock);
 
         if (globals.msock.thread) switch_thread_join(&st, globals.msock.thread);
         if (globals.msock_ssl.thread) switch_thread_join(&st, globals.msock_ssl.thread);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "destroy thread done\n");
 
         globals.msock.thread = NULL;
         globals.msock_ssl.thread = NULL;
 
         msrp_deinit_ssl();
 
         switch_safe_free(globals.ip);
 
         return st;
 }

◆ switch_msrp_header_name()

char* switch_msrp_header_name ( switch_msrp_header_type_t htype )

◆ switch_msrp_init()

switch_status_t switch_msrp_init ( void )

Definition at line 294 of file switch_msrp.c.

References DEBUG_MSRP, globals, load_config(), memset(), msock_init(), msrp_init_ssl(), msrp_listener(), pool, SWITCH_CHANNEL_LOG, switch_core_new_memory_pool, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), and msrp_socket_s::thread.

Referenced by switch_core_init_and_modload(), and SWITCH_STANDARD_API().

 {
         switch_memory_pool_t *pool;
         switch_thread_t *thread;
         switch_threadattr_t *thd_attr = NULL;
         switch_status_t status;
 
         if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n");
                 return SWITCH_STATUS_FALSE;
         }
 
         memset(&globals, 0, sizeof(globals));
         set_global_ip("0.0.0.0");
         globals.pool = pool;
         globals.msock.port = (switch_port_t)0;
         globals.msock_ssl.port = (switch_port_t)0;
         globals.msock_ssl.secure = 1;
         globals.message_buffer_size = 50;
         globals.debug = DEBUG_MSRP;
 
         load_config();
 
         if (globals.msock.port) {
                 globals.running = 1;
 
                 status = msock_init(globals.ip, globals.msock.port, &globals.msock.sock, pool);
 
                 if (status == SWITCH_STATUS_SUCCESS) {
                         switch_threadattr_create(&thd_attr, pool);
                         // switch_threadattr_detach_set(thd_attr, 1);
                         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                         switch_thread_create(&thread, thd_attr, msrp_listener, &globals.msock, pool);
                         globals.msock.thread = thread;
                 }
         }
 
         if (globals.msock_ssl.port) {
                 globals.running = 1;
 
                 msrp_init_ssl();
                 status = msock_init(globals.ip, globals.msock_ssl.port, &globals.msock_ssl.sock, pool);
 
                 if (status == SWITCH_STATUS_SUCCESS) {
                         switch_threadattr_create(&thd_attr, pool);
                         // switch_threadattr_detach_set(thd_attr, 1);
                         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                         switch_thread_create(&thread, thd_attr, msrp_listener, &globals.msock_ssl, pool);
                         globals.msock_ssl.thread = thread;
                 }
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_msrp_listen_ip()

const char* switch_msrp_listen_ip ( void )

Definition at line 289 of file switch_msrp.c.

References globals.

Referenced by switch_core_media_negotiate_sdp().

 {
         return globals.ip;
 }

◆ switch_msrp_load_apis_and_applications()

void switch_msrp_load_apis_and_applications ( switch_loadable_module_interface_t ** moudle_interface )

Definition at line 1870 of file switch_msrp.c.

References MSRP_SYNTAX, SAF_SUPPORT_NOMEDIA, SAF_SUPPORT_TEXT_ONLY, SWITCH_ADD_API, SWITCH_ADD_APP, and switch_console_set_complete().

 {
         switch_application_interface_t *app_interface;
         switch_api_interface_t *api_interface;
 
         SWITCH_ADD_API(api_interface, "msrp", "MSRP Functions", msrp_api_function, MSRP_SYNTAX);
 
         SWITCH_ADD_API(api_interface, "uuid_msrp_send", "send msrp text", uuid_msrp_send_function, "<msg>");
         SWITCH_ADD_APP(app_interface, "msrp_recv_file", "Recv msrp message to file", "Recv msrp message", msrp_recv_file_function, "<filename>", SAF_SUPPORT_TEXT_ONLY | SAF_SUPPORT_NOMEDIA);
         SWITCH_ADD_APP(app_interface, "msrp_send_file", "Send file via msrp", "Send file via msrp", msrp_send_file_function, "<filename>", SAF_SUPPORT_TEXT_ONLY | SAF_SUPPORT_NOMEDIA);
 
         switch_console_set_complete("add msrp debug on");
         switch_console_set_complete("add msrp debug off");
         switch_console_set_complete("restart");
         switch_console_set_complete("add uuid_msrp_send ::console::list_uuid");
 }

◆ switch_msrp_msg_add_header()

switch_status_t switch_msrp_msg_add_header	(	switch_msrp_msg_t *	msrp_msg,
		switch_msrp_header_type_t	htype,
		char *	fmt,
			...
	)

Definition at line 651 of file switch_msrp.c.

References msrp_msg_s::code_description, msrp_msg_s::delimiter, msrp_msg_s::headers, MSRP_H_CODE_DESCRIPTION, MSRP_H_DELIMITER, MSRP_H_TRASACTION_ID, switch_event_add_header_string(), switch_msrp_msg_get_header(), switch_msrp_msg_header_name(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_MEMERR, switch_vasprintf(), and msrp_msg_s::transaction_id.

Referenced by msrp_parse_header(), msrp_parse_headers(), msrp_worker(), SWITCH_STANDARD_API(), and SWITCH_STANDARD_APP().

 {
         switch_status_t status;
 
         int ret = 0;
         char *data;
         va_list ap;
 
         va_start(ap, fmt);
         ret = switch_vasprintf(&data, fmt, ap);
         va_end(ap);
 
         if (ret == -1) {
                 return SWITCH_STATUS_MEMERR;
         }
 
         status = switch_event_add_header_string(msrp_msg->headers, SWITCH_STACK_BOTTOM, switch_msrp_msg_header_name(htype), data);
 
         switch (htype) {
         case MSRP_H_TRASACTION_ID:
                 msrp_msg->transaction_id = switch_msrp_msg_get_header(msrp_msg, MSRP_H_TRASACTION_ID);
                 break;
         case MSRP_H_DELIMITER:
                 msrp_msg->delimiter = switch_msrp_msg_get_header(msrp_msg, MSRP_H_DELIMITER);
                 break;
         case MSRP_H_CODE_DESCRIPTION:
                 msrp_msg->code_description = switch_msrp_msg_get_header(msrp_msg, MSRP_H_CODE_DESCRIPTION);
                 break;
         default: break;
         }
 
         return status;
 }

◆ switch_msrp_msg_create()

switch_msrp_msg_t* switch_msrp_msg_create ( void )

Definition at line 1625 of file switch_msrp.c.

References msrp_msg_s::headers, memset(), switch_assert, switch_event_create, and SWITCH_EVENT_GENERAL.

Referenced by msrp_parse_buffer(), msrp_worker(), SWITCH_STANDARD_API(), and SWITCH_STANDARD_APP().

 {
         switch_msrp_msg_t *msg = malloc(sizeof(switch_msrp_msg_t));
         switch_assert(msg);
 
         memset(msg, 0, sizeof(switch_msrp_msg_t));
         switch_event_create(&msg->headers, SWITCH_EVENT_GENERAL);
         switch_assert(msg->headers);
 
         return msg;
 }

◆ switch_msrp_msg_destroy()

void switch_msrp_msg_destroy ( switch_msrp_msg_t ** msg )

Definition at line 1663 of file switch_msrp.c.

References msrp_msg_s::headers, msrp_msg_s::payload, switch_event_destroy(), and switch_safe_free.

Referenced by msrp_worker(), switch_msrp_perform_send(), switch_msrp_session_destroy(), SWITCH_STANDARD_API(), and SWITCH_STANDARD_APP().

 {
         switch_msrp_msg_t *msrp_msg = *msg;
         if (msrp_msg->headers) {
                 switch_event_destroy(&msrp_msg->headers);
         }
 
         switch_safe_free(msrp_msg->payload);
         *msg = NULL;
 }

◆ switch_msrp_msg_dup()

switch_msrp_msg_t* switch_msrp_msg_dup ( switch_msrp_msg_t * msg )

Definition at line 1637 of file switch_msrp.c.

References msrp_msg_s::code_description, msrp_msg_s::code_number, msrp_msg_s::delimiter, msrp_msg_s::headers, memset(), msrp_msg_s::method, MSRP_H_CODE_DESCRIPTION, MSRP_H_DELIMITER, MSRP_H_TRASACTION_ID, msrp_msg_s::payload, msrp_msg_s::payload_bytes, msrp_msg_s::state, switch_assert, switch_event_dup(), switch_msrp_msg_get_header(), and msrp_msg_s::transaction_id.

Referenced by msrp_worker(), and switch_msrp_perform_send().

 {
         switch_msrp_msg_t *new_msg = malloc(sizeof(switch_msrp_msg_t));
         switch_assert(new_msg);
         memset(new_msg, 0, sizeof(switch_msrp_msg_t));
         switch_event_dup(&new_msg->headers, msg->headers);
         switch_assert(new_msg->headers);
 
         new_msg->transaction_id = switch_msrp_msg_get_header(new_msg, MSRP_H_TRASACTION_ID);
         new_msg->delimiter = switch_msrp_msg_get_header(new_msg, MSRP_H_DELIMITER);
         new_msg->code_description = switch_msrp_msg_get_header(new_msg, MSRP_H_CODE_DESCRIPTION);
         new_msg->state = msg->state;
         new_msg->method = msg->method;
         new_msg->code_number = msg->code_number;
         new_msg->payload_bytes = msg->payload_bytes;
 
         if (msg->payload_bytes > 0 && msg->payload) {
                 new_msg->payload = malloc(msg->payload_bytes + 1);
                 switch_assert(new_msg->payload);
                 memcpy(new_msg->payload, msg->payload, msg->payload_bytes);
                 *(new_msg->payload + msg->payload_bytes) = '\0';
         }
 
         return new_msg;
 }

◆ switch_msrp_msg_get_header()

const char* switch_msrp_msg_get_header	(	switch_msrp_msg_t *	msrp_msg,
		switch_msrp_header_type_t	htype
	)

Definition at line 685 of file switch_msrp.c.

References msrp_msg_s::headers, switch_event_get_header, and switch_msrp_msg_header_name().

Referenced by msrp_check_success_report(), msrp_msg_serialize(), msrp_reply(), msrp_report(), msrp_worker(), switch_msrp_do_send(), switch_msrp_msg_add_header(), switch_msrp_msg_dup(), and SWITCH_STANDARD_APP().

                                                                                                                       {
         char *v = switch_event_get_header(msrp_msg->headers, switch_msrp_msg_header_name(htype));
         return v;
 }

◆ switch_msrp_msg_set_payload()

void switch_msrp_msg_set_payload	(	switch_msrp_msg_t *	msrp_msg,
		const char *	buf,
		switch_size_t	payload_bytes
	)

Definition at line 82 of file switch_msrp.c.

References msrp_msg_s::payload, msrp_msg_s::payload_bytes, switch_assert, and switch_malloc.

Referenced by msrp_parse_buffer(), msrp_worker(), SWITCH_STANDARD_API(), and SWITCH_STANDARD_APP().

 {
         if (!msrp_msg->payload) {
                 switch_malloc(msrp_msg->payload, payload_bytes + 1);
         } else if (msrp_msg->payload_bytes < payload_bytes + 1) {
                 msrp_msg->payload = realloc(msrp_msg->payload, payload_bytes + 1);
         }
 
         switch_assert(msrp_msg->payload);
         memcpy(msrp_msg->payload, buf, payload_bytes);
         *(msrp_msg->payload + payload_bytes) = '\0';
         msrp_msg->payload_bytes = payload_bytes;
 }

◆ switch_msrp_perform_send()

switch_status_t switch_msrp_perform_send	(	switch_msrp_session_t *	ms,
		switch_msrp_msg_t *	msg,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 1583 of file switch_msrp.c.

References switch_msrp_session_s::call_id, globals, msrp_msg_s::payload, msrp_msg_s::payload_bytes, switch_msrp_session_s::pool, switch_msrp_session_s::running, switch_msrp_session_s::send_queue, SWITCH_CHANNEL_ID_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_msrp_do_send(), switch_msrp_msg_destroy(), switch_msrp_msg_dup(), switch_queue_create(), switch_queue_term(), switch_queue_trypop(), switch_queue_trypush(), SWITCH_SIZE_T_FMT, and SWITCH_STATUS_SUCCESS.

 {
         switch_msrp_msg_t *msg = NULL;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         if (!ms->running) {
                 if (!ms->send_queue) {
                         switch_queue_create(&ms->send_queue, 100, ms->pool);
                 }
 
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, ms->call_id, SWITCH_LOG_WARNING, "MSRP not ready! Buffering one message %" SWITCH_SIZE_T_FMT " bytes\n", msrp_msg->payload_bytes);
 
                 if (globals.debug && msrp_msg->payload) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, ms->call_id, SWITCH_LOG_WARNING, "MSRP not ready! Buffered one message [%s]\n", msrp_msg->payload);
                 }
 
                 msg = switch_msrp_msg_dup(msrp_msg);
 
                 status = switch_queue_trypush(ms->send_queue, msg);
 
                 if (status != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, ms->call_id, SWITCH_LOG_ERROR, "MSRP queue FULL! Discard one message %" SWITCH_SIZE_T_FMT " bytes\n", msg->payload_bytes);
                         switch_msrp_msg_destroy(&msg);
                 }
 
                 return status;
         }
 
         if (ms->send_queue) {
                 while (status == SWITCH_STATUS_SUCCESS && switch_queue_trypop(ms->send_queue, (void **)&msg) == SWITCH_STATUS_SUCCESS) {
                         status = switch_msrp_do_send(ms, msg, file, func, line);
                 }
 
                 switch_queue_term(ms->send_queue);
                 ms->send_queue = NULL;
         }
 
         status = switch_msrp_do_send(ms, msrp_msg, file, func, line);
 
         return status;
 }

◆ switch_msrp_session_destroy()

switch_status_t switch_msrp_session_destroy ( switch_msrp_session_t ** ms )

Definition at line 392 of file switch_msrp.c.

References close_socket(), SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), switch_msrp_msg_destroy(), switch_mutex_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), SWITCH_STATUS_SUCCESS, and switch_yield.

Referenced by switch_media_handle_destroy().

 {
         int sanity = 500;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Destroying MSRP session %s\n", (*ms)->call_id);
 
         switch_mutex_lock((*ms)->mutex);
 
         if ((*ms)->csock && (*ms)->csock->sock) {
                 close_socket(&(*ms)->csock->sock);
         }
 
         switch_mutex_unlock((*ms)->mutex);
 
         switch_yield(20000);
 
         while(sanity-- > 0 && (*ms)->running) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "waiting MSRP worker %s\n", (*ms)->call_id);
                 switch_yield(20000);
         }
 
         if ((*ms)->send_queue) {
                 switch_msrp_msg_t *msg = NULL;
 
                 while (switch_queue_trypop((*ms)->send_queue, (void **)&msg) == SWITCH_STATUS_SUCCESS) {
                         switch_msrp_msg_destroy(&msg);
                 }
         }
 
         switch_mutex_destroy((*ms)->mutex);
         ms = NULL;
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_msrp_session_new()

switch_msrp_session_t* switch_msrp_session_new	(	switch_memory_pool_t *	pool,
		const char *	call_id,
		switch_bool_t	secure
	)

Definition at line 378 of file switch_msrp.c.

References switch_msrp_session_s::call_id, globals, switch_msrp_session_s::local_port, switch_msrp_session_s::msrp_msg_buffer_size, switch_msrp_session_s::mutex, pool, switch_msrp_session_s::pool, msrp_socket_s::secure, switch_msrp_session_s::secure, switch_assert, switch_core_alloc, switch_core_strdup, switch_mutex_init(), and SWITCH_MUTEX_NESTED.

Referenced by switch_core_media_gen_local_sdp(), and switch_core_media_negotiate_sdp().

 {
         switch_msrp_session_t *ms;
         ms = switch_core_alloc(pool, sizeof(switch_msrp_session_t));
         switch_assert(ms);
         ms->pool = pool;
         ms->secure = secure;
         ms->local_port = secure ? globals.msock_ssl.port : globals.msock.port;
         ms->msrp_msg_buffer_size = globals.message_buffer_size;
         ms->call_id = switch_core_strdup(pool, call_id);
         switch_mutex_init(&ms->mutex, SWITCH_MUTEX_NESTED, pool);
         return ms;
 }

◆ switch_msrp_session_pop_msg()

switch_msrp_msg_t* switch_msrp_session_pop_msg ( switch_msrp_session_t * ms )

Definition at line 445 of file switch_msrp.c.

References switch_msrp_session_s::last_msg, switch_msrp_session_s::msrp_msg, switch_msrp_session_s::msrp_msg_count, switch_msrp_session_s::mutex, msrp_msg_s::next, switch_mutex_lock(), switch_mutex_unlock(), and switch_yield.

Referenced by SWITCH_STANDARD_APP().

 {
         switch_msrp_msg_t *m = NULL;
 
         switch_mutex_lock(ms->mutex);
 
         m = ms->msrp_msg;
 
         if (m == NULL) {
                 switch_mutex_unlock(ms->mutex);
                 switch_yield(20000);
                 switch_mutex_lock(ms->mutex);
         }
 
         m = ms->msrp_msg;
 
         if (m == NULL) {
                 switch_mutex_unlock(ms->mutex);
                 return NULL;
         }
 
         ms->msrp_msg = ms->msrp_msg->next;
         ms->msrp_msg_count--;
 
         if (ms->msrp_msg == NULL) ms->last_msg = NULL;
 
         switch_mutex_unlock(ms->mutex);
 
         return m;
 }

◆ switch_msrp_start_client()

switch_status_t switch_msrp_start_client ( switch_msrp_session_t * msrp_session )

Definition at line 1488 of file switch_msrp.c.

References switch_msrp_session_s::call_id, msrp_client_socket_s::client_mode, worker_helper::csock, worker_helper::debug, globals, worker_helper::msrp_session, msrp_worker(), worker_helper::pool, switch_msrp_session_s::pool, msrp_client_socket_s::secure, switch_msrp_session_s::secure, msrp_client_socket_s::sock, switch_assert, SWITCH_CHANNEL_LOG, switch_core_alloc, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), and msrp_socket_s::thread.