Yeah many calls

1 files changed, 466 insertions, 242 deletions

diff --git a/toxav/msi.c b/toxav/msi.c
index 26e301d3..ae6fcf84 100755
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -26,7 +26,9 @@
 #include "config.h"
 #endif /* HAVE_CONFIG_H */
 
-#define _BSD_SOURCE
+#include "../toxcore/logger.h"
+
+/*#define _BSD_SOURCE*/
 
 #include "msi.h"
 #include "event.h"
@@ -120,10 +122,13 @@ static struct _Callbacks {
     void* data;
 } callbacks[11] = {0};
 
-inline__ void invoke_callback(MSICallbackID id)
+inline__ void invoke_callback(uint32_t call_index, MSICallbackID id)
 {
     /*if ( callbacks[id].function ) event.rise ( callbacks[id].function, callbacks[id].data );*/
-    if ( callbacks[id].function ) callbacks[id].function ( callbacks[id].data );
+    if ( callbacks[id].function ) { 
+        LOGGER_DEBUG("Invoking callback function: %d", id);
+        callbacks[id].function ( call_index, callbacks[id].data );
+    }
 }
 
 /*static MSICallback callbacks[10] = {0};*/
@@ -230,7 +235,9 @@ static inline__ const uint8_t *stringify_response ( MSIResponse response )
  */
 int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
 {
-    assert ( msg );
+    if ( msg == NULL ) {
+        LOGGER_ERROR("Could not parse message: no storage!");
+    }
 
     if ( data[length - 1] ) /* End byte must have value 0 */
         return -1;
@@ -271,7 +278,7 @@ int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
                     if ON_HEADER ( _it, msg->version, VERSION_FIELD, 7 )
                         else if ON_HEADER ( _it, msg->request, REQUEST_FIELD, 7 )
                             else if ON_HEADER ( _it, msg->callid, CALLID_FIELD, 7 )
-                            }
+                    }
                 break;
 
                 case 8: { /* Response header */
@@ -290,9 +297,13 @@ int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
                 break;
 
                 default:
+                    LOGGER_ERROR("Unkown field value");
                     return -1;
             }
-        } else 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 */
 
@@ -304,8 +315,9 @@ int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
 
 #define ALLOCATE_HEADER( var, mheader_value, t_size) \
 var.header_value = calloc(sizeof *mheader_value, t_size); \
