#include <switch.h>
#include <switch_ssl.h>
#include <switch_msrp.h>
#include <switch_stun.h>

Include dependency graph for switch_msrp.c:

Data Structures
struct	msrp_socket_s

struct	msrp_client_socket_s

struct	worker_helper

Macros
#define	MSRP_BUFF_SIZE (SWITCH_RTP_MAX_BUF_LEN - 32)

#define	DEBUG_MSRP 0

#define	MSRP_TRANS_ID_LEN 16

#define	MSRP_SYNTAX "debug <on\|off>\|restart"

Typedefs
typedef struct worker_helper	worker_helper_t

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

static switch_bool_t	msrp_check_success_report (switch_msrp_msg_t *msrp_msg)

static void	msrp_deinit_ssl (void)

static void	msrp_init_ssl (void)

	SWITCH_DECLARE_GLOBAL_STRING_FUNC (set_global_ip, globals.ip)

static switch_status_t	load_config (void)

static void *SWITCH_THREAD_FUNC	msrp_listener (switch_thread_t thread, void obj)

static void	close_socket (switch_socket_t **sock)

static switch_status_t	msock_init (char ip, switch_port_t port, switch_socket_t sock, switch_memory_pool_t pool)

const char *	switch_msrp_listen_ip (void)

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_status_t	switch_msrp_session_push_msg (switch_msrp_session_t ms, switch_msrp_msg_t msg)

switch_msrp_msg_t *	switch_msrp_session_pop_msg (switch_msrp_session_t *ms)

char *	msrp_msg_serialize (switch_msrp_msg_t *msrp_msg)

static switch_status_t	msrp_socket_recv (switch_msrp_client_socket_t csock, char buf, switch_size_t *len)

static switch_status_t	msrp_socket_send (switch_msrp_client_socket_t csock, char buf, switch_size_t *len)

void	dump_buffer (const char *buf, switch_size_t len, int line, int is_send)

char *	find_delim (char buf, int len, const char delim)

char *	switch_msrp_msg_header_name (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,...)

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

static char *	msrp_parse_header (char start, int skip, const char end, switch_msrp_msg_t msrp_msg, switch_msrp_header_type_t htype, switch_memory_pool_t pool)

static switch_msrp_msg_t *	msrp_parse_headers (char start, int len, switch_msrp_msg_t msrp_msg, switch_memory_pool_t *pool)

static switch_msrp_msg_t *	msrp_parse_buffer (char buf, int len, switch_msrp_msg_t msrp_msg, switch_memory_pool_t *pool)

switch_status_t	msrp_reply (switch_msrp_client_socket_t csock, switch_msrp_msg_t msrp_msg)

switch_status_t	msrp_report (switch_msrp_client_socket_t csock, switch_msrp_msg_t msrp_msg, char *status_code)

static switch_bool_t	msrp_find_uuid (char uuid, const char to_path)

static void *SWITCH_THREAD_FUNC	msrp_worker (switch_thread_t thread, void obj)

switch_status_t	switch_msrp_start_client (switch_msrp_session_t *msrp_session)

void	random_string (char *buf, uint16_t size)

static switch_status_t	switch_msrp_do_send (switch_msrp_session_t ms, switch_msrp_msg_t msrp_msg, const char file, const char func, int line)

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

switch_msrp_msg_t *	switch_msrp_msg_create (void)

switch_msrp_msg_t *	switch_msrp_msg_dup (switch_msrp_msg_t *msg)

void	switch_msrp_msg_destroy (switch_msrp_msg_t **msg)

	SWITCH_STANDARD_APP (msrp_recv_file_function)

	SWITCH_STANDARD_APP (msrp_send_file_function)

	SWITCH_STANDARD_API (uuid_msrp_send_function)

	SWITCH_STANDARD_API (msrp_api_function)

void	switch_msrp_load_apis_and_applications (switch_loadable_module_interface_t **module_interface)

Variables
struct {
int running

int debug

switch_memory_pool_t * pool

char * ip

int message_buffer_size

char * cert

char * key

const SSL_METHOD * ssl_method

SSL_CTX * ssl_ctx

int ssl_ready

const SSL_METHOD * ssl_client_method

SSL_CTX * ssl_client_ctx

switch_msrp_socket_t msock

switch_msrp_socket_t msock_ssl

}	globals

char *	HEADER_NAMES []

Macro Definition Documentation

◆ DEBUG_MSRP

#define DEBUG_MSRP 0

Definition at line 38 of file switch_msrp.c.

Referenced by switch_msrp_init().

◆ MSRP_BUFF_SIZE

#define MSRP_BUFF_SIZE (SWITCH_RTP_MAX_BUF_LEN - 32)

Definition at line 37 of file switch_msrp.c.

Referenced by dump_buffer(), msrp_worker(), and switch_msrp_do_send().

◆ MSRP_SYNTAX

#define MSRP_SYNTAX "debug <on|off>|restart"

Definition at line 1848 of file switch_msrp.c.

Referenced by switch_msrp_load_apis_and_applications(), and SWITCH_STANDARD_API().

◆ MSRP_TRANS_ID_LEN

#define MSRP_TRANS_ID_LEN 16

Definition at line 1518 of file switch_msrp.c.

Referenced by switch_msrp_do_send().

Typedef Documentation

◆ worker_helper_t

typedef struct worker_helper worker_helper_t

Function Documentation

◆ close_socket()

static void close_socket ( switch_socket_t ** sock )

static

Definition at line 239 of file switch_msrp.c.

References SWITCH_SHUTDOWN_READWRITE, switch_socket_close(), and switch_socket_shutdown().

Referenced by msrp_worker(), switch_msrp_destroy(), and switch_msrp_session_destroy().

 {
         // switch_mutex_lock(globals.sock_mutex);
         if (*sock) {
                 switch_socket_shutdown(*sock, SWITCH_SHUTDOWN_READWRITE);
                 switch_socket_close(*sock);
                 *sock = NULL;
         }
         // switch_mutex_unlock(globals.sock_mutex);
 }

◆ dump_buffer()

void dump_buffer	(	const char *	buf,
		switch_size_t	len,
		int	line,
		int	is_send
	)

Definition at line 561 of file switch_msrp.c.

References MSRP_BUFF_SIZE, SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, SWITCH_LOG_NOTICE, switch_log_printf(), and SWITCH_SIZE_T_FMT.

Referenced by msrp_parse_buffer(), msrp_worker(), and switch_msrp_do_send().

 {
         int i, j, k = 0;
         char buff[MSRP_BUFF_SIZE * 2];
         // return;
         for(i=0,j=0; i<len; i++) {
                 if (buf[i] == '\0') {
                         buff[j++] = '\\';
                         buff[j++] = '0';
                 } else if(buf[i] == '\r') {
                         buff[j++] = '\\';
                         buff[j++] = 'r';
                 } else if(buf[i] == '\n') {
                         buff[j++] = '\\';
                         buff[j++] = 'n';
                         buff[j++] = '\n';
                         k = 0;
                 }
                  else {
                         buff[j++] = buf[i];
                 }
                 if ((++k) %80 == 0) buff[j++] = '\n';
                 if (j >= MSRP_BUFF_SIZE * 2) break;
         }
 
         buff[j] = '\0';
         switch_log_printf(SWITCH_CHANNEL_LOG, is_send ? SWITCH_LOG_NOTICE: SWITCH_LOG_INFO,
                 "%d: %s [%" SWITCH_SIZE_T_FMT "] bytes [\n%s]\n", line, is_send? "SEND" : "RECV", len, buff);
 }

◆ find_delim()

char* find_delim	(	char *	buf,
		int	len,
		const char *	delim
	)

Definition at line 591 of file switch_msrp.c.

References buf.

Referenced by msrp_parse_buffer().

 {
         char *p, *q, *s = NULL;
         char *end;
 
         p = buf;
         q = (char *)delim;
 
         if (p == NULL) return NULL;
         if (q == NULL) return NULL;
 
         end = buf + len - strlen(delim);
 
         while(p < end && *q) {
                         if (*p == *q) {
                                         if (s == NULL) s = p;
                                         p++;
                                         q++;
                         } else {
                                         s = NULL;
                                         p++;
                                         q = (char *)delim;
                         }
                         if (*q == '\0') return s;
         }
         return NULL;
 }

◆ load_config()

static switch_status_t load_config ( void )

static

Definition at line 190 of file switch_msrp.c.

References switch_directories::certs_dir, globals, msrp_listener(), switch_xml::next, SWITCH_CHANNEL_LOG, switch_core_gen_certs(), switch_core_sprintf(), switch_core_strdup, switch_file_exists(), SWITCH_GLOBAL_dirs, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_PATH_SEPARATOR, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_THREAD_FUNC, switch_true(), switch_xml_attr_soft(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), and msrp_socket_s::thread.

Referenced by switch_msrp_init().

 {
         char *cf = "msrp.conf";
         switch_xml_t cfg, xml = NULL, settings, param;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         globals.cert = switch_core_sprintf(globals.pool, "%s%swss.pem", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR);
         globals.key = globals.cert;
 
         if ( switch_file_exists(globals.key, globals.pool) != SWITCH_STATUS_SUCCESS ) {
                 switch_core_gen_certs(globals.key);
         }
 
         if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Open of %s failed\n", cf);
                 status = SWITCH_STATUS_FALSE;
                 return status;
         }
 
         if ((settings = switch_xml_child(cfg, "settings"))) {
                 for (param = switch_xml_child(settings, "param"); param; param = param->next) {
                         char *var = (char *) switch_xml_attr_soft(param, "name");
                         char *val = (char *) switch_xml_attr_soft(param, "value");
                         if (!strcasecmp(var, "listen-ip")) {
                                 set_global_ip(val);
                         } else if (!strcasecmp(var, "listen-port")) {
                                 globals.msock.port = atoi(val);
                         } else if (!strcasecmp(var, "listen-ssl-port")) {
                                 globals.msock_ssl.port = atoi(val);
                         } else if (!strcasecmp(var, "debug")) {
                                 globals.debug = switch_true(val);
                         } else if (!strcasecmp(var, "secure-cert")) {
                                 globals.cert = switch_core_strdup(globals.pool, val);
                         } else if (!strcasecmp(var, "secure-key")) {
                                 globals.key = switch_core_strdup(globals.pool, val);
                         } else if (!strcasecmp(var, "message-buffer-size") && val) {
                                 globals.message_buffer_size = atoi(val);
                                 if (globals.message_buffer_size == 0) globals.message_buffer_size = 50;
                         }
                 }
         }
 
         switch_xml_free(xml);
 
         return status;
 }

