/**Resets the result.
*/
void _tcomp_result_reset(tcomp_result_t *result, tsk_bool_t isDestructor, tsk_bool_t isResetOutput)
{
if(result){
uint8_t i;
for(i = 0; i < result->statesToCreateIndex; i++){
TSK_OBJECT_SAFE_FREE(result->statesToCreate[i]);
}
for(i = 0; i < result->statesToFreeIndex; i++){
TSK_OBJECT_SAFE_FREE(result->statesToFree[i]);
}
if(!isDestructor){
result->statesToCreateIndex = 0;
result->statesToFreeIndex = 0;
result->consumed_cycles = 0;
tcomp_params_reset(result->remote_parameters);
if(isResetOutput){
tcomp_buffer_reset(result->output_buffer);
}
tcomp_reqfeed_reset(result->req_feedback);
tcomp_buffer_freeBuff(result->ret_feedback);
result->isNack = 0;
tcomp_buffer_freeBuff(result->nack_info);
}
}
else{
TSK_DEBUG_ERROR("NULL SigComp result.");
}
}
tnet_tls_socket_handle_t* tnet_tls_socket_create(tnet_fd_t fd, struct ssl_ctx_st* ssl_ctx)
{
#if !HAVE_OPENSSL
TSK_DEBUG_ERROR("OpenSSL not enabled");
return tsk_null;
#else
tnet_tls_socket_t* socket;
if(fd <= 0 || !ssl_ctx){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if((socket = tsk_object_new(tnet_tls_socket_def_t))){
socket->fd = fd;
if(!(socket->ssl = SSL_new(ssl_ctx))){
TSK_DEBUG_ERROR("SSL_new(CTX) failed [%s]", ERR_error_string(ERR_get_error(), tsk_null));
TSK_OBJECT_SAFE_FREE(socket);
return tsk_null;
}
if(SSL_set_fd(socket->ssl, socket->fd) != 1){
TSK_DEBUG_ERROR("SSL_set_fd(%d) failed [%s]", socket->fd, ERR_error_string(ERR_get_error(), tsk_null));
TSK_OBJECT_SAFE_FREE(socket);
return tsk_null;
}
}
return socket;
#endif
}
tnet_transport_t* tnet_transport_create(const char* host, tnet_port_t port, tnet_socket_type_t type, const char* description)
{
tnet_transport_t* transport;
if((transport = tsk_object_new(tnet_transport_def_t))){
transport->description = tsk_strdup(description);
transport->local_host = tsk_strdup(host);
transport->req_local_port = port;
transport->type = type;
transport->context = tnet_transport_context_create();
if((transport->master = tnet_socket_create(transport->local_host, transport->req_local_port, transport->type))){
transport->local_ip = tsk_strdup(transport->master->ip);
transport->bind_local_port = transport->master->port;
}
else{
TSK_DEBUG_ERROR("Failed to create master socket");
TSK_OBJECT_SAFE_FREE(transport);
}
if(_tnet_transport_ssl_init(transport) != 0){
TSK_DEBUG_ERROR("Failed to initialize TLS and/or DTLS caps");
TSK_OBJECT_SAFE_FREE(transport);
}
// set priority
tsk_runnable_set_priority(TSK_RUNNABLE(transport), TSK_THREAD_PRIORITY_TIME_CRITICAL);
}
return transport;
}
static tsk_object_t* tnet_transport_dtor(tsk_object_t * self)
{
tnet_transport_t *transport = self;
if (transport){
tnet_transport_set_callback(transport, tsk_null, tsk_null);
tnet_transport_shutdown(transport);
TSK_OBJECT_SAFE_FREE(transport->master);
TSK_OBJECT_SAFE_FREE(transport->context);
TSK_OBJECT_SAFE_FREE(transport->natt_ctx);
TSK_FREE(transport->local_ip);
TSK_FREE(transport->local_host);
// proxy
TSK_OBJECT_SAFE_FREE(transport->proxy.info);
// (tls and dtls) = ssl
TSK_FREE(transport->tls.ca);
TSK_FREE(transport->tls.pbk);
TSK_FREE(transport->tls.pvk);
_tnet_transport_ssl_deinit(transport); // openssl contexts
TSK_DEBUG_INFO("*** Transport (%s) destroyed ***", transport->description);
TSK_FREE(transport->description);
}
return self;
}
tnet_dtls_socket_handle_t* tnet_dtls_socket_create(struct tnet_socket_s* wrapped_sock, struct ssl_ctx_st* ssl_ctx)
{
#if !HAVE_OPENSSL || !HAVE_OPENSSL_DTLS
TSK_DEBUG_ERROR("OpenSSL or DTLS not enabled");
return tsk_null;
#else
tnet_dtls_socket_t* socket;
if (!wrapped_sock || !ssl_ctx){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if ((socket = tsk_object_new(tnet_dtls_socket_def_t))) {
const tsk_bool_t set_mtu = TNET_SOCKET_TYPE_IS_DGRAM(wrapped_sock->type) || 1; //!\ This is required even if the local transport is TCP/TLS because the relayed (TURN) transport could be UDP
socket->wrapped_sock = tsk_object_ref(wrapped_sock);
if (!(socket->ssl = SSL_new(ssl_ctx))) {
TSK_DEBUG_ERROR("SSL_new(CTX) failed [%s]", ERR_error_string(ERR_get_error(), tsk_null));
TSK_OBJECT_SAFE_FREE(socket);
return tsk_null;
}
if (set_mtu) {
SSL_set_options(socket->ssl, SSL_OP_NO_QUERY_MTU);
SSL_set_mtu(socket->ssl, TNET_DTLS_MTU - 28);
socket->ssl->d1->mtu = TNET_DTLS_MTU - 28;
}
if (!(socket->rbio = BIO_new(BIO_s_mem())) || !(socket->wbio = BIO_new(BIO_s_mem()))){
TSK_DEBUG_ERROR("BIO_new_socket(%d) failed [%s]", socket->wrapped_sock->fd, ERR_error_string(ERR_get_error(), tsk_null));
if (socket->rbio){
BIO_free(socket->rbio);
}
if (socket->wbio){
BIO_free(socket->wbio);
}
TSK_OBJECT_SAFE_FREE(socket);
return tsk_null;
}
BIO_set_mem_eof_return(socket->rbio, -1);
BIO_set_mem_eof_return(socket->wbio, -1);
SSL_set_bio(socket->ssl, socket->rbio, socket->wbio);
SSL_set_mode(socket->ssl, SSL_MODE_AUTO_RETRY);
SSL_set_read_ahead(socket->ssl, 1);
if (set_mtu) {
BIO_ctrl(SSL_get_wbio(socket->ssl), BIO_CTRL_DGRAM_SET_MTU, TNET_DTLS_MTU - 28, NULL);
}
if ((socket->verify_peer = (SSL_CTX_get_verify_mode(ssl_ctx) != SSL_VERIFY_NONE))){
TSK_DEBUG_INFO("SSL cert verify: ON");
socket->verify_peer = tsk_true;
SSL_set_verify(socket->ssl, (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT), _tnet_dtls_verify_cert);
}
else {
TSK_DEBUG_ERROR("Verity not enabled");
}
SSL_set_app_data(socket->ssl, socket);
}
return socket;
#endif
}
static void* tsdp_ctx_destroy(void * self)
{
tsdp_ctx_t *ctx = self;
if(ctx){
TSK_OBJECT_SAFE_FREE(ctx->local);
TSK_OBJECT_SAFE_FREE(ctx->remote);
TSK_OBJECT_SAFE_FREE(ctx->negotiated);
}
return self;
}
static tsk_object_t* tsms_tpdu_deliver_dtor(tsk_object_t * self)
{
tsms_tpdu_deliver_t *deliver = self;
if(deliver){
/*deinit base*/
tsms_tpdu_message_deinit(TSMS_TPDU_MESSAGE(deliver));
/*deinit self*/
TSK_OBJECT_SAFE_FREE(deliver->oa);
TSK_OBJECT_SAFE_FREE(deliver->smsc);
}
return self;
}
static tsk_object_t* thttp_action_dtor(tsk_object_t * self)
{
thttp_action_t *action = self;
if(action){
TSK_FREE(action->url);
TSK_FREE(action->method);
TSK_OBJECT_SAFE_FREE(action->options);
TSK_OBJECT_SAFE_FREE(action->headers);
TSK_OBJECT_SAFE_FREE(action->payload);
}
return self;
}
static void* tmsrp_receiver_dtor(tsk_object_t * self)
{
tmsrp_receiver_t *receiver = self;
if(receiver){
/* Stop */
tmsrp_receiver_stop(receiver);
TSK_OBJECT_SAFE_FREE(receiver->config);
TSK_OBJECT_SAFE_FREE(receiver->data_in);
TSK_OBJECT_SAFE_FREE(receiver->buffer);
// the FD is owned by the transport ...do not close it
}
return self;
}
int tnet_transport_unprepare(tnet_transport_t *transport)
{
int ret = -1;
transport_context_t *context;
if (!transport || !transport->context) {
TSK_DEBUG_ERROR("Invalid parameter.");
return -1;
}
else {
context = transport->context;
}
if (!transport->prepared) {
return 0;
}
transport->prepared = tsk_false;
while (context->count) {
removeSocket(0, context); // safe
}
// destroy master as it has been close by removeSocket()
TSK_OBJECT_SAFE_FREE(transport->master);
return 0;
}
static tsk_object_t* tnet_dtls_socket_dtor(tsk_object_t * self)
{
tnet_dtls_socket_t *socket = self;
if (socket){
#if HAVE_OPENSSL
if (socket->rbio) {
//BIO_free(socket->rbio);
socket->rbio = tsk_null;
}
if (socket->wbio) {
//BIO_free(socket->wbio);
socket->wbio = tsk_null;
}
if (socket->ssl) {
SSL_shutdown(socket->ssl);
// https://www.openssl.org/docs/crypto/BIO_s_bio.html
// implicitly frees internal_bio
SSL_free(socket->ssl);
}
#endif
TSK_FREE(socket->handshake_data.ptr);
TSK_OBJECT_SAFE_FREE(socket->wrapped_sock);
tsk_safeobj_deinit(socket);
TSK_DEBUG_INFO("*** tnet_dtls_socket_t destroyed ***");
}
return self;
}
tsk_buffer_t* tmsrp_data_out_get(tmsrp_data_out_t* self)
{
tsk_buffer_t* ret = tsk_null;
tsk_size_t toread;
if(!self){
return tsk_null;
}
if(!(toread = self->size > TMSRP_MAX_CHUNK_SIZE ? TMSRP_MAX_CHUNK_SIZE : self->size)){
return tsk_null;
}
if(self->message){
ret = tsk_buffer_create(TSK_BUFFER_DATA(self->message), toread);
tsk_buffer_remove(self->message, 0, toread);
self->size = self->message->size;
}
else if(self->file){
// Buffer hack
tsk_size_t read;
ret = tsk_buffer_create_null();
ret->data = tsk_calloc(toread, sizeof(uint8_t));
ret->size = toread;
if((read = fread(ret->data, sizeof(uint8_t), toread, self->file)) == toread){
self->size -= toread;
}
else{
TSK_OBJECT_SAFE_FREE(ret);
}
}
return ret;
}
void tdav_consumer_audio_set_jitterbuffer(tdav_consumer_audio_t* self, struct tmedia_jitterbuffer_s* jitterbuffer)
{
tsk_safeobj_lock(self);
TSK_OBJECT_SAFE_FREE(self->jitterbuffer);
self->jitterbuffer = (struct tmedia_jitterbuffer_s*)tsk_object_ref(jitterbuffer);
tsk_safeobj_unlock(self);
}
static tsk_object_t* tsip_action_dtor(tsk_object_t * self)
{
tsip_action_t *action = self;
if(action){
TSK_OBJECT_SAFE_FREE(action->headers);
TSK_OBJECT_SAFE_FREE(action->payload);
TSK_OBJECT_SAFE_FREE(action->media.params);
TSK_FREE(action->line_resp.phrase);
TSK_FREE(action->ect.to);
}
return self;
}
tsip_header_Authorization_t *tsip_header_Authorization_parse(const char *data, tsk_size_t size)
{
tsip_header_Authorization_t *hdr_sip = 0;
thttp_header_Authorization_t* hdr_http;
if((hdr_http = thttp_header_Authorization_parse(data, size))){
hdr_sip = tsip_header_Authorization_create();
hdr_sip->scheme = tsk_strdup(hdr_http->scheme);
hdr_sip->username = tsk_strdup(hdr_http->username);
hdr_sip->realm = tsk_strdup(hdr_http->realm);
hdr_sip->nonce = tsk_strdup(hdr_http->nonce);
hdr_sip->uri = tsk_strdup(hdr_http->uri);
hdr_sip->response = tsk_strdup(hdr_http->response);
hdr_sip->algorithm = tsk_strdup(hdr_http->algorithm);
hdr_sip->cnonce = tsk_strdup(hdr_http->cnonce);
hdr_sip->opaque = tsk_strdup(hdr_http->opaque);
hdr_sip->qop = tsk_strdup(hdr_http->qop);
hdr_sip->nc = tsk_strdup(hdr_http->nc);
TSIP_HEADER(hdr_sip)->params = tsk_object_ref(THTTP_HEADER(hdr_http)->params);
TSK_OBJECT_SAFE_FREE(hdr_http);
}
return hdr_sip;
}
static int _tnet_transport_ssl_init(tnet_transport_t* transport)
{
if(!transport){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
#if HAVE_OPENSSL
{
tnet_socket_type_t type = tnet_transport_get_type(transport);
tsk_bool_t is_tls = (TNET_SOCKET_TYPE_IS_TLS(type) || TNET_SOCKET_TYPE_IS_WSS(type));
tsk_bool_t is_dtls = TNET_SOCKET_TYPE_IS_DTLS(type);
if(is_dtls && !tnet_dtls_is_supported()){
TSK_DEBUG_ERROR("Requesting to create DTLS transport but source code not built with support for this feature");
return -1;
}
if(is_tls && !tnet_tls_is_supported()){
TSK_DEBUG_ERROR("Requesting to create TLS transport but source code not built with support for this feature");
return -1;
}
if((transport->tls.enabled = is_tls)){
if(!transport->tls.ctx_client && !(transport->tls.ctx_client = SSL_CTX_new(SSLv23_client_method()))){
TSK_DEBUG_ERROR("Failed to create SSL client context");
return -2;
}
if(!transport->tls.ctx_server && !(transport->tls.ctx_server = SSL_CTX_new(SSLv23_server_method()))){
TSK_DEBUG_ERROR("Failed to create SSL server context");
return -3;
}
SSL_CTX_set_mode(transport->tls.ctx_client, SSL_MODE_AUTO_RETRY);
SSL_CTX_set_mode(transport->tls.ctx_server, SSL_MODE_AUTO_RETRY);
SSL_CTX_set_verify(transport->tls.ctx_server, SSL_VERIFY_NONE, tsk_null); // to be updated by tnet_transport_tls_set_certs()
SSL_CTX_set_verify(transport->tls.ctx_client, SSL_VERIFY_NONE, tsk_null); // to be updated by tnet_transport_tls_set_certs()
if(SSL_CTX_set_cipher_list(transport->tls.ctx_client, TNET_CIPHER_LIST) <= 0 || SSL_CTX_set_cipher_list(transport->tls.ctx_server, TNET_CIPHER_LIST) <= 0){
TSK_DEBUG_ERROR("SSL_CTX_set_cipher_list failed [%s]", ERR_error_string(ERR_get_error(), tsk_null));
return -4;
}
}
#if HAVE_OPENSSL_DTLS
if((transport->dtls.enabled = is_dtls)){
if(!transport->dtls.ctx && !(transport->dtls.ctx = SSL_CTX_new(DTLSv1_method()))){
TSK_DEBUG_ERROR("Failed to create DTLSv1 context");
TSK_OBJECT_SAFE_FREE(transport);
return -5;
}
SSL_CTX_set_read_ahead(transport->dtls.ctx, 1);
// SSL_CTX_set_options(transport->dtls.ctx, SSL_OP_ALL);
// SSL_CTX_set_mode(transport->dtls.ctx, SSL_MODE_AUTO_RETRY);
SSL_CTX_set_verify(transport->dtls.ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, tsk_null); // to be updated by tnet_transport_tls_set_certs()
if(SSL_CTX_set_cipher_list(transport->dtls.ctx, TNET_CIPHER_LIST) <= 0){
TSK_DEBUG_ERROR("SSL_CTX_set_cipher_list failed [%s]", ERR_error_string(ERR_get_error(), tsk_null));
return -6;
}
transport->dtls.activated = tsk_true;
}
#endif /* HAVE_OPENSSL_DTLS */
}
#endif /* HAVE_OPENSSL */
return 0;
}
int tmedia_session_dvideo_set_ro(tmedia_session_t* self, const tsdp_header_M_t* m)
{
tmedia_codecs_L_t* neg_codecs;
if((neg_codecs = tmedia_session_match_codec(self, m))){
/* update negociated codecs */
TSK_OBJECT_SAFE_FREE(self->neg_codecs);
self->neg_codecs = neg_codecs;
/* update remote offer */
TSK_OBJECT_SAFE_FREE(self->M.ro);
self->M.ro = tsk_object_ref((void*)m);
return 0;
}
return -1;
}
int tsip_api_publish_send_unpublish(const tsip_ssession_handle_t *ss, ...)
{
const tsip_ssession_t* _ss;
va_list ap;
tsip_action_t* action;
int ret = -1;
if(!(_ss = ss) || !_ss->stack){
TSK_DEBUG_ERROR("Invalid parameter.");
return ret;
}
/* Checks if the stack is running */
if(!TSK_RUNNABLE(_ss->stack)->running){
TSK_DEBUG_ERROR("Stack not running.");
return -2;
}
va_start(ap, ss);
if((action = _tsip_action_create(tsip_atype_unpublish, &ap))){
ret = tsip_ssession_handle(ss, action);
TSK_OBJECT_SAFE_FREE(action);
}
va_end(ap);
return 0;
}
int tsip_api_publish_send_publish(const tsip_ssession_handle_t *ss, ...)
{
const tsip_ssession_t* _ss;
va_list ap;
tsip_action_t* action;
tsip_dialog_t* dialog;
int ret = -1;
if(!(_ss = ss) || !_ss->stack){
TSK_DEBUG_ERROR("Invalid parameter.");
return ret;
}
/* Checks if the stack has been started */
if(!TSK_RUNNABLE(_ss->stack)->started){
TSK_DEBUG_ERROR("Stack not started.");
return -2;
}
va_start(ap, ss);
if((action = _tsip_action_create(tsip_atype_publish, &ap))){
if(!(dialog = tsip_dialog_layer_find_by_ss(_ss->stack->layer_dialog, ss))){
dialog = tsip_dialog_layer_new(_ss->stack->layer_dialog, tsip_dialog_PUBLISH, ss);
}
ret = tsip_dialog_fsm_act(dialog, action->type, tsk_null, action);
tsk_object_unref(dialog);
TSK_OBJECT_SAFE_FREE(action);
}
va_end(ap);
return ret;
}
/**@ingroup thttp_action_group
* Sends a custom HTTP/HTTPS request.
* @param session The @a session (or connection) to use.
* @param urlstring The Request-URI. If the url scheme is 'https', then the default port will be 443, otherwise the port value will be 80.
* @param method The method to use for the HTTP request (e.g. GET, PUT, DELETE, POST ...).
* @retval Zero if succeed and non-zero error code otherwise.
*
* @code
thttp_action_perform(session, "http://www.google.com", "GET"
// request-level parameters
THTTP_ACTION_SET_PARAM("timeout", "6000"),
// request-level headers
THTTP_ACTION_SET_HEADER("Pragma", "No-Cache"),
THTTP_ACTION_SET_HEADER("Connection", "Keep-Alive"),
// close parameters
THTTP_ACTION_SET_NULL());
* @endcode
* @sa @ref thttp_action_CONNECT<br>@ref thttp_action_DELETE<br>@ref thttp_action_GET<br>@ref thttp_action_HEAD<br>@ref thttp_action_OPTIONS<br>
* @ref thttp_action_PATCH<br>@ref thttp_action_POST<br>@ref thttp_action_PUT<br>@ref thttp_action_TRACE
*/
int thttp_action_perform(thttp_session_handle_t *session, const char* urlstring, const char* method, ...)
{
thttp_session_t* sess = session;
va_list ap;
thttp_action_t* action;
thttp_dialog_t* dialog;
int ret = -1;
if(!sess || !sess->stack || !urlstring || !method){
TSK_DEBUG_ERROR("Invalid parameter");
return ret;
}
va_start(ap, method);
if((action = thttp_action_create(thttp_atype_o_request, urlstring, method, &ap))){
if((dialog = thttp_dialog_new(sess))){
ret = thttp_dialog_fsm_act(dialog, action->type, tsk_null, action);
tsk_object_unref(dialog);
}
else{
TSK_DEBUG_ERROR("Failed to create new HTTP/HTTPS dialog.");
ret = -2;
}
TSK_OBJECT_SAFE_FREE(action);
}
va_end(ap);
return ret;
}
tnet_transport_t* tnet_transport_create_2(tnet_socket_t *master, const char* description)
{
tnet_transport_t* transport;
if(!master){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if((transport = tsk_object_new(tnet_transport_def_t))){
transport->description = tsk_strdup(description);
transport->local_host = tsk_strdup(master->ip);
transport->req_local_port = master->port;
transport->type = master->type;
transport->master = tsk_object_ref(master);
transport->local_ip = tsk_strdup(transport->master->ip);
transport->bind_local_port = transport->master->port;
transport->context = tnet_transport_context_create();
if(_tnet_transport_ssl_init(transport) != 0){
TSK_DEBUG_ERROR("Failed to initialize TLS and/or DTLS caps");
TSK_OBJECT_SAFE_FREE(transport);
}
// set priority
tsk_runnable_set_priority(TSK_RUNNABLE(transport), TSK_THREAD_PRIORITY_TIME_CRITICAL);
}
return transport;
}
tsip_ssession_id_t register_handle_cmd(cmd_type_t cmd, const opts_L_t* opts)
{
const session_t* session = tsk_null;
tsip_ssession_id_t id = TSIP_SSESSION_INVALID_ID;
if(!(session = session_handle_cmd(cmd, opts))){
goto bail;
}
else{
id = tsip_ssession_get_id(session->handle);
}
/* action config */
/* Execute command */
switch(cmd){
case cmd_register:
{ /* Send SIP REGISTER */
tsip_action_handle_t* action_config = action_get_config(opts);
tsip_api_register_send_register(session->handle,
TSIP_ACTION_SET_CONFIG(action_config),
/* Any other TSIP_ACTION_SET_*() macros */
TSIP_ACTION_SET_NULL());
TSK_OBJECT_SAFE_FREE(action_config);
break;
}
default:
/* already handled by session_handle_cmd() */
break;
}
bail:
return id;
}
/*
Enable or disable DTLS on the transport and all coresponding sockets
*@param handle The transport for which to enable or disable DTLS
*@param enabled Whether to enable or disable DTLS
*@param sockets List of all sockets for which to enable or disable DLS could be null. You should include the master socket in this list.
*@param sockets_count The number of sockets
*@return 0 if succeed, otherwise non-zero error code
*/
int tnet_transport_dtls_set_enabled(tnet_transport_handle_t *handle, tsk_bool_t enabled, struct tnet_socket_s** sockets, tsk_size_t sockets_count)
{
tnet_transport_t *transport = handle;
tnet_socket_type_t type;
int ret;
if(!transport){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
type = tnet_transport_get_type(transport);
if(!TNET_SOCKET_TYPE_IS_DTLS(type) && !TNET_SOCKET_TYPE_IS_UDP(type)){
TSK_DEBUG_ERROR("Trying to enable/disable DTLS on invalid transport type: %d", type);
return -3;
}
if(enabled & !tnet_dtls_is_supported()){
TSK_DEBUG_ERROR("Trying to enable DTLS but code source not built with this feature");
return -1;
}
if((transport->dtls.enabled = enabled)){
TNET_SOCKET_TYPE_SET_DTLS(transport->type);
if((ret = _tnet_transport_ssl_init(transport))){
return ret;
}
}
else{
TNET_SOCKET_TYPE_SET_UDP(transport->type);
ret = _tnet_transport_ssl_deinit(transport);
}
if(sockets && sockets_count){
tsk_size_t i;
for(i = 0; i < sockets_count; ++i){
if(!sockets[i]){
continue;
}
if(enabled){
if(!sockets[i]->dtlshandle){
if(!(sockets[i]->dtlshandle = tnet_dtls_socket_create(sockets[i]->fd, transport->dtls.ctx))){
return -4;
}
}
if(transport->dtls.use_srtp){
tnet_dtls_socket_use_srtp(sockets[i]->dtlshandle);
}
TNET_SOCKET_TYPE_SET_DTLS(sockets[i]->type);
tnet_dtls_socket_set_callback(sockets[i]->dtlshandle, transport, _tnet_transport_dtls_cb);
}
else{
TSK_OBJECT_SAFE_FREE(sockets[i]->dtlshandle);
TNET_SOCKET_TYPE_SET_UDP(sockets[i]->type);
}
}
}
return ret;
}
tsip_ssession_id_t publish_handle_cmd(cmd_type_t cmd, const opts_L_t* opts)
{
const session_t* session = tsk_null;
tsip_ssession_id_t id = TSIP_SSESSION_INVALID_ID;
if(!(session = session_handle_cmd(cmd, opts))){
goto bail;
}
else{
id = tsip_ssession_get_id(session->handle);
}
switch(cmd){
case cmd_publish:
{ /* Send SIP PUBLISH */
tsip_action_handle_t* action_config = action_get_config(opts);
tsip_action_PUBLISH(session->handle,
TSIP_ACTION_SET_CONFIG(action_config),
/* Any other TSIP_ACTION_SET_*() macros */
TSIP_ACTION_SET_NULL());
TSK_OBJECT_SAFE_FREE(action_config);
break;
}
default:
/* already handled by session_handle_cmd() */
break;
}
bail:
return id;
}
trtp_rtcp_packet_t* trtp_rtcp_packet_deserialize(const void* data, tsk_size_t size)
{
trtp_rtcp_packet_type_t type;
if(!data || size < TRTP_RTCP_HEADER_SIZE){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
type = (trtp_rtcp_packet_type_t)((const uint8_t*)data)[1];
switch(type){
case trtp_rtcp_packet_type_rr: return (trtp_rtcp_packet_t*)trtp_rtcp_report_rr_deserialize(data, size);
case trtp_rtcp_packet_type_sr: return (trtp_rtcp_packet_t*)trtp_rtcp_report_sr_deserialize(data, size);
case trtp_rtcp_packet_type_sdes: return (trtp_rtcp_packet_t*)trtp_rtcp_report_sdes_deserialize(data, size);
case trtp_rtcp_packet_type_bye: return (trtp_rtcp_packet_t*)trtp_rtcp_report_bye_deserialize(data, size);
case trtp_rtcp_packet_type_rtpfb: return (trtp_rtcp_packet_t*)trtp_rtcp_report_rtpfb_deserialize(data, size);
case trtp_rtcp_packet_type_psfb: return (trtp_rtcp_packet_t*)trtp_rtcp_report_psfb_deserialize(data, size);
default:
{
// returns abstract RTCP packet
trtp_rtcp_header_t* header;
TSK_DEBUG_ERROR("%d not recognized as valid RTCP packet type", (int)type);
if((header = trtp_rtcp_header_deserialize(data, size))){
trtp_rtcp_packet_t* packet = trtp_rtcp_packet_create(header);
TSK_OBJECT_SAFE_FREE(header);
return packet;
}
break;
}
}
return tsk_null;
}
/* set denioiser */
void tdav_consumer_audio_set_denoise(tdav_consumer_audio_t* self, struct tmedia_denoise_s* denoise)
{
tsk_safeobj_lock(self);
TSK_OBJECT_SAFE_FREE(self->denoise);
self->denoise = (struct tmedia_denoise_s*)tsk_object_ref(denoise);
tsk_safeobj_unlock(self);
}
/**@ingroup tnet_nat_group
* Creates new NAT context.
*/
struct tnet_nat_ctx_s* tnet_nat_context_create(tnet_socket_type_t socket_type, const char* pc_username, const char* pc_password)
{
extern const tsk_object_def_t *tnet_nat_context_def_t;
struct tnet_nat_ctx_s* p_ctx;
if (!(p_ctx = tsk_object_new(tnet_nat_context_def_t)) || !(p_ctx->stun_bindings = tsk_list_create())) {
TSK_OBJECT_SAFE_FREE(p_ctx);
TSK_DEBUG_ERROR("Failed to create NAT context");
return tsk_null;
}
p_ctx->socket_type = socket_type;
p_ctx->username = tsk_strdup(pc_username);
p_ctx->password = tsk_strdup(pc_password);
p_ctx->server_port = kStunPortDefaultTcpUdp;
/* 7.2.1. Sending over UDP
In fixed-line access links, a value of 500 ms is RECOMMENDED.
*/
p_ctx->RTO = kStunRTO;
/* 7.2.1. Sending over UDP
Rc SHOULD be configurable and SHOULD have a default of 7.
*/
p_ctx->Rc = kStunRC;
return p_ctx;
}
static const tsdp_header_M_t* tmedia_session_ghost_get_lo(tmedia_session_t* self)
{
tmedia_session_ghost_t* ghost;
ghost = (tmedia_session_ghost_t*)self;
if(self->M.lo){
return self->M.lo;
}
else if(!(self->M.lo = tsdp_header_M_create(ghost->media, 0, ghost->proto ? ghost->proto: "RTP/AVP"))){
TSK_DEBUG_ERROR("Failed to create lo");
return tsk_null;
}
// add format
if(!tsk_strnullORempty(ghost->first_format)){
tsk_string_t* fmt = tsk_string_create(ghost->first_format);
if(!self->M.lo->FMTs){
self->M.lo->FMTs = tsk_list_create();
}
tsk_list_push_back_data(self->M.lo->FMTs, (void**)&fmt);
TSK_OBJECT_SAFE_FREE(fmt);
}
return self->M.lo;
}
//=================================================================================================
// HTTP action object definition
//
static tsk_object_t* thttp_action_ctor(tsk_object_t * self, va_list * app)
{
thttp_action_t *action = self;
if(action){
va_list* app_2;
thttp_action_param_type_t curr;
action->type = va_arg(*app, thttp_action_type_t);
action->url = tsk_strdup(va_arg(*app, const char*));
action->method = tsk_strdup(va_arg(*app, const char*));
app_2 = va_arg(*app, va_list*);
action->options = tsk_list_create();
action->headers = tsk_list_create();
if(!app_2){ /* XCAP stack will pass null va_list */
goto bail;
}
while((curr = va_arg(*app_2, thttp_action_param_type_t)) != thttp_aptype_null){
switch(curr){
case thttp_aptype_option:
{ /* (thttp_action_option_t)ID_ENUM, (const char*)VALUE_STR */
thttp_action_option_t id = va_arg(*app_2, thttp_action_option_t);
const char* value = va_arg(*app_2, const char *);
tsk_options_add_option(&action->options, id, value);
break;
}
case thttp_aptype_header:
{ /* (const char*)NAME_STR, (const char*)VALUE_STR */
const char* name = va_arg(*app_2, const char *);
const char* value = va_arg(*app_2, const char *);
tsk_params_add_param(&action->headers, name, value);
break;
}
case thttp_aptype_payload:
{ /* (const void*)PAY_PTR, (tsk_size_t)PAY_SIZE */
const void* payload = va_arg(*app_2, const void *);
tsk_size_t size = va_arg(*app_2, tsk_size_t);
if(payload && size){
TSK_OBJECT_SAFE_FREE(action->payload);
action->payload = tsk_buffer_create(payload, size);
}
break;
}
default:
{ /* va_list will be unsafe ==> exit */
TSK_DEBUG_ERROR("NOT SUPPORTED.");
goto bail;
}
} /* switch */
} /* while */
}
bail:
return self;
}
int tsip_transac_deinit(tsip_transac_t *self)
{
if(self && self->initialized){
/* FSM */
TSK_OBJECT_SAFE_FREE(self->fsm);
TSK_FREE(self->branch);
TSK_FREE(self->cseq_method);
TSK_FREE(self->callid);
TSK_OBJECT_SAFE_FREE(self->dialog);
self->initialized = tsk_false;
return 0;
}
return -1;
}
