3 files changed, 437 insertions, 471 deletions

diff --git a/toxav/msi.c b/toxav/msi.c
index c1342950..cc855613 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -33,9 +33,11 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <assert.h>
 
 #define MSI_MAXMSG_SIZE 256
 
+/* TODO send error on any calloc or etc */
 
 /**
  * Protocol:
@@ -63,14 +65,13 @@ typedef enum {
 typedef enum {
     resp_ringing,
     resp_starting,
-    resp_error,
 } MSIResponse;
 
 
 #define GENERIC_HEADER(header, val_type) \
 typedef struct { \
-val_type value; \
-bool exists; \
+    val_type value; \
+    bool exists; \
 } MSIHeader##header
 
 
@@ -92,7 +93,207 @@ typedef struct {
 } MSIMessage;
 
 
-static int parse_input ( MSIMessage *dest, const uint8_t *data, uint16_t length )
+int msg_parse_in ( MSIMessage *dest, const uint8_t *data, uint16_t length );
+uint8_t *msg_parse_header_out ( MSIHeaderID id, uint8_t *dest, const void *value, uint8_t value_len, uint16_t *length );
+int send_message ( Messenger* m, uint32_t friend_id, const MSIMessage *msg );
+int send_error ( Messenger* m, uint32_t friend_id, MSIError error );
+static void invoke_callback(MSICall* call, MSICallbackID cb);
+static MSICall *get_call ( MSISession *session, uint32_t friend_id );
+MSICall *new_call ( MSISession *session, uint32_t friend_id );
+void kill_call ( MSICall *call );
+void on_peer_status(Messenger *m, int friend_id, uint8_t status, void *data);
+int handle_recv_invite ( MSICall *call, const MSIMessage *msg );
+int handle_recv_start ( MSICall *call, const MSIMessage *msg );
+int handle_recv_reject ( MSICall *call, const MSIMessage *msg );
+int handle_recv_end ( MSICall *call, const MSIMessage *msg );
+int handle_recv_ringing ( MSICall *call, const MSIMessage *msg );
+int handle_recv_starting ( MSICall *call, const MSIMessage *msg );
+int handle_recv_error ( MSICall *call, const MSIMessage *msg );
+void handle_msi_packet ( Messenger *m, int friend_id, const uint8_t *data, uint16_t length, void *object );
+
+
+/**
+ * Public functions
+ */
+void msi_register_callback ( MSISession *session, MSICallbackType callback, MSICallbackID id)
+{
+    session->callbacks[id] = callback;
+}
+MSISession *msi_new ( Messenger *messenger )
+{
+    if (messenger == NULL) {
+        LOGGER_ERROR("Could not init session on empty messenger!");
+        return NULL;
+    }
+    
+    MSISession *retu = calloc ( sizeof ( MSISession ), 1 );
+    
+    if (retu == NULL) {
+        LOGGER_ERROR("Allocation failed! Program might misbehave!");
+        return NULL;
+    }
+    
+    if (create_recursive_mutex(retu->mutex) != 0) {
+        LOGGER_ERROR("Failed to init mutex! Program might misbehave");
+        free(retu);
+        return NULL;
+    }
+    
+    retu->messenger = messenger;
+    
+    m_callback_msi_packet(messenger, handle_msi_packet, retu );
+    
+    /* This is called when remote terminates session */
+    m_callback_connectionstatus_internal_av(messenger, on_peer_status, retu);
+    
+    LOGGER_DEBUG("New msi session: %p ", retu);
+    return retu;
+}
+int msi_kill ( MSISession *session )
+{
+    if (session == NULL) {
+        LOGGER_ERROR("Tried to terminate non-existing session");
+        return -1;
+    }
+    
+    m_callback_msi_packet((struct Messenger *) session->messenger, NULL, NULL);
+    pthread_mutex_lock(session->mutex);
+    
+    if (session->calls) {
+        MSIMessage msg_end;
+        msg_end.request.exists = true;
+        msg_end.request.value = requ_end;
+        
+        MSICall* it = get_call(session, session->calls_head);
+        for (; it; it = it->next) {
+            send_message(session->messenger, it->friend_id, &msg_end);
+            kill_call(it); /* This will eventually free session->calls */
+        }
+    }
+    
+    pthread_mutex_unlock(session->mutex);
+    pthread_mutex_destroy(session->mutex);
+    
+    LOGGER_DEBUG("Terminated session: %p", session);
+    free ( session );
+    return 0;
+}
+int msi_invite ( MSISession *session, MSICall **call, uint32_t friend_id, uint8_t capabilities )
+{
+    LOGGER_DEBUG("Session: %p Inviting friend: %u", session, friend_id);
+    
+    if (get_call(session, friend_id) != NULL) {
+        LOGGER_ERROR("Already in a call");
+        return -1;
+    }
+    
+    (*call) = new_call ( session, friend_id );
+    
+    if ( *call == NULL )
+        return -1;
+    
+    (*call)->self_capabilities = capabilities;
+    
+    MSIMessage msg_invite;
+    msg_invite.request.exists = true;
+    msg_invite.request.value = requ_invite;
+    
+    msg_invite.capabilities.exists = true;
+    msg_invite.capabilities.value = capabilities;
+    
+    msg_invite.mvfsz.exists = true;
+    msg_invite.mvfsz.value = htons(D_MVFSZ);
+    
+    msg_invite.mvfpsz.exists = true;
+    msg_invite.mvfpsz.value = htons(D_MVFPSZ);
+    
+    send_message ( (*call)->session->messenger, (*call)->friend_id, &msg_invite );
+    
+    (*call)->state = msi_CallRequesting;
+    
+    LOGGER_DEBUG("Invite sent");
+    return 0;
+}
+int msi_hangup ( MSICall* call )
+{
+    LOGGER_DEBUG("Session: %p Hanging up call: %u", session, call_index);
+    
+    MSIMessage msg_end;
+    msg_end.request.exists = true;
+    msg_end.request.value = requ_end;
+    send_message ( call->session->messenger, call->friend_id, &msg_end );
+    
+    kill_call(call);
+    return 0;
+}
+int msi_answer ( MSICall* call, uint8_t capabilities )
+{
+    LOGGER_DEBUG("Session: %p Answering call from: %u", call->session, call->friend_id);
+    
+    if ( call->state != msi_CallRequested ) {
+        LOGGER_ERROR("Call is in invalid state!");
+        return -1;
+    }
+    
+    call->self_capabilities = capabilities;
+    
+    MSIMessage msg_starting;
+    msg_starting.response.exists = true;
+    msg_starting.response.value = resp_starting;
+    
+    msg_starting.capabilities.exists = true;
+    msg_starting.capabilities.value = capabilities;
+    
+    msg_starting.mvfsz.exists = true;
+    msg_starting.mvfsz.value = htons(D_MVFSZ);
+    
+    msg_starting.mvfpsz.exists = true;
+    msg_starting.mvfpsz.value = htons(D_MVFPSZ);
+    
+    send_message ( call->session->messenger, call->friend_id, &msg_starting );
+    
+    return 0;
+}
+int msi_reject ( MSICall* call )
+{
+    LOGGER_DEBUG("Session: %p Rejecting call: %u; reason: %s", session, call_index, reason ? reason : "Unknown");
+    
+    if ( call->state != msi_CallRequested ) {
+        LOGGER_ERROR("Call is in invalid state!");
+        return -1;
+    }
+    
+    MSIMessage msg_reject;
+    msg_reject.request.exists = true;
+    msg_reject.request.value = requ_reject;
+    
+    send_message ( call->session->messenger, call->friend_id, &msg_reject );
+    
+    return 0;
+}
+int msi_change_csettings( MSICall* call, uint8_t capabilities )
+{
+    call->self_capabilities = capabilities;
+    
+    MSIMessage msg_invite;
+    msg_invite.request.exists = true;
+    msg_invite.request.value = requ_invite;
+    
+    msg_invite.capabilities.exists = true;
+    msg_invite.capabilities.value = capabilities;
+    
+    send_message ( call->session->messenger, call->friend_id, &msg_invite );
+    
+    return 0;
+}
+
+
+
+/**
+ * Private functions
+ */
+
+int msg_parse_in ( MSIMessage *dest, const uint8_t *data, uint16_t length )
 {
     /* Parse raw data received from socket into MSIMessage struct */
     
@@ -116,10 +317,7 @@ static int parse_input ( MSIMessage *dest, const uint8_t *data, uint16_t length
     } while(0)
     
     
-    if ( dest == NULL ) {
-        LOGGER_ERROR("Could not parse message: no storage!");
-        return -1;
-    }
+    assert(dest);
 
     if ( length == 0 || data[length - 1] ) { /* End byte must have value 0 */
         LOGGER_ERROR("Invalid end byte");
@@ -139,7 +337,7 @@ static int parse_input ( MSIMessage *dest, const uint8_t *data, uint16_t length
                 
             case IDResponse:
                 CHECK_SIZE(it, size_constraint, 1);
-                CHECK_ENUM_HIGH(it, resp_error);
+                CHECK_ENUM_HIGH(it, resp_starting);
                 SET_UINT8(it, dest->response);
                 it += 3;
                 break;
@@ -179,22 +377,13 @@ static int parse_input ( MSIMessage *dest, const uint8_t *data, uint16_t length
 #undef SET_UINT8
 #undef SET_UINT16
 }
-
-static uint8_t *parse_header ( MSIHeaderID id, uint8_t *dest, const void *value, 
-                               uint8_t value_len, uint16_t *length )
+uint8_t *msg_parse_header_out ( MSIHeaderID id, uint8_t *dest, const void *value, uint8_t value_len, uint16_t *length )
 {
     /* Parse a single header for sending */
+    assert(dest);
+    assert(value);
+    assert(value_len);
     
-    if ( dest == NULL ) {
-        LOGGER_ERROR("No destination space!");
-        return NULL;
-    }
-
-    if (value == NULL || value_len == 0) {
-        LOGGER_ERROR("Empty header value");
-        return NULL;
-    }
-
     *dest = id;
     dest ++;
     *dest = value_len;
@@ -206,20 +395,10 @@ static uint8_t *parse_header ( MSIHeaderID id, uint8_t *dest, const void *value,
 
     return dest + value_len; /* Set to next position ready to be written */
 }
-
-
-
-static void call_invoke_callback(MSICall* call, MSICallbackID cb)
-{
-    if ( call->session->callbacks[cb] ) {
-        LOGGER_DEBUG("Invoking callback function: %d", cb);
-        call->session->callbacks[cb] ( call->session->agent_handler, call );
-    }
-}
-
-static int call_send_message ( MSICall *call, const MSIMessage *msg )
+int send_message ( Messenger* m, uint32_t friend_id, const MSIMessage *msg )
 {
     /* Parse and send message */
+    assert(m);
     
     uint8_t parsed [MSI_MAXMSG_SIZE];
 
@@ -228,33 +407,33 @@ static int call_send_message ( MSICall *call, const MSIMessage *msg )
     
     if (msg->request.exists) {
         uint8_t cast = msg->request.value;
-        it = parse_header(IDRequest, it, &cast, 
+        it = msg_parse_header_out(IDRequest, it, &cast, 
                           sizeof(cast), &size);
     }
     
     if (msg->response.exists) {
         uint8_t cast = msg->response.value;
-        it = parse_header(IDResponse, it, &cast, 
+        it = msg_parse_header_out(IDResponse, it, &cast, 
                           sizeof(cast), &size);
     }
     
     if (msg->error.exists) {
-        it = parse_header(IDError, it, &msg->error.value, 
+        it = msg_parse_header_out(IDError, it, &msg->error.value, 
                           sizeof(msg->error.value), &size);
     }
     
     if (msg->capabilities.exists) {
-        it = parse_header(IDCapabilities, it, &msg->capabilities.value, 
+        it = msg_parse_header_out(IDCapabilities, it, &msg->capabilities.value, 
                           sizeof(msg->capabilities.value), &size);
     }
     
     if (msg->mvfsz.exists) {
-        it = parse_header(IDMVFSZ, it, &msg->mvfsz.value,
+        it = msg_parse_header_out(IDMVFSZ, it, &msg->mvfsz.value,
                           sizeof(msg->mvfsz.value), &size);
     }
     
     if (msg->mvfpsz.exists) {
-        it = parse_header(IDMVFPSZ, it, &msg->mvfpsz.value,
+        it = msg_parse_header_out(IDMVFPSZ, it, &msg->mvfpsz.value,
                           sizeof(msg->mvfpsz.value), &size);
     }
     
@@ -266,47 +445,50 @@ static int call_send_message ( MSICall *call, const MSIMessage *msg )
         return -1;
     }
     
-    if ( m_msi_packet(call->session->messenger_handle, call->friend_id, parsed, size) ) {
+    if ( m_msi_packet(m, friend_id, parsed, size) ) {
         LOGGER_DEBUG("Sent message");
         return 0;
     }
 
     return -1;
 }
-
-static int call_send_error ( MSICall *call, MSIError error )
+int send_error ( Messenger* m, uint32_t friend_id, MSIError error )
 {
     /* Send error message */
+    assert(m);
     
-    if (!call) {
-        LOGGER_WARNING("Cannot handle error on 'null' call");
-        return -1;
-    }
-
-    LOGGER_DEBUG("Sending error: %d to friend: %d", error, call->friend_id);
+    LOGGER_DEBUG("Sending error: %d to friend: %d", error, friend_id);
 
     MSIMessage msg_error;
-    msg_error.response.exists = true;
-    msg_error.response.value = resp_error;
     
     msg_error.error.exists = true;
     msg_error.error.value = error;
     
-    call_send_message ( call, &msg_error );
+    send_message ( m, friend_id, &msg_error );
     return 0;
 }
-
-
+static void invoke_callback(MSICall* call, MSICallbackID cb)
+{
+    assert(call);
+    
+    if ( call->session->callbacks[cb] ) {
+        LOGGER_DEBUG("Invoking callback function: %d", cb);
+        call->session->callbacks[cb] ( call->session->av, call );
+    }
+}
 static MSICall *get_call ( MSISession *session, uint32_t friend_id )
 {
+    assert(session);
+    
     if (session->calls == NULL || session->calls_tail < friend_id)
         return NULL;
     
     return session->calls[friend_id];
 }
-
-static MSICall *new_call ( MSISession *session, uint32_t friend_id )
+MSICall *new_call ( MSISession *session, uint32_t friend_id )
 {
+    assert(session);
+    
     MSICall *rc = calloc(sizeof(MSICall), 1);
     
     if (rc == NULL)
@@ -353,8 +535,7 @@ static MSICall *new_call ( MSISession *session, uint32_t friend_id )
     session->calls[friend_id] = rc;
     return rc;
 }
-
-static void kill_call ( MSICall *call )
+void kill_call ( MSICall *call )
 {
     if ( call == NULL )
         return;
@@ -386,22 +567,21 @@ CLEAR:
     session->calls = NULL;
     free(call);
 }
-
-
-
-static void on_remote_connection_change(Messenger *messenger, int friend_id, uint8_t status, void *session_p)
+void on_peer_status(Messenger *m, int friend_id, uint8_t status, void *data)
 {
-    (void)messenger;
-    MSISession *session = session_p;
+    (void)m;
+    MSISession *session = data;
 
     switch ( status ) {
-        case 0: { /* Went offline */
+        case 0: { /* Friend is now offline */
+            LOGGER_DEBUG("Friend %d is now offline", friend_id);
+            
             MSICall* call = get_call(session, friend_id);
             
             if (call == NULL)
                 return;
             
-            call_invoke_callback(call, msi_OnPeerTimeout);
+            invoke_callback(call, msi_OnPeerTimeout);
             kill_call(call);
         }
         break;
@@ -410,16 +590,9 @@ static void on_remote_connection_change(Messenger *messenger, int friend_id, uin
             break;
     }
 }
-
-
-
-/********** Request handlers **********/
-static int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
+int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'invite' on no call");
-        return -1;
-    }
+    assert(call);
     
     MSISession* session = call->session;
     
@@ -427,19 +600,7 @@ static int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
 
     if (!msg->capabilities.exists) {
         LOGGER_WARNING("Session: %p Invalid capabilities on 'invite'");
-        /* TODO send error */
-        return -1;
-    }
-    
-    if (!msg->mvfsz.exists) {
-        LOGGER_WARNING("Session: %p Invalid mvfsz on 'invite'");
-        /* TODO send error */
-        return -1;
-    }
-    
-    if (!msg->mvfpsz.exists) {
-        LOGGER_WARNING("Session: %p Invalid mvfpsz on 'invite'");
-        /* TODO send error */
+        call->error = msi_InvalidMessage;
         return -1;
     }
     
@@ -456,14 +617,32 @@ static int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
         
         LOGGER_DEBUG("Glare detected!");
         
-        call->peer_capabilities = msg->capabilities;
+        if (!msg->mvfsz.exists) {
+            LOGGER_WARNING("Session: %p Invalid mvfsz on 'invite'");
+            call->error = msi_InvalidMessage;
+            return -1;
+        }
+        
+        if (!msg->mvfpsz.exists) {
+            LOGGER_WARNING("Session: %p Invalid mvfpsz on 'invite'");
+            call->error = msi_InvalidMessage;
+            return -1;
+        }
+        
+        call->peer_capabilities = msg->capabilities.value;
         
         call->peer_mvfsz = ntohs(msg->mvfsz.value);
         call->peer_mvfpsz = ntohs(msg->mvfpsz.value);
         
+        if (call->peer_mvfsz > call->peer_mvfpsz) {
+            LOGGER_WARNING("Session: %p mvfsz param greater than mvfpsz on 'invite'");
+            call->error = msi_InvalidParam;
+            return -1;
+        }
+        
         /* Send response */
         response.response.value = resp_starting;
-        call_send_message ( call, &response );
+        send_message ( call->session->messenger, call->friend_id, &response );
         
         return 0;
     } else if ( call->state == msi_CallActive ) {
@@ -473,21 +652,33 @@ static int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
          */
         LOGGER_DEBUG("Peer is changing capabilities");
         
-        call->peer_capabilities = msg->capabilities;
-        
-        call->peer_mvfsz = ntohs(msg->mvfsz.value);
-        call->peer_mvfpsz = ntohs(msg->mvfpsz.value);
-        
         /* Send response */
         response.response.value = resp_starting;
-        call_send_message ( call, &response );
+        send_message ( call->session->messenger, call->friend_id, &response );
         
+        if ( call->peer_capabilities != msg->capabilities.value) {
+            /* Only invoke callback if capabilities changed */
+            call->peer_capabilities = msg->capabilities.value;
+            invoke_callback(call, msi_OnCapabilities);
+        }
         
-        call_invoke_callback(call, msi_OnCapabilities);
         return 0;
     }
     
-    call->peer_capabilities = msg->capabilities;
+    
+    if (!msg->mvfsz.exists) {
+        LOGGER_WARNING("Session: %p Invalid mvfsz on 'invite'");
+        call->error = msi_InvalidMessage;
+        return -1;
+    }
+    
+    if (!msg->mvfpsz.exists) {
+        LOGGER_WARNING("Session: %p Invalid mvfpsz on 'invite'");
+        call->error = msi_InvalidMessage;
+        return -1;
+    }
+    
+    call->peer_capabilities = msg->capabilities.value;
     
     call->peer_mvfsz = ntohs(msg->mvfsz.value);
     call->peer_mvfpsz = ntohs(msg->mvfpsz.value);
@@ -496,23 +687,19 @@ static int handle_recv_invite ( MSICall *call, const MSIMessage *msg )
     
     /* Send response */
     response.response.value = resp_ringing;
-    call_send_message ( call, &response );
+    send_message ( call->session->messenger, call->friend_id, &response );
     
     
-    call_invoke_callback(call, msi_OnInvite);
+    invoke_callback(call, msi_OnInvite);
     return 0;
 }
-
-static int handle_recv_start ( MSICall *call, const MSIMessage *msg )
+int handle_recv_start ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-        return -1;
-    }
+    assert(call);
     
     if ( call->state != msi_CallRequested || call->state != msi_CallRequesting ) {
         LOGGER_WARNING("Session: %p Invalid call state on 'start'");
-        /* TODO send error */
+        call->error = msi_InvalidState;
         return -1;
     }
     
@@ -521,105 +708,88 @@ static int handle_recv_start ( MSICall *call, const MSIMessage *msg )
     LOGGER_DEBUG("Session: %p Handling 'start', friend id: %d", call->session, call->friend_id );
 
     call->state = msi_CallActive;
-    call_invoke_callback(call, msi_OnStart);
+    invoke_callback(call, msi_OnStart);
     
     return 0;
 }
-
-static int handle_recv_reject ( MSICall *call, const MSIMessage *msg )
+int handle_recv_reject ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-        return -1;
-    }
+    assert(call);
     
     (void)msg;
     
     if ( call->state != msi_CallRequesting ) {
         LOGGER_WARNING("Session: %p Invalid call state on 'reject'");
-        /* TODO send error */
+        call->error = msi_InvalidState;
         return -1;
     }
     
     LOGGER_DEBUG("Session: %p Handling 'reject', friend id: %u", call->session, call->friend_id);
 
-    call_invoke_callback(call, msi_OnReject);
+    invoke_callback(call, msi_OnReject);
     kill_call(call);
 
     return 0;
 }
-
-static int handle_recv_end ( MSICall *call, const MSIMessage *msg )
+int handle_recv_end ( MSICall *call, const MSIMessage *msg )
 {
-    (void)msg;
+    assert(call);
     
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-        return -1;
-    }
+    (void)msg;
 
     LOGGER_DEBUG("Session: %p Handling 'end', friend id: %d", call->session, call->friend_id);
 
-    call_invoke_callback(call, msi_OnEnd);
+    invoke_callback(call, msi_OnEnd);
     kill_call ( call );
 
     return 0;
 }
-
-/********** Response handlers **********/
-static int handle_recv_ringing ( MSICall *call, const MSIMessage *msg )
+int handle_recv_ringing ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'start' on no call");
-        return -1;
-    }
+    assert(call);
 
     (void)msg;
     
     if ( call->state != msi_CallRequesting ) {
         LOGGER_WARNING("Session: %p Invalid call state on 'ringing'");
-        /* TODO send error */
+        call->error = msi_InvalidState;
         return -1;
     }
 
     LOGGER_DEBUG("Session: %p Handling 'ringing' friend id: %d", call->session, call->friend_id );
 
-    call_invoke_callback(call, msi_OnRinging);
+    invoke_callback(call, msi_OnRinging);
     return 0;
 }
-
-static int handle_recv_starting ( MSICall *call, const MSIMessage *msg )
+int handle_recv_starting ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Session: %p Handling 'starting' on non-existing call");
-        return 0;
-    }
+    assert(call);
     
     if ( call->state == msi_CallActive ) {
         LOGGER_DEBUG("Capabilities change confirmed");
         return 0;
     } else if ( call->state != msi_CallRequested || call->state != msi_CallRequesting ) {
         LOGGER_WARNING("Session: %p Invalid call state on 'starting'");
-        /* TODO send error */
+        call->error = msi_InvalidState;
         return -1;
     }
     
     if (call->state == msi_CallRequesting) {
         if (!msg->capabilities.exists) {
             LOGGER_WARNING("Session: %p Invalid capabilities on 'starting'");
-            /* TODO send error */
+            call->error = msi_InvalidParam;
             return -1;
         }
         
         if (!msg->mvfsz.exists) {
             LOGGER_WARNING("Session: %p Invalid mvfsz on 'invite'");
-            /* TODO send error */
+            call->error = msi_InvalidParam;
             return -1;
         }
         
         if (!msg->mvfpsz.exists) {
             LOGGER_WARNING("Session: %p Invalid mvfpsz on 'invite'");
-            /* TODO send error */
+            call->error = msi_InvalidParam;
             return -1;
         }
         
@@ -628,8 +798,15 @@ static int handle_recv_starting ( MSICall *call, const MSIMessage *msg )
         call->peer_mvfsz = ntohs(msg->mvfsz.value);
         call->peer_mvfpsz = ntohs(msg->mvfpsz.value);
         
+        
+        if (call->peer_mvfsz > call->peer_mvfpsz) {
+            LOGGER_WARNING("Session: %p mvfsz param greater than mvfpsz on 'invite'");
+            call->error = msi_InvalidParam;
+            return -1;
+        }
+        
         call->state = msi_CallActive;
-        call_invoke_callback(call, msi_OnStart);
+        invoke_callback(call, msi_OnStart);
     }
     /* Otherwise it's a glare case so don't start until 'start' is recved */
     
@@ -637,65 +814,55 @@ static int handle_recv_starting ( MSICall *call, const MSIMessage *msg )
     MSIMessage msg_start;
     msg_start.request.exists = true;
     msg_start.request.value = requ_start;
-    call_send_message ( call, &msg_start );
+    send_message ( call->session->messenger, call->friend_id, &msg_start );
     
     return 0;
 }