◆ msock_init()

static switch_status_t msock_init	(	char *	ip,
		switch_port_t	port,
		switch_socket_t **	sock,
		switch_memory_pool_t *	pool
	)

static

Definition at line 250 of file switch_msrp.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_PROTO_TCP, SWITCH_SO_IPV6_V6ONLY, SWITCH_SO_REUSEADDR, switch_sockaddr_get_family(), switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_create(), switch_socket_listen(), switch_socket_opt_set(), SWITCH_STATUS_SUCCESS, and SWITCH_UNSPEC.

Referenced by switch_msrp_init().

 {
         switch_sockaddr_t *sa;
         switch_status_t rv;
 
         rv = switch_sockaddr_info_get(&sa, ip, SWITCH_UNSPEC, port, 0, pool);
         if (rv) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot get information about MSRP listen IP address %s\n", ip);
                 goto sock_fail;
         }
 
         rv = switch_socket_create(sock, switch_sockaddr_get_family(sa), SOCK_STREAM, SWITCH_PROTO_TCP, pool);
         if (rv) goto sock_fail;
 
         rv = switch_socket_opt_set(*sock, SWITCH_SO_REUSEADDR, 1);
         if (rv) goto sock_fail;
 
 #ifdef WIN32
         /* Enable dual-stack listening on Windows */
         if (switch_sockaddr_get_family(sa) == AF_INET6) {
                 rv = switch_socket_opt_set(*sock, SWITCH_SO_IPV6_V6ONLY, 0);
                 if (rv) goto sock_fail;
         }
 #endif
 
         rv = switch_socket_bind(*sock, sa);
         if (rv) goto sock_fail;
 
         rv = switch_socket_listen(*sock, 5);
         if (rv) goto sock_fail;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Socket up listening on %s:%u\n", ip, port);
 
         return SWITCH_STATUS_SUCCESS;
 
 sock_fail:
         return rv;
 }

◆ msrp_check_success_report()

static switch_bool_t msrp_check_success_report ( switch_msrp_msg_t * msrp_msg )

static

Definition at line 96 of file switch_msrp.c.

References MSRP_H_SUCCESS_REPORT, and switch_msrp_msg_get_header().

Referenced by msrp_worker().

 {
         const char *msrp_h_success_report = switch_msrp_msg_get_header(msrp_msg, MSRP_H_SUCCESS_REPORT);
         return (msrp_h_success_report && !strcmp(msrp_h_success_report, "yes"));
 }

◆ msrp_deinit_ssl()

static void msrp_deinit_ssl ( void )

static

Definition at line 102 of file switch_msrp.c.

References globals.

Referenced by msrp_init_ssl(), and switch_msrp_destroy().

 {
         globals.ssl_ready = 0;
         if (globals.ssl_ctx) {
                 SSL_CTX_free(globals.ssl_ctx);
                 globals.ssl_ctx = NULL;
         }
         if (globals.ssl_client_ctx) {
                 SSL_CTX_free(globals.ssl_client_ctx);
                 globals.ssl_client_ctx = NULL;
         }
 }

◆ msrp_find_uuid()

static switch_bool_t msrp_find_uuid	(	char *	uuid,
		const char *	to_path
	)

static

Definition at line 1034 of file switch_msrp.c.

References switch_assert, SWITCH_FALSE, switch_snprintf(), and SWITCH_TRUE.

Referenced by msrp_worker().

 {
         int len = strlen(to_path);
         int i;
         int slash_count = 0;
         switch_assert(to_path);
         for(i=0; i<len; i++){
                 if (*(to_path + i) == '/') {
                         if (++slash_count == 3) break;
                 }
         }
         if (slash_count < 3) return SWITCH_FALSE;
         if (len - i++ < 36) return SWITCH_FALSE;
         switch_snprintf(uuid, 37, to_path + i);
         return SWITCH_TRUE;
 }

◆ msrp_init_ssl()

static void msrp_init_ssl ( void )

static

Definition at line 115 of file switch_msrp.c.

References fail, globals, msrp_deinit_ssl(), SWITCH_CHANNEL_LOG, SWITCH_DECLARE_GLOBAL_STRING_FUNC(), switch_file_exists(), SWITCH_LOG_ERROR, switch_log_printf(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_msrp_init().

 {
         const char *err = "";
 
         globals.ssl_client_method = SSLv23_client_method();
         globals.ssl_client_ctx = SSL_CTX_new(globals.ssl_client_method);
         assert(globals.ssl_client_ctx);
         SSL_CTX_set_options(globals.ssl_client_ctx, SSL_OP_NO_SSLv2);
 
         globals.ssl_method = SSLv23_server_method();   /* create server instance */
         globals.ssl_ctx = SSL_CTX_new(globals.ssl_method);    /* create context */
         assert(globals.ssl_ctx);
         globals.ssl_ready = 1;
 
         /* Disable SSLv2 */
         SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv2);
         /* Disable SSLv3 */
         SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_SSLv3);
         /* Disable TLSv1 */
         SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_TLSv1);
         /* Disable Compression CRIME (Compression Ratio Info-leak Made Easy) */
         SSL_CTX_set_options(globals.ssl_ctx, SSL_OP_NO_COMPRESSION);
 
         // /* set the local certificate from CertFile */
         // if (!zstr(profile->chain)) {
         //      if (switch_file_exists(profile->chain, NULL) != SWITCH_STATUS_SUCCESS) {
         //              err = "SUPPLIED CHAIN FILE NOT FOUND\n";
         //              goto fail;
         //      }
 
         //      if (!SSL_CTX_use_certificate_chain_file(profile->ssl_ctx, profile->chain)) {
         //              err = "CERT CHAIN FILE ERROR";
         //              goto fail;
         //      }
         // }
 
         if (switch_file_exists(globals.cert, NULL) != SWITCH_STATUS_SUCCESS) {
                 err = "SUPPLIED CERT FILE NOT FOUND\n";
                 goto fail;
         }
 
         if (!SSL_CTX_use_certificate_file(globals.ssl_ctx, globals.cert, SSL_FILETYPE_PEM)) {
                 err = "CERT FILE ERROR";
                 goto fail;
         }
 
         /* set the private key from KeyFile */
 
         if (switch_file_exists(globals.key, NULL) != SWITCH_STATUS_SUCCESS) {
                 err = "SUPPLIED KEY FILE NOT FOUND\n";
                 goto fail;
         }
 
         if (!SSL_CTX_use_PrivateKey_file(globals.ssl_ctx, globals.key, SSL_FILETYPE_PEM)) {
                 err = "PRIVATE KEY FILE ERROR";
                 goto fail;
         }
 
         /* verify private key */
         if ( !SSL_CTX_check_private_key(globals.ssl_ctx) ) {
                 err = "PRIVATE KEY FILE ERROR";
                 goto fail;
         }
 
         SSL_CTX_set_cipher_list(globals.ssl_ctx, "HIGH:!DSS:!aNULL@STRENGTH");
 
         return;
 
  fail:
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SSL ERR: %s\n", err);
         msrp_deinit_ssl();
 }

◆ msrp_listener()

static void *SWITCH_THREAD_FUNC msrp_listener	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1425 of file switch_msrp.c.

References worker_helper::csock, worker_helper::debug, globals, msock, msrp_worker(), pool, worker_helper::pool, msrp_socket_s::secure, msrp_client_socket_s::secure, msrp_socket_s::sock, msrp_client_socket_s::sock, switch_assert, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_get_addr(), SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_SO_TCP_NODELAY, switch_sockaddr_get_port(), switch_socket_accept(), switch_socket_addr_get(), switch_socket_opt_set(), SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), SWITCH_TRUE, and TRUE.

Referenced by load_config(), and switch_msrp_init().

 {
         switch_msrp_socket_t *msock = (switch_msrp_socket_t *)obj;
         switch_memory_pool_t *pool = NULL;
         switch_threadattr_t *thd_attr = NULL;
         switch_socket_t *sock = NULL;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP listener start%s\n", msock->secure ? " ssl" : "");
 
         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 NULL;
         }
 
         switch_socket_opt_set(msock->sock, SWITCH_SO_TCP_NODELAY, TRUE);
         // switch_socket_opt_set(msock->sock, SWITCH_SO_NONBLOCK, TRUE);
 
         while (globals.running && switch_socket_accept(&sock, msock->sock, pool) == SWITCH_STATUS_SUCCESS) {
                 switch_memory_pool_t *worker_pool;
                 worker_helper_t *helper;
 
                 if (globals.debug > 0) {
                         switch_sockaddr_t *addr = NULL;
                         char remote_ip[128];
 
                         /* Get the remote address/port info */
                         switch_socket_addr_get(&addr, SWITCH_TRUE, sock);
 
                         if (addr) {
                                 switch_get_addr(remote_ip, sizeof(remote_ip), addr);
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Connection Open%s from %s:%d\n", msock->secure ? " SSL" : "", remote_ip, switch_sockaddr_get_port(addr));
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error get remote addr!\n");
                         }
                 }
 
                 if (switch_core_new_memory_pool(&worker_pool) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "OH OH no pool\n");
                         return NULL;
                 }
 
                 helper = switch_core_alloc(worker_pool, sizeof(worker_helper_t));
 
                 switch_assert(helper != NULL);
                 helper->pool = worker_pool;
                 helper->debug = globals.debug;
                 helper->csock.sock = sock;
                 helper->csock.secure = msock->secure;
 
                 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_worker, helper, worker_pool);
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP worker new thread spawned!\n");
         }
 
         if (pool) switch_core_destroy_memory_pool(&pool);
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP listener down\n");
 
         return NULL;
 }