-memcpy(var.header_value, mheader_value, t_size); \
-var.size = t_size;
+if (var.header_value == NULL) { LOGGER_WARNING("Header allocation failed!"); } \
+else { memcpy(var.header_value, mheader_value, t_size); \
+var.size = t_size; }
 
 
 /**
@@ -316,7 +328,9 @@ var.size = t_size;
  */
 void free_message ( MSIMessage *msg )
 {
-    assert ( msg );
+    if ( msg == NULL ) {
+        LOGGER_ERROR("Tried to free empty message");
+    }
 
     free ( msg->calltype.header_value );
     free ( msg->request.header_value );
@@ -343,7 +357,11 @@ void free_message ( MSIMessage *msg )
 MSIMessage *msi_new_message ( uint8_t type, const uint8_t *type_id )
 {
     MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
-    assert ( _retu );
+    
+    if ( _retu == NULL ) {
+        LOGGER_WARNING("Allocation failed!");
+        return NULL;
+    }
 
     if ( type == TYPE_REQUEST ) {
         ALLOCATE_HEADER ( _retu->request, type_id, strlen ( (const char *)type_id ) )
@@ -371,10 +389,17 @@ MSIMessage *msi_new_message ( uint8_t type, const uint8_t *type_id )
  */
 MSIMessage *parse_message ( const uint8_t *data, uint16_t length )
 {
-    assert ( data );
+    if ( data == NULL ) {
+        LOGGER_WARNING("Tried to parse empty message!");
+        return NULL;
+    }
 
     MSIMessage *_retu = calloc ( sizeof ( MSIMessage ), 1 );
-    assert ( _retu );
+    
+    if ( _retu == NULL ) {
+        LOGGER_WARNING("Allocation failed!");
+        return NULL;
+    }
 
     memset ( _retu, 0, sizeof ( MSIMessage ) );
 
@@ -397,6 +422,42 @@ MSIMessage *parse_message ( const uint8_t *data, uint16_t length )
 
 
 /**
+ * @brief Makes clear message presentation
+ * 
+ * @param msg Message
+ * @param dest Dest string
+ * @return int
+ */
+int stringify_message(MSIMessage* msg, char* dest) 
+{
+    #define HDR_TO_STR(__dest, __hdr) if (__hdr.header_value) {\
+    char nltstr[MSI_MAXMSG_SIZE]; memset(nltstr, '\0', MSI_MAXMSG_SIZE); int i = 0; \
+    for ( ; i < __hdr.size; i ++) nltstr[i] = (char)__hdr.header_value[i]; \
+    }
+        
+    if ( !msg || !dest )
+        return -1;
+    
+    HDR_TO_STR(dest, msg->version);
+    HDR_TO_STR(dest, msg->request);
+    HDR_TO_STR(dest, msg->response);
+    HDR_TO_STR(dest, msg->reason);
+    HDR_TO_STR(dest, msg->callid);
+    HDR_TO_STR(dest, msg->calltype);
+    HDR_TO_STR(dest, msg->cryptokey);
+    HDR_TO_STR(dest, msg->nonce);
+    
+//     if (msg->version.header_value) {
+//         U8_TO_NLTCHAR(msg->version.header_value, msg->version.size, nltstr, MSI_MAXMSG_SIZE);
+//         sprintf(dest, "Version: %s\n", nltstr);
+//     }
+    
+    return 0;
+}
+
+
+
+/**
  * @brief Speaks for it self.
  *
  * @param dest Container.
@@ -413,10 +474,20 @@ uint8_t *append_header_to_string (
     uint16_t value_len,
     uint16_t *length )
 {
-    assert ( dest );
-    assert ( header_value );
-    assert ( header_field );
-
+    if ( dest == NULL ) {
+        LOGGER_ERROR("No destination space!");
+        assert(dest);
+    }
+    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*/
 
@@ -477,10 +548,16 @@ if ( header.header_value ) { var = append_header_to_string(var, (const uint8_t*)
  * @param dest Destination.
  * @return uint16_t It's final size.
  */
-uint16_t message_to_string ( MSIMessage *msg, uint8_t *dest )
+uint16_t message_to_send ( MSIMessage *msg, uint8_t *dest )
 {
-    assert ( msg );
-    assert ( dest );
+    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;
@@ -525,7 +602,10 @@ GENERIC_SETTER_DEFINITION ( nonce )
  */
 void t_randomstr ( uint8_t *str, size_t size )
 {
-    assert ( str );
+    if (str == NULL) {
+        LOGGER_DEBUG("Empty destination!");
+        return;
+    }
 
     static const uint8_t _bytes[] =
         "0123456789"
@@ -607,14 +687,32 @@ static inline__ const uint8_t *stringify_error_code ( MSICallError error_code )
  * @retval -1 Error occured.
  * @retval 0 Success.
  */
-int send_message ( MSISession *session, MSIMessage *msg, uint32_t to )
+int send_message ( MSISession *session, MSICall* call, MSIMessage *msg, uint32_t to )
 {
-    msi_msg_set_callid ( msg, session->call->id, CALL_ID_LEN );
+    msi_msg_set_callid ( msg, call->id, CALL_ID_LEN );
 
     uint8_t _msg_string_final [MSI_MAXMSG_SIZE];
-    uint16_t _length = message_to_string ( msg, _msg_string_final );
-
-    return m_msi_packet(session->messenger_handle, to, _msg_string_final, _length) ? 0 : -1;
+    uint16_t _length = message_to_send ( msg, _msg_string_final );
+    
+    if (!_length) {
+        LOGGER_WARNING("Parsing message failed; nothing sent!");
+        return -1;
+    }
+    
+    /*    
+    LOGGER_SCOPE(
+        char cast[MSI_MAXMSG_SIZE];
+        stringify_message(msg, cast);
+        LOGGER_DEBUG("[Call: %s] [to: %u] Sending message: len: %d\n%s", call->id, to, _length, cast);
+    );*/
+    
+    
+    if ( m_msi_packet(session->messenger_handle, to, _msg_string_final, _length) ) {
+        LOGGER_DEBUG("Sent message");
+        return 0;
+    }
+    
+    return -1;
 }
 
 
@@ -646,7 +744,7 @@ int call_id_bigger( const uint8_t* first, const uint8_t* second)
  * @param peer_id The peer.
  * @return void
  */
-void flush_peer_type ( MSISession *session, MSIMessage *msg, int peer_id )
+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 */
@@ -655,10 +753,10 @@ void flush_peer_type ( MSISession *session, MSIMessage *msg, int peer_id )
         hdrval[msg->calltype.size] = '\0';
         
         if ( strcmp ( ( const char * ) hdrval, CT_AUDIO_HEADER_VALUE ) == 0 ) {
-            session->call->type_peer[peer_id] = type_audio;
+            call->type_peer[peer_id] = type_audio;
 
         } else if ( strcmp ( ( const char * ) hdrval, CT_VIDEO_HEADER_VALUE ) == 0 ) {
-            session->call->type_peer[peer_id] = type_video;
+            call->type_peer[peer_id] = type_video;
         } else {} /* Error */
     } else {} /* Error */
 }
@@ -669,13 +767,17 @@ void handle_remote_connection_change(Messenger *messenger, int friend_num, uint8
 
     switch ( status ) {
         case 0: { /* Went offline */
-            if ( session->call ) {
+            uint32_t j =0;
+            for ( ; j < session->max_calls; j ++ ) {
+                
+                if ( !session->calls[j] ) continue;
+                
                 int i = 0;
-
-                for ( ; i < session->call->peer_count; i ++ )
-                    if ( session->call->peers[i] == friend_num ) {
-                        invoke_callback(MSI_OnPeerTimeout);
-                        return;
+                for ( ; i < session->calls[j]->peer_count; i ++ )
+                    if ( session->calls[j]->peers[i] == friend_num ) {
+                        invoke_callback(j, MSI_OnPeerTimeout);
+                        LOGGER_DEBUG("Remote: %d timed out!", friend_num);
+                        return; /* TODO: On group calls change behaviour */
                     }
             }
         }
@@ -686,6 +788,18 @@ void handle_remote_connection_change(Messenger *messenger, int friend_num, uint8
     }
 }
 
+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 ) 
+            return session->calls[i];
+        
+    return NULL;
+}
+
 /**
  * @brief Sends error response to peer.
  *
@@ -695,20 +809,22 @@ void handle_remote_connection_change(Messenger *messenger, int friend_num, uint8
  * @return int
  * @retval 0 It's always success.
  */
-int handle_error ( MSISession *session, MSICallError errid, uint32_t to )
+int handle_error ( MSISession *session, MSICall* call, MSICallError errid, uint32_t to )
 {
+    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, _msg_error, to );
+    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(MSI_OnError);
+    invoke_callback(call->call_idx, MSI_OnError);
 
     return 0;
 }
@@ -723,16 +839,16 @@ int handle_error ( MSISession *session, MSICallError errid, uint32_t to )
  * @retval -1 No error.
  * @retval 0 Error occured and response sent.
  */
-int has_call_error ( MSISession *session, MSIMessage *msg )
+int has_call_error ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
     if ( !msg->callid.header_value ) {
-        return handle_error ( session, error_no_callid, msg->friend_id );
+        return handle_error ( session, call, error_no_callid, msg->friend_id );
 
-    } else if ( !session->call ) {
-        return handle_error ( session, error_no_call, msg->friend_id );
+    } else if ( !call ) {
+        return handle_error ( session, call, error_no_call, msg->friend_id );
 
-    } else if ( memcmp ( session->call->id, msg->callid.header_value, CALL_ID_LEN ) != 0 ) {
-        return handle_error ( session, error_id_mismatch, msg->friend_id );
+    } else if ( memcmp ( call->id, msg->callid.header_value, CALL_ID_LEN ) != 0 ) {
+        return handle_error ( session, call, error_id_mismatch, msg->friend_id );
 
     }
 
@@ -741,7 +857,7 @@ int has_call_error ( MSISession *session, MSIMessage *msg )
 
 
 /**
- * @brief Function called at request timeout.
+ * @brief Function called at request timeout. If not called in thread it might cause trouble
  *
  * @param arg Control session
  * @return void*
@@ -752,16 +868,18 @@ void *handle_timeout ( void *arg )
      * timers on these cancels and terminate call on
      * their timeout
      */
-    MSISession *_session = arg;
-        
-    invoke_callback(MSI_OnRequestTimeout);
+    MSICall *_call = arg;
+    
+    LOGGER_DEBUG("[Call: %s] Request timed out!", _call->id);
+    
+    invoke_callback(_call->call_idx, MSI_OnRequestTimeout);
         
-    if ( _session && _session->call ) {
+    if ( _call && _call->session ) {
        
         /* TODO: Cancel all? */
         /* uint16_t _it = 0;        
         for ( ; _it < _session->call->peer_count; _it++ ) */
-        msi_cancel ( _session, _session->call->peers [0], "Request timedout" );
+        msi_cancel ( _call->session, _call->call_idx, _call->peers [0], "Request timed out" );
     }
 
     pthread_exit(NULL);
@@ -798,14 +916,41 @@ void add_peer( MSICall *call, int peer_id )
  */
 MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
 {
-    assert ( session );
-    assert ( peers );
+    
+    if (peers == 0) {
+        LOGGER_ERROR("No peers!");
+        return NULL;
+    }
+    
+    uint32_t _call_idx = 0;
+    for (; _call_idx < session->max_calls; _call_idx ++) {
+        if ( !session->calls[_call_idx] ) {
+            session->calls[_call_idx] = calloc ( sizeof ( MSICall ), 1 );
+            break;
+        }
+    }
+    
+    if ( _call_idx == session->max_calls ) { 
+        LOGGER_WARNING("Reached maximum amount of calls!");
+    }
+    
 
-    MSICall *_call = calloc ( sizeof ( MSICall ), 1 );
+    MSICall *_call = session->calls[_call_idx];
+    _call->call_idx = _call_idx;
+    
+    if ( _call == NULL ) {
+        LOGGER_WARNING("Allocation failed!");
+        return NULL;
+    }
+    
     _call->type_peer = calloc ( sizeof ( MSICallType ), peers );
-
-    assert ( _call );
-    assert ( _call->type_peer );
+    
+    if ( _call->type_peer == NULL ) {
+        LOGGER_WARNING("Allocation failed!");
+        return NULL;
+    }
+    
+    _call->session = session;
 
     /*_call->_participant_count = _peers;*/
 
@@ -821,6 +966,7 @@ MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
 
     pthread_mutex_init ( &_call->mutex, NULL );
 
+    LOGGER_DEBUG("Started new call with index: %u", _call_idx);
     return _call;
 }
 
@@ -833,51 +979,48 @@ MSICall *init_call ( MSISession *session, int peers, int ringing_timeout )
  * @retval -1 Error occured.
  * @retval 0 Success.
  */
-int terminate_call ( MSISession *session )
+int terminate_call ( MSISession *session, MSICall *call )
 {
-    assert ( session );
-
-    if ( !session->call )
+    if ( !call ) { 
+        LOGGER_WARNING("Tried to terminate non-existing call!");
         return -1;
-
+    }
 
     /* 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
      */
-    event.timer_release ( session->call->request_timer_id );
-    event.timer_release ( session->call->ringing_timer_id );
+    event.timer_release ( call->request_timer_id );
+    event.timer_release ( call->ringing_timer_id );
 
     /* Get a handle */
-    pthread_mutex_lock ( &session->call->mutex );
-
-    MSICall *_call = session->call;
-    session->call = NULL;
+    pthread_mutex_lock ( &call->mutex );
+    
+    session->calls[call->call_idx]= NULL;
 
-    free ( _call->type_peer );
-    free ( _call->key_local );
-    free ( _call->key_peer );
-    free ( _call->peers);
+    free ( call->type_peer );
+    free ( call->key_local );
+    free ( call->key_peer );
+    free ( call->peers);
 
     /* Release handle */
-    pthread_mutex_unlock ( &_call->mutex );
+    pthread_mutex_unlock ( &call->mutex );
 
-    pthread_mutex_destroy ( &_call->mutex );
+    pthread_mutex_destroy ( &call->mutex );
 
-    free ( _call );
+    free ( call );
 
     return 0;
 }
 
 
 /********** Request handlers **********/
-int handle_recv_invite ( MSISession *session, MSIMessage *msg )
+int handle_recv_invite ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
+    LOGGER_DEBUG("Handling 'invite' on call: %s", call? (char*)call->id : "making new");
     
-    if ( session->call ) {
-        if ( session->call->peers[0] == msg->friend_id ) { 
+    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
@@ -885,8 +1028,8 @@ int handle_recv_invite ( MSISession *session, MSIMessage *msg )
              * as in he will wait the reponse from the other.
              */
             
-            if ( call_id_bigger (session->call->id, msg->callid.header_value) == 1 ) { /* Peer has advantage */
-                terminate_call(session);
+            if ( call_id_bigger (call->id, msg->callid.header_value) == 1 ) { /* Peer has advantage */
+                terminate_call(session, call);
             } 
             else {
                 return 0; /* Wait for ringing from peer */
@@ -894,202 +1037,213 @@ int handle_recv_invite ( MSISession *session, MSIMessage *msg )
                 
         }
         else {
-            handle_error ( session, error_busy, msg->friend_id );
+            handle_error ( session, call, error_busy, msg->friend_id ); /* TODO: Ugh*/
             return 0;
         }        
     }
 
     if ( !msg->callid.header_value ) {
-        handle_error ( session, error_no_callid, msg->friend_id );
+        handle_error ( session, call, error_no_callid, msg->friend_id );
         return 0;
     }
 
-    session->call = init_call ( session, 1, 0 );
-    memcpy ( session->call->id, msg->callid.header_value, CALL_ID_LEN );
-    session->call->state = call_starting;
+    MSICall* new_call = init_call ( session, 1, 0 );
+    
+    if ( !new_call ) {
+        handle_error ( session, call, error_busy, msg->friend_id );
+        return 0;
+    }
+    
+    memcpy ( new_call->id, msg->callid.header_value, CALL_ID_LEN );
+    new_call->state = call_starting;
 
-    add_peer( session->call, msg->friend_id);
+    add_peer( new_call, msg->friend_id);
 
-    flush_peer_type ( session, msg, 0 );
+    flush_peer_type ( new_call, msg, 0 );
 
     MSIMessage *_msg_ringing = msi_new_message ( TYPE_RESPONSE, stringify_response ( ringing ) );
-    send_message ( session, _msg_ringing, msg->friend_id );
+    send_message ( session, new_call, _msg_ringing, msg->friend_id );
     free_message ( _msg_ringing );
 
-    invoke_callback(MSI_OnInvite);
+    invoke_callback(new_call->call_idx, MSI_OnInvite);
 
     return 1;
 }
-int handle_recv_start ( MSISession *session, MSIMessage *msg )
+int handle_recv_start ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
-    if ( has_call_error ( session, msg ) == 0 )
-        return 0;
+    LOGGER_DEBUG("Handling 'start' on call: %s", call->id );
+    
+    if ( has_call_error ( session, call, msg ) == 0 )
+        return -1;
 
     if ( !msg->cryptokey.header_value )
-        return handle_error ( session, error_no_crypto_key, msg->friend_id );
+        return handle_error ( session, call, error_no_crypto_key, msg->friend_id );
 
-    session->call->state = call_active;
+    call->state = call_active;
 
-    session->call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
-    memcpy ( session->call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
+    call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    memcpy ( call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
 
-    session->call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
-    memcpy ( session->call->nonce_peer, msg->nonce.header_value,  crypto_secretbox_NONCEBYTES );
+    call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
+    memcpy ( call->nonce_peer, msg->nonce.header_value,  crypto_secretbox_NONCEBYTES );
 
-    flush_peer_type ( session, msg, 0 );
+    flush_peer_type ( call, msg, 0 );
 
-    invoke_callback(MSI_OnStart);
+    invoke_callback(call->call_idx, MSI_OnStart);
 
     return 1;
 }
-int handle_recv_reject ( MSISession *session, MSIMessage *msg )
+int handle_recv_reject ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
-    if ( has_call_error ( session, msg ) == 0 )
+    LOGGER_DEBUG("Handling 'reject' on call: %s", call->id );
+    
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
 
 
     MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
-    send_message ( session, _msg_ending, msg->friend_id );
+    send_message ( session, call, _msg_ending, msg->friend_id );
     free_message ( _msg_ending );
 
     
-    invoke_callback(MSI_OnReject);
+    invoke_callback(call->call_idx, MSI_OnReject);
     /*
     event.timer_release ( session->call->request_timer_id );
     session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
     */
 
-    terminate_call(session);
+    terminate_call(session, call);
     
     return 1;
 }
-int handle_recv_cancel ( MSISession *session, MSIMessage *msg )
+int handle_recv_cancel ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
+    LOGGER_DEBUG("Handling 'cancel' on call: %s", call->id );
     
-    if ( has_call_error ( session, msg ) == 0 )
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
     
     /* Act as end message */
     
     MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
-    send_message ( session, _msg_ending, msg->friend_id );
+    send_message ( session, call, _msg_ending, msg->friend_id );
     free_message ( _msg_ending );
     
-    invoke_callback(MSI_OnCancel);
+    invoke_callback(call->call_idx, MSI_OnCancel);
     
-    terminate_call ( session );
+    terminate_call ( session, call );
     
     return 1;
 }
-int handle_recv_end ( MSISession *session, MSIMessage *msg )
+int handle_recv_end ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
-    if ( has_call_error ( session, msg ) == 0 )
+    LOGGER_DEBUG("Handling 'end' on call: %s", call->id );
+    
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
 
 
     MSIMessage *_msg_ending = msi_new_message ( TYPE_RESPONSE, stringify_response ( ending ) );
-    send_message ( session, _msg_ending, msg->friend_id );
+    send_message ( session, call, _msg_ending, msg->friend_id );
     free_message ( _msg_ending );
 
-    invoke_callback(MSI_OnEnd);
+    invoke_callback(call->call_idx, MSI_OnEnd);
 
-    terminate_call ( session );
+    terminate_call ( session, call );
     return 1;
 }
 
 /********** Response handlers **********/
-int handle_recv_ringing ( MSISession *session, MSIMessage *msg )
+int handle_recv_ringing ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
-    if ( has_call_error ( session, msg ) == 0 )
+    LOGGER_DEBUG("Handling 'ringing' on call: %s", call->id );
+    
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
 
-    session->call->ringing_timer_id = event.timer_alloc ( handle_timeout, session, session->call->ringing_tout_ms );
+    call->ringing_timer_id = event.timer_alloc ( handle_timeout, call, call->ringing_tout_ms );
     
-    invoke_callback(MSI_OnRinging);
+    invoke_callback(call->call_idx, MSI_OnRinging);
 
     return 1;
 }
-int handle_recv_starting ( MSISession *session, MSIMessage *msg )
+int handle_recv_starting ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-
-    if ( has_call_error ( session, msg ) == 0 )
+    LOGGER_DEBUG("Handling 'starting' on call: %s", call->id );
+    
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
 
     if ( !msg->cryptokey.header_value ) {
-        return handle_error ( session, error_no_crypto_key, msg->friend_id );
+        return handle_error ( session, call, error_no_crypto_key, msg->friend_id );
     }
 
     /* Generate local key/nonce to send */
-    session->call->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
-    new_symmetric_key ( session->call->key_local );
+    call->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    new_symmetric_key ( call->key_local );
 
-    session->call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
-    new_nonce ( session->call->nonce_local );
+    call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
+    new_nonce ( call->nonce_local );
 
     /* Save peer key/nonce */
-    session->call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
-    memcpy ( session->call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
+    call->key_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    memcpy ( call->key_peer, msg->cryptokey.header_value, crypto_secretbox_KEYBYTES );
 
-    session->call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
-    memcpy ( session->call->nonce_peer, msg->nonce.header_value,  crypto_secretbox_NONCEBYTES );
+    call->nonce_peer = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
+    memcpy ( call->nonce_peer, msg->nonce.header_value,  crypto_secretbox_NONCEBYTES );
 
-    session->call->state = call_active;
+    call->state = call_active;
 
     MSIMessage *_msg_start = msi_new_message ( TYPE_REQUEST, stringify_request ( start ) );
-    msi_msg_set_cryptokey ( _msg_start, session->call->key_local, crypto_secretbox_KEYBYTES );
-    msi_msg_set_nonce ( _msg_start, session->call->nonce_local, crypto_secretbox_NONCEBYTES );
-    send_message ( session, _msg_start, msg->friend_id );
+    msi_msg_set_cryptokey ( _msg_start, call->key_local, crypto_secretbox_KEYBYTES );
+    msi_msg_set_nonce ( _msg_start, call->nonce_local, crypto_secretbox_NONCEBYTES );
+    send_message ( session, call, _msg_start, msg->friend_id );
     free_message ( _msg_start );
 
-    flush_peer_type ( session, msg, 0 );
+    flush_peer_type ( call, msg, 0 );
 
-    invoke_callback(MSI_OnStarting);
+    invoke_callback(call->call_idx, MSI_OnStarting);
     
-    event.timer_release ( session->call->ringing_timer_id );
+    event.timer_release ( call->ringing_timer_id );
 
     return 1;
 }
-int handle_recv_ending ( MSISession *session, MSIMessage *msg )
+int handle_recv_ending ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
+    LOGGER_DEBUG("Handling 'ending' on call: %s", call->id );
     
-    if ( has_call_error ( session, msg ) == 0 )
+    if ( has_call_error ( session, call, msg ) == 0 )
         return 0;
     
     /* Stop timer */    
-    event.timer_release ( session->call->request_timer_id );
+    event.timer_release ( call->request_timer_id );
     
-    invoke_callback(MSI_OnEnding);
+    invoke_callback(call->call_idx, MSI_OnEnding);
     
     /* Terminate call */
-    terminate_call ( session );
+    terminate_call ( session, call );
 
     return 1;
 }
-int handle_recv_error ( MSISession *session, MSIMessage *msg )
+int handle_recv_error ( MSISession *session, MSICall* call, MSIMessage *msg )
 {
-    assert ( session );
-    assert ( session->call );
+    if ( !call ) { 
+        LOGGER_WARNING("Handling 'error' on non-existing call!");
+        return -1;
+    }
+    
+    LOGGER_DEBUG("Handling 'error' on call: %s", 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);
     }
 
-    invoke_callback(MSI_OnEnding);
+    invoke_callback(call->call_idx, MSI_OnEnding);
     
-    terminate_call ( session );
+    terminate_call ( session, call );
     return 1;
 }
 
@@ -1128,26 +1282,40 @@ int handle_recv_error ( MSISession *session, MSIMessage *msg )
  */
 void msi_handle_packet ( Messenger *messenger, int source, uint8_t *data, uint16_t length, void *object )
 {
+    LOGGER_DEBUG("Got msi message");
     /* Unused */
     (void)messenger;
 
     MSISession *_session = object;
     MSIMessage *_msg;
 
-    if ( !length ) return;
+    if ( !length ) { 
+        LOGGER_WARNING("Lenght param negative");
+        return;
+    }
 
     _msg = parse_message ( data, length );
 
-    if ( !_msg ) return;
+    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 ) goto free_end;
+        if ( _msg->response.size > 32 ) { 
+            LOGGER_WARNING("Header size too big");
+            goto free_end;
+        }
         
         uint8_t _request_value[32];
         
@@ -1155,26 +1323,30 @@ void msi_handle_packet ( Messenger *messenger, int source, uint8_t *data, uint16
         _request_value[_msg->request.size] = '\0';
 
         if ( same ( _request_value, stringify_request ( invite ) ) ) {
-            handle_recv_invite ( _session, _msg );
+            handle_recv_invite ( _session, _call, _msg );
 
         } else if ( same ( _request_value, stringify_request ( start ) ) ) {
-            handle_recv_start ( _session, _msg );
+            handle_recv_start ( _session, _call, _msg );
 
         } else if ( same ( _request_value, stringify_request ( cancel ) ) ) {
-            handle_recv_cancel ( _session, _msg );
+            handle_recv_cancel ( _session, _call, _msg );
 
         } else if ( same ( _request_value, stringify_request ( reject ) ) ) {
-            handle_recv_reject ( _session, _msg );
+            handle_recv_reject ( _session, _call, _msg );
 
         } else if ( same ( _request_value, stringify_request ( end ) ) ) {
-            handle_recv_end ( _session, _msg );
+            handle_recv_end ( _session, _call, _msg );
+        } else { 
+            LOGGER_WARNING("Uknown request");
+            goto free_end;
         }
 
-        else goto free_end;
-
     } else if ( _msg->response.header_value ) { /* Handle response */
         
-        if ( _msg->response.size > 32 ) goto free_end;
+        if ( _msg->response.size > 32 ) { 
+            LOGGER_WARNING("Header size too big");
+            goto free_end;
+        }
         
         uint8_t _response_value[32];
         
@@ -1182,23 +1354,28 @@ void msi_handle_packet ( Messenger *messenger, int source, uint8_t *data, uint16
         _response_value[_msg->response.size] = '\0';
         
         if ( same ( _response_value, stringify_response ( ringing ) ) ) {
-            handle_recv_ringing ( _session, _msg );
+            handle_recv_ringing ( _session, _call, _msg );
 
         } else if ( same ( _response_value, stringify_response ( starting ) ) ) {
-            handle_recv_starting ( _session, _msg );
+            handle_recv_starting ( _session, _call, _msg );
 
         } else if ( same ( _response_value, stringify_response ( ending ) ) ) {
-            handle_recv_ending ( _session, _msg );
+            handle_recv_ending ( _session, _call, _msg );
 
         } else if ( same ( _response_value, stringify_response ( error ) ) ) {
-            handle_recv_error ( _session, _msg );
+            handle_recv_error ( _session, _call, _msg );
             
-        } else goto free_end;
+        } else {
+            LOGGER_WARNING("Uknown response");
+            goto free_end;
+        }
 
         /* Got response so cancel timer */
-        if ( _session->call )
-            event.timer_release ( _session->call->request_timer_id );
+        if ( _call )
+            event.timer_release ( _call->request_timer_id );
 
+    } else {
+        LOGGER_WARNING("Invalid message: no resp nor requ headers");
     }
 
     free_end:free_message ( _msg );
@@ -1248,21 +1425,31 @@ void msi_register_callback ( MSICallback callback, MSICallbackID id, void* userd
  * @brief Start the control session.
  *
  * @param messenger Tox* object.
- * @param user_agent User agent, i.e. 'Venom'; 'QT-gui'
+ * @param max_calls Amount of calls possible
  * @return MSISession* The created session.
  * @retval NULL Error occured.
  */
-MSISession *msi_init_session ( Messenger* messenger )
+MSISession *msi_init_session ( Messenger* messenger, uint32_t max_calls )
 {
-    assert ( messenger );
+    if (messenger == NULL) {
+        LOGGER_ERROR("Could not init session on empty messenger!");
+        return NULL;
+    }
 
+    if ( !max_calls) return NULL;
+    
     MSISession *_retu = calloc ( sizeof ( MSISession ), 1 );
-    assert ( _retu );
+    
+    if (_retu == NULL) {
+        LOGGER_ERROR("Allocation failed!");
+        return NULL;        
+    }
 
     _retu->messenger_handle = messenger;
     _retu->agent_handler = NULL;
 
-    _retu->call = NULL;
+    _retu->calls = calloc( sizeof (MSICall*), max_calls );
+    _retu->max_calls = max_calls;
 
     _retu->frequ = 10000; /* default value? */
     _retu->call_timeout = 30000; /* default value? */
@@ -1272,7 +1459,8 @@ MSISession *msi_init_session ( Messenger* messenger )
 
     /* This is called when remote terminates session */
     m_callback_connectionstatus_internal_av(messenger, handle_remote_connection_change, _retu);
-
+    
+    LOGGER_DEBUG("New msi session: %p max calls: %u", _retu, max_calls);
     return _retu;
 }
 
@@ -1285,16 +1473,20 @@ MSISession *msi_init_session ( Messenger* messenger )
  */
 int msi_terminate_session ( MSISession *session )
 {
-    assert ( session );
+    if (session == NULL) {
+        LOGGER_ERROR("Tried to terminate non-existing session");
+        return -1;
+    }
 
     int _status = 0;
     
-    /* If have call, cancel it */
-    if ( session->call ) { 
+    /* 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->call->peer_count; _it++ )
-            msi_cancel ( session, session->call->peers [_it], "MSI session terminated!" );
+        for ( ; _it < session->calls[idx]->peer_count; _it++ )
+            msi_cancel ( session, idx, session->calls[idx]->peers [_it], "MSI session terminated!" );
     }
     
     m_callback_msi_packet((struct Messenger *) session->messenger_handle, NULL, NULL);
@@ -1313,35 +1505,39 @@ int msi_terminate_session ( MSISession *session )
  * @param friend_id The friend.
  * @return int
  */
-int msi_invite ( MSISession *session, MSICallType call_type, uint32_t rngsec, uint32_t friend_id )
+int msi_invite ( MSISession* session, uint32_t* call_index, MSICallType call_type, uint32_t rngsec, uint32_t friend_id )
 {
-    assert ( session );
-
+    LOGGER_DEBUG("Inviting friend: %u", friend_id);
+    
     MSIMessage *_msg_invite = msi_new_message ( TYPE_REQUEST, stringify_request ( invite ) );
+    
+    MSICall* _call = init_call ( session, 1, rngsec ); /* Just one for now */
+    if ( !_call ) return -1; /* Cannot handle more calls */
+    
+    *call_index = _call->call_idx;
+    
+    t_randomstr ( _call->id, CALL_ID_LEN );
 
-    session->call = init_call ( session, 1, rngsec ); /* Just one for now */
-    t_randomstr ( session->call->id, CALL_ID_LEN );
-
-    add_peer(session->call, friend_id );
+    add_peer(_call, friend_id );
 
-    session->call->type_local = call_type;
+    _call->type_local = call_type;
+    
     /* 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 ) );
+        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 ) );
+        msi_msg_set_calltype ( _msg_invite, ( const uint8_t * ) CT_VIDEO_HEADER_VALUE, strlen ( CT_VIDEO_HEADER_VALUE ) );
     }
 
-    send_message ( session, _msg_invite, friend_id );
+    send_message ( session, _call, _msg_invite, friend_id );
     free_message ( _msg_invite );
 
-    session->call->state = call_inviting;
-
-    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+    _call->state = call_inviting;
 
+    _call->request_timer_id = event.timer_alloc ( handle_timeout, _call, m_deftout );
+    
+    LOGGER_DEBUG("Invite sent");
+    
     return 0;
 }
 
@@ -1350,29 +1546,37 @@ int msi_invite ( MSISession *session, MSICallType call_type, uint32_t rngsec, ui
  * @brief Hangup active call.
  *
  * @param session Control session.
+ * @param call_id To which call is this action handled.
  * @return int
  * @retval -1 Error occured.
  * @retval 0 Success.
  */
-int msi_hangup ( MSISession *session )
+int msi_hangup ( MSISession* session, uint32_t call_index )
 {
-    assert ( session );
-
-    if ( !session->call || session->call->state != call_active )
+    LOGGER_DEBUG("Hanging up call: %u", call_index);
+    
+    if ( call_index >= session->max_calls || !session->calls[call_index] ) {
+        LOGGER_ERROR("Invalid call index!");
+        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!");
         return -1;
+    }
 
     MSIMessage *_msg_end = msi_new_message ( TYPE_REQUEST, stringify_request ( end ) );
 
     /* hangup for each peer */
     int _it = 0;
     
-    for ( ; _it < session->call->peer_count; _it ++ ) 
-        send_message ( session, _msg_end, session->call->peers[_it] );
+    for ( ; _it < session->calls[call_index]->peer_count; _it ++ ) 
+        send_message ( session, session->calls[call_index], _msg_end, session->calls[call_index]->peers[_it] );
     
 
     free_message ( _msg_end );
 
-    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+    session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index], m_deftout );
     
     return 0;
 }
@@ -1382,15 +1586,22 @@ int msi_hangup ( MSISession *session )
  * @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, MSICallType call_type )
+int msi_answer ( MSISession* session, uint32_t call_index, MSICallType call_type )
 {
-    assert ( session );
-
+    LOGGER_DEBUG("Answering call: %u", call_index);
+    
+    if ( call_index >= session->max_calls || !session->calls[call_index] ){
+        LOGGER_ERROR("Invalid call index!");
+        return -1;
+    }
+    
     MSIMessage *_msg_starting = msi_new_message ( TYPE_RESPONSE, stringify_response ( starting ) );
-    session->call->type_local = call_type;
+    
+    session->calls[call_index]->type_local = call_type;
 
     if ( call_type == type_audio ) {
         msi_msg_set_calltype
@@ -1402,19 +1613,19 @@ int msi_answer ( MSISession *session, MSICallType call_type )
 
     /* Now set the local encryption key and pass it with STARTING message */
 
-    session->call->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
-    new_symmetric_key ( session->call->key_local );
+    session->calls[call_index]->key_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_KEYBYTES );
+    new_symmetric_key ( session->calls[call_index]->key_local );
 
-    session->call->nonce_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
-    new_nonce ( session->call->nonce_local );
+    session->calls[call_index]->nonce_local = calloc ( sizeof ( uint8_t ), crypto_secretbox_NONCEBYTES );
+    new_nonce ( session->calls[call_index]->nonce_local );
 
-    msi_msg_set_cryptokey ( _msg_starting, session->call->key_local, crypto_secretbox_KEYBYTES );
-    msi_msg_set_nonce ( _msg_starting, session->call->nonce_local, crypto_secretbox_NONCEBYTES );
+    msi_msg_set_cryptokey ( _msg_starting, session->calls[call_index]->key_local, crypto_secretbox_KEYBYTES );
+    msi_msg_set_nonce ( _msg_starting, session->calls[call_index]->nonce_local, crypto_secretbox_NONCEBYTES );
 
-    send_message ( session, _msg_starting, session->call->peers[session->call->peer_count - 1] );
+    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->call->state = call_active;
+    session->calls[call_index]->state = call_active;
 
     return 0;
 }
@@ -1424,21 +1635,27 @@ int msi_answer ( MSISession *session, MSICallType call_type )
  * @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, uint32_t peer, const char *reason )
+int msi_cancel ( MSISession *session, uint32_t call_index, uint32_t peer, const char *reason )
 {
-    assert ( session );
-
+    LOGGER_DEBUG("Canceling call: %u; reason:", call_index, reason? reason : "Unknown");
+    
+    if ( call_index >= session->max_calls || !session->calls[call_index] ){
+        LOGGER_ERROR("Invalid call index!");
+        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, _msg_cancel, peer );
+    send_message ( session, session->calls[call_index], _msg_cancel, peer );
     free_message ( _msg_cancel );
     
-    session->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+    session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index], m_deftout );
     
     return 0;
 }
