kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

retool RTP API and downgrade previous constructor to back-compat convience function 

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@1069 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale 2006-04-06 20:56:29 +00:00
parent 0af60e1b2f
commit a203f3138e
5 changed files with 128 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
src/include/switch_rtp.h
View File

@ -70,10 +70,26 @@ SWITCH_DECLARE(void) switch_rtp_init(switch_memory_pool *pool);
SWITCH_DECLARE(switch_port_t) switch_rtp_request_port(void);
/*!
\brief prepare a new RTP session handle
\param rx_ip the local address
\brief create a new RTP session handle
\param new_rtp_session a poiter to aim at the new session
\param payload the IANA payload number
\param flags flags to control behaviour
\param err a pointer to resolve error messages
\param pool a memory pool to use for the session
\return the new RTP session or NULL on failure
*/
SWITCH_DECLARE(switch_status)switch_rtp_create(switch_rtp **new_rtp_session,
int payload,
switch_rtp_flag_t flags,
const char **err,
switch_memory_pool *pool);
/*!
\brief prepare a new RTP session handle and fully initilize it
\param rx_host the local address
\param rx_port the local port
\param tx_ip the remote address
\param tx_host the remote address
\param tx_port the remote port
\param payload the IANA payload number
\param flags flags to control behaviour
@ -81,14 +97,35 @@ SWITCH_DECLARE(switch_port_t) switch_rtp_request_port(void);
\param pool a memory pool to use for the session
\return the new RTP session or NULL on failure
*/
SWITCH_DECLARE(switch_rtp *)switch_rtp_new(char *rx_ip,
SWITCH_DECLARE(switch_rtp *)switch_rtp_new(char *rx_host,
switch_port_t rx_port,
char *tx_ip,
char *tx_host,
switch_port_t tx_port,
int payload,
switch_rtp_flag_t flags,
const char **err,
switch_memory_pool *pool);
/*!
\brief Assign a remote address to the RTP session
\param rtp_session an RTP session to assign the remote address to
\param host the ip or fqhn of the remote address
\param port the remote port
\param err pointer for error messages
*/
SWITCH_DECLARE(switch_status) switch_rtp_set_remote_address(switch_rtp *rtp_session, char *host, switch_port_t port, const char **err);
/*!
\brief Assign a local address to the RTP session
\param rtp_session an RTP session to assign the local address to
\param host the ip or fqhn of the local address
\param port the local port
\param err pointer for error messages
\note this call also binds the RTP session's socket to the new address
*/
SWITCH_DECLARE(switch_status) switch_rtp_set_local_address(switch_rtp *rtp_session, char *host, switch_port_t port, const char **err);
/*!
\brief Kill the socket on an existing RTP session
\param rtp_session an RTP session to kill the socket of
@ -114,13 +151,6 @@ SWITCH_DECLARE(switch_status) switch_rtp_activate_ice(switch_rtp *rtp_session, c
*/
SWITCH_DECLARE(switch_socket_t *)switch_rtp_get_rtp_socket(switch_rtp *rtp_session);
/*!
\brief Activate a given RTP session
\param rtp_session the RTP session to activate
\return 0
*/
SWITCH_DECLARE(uint32_t) switch_rtp_start(switch_rtp *rtp_session);
/*!
\brief Set a callback function to execute when an invalid RTP packet is encountered
\param rtp_session the RTP session

2
src/include/switch_types.h
View File

@ -182,6 +182,7 @@ typedef enum {
SWITCH_STATUS_GENERR - A general Error
SWITCH_STATUS_INUSE - An indication that requested resource is in use
SWITCH_STATUS_BREAK - A non-fatal break of an operation
SWITCH_STATUS_SOCKERR - A socket error
</pre>
*/
typedef enum {
@ -197,6 +198,7 @@ typedef enum {
SWITCH_STATUS_GENERR,
SWITCH_STATUS_INUSE,
SWITCH_STATUS_BREAK,
SWITCH_STATUS_SOCKERR
} switch_status;
/*!

1
src/mod/endpoints/mod_dingaling/mod_dingaling.c
View File

@ -1278,7 +1278,6 @@ static ldl_status handle_signalling(ldl_handle_t *handle, ldl_session_t *dlsessi
}
switch_set_flag(tech_pvt, TFLAG_RTP_READY);
switch_rtp_activate_ice(tech_pvt->rtp_session, tech_pvt->remote_user, tech_pvt->local_user);
switch_rtp_start(tech_pvt->rtp_session);
}
return LDL_STATUS_SUCCESS;

1
src/mod/endpoints/mod_exosip/mod_exosip.c
View File

@ -480,7 +480,6 @@ static void activate_rtp(struct private_object *tech_pvt)
if (tech_pvt->rtp_session) {
tech_pvt->ssrc = switch_rtp_get_ssrc(tech_pvt->rtp_session);
switch_rtp_start(tech_pvt->rtp_session);
switch_set_flag(tech_pvt, TFLAG_RTP);
} else {
switch_channel *channel = switch_core_session_get_channel(tech_pvt->session);

110
src/switch_rtp.c
View File

@ -193,52 +193,65 @@ SWITCH_DECLARE(switch_port_t) switch_rtp_request_port(void)
return port;
}
SWITCH_DECLARE(switch_rtp *)switch_rtp_new(char *rx_ip,
switch_port_t rx_port,
char *tx_ip,
switch_port_t tx_port,
SWITCH_DECLARE(switch_status) switch_rtp_set_local_address(switch_rtp *rtp_session, char *host, switch_port_t port, const char **err)
{
*err = "Success";
if (switch_sockaddr_info_get(&rtp_session->local_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
*err = "Local Address Error!";
return SWITCH_STATUS_FALSE;
}
if (rtp_session->sock) {
switch_socket_close(rtp_session->sock);
rtp_session->sock = NULL;
}
if (switch_socket_create(&rtp_session->sock, AF_INET, SOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
*err = "Socket Error!";
return SWITCH_STATUS_SOCKERR;
}
if (switch_socket_bind(rtp_session->sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
*err = "Bind Error!";
return SWITCH_STATUS_FALSE;
}
switch_set_flag(rtp_session, SWITCH_RTP_FLAG_IO);
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(switch_status) switch_rtp_set_remote_address(switch_rtp *rtp_session, char *host, switch_port_t port, const char **err)
{
*err = "Success";
if (switch_sockaddr_info_get(&rtp_session->remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
*err = "Remote Address Error!";
return SWITCH_STATUS_FALSE;
}
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(switch_status) switch_rtp_create(switch_rtp **new_rtp_session,
int payload,
switch_rtp_flag_t flags,
const char **err,
switch_memory_pool *pool)
{
switch_socket_t *sock;
switch_rtp *rtp_session = NULL;
switch_sockaddr_t *rx_addr;
switch_sockaddr_t *tx_addr;
srtp_policy_t policy;
char key[MAX_KEY_LEN];
uint32_t ssrc = rand() & 0xffff;
if (switch_sockaddr_info_get(&rx_addr, rx_ip, SWITCH_UNSPEC, rx_port, 0, pool) != SWITCH_STATUS_SUCCESS) {
*err = "RX Address Error!";
return NULL;
}
if (switch_sockaddr_info_get(&tx_addr, tx_ip, SWITCH_UNSPEC, tx_port, 0, pool) != SWITCH_STATUS_SUCCESS) {
*err = "TX Address Error!";
return NULL;
}
if (switch_socket_create(&sock, AF_INET, SOCK_DGRAM, 0, pool) != SWITCH_STATUS_SUCCESS) {
*err = "Socket Error!";
return NULL;
}
if (switch_socket_bind(sock, rx_addr) != SWITCH_STATUS_SUCCESS) {
*err = "Bind Error!";
return NULL;
}
*new_rtp_session = NULL;
if (!(rtp_session = switch_core_alloc(pool, sizeof(*rtp_session)))) {
*err = "Memory Error!";
return NULL;
return SWITCH_STATUS_MEMERR;
}
rtp_session->sock = sock;
rtp_session->local_addr = rx_addr;
rtp_session->remote_addr = tx_addr;
rtp_session->pool = pool;
switch_sockaddr_info_get(&rtp_session->from_addr, NULL, SWITCH_UNSPEC, 0, 0, rtp_session->pool);
@ -288,9 +301,38 @@ SWITCH_DECLARE(switch_rtp *)switch_rtp_new(char *rx_ip,
srtp_create(&rtp_session->recv_ctx, &policy);
srtp_create(&rtp_session->send_ctx, &policy);
*new_rtp_session = rtp_session;
return SWITCH_STATUS_SUCCESS;
}
SWITCH_DECLARE(switch_rtp *)switch_rtp_new(char *rx_host,
switch_port_t rx_port,
char *tx_host,
switch_port_t tx_port,
int payload,
switch_rtp_flag_t flags,
const char **err,
switch_memory_pool *pool)
{
switch_rtp *rtp_session;
if (switch_rtp_create(&rtp_session, payload, flags, err, pool) != SWITCH_STATUS_SUCCESS) {
return NULL;
}
if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, err) != SWITCH_STATUS_SUCCESS) {
return NULL;
}
if (switch_rtp_set_local_address(rtp_session, rx_host, rx_port, err) != SWITCH_STATUS_SUCCESS) {
return NULL;
}
return rtp_session;
}
SWITCH_DECLARE(switch_status) switch_rtp_activate_ice(switch_rtp *rtp_session, char *login, char *rlogin)
{
char ice_user[80];
@ -461,12 +503,6 @@ SWITCH_DECLARE(int) switch_rtp_write_payload(switch_rtp *rtp_session, void *data
return (int)bytes;
}
SWITCH_DECLARE(uint32_t) switch_rtp_start(switch_rtp *rtp_session)
{
switch_set_flag(rtp_session, SWITCH_RTP_FLAG_IO);
return 0;
}
SWITCH_DECLARE(uint32_t) switch_rtp_get_ssrc(switch_rtp *rtp_session)
{
return rtp_session->send_msg.header.ssrc;