◆ msrp_msg_serialize()

char* msrp_msg_serialize ( switch_msrp_msg_t * msrp_msg )

Definition at line 476 of file switch_msrp.c.

References msrp_msg_s::byte_end, msrp_msg_s::byte_start, msrp_msg_s::bytes, msrp_msg_s::code_description, msrp_msg_s::code_number, msrp_msg_s::delimiter, msrp_msg_s::method, MSRP_H_CONTENT_TYPE, MSRP_H_FROM_PATH, MSRP_H_MESSAGE_ID, MSRP_H_TO_PATH, MSRP_METHOD_AUTH, MSRP_METHOD_REPLY, MSRP_METHOD_REPORT, MSRP_METHOD_SEND, msrp_msg_s::payload, switch_mprintf(), switch_msrp_msg_get_header(), switch_safe_free, SWITCH_SIZE_T_FMT, and msrp_msg_s::transaction_id.

Referenced by msrp_worker().

 {
         char *code_number_str = switch_mprintf("%d", msrp_msg->code_number);
         const char *content_type = switch_msrp_msg_get_header(msrp_msg, MSRP_H_CONTENT_TYPE);
         char method[10];
         char *result = NULL;
 
         switch(msrp_msg->method) {
                 case MSRP_METHOD_SEND: sprintf(method, "SEND"); break;
                 case MSRP_METHOD_AUTH: sprintf(method, "AUTH"); break;
                 case MSRP_METHOD_REPLY: sprintf(method, "REPLY"); break;
                 case MSRP_METHOD_REPORT: sprintf(method, "REPORT"); break;
                 default: sprintf(method, "??%d", msrp_msg->method); break;
         }
 
         result = switch_mprintf("\n=================================\n"
                 "MSRP %s %s%s\r\nFrom: %s\r\nTo: %s\r\nMessage-ID: %s\r\n"
                 "Byte-Range: %" SWITCH_SIZE_T_FMT "-%" SWITCH_SIZE_T_FMT"/%" SWITCH_SIZE_T_FMT "\r\n"
                 "%s%s%s" /* Content-Type */
                 "%s%s%s%s$\r\n"
                 "=================================\n",
                 msrp_msg->transaction_id ? msrp_msg->transaction_id : code_number_str,
                 msrp_msg->transaction_id ? "" : " ",
                 msrp_msg->transaction_id ? method : msrp_msg->code_description,
                 switch_msrp_msg_get_header(msrp_msg, MSRP_H_FROM_PATH),
                 switch_msrp_msg_get_header(msrp_msg, MSRP_H_TO_PATH),
                 switch_msrp_msg_get_header(msrp_msg, MSRP_H_MESSAGE_ID),
                 msrp_msg->byte_start,
                 msrp_msg->byte_end,
                 msrp_msg->bytes,
                 content_type ? "Content-Type: " : "",
                 content_type ? content_type : "",
                 content_type ? "\r\n" : "",
                 msrp_msg->payload ? "\r\n" : "",
                 msrp_msg->payload ? msrp_msg->payload : "",
                 msrp_msg->payload ? "\r\n" : "",
                 msrp_msg->delimiter);
 
         switch_safe_free(code_number_str)
 
         return result;
 }

◆ msrp_parse_buffer()

static switch_msrp_msg_t* msrp_parse_buffer	(	char *	buf,
		int	len,
		switch_msrp_msg_t *	msrp_msg,
		switch_memory_pool_t *	pool
	)

static

Definition at line 878 of file switch_msrp.c.

References msrp_msg_s::accumulated_bytes, buf, msrp_msg_s::byte_end, msrp_msg_s::byte_start, msrp_msg_s::delimiter, dump_buffer(), find_delim(), globals, msrp_msg_s::last_p, msrp_parse_headers(), MSRP_ST_DONE, MSRP_ST_ERROR, MSRP_ST_WAIT_BODY, MSRP_ST_WAIT_HEADER, msrp_msg_s::payload, msrp_msg_s::payload_bytes, msrp_msg_s::range_star, msrp_msg_s::state, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_msrp_msg_create(), switch_msrp_msg_set_payload(), SWITCH_SIZE_T_FMT, and switch_stristr().

Referenced by msrp_worker().

 {
         char *start;
 
         if (!msrp_msg) {
                 msrp_msg = switch_msrp_msg_create();
                 msrp_msg->state = MSRP_ST_WAIT_HEADER;
         }
 
         if (globals.debug) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "parse state: %d\n", msrp_msg->state);
                 dump_buffer(buf, len, __LINE__, 0);
         }
 
         if (msrp_msg->state == MSRP_ST_WAIT_HEADER) {
                 if ((start = (char *)switch_stristr("MSRP ", buf)) == NULL) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Not an MSRP packet, Skip!\n");
                         return msrp_msg;
                 }
 
                 msrp_msg = msrp_parse_headers(start, len - (start - buf), msrp_msg, pool);
 
                 if (msrp_msg->state == MSRP_ST_ERROR) return msrp_msg;
                 if (msrp_msg->state == MSRP_ST_DONE) return msrp_msg;
 
                 if (msrp_msg->last_p && msrp_msg->last_p < buf + len) {
                         msrp_msg = msrp_parse_buffer(msrp_msg->last_p, len - (msrp_msg->last_p - buf), msrp_msg, pool);
                 }
         } else if (msrp_msg->state == MSRP_ST_WAIT_BODY) {
                 if(!msrp_msg->range_star && msrp_msg->byte_end == 0) {
                         msrp_msg->state = MSRP_ST_DONE;
                         return msrp_msg;
                 }
 
                 if (msrp_msg->range_star) { /* the * case */
                         /*hope we can find the delimiter at the end*/
                         int dlen;
                         char *delim_pos = NULL;
                         switch_size_t payload_bytes;
 
                         switch_assert(msrp_msg->delimiter);
                         dlen = strlen(msrp_msg->delimiter);
 
                         if (!strncmp(buf + len - dlen - 3, msrp_msg->delimiter, dlen)) { /*bingo*/
                                 payload_bytes = len - dlen - 5;
                                 switch_msrp_msg_set_payload(msrp_msg, buf, payload_bytes);
                                 msrp_msg->byte_end = msrp_msg->byte_start + payload_bytes - 1;
                                 msrp_msg->state = MSRP_ST_DONE;
                                 msrp_msg->last_p = buf + len;
                                 if (msrp_msg->accumulated_bytes) {
                                         msrp_msg->accumulated_bytes += payload_bytes;
                                 }
                                 return msrp_msg;
                         } else if ((delim_pos = find_delim(buf, len, msrp_msg->delimiter))) {
                                 if (globals.debug) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "=======================================delimiter: %s\n", delim_pos);
                                 }
                                 switch_assert(delim_pos - buf >= 2);
                                 payload_bytes = delim_pos - buf - 2;
                                 switch_msrp_msg_set_payload(msrp_msg, buf, payload_bytes);
                                 msrp_msg->byte_end = msrp_msg->byte_start + msrp_msg->payload_bytes - 1;
                                 msrp_msg->state = MSRP_ST_DONE;
                                 msrp_msg->last_p = delim_pos + dlen + 3;
                                 if (msrp_msg->accumulated_bytes) {
                                         msrp_msg->accumulated_bytes += payload_bytes;
                                 }
                                 return msrp_msg;
                         } else {/* keep waiting*/
                                 msrp_msg->last_p = buf;
                                 return msrp_msg;
                         }
                 } else if (msrp_msg->payload_bytes == 0) {
                         int dlen = strlen(msrp_msg->delimiter);
 
                         if (strncasecmp(buf, msrp_msg->delimiter, dlen)) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error find delimiter\n");
                                 msrp_msg->state = MSRP_ST_ERROR;
                                 return msrp_msg;
                         }
 
                         msrp_msg->payload = NULL;
                         msrp_msg->state = MSRP_ST_DONE;
                         msrp_msg->last_p = buf + dlen + 3; /*Fixme: assuming end with $\r\n*/
 
                         return msrp_msg;
                 } else {
                         int dlen = strlen(msrp_msg->delimiter);
 
                         if (msrp_msg->payload_bytes > len) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "payload too large ... %d > %d\n", (int)msrp_msg->payload_bytes, (int)len);
                                 msrp_msg->state = MSRP_ST_ERROR; // not supported yet
                                 return msrp_msg;
                         }
 
                         switch_msrp_msg_set_payload(msrp_msg, buf, msrp_msg->payload_bytes);
                         msrp_msg->last_p = buf + msrp_msg->payload_bytes;
                         msrp_msg->state = MSRP_ST_DONE;
                         msrp_msg->last_p = buf + msrp_msg->payload_bytes;
 
                         if (msrp_msg->payload_bytes <= len - dlen - 5) {
                                 msrp_msg->last_p = buf + msrp_msg->payload_bytes + dlen + 5;
 
                                 if (globals.debug) switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "payload bytes: %" SWITCH_SIZE_T_FMT " len: %d dlen: %d delimiter: %s\n", msrp_msg->payload_bytes, len, dlen, msrp_msg->delimiter);
 
                                 return msrp_msg; /*Fixme: assuming \r\ndelimiter$\r\n present*/
                         }
 
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%" SWITCH_SIZE_T_FMT " %d %d\n", msrp_msg->payload_bytes, len, dlen);
                         msrp_msg->state = MSRP_ST_ERROR;
 
                         return msrp_msg;
                 }
         } else {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error code: %d\n", msrp_msg->state);
         }
 
         return msrp_msg;
 }