-
-static int handle_recv_error ( MSICall *call, const MSIMessage *msg )
+int handle_recv_error ( MSICall *call, const MSIMessage *msg )
 {
-    if ( call == NULL ) {
-        LOGGER_WARNING("Handling 'error' on non-existing call!");
-        return -1;
-    }
+    assert(call);
 
     LOGGER_DEBUG("Session: %p Handling 'error' friend id: %d", call->session, call->friend_id );
+    
+    call->error = msg->error.value;
+    invoke_callback(call, msi_OnError);
 
-    call_invoke_callback(call, msi_OnError);
-
-    /* TODO Handle error accordingly */
-
-    return -1;
+    return 0;
 }
-
-static void handle_msi_packet ( Messenger *messenger, int friend_id, const uint8_t *data, 
-                                uint16_t length, void *object )
+void handle_msi_packet ( Messenger *m, int friend_id, const uint8_t *data, uint16_t length, void *object )
 {
     LOGGER_DEBUG("Got msi message");
     
-    /* Unused */
-    (void)messenger;
-
     MSISession *session = object;
     MSIMessage msg;
+    
+    int rc = 0;
 
-    if ( parse_input ( &msg, data, length ) == -1 ) {
+    if ( msg_parse_in ( &msg, data, length ) == -1 ) {
         LOGGER_WARNING("Error parsing message");
+        send_error(m, friend_id, msi_InvalidMessage);
         return;
     } else {
         LOGGER_DEBUG("Successfully parsed message");
     }
     
-    pthread_mutex_lock(session->mutex);
-
     MSICall *call = get_call(session, friend_id);
     
     if (call == NULL) {
-        if (msg.request != requ_invite) {
-            /* TODO send error */
+        if (msg.request.value != requ_invite) {
+            send_error(m, friend_id, msi_StrayMessage);
             return;
         }
         
         call = new_call(session, friend_id);
         if (call == NULL) {
-            /* TODO send error */
+            send_error(m, friend_id, msi_SystemError);
             return;
         }
     }
     
     
     /* Now handle message */
-    int rc = 0;
     if ( msg.request.exists ) { /* Handle request */
         switch (msg.request.value) {
             case requ_invite:
@@ -723,201 +890,21 @@ static void handle_msi_packet ( Messenger *messenger, int friend_id, const uint8
             case resp_starting:
                 rc = handle_recv_starting ( call, &msg );
                 break;
-
-            case resp_error:
-                rc = handle_recv_error ( call, &msg );
-                break;
         }
+    } else if (msg.error.exists) {
+        handle_recv_error ( call, &msg );
+        rc = -1;
     } else {
-        LOGGER_WARNING("Invalid message: no resp nor requ headers");
-        /* TODO send error */
+        LOGGER_WARNING("Invalid message; none of the request, response or error!");
+        call->error = msi_InvalidMessage;
         rc = -1;
     }
     
-    if (rc == -1)
-        kill_call(call);
     
-    pthread_mutex_unlock(session->mutex);
-}
-
-
-
-/********** User functions **********/
-void msi_register_callback ( MSISession *session, MSICallbackType callback, MSICallbackID id)
-{
-    session->callbacks[id] = callback;
-}
-
-MSISession *msi_new ( Messenger *messenger )
-{
-    if (messenger == NULL) {
-        LOGGER_ERROR("Could not init session on empty messenger!");
-        return NULL;
-    }
-
-    MSISession *retu = calloc ( sizeof ( MSISession ), 1 );
-
-    if (retu == NULL) {
-        LOGGER_ERROR("Allocation failed! Program might misbehave!");
-        return NULL;
-    }
-
-    if (create_recursive_mutex(retu->mutex) != 0) {
-        LOGGER_ERROR("Failed to init mutex! Program might misbehave");
-        free(retu);
-        return NULL;
-    }
-
-    retu->messenger_handle = messenger;
-
-    m_callback_msi_packet(messenger, handle_msi_packet, retu );
-
-    /* This is called when remote terminates session */
-    m_callback_connectionstatus_internal_av(messenger, on_remote_connection_change, retu);
-
-    LOGGER_DEBUG("New msi session: %p ", retu);
-    return retu;
-}
-
-int msi_kill ( MSISession *session )
-{
-    if (session == NULL) {
-        LOGGER_ERROR("Tried to terminate non-existing session");
-        return -1;
-    }
-
-    m_callback_msi_packet((struct Messenger *) session->messenger_handle, NULL, NULL);
-    pthread_mutex_lock(session->mutex);
-
-    if (session->calls) {
-        MSIMessage msg_end;
-        msg_end.request.exists = true;
-        msg_end.request.value = requ_end;
+    if (rc == -1) {
+        if (call->error != msi_ErrorNone)
+            send_error(m, friend_id, call->error);
         
-        MSICall* it = get_call(session, session->calls_head);
-        for (; it; it = it->next) {
-            call_send_message(it, &msg_end);
-            kill_call(it); /* This will eventually free session->calls */
-        }
-    }
-    
-    pthread_mutex_unlock(session->mutex);
-    pthread_mutex_destroy(session->mutex);
-
-    LOGGER_DEBUG("Terminated session: %p", session);
-    free ( session );
-    return 0;
-}
-
-int msi_invite ( MSISession *session, MSICall **call, uint32_t friend_id, uint8_t capabilities )
-{
-    LOGGER_DEBUG("Session: %p Inviting friend: %u", session, friend_id);
-    
-    if (get_call(session, friend_id) != NULL) {
-        LOGGER_ERROR("Already in a call");
-        return -1;
-    }
-    
-    *call = new_call ( session, friend_id );
-
-    if ( *call == NULL )
-        return -1;
-    
-    *call->self_capabilities = capabilities;
-    
-    MSIMessage msg_invite;
-    msg_invite.request.exists = true;
-    msg_invite.request.value = requ_invite;
-    
-    msg_invite.capabilities.exists = true;
-    msg_invite.capabilities.value = capabilities;
-    
-    msg_invite.mvfsz.exists = true;
-    msg_invite.mvfsz.value = htons(D_MVFSZ);
-    
-    msg_invite.mvfpsz.exists = true;
-    msg_invite.mvfpsz.value = htons(D_MVFPSZ);
-    
-    call_send_message ( *call, &msg_invite );
-
-    *call->state = msi_CallRequesting;
-    
-    LOGGER_DEBUG("Invite sent");
-    return 0;
-}
-
-int msi_hangup ( MSICall* call )
-{
-    LOGGER_DEBUG("Session: %p Hanging up call: %u", session, call_index);
-    
-    MSIMessage msg_end;
-    msg_end.request.exists = true;
-    msg_end.request.value = requ_end;
-    call_send_message ( call, &msg_end );
-    
-    kill_call(call);
-    return 0;
-}
-
-int msi_answer ( MSICall* call, uint8_t capabilities )
-{
-    LOGGER_DEBUG("Session: %p Answering call from: %u", call->session, call->friend_id);
-
-    if ( call->state != msi_CallRequested ) {
-        LOGGER_ERROR("Call is in invalid state!");
-        return -1;
-    }
-    
-    call->self_capabilities = capabilities;
-    
-    MSIMessage msg_starting;
-    msg_starting.response.exists = true;
-    msg_starting.response.value = resp_starting;
-    
-    msg_starting.capabilities.exists = true;
-    msg_starting.capabilities.value = capabilities;
-    
-    msg_starting.mvfsz.exists = true;
-    msg_starting.mvfsz.value = htons(D_MVFSZ);
-    
-    msg_starting.mvfpsz.exists = true;
-    msg_starting.mvfpsz.value = htons(D_MVFPSZ);
-    
-    call_send_message ( call, &msg_starting );
-
-    return 0;
-}
-
-int msi_reject ( MSICall* call )
-{
-    LOGGER_DEBUG("Session: %p Rejecting call: %u; reason: %s", session, call_index, reason ? reason : "Unknown");
-
-    if ( call->state != msi_CallRequested ) {
-        LOGGER_ERROR("Call is in invalid state!");
-        return -1;
+        kill_call(call);
     }
-    
-    MSIMessage msg_reject;
-    msg_reject.request.exists = true;
-    msg_reject.request.value = requ_reject;
-    
-    call_send_message ( call, &msg_reject );
-
-    return 0;
 }
-
-int msi_change_csettings( MSICall* call, uint8_t capabilities )
-{
-    call->self_capabilities = capabilities;
-    
-    MSIMessage msg_invite;
-    msg_invite.request.exists = true;
-    msg_invite.request.value = requ_invite;
-    
-    msg_invite.capabilities.exists = true;
-    msg_invite.capabilities.value = capabilities;
-    
-    call_send_message ( *call, &msg_invite );
-    
-    return 0;
-}
\ No newline at end of file
diff --git a/toxav/msi.h b/toxav/msi.h
index a1eb499b..4f27b9f8 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -36,6 +36,12 @@
  * Error codes.
  */
 typedef enum {
+    msi_ErrorNone,
+    msi_InvalidMessage,
+    msi_InvalidParam,
+    msi_InvalidState,
+    msi_StrayMessage,
+    msi_SystemError,
     msi_ErrUndisclosed,
 } MSIError;
 
@@ -69,7 +75,7 @@ typedef enum {
     msi_OnStart, /* Call (RTP transmission) started */
     msi_OnReject, /* The side that was invited rejected the call */
     msi_OnEnd, /* Call that was active ended */
-    msi_OnError, /* Call that was active ended */
+    msi_OnError, /* On protocol error */
     msi_OnPeerTimeout, /* Peer timed out; stop the call */
     msi_OnCapabilities, /* Peer requested capabilities change */
 } MSICallbackID;
@@ -90,6 +96,10 @@ typedef struct MSICall_s {
     
     uint32_t             friend_id;         /* Index of this call in MSISession */
     
+    MSIError             error;             /* Last error */
+    
+    void*                av_call;           /* Pointer to av call handler */
+    
     struct MSICall_s*    next;
     struct MSICall_s*    prev;
 } MSICall;
@@ -109,8 +119,8 @@ typedef struct MSISession_s {
     uint32_t        calls_tail;
     uint32_t        calls_head;
     
-    void           *agent_handler;
-    Messenger      *messenger_handle;
+    void           *av;
+    Messenger      *messenger;
 
     pthread_mutex_t mutex[1];
     MSICallbackType callbacks[8];
@@ -119,7 +129,7 @@ typedef struct MSISession_s {
 /**
  * Start the control session.
  */
-MSISession *msi_new ( Messenger *messenger, int32_t max_calls );
+MSISession *msi_new ( Messenger *messenger );
 
 /**
  * Terminate control session. NOTE: all calls will be freed
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 864d16cf..12a65737 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -49,8 +49,8 @@ typedef struct iToxAVCall
     RTPSession *rtps[2]; /** Audio is first and video is second */
     CSSession *cs;
     bool active;
-    int32_t friend_number;
-    int32_t call_idx; /* FIXME msi compat, remove */
+    int32_t friend_id;
+    MSICall* msi_call;
     
     struct iToxAVCall *prev;
     struct iToxAVCall *next;
@@ -80,21 +80,20 @@ struct toxAV
 };
 
 
-void i_toxav_msi_callback_invite(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_ringing(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_start(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_reject(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_end(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_request_to(void* toxav_inst, int32_t call_idx, void *data); /* TODO remove */
-void i_toxav_msi_callback_peer_to(void* toxav_inst, int32_t call_idx, void *data);
-void i_toxav_msi_callback_state_change(void* toxav_inst, int32_t call_idx, void *data);
+void i_callback_invite(void* toxav_inst, MSICall* call);
+void i_callback_ringing(void* toxav_inst, MSICall* call);
+void i_callback_start(void* toxav_inst, MSICall* call);
+void i_callback_end(void* toxav_inst, MSICall* call);
+void i_callback_error(void* toxav_inst, MSICall* call);
+void i_callback_capabilites(void* toxav_inst, MSICall* call);
 
+TOXAV_CALL_STATE capabilities_to_state(uint8_t capabilities);
 IToxAVCall* i_toxav_get_call(ToxAV* av, uint32_t friend_number);
 IToxAVCall* i_toxav_add_call(ToxAV* av, uint32_t friend_number);
 void i_toxav_remove_call(ToxAV* av, uint32_t friend_number);
+IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, TOXAV_ERR_CALL* error);
 bool i_toxav_audio_bitrate_invalid(uint32_t bitrate);
 bool i_toxav_video_bitrate_invalid(uint32_t bitrate);
-IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error);
 bool i_toxav_prepare_transmission(ToxAV* av, IToxAVCall* call);
 void i_toxav_kill_transmission(ToxAV* av, uint32_t friend_number);
 
@@ -124,7 +123,7 @@ ToxAV* toxav_new(Tox* tox, TOXAV_ERR_NEW* error)
     }
     
     av->m = (Messenger *)tox;
-    av->msi = msi_new(av->m, 100); /* TODO remove max calls */
+    av->msi = msi_new(av->m);
     
     if (av->msi == NULL) {
         rc = TOXAV_ERR_NEW_MALLOC;
@@ -132,17 +131,16 @@ ToxAV* toxav_new(Tox* tox, TOXAV_ERR_NEW* error)
     }
     
     av->interval = 200;
-    av->msi->agent_handler = av;
+    av->msi->av = av;
     
-    msi_register_callback(av->msi, i_toxav_msi_callback_invite, msi_OnInvite, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_ringing, msi_OnRinging, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_start, msi_OnStart, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_reject, msi_OnReject, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_end, msi_OnEnd, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_request_to, msi_OnRequestTimeout, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_peer_to, msi_OnPeerTimeout, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_state_change, msi_OnPeerCSChange, NULL);
-    msi_register_callback(av->msi, i_toxav_msi_callback_state_change, msi_OnSelfCSChange, NULL);
+    msi_register_callback(av->msi, i_callback_invite, msi_OnInvite);
+    msi_register_callback(av->msi, i_callback_ringing, msi_OnRinging);
+    msi_register_callback(av->msi, i_callback_start, msi_OnStart);
+    msi_register_callback(av->msi, i_callback_end, msi_OnReject);
+    msi_register_callback(av->msi, i_callback_end, msi_OnEnd);
+    msi_register_callback(av->msi, i_callback_error, msi_OnError);
+    msi_register_callback(av->msi, i_callback_error, msi_OnPeerTimeout);
+    msi_register_callback(av->msi, i_callback_capabilites, msi_OnCapabilities);
     
     
     if (error)
@@ -209,7 +207,7 @@ void toxav_iteration(ToxAV* av)
 
 bool toxav_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error)
 {
-    IToxAVCall* call = i_toxav_init_call(av, friend_number, audio_bit_rate, video_bit_rate, error);
+    IToxAVCall* call = i_toxav_init_call(av, friend_number, error);
     if (call == NULL) {
         return false;
     }
@@ -528,109 +526,87 @@ void toxav_callback_receive_audio_frame(ToxAV* av, toxav_receive_audio_frame_cb*
  *
  ******************************************************************************/
 /** TODO: 
- * - In msi call_idx can be the same as friend id 
- * - If crutial callback not present send error
- * - Remove *data from msi
- * - Remove CSettings from msi
+ * - If crutial callback not present send error.
+ * - Error handling by return values from callbacks and setting 'error'.
  */
-void i_toxav_msi_callback_invite(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_invite(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
     
-    uint32_t ab = toxav->msi->calls[call_idx]->csettings_peer[0].audio_bitrate;
-    uint32_t vb = toxav->msi->calls[call_idx]->csettings_peer[0].video_bitrate;
-    
-    IToxAVCall* call = i_toxav_init_call(toxav, toxav->msi->calls[call_idx]->peers[0], ab, vb, NULL);
-    if (call == NULL) {
-        LOGGER_WARNING("No call, rejecting...");
-        msi_reject(toxav->msi, call_idx, NULL);
+    IToxAVCall* av_call = i_toxav_init_call(toxav, call->friend_id, NULL);
+    if (av_call == NULL) {
+        LOGGER_WARNING("Failed to start call, rejecting...");
+        msi_reject(toxav->msi, call);
+        return;
     }
     
-    call->call_idx = call_idx;
+    call->av_call = av_call;
+    av_call->msi_call = call;
     
     if (toxav->ccb.first)
-        toxav->ccb.first(toxav, toxav->msi->calls[call_idx]->peers[0], true, true, toxav->ccb.second);
+        toxav->ccb.first(toxav, call->friend_id, call->peer_capabilities & msi_CapSAudio, 
+                         call->peer_capabilities & msi_CapSVideo, toxav->ccb.second);
 }
 
-void i_toxav_msi_callback_ringing(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_ringing(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
     if (toxav->scb.first)
-        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
-                         TOXAV_CALL_STATE_RINGING, toxav->scb.second);
+        toxav->scb.first(toxav, call->friend_id, TOXAV_CALL_STATE_RINGING, toxav->scb.second);
 }
 
-void i_toxav_msi_callback_start(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_start(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
     
-    IToxAVCall* call = i_toxav_get_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+    IToxAVCall* call = i_toxav_get_call(toxav, call->friend_id);
     
     if (call == NULL || !i_toxav_prepare_transmission(toxav, call)) {
         /* TODO send error */
-        i_toxav_remove_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+        i_toxav_remove_call(toxav, call->friend_id);
         return;
     }
     
-    TOXAV_CALL_STATE state;
-    const MSICSettings* csets = &toxav->msi->calls[call_idx]->csettings_peer[0];
-    
-    if (csets->audio_bitrate && csets->video_bitrate)
-        state = TOXAV_CALL_STATE_SENDING_AV;
-    else if (csets->video_bitrate == 0)
-        state = TOXAV_CALL_STATE_SENDING_A;
-    else
-        state = TOXAV_CALL_STATE_SENDING_V;
-    
-    if (toxav->scb.first) /* TODO this */
-        toxav->scb.first(toxav, call->friend_number, state, toxav->scb.second);
-}
-
-void i_toxav_msi_callback_reject(void* toxav_inst, int32_t call_idx, void* data)
-{
-    ToxAV* toxav = toxav_inst;
-    
-    i_toxav_kill_transmission(toxav, toxav->msi->calls[call_idx]->peers[0]);
-    i_toxav_remove_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+    TOXAV_CALL_STATE state = capabilities_to_state(call->msi_call->peer_capabilities);
     
     if (toxav->scb.first)
-        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
-                         TOXAV_CALL_STATE_END, toxav->scb.second);
+        toxav->scb.first(toxav, call->friend_id, state, toxav->scb.second);
 }
 
-void i_toxav_msi_callback_end(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_end(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
     
-    i_toxav_kill_transmission(toxav, toxav->msi->calls[call_idx]->peers[0]);
-    i_toxav_remove_call(toxav, toxav->msi->calls[call_idx]->peers[0]);
+    i_toxav_kill_transmission(toxav, call->friend_id);
+    i_toxav_remove_call(toxav, call->friend_id);
     
     if (toxav->scb.first)
-        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
-                         TOXAV_CALL_STATE_END, toxav->scb.second);
+        toxav->scb.first(toxav, call->friend_id, TOXAV_CALL_STATE_END, toxav->scb.second);
 }
 
-void i_toxav_msi_callback_request_to(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_error(void* toxav_inst, MSICall* call)
 {
-    /* TODO remove */
     ToxAV* toxav = toxav_inst;
     if (toxav->scb.first)
-        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
-                         TOXAV_CALL_STATE_ERROR, toxav->scb.second);
+        toxav->scb.first(toxav, call->friend_id, TOXAV_CALL_STATE_ERROR, toxav->scb.second);
 }
 
-void i_toxav_msi_callback_peer_to(void* toxav_inst, int32_t call_idx, void* data)
+void i_callback_capabilites(void* toxav_inst, MSICall* call)
 {
     ToxAV* toxav = toxav_inst;
-    if (toxav->scb.first)
-        toxav->scb.first(toxav, toxav->msi->calls[call_idx]->peers[0], 
-                         TOXAV_CALL_STATE_ERROR, toxav->scb.second);
+    /* TODO something something msi */
 }
 
-void i_toxav_msi_callback_state_change(void* toxav_inst, int32_t call_idx, void* data)
+TOXAV_CALL_STATE capabilities_to_state(uint8_t capabilities)
 {
-    ToxAV* toxav = toxav_inst;
-    /* TODO something something msi */
+    if ((capabilities & msi_CapSAudio) && (capabilities & msi_CapSVideo))
+        return TOXAV_CALL_STATE_SENDING_AV;
+    else if (capabilities & msi_CapSAudio)
+        return TOXAV_CALL_STATE_SENDING_A;
+    else if (capabilities & msi_CapSVideo)
+        return TOXAV_CALL_STATE_SENDING_V;
+    else
+        return TOXAV_CALL_STATE_PAUSED;
 }
 
 IToxAVCall* i_toxav_get_call(ToxAV* av, uint32_t friend_number)
@@ -648,7 +624,7 @@ IToxAVCall* i_toxav_add_call(ToxAV* av, uint32_t friend_number)
     if (rc == NULL)
         return NULL;
     
-    rc->friend_number = friend_number;
+    rc->friend_id = friend_number;
     
     if (create_recursive_mutex(rc->mutex_control) != 0) {
         free(rc);
@@ -724,13 +700,13 @@ void i_toxav_remove_call(ToxAV* av, uint32_t friend_number)
     if (prev)
         prev->next = next;
     else if (next)
-        av->calls_head = next->friend_number;
+        av->calls_head = next->friend_id;
     else goto CLEAR;
     
     if (next)
         next->prev = prev;
     else if (prev)
-        av->calls_tail = prev->friend_number;
+        av->calls_tail = prev->friend_id;
     else goto CLEAR;
     
     av->calls[friend_number] = NULL;
@@ -742,21 +718,7 @@ CLEAR:
     av->calls = NULL;
 }
 
-bool i_toxav_audio_bitrate_invalid(uint32_t bitrate)
-{
-    /* Opus RFC 6716 section-2.1.1 dictates the following:
-    * Opus supports all bitrates from 6 kbit/s to 510 kbit/s.
-    */
-    return bitrate < 6 || bitrate > 510;
-}
-
-bool i_toxav_video_bitrate_invalid(uint32_t bitrate)
-{
-    /* TODO: If anyone knows the answer to this one please fill it up */
-    return false;
-}
-
-IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate, TOXAV_ERR_CALL* error)
+IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, TOXAV_ERR_CALL* error)
 {
     TOXAV_ERR_CALL rc = TOXAV_ERR_CALL_OK;
     IToxAVCall* call = NULL;
@@ -776,25 +738,32 @@ IToxAVCall* i_toxav_init_call(ToxAV* av, uint32_t friend_number, uint32_t audio_
         goto END;
     }
     
-    if ((audio_bit_rate && i_toxav_audio_bitrate_invalid(audio_bit_rate))
-      ||(video_bit_rate && i_toxav_video_bitrate_invalid(video_bit_rate))
-    ) {
-        rc = TOXAV_ERR_CALL_INVALID_BIT_RATE;
-        goto END;
-    }
-    
     call = i_toxav_add_call(av, friend_number);
     if (call == NULL) {
         rc = TOXAV_ERR_CALL_MALLOC;
     }
     
-END:
+    END:
     if (error)
         *error = rc;
     
     return call;
 }
 
+bool i_toxav_audio_bitrate_invalid(uint32_t bitrate)
+{
+    /* Opus RFC 6716 section-2.1.1 dictates the following:
+    * Opus supports all bitrates from 6 kbit/s to 510 kbit/s.
+    */
+    return bitrate < 6 || bitrate > 510;
+}
+
+bool i_toxav_video_bitrate_invalid(uint32_t bitrate)
+{
+    /* TODO: If anyone knows the answer to this one please fill it up */
+    return false;
+}
+
 bool i_toxav_prepare_transmission(ToxAV* av, IToxAVCall* call)
 {
     pthread_mutex_lock(call->mutex_control);
@@ -838,7 +807,7 @@ bool i_toxav_prepare_transmission(ToxAV* av, IToxAVCall* call)
     memcpy(&call->cs->acb, &av->acb, sizeof(av->acb));
     memcpy(&call->cs->vcb, &av->vcb, sizeof(av->vcb));
     
-    call->cs->friend_number = call->friend_number;
+    call->cs->friend_number = call->friend_id;
     call->cs->call_idx = call->call_idx;
     
     
@@ -929,4 +898,4 @@ void i_toxav_kill_transmission(ToxAV* av, uint32_t friend_number)
     pthread_mutex_destroy(call->mutex_do);
     
     pthread_mutex_unlock(call->mutex_control);
-}
+}
\ No newline at end of file