@@ -1448,20 +1665,26 @@ int msi_cancel ( MSISession *session, uint32_t peer, const char *reason )
  * @brief Reject request.
  *
  * @param session Control session.
+ * @param call_id To which call is this action handled.
  * @return int
  */
-int msi_reject ( MSISession *session, const uint8_t *reason )
+int msi_reject ( MSISession *session, uint32_t call_index, const uint8_t *reason )
 {
-    assert ( session );
-
+    LOGGER_DEBUG("Rejecting call: %u; reason:", call_index, reason? (char*)reason : "Unknown");
+    
+    if ( call_index >= session->max_calls || !session->calls[call_index] ){
+        LOGGER_ERROR("Invalid call index!");
+        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, _msg_reject, session->call->peers[session->call->peer_count - 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->call->request_timer_id = event.timer_alloc ( handle_timeout, session, m_deftout );
+    session->calls[call_index]->request_timer_id = event.timer_alloc ( handle_timeout, session->calls[call_index], m_deftout );
 
     return 0;
 }
@@ -1471,18 +1694,19 @@ int msi_reject ( MSISession *session, const uint8_t *reason )
  * @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 )
+int msi_stopcall ( MSISession *session, uint32_t call_index )
 {
-    assert ( session );
-
-    if ( !session->call )
+    LOGGER_DEBUG("Stopping call index: %u", call_index);
+    
+    if ( call_index >= session->max_calls || !session->calls[call_index] )
         return -1;
 
     /* just terminate it */
 
-    terminate_call ( session );
+    terminate_call ( session, session->calls[call_index] );
 
     return 0;
 }
\ No newline at end of file