◆ msrp_parse_header()

static char* msrp_parse_header	(	char *	start,
		int	skip,
		const char *	end,
		switch_msrp_msg_t *	msrp_msg,
		switch_msrp_header_type_t	htype,
		switch_memory_pool_t *	pool
	)

static

Definition at line 690 of file switch_msrp.c.

References switch_msrp_msg_add_header().

Referenced by msrp_parse_headers().

 {
         char *p = start + skip;
         char *q;
         if (*p && *p == ' ') p++;
         q = p;
         while(*q != '\n' && q < end) q++;
         if (q > p) {
                 if (*(q-1) == '\r') *(q-1) = '\0';
                 *q = '\0';
                 switch_msrp_msg_add_header(msrp_msg, htype, p);
                 return q + 1;
         }
         return start;
 }

◆ msrp_parse_headers()

static switch_msrp_msg_t* msrp_parse_headers	(	char *	start,
		int	len,
		switch_msrp_msg_t *	msrp_msg,
		switch_memory_pool_t *	pool
	)

static

Definition at line 706 of file switch_msrp.c.

References msrp_msg_s::byte_end, msrp_msg_s::byte_start, msrp_msg_s::bytes, msrp_msg_s::code_number, msrp_msg_s::delimiter, globals, msrp_msg_s::last_p, msrp_msg_s::method, MSRP_H_CODE_DESCRIPTION, MSRP_H_CONTENT_TYPE, MSRP_H_DELIMITER, MSRP_H_FAILURE_REPORT, MSRP_H_FROM_PATH, MSRP_H_KEEPALIVE, MSRP_H_MESSAGE_ID, MSRP_H_STATUS, MSRP_H_SUCCESS_REPORT, MSRP_H_TO_PATH, MSRP_H_TRASACTION_ID, MSRP_H_UNKNOWN, MSRP_METHOD_AUTH, MSRP_METHOD_REPLY, MSRP_METHOD_REPORT, MSRP_METHOD_SEND, msrp_parse_header(), MSRP_ST_DONE, MSRP_ST_ERROR, MSRP_ST_PARSE_HEADER, MSRP_ST_WAIT_BODY, msrp_msg_s::payload_bytes, msrp_msg_s::range_star, msrp_msg_s::state, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_msrp_msg_add_header(), and SWITCH_SIZE_T_FMT.

Referenced by msrp_parse_buffer().

 {
         char *p = start;
         char *q;
         const char *end = start + len;
 
         while(p < end) {
                 if (!strncasecmp(p, "MSRP ", 5)) {
                         p += 5;
                         q = p;
 
                         while(*q && q < end && *q != ' ') q++;
 
                         if (q > p) {
                                 *q = '\0';
                                 switch_msrp_msg_add_header(msrp_msg, MSRP_H_TRASACTION_ID, p);
                                 switch_msrp_msg_add_header(msrp_msg, MSRP_H_DELIMITER, "-------%s", p);
                                 msrp_msg->state = MSRP_ST_PARSE_HEADER;
                         }
 
                         p = q;
 
                         if (++p >= end) goto done;
 
                         if (!strncasecmp(p, "SEND", 4)) {
                                 msrp_msg->method = MSRP_METHOD_SEND;
                                 p += 6; /*skip \r\n*/
                         } else if (!strncasecmp(p, "REPORT", 6)) {
                                 msrp_msg->method = MSRP_METHOD_REPORT;
                                 p += 8;
                         } else if (!strncasecmp(p, "AUTH", 4)) {
                                 msrp_msg->method = MSRP_METHOD_AUTH;
                                 p += 6;
                         } else {/* MSRP transaction_id coden_number codede_scription */
                                 msrp_msg->method = MSRP_METHOD_REPLY;
                                 q = p;
                                 while(*q && q < end && *q != ' ') q++;
                                 if (q > p) {
                                         *q = '\0';
                                         msrp_msg->code_number = atoi(p);
                                         p = ++q;
                                         while(*q && q < end && *q != '\n') q++;
                                         if (q > p) {
                                                 if (*(q-1) == '\r') *(q-1) = '\0';
                                                 *q = '\0';
                                                 switch_msrp_msg_add_header(msrp_msg, MSRP_H_CODE_DESCRIPTION, p);
                                                 p = ++q;
                                         }
                                 }
                         }
                 } else if (!strncasecmp(p, "From-Path:", 10)) {
                         q = msrp_parse_header(p, 10, end, msrp_msg, MSRP_H_FROM_PATH, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "To-Path:", 8)) {
                         q = msrp_parse_header(p, 8, end, msrp_msg, MSRP_H_TO_PATH, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Status:", 7)) {
                         q = msrp_parse_header(p, 7, end, msrp_msg, MSRP_H_STATUS, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Keep-Alive:", 11)) {
                         q = msrp_parse_header(p, 11, end, msrp_msg, MSRP_H_KEEPALIVE, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Message-ID:", 11)) {
                         q = msrp_parse_header(p, 11, end, msrp_msg, MSRP_H_MESSAGE_ID, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Content-Type:", 13)) {
                         q = msrp_parse_header(p, 13, end, msrp_msg, MSRP_H_CONTENT_TYPE, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Success-Report:", 15)) {
                         q = msrp_parse_header(p, 15, end, msrp_msg, MSRP_H_SUCCESS_REPORT, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Failure-Report:", 15)) {
                         q = msrp_parse_header(p, 15, end, msrp_msg, MSRP_H_FAILURE_REPORT, pool);
                         if (q == p) break; /* incomplete header*/
                         p = q;
                 } else if (!strncasecmp(p, "Byte-Range:", 11)) {
                         p += 11;
                         if (*p && *p == ' ') p++;
                         q = p;
                         while(*q && q < end && *q != '-') q++;
                         if (q > p) {
                                 *q = '\0';
                                 msrp_msg->byte_start = atoi(p);
                                 switch_assert(msrp_msg->byte_start > 0);
                                 p = ++q;
                                 if (*p && *p == '*') {
                                         msrp_msg->range_star = 1;
                                 }
                                 while(*q && q < end && *q != '/') q++;
                                 if (q > p) {
                                         *q = '\0';
                                         msrp_msg->byte_end = msrp_msg->range_star ? 0 : atoi(p);
                                         p = ++q;
                                         while(*q && q < end && *q != '\n') q++;
                                         if (q > p) {
                                                 if (*(q-1) == '\r') *(q-1) = '\0';
                                                 *q = '\0';
                                                 msrp_msg->bytes = atoi(p);
 
                                                 if (!msrp_msg->range_star) {
                                                         msrp_msg->payload_bytes = msrp_msg->byte_end + 1 - msrp_msg->byte_start;
                                                 }
 
                                                 if (globals.debug) switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%" SWITCH_SIZE_T_FMT " payload bytes\n", msrp_msg->payload_bytes);
 
                                                 /*Fixme sanity check to avoid large byte-range attack*/
                                                 if (!msrp_msg->range_star && msrp_msg->payload_bytes > msrp_msg->bytes) {
                                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "payload size does't match %" SWITCH_SIZE_T_FMT " != %" SWITCH_SIZE_T_FMT "\n", msrp_msg->payload_bytes, msrp_msg->bytes);
                                                         msrp_msg->state = MSRP_ST_ERROR;
                                                         p = ++q;
                                                         break;
                                                 }
                                                 p = ++q;
                                         }
                                 }
                         }
                 } else if (*p == '\r' && *(p+1) == '\n') {
                         msrp_msg->state = MSRP_ST_WAIT_BODY;
                         p += 2;
                         break;
                 } else if (msrp_msg->delimiter &&
                         !strncasecmp(p, msrp_msg->delimiter, strlen(msrp_msg->delimiter))) {
                                 char *x = p + strlen(msrp_msg->delimiter);
                                 if (x < end) {
                                         if (*x == '$') {
                                                 p = x + 1;
                                                 msrp_msg->state = MSRP_ST_DONE;
                                                 if (*p == '\r') p++;
                                                 if (*p == '\n') p++;
                                                 break;
                                         } else if(*x == '+') {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unsupported %c\n", *x);
                                                 if (*p == '\r') p++;
                                                 if (*p == '\n') p++;
                                                 break;
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unsupported %c\n", *x);
                                                 msrp_msg->state = MSRP_ST_ERROR; //TODO support # etc.
                                                 break;
                                         }
                                 }
                                 break;
                 } else {/* unsupported header */
                         q = p;
                         while(*q && q < end && *q != ':') q++;
                         if (q > p) {
                                 char *last_p = p;
                                 *q = '\0';
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unsupported header [%s]\n", p);
                                 p = q + 1;
                                 q = msrp_parse_header(p, 0, end, msrp_msg, MSRP_H_UNKNOWN, pool);
                                 if (q == p) {
                                         p = last_p;
                                         break; /* incomplete header */
                                 }
                                 p = q;
                         }
                 }
         }
 
 done:
         msrp_msg->last_p = p;
         return msrp_msg;
 }

◆ msrp_reply()

switch_status_t msrp_reply	(	switch_msrp_client_socket_t *	csock,
		switch_msrp_msg_t *	msrp_msg
	)

Definition at line 997 of file switch_msrp.c.

References buf, msrp_msg_s::delimiter, MSRP_H_FROM_PATH, MSRP_H_TO_PATH, msrp_socket_send(), switch_msrp_msg_get_header(), switch_str_nil, and msrp_msg_s::transaction_id.

Referenced by msrp_worker().

 {
         char buf[2048];
         switch_size_t len;
         sprintf(buf, "MSRP %s 200 OK\r\nTo-Path: %s\r\nFrom-Path: %s\r\n"
                 "%s$\r\n",
                 msrp_msg->transaction_id,
                 switch_str_nil(switch_msrp_msg_get_header(msrp_msg, MSRP_H_FROM_PATH)),
                 switch_str_nil(switch_msrp_msg_get_header(msrp_msg, MSRP_H_TO_PATH)),
                 msrp_msg->delimiter);
         len = strlen(buf);
 
         return msrp_socket_send(csock, buf, &len);
 }

◆ msrp_report()

switch_status_t msrp_report	(	switch_msrp_client_socket_t *	csock,
		switch_msrp_msg_t *	msrp_msg,
		char *	status_code
	)

Definition at line 1012 of file switch_msrp.c.

References msrp_msg_s::accumulated_bytes, buf, msrp_msg_s::byte_end, msrp_msg_s::bytes, msrp_msg_s::delimiter, globals, MSRP_H_FROM_PATH, MSRP_H_MESSAGE_ID, MSRP_H_TO_PATH, msrp_socket_send(), SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), switch_msrp_msg_get_header(), SWITCH_SIZE_T_FMT, switch_str_nil, and msrp_msg_s::transaction_id.

Referenced by msrp_worker().

 {
         char buf[2048];
         switch_size_t len;
         sprintf(buf, "MSRP %s REPORT\r\nTo-Path: %s\r\nFrom-Path: %s\r\nMessage-ID: %s\r\n"
                 "Status: 000 %s\r\nByte-Range: 1-%" SWITCH_SIZE_T_FMT "/%" SWITCH_SIZE_T_FMT
                 "\r\n%s$\r\n",
                 msrp_msg->transaction_id,
                 switch_str_nil(switch_msrp_msg_get_header(msrp_msg, MSRP_H_FROM_PATH)),
                 switch_str_nil(switch_msrp_msg_get_header(msrp_msg, MSRP_H_TO_PATH)),
                 switch_str_nil(switch_msrp_msg_get_header(msrp_msg, MSRP_H_MESSAGE_ID)),
                 switch_str_nil(status_code),
                 msrp_msg->accumulated_bytes ? msrp_msg->accumulated_bytes : msrp_msg->byte_end,
                 msrp_msg->bytes,
                 msrp_msg->delimiter);
         len = strlen(buf);
 
         if (globals.debug) switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "report: %" SWITCH_SIZE_T_FMT " bytes [\n%s]\n", len, buf);
 
         return msrp_socket_send(csock, buf, &len);
 }

◆ msrp_socket_recv()

static switch_status_t msrp_socket_recv	(	switch_msrp_client_socket_t *	csock,
		char *	buf,
		switch_size_t *	len
	)

static

Definition at line 519 of file switch_msrp.c.

References globals, msrp_client_socket_s::secure, msrp_client_socket_s::sock, msrp_client_socket_s::ssl, SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, switch_socket_recv(), SWITCH_SSIZE_T_FMT, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_strerror().

Referenced by msrp_worker().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (csock->secure) {
                 switch_ssize_t r;
                 r = SSL_read(csock->ssl, buf, *len);
                 if (r < 0) {
                         int error = SSL_get_error(csock->ssl, r);
                         if (!(SSL_ERROR_SYSCALL == error && errno == 9)) {// socket closed
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "TLS read error: ret=%" SWITCH_SSIZE_T_FMT " error=%d errno=%d\n", r, error, errno);
                         }
                         *len = 0;
                 } else {
                         *len = r;
                         status = SWITCH_STATUS_SUCCESS;
                 }
         } else {
                 status = switch_socket_recv(csock->sock, buf, len);
         }
 
         if (globals.debug && status != SWITCH_STATUS_SUCCESS) {
                 char err[1024] = { 0 };
                 switch_strerror(status, err, sizeof(err) - 1);
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "msrp socket recv status = %d, %s\n", status, err);
         }
 
         return status;
 }

