StarMirror/toxcore
1
0
Fork 0
mirror of https://github.com/irungentoo/toxcore.git synced 2024-03-22 13:30:51 +08:00
Code Issues Projects Releases Wiki Activity
e04fff3eac
toxcore/toxav/msi.c

1951 lines
52 KiB
C
Raw Blame History

/** toxmsi.c
*
* Copyright (C) 2013 Tox project All Rights Reserved.
*
* This file is part of Tox.
*
* Tox is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Tox is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Tox. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "../toxcore/logger.h"
#include "../toxcore/util.h"
#include "msi.h"
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#define same(x, y) strcmp((const char*) x, (const char*) y) == 0
#define MSI_MAXMSG_SIZE 1024
#define TYPE_REQUEST 1
#define TYPE_RESPONSE 2
unsigned char *VERSION_STRING = (unsigned char *)"0.3.1";
#define VERSION_STRLEN 5
#define CT_AUDIO_HEADER_VALUE "AUDIO"
#define CT_VIDEO_HEADER_VALUE "VIDEO"
/* Define default timeout for a request.
* There is no behavior specified by the msi on what will
* client do on timeout, but to call timeout callback.
*/
#define m_deftout 10000 /* in milliseconds */
/**
* Protocol:
*
* | desc. ( 1 byte ) | length ( 2 bytes ) | value ( length bytes ) |
*
* ie.
*
* | 0x1 | 0x0 0x7 | "version"
*
* Means: it's field value with length of 7 bytes and value of "version"
* It's similar to amp protocol
*/
#define GENERIC_HEADER(header) \
typedef struct _MSIHeader##header { \
uint8_t* header_value; \
uint16_t size; \
} MSIHeader##header;
GENERIC_HEADER ( Version )
GENERIC_HEADER ( Request )
GENERIC_HEADER ( Response )
GENERIC_HEADER ( CallType )
GENERIC_HEADER ( CallId )
GENERIC_HEADER ( Info )
GENERIC_HEADER ( Reason )
/**
* @brief This is the message structure. It contains all of the headers and
* destination/source of the message stored in friend_id.
*
*/
typedef struct _MSIMessage {
MSIHeaderVersion version;
MSIHeaderRequest request;
MSIHeaderResponse response;
MSIHeaderCallType calltype;
MSIHeaderInfo info;
MSIHeaderReason reason;
MSIHeaderCallId callid;
struct _MSIMessage *next;
int friend_id;
} MSIMessage;
static struct _Callbacks {
MSICallback function;
void *data;
} callbacks[11] = {{0}};
inline__ void invoke_callback(int32_t call_index, MSICallbackID id)
{
if ( callbacks[id].function ) {
LOGGER_DEBUG("Invoking callback function: %d", id);
callbacks[id].function ( call_index, callbacks[id].data );
}
}
/*static MSICallback callbacks[10] = {0};*/
/* define strings for the identifiers */
#define VERSION_FIELD "Version"
#define REQUEST_FIELD "Request"
#define RESPONSE_FIELD "Response"
#define INFO_FIELD "INFO"
#define REASON_FIELD "Reason"
#define CALLTYPE_FIELD "Call-type"
#define CALLID_FIELD "Call-id"
/* protocol descriptors */
#define end_byte 0x0
#define field_byte 0x1
#define value_byte 0x2
typedef enum {
invite,
start,
cancel,
reject,
end,
} MSIRequest;
/**
* @brief Get string value for request.
*
* @param request The request.
* @return const uint8_t* The string
*/
static inline__ const uint8_t *stringify_request ( MSIRequest request )
{
static const uint8_t *strings[] = {
( uint8_t *) "INVITE",
( uint8_t *) "START",
( uint8_t *) "CANCEL",
( uint8_t *) "REJECT",
( uint8_t *) "END"
};
return strings[request];
}
typedef enum {
ringing,
starting,
ending,
error
} MSIResponse;
/**
* @brief Get string value for response.
*
* @param response The response.
* @return const uint8_t* The string
*/
static inline__ const uint8_t *stringify_response ( MSIResponse response )
{
static const uint8_t *strings[] = {
( uint8_t *) "ringing",
( uint8_t *) "starting",
( uint8_t *) "ending",
( uint8_t *) "error"
};
return strings[response];
}
/**
* @brief Parse raw 'data' received from socket into MSIMessage struct.
* Every message has to have end value of 'end_byte' or _undefined_ behavior
* occures. The best practice is to check the end of the message at the handle_packet.
*
* @param msg Container.
* @param data The data.
* @return int
* @retval -1 Error occurred.
* @retval 0 Success.
*/
int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
{
#define ON_HEADER(iterator, size_con, header, descriptor, type_size_const) \
( memcmp(iterator, descriptor, type_size_const) == 0){ /* Okay */ \
iterator += type_size_const; /* Set iterator at begining of value part */ \
if ( *iterator != value_byte || size_con <= type_size_const) { return -1; } size_con -= type_size_const; \
iterator ++; if(size_con <= 3) {return -1;} size_con -= 3; \
uint16_t _value_size; memcpy(&_value_size, iterator, sizeof(_value_size)); _value_size = ntohs(_value_size);\
if(size_con < _value_size) { return -1; } size_con -= _value_size; \
if ( !(header.header_value = calloc(sizeof(uint8_t), _value_size)) ) \
LOGGER_ERROR("Allocation failed! Program might misbehave!"); \
header.size = _value_size; \
memcpy(header.header_value, iterator + 2, _value_size);\
iterator = iterator + 2 + _value_size; /* set iterator at new header or end_byte */ }
if ( msg == NULL ) {
LOGGER_ERROR("Could not parse message: no storage!");
return -1;
}
if ( data[length - 1] ) /* End byte must have value 0 */
return -1;
const uint8_t *_it = data;
uint16_t size_max = length;
while ( *_it ) {/* until end_byte is hit */
uint16_t itedlen = (_it - data) + 2;
if ( *_it == field_byte && itedlen < length ) {
uint16_t _size;
memcpy(&_size, _it + 1, sizeof(_size));
_size = ntohs(_size);
if ( itedlen + _size > length ) return -1;
_it += 3; /* place it at the field value beginning */
size_max -= 3;
switch ( _size ) { /* Compare the size of the hardcoded values ( very convenient ) */
case 4: { /* INFO header */
if ON_HEADER ( _it, size_max, msg->info, INFO_FIELD, 4 )
}
break;
case 6: { /* Reason header */
if ON_HEADER ( _it, size_max, msg->reason, REASON_FIELD, 6 )
}
break;
case 7: { /* Version, Request, Call-id headers */
if ON_HEADER ( _it, size_max, msg->version, VERSION_FIELD, 7 )
else if ON_HEADER ( _it, size_max, msg->request, REQUEST_FIELD, 7 )
else if ON_HEADER ( _it, size_max, msg->callid, CALLID_FIELD, 7 )
}
break;
case 8: { /* Response header */
if ON_HEADER ( _it, size_max, msg->response, RESPONSE_FIELD, 8 )
}
break;
case 9: { /* Call-type header */
if ON_HEADER ( _it, size_max, msg->calltype, CALLTYPE_FIELD, 9 )
}
break;
default:
LOGGER_ERROR("Unkown field value");
return -1;
}
} else {
LOGGER_ERROR("Invalid field byte or field size too large");
return -1;
}
/* If it's anything else return failure as the message is invalid */
}
return 0;
}
#define ALLOCATE_HEADER( var, mheader_value, t_size) \
if (!(var.header_value = calloc(sizeof *mheader_value, t_size))) \
{ LOGGER_WARNING("Header allocation failed! Program might misbehave!"); } \
else { memcpy(var.header_value, mheader_value, t_size); \
var.size = t_size; }
/**
* @brief Speaks for it self.
*
* @param msg The message.
* @return void
*/
void free_message ( MSIMessage *msg )
{
if ( msg == NULL ) {
LOGGER_WARNING("Tried to free empty message");
return;
}
free ( msg->calltype.header_value );
free ( msg->request.header_value );
free ( msg->response.header_value );
free ( msg->version.header_value );
free ( msg->info.header_value );
free ( msg->reason.header_value );
free ( msg->callid.header_value );
free ( msg );
}
/**
* @brief Create the message.
*
* @param type Request or response.
* @param type_id Type of request/response.
* @return MSIMessage* Created message.
* @retval NULL Error occurred.
*/
MSIMessage *msi_new_message ( uint8_t type, const uint8_t *type_id )
{
MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
if ( _retu == NULL ) {
LOGGER_WARNING("Allocation failed! Program might misbehave!");
return NULL;
}
if ( type == TYPE_REQUEST ) {
ALLOCATE_HEADER ( _retu->request, type_id, strlen ( (const char *)type_id ) )
} else if ( type == TYPE_RESPONSE ) {
ALLOCATE_HEADER ( _retu->response, type_id, strlen ( (const char *)type_id ) )
} else {
free_message ( _retu );
return NULL;
}
ALLOCATE_HEADER ( _retu->version, VERSION_STRING, strlen ( (const char *)VERSION_STRING ) )
return _retu;
}
/**
* @brief Parse data from handle_packet.
*
* @param data The data.
* @return MSIMessage* Parsed message.
* @retval NULL Error occurred.
*/
MSIMessage *parse_message ( const uint8_t *data, uint16_t length )
{
if ( data == NULL ) {
LOGGER_WARNING("Tried to parse empty message!");
return NULL;
}
MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
if ( _retu == NULL ) {
LOGGER_WARNING("Allocation failed! Program might misbehave!");
return NULL;
}
memset ( _retu, 0, sizeof ( MSIMessage ) );
if ( parse_raw_data ( _retu, data, length ) == -1 ) {
free_message ( _retu );
return NULL;
}
if ( !_retu->version.header_value || VERSION_STRLEN != _retu->version.size ||
memcmp ( _retu->version.header_value, VERSION_STRING, VERSION_STRLEN ) != 0 ) {
free_message ( _retu );
return NULL;
}
return _retu;
}
/**
* @brief Speaks for it self.
*
* @param dest Container.
* @param header_field Field.
* @param header_value Field value.
* @param value_len Length of field value.
* @param length Pointer to container length.
* @return uint8_t* Iterated container.
*/
uint8_t *append_header_to_string (
uint8_t *dest,
const uint8_t *header_field,
const uint8_t *header_value,
uint16_t value_len,
uint16_t *length )
{
if ( dest == NULL ) {
LOGGER_ERROR("No destination space!");
return NULL;
}
if (header_value == NULL) {
LOGGER_ERROR("Empty header value");
return NULL;
}
if ( header_field == NULL ) {
LOGGER_ERROR("Empty header field");
return NULL;
}
const uint8_t *_hvit = header_value;
uint16_t _total = 6 + value_len; /* 6 is known plus header value len + field len*/
*dest = field_byte; /* Set the first byte */
uint8_t *_getback_byte = dest + 1; /* remember the byte we were on */
dest += 3; /* swith to 4th byte where field value starts */
/* Now set the field value and calculate it's length */
uint16_t _i = 0;
for ( ; header_field[_i]; ++_i ) {
*dest = header_field[_i];
++dest;
};
_total += _i;
/* Now set the length of the field byte */
uint16_t _convert;
_convert = htons(_i);
memcpy(_getback_byte, &_convert, sizeof(_convert));
/* for value part do it regulary */
*dest = value_byte;
dest++;
_convert = htons(value_len);
memcpy(dest, &_convert, sizeof(_convert));
dest += 2;
for ( _i = value_len; _i; --_i ) {
*dest = *_hvit;
++_hvit;
++dest;
}
*length += _total;
return dest;
}
/**
* @brief Convert MSIMessage struct to _sendable_ string.
*
* @param msg The message.
* @param dest Destination.
* @return uint16_t It's final size.
*/
uint16_t message_to_send ( MSIMessage *msg, uint8_t *dest )
{
#define CLEAN_ASSIGN(added, var, field, header)\
if ( header.header_value ) { var = append_header_to_string(var, (const uint8_t*)field, header.header_value, header.size, &added); }
if (msg == NULL) {
LOGGER_ERROR("Empty message!");
return 0;
}
if (dest == NULL ) {
LOGGER_ERROR("Empty destination!");
return 0;
}
uint8_t *_iterated = dest;
uint16_t _size = 0;
CLEAN_ASSIGN ( _size, _iterated, VERSION_FIELD, msg->version );
CLEAN_ASSIGN ( _size, _iterated, REQUEST_FIELD, msg->request );
CLEAN_ASSIGN ( _size, _iterated, RESPONSE_FIELD, msg->response );
CLEAN_ASSIGN ( _size, _iterated, CALLTYPE_FIELD, msg->calltype );
CLEAN_ASSIGN ( _size, _iterated, INFO_FIELD, msg->info );
CLEAN_ASSIGN ( _size, _iterated, CALLID_FIELD, msg->callid );
CLEAN_ASSIGN ( _size, _iterated, REASON_FIELD, msg->reason );
*_iterated = end_byte;
_size ++;
return _size;
}
#define GENERIC_SETTER_DEFINITION(header) \
void msi_msg_set_##header ( MSIMessage* _msg, const uint8_t* header_value, uint16_t _size ) \
{ if ( !_msg || !header_value) { LOGGER_WARNING("No setter values!"); return; } \
free(_msg->header.header_value); \
ALLOCATE_HEADER( _msg->header, header_value, _size )}
GENERIC_SETTER_DEFINITION ( calltype )
GENERIC_SETTER_DEFINITION ( reason )
GENERIC_SETTER_DEFINITION ( info )
GENERIC_SETTER_DEFINITION ( callid )
typedef struct _Timer {
void *(*func)(void *);
void *func_arg1;
int func_arg2;
uint64_t timeout;
size_t idx;
} Timer;
typedef struct _TimerHandler {
Timer **timers;
pthread_mutex_t mutex;
size_t max_capacity;
size_t size;
uint64_t resolution;
_Bool running;
} TimerHandler;
struct timer_function_args {
void *arg1;
int arg2;
};
/**
* @brief Allocate timer in array
*
* @param timers_container Handler
* @param func Function to be executed
* @param arg Its args
* @param timeout Timeout in ms
* @return int
*/
int timer_alloc ( TimerHandler *timers_container, void *(func)(void *), void *arg1, int arg2, unsigned timeout)
{
static int timer_id;
pthread_mutex_lock(&timers_container->mutex);
int i = 0;
for (; i < timers_container->max_capacity && timers_container->timers[i]; i ++);
if (i == timers_container->max_capacity) {
LOGGER_WARNING("Maximum capacity reached!");
pthread_mutex_unlock(&timers_container->mutex);
return -1;
}
Timer *timer = timers_container->timers[i] = calloc(sizeof(Timer), 1);
if (timer == NULL) {
LOGGER_ERROR("Failed to allocate timer!");
pthread_mutex_unlock(&timers_container->mutex);
return -1;
}
timers_container->size ++;
timer->func = func;
timer->func_arg1 = arg1;
timer->func_arg2 = arg2;
timer->timeout = timeout + current_time_monotonic(); /* In ms */
++timer_id;
timer->idx = timer_id;
/* reorder */
if (i) {
int j = i - 1;
for (; j >= 0 && timeout < timers_container->timers[j]->timeout; j--) {
Timer *tmp = timers_container->timers[j];
timers_container->timers[j] = timer;
timers_container->timers[j + 1] = tmp;
}
}
pthread_mutex_unlock(&timers_container->mutex);
LOGGER_DEBUG("Allocated timer index: %d timeout: %d, current size: %d", i, timeout, timers_container->size);
return timer->idx;
}
/**
* @brief Remove timer from array
*
* @param timers_container handler
* @param idx timer id
* @param lock_mutex (does the mutex need to be locked)
* @return int
*/
int timer_release ( TimerHandler *timers_container, int idx , int lock_mutex)
{
if (lock_mutex)
pthread_mutex_lock(&timers_container->mutex);
Timer **timed_events = timers_container->timers;
int i, res = -1;
for (i = 0; i < timers_container->max_capacity; ++i) {
if (timed_events[i] && timed_events[i]->idx == idx) {
res = i;
break;
}
}
if (res == -1) {
LOGGER_WARNING("No event with id: %d", idx);
if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
return -1;
}
free(timed_events[res]);
timed_events[res] = NULL;
i = res + 1;
for (; i < timers_container->max_capacity && timed_events[i]; i ++) {
timed_events[i - 1] = timed_events[i];
timed_events[i] = NULL;
}
timers_container->size--;
LOGGER_DEBUG("Popped index: %d, current size: %d ", idx, timers_container->size);
if (lock_mutex) pthread_mutex_unlock(&timers_container->mutex);
return 0;
}
/**
* @brief Main poll for timer execution
*
* @param arg ...
* @return void*
*/
void *timer_poll( void *arg )
{
TimerHandler *handler = arg;
while ( handler->running ) {
pthread_mutex_lock(&handler->mutex);
if ( handler->running ) {
uint64_t time = current_time_monotonic();
if ( handler->timers[0] && handler->timers[0]->timeout < time ) {
pthread_t _tid;
struct timer_function_args *args = malloc(sizeof(struct timer_function_args));
args->arg1 = handler->timers[0]->func_arg1;
args->arg2 = handler->timers[0]->func_arg2;
if ( 0 != pthread_create(&_tid, NULL, handler->timers[0]->func, args) ||
0 != pthread_detach(_tid) ) {
LOGGER_ERROR("Failed to execute timer at: %d!", handler->timers[0]->timeout);
free(args);
} else {
LOGGER_DEBUG("Exectued timer assigned at: %d", handler->timers[0]->timeout);
}
timer_release(handler, handler->timers[0]->idx, 0);
}
}
pthread_mutex_unlock(&handler->mutex);
usleep(handler->resolution);
}
pthread_exit(NULL);
}
/**
* @brief Start timer poll and return handler
*
* @param max_capacity capacity
* @param resolution ...
* @return TimerHandler*
*/
TimerHandler *timer_init_session (int max_capacity, int resolution)
{
TimerHandler *handler = calloc(1, sizeof(TimerHandler));
if (handler == NULL) {
LOGGER_ERROR("Failed to allocate memory, program might misbehave!");
return NULL;
}
handler->timers = calloc(max_capacity, sizeof(Timer *));
if (handler->timers == NULL) {
LOGGER_ERROR("Failed to allocate %d timed events!", max_capacity);
free(handler);
return NULL;
}
handler->max_capacity = max_capacity;
handler->running = 1;
handler->resolution = resolution;
pthread_mutex_init(&handler->mutex, NULL);
pthread_t _tid;
if ( 0 != pthread_create(&_tid, NULL, timer_poll, handler) || 0 != pthread_detach(_tid) ) {
LOGGER_ERROR("Failed to start timer poll thread!");
free(handler->timers);
free(handler);
return NULL;
}
return handler;
}
/**
* @brief Terminate timer session
*
* @param handler The timer handler
* @return void
*/
void timer_terminate_session(TimerHandler *handler)
{
pthread_mutex_lock(&handler->mutex);
handler->running = 0;
pthread_mutex_unlock(&handler->mutex);
int i = 0;
for (; i < handler->max_capacity; i ++)
free(handler->timers[i]);
free(handler->timers);
pthread_mutex_destroy( &handler->mutex );
}
/**
* @brief Generate _random_ alphanumerical string.
*
* @param str Destination.
* @param size Size of string.
* @return void
*/
void t_randomstr ( uint8_t *str, uint32_t size )
{
if (str == NULL) {
LOGGER_DEBUG("Empty destination!");
return;
}
static const uint8_t _bytes[] =
"0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
uint32_t _it = 0;
for ( ; _it < size; _it++ ) {
str[_it] = _bytes[ random_int() % 61 ];
}
}
typedef enum {
error_none,
error_deadcall, /* has call id but it's from old call */
error_id_mismatch, /* non-existing call */
error_no_callid, /* not having call id */
error_no_call, /* no call in session */
error_no_crypto_key, /* no crypto key */
error_busy
} MSICallError; /* Error codes */
/**
* @brief Stringify error code.
*
* @param error_code The code.
* @return const uint8_t* The string.
*/
static inline__ const uint8_t *stringify_error ( MSICallError error_code )
{
static const uint8_t *strings[] = {
( uint8_t *) "",
( uint8_t *) "Using dead call",
( uint8_t *) "Call id not set to any call",
( uint8_t *) "Call id not available",
( uint8_t *) "No active call in session",
( uint8_t *) "No Crypto-key set",
( uint8_t *) "Callee busy"
};
return strings[error_code];
}
/**
* @brief Convert error_code into string.
*
* @param error_code The code.
* @return const uint8_t* The string.
*/
static inline__ const uint8_t *stringify_error_code ( MSICallError error_code )
{
static const uint8_t *strings[] = {
( uint8_t *) "",
( uint8_t *) "1",
( uint8_t *) "2",
( uint8_t *) "3",
( uint8_t *) "4",
( uint8_t *) "5",
( uint8_t *) "6"
};
return strings[error_code];
}
/**
* @brief Speaks for it self.
*
* @param session Control session.
* @param msg The message.
* @param to Where to.
* @return int
* @retval -1 Error occurred.
* @retval 0 Success.
*/
int send_message ( MSISession *session, MSICall *call, MSIMessage *msg, uint32_t to )
{
msi_msg_set_callid ( msg, call->id, CALL_ID_LEN );
uint8_t _msg_string_final [MSI_MAXMSG_SIZE];
uint16_t _length = message_to_send ( msg, _msg_string_final );
if (!_length) {
LOGGER_WARNING("Parsing message failed; nothing sent!");
return -1;
}
if ( m_msi_packet(session->messenger_handle, to, _msg_string_final, _length) ) {
LOGGER_DEBUG("Sent message");
return 0;
}
return -1;
}
/**
* @brief Determine 'bigger' call id
*
* @param first duh
* @param second duh
* @return int
* @retval 0 it's first
* @retval 1 it's second
*/
int call_id_bigger( const uint8_t *first, const uint8_t *second)
{
return (memcmp(first, second, CALL_ID_LEN) < 0);
}
/**
* @brief Speaks for it self.
*
* @param session Control session.
* @param msg The message.
* @param peer_id The peer.
* @return void
*/
void flush_peer_type ( MSICall *call, MSIMessage *msg, int peer_id )
{
if ( msg->calltype.header_value ) {
uint8_t hdrval [MSI_MAXMSG_SIZE]; /* Make sure no overflow */
memcpy(hdrval, msg->calltype.header_value, msg->calltype.size);
hdrval[msg->calltype.size] = '\0';
if ( strcmp ( ( const char *) hdrval, CT_AUDIO_HEADER_VALUE ) == 0 ) {
call->type_peer[peer_id] = type_audio;
} else if ( strcmp ( ( const char *) hdrval, CT_VIDEO_HEADER_VALUE ) == 0 ) {
call->type_peer[peer_id] = type_video;
} else {} /* Error */
} else {} /* Error */
}
void handle_remote_connection_change(Messenger *messenger, int friend_num, uint8_t status, void *session_p)
{
MSISession *session = session_p;
switch ( status ) {
case 0: { /* Went offline */
uint32_t j = 0;
for ( ; j < session->max_calls; j ++ ) {
if ( !session->calls[j] ) continue;
int i = 0;
for ( ; i < session->calls[j]->peer_count; i ++ )
if ( session->calls[j]->peers[i] == friend_num ) {
invoke_callback(j, MSI_OnPeerTimeout);
terminate_call(session, session->calls[j]);
LOGGER_DEBUG("Remote: %d timed out!", friend_num);
return; /* TODO: On group calls change behaviour */
}
}
}
break;
default:
break;
}
}
MSICall *find_call ( MSISession *session, uint8_t *call_id )
{
if ( call_id == NULL ) return NULL;
uint32_t i = 0;
for (; i < session->max_calls; i ++ )
if ( session->calls[i] && memcmp(session->calls[i]->id, call_id, CALL_ID_LEN) == 0 ) {
LOGGER_SCOPE(
char tmp[CALL_ID_LEN + 1] = {'\0'};
memcpy(tmp, session->calls[i]->id, CALL_ID_LEN);
LOGGER_DEBUG("Found call id: %s", tmp);
);
return session->calls[i];
}
return NULL;
}
/**
* @brief Sends error response to peer.
*
* @param session The session.
* @param errid The id.
* @param to Where to?
* @return int
* @retval -1/0 It's usually always success.
*/
int send_error ( MSISession *session, MSICall *call, MSICallError errid, uint32_t to )
{
if (!call) {
LOGGER_WARNING("Cannot handle error on 'null' call");
return -1;
}
LOGGER_DEBUG("Sending error: %d on call: %s", errid, call->id);
MSIMessage *_msg_error = msi_new_message ( TYPE_RESPONSE, stringify_response ( error ) );
const uint8_t *_error_code_str = stringify_error_code ( errid );
msi_msg_set_reason ( _msg_error, _error_code_str, strlen ( ( const char *) _error_code_str ) );
send_message ( session, call, _msg_error, to );
free_message ( _msg_error );
session->last_error_id = errid;
session->last_error_str = stringify_error ( errid );
/* invoke_callback(call->call_idx, MSI_OnError); */
return 0;
}
/**
* @brief Add peer to peer list.
*
* @param call What call.
* @param peer_id Its id.
* @return void
*/
void add_peer( MSICall *call, int peer_id )
{
uint32_t *peers = !call->peers ? peers = calloc(sizeof(uint32_t), 1) :
realloc( call->peers, sizeof(uint32_t) * call->peer_count);
if (!peers) {
LOGGER_WARNING("Allocation failed! Program might misbehave!");
return;
}
call->peer_count ++;
call->peers = peers;
call->peers[call->peer_count - 1] = peer_id;
LOGGER_DEBUG("Added peer: %d", peer_id);
}
/**
* @brief Speaks for it self.
*
* @param session Control session.
* @param peers Amount of peers. (Currently it only supports 1)
* @param ringing_timeout Ringing timeout.
* @return MSICall* The created call.
*/
MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
{
if (peers == 0) {
LOGGER_ERROR("No peers!");
return NULL;
}
int32_t call_idx = 0;
for (; call_idx < session->max_calls; call_idx ++) {
if ( !session->calls[call_idx] ) {
if (!(session->calls[call_idx] = calloc ( sizeof ( MSICall ), 1 ))) {
LOGGER_WARNING("Allocation failed! Program might misbehave!");
return NULL;
}
break;
}
}
if ( call_idx == session->max_calls ) {
LOGGER_WARNING("Reached maximum amount of calls!");
return NULL;
}
MSICall *call = session->calls[call_idx];
call->call_idx = call_idx;
if ( !(call->type_peer = calloc ( sizeof ( MSICallType ), peers )) ) {
LOGGER_WARNING("Allocation failed! Program might misbehave!");
free(call);
return NULL;
}
call->session = session;
/*_call->_participant_count = _peers;*/
call->request_timer_id = 0;
call->ringing_timer_id = 0;
call->ringing_tout_ms = ringing_timeout;
pthread_mutex_init ( &call->mutex, NULL );
LOGGER_DEBUG("Started new call with index: %u", call_idx);
return call;
}
/**
* @brief Terminate the call.
*
* @param session Control session.
* @return int
* @retval -1 Error occurred.
* @retval 0 Success.
*/
int terminate_call ( MSISession *session, MSICall *call )
{
if ( !call ) {
LOGGER_WARNING("Tried to terminate non-existing call!");
return -1;
}
int rc = pthread_mutex_trylock(&session->mutex); /* Lock if not locked */
LOGGER_DEBUG("Terminated call id: %d", call->call_idx);
/* Check event loop and cancel timed events if there are any
* NOTE: This has to be done before possibly
* locking the mutex the second time
*/
timer_release ( session->timer_handler, call->request_timer_id, 1);
timer_release ( session->timer_handler, call->ringing_timer_id, 1);
/* Get a handle */
pthread_mutex_lock ( &call->mutex );
session->calls[call->call_idx] = NULL;
free ( call->type_peer );
free ( call->peers);
/* Release handle */
pthread_mutex_unlock ( &call->mutex );
pthread_mutex_destroy ( &call->mutex );
free ( call );
if ( rc != EBUSY ) /* Unlock if locked by this call */
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Function called at request timeout. If not called in thread it might cause trouble
*
* @param arg Control session
* @return void*
*/
void *handle_timeout ( void *arg )
{
/* TODO: Cancel might not arrive there; set up
* timers on these cancels and terminate call on
* their timeout
*/
struct timer_function_args *args = arg;
int call_index = args->arg2;
MSISession *session = args->arg1;
MSICall *_call = session->calls[call_index];
if (_call) {
LOGGER_DEBUG("[Call: %s] Request timed out!", _call->id);
invoke_callback(call_index, MSI_OnRequestTimeout);
}
if ( _call && _call->session ) {
/* TODO: Cancel all? */
/* uint16_t _it = 0;
* for ( ; _it < _session->call->peer_count; _it++ ) */
msi_cancel ( _call->session, _call->call_idx, _call->peers [0], "Request timed out" );
/*terminate_call(_call->session, _call);*/
}
free(arg);
pthread_exit(NULL);
}
/********** Request handlers **********/
int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *msg )
{
LOGGER_DEBUG("Session: %p Handling 'invite' on call: %s", session, call ? (char *)call->id : "making new");
pthread_mutex_lock(&session->mutex);
if ( call ) {
if ( call->peers[0] == msg->friend_id ) {
/* The glare case. A calls B when at the same time
* B calls A. Who has advantage is set bey calculating
* 'bigger' Call id and then that call id is being used in
* future. User with 'bigger' Call id has the advantage
* as in he will wait the response from the other.
*/
if ( call_id_bigger (call->id, msg->callid.header_value) == 1 ) { /* Peer has advantage */
/* Terminate call; peer will timeout(call) if call initialization (magically) fails */
terminate_call(session, call);
call = init_call ( session, 1, 0 );
if ( !call ) {
pthread_mutex_unlock(&session->mutex);
LOGGER_ERROR("Starting call");
return 0;
}
} else {
pthread_mutex_unlock(&session->mutex);
return 0; /* Wait for ringing from peer */
}
} else {
send_error ( session, call, error_busy, msg->friend_id ); /* TODO: Ugh*/
terminate_call(session, call);
pthread_mutex_unlock(&session->mutex);
return 0;
}
} else {
call = init_call ( session, 1, 0 );
if ( !call ) {
pthread_mutex_unlock(&session->mutex);
LOGGER_ERROR("Starting call");
return 0;
}
}
if ( !msg->callid.header_value ) {
send_error ( session, call, error_no_callid, msg->friend_id );
terminate_call(session, call);
pthread_mutex_unlock(&session->mutex);
return 0;
}
memcpy ( call->id, msg->callid.header_value, CALL_ID_LEN );
call->state = call_starting;
add_peer( call, msg->friend_id);
flush_peer_type ( call, msg, 0 );
MSIMessage *_msg_ringing = msi_new_message ( TYPE_RESPONSE, stringify_response ( ringing ) );
send_message ( session, call, _msg_ringing, msg->friend_id );
free_message ( _msg_ringing );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnInvite);
return 1;
}
int handle_recv_start ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
LOGGER_DEBUG("Session: %p Handling 'start' on call: %s, friend id: %d", session, call->id, msg->friend_id );
pthread_mutex_lock(&session->mutex);
call->state = call_active;
flush_peer_type ( call, msg, 0 );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnStart);
return 1;
}
int handle_recv_reject ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
LOGGER_DEBUG("Session: %p Handling 'reject' on call: %s", session, call->id);
pthread_mutex_lock(&session->mutex);
MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
send_message ( session, call, _msg_ending, msg->friend_id );
free_message ( _msg_ending );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnReject);
terminate_call(session, call);
return 1;
}
int handle_recv_cancel ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
LOGGER_DEBUG("Session: %p Handling 'cancel' on call: %s", session, call->id );
pthread_mutex_lock(&session->mutex);
/* Act as end message */
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnCancel);
terminate_call ( session, call );
return 1;
}
int handle_recv_end ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
LOGGER_DEBUG("Session: %p Handling 'end' on call: %s", session, call->id );
pthread_mutex_lock(&session->mutex);
MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
send_message ( session, call, _msg_ending, msg->friend_id );
free_message ( _msg_ending );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnEnd);
terminate_call ( session, call );
return 1;
}
/********** Response handlers **********/
int handle_recv_ringing ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
pthread_mutex_lock(&session->mutex);
if ( call->ringing_timer_id ) {
LOGGER_WARNING("Call already ringing");
pthread_mutex_unlock(&session->mutex);
return 0;
}
LOGGER_DEBUG("Session: %p Handling 'ringing' on call: %s", session, call->id );
call->ringing_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, call->call_idx,
call->ringing_tout_ms );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnRinging);
return 1;
}
int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Handling 'starting' on call: %s", session, call->id );
call->state = call_active;
MSIMessage *_msg_start = msi_new_message ( TYPE_REQUEST, stringify_request ( start ) );
send_message ( session, call, _msg_start, msg->friend_id );
free_message ( _msg_start );
flush_peer_type ( call, msg, 0 );
timer_release ( session->timer_handler, call->ringing_timer_id, 1 );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnStarting);
return 1;
}
int handle_recv_ending ( MSISession *session, MSICall *call, MSIMessage *msg )
{
if ( !call ) {
LOGGER_WARNING("Session: %p Handling 'start' on no call");
return 0;
}
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Handling 'ending' on call: %s", session, call->id );
/* Stop timer */
timer_release ( session->timer_handler, call->request_timer_id, 1 );
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnEnding);
/* Terminate call */
terminate_call ( session, call );
return 1;
}
int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *msg )
{
pthread_mutex_lock(&session->mutex);
if ( !call ) {
LOGGER_WARNING("Handling 'error' on non-existing call!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
LOGGER_DEBUG("Session: %p Handling 'error' on call: %s", session, call->id );
/* Handle error accordingly */
if ( msg->reason.header_value ) {
session->last_error_id = atoi ( ( const char *) msg->reason.header_value );
session->last_error_str = stringify_error ( session->last_error_id );
LOGGER_DEBUG("Error reason: %s", session->last_error_str);
}
pthread_mutex_unlock(&session->mutex);
invoke_callback(call->call_idx, MSI_OnEnding);
terminate_call ( session, call );
return 1;
}
/**
* @brief BASIC call flow:
*
* ALICE BOB
* | invite --> |
* | |
* | <-- ringing |
* | |
* | <-- starting |
* | |
* | start --> |
* | |
* | <-- MEDIA TRANS --> |
* | |
* | end --> |
* | |
* | <-- ending |
*
* Alice calls Bob by sending invite packet.
* Bob recvs the packet and sends an ringing packet;
* which notifies Alice that her invite is acknowledged.
* Ringing screen shown on both sides.
* Bob accepts the invite for a call by sending starting packet.
* Alice recvs the starting packet and sends the started packet to
* inform Bob that she recved the starting packet.
* Now the media transmission is established ( i.e. RTP transmission ).
* Alice hangs up and sends end packet.
* Bob recves the end packet and sends ending packet
* as the acknowledgement that the call is ending.
*
*
*/
void msi_handle_packet ( Messenger *messenger, int source, const uint8_t *data, uint16_t length, void *object )
{
LOGGER_DEBUG("Got msi message");
/* Unused */
(void)messenger;
MSISession *session = object;
MSIMessage *msg;
if ( !length ) {
LOGGER_WARNING("Lenght param negative");
return;
}
msg = parse_message ( data, length );
if ( !msg ) {
LOGGER_WARNING("Error parsing message");
return;
} else {
LOGGER_DEBUG("Successfully parsed message");
}
msg->friend_id = source;
/* Find what call */
MSICall *call = msg->callid.header_value ? find_call(session, msg->callid.header_value ) : NULL;
/* Now handle message */
if ( msg->request.header_value ) { /* Handle request */
if ( msg->response.size > 32 ) {
LOGGER_WARNING("Header size too big");
goto free_end;
}
uint8_t _request_value[32];
memcpy(_request_value, msg->request.header_value, msg->request.size);
_request_value[msg->request.size] = '\0';
if ( same ( _request_value, stringify_request ( invite ) ) ) {
handle_recv_invite ( session, call, msg );
} else if ( same ( _request_value, stringify_request ( start ) ) ) {
handle_recv_start ( session, call, msg );
} else if ( same ( _request_value, stringify_request ( cancel ) ) ) {
handle_recv_cancel ( session, call, msg );
} else if ( same ( _request_value, stringify_request ( reject ) ) ) {
handle_recv_reject ( session, call, msg );
} else if ( same ( _request_value, stringify_request ( end ) ) ) {
handle_recv_end ( session, call, msg );
} else {
LOGGER_WARNING("Uknown request");
goto free_end;
}
} else if ( msg->response.header_value ) { /* Handle response */
if ( msg->response.size > 32 ) {
LOGGER_WARNING("Header size too big");
goto free_end;
}
/* Got response so cancel timer */
if ( call ) timer_release ( session->timer_handler, call->request_timer_id, 1 );
uint8_t _response_value[32];
memcpy(_response_value, msg->response.header_value, msg->response.size);
_response_value[msg->response.size] = '\0';
if ( same ( _response_value, stringify_response ( ringing ) ) ) {
handle_recv_ringing ( session, call, msg );
} else if ( same ( _response_value, stringify_response ( starting ) ) ) {
handle_recv_starting ( session, call, msg );
} else if ( same ( _response_value, stringify_response ( ending ) ) ) {
handle_recv_ending ( session, call, msg );
} else if ( same ( _response_value, stringify_response ( error ) ) ) {
handle_recv_error ( session, call, msg );
} else {
LOGGER_WARNING("Uknown response");
goto free_end;
}
} else {
LOGGER_WARNING("Invalid message: no resp nor requ headers");
}
free_end:
free_message ( msg );
}
/**
* @brief Callback setter.
*
* @param callback The callback.
* @param id The id.
* @return void
*/
void msi_register_callback ( MSICallback callback, MSICallbackID id, void *userdata )
{
callbacks[id].function = callback;
callbacks[id].data = userdata;
}
/**
* @brief Start the control session.
*
* @param messenger Tox* object.
* @param max_calls Amount of calls possible
* @return MSISession* The created session.
* @retval NULL Error occurred.
*/
MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls )
{
if (messenger == NULL) {
LOGGER_ERROR("Could not init session on empty messenger!");
return NULL;
}
TimerHandler *handler = timer_init_session(max_calls * 10, 10000);
if ( !max_calls || !handler ) {
LOGGER_WARNING("Invalid max call treshold or timer handler initialization failed!");
return NULL;
}
MSISession *retu = calloc ( sizeof ( MSISession ), 1 );
if (retu == NULL) {
LOGGER_ERROR("Allocation failed! Program might misbehave!");
return NULL;
}
retu->messenger_handle = messenger;
retu->agent_handler = NULL;
retu->timer_handler = handler;
if (!(retu->calls = calloc( sizeof (MSICall *), max_calls ))) {
LOGGER_ERROR("Allocation failed! Program might misbehave!");
free(retu);
return NULL;
}
retu->max_calls = max_calls;
retu->frequ = 10000; /* default value? */
retu->call_timeout = 30000; /* default value? */
m_callback_msi_packet(messenger, msi_handle_packet, retu );
/* This is called when remote terminates session */
m_callback_connectionstatus_internal_av(messenger, handle_remote_connection_change, retu);
pthread_mutex_init(&retu->mutex, NULL);
LOGGER_DEBUG("New msi session: %p max calls: %u", retu, max_calls);
return retu;
}
/**
* @brief Terminate control session.
*
* @param session The session
* @return int
*/
int msi_terminate_session ( MSISession *session )
{
if (session == NULL) {
LOGGER_ERROR("Tried to terminate non-existing session");
return -1;
}
pthread_mutex_lock(&session->mutex);
m_callback_msi_packet((struct Messenger *) session->messenger_handle, NULL, NULL);
pthread_mutex_unlock(&session->mutex);
int _status = 0;
/* If have calls, cancel them */
uint32_t idx = 0;
for (; idx < session->max_calls; idx ++) if ( session->calls[idx] ) {
/* Cancel all? */
uint16_t _it = 0;
/*for ( ; _it < session->calls[idx]->peer_count; _it++ )
* FIXME: will not work on multiple peers, must cancel call for all peers
*/
msi_cancel ( session, idx, session->calls[idx]->peers [_it], "MSI session terminated!" );
}
timer_terminate_session(session->timer_handler);
pthread_mutex_destroy(&session->mutex);
LOGGER_DEBUG("Terminated session: %p", session);
free ( session );
return _status;
}
/**
* @brief Send invite request to friend_id.
*
* @param session Control session.
* @param call_type Type of the call. Audio or Video(both audio and video)
* @param rngsec Ringing timeout.
* @param friend_id The friend.
* @return int
*/
int msi_invite ( MSISession *session, int32_t *call_index, MSICallType call_type, uint32_t rngsec, uint32_t friend_id )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Inviting friend: %u", session, friend_id);
MSICall *_call = init_call ( session, 1, rngsec ); /* Just one peer for now */
if ( !_call ) {
pthread_mutex_unlock(&session->mutex);
LOGGER_ERROR("Cannot handle more calls");
return -1;
}
*call_index = _call->call_idx;
t_randomstr ( _call->id, CALL_ID_LEN );
add_peer(_call, friend_id );
_call->type_local = call_type;
MSIMessage *_msg_invite = msi_new_message ( TYPE_REQUEST, stringify_request ( invite ) );
/* Do whatever with message */
if ( call_type == type_audio ) {
msi_msg_set_calltype ( _msg_invite, ( const uint8_t *) CT_AUDIO_HEADER_VALUE, strlen ( CT_AUDIO_HEADER_VALUE ) );
} else {
msi_msg_set_calltype ( _msg_invite, ( const uint8_t *) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
}
send_message ( session, _call, _msg_invite, friend_id );
free_message ( _msg_invite );
_call->state = call_inviting;
_call->request_timer_id = timer_alloc ( session->timer_handler, handle_timeout, session, _call->call_idx, m_deftout );
LOGGER_DEBUG("Invite sent");
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Hangup active call.
*
* @param session Control session.
* @param call_id To which call is this action handled.
* @return int
* @retval -1 Error occurred.
* @retval 0 Success.
*/
int msi_hangup ( MSISession *session, int32_t call_index )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Hanging up call: %u", session, call_index);
if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
LOGGER_ERROR("Invalid call index!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
if ( !session->calls[call_index] || session->calls[call_index]->state != call_active ) {
LOGGER_ERROR("No call with such index or call is not active!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
MSIMessage *_msg_end = msi_new_message ( TYPE_REQUEST, stringify_request ( end ) );
/* hangup for each peer */
int _it = 0;
for ( ; _it < session->calls[call_index]->peer_count; _it ++ )
send_message ( session, session->calls[call_index], _msg_end, session->calls[call_index]->peers[_it] );
session->calls[call_index]->state = call_hanged_up;
free_message ( _msg_end );
session->calls[call_index]->request_timer_id =
timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Answer active call request.
*
* @param session Control session.
* @param call_id To which call is this action handled.
* @param call_type Answer with Audio or Video(both).
* @return int
*/
int msi_answer ( MSISession *session, int32_t call_index, MSICallType call_type )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Answering call: %u", session, call_index);
if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
LOGGER_ERROR("Invalid call index!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
MSIMessage *_msg_starting = msi_new_message ( TYPE_RESPONSE, stringify_response ( starting ) );
session->calls[call_index]->type_local = call_type;
if ( call_type == type_audio ) {
msi_msg_set_calltype
( _msg_starting, ( const uint8_t *) CT_AUDIO_HEADER_VALUE, strlen ( CT_AUDIO_HEADER_VALUE ) );
} else {
msi_msg_set_calltype
( _msg_starting, ( const uint8_t *) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
}
send_message ( session, session->calls[call_index], _msg_starting,
session->calls[call_index]->peers[session->calls[call_index]->peer_count - 1] );
free_message ( _msg_starting );
session->calls[call_index]->state = call_active;
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Cancel request.
*
* @param session Control session.
* @param call_id To which call is this action handled.
* @param reason Set optional reason header. Pass NULL if none.
* @return int
*/
int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const char *reason )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Canceling call: %u; reason:", session, call_index, reason ? reason : "Unknown");
if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
LOGGER_ERROR("Invalid call index!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
MSIMessage *_msg_cancel = msi_new_message ( TYPE_REQUEST, stringify_request ( cancel ) );
if ( reason ) msi_msg_set_reason(_msg_cancel, (const uint8_t *)reason, strlen(reason));
send_message ( session, session->calls[call_index], _msg_cancel, peer );
free_message ( _msg_cancel );
/*session->calls[call_index]->state = call_hanged_up;
session->calls[call_index]->request_timer_id = timer_alloc ( handle_timeout, session, call_index, m_deftout );*/
terminate_call ( session, session->calls[call_index] );
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Reject request.
*
* @param session Control session.
* @param call_id To which call is this action handled.
* @return int
*/
int msi_reject ( MSISession *session, int32_t call_index, const uint8_t *reason )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Rejecting call: %u; reason:", session, call_index, reason ? (char *)reason : "Unknown");
if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
LOGGER_ERROR("Invalid call index!");
pthread_mutex_unlock(&session->mutex);
return -1;
}
MSIMessage *_msg_reject = msi_new_message ( TYPE_REQUEST, stringify_request ( reject ) );
if ( reason ) msi_msg_set_reason(_msg_reject, reason, strlen((const char *)reason) + 1);
send_message ( session, session->calls[call_index], _msg_reject,
session->calls[call_index]->peers[session->calls[call_index]->peer_count - 1] );
free_message ( _msg_reject );
session->calls[call_index]->state = call_hanged_up;
session->calls[call_index]->request_timer_id =
timer_alloc ( session->timer_handler, handle_timeout, session, call_index, m_deftout );
pthread_mutex_unlock(&session->mutex);
return 0;
}
/**
* @brief Terminate the current call.
*
* @param session Control session.
* @param call_id To which call is this action handled.
* @return int
*/
int msi_stopcall ( MSISession *session, int32_t call_index )
{
pthread_mutex_lock(&session->mutex);
LOGGER_DEBUG("Session: %p Stopping call index: %u", session, call_index);
if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
pthread_mutex_unlock(&session->mutex);
return -1;
}
/* just terminate it */
terminate_call ( session, session->calls[call_index] );
pthread_mutex_unlock(&session->mutex);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink