/* 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);
}
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;
}
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);
}
/**@ingroup thttp_message_group
*/
int thttp_message_add_header(thttp_message_t *self, const thttp_header_t *hdr)
{
#define ADD_HEADER(type, field) \
case thttp_htype_##type: \
{ \
if(!self->field) \
{ \
self->field = (thttp_header_##type##_t*)header; \
return 0; \
} \
break; \
}
if(self && hdr)
{
thttp_header_t *header = tsk_object_ref((void*)hdr);
switch(header->type)
{
ADD_HEADER(Content_Type, Content_Type);
ADD_HEADER(Content_Length, Content_Length);
default: break;
}
tsk_list_push_back_data(self->headers, (void**)&header);
return 0;
}
return -1;
}
tnet_ice_candidate_t* tnet_ice_candidate_create(tnet_ice_cand_type_t type_e, tnet_socket_t* socket, tsk_bool_t is_ice_jingle, tsk_bool_t is_rtp, tsk_bool_t is_video, const char* ufrag, const char* pwd, const char *foundation)
{
tnet_ice_candidate_t* candidate;
if(!(candidate = tsk_object_new(&tnet_ice_candidate_def_s))){
TSK_DEBUG_ERROR("Failed to create candidate");
return tsk_null;
}
candidate->type_e = type_e;
candidate->socket = tsk_object_ref(socket);
candidate->local_pref = 0xFFFF;
candidate->is_ice_jingle = is_ice_jingle;
candidate->is_rtp = is_rtp;
candidate->is_video = is_video;
candidate->comp_id = is_rtp ? TNET_ICE_CANDIDATE_COMPID_RTP : TNET_ICE_CANDIDATE_COMPID_RTCP;
if(foundation){
memcpy(candidate->foundation, foundation, TSK_MIN(tsk_strlen(foundation), TNET_ICE_CANDIDATE_FOUND_SIZE_PREF));
}
else{
tnet_ice_utils_compute_foundation((char*)candidate->foundation, TSK_MIN(sizeof(candidate->foundation), TNET_ICE_CANDIDATE_FOUND_SIZE_PREF));
}
candidate->priority = tnet_ice_utils_get_priority(candidate->type_e, candidate->local_pref, candidate->is_rtp);
if(candidate->socket){
memcpy(candidate->connection_addr, candidate->socket->ip, sizeof(candidate->socket->ip));
candidate->port = candidate->socket->port;
candidate->transport_e = socket->type;
}
tnet_ice_candidate_set_credential(candidate, ufrag, pwd);
return candidate;
}
int trtp_rtcp_packet_add_packet(trtp_rtcp_packet_t* self, trtp_rtcp_packet_t* packet, tsk_bool_t front)
{
trtp_rtcp_packets_L_t* packets = tsk_null;
if(!self || !self->header || !packet){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
switch(self->header->type){
case trtp_rtcp_packet_type_rr: packets = ((trtp_rtcp_report_rr_t*)self)->packets; break;
case trtp_rtcp_packet_type_sr: packets = ((trtp_rtcp_report_sr_t*)self)->packets; break;
case trtp_rtcp_packet_type_bye: packets = ((trtp_rtcp_report_bye_t*)self)->packets; break;
default: TSK_DEBUG_ERROR("not valid operation for packet type %d", (int)self->header->type); return -2;
}
if(packets){
//tsk_size_t packet_size = trtp_rtcp_packet_get_size(packet);
packet = tsk_object_ref(packet);
// self->header->length_in_bytes += packet_size;
// self->header->length_in_words_minus1 = ((self->header->length_in_bytes >> 2) - 1) +
// ((self->header->length_in_bytes & 0x03) ? 1 : 0);
tsk_list_push_data(packets, (void**)&packet, !front);
}
return 0;
}
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;
}
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
}
struct tsip_transac_dst_s* tsip_transac_dst_dialog_create(tsip_dialog_t *dlg)
{
struct tsip_transac_dst_s* dst;
if((dst = tsip_transac_dst_create(tsip_transac_dst_type_dialog, TSIP_DIALOG_GET_STACK(dlg)))){
dst->dialog.dlg = tsk_object_ref(dlg);
}
return dst;
}
trtp_rtcp_packet_t* trtp_rtcp_packet_create(struct trtp_rtcp_header_s* header)
{
trtp_rtcp_packet_t* packet;
if((packet = tsk_object_new(trtp_rtcp_packet_def_t)) && header){
packet->header = tsk_object_ref(header);
}
return packet;
}
static struct tsip_transac_dst_s* tsip_transac_dst_create(tsip_transac_dst_type_t type, struct tsip_stack_s* stack)
{
struct tsip_transac_dst_s* dst = tsk_object_new(tsip_transac_dst_def_t);
if(dst){
dst->type = type;
dst->stack = tsk_object_ref(stack);
}
return dst;
}
int tnet_transport_set_natt_ctx(tnet_transport_handle_t *handle, struct tnet_nat_ctx_s* natt_ctx)
{
if (!handle) {
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
TSK_OBJECT_SAFE_FREE(((tnet_transport_t *)handle)->natt_ctx);
((tnet_transport_t *)handle)->natt_ctx = tsk_object_ref(natt_ctx);
return 0;
}
int tsip_transac_remove(const tsip_transac_t* self)
{
int ret;
tsip_transac_t* safe_copy;
safe_copy = (tsip_transac_t*)tsk_object_ref(TSK_OBJECT(self));
ret = tsip_transac_layer_remove(TSIP_TRANSAC_GET_STACK(self)->layer_transac, safe_copy);
tsk_object_unref(safe_copy);
return ret;
}
int tsip_dialog_invite_ice_save_action(tsip_dialog_invite_t * self, tsk_fsm_action_id action_id, const tsip_action_t* action, const tsip_message_t* message)
{
if(!self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
// There are good reasons to ref() the action and message before safe_free()
// /!\ do not change
self->ice.last_action_id = action_id;
action = tsk_object_ref((tsk_object_t*)action);
TSK_OBJECT_SAFE_FREE(self->ice.last_action);
self->ice.last_action = (tsip_action_t*)action;
message = tsk_object_ref((tsk_object_t*)message);
TSK_OBJECT_SAFE_FREE(self->ice.last_message);
self->ice.last_message = (tsip_message_t*)message;
return 0;
}
static int tsip_dialog_invite_ice_callback(const tnet_ice_event_t *e)
{
int ret = 0;
tsip_dialog_invite_t *dialog;
TSK_DEBUG_INFO("ICE callback: %s", e->phrase);
dialog = tsk_object_ref(TSK_OBJECT(e->userdata));
// Do not lock: caller is thread safe
switch(e->type){
case tnet_ice_event_type_gathering_completed:
case tnet_ice_event_type_conncheck_succeed:
case tnet_ice_event_type_conncheck_failed:
case tnet_ice_event_type_cancelled:
{
if(dialog->ice.last_action_id != tsk_fsm_state_none){
if(tsip_dialog_invite_ice_got_local_candidates(dialog)){
ret = tsip_dialog_fsm_act(TSIP_DIALOG(dialog), dialog->ice.last_action_id, dialog->ice.last_message, dialog->ice.last_action);
dialog->ice.last_action_id = tsk_fsm_state_none;
}
}
if(dialog->ice.start_smgr){
ret = tsip_dialog_invite_msession_start(dialog);
}
break;
}
// fatal errors which discard ICE process
case tnet_ice_event_type_gathering_host_candidates_failed:
case tnet_ice_event_type_gathering_reflexive_candidates_failed:
case tnet_ice_event_type_gathering_relay_candidates_failed:
{
if (dialog->ice.last_action_id != tsk_fsm_state_none) {
ret = tsip_dialog_fsm_act(TSIP_DIALOG(dialog), dialog->ice.last_action_id, dialog->ice.last_message, dialog->ice.last_action);
dialog->ice.last_action_id = tsk_fsm_state_none;
}
break;
}
// TURN session disconnected while we're in call
case tnet_ice_event_type_turn_connection_broken:
{
ret = tsip_dialog_fsm_act_2(TSIP_DIALOG(dialog), _fsm_action_oBYE);
break;
}
default: break;
}
TSK_OBJECT_SAFE_FREE(dialog);
return ret;
}
int tnet_ice_event_set_action(tnet_ice_event_t* self, struct tnet_ice_action_s* action)
{
if(!self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
self->type = tnet_ice_event_type_action;
TSK_OBJECT_SAFE_FREE(self->action);
if(action){
self->action = tsk_object_ref(action);
}
return 0;
}
trtp_rtp_packet_t* trtp_rtp_packet_create_2(const trtp_rtp_header_t* header)
{
trtp_rtp_packet_t* packet;
if(!header){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if((packet = tsk_object_new(trtp_rtp_packet_def_t))){
packet->header = tsk_object_ref(TSK_OBJECT(header));
}
return packet;
}
int tnet_transport_get_public_ip_n_port(const tnet_transport_handle_t *handle, tnet_fd_t fd, tnet_ip_t *ip, tnet_port_t *port)
{
tsk_bool_t stun_ok = tsk_false;
struct tnet_nat_ctx_s* natt_ctx;
const tnet_transport_t *transport = handle;
if(!transport){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if (TNET_SOCKET_TYPE_IS_DGRAM(transport->type) && (natt_ctx = tsk_object_ref(transport->natt_ctx))) {
tnet_stun_binding_id_t bind_id = kStunBindingInvalidId;
// if the socket is already monitored by the transport we should pause because both the transport and
// NAT binder will try to read from it
// Pause the soket
tnet_transport_pause_socket(transport, fd, tsk_true);
// Performs STUN binding
bind_id = tnet_nat_stun_bind(transport->natt_ctx, fd);
// Resume the socket
tnet_transport_pause_socket(transport, fd, tsk_false);
if (bind_id != kStunBindingInvalidId) {
char* public_ip = tsk_null;
if(tnet_nat_stun_get_reflexive_address(transport->natt_ctx, bind_id, &public_ip, port) == 0){
if(ip && public_ip){
tsk_size_t ip_len = tsk_strlen(public_ip);
memcpy(ip, public_ip, ip_len> sizeof(*ip)?sizeof(*ip):ip_len);
}
stun_ok = tsk_true;
}
TSK_FREE(public_ip);
tnet_nat_stun_unbind(transport->natt_ctx, bind_id);
}
tsk_object_unref(natt_ctx);
}
if(!stun_ok){
if(fd == TNET_INVALID_FD && transport->local_ip){
memcpy(*ip, transport->local_ip, TSK_MIN(sizeof(tnet_ip_t), tsk_strlen(transport->local_ip)));
*port = transport->bind_local_port;
return 0;
}
else{
return tnet_transport_get_ip_n_port(handle, fd, ip, port);
}
}
return 0;
}
tmsrp_event_t* tmsrp_event_create(const void* callback_data, tsk_bool_t outgoing, tmsrp_event_type_t type, tmsrp_message_t* message)
{
tmsrp_event_t* _event;
if((_event = tsk_object_new(tmsrp_event_def_t))){
_event->callback_data = callback_data;
_event->outgoing = outgoing;
_event->type = type;
_event->message = tsk_object_ref(message);
}
else{
TSK_DEBUG_ERROR("Faile to create new MSRP event");
}
return _event;
}
int tsip_transac_fsm_act(tsip_transac_t* self, tsk_fsm_action_id action_id, const tsip_message_t* message)
{
int ret;
tsip_transac_t* safe_copy;
if(!self || !self->fsm){
TSK_DEBUG_WARN("Invalid parameter.");
return -1;
}
safe_copy = tsk_object_ref(TSK_OBJECT(self));
ret = tsk_fsm_act(self->fsm, action_id, safe_copy, message, self, message);
tsk_object_unref(safe_copy);
return ret;
}
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;
}
/**@ingroup tmedia_codec_group
* Finds a codec by format. If the codec has a dyn. payload type, then this function will also compare negociate formats.
* @param codecs List of codecs from which to retrieve the matching codec.
* @param format the format of the codec to find.
* @retval Zero if succeed and non-zero error code otherwise.
*/
tmedia_codec_t* tmedia_codec_find_by_format(tmedia_codecs_L_t* codecs, const char* format)
{
const tmedia_codec_t* codec = tsk_null;
if(!codecs || !format) {
TSK_DEBUG_ERROR("Inalid parameter");
return tsk_null;
}
if((codec = tsk_list_find_object_by_pred(codecs, __pred_find_codec_by_format, format)) ||
(codec = tsk_list_find_object_by_pred(codecs, __pred_find_codec_by_neg_format, format))) {
return tsk_object_ref((void*)codec);
}
else {
return tsk_null;
}
}
tmedia_param_t* tmedia_param_create(tmedia_param_access_type_t access_type,
tmedia_type_t media_type,
tmedia_param_plugin_type_t plugin_type,
tmedia_param_value_type_t value_type,
const char* key,
void* value)
{
tmedia_param_t* param;
if(!key ||!value){
TSK_DEBUG_ERROR("Invalid parameter");
return tsk_null;
}
if((param = tsk_object_new(tmedia_param_def_t))){
param->access_type = access_type;
param->media_type = media_type;
param->plugin_type = plugin_type;
param->value_type = value_type;
param->key = tsk_strdup(key);
switch(value_type){
case tmedia_pvt_int32:
if(param->value = tsk_calloc(1, sizeof(int32_t))){
memcpy(param->value, value, sizeof(int32_t));
//*((int32_t*)param->value) = *((int32_t*)value);
}
break;
case tmedia_pvt_pobject:
param->value = tsk_object_ref(value);
break;
case tmedia_pvt_pchar:
param->value = tsk_strdup(value);
break;
case tmedia_pvt_int64:
if(param->value = tsk_calloc(1, sizeof(int64_t))){
memcpy(param->value, value, sizeof(int64_t));
//*((int64_t*)param->value) = *((int64_t*)value);
}
break;
}
}
else{
TSK_DEBUG_ERROR("Failed to create media parameter");
}
return param;
}
/**
* Finds an AUID by id (case-insensitive).
* @param auids List of AUIDs from which to find the AUID.
* @param id The @a id of the AUID to find.
* @retval An AUID with the matching id or null if does not exist.
* It's up to you to free the returned object.
*/
txcap_auid_t* txcap_auid_get_by_id(txcap_auids_L_t* auids, const char* id)
{
//const txcap_auid_t* ret = tsk_null;
const tsk_list_item_t* item;
if(!auids){
return tsk_null;
}
if((item = tsk_list_find_item_by_pred(auids, pred_find_auid_by_id, id))){
return tsk_object_ref((void*)item->data);
}
else{
return tsk_null;
}
}
/*== Add new socket ==*/
static int addSocket(tnet_fd_t fd, tnet_socket_type_t type, tnet_transport_t *transport, tsk_bool_t take_ownership, tsk_bool_t is_client, tnet_tls_socket_handle_t* tlsHandle)
{
transport_context_t *context;
if (TNET_SOCKET_TYPE_IS_TLS(type) || TNET_SOCKET_TYPE_IS_WSS(type)) {
#if !HAVE_OPENSSL
TSK_DEBUG_ERROR("Cannot create TLS socket: OpenSSL missing");
return -2;
#endif
}
if ((context = transport ? transport->context : tsk_null)) {
transport_socket_xt *sock = tsk_calloc(1, sizeof(transport_socket_xt));
sock->fd = fd;
sock->type = type;
sock->owner = take_ownership ? 1 : 0;
if ((TNET_SOCKET_TYPE_IS_TLS(sock->type) || TNET_SOCKET_TYPE_IS_WSS(sock->type)) && transport->tls.enabled) {
if (tlsHandle) {
sock->tlshandle = tsk_object_ref(tlsHandle);
}
else {
#if HAVE_OPENSSL
sock->tlshandle = tnet_tls_socket_create(sock->fd, is_client ? transport->tls.ctx_client : transport->tls.ctx_server);
#endif
}
}
tsk_safeobj_lock(context);
context->events[context->count] = WSACreateEvent();
context->sockets[context->count] = sock;
context->count++;
TSK_DEBUG_INFO("Transport[%s] sockets count = %u", transport->description, context->count);
tsk_safeobj_unlock(context);
return 0;
}
else {
TSK_DEBUG_ERROR("Context is Null.");
return -1;
}
}
tmsrp_request_t* tmsrp_create_report(const tmsrp_request_t* SEND, short status, const char* reason)
{
/* RFC 4975 - 7.1.2. Sending REPORT Requests
* REPORT requests are similar to SEND requests, except that report
* requests MUST NOT include Success-Report or Failure-Report header
* fields, and MUST contain a Status header field. REPORT requests MUST
* contain the Message-ID header field from the original SEND request.
*/
tmsrp_request_t* REPORT = tsk_null;
tsk_istr_t tid;
/* If an MSRP element receives a REPORT for a Message-ID it does not
recognize, it SHOULD silently ignore the REPORT.
*/
if(!SEND || !SEND->MessageID){
goto bail;
}
/* Generate new tid (Report has it's own tid) */
tsk_strrandom(&tid);
/* MSRP response will have the same tid ==> nothing to do */
if(!(REPORT = tmsrp_request_create(tid, "REPORT"))){
goto bail;
}
/* reverse To-Path and From-Path */
REPORT->To = (tmsrp_header_To_Path_t*)tmsrp_header_From_Path_clone(SEND->From);
TMSRP_HEADER(REPORT->To)->type = tmsrp_htype_To_Path; /* as it's a clone we shall change type */
REPORT->From = (tmsrp_header_From_Path_t*)tmsrp_header_To_Path_clone(SEND->To);
TMSRP_HEADER(REPORT->From)->type = tmsrp_htype_From_Path; /* as it's a clone we shall change type */
/* Byte-Range */
REPORT->ByteRange = tsk_object_ref((void*)SEND->ByteRange);
/* Message ID */
/* Status */
tmsrp_message_add_headers(REPORT,
TMSRP_HEADER_MESSAGE_ID_VA_ARGS(SEND->MessageID->value),
TMSRP_HEADER_STATUS_VA_ARGS(TMSR_DEFAULT_NAMESPACE, status, reason),
tsk_null);
bail:
return REPORT;
}
/**@ingroup tsk_list_group
* Add all items in @a src into @a dest. Each item will have its reference counter incremented before being added.
* @param dest The destination list.
* @param src The source list.
* @param back Indicates whether to put the list back or not.
* @return 0 if succeed and non-zero error code otherwise.
**/
int tsk_list_push_list(tsk_list_t* dest, const tsk_list_t* src, tsk_bool_t back)
{
const tsk_list_item_t* curr = (src)->head;
tsk_object_t* copy;
if(!dest || !src){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
while(curr){
copy = tsk_object_ref(curr->data);
tsk_list_push_data(dest, (void**)©, back);
curr = curr->next;
}
return 0;
}
int tsip_transac_init(tsip_transac_t *self, tsip_transac_type_t type, int32_t cseq_value, const char* cseq_method, const char* callid, struct tsip_transac_dst_s* dst, tsk_fsm_state_id curr, tsk_fsm_state_id term)
{
if(self && !self->initialized){
self->type = type;
self->cseq_value = cseq_value;
tsk_strupdate(&self->cseq_method, cseq_method);
tsk_strupdate(&self->callid, callid);
self->dst = tsk_object_ref(dst);
/* FSM */
self->fsm = tsk_fsm_create(curr, term);
self->initialized = tsk_true;
return 0;
}
return -1;
}
int tdav_msrp_event_proxy_cb(tmsrp_event_t* _event/*!Not the owner of the object*/)
{
tdav_session_msrp_t* msrp;
int ret = 0;
if(!_event || !_event->callback_data){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
msrp = tsk_object_ref((void*)_event->callback_data);
if(TMEDIA_SESSION_MSRP(msrp)->callback.func){
_event->callback_data = TMEDIA_SESSION_MSRP(msrp)->callback.data; // steal callback data
ret = TMEDIA_SESSION_MSRP(msrp)->callback.func(_event); // call callback function()
}
tsk_object_unref(msrp);
return ret;
}
int tsip_transac_init(tsip_transac_t *self, tsip_transac_type_t type, tsk_bool_t reliable, int32_t cseq_value, const char* cseq_method, const char* callid, tsip_dialog_t* dialog, tsk_fsm_state_id curr, tsk_fsm_state_id term)
{
if(self && !self->initialized){
self->type = type;
self->reliable = reliable;
self->cseq_value = cseq_value;
self->cseq_method = tsk_strdup(cseq_method);
self->callid = tsk_strdup(callid);
self->dialog = tsk_object_ref(dialog);
/* FSM */
self->fsm = tsk_fsm_create(curr, term);
self->initialized = tsk_true;
return 0;
}
return -1;
}