◆ msrp_socket_send()

static switch_status_t msrp_socket_send	(	switch_msrp_client_socket_t *	csock,
		char *	buf,
		switch_size_t *	len
	)

static

Definition at line 549 of file switch_msrp.c.

References msrp_client_socket_s::secure, msrp_client_socket_s::sock, msrp_client_socket_s::ssl, switch_socket_send(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by msrp_reply(), msrp_report(), and switch_msrp_do_send().

 {
         // switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "send: %s\n", buf);
 
         if (csock->secure) {
                 *len = SSL_write(csock->ssl, buf, *len);
                 return *len ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
         } else {
                 return switch_socket_send(csock->sock, buf, len);
         }
 }

◆ msrp_worker()

static void* SWITCH_THREAD_FUNC msrp_worker	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1051 of file switch_msrp.c.

Referenced by msrp_listener(), and switch_msrp_start_client().

 {
         worker_helper_t *helper = (worker_helper_t *) obj;
         switch_msrp_client_socket_t *csock = &helper->csock;
         switch_memory_pool_t *pool = helper->pool;
         char buf[MSRP_BUFF_SIZE];
         char *p;
         char *last_p;
         switch_size_t len = MSRP_BUFF_SIZE;
         switch_status_t status;
         switch_msrp_msg_t *msrp_msg = NULL;
         char uuid[128] = { 0 };
         switch_msrp_session_t *msrp_session = NULL;
         int sanity = 10;
         SSL *ssl = NULL;
         int client_mode = helper->csock.client_mode;
 
         if (client_mode) {
                 switch_sockaddr_t *sa = NULL;
                 switch_msrp_msg_t *setup_msg = switch_msrp_msg_create();
                 const char *remote_ip = NULL;
                 switch_port_t remote_port = 0;
                 char *dup = NULL;
                 char *p = NULL;
 
                 switch_assert(setup_msg);
                 switch_assert(helper->msrp_session);
                 msrp_session = helper->msrp_session;
                 msrp_session->running = 1;
 
                 switch_assert(msrp_session->remote_path);
                 dup = switch_core_strdup(pool, msrp_session->remote_path);
                 switch_assert(dup);
 
                 p = (char *)switch_stristr("msrp://", dup);
 
                 if (p) {
                         p += 7;
                 } else {
                         p = (char *)switch_stristr("msrps://", dup);
 
                         if (p) p+= 8;
                 }
 
                 if (p) {
                         remote_ip = p;
 
                         p = (char *)switch_stristr(":", p);
 
                         if (p) {
                                 *p++ = '\0';
                                 remote_port = atoi(p);
                         }
                 }
 
                 if (!remote_ip || remote_port <= 0) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error get remote MSRP ip:port from path: [%s]\n", msrp_session->remote_path);
                 }
 
                 if (switch_sockaddr_info_get(&sa, remote_ip, SWITCH_UNSPEC, remote_port, 0, pool) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error!\n");
                         goto end;
                 }
 
                 if (switch_socket_create(&csock->sock, switch_sockaddr_get_family(sa),
                         SOCK_STREAM, SWITCH_PROTO_TCP, pool) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error!\n");
                         goto end;
                 }
 
                 switch_socket_opt_set(csock->sock, SWITCH_SO_KEEPALIVE, 1);
                 switch_socket_opt_set(csock->sock, SWITCH_SO_TCP_NODELAY, 1);
                 // switch_socket_opt_set(csock->sock, SWITCH_SO_NONBLOCK, TRUE);
                 switch_socket_opt_set(csock->sock, SWITCH_SO_TCP_KEEPIDLE, 30);
                 switch_socket_opt_set(csock->sock, SWITCH_SO_TCP_KEEPINTVL, 30);
                 switch_socket_timeout_set(csock->sock, 3000000); // abort connection 3 seconds than forever
 
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "MSRP %s Connecting to %s\n", msrp_session->call_id, msrp_session->remote_path);
 
                 if ((switch_socket_connect(csock->sock, sa)) != SWITCH_STATUS_SUCCESS) {
                         char errbuf[512] = {0};
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Socket Error: %s\n", switch_strerror(errno, errbuf, sizeof(errbuf)));
                         goto end;
                 }
 
                 switch_socket_timeout_set(csock->sock, -1);
 
                 if (msrp_session->secure) {
                         X509 *cert = NULL;
                         switch_os_socket_t sockdes = SWITCH_SOCK_INVALID;
                         int ret;
 
                         switch_os_sock_get(&sockdes, csock->sock);
                         switch_assert(sockdes != SWITCH_SOCK_INVALID);
 
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "MSRP setup TLS %s\n", msrp_session->call_id);
 
                         ssl = SSL_new(globals.ssl_client_ctx);
                         assert(ssl);
                         csock->ssl = ssl;
                         SSL_set_fd(ssl, sockdes);
 
                         if ((ret = SSL_connect(ssl)) != 1 ) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: Could not build a SSL session to: %s error=%d\n", msrp_session->remote_path, SSL_get_error(ssl, ret));
                                 goto end;
                         }
 
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Successfully enabled SSL/TLS session to: %s\n", msrp_session->remote_path);
 
                         cert = SSL_get_peer_certificate(ssl);
 
                         if (cert == NULL) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: Could not get a certificate from: %s\n", msrp_session->remote_path);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got SSL Cert from %s\n", msrp_session->remote_path);
 #if 0
                                 certname = X509_NAME_new();
                                 certname = X509_get_subject_name(cert);
 
                                 X509_NAME_print_ex(outbio, certname, 0, 0);
                                 BIO_printf(outbio, "\n");
 #endif
                         }
                 }
 
                 helper->msrp_session->csock = csock;
 
                 switch_msrp_msg_add_header(setup_msg, MSRP_H_CONTENT_TYPE, "text/plain");
 
                 if (SWITCH_STATUS_SUCCESS != switch_msrp_send(msrp_session, setup_msg)) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MSRP initial setup send error!\n");
                         switch_msrp_msg_destroy(&setup_msg);
                         goto end;
                 }
 
                 switch_msrp_msg_destroy(&setup_msg);
         } else { // server mode
                 switch_socket_opt_set(csock->sock, SWITCH_SO_TCP_NODELAY, TRUE);
                 // switch_socket_opt_set(csock->sock, SWITCH_SO_NONBLOCK, TRUE);
 
                 if (csock->secure) { // tls?
                         int secure_established = 0;
                         int sanity = 10;
                         switch_os_socket_t sockdes = SWITCH_SOCK_INVALID;
                         int code = 0;
 
                         if (globals.ssl_ready != 1) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SSL not ready\n");
                                 goto end;
                         }
 
                         switch_os_sock_get(&sockdes, csock->sock);
                         // switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "socket: %d\n", sockdes);
                         switch_assert(sockdes != SWITCH_SOCK_INVALID);
 
                         ssl = SSL_new(globals.ssl_ctx);
                         assert(ssl);
                         csock->ssl = ssl;
 
                         SSL_set_fd(ssl, sockdes);
 
                         do {
                                 code = SSL_accept(ssl);
 
                                 if (code == 1) {
                                         secure_established = 1;
                                         goto done;
                                 } else if (code == 0) {
                                         goto err;
                                 } else if (code < 0) {
                                         if (code == -1 && SSL_get_error(ssl, code) != SSL_ERROR_WANT_READ) {
                                                 goto err;
                                         }
                                 }
                         } while(sanity--);
 
                         err:
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SSL ERR code=%d error=%d\n", code, SSL_get_error(ssl, code));
                                 goto end;
 
                         done:
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "SSL established = %d\n", secure_established);
                 }
 
                 len = MSRP_BUFF_SIZE;
                 status = msrp_socket_recv(csock, buf, &len);
 
                 if (helper->debug) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "status:%d, len:%" SWITCH_SIZE_T_FMT "\n", status, len);
                 }
 
                 if (status == SWITCH_STATUS_SUCCESS) {
                         msrp_msg = msrp_parse_buffer(buf, len, NULL, pool);
                         switch_assert(msrp_msg);
                 } else {
                         goto end;
                 }
 
                 if (helper->debug) {
                         char *data = msrp_msg_serialize(msrp_msg);
 
                         if (data) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s\n", data);
                                 free(data);
                         }
                 }
 
                 if (msrp_msg->state == MSRP_ST_DONE && msrp_msg->method == MSRP_METHOD_SEND) {
                         msrp_reply(csock, msrp_msg);
                         if (msrp_check_success_report(msrp_msg)) {
                                 msrp_report(csock, msrp_msg, "200 OK");
                         }
                 } else if (msrp_msg->state == MSRP_ST_DONE && msrp_msg->method == MSRP_METHOD_AUTH) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MSRP_METHOD_AUTH\n");
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Parse initial message error!\n");
                         goto end;
                 }
 
                 if (msrp_find_uuid(uuid, switch_msrp_msg_get_header(msrp_msg, MSRP_H_TO_PATH)) != SWITCH_TRUE) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid MSRP to-path!\n");
                 }
 
                 {
                         switch_core_session_t *session = NULL;
 
                         while (sanity-- && !(session = switch_core_session_locate(uuid))) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "waiting for session\n");
                                 switch_yield(1000000);
                         }
 
                         if(!session) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "No such session %s\n", uuid);
                                 goto end;
                         }
 
                         msrp_session = switch_core_media_get_msrp_session(session);
                         switch_assert(msrp_session);
                         msrp_session->csock = csock;
                         msrp_session->running = 1;
 
                         switch_core_session_rwunlock(session);
                 }
         }
 
         len = MSRP_BUFF_SIZE;
         p = buf;
         last_p = buf;
         if (msrp_msg) switch_msrp_msg_destroy(&msrp_msg);
 
         while (msrp_socket_recv(csock, p, &len) == SWITCH_STATUS_SUCCESS) {
                 // switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "read bytes: %" SWITCH_SIZE_T_FMT "\n", len);
 
                 if (len == 0) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "read bytes: %" SWITCH_SIZE_T_FMT "\n", len);
                         continue;
                 }
 
                 if (helper->debug) dump_buffer(buf, (p - buf) + len, __LINE__, 0);
 
         again:
                 msrp_msg = msrp_parse_buffer(last_p, p - last_p + len, msrp_msg, pool);
 
                 switch_assert(msrp_msg);
 
                 if (msrp_msg->state == MSRP_ST_ERROR) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "msrp parse error!\n");
                         goto end;
                 }
 
                 if (helper->debug) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "state:%d, len:%" SWITCH_SIZE_T_FMT " payload_bytes:%" SWITCH_SIZE_T_FMT "\n", msrp_msg->state, len, msrp_msg->payload_bytes);
                 }
 
                 if (msrp_msg->state == MSRP_ST_DONE && msrp_msg->method == MSRP_METHOD_SEND) {
                         msrp_reply(csock, msrp_msg);
 
                         if (msrp_check_success_report(msrp_msg)) {
                                 msrp_report(csock, msrp_msg, "200 OK");
                         }
 
                         last_p = msrp_msg->last_p;
                         switch_msrp_session_push_msg(msrp_session, msrp_msg);
                         msrp_msg = NULL;
                 } else if (msrp_msg->state == MSRP_ST_DONE) { /* throw away */
                         last_p = msrp_msg->last_p;
                         switch_msrp_msg_destroy(&msrp_msg);
                 } else {
                         last_p = msrp_msg->last_p;
                 }
 
                 while (msrp_session && msrp_session->running && msrp_session->msrp_msg_count > msrp_session->msrp_msg_buffer_size) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s reading too fast, relax...\n", msrp_session->call_id);
                         switch_yield(100000);
                 }
 
                 if (p + len > last_p) { // unparsed msg in buffer
                         p += len;
                         len = MSRP_BUFF_SIZE - (p - buf);
 
                         if (!msrp_msg) {
                                 int rest_len = p - last_p;
 
                                 memmove(buf, last_p, rest_len);
                                 p = buf + rest_len;
                                 len = MSRP_BUFF_SIZE - rest_len;
                                 last_p = buf;
 
                                 if (rest_len > 10) { // might have a complete msg in buffer, try parse again
                                         len = 0;
                                         goto again;
                                 }
 
                                 continue;
                         }
 
                         if (p >= buf + MSRP_BUFF_SIZE) {
                                 switch_msrp_msg_t *new_msg;
 
                                 if (msrp_msg->state != MSRP_ST_WAIT_BODY || !msrp_msg->range_star) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "buffer overflow\n");
                                         /*todo, do a strstr in the whole buffer ?*/
                                         break;
                                 }
 
                                 switch_assert(p == buf + MSRP_BUFF_SIZE);
 
                                 /* buffer full*/
                                 msrp_msg->payload_bytes = 0;
                                 new_msg = switch_msrp_msg_dup(msrp_msg);
                                 switch_msrp_msg_set_payload(new_msg, last_p, p - last_p);
                                 new_msg->state = MSRP_ST_DONE;
                                 switch_msrp_session_push_msg(msrp_session, new_msg);
                                 new_msg = NULL;
 
                                 msrp_msg->accumulated_bytes += (p - last_p);
                                 p = buf;
                                 len = MSRP_BUFF_SIZE;
                                 last_p = buf;
                                 msrp_msg->last_p = buf;
                                 msrp_msg->byte_start = msrp_msg->byte_end = 0;
                                 msrp_msg->payload_bytes = 0;
 
                                 if (globals.debug) {
                                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "acc: %" SWITCH_SIZE_T_FMT "\n", msrp_msg->accumulated_bytes);
                                 }
                         }
                 } else { /* all buffer parsed */
                         p = buf;
                         len = MSRP_BUFF_SIZE;
                         last_p = buf;
                 }
                 if (!msrp_session->running) break;
         }
 
 end:
 
         if (msrp_session) {
                 switch_mutex_lock(msrp_session->mutex);
                 close_socket(&csock->sock);
                 switch_mutex_unlock(msrp_session->mutex);
         }
 
         if (!client_mode) switch_core_destroy_memory_pool(&pool);
 
         if (ssl) SSL_free(ssl);
 
         if (msrp_session) msrp_session->running = 0;
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP worker down %s\n", msrp_session ? msrp_session->call_id : "!");
 
         return NULL;
 }

◆ random_string()

void random_string	(	char *	buf,
		uint16_t	size
	)

Definition at line 1513 of file switch_msrp.c.

References switch_stun_random_string().

Referenced by switch_msrp_do_send().

 {
         switch_stun_random_string(buf, size, NULL);
 }

◆ SWITCH_DECLARE_GLOBAL_STRING_FUNC()

SWITCH_DECLARE_GLOBAL_STRING_FUNC	(	set_global_ip	,
		globals.	ip
	)

Referenced by msrp_init_ssl().

◆ 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_do_send()

static switch_status_t switch_msrp_do_send	(	switch_msrp_session_t *	ms,
		switch_msrp_msg_t *	msrp_msg,
		const char *	file,
		const char *	func,
		int	line
	)

static

Definition at line 1519 of file switch_msrp.c.

References buf, switch_msrp_session_s::call_id, switch_msrp_session_s::csock, dump_buffer(), globals, switch_msrp_session_s::local_path, MSRP_BUFF_SIZE, MSRP_H_CONTENT_TYPE, MSRP_H_FROM_PATH, MSRP_H_TO_PATH, msrp_socket_send(), MSRP_TRANS_ID_LEN, msrp_msg_s::payload, msrp_msg_s::payload_bytes, random_string(), switch_msrp_session_s::remote_path, SWITCH_CHANNEL_ID_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_msrp_msg_get_header(), SWITCH_SIZE_T_FMT, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_UUID_FORMATTED_LENGTH, switch_uuid_str(), and zstr.

Referenced by switch_msrp_perform_send().

 {
         char transaction_id[MSRP_TRANS_ID_LEN + 1] = { 0 };
         char buf[MSRP_BUFF_SIZE];
         char message_id[SWITCH_UUID_FORMATTED_LENGTH + 1] = { 0 };
         switch_size_t len;
         const char *msrp_h_to_path = switch_msrp_msg_get_header(msrp_msg, MSRP_H_TO_PATH);
         const char *msrp_h_from_path = switch_msrp_msg_get_header(msrp_msg, MSRP_H_FROM_PATH);
         const char *to_path = msrp_h_to_path ? msrp_h_to_path : ms->remote_path;
         const char *from_path = msrp_h_from_path ? msrp_h_from_path: ms->local_path;
         const char *content_type = switch_msrp_msg_get_header(msrp_msg, MSRP_H_CONTENT_TYPE);
 
         if (msrp_msg->payload_bytes == 2 && msrp_msg->payload && !strncmp(msrp_msg->payload, "\r\n", 2)) {
                 // discard \r\n appended in uuid_send_text
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (!from_path) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, ms->call_id, SWITCH_LOG_WARNING, "NO FROM PATH\n");
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (zstr(content_type)) {
                 content_type = "text/plain";
         }
 
         random_string(transaction_id, MSRP_TRANS_ID_LEN);
         switch_uuid_str(message_id, sizeof(message_id));
 
         sprintf(buf, "MSRP %s SEND\r\nTo-Path: %s\r\nFrom-Path: %s\r\n"
                 "Message-ID: %s\r\n"
                 "Byte-Range: 1-%" SWITCH_SIZE_T_FMT "/%" SWITCH_SIZE_T_FMT "\r\n"
                 "%s%s%s",
                 transaction_id,
                 to_path,
                 from_path,
                 message_id,
                 msrp_msg->payload ? msrp_msg->payload_bytes : 0,
                 msrp_msg->payload ? msrp_msg->payload_bytes : 0,
                 msrp_msg->payload ? "Content-Type: " : "",
                 msrp_msg->payload ? content_type : "",
                 msrp_msg->payload ? "\r\n\r\n" : "");
 
         len = strlen(buf);
 
         if (msrp_msg->payload) {
                 if (len + msrp_msg->payload_bytes >= MSRP_BUFF_SIZE) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, ms->call_id, SWITCH_LOG_ERROR, "payload too large! %" SWITCH_SIZE_T_FMT "\n", len + msrp_msg->payload_bytes);
                         return SWITCH_STATUS_FALSE;
                 }
                 memcpy(buf + len, msrp_msg->payload, msrp_msg->payload_bytes);
                 len += msrp_msg->payload_bytes;
                 sprintf(buf + len, "\r\n");
                 len += 2;
         }
 
         sprintf(buf + len, "-------%s$\r\n", transaction_id);
         len += (10 + strlen(transaction_id));
 
         if (globals.debug) dump_buffer(buf, len, __LINE__, 1);
 
         return ms->csock ? msrp_socket_send(ms->csock, buf, &len) : SWITCH_STATUS_FALSE;
 }

◆ 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 ** module_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_header_name()

char* switch_msrp_msg_header_name ( switch_msrp_header_type_t htype )

Definition at line 645 of file switch_msrp.c.

References HEADER_NAMES, and MSRP_H_UNKNOWN.

Referenced by switch_msrp_msg_add_header(), and switch_msrp_msg_get_header().

                                                                                    {
         if (htype > MSRP_H_UNKNOWN) htype = MSRP_H_UNKNOWN;
 
         return HEADER_NAMES[htype];
 }

◆ 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 *	msrp_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_session_push_msg()

switch_status_t switch_msrp_session_push_msg	(	switch_msrp_session_t *	ms,
		switch_msrp_msg_t *	msg
	)

Definition at line 426 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_STATUS_SUCCESS.

Referenced by msrp_worker().

 {
         switch_mutex_lock(ms->mutex);
 
         if (ms->last_msg == NULL) {
                 ms->last_msg = msg;
                 ms->msrp_msg = msg;
         } else {
                 ms->last_msg->next = msg;
                 ms->last_msg = msg;
         }
 
         ms->msrp_msg_count++;
 
         switch_mutex_unlock(ms->mutex);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ 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.

Referenced by switch_core_media_negotiate_sdp().

 {
         worker_helper_t *helper;
         switch_thread_t *thread;
         switch_threadattr_t *thd_attr = NULL;
 
         helper = switch_core_alloc(msrp_session->pool, sizeof(worker_helper_t));
 
         switch_assert(helper != NULL);
         helper->pool = msrp_session->pool;
         helper->debug = globals.debug;
         helper->csock.sock = NULL; // client mode
         helper->csock.secure = msrp_session->secure;
         helper->csock.client_mode = 1;
         helper->msrp_session = msrp_session;
 
         switch_threadattr_create(&thd_attr, helper->pool);
         switch_threadattr_detach_set(thd_attr, 1);
         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
         switch_thread_create(&thread, thd_attr, msrp_worker, helper, helper->pool);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP new worker client started! %s\n", msrp_session->call_id);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ SWITCH_STANDARD_API() [1/2]

SWITCH_STANDARD_API ( uuid_msrp_send_function )

Definition at line 1805 of file switch_msrp.c.

References MSRP_H_CONTENT_TYPE, switch_core_media_get_msrp_session(), switch_core_session_locate, switch_core_session_rwunlock(), switch_msrp_msg_add_header(), switch_msrp_msg_create(), switch_msrp_msg_destroy(), switch_msrp_msg_set_payload(), switch_msrp_send, switch_separate_string(), SWITCH_STATUS_SUCCESS, and zstr.

 {
         char *mycmd = NULL, *argv[3] = { 0 };
         int argc;
         switch_core_session_t *msession = NULL;
         switch_msrp_session_t *msrp_session = NULL;
         switch_msrp_msg_t *msrp_msg = NULL;
 
         if (zstr(cmd) || !(mycmd = strdup(cmd))) {
                 goto error;
         }
 
         argc = switch_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
 
         if (argc < 2 || !argv[0]) {
                 goto error;
         }
 
         if (!(msession = switch_core_session_locate(argv[0]))) {
                 stream->write_function(stream, "-ERR Usage: cannot locate session.\n");
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (!(msrp_session = switch_core_media_get_msrp_session(msession))) {
                 stream->write_function(stream, "-ERR No msrp_session.\n");
                 switch_core_session_rwunlock(msession);
                 return SWITCH_STATUS_SUCCESS;
         }
 
         msrp_msg = switch_msrp_msg_create();
         switch_msrp_msg_add_header(msrp_msg, MSRP_H_CONTENT_TYPE, "text/plain");
         switch_msrp_msg_set_payload(msrp_msg, argv[1], strlen(argv[1]));
         switch_msrp_send(msrp_session, msrp_msg);
         switch_msrp_msg_destroy(&msrp_msg);
         stream->write_function(stream, "+OK message sent\n");
         switch_core_session_rwunlock(msession);
         return SWITCH_STATUS_SUCCESS;
 
 error:
         stream->write_function(stream, "-ERR Usage: uuid_msrp_send <uuid> msg\n");
         return SWITCH_STATUS_SUCCESS;
 }

◆ SWITCH_STANDARD_API() [2/2]

SWITCH_STANDARD_API ( msrp_api_function )

Definition at line 1849 of file switch_msrp.c.

References globals, MSRP_SYNTAX, switch_msrp_destroy(), switch_msrp_init(), SWITCH_STATUS_SUCCESS, and zstr.

 {
         if (zstr(cmd)) {
                 stream->write_function(stream, "-ERR usage: " MSRP_SYNTAX "\n");
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (!strcmp(cmd, "debug on")) {
                 globals.debug = 1;
                 stream->write_function(stream, "+OK debug on\n");
         } else if(!strcmp(cmd, "debug off")) {
                 globals.debug = 0;
                 stream->write_function(stream, "+OK debug off\n");
         } else if(!strcmp(cmd, "restart")) {
                 switch_msrp_destroy();
                 switch_msrp_init();
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ SWITCH_STANDARD_APP() [1/2]

SWITCH_STANDARD_APP ( msrp_recv_file_function )

Definition at line 1676 of file switch_msrp.c.

References switch_directories::base_dir, CF_TEXT_PASSIVE, filename, msrp_msg_s::method, MSRP_H_MESSAGE_ID, MSRP_METHOD_SEND, switch_msrp_session_s::msrp_msg_count, msrp_msg_s::payload, msrp_msg_s::payload_bytes, pool, switch_channel_answer, switch_channel_clear_flag(), switch_channel_get_variable, SWITCH_CHANNEL_LOG, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_core_media_get_msrp_session(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_sprintf(), switch_file_close(), switch_file_open(), switch_file_write(), SWITCH_FOPEN_CREATE, SWITCH_FOPEN_TRUNCATE, SWITCH_FOPEN_WRITE, SWITCH_FPROT_OS_DEFAULT, SWITCH_GLOBAL_dirs, SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_msrp_msg_get_header(), switch_msrp_session_pop_msg(), SWITCH_PATH_SEPARATOR, switch_safe_free, SWITCH_SIZE_T_FMT, SWITCH_STATUS_SUCCESS, and zstr.

 {
         switch_msrp_session_t *msrp_session = NULL;
         switch_msrp_msg_t *msrp_msg = NULL;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_memory_pool_t *pool = switch_core_session_get_pool(session);
         switch_file_t *fd;
         const char *filename = data;
 
         switch_channel_set_flag(channel, CF_TEXT_PASSIVE);
         switch_channel_answer(channel);
 
         if (zstr(data)) {
                 filename = switch_channel_get_variable(channel, "sip_msrp_file_name");
 
                 if (zstr(filename)) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No file specified.\n");
                         return;
                 }
 
                 filename = switch_core_session_sprintf(session, "%s%s%s", SWITCH_GLOBAL_dirs.base_dir, SWITCH_PATH_SEPARATOR, filename);
         }
 
         if (!(msrp_session = switch_core_media_get_msrp_session(session))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Not a MSRP session!\n");
                 return;
         }
 
         if (switch_file_open(&fd, filename, SWITCH_FOPEN_WRITE | SWITCH_FOPEN_TRUNCATE | SWITCH_FOPEN_CREATE, SWITCH_FPROT_OS_DEFAULT, pool) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Open File %s\n", filename);
                 return;
         }
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "File [%s] Opened\n", filename);
 
         while (1) {
                 if ((msrp_msg = switch_msrp_session_pop_msg(msrp_session)) == NULL) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "MSRP message queue size: %d\n", (int)msrp_session->msrp_msg_count);
                         if (!switch_channel_ready(channel)) break;
                         continue;
                 }
 
                 if (msrp_msg->method == MSRP_METHOD_SEND) {
                         switch_size_t bytes = msrp_msg->payload_bytes;
                         const char *msg = switch_msrp_msg_get_header(msrp_msg, MSRP_H_MESSAGE_ID);
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "%s %" SWITCH_SIZE_T_FMT " bytes writing\n", msg, bytes);
                         switch_file_write(fd, msrp_msg->payload, &bytes);
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "%" SWITCH_SIZE_T_FMT " bytes written\n", bytes);
                         if (bytes != msrp_msg->payload_bytes) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "write failed, bytes lost!\n");
                         }
                 }
 
                 switch_safe_free(msrp_msg);
         }
 
         switch_file_close(fd);
         switch_channel_clear_flag(channel, CF_TEXT_PASSIVE);
 
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "File closed!\n");
 }

◆ SWITCH_STANDARD_APP() [2/2]

SWITCH_STANDARD_APP ( msrp_send_file_function )

Definition at line 1740 of file switch_msrp.c.

References buf, msrp_msg_s::byte_end, msrp_msg_s::byte_start, filename, MSRP_H_CONTENT_TYPE, msrp_msg_s::payload_bytes, pool, switch_msrp_session_s::running, SWITCH_CHANNEL_LOG, switch_channel_ready, switch_core_media_get_msrp_session(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_file_close(), switch_file_get_size(), switch_file_open(), switch_file_read(), SWITCH_FOPEN_READ, SWITCH_FPROT_OS_DEFAULT, SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_msrp_msg_add_header(), switch_msrp_msg_create(), switch_msrp_msg_destroy(), switch_msrp_msg_set_payload(), switch_msrp_send, SWITCH_SIZE_T_FMT, SWITCH_STATUS_SUCCESS, and switch_yield.

 {
         switch_msrp_session_t *msrp_session = NULL;
         switch_msrp_msg_t *msrp_msg = NULL;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_memory_pool_t *pool = switch_core_session_get_pool(session);
         switch_file_t *fd;
         const char *filename = data;
         switch_size_t len = 1024;
         char buf[1024];
         int sanity = 10;
 
         if (!(msrp_session = switch_core_media_get_msrp_session(session))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Not a msrp session!\n");
                 return;
         }
 
         if (switch_file_open(&fd, filename, SWITCH_FOPEN_READ, SWITCH_FPROT_OS_DEFAULT, pool) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Open File %s\n", filename);
                 return;
         }
 
         msrp_msg = switch_msrp_msg_create();
 
         switch_msrp_msg_add_header(msrp_msg, MSRP_H_CONTENT_TYPE, "text/plain");
 
         msrp_msg->payload_bytes = switch_file_get_size(fd);
         msrp_msg->byte_start = 1;
 
         while(sanity-- && !msrp_session->running) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Waiting MSRP socket ...\n");
                 switch_yield(1000000);
         }
 
         if (!msrp_session->running) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Waiting for MSRP socket timedout, exiting...\n");
                 goto end;
         }
 
         while (switch_file_read(fd, buf, &len) == SWITCH_STATUS_SUCCESS &&
                 switch_channel_ready(channel) && len > 0) {
 
                 msrp_msg->byte_end = msrp_msg->byte_start + len + 1;
                 switch_msrp_msg_set_payload(msrp_msg, buf, len);
 
                 /*TODO: send in chunk should ending in + but not $ after delimiter*/
                 switch_msrp_send(msrp_session, msrp_msg);
 
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "%" SWITCH_SIZE_T_FMT " bytes sent\n", len);
 
                 msrp_msg->byte_start += len;
         }
 
         sanity = 10;
 
         while(sanity-- && switch_channel_ready(channel)) {
                 switch_yield(1000000);
         }
 
 end:
         switch_file_close(fd);
         switch_msrp_msg_destroy(&msrp_msg);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "File [%s] sent, closed!\n", filename);
 }

Variable Documentation

◆ cert

char* cert

Definition at line 63 of file switch_msrp.c.

Referenced by do_dtls(), dtls_state_setup(), and msrp_worker().

◆ debug

int debug

Definition at line 57 of file switch_msrp.c.

Referenced by switch_ivr_delay_echo().

◆ globals

struct { ... } globals

Referenced by load_config(), msrp_deinit_ssl(), msrp_init_ssl(), msrp_listener(), msrp_parse_buffer(), msrp_parse_headers(), msrp_report(), msrp_socket_recv(), msrp_worker(), switch_msrp_destroy(), switch_msrp_do_send(), switch_msrp_init(), switch_msrp_listen_ip(), switch_msrp_perform_send(), switch_msrp_session_new(), switch_msrp_start_client(), and SWITCH_STANDARD_API().

◆ HEADER_NAMES

char* HEADER_NAMES[]

Initial value:

= {
        "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 628 of file switch_msrp.c.

Referenced by switch_msrp_msg_header_name().

◆ ip

char* ip

Definition at line 60 of file switch_msrp.c.

Referenced by check_ice(), handle_ice(), switch_check_network_list_ip_port_token(), switch_core_media_negotiate_sdp(), switch_core_media_receive_message(), switch_core_media_recover_session(), switch_core_media_set_udptl_image_sdp(), switch_media_type2str(), switch_parse_audio_col(), switch_stun_ip_lookup(), switch_stun_packet_attribute_add_binded_address(), switch_stun_packet_attribute_add_xor_binded_address(), switch_stun_packet_attribute_get_mapped_address(), switch_stun_packet_attribute_get_xor_mapped_address(), switch_stun_packet_parse(), and timesub().

◆ key

◆ message_buffer_size

int message_buffer_size

Definition at line 61 of file switch_msrp.c.

◆ msock

switch_msrp_socket_t msock

Definition at line 71 of file switch_msrp.c.

Referenced by msrp_listener().

◆ msock_ssl

switch_msrp_socket_t msock_ssl

Definition at line 72 of file switch_msrp.c.

◆ pool

switch_memory_pool_t* pool

Definition at line 58 of file switch_msrp.c.

Referenced by msrp_listener(), msrp_worker(), switch_msrp_init(), switch_msrp_session_new(), and SWITCH_STANDARD_APP().

◆ running

int running

Definition at line 56 of file switch_msrp.c.

◆ ssl_client_ctx

SSL_CTX* ssl_client_ctx

Definition at line 69 of file switch_msrp.c.

◆ ssl_client_method

const SSL_METHOD* ssl_client_method

Definition at line 68 of file switch_msrp.c.

◆ ssl_ctx

SSL_CTX* ssl_ctx

Definition at line 66 of file switch_msrp.c.

Referenced by switch_rtp_add_dtls().

◆ ssl_method

const SSL_METHOD* ssl_method

Definition at line 65 of file switch_msrp.c.

Referenced by switch_rtp_add_dtls().

◆ ssl_ready

int ssl_ready

Definition at line 67 of file switch_msrp.c.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ DEBUG_MSRP

◆ MSRP_BUFF_SIZE

◆ MSRP_SYNTAX

◆ MSRP_TRANS_ID_LEN

Typedef Documentation

◆ worker_helper_t

Function Documentation

◆ close_socket()

◆ dump_buffer()

◆ find_delim()

◆ load_config()

◆ msock_init()

◆ msrp_check_success_report()

◆ msrp_deinit_ssl()

◆ msrp_find_uuid()

◆ msrp_init_ssl()

◆ msrp_listener()

◆ msrp_msg_serialize()

◆ msrp_parse_buffer()

◆ msrp_parse_header()

◆ msrp_parse_headers()

◆ msrp_reply()

◆ msrp_report()

◆ msrp_socket_recv()

◆ msrp_socket_send()

◆ msrp_worker()

◆ random_string()

◆ SWITCH_DECLARE_GLOBAL_STRING_FUNC()

◆ switch_msrp_destroy()

◆ switch_msrp_do_send()

◆ switch_msrp_init()

◆ switch_msrp_listen_ip()

◆ switch_msrp_load_apis_and_applications()

◆ switch_msrp_msg_add_header()

◆ switch_msrp_msg_create()

◆ switch_msrp_msg_destroy()

◆ switch_msrp_msg_dup()

◆ switch_msrp_msg_get_header()

◆ switch_msrp_msg_header_name()

◆ switch_msrp_msg_set_payload()

◆ switch_msrp_perform_send()

◆ switch_msrp_session_destroy()

◆ switch_msrp_session_new()

◆ switch_msrp_session_pop_msg()

◆ switch_msrp_session_push_msg()

◆ switch_msrp_start_client()

◆ SWITCH_STANDARD_API() [1/2]

◆ SWITCH_STANDARD_API() [2/2]

◆ SWITCH_STANDARD_APP() [1/2]

◆ SWITCH_STANDARD_APP() [2/2]

Variable Documentation

◆ cert

◆ debug

◆ globals

◆ HEADER_NAMES

◆ ip

◆ key

◆ message_buffer_size

◆ msock

◆ msock_ssl

◆ pool

◆ running

◆ ssl_client_ctx

◆ ssl_client_method

◆ ssl_ctx

◆ ssl_method

◆ ssl